unstable_instrumentations middleware spans lack identity — no name or function reference

[kevinxh]

We understand this is an unstable API, so we're raising this more as feedback that we hope is useful in shaping the API as it matures.

What

When using the unstable_ServerInstrumentation API, the route.instrument({ middleware }) callback provides no way to identify which middleware is being instrumented. The callback receives handleMiddleware and { unstable_pattern }, but no middleware function name, index, or other distinguishing information.

This means all middleware spans in a trace end up identical — same name, same attributes — making them impossible to differentiate.

Reproduction

Given a route with multiple middleware:

export const unstable_middleware = [
  middlewareA,
  middlewareB,
  middlewareC,
  // ...
];

And instrumentation code:

export const platformInstrumentation: unstable_ServerInstrumentation = {
  route(route) {
    route.instrument({
      async middleware(handleMiddleware, { unstable_pattern }) {
        // No way to know which middleware this is
        tracer.startActiveSpan('middleware', {
          attributes: {
            'rr.route.id': route.id,
            'rr.route.pattern': unstable_pattern,
          }
        }, async (span) => {
          await handleMiddleware();
          span.end();
        });
      },
    });
  },
};

The resulting trace looks something like:

request (GET /)                           228ms
└── middleware (root, /)                   218ms
    └── middleware (root, /)               217ms
        └── middleware (root, /)           216ms
            └── middleware (root, /)       213ms
                └── middleware (root, /)   209ms
                    └── middleware (root, /)  127ms
                        ├── loader (root, /)           14ms
                        ├── loader (_app, /)           24ms
                        └── loader (_app._index, /)    23ms

Every middleware span is indistinguishable. There's no way to tell which function each span corresponds to.

Expected Behavior

It would be really helpful if the middleware callback received the middleware function name (e.g. derived from fn.name). This is probably what most developers would want to see in a trace.

This would enable instrumentation like:

async middleware(handleMiddleware, { unstable_pattern, name }) {
  tracer.startActiveSpan(`middleware ${name}`, { ... }, async (span) => {
    await handleMiddleware();
    span.end();
  });
}

Why This Matters

Middleware is often a significant contributor to request latency in server-rendered React Router apps. The deeply nested span structure means each outer middleware's duration includes all inner middleware + loaders. Without identification, it's hard to pinpoint which middleware is responsible for performance issues — which somewhat defeats the purpose of the instrumentation API.

[jellevwezel]

Why hasn’t this post gained more traction? Being able to identify which specific middleware is running seems like a pretty fundamental part of middleware instrumentation, especially when a route has multiple middleware functions. Without a name, index, or function reference, the instrumentation API feels incomplete. This seems like an important feature gap that may have been overlooked.

[jellevanwezel]

I created a PR for this: #15304

[jellevanwezel]

created an RFC: #15314