fix(core): Write the resolved express route onto the root http.server span

Unlike the Node SDK, which renames the root span via `setHttpServerSpanRouteAttribute`, core's express
integration only set the isolation scope's transaction name. With span streaming that left routed
requests on Bun and Deno stuck with the method-only span name they start with.

Gated on span streaming so `static` mode names are unchanged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: chargome

dev-packages/node-integration-tests/suites/tracing/httpServerSpans-streamed-unrouted/test.ts

@@ -20,7 +20,7 @@ describe('httpServerSpans-streamed (no route)', () => {
             expect(serverSpan?.is_segment).toBe(true);
             // Without a route the name must not carry the URL path.
             expect(serverSpan?.name).toBe('GET');
-            expect(serverSpan?.attributes['sentry.source']).toEqual({ type: 'string', value: 'url' });
+            expect(serverSpan?.attributes['sentry.segment.name.source']).toEqual({ type: 'string', value: 'url' });
             // The path is still available as an attribute, which is what `ignoreSpans`/`tracesSampler` match on.
             expect(serverSpan?.attributes['url.path']).toEqual({ type: 'string', value: '/users/42' });
           },

packages/bun/test/integrations/bunHttpServer.test.ts

@@ -52,7 +52,9 @@ describe('Bun HTTP Server Integration', () => {
 
     expect(span).toBeDefined();
     expect(span?.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toBe('http.server');
-    expect(span?.name).toBe('GET /users');
+    // No router resolves a route here, so with span streaming the name is the request method.
+    expect(span?.name).toBe('GET');
+    expect(span?.attributes['url.path']).toBe('/users');
     expect(span?.attributes['sentry.origin']).toBe('auto.http.server');
   });
 
@@ -81,7 +83,8 @@ describe('Bun HTTP Server Integration', () => {
 
     expect(span).toBeDefined();
     expect(span?.attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP]).toBe('http.server');
-    expect(span?.name).toBe('QUERY /search');
+    expect(span?.name).toBe('QUERY');
+    expect(span?.attributes['url.path']).toBe('/search');
     expect(span?.attributes[HTTP_REQUEST_METHOD]).toBe('QUERY');
   });
 

packages/core/src/integrations/express/patch-layer.ts

@@ -27,7 +27,13 @@
  * limitations under the License.
  */
 
-import { SENTRY_OP } from '@sentry/conventions/attributes';
+import {
+  HTTP_METHOD,
+  HTTP_REQUEST_METHOD,
+  HTTP_ROUTE,
+  SENTRY_OP,
+  SENTRY_SEGMENT_NAME_SOURCE,
+} from '@sentry/conventions/attributes';
 import { MIDDLEWARE } from '@sentry/conventions/op';
 import { DEBUG_BUILD } from '../../debug-build';
 import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '../../semanticAttributes';
@@ -37,7 +43,7 @@ import { ROUTER_SPAN_NAME_FALLBACK } from '../../tracing/spans/spanNames';
 import { startSpanManual } from '../../tracing/trace';
 import { debug } from '../../utils/debug-logger';
 import type { SpanAttributes } from '../../types/span';
-import { getActiveSpan } from '../../utils/spanUtils';
+import { getActiveSpan, getRootSpan, spanToJSON } from '../../utils/spanUtils';
 import { getStoredLayers, storeLayer } from './request-layer-store';
 import {
   type ExpressRequest,
@@ -142,6 +148,13 @@ export function patchLayer(
       attributes[ATTR_HTTP_ROUTE] = actualMatchedRoute;
     }
 
+    // Propagate the route to the root `http.server` span before the ignore check, so the span is still
+    // named when the layer's own span is ignored. Runs for every layer that matched a route, not just
+    // request handlers: mounted middleware (`app.use('/trpc', ...)`) resolves a route too.
+    if (actualMatchedRoute) {
+      applyRouteToRootSpan(actualMatchedRoute);
+    }
+
     // verify against the config if the layer should be ignored
     if (isLayerIgnored(metadata.attributes[ATTR_EXPRESS_NAME], type, options)) {
       // XXX: the isLayerPathStored guard here is *not* present in the
@@ -289,3 +302,34 @@ export function patchLayer(
     value: layerHandlePatched,
   });
 }
+
+/**
+ * Write the resolved route onto the root `http.server` span.
+ *
+ * With span streaming the root span starts out named after the request method only, because no route
+ * is known at that point. Unlike the Node SDK — which goes through `setHttpServerSpanRouteAttribute` —
+ * nothing else on this path renames it, so a routed request would otherwise keep the method-only name.
+ */
+function applyRouteToRootSpan(route: string): void {
+  const client = getClient();
+  if (!client || !hasSpanStreamingEnabled(client)) {
+    return;
+  }
+
+  const activeSpan = getActiveSpan();
+  const rootSpan = activeSpan && getRootSpan(activeSpan);
+  if (!rootSpan) {
+    return;
+  }
+
+  const attributes = spanToJSON(rootSpan).attributes;
+  if (attributes[SENTRY_OP] !== 'http.server') {
+    return;
+  }
+
+  // eslint-disable-next-line typescript/no-deprecated
+  const method = attributes[HTTP_REQUEST_METHOD] || attributes[HTTP_METHOD] || 'GET';
+  rootSpan.updateName(`${method} ${route}`);
+  rootSpan.setAttribute(HTTP_ROUTE, route);
+  rootSpan.setAttribute(SENTRY_SEGMENT_NAME_SOURCE, 'route');
+}

packages/core/test/lib/integrations/express/patch-layer.test.ts

@@ -70,6 +70,7 @@ vi.mock('../../../../src/defaultScopes', () => ({
 
 const mockSpans: MockSpan[] = [];
 beforeEach(() => (mockSpans.length = 0));
+beforeEach(() => (transactionNames.length = 0));
 class MockSpan {
   ended = false;
   status: { code: number; message: string } = { code: 0, message: 'OK' };
@@ -131,12 +132,34 @@ const checkSpans = (expectations: Partial<MockSpanJSON>[]) => {
 };
 
 let hasActiveSpan = true;
-const parentSpan = {};
+// Stands in for the root `http.server` span so the route-to-root-span write can be asserted.
+const parentSpan = {
+  name: 'GET',
+  attributes: { 'sentry.op': 'http.server' } as Record<string, unknown>,
+  updateName(name: string) {
+    this.name = name;
+    return this;
+  },
+  setAttribute(key: string, value: unknown) {
+    this.attributes[key] = value;
+    return this;
+  },
+};
+beforeEach(() => {
+  parentSpan.name = 'GET';
+  parentSpan.attributes = { 'sentry.op': 'http.server' };
+});
 vi.mock('../../../../src/utils/spanUtils', async () => ({
   ...(await import('../../../../src/utils/spanUtils')),
   getActiveSpan() {
     return hasActiveSpan ? parentSpan : undefined;
   },
+  getRootSpan(span: unknown) {
+    return span;
+  },
+  spanToJSON(span: { attributes?: Record<string, unknown> }) {
+    return { attributes: span.attributes ?? {} };
+  },
 }));
 
 vi.mock('../../../../src/tracing', () => ({
@@ -367,6 +390,90 @@ describe('patchLayer', () => {
     checkSpans([]);
   });
 
+  it('writes the resolved route onto the root http.server span when span streaming is enabled', () => {
+    // Regression guard: with streaming the root span starts named `GET`, and nothing else on this
+    // path renames it — a routed request would otherwise keep the method-only name.
+    spanStreamingEnabled = true;
+
+    const req = Object.assign(new EventEmitter(), {
+      originalUrl: '/a/b/c/layerPath',
+      method: 'get',
+    }) as unknown as ExpressRequest;
+    const res = Object.assign(new EventEmitter(), {}) as unknown as ExpressResponse;
+    const layer = { name: 'handle', handle: vi.fn() } as unknown as ExpressLayer;
+
+    storeLayer(req, 'a');
+    storeLayer(req, '/:boo');
+
+    patchLayer(() => ({}), layer);
+    layer.handle(req, res);
+
+    expect(parentSpan.name).toBe('GET /a/:boo');
+    expect(parentSpan.attributes['http.route']).toBe('/a/:boo');
+    expect(parentSpan.attributes['sentry.segment.name.source']).toBe('route');
+  });
+
+  it('names the root route `GET /` rather than leaving the route empty', () => {
+    // `getConstructedRoute` skips `/`, so the root handler must take its route from the matched route.
+    spanStreamingEnabled = true;
+
+    const req = Object.assign(new EventEmitter(), {
+      originalUrl: '/',
+      method: 'get',
+    }) as unknown as ExpressRequest;
+    const res = Object.assign(new EventEmitter(), {}) as unknown as ExpressResponse;
+    const layer = { name: 'handle', handle: vi.fn() } as unknown as ExpressLayer;
+
+    storeLayer(req, '/');
+
+    patchLayer(() => ({}), layer);
+    layer.handle(req, res);
+
+    expect(parentSpan.name).toBe('GET /');
+    expect(parentSpan.attributes['http.route']).toBe('/');
+  });
+
+  it('applies the route from mounted middleware, not only from request handlers', () => {
+    // `app.use('/trpc', handler)` matches a route without being a request handler.
+    spanStreamingEnabled = true;
+
+    const req = Object.assign(new EventEmitter(), {
+      originalUrl: '/trpc/foo',
+      method: 'get',
+    }) as unknown as ExpressRequest;
+    const res = Object.assign(new EventEmitter(), {}) as unknown as ExpressResponse;
+    // A layer name other than `handle`/`bound dispatch`/`router` is treated as middleware.
+    const layer = { name: 'trpcMiddleware', handle: vi.fn() } as unknown as ExpressLayer;
+
+    storeLayer(req, '/trpc');
+
+    patchLayer(() => ({}), layer);
+    layer.handle(req, res);
+
+    expect(parentSpan.name).toBe('GET /trpc');
+    expect(parentSpan.attributes['http.route']).toBe('/trpc');
+  });
+
+  it('leaves the root span name alone without span streaming', () => {
+    spanStreamingEnabled = false;
+
+    const req = Object.assign(new EventEmitter(), {
+      originalUrl: '/a/b/c/layerPath',
+      method: 'get',
+    }) as unknown as ExpressRequest;
+    const res = Object.assign(new EventEmitter(), {}) as unknown as ExpressResponse;
+    const layer = { name: 'handle', handle: vi.fn() } as unknown as ExpressLayer;
+
+    storeLayer(req, 'a');
+    storeLayer(req, '/:boo');
+
+    patchLayer(() => ({}), layer);
+    layer.handle(req, res);
+
+    expect(parentSpan.name).toBe('GET');
+    expect(parentSpan.attributes['http.route']).toBeUndefined();
+  });
+
   it('sets tx name in isolation scope', async () => {
     DEBUG_BUILD = true;
     expect(