feat: Emit low-cardinality http.server span names in framework SDKs

Applies the same span-streaming gate to the runtime and framework SDKs so no integration keeps a raw
URL in an http.server span name. Requests that resolve to a route are unchanged.

Three sites differ from the rest and are worth a closer look: remix reads its own span name back,
sveltekit also renames SvelteKit's native root span, and nextjs renames in a `spanStart` hook because
Next.js — not the SDK — creates that span.

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

Author: chargome

dev-packages/e2e-tests/test-applications/deno-streamed/tests/spans.test.ts

@@ -113,7 +113,7 @@ const SEGMENT_SPAN = {
     },
     'sentry.segment.name': {
       type: 'string',
-      value: 'GET /test-sentry-span',
+      value: 'GET',
     },
     'sentry.segment.name.source': {
       type: 'string',
@@ -154,7 +154,7 @@ const SEGMENT_SPAN = {
   },
   end_timestamp: expect.any(Number),
   is_segment: true,
-  name: 'GET /test-sentry-span',
+  name: 'GET',
   span_id: expect.stringMatching(/^[\da-f]{16}$/),
   start_timestamp: expect.any(Number),
   status: 'ok',
@@ -200,7 +200,7 @@ test('Sends streamed spans (http.server and manual with Sentry.startSpan)', asyn
         },
         'sentry.segment.name': {
           type: 'string',
-          value: 'GET /test-sentry-span',
+          value: 'GET',
         },
       },
       end_timestamp: expect.any(Number),
@@ -230,10 +230,10 @@ test('OTel span appears as child of Sentry span (interop)', async ({ baseURL })
   const httpServerSpan = spans.find(span => getSpanOp(span) === 'http.server');
   expect(httpServerSpan).toEqual({
     ...SEGMENT_SPAN,
-    name: 'GET /test-interop',
+    name: 'GET',
     attributes: {
       ...SEGMENT_SPAN.attributes,
-      'sentry.segment.name': { type: 'string', value: 'GET /test-interop' },
+      'sentry.segment.name': { type: 'string', value: 'GET' },
       'url.full': { type: 'string', value: expect.stringMatching(/^http:\/\/localhost:\d+\/test-interop$/) },
       'url.path': { type: 'string', value: '/test-interop' },
     },
@@ -272,7 +272,7 @@ test('OTel span appears as child of Sentry span (interop)', async ({ baseURL })
       },
       'sentry.segment.name': {
         type: 'string',
-        value: 'GET /test-interop',
+        value: 'GET',
       },
     },
     end_timestamp: expect.any(Number),
@@ -313,7 +313,7 @@ test('OTel span appears as child of Sentry span (interop)', async ({ baseURL })
       },
       'sentry.segment.name': {
         type: 'string',
-        value: 'GET /test-interop',
+        value: 'GET',
       },
       'sentry.deno_tracer': {
         type: 'boolean',

packages/astro/src/server/middleware.ts

@@ -16,6 +16,8 @@ import {
   getRootSpan,
   getUrlFragment,
   getUrlQuery,
+  hasSpanStreamingEnabled,
+  HTTP_SPAN_NAME_FALLBACK,
   objectify,
   SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD,
   spanToJSON,
@@ -235,9 +237,16 @@ async function instrumentRequestStartHttpServerSpan(
           attributes[URL_QUERY] = filterCollectedUrlQuery(getUrlQuery(ctx.url.search));
           attributes[URL_FRAGMENT] = getUrlFragment(ctx.url.hash);
 
-          const name = `${method} ${parametrizedRoute || ctx.url.pathname}`;
+          const transactionName = `${method} ${parametrizedRoute || ctx.url.pathname}`;
 
-          isolationScope.setTransactionName(name);
+          // The scope's transaction name is what error events are grouped by, so it keeps the URL path.
+          isolationScope.setTransactionName(transactionName);
+
+          // With span streaming, span names have to be low cardinality, so we can't fall back to the URL path.
+          const name =
+            parametrizedRoute || !hasSpanStreamingEnabled(client)
+              ? transactionName
+              : method?.toUpperCase() || HTTP_SPAN_NAME_FALLBACK;
 
           const res = await startSpan(
             {

packages/astro/test/server/middleware.test.ts

@@ -3,6 +3,7 @@ import type { Client, Span } from '@sentry/core';
 
 import * as SentryCore from '@sentry/core';
 import * as SentryNode from '@sentry/node';
+import type { APIContext } from 'astro';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { handleRequest, interpolateRouteFromUrlAndParams } from '../../src/server/middleware';
 
@@ -133,6 +134,70 @@ describe('sentryMiddleware', () => {
     expect(resultFromNext).toStrictEqual(nextResult);
   });
 
+  describe('with span streaming enabled', () => {
+    // A full `APIContext` is much larger than these tests need, so build a partial one behind a typed
+    // helper rather than suppressing the type error at each call site.
+    function mockApiContext(override: Record<string, unknown>): APIContext {
+      return { ...DYNAMIC_REQUEST_CONTEXT, ...override } as unknown as APIContext;
+    }
+
+    beforeEach(() => {
+      vi.spyOn(SentryNode, 'getClient').mockImplementation(
+        () =>
+          ({
+            getOptions: () => ({ traceLifecycle: 'stream' }),
+            getDataCollectionOptions: () => ({
+              userInfo: false,
+              cookies: true,
+              httpHeaders: { request: true, response: true },
+              httpBodies: [],
+              urlQueryParams: true,
+              graphQL: { document: true, variables: true },
+              genAI: { inputs: true, outputs: true },
+              databaseQueryData: true,
+              stackFrameVariables: true,
+              frameContextLines: 5,
+            }),
+          }) as unknown as Client,
+      );
+    });
+
+    it('names an unparameterized span after the request method', async () => {
+      const middleware = handleRequest();
+      const ctx = mockApiContext({
+        request: { method: 'GET', url: '/a%xx', headers: new Headers() },
+        url: { pathname: 'a%xx', href: 'http://localhost:1234/a%xx' },
+        params: {},
+      });
+
+      await middleware(
+        ctx,
+        vi.fn(() => nextResult),
+      );
+
+      expect(startSpanSpy).toHaveBeenCalledWith(expect.objectContaining({ name: 'GET' }), expect.any(Function));
+    });
+
+    it('keeps the parameterized route as the span name', async () => {
+      const middleware = handleRequest();
+      const ctx = mockApiContext({
+        request: { method: 'GET', url: '/users/123/details', headers: new Headers() },
+        params: { id: '123' },
+        url: new URL('https://myDomain.io/users/123/details'),
+      });
+
+      await middleware(
+        ctx,
+        vi.fn(() => nextResult),
+      );
+
+      expect(startSpanSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ name: 'GET /users/[id]/details' }),
+        expect.any(Function),
+      );
+    });
+  });
+
   it("sets source route if the url couldn't be decoded correctly", async () => {
     const middleware = handleRequest();
     const ctx = {

packages/bun/src/integrations/bunserver.ts

@@ -6,7 +6,9 @@ import {
   getClient,
   getUrlFragment,
   getUrlQuery,
+  hasSpanStreamingEnabled,
   httpHeadersToSpanAttributes,
+  HTTP_SPAN_NAME_FALLBACK,
   isURLObjectRelative,
   parseStringToURLObject,
   SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD,
@@ -246,7 +248,11 @@ function wrapRequestHandler<T extends RouteHandler = RouteHandler>(
           {
             attributes,
             op: 'http.server',
-            name: `${request.method} ${routeName}`,
+            // With span streaming, span names have to be low cardinality, so we can't fall back to the URL path.
+            name:
+              attributes[SENTRY_SEGMENT_NAME_SOURCE] === 'route' || !client || !hasSpanStreamingEnabled(client)
+                ? `${request.method} ${routeName}`
+                : request.method?.toUpperCase() || HTTP_SPAN_NAME_FALLBACK,
           },
           async span => {
             try {

packages/bun/test/integrations/bunserver.test.ts

@@ -75,7 +75,7 @@ describe('Bun Serve Integration', () => {
           'http.request.header.user_agent': expect.stringContaining('Bun'),
         }),
         op: 'http.server',
-        name: 'GET /users',
+        name: 'GET',
       },
       expect.any(Function),
     );
@@ -119,7 +119,7 @@ describe('Bun Serve Integration', () => {
           'http.request.header.user_agent': expect.stringContaining('Bun'),
         }),
         op: 'http.server',
-        name: 'POST /',
+        name: 'POST',
       },
       expect.any(Function),
     );
@@ -148,7 +148,7 @@ describe('Bun Serve Integration', () => {
           'http.request.method': 'QUERY',
         }),
         op: 'http.server',
-        name: 'QUERY /search',
+        name: 'QUERY',
       }),
       expect.any(Function),
     );
@@ -243,7 +243,7 @@ describe('Bun Serve Integration', () => {
           'http.request.header.sentry_trace': expect.any(String),
         }),
         op: 'http.server',
-        name: 'POST /api/test',
+        name: 'POST',
       }),
       expect.any(Function),
     );

packages/cloudflare/src/wrapRequestHandlerWithInit.ts

@@ -1,10 +1,16 @@
 import type { CfProperties, IncomingRequestCfProperties } from '@cloudflare/workers-types';
-import { NETWORK_PROTOCOL_NAME, NETWORK_PROTOCOL_VERSION } from '@sentry/conventions/attributes';
+import {
+  NETWORK_PROTOCOL_NAME,
+  NETWORK_PROTOCOL_VERSION,
+  SENTRY_SEGMENT_NAME_SOURCE,
+} from '@sentry/conventions/attributes';
 import {
   captureException,
   continueTrace,
   getHttpSpanDetailsFromUrlObject,
+  hasSpanStreamingEnabled,
   httpHeadersToSpanAttributes,
+  HTTP_SPAN_NAME_FALLBACK,
   parseStringToURLObject,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   setHttpStatus,
@@ -76,14 +82,20 @@ export function wrapRequestHandlerWithInit(
     isolationScope.setClient(client);
 
     const urlObject = parseStringToURLObject(request.url);
-    const [name, attributes] = getHttpSpanDetailsFromUrlObject(
+    const [rawName, attributes] = getHttpSpanDetailsFromUrlObject(
       urlObject,
       'server',
       'auto.http.cloudflare',
       request,
       undefined,
       client,
     );
+    // With span streaming, span names have to be low cardinality, so we can't fall back to the URL.
+    // A `route` source means the name already is (e.g. the `/` path), so it is kept as-is.
+    const name =
+      attributes[SENTRY_SEGMENT_NAME_SOURCE] === 'route' || !client || !hasSpanStreamingEnabled(client)
+        ? rawName
+        : request.method?.toUpperCase() || HTTP_SPAN_NAME_FALLBACK;
 
     const contentLength = request.headers.get('content-length');
     if (contentLength) {

packages/cloudflare/test/request.test.ts

@@ -33,6 +33,36 @@ describe('withSentry', () => {
     vi.clearAllMocks();
   });
 
+  describe('with span streaming enabled', () => {
+    async function segmentSpanNameFor(url: string): Promise<string | undefined> {
+      let spanName: string | undefined;
+
+      await wrapRequestHandler(
+        {
+          options: { ...MOCK_OPTIONS, traceLifecycle: 'stream', tracesSampleRate: 1 },
+          request: new Request(url),
+          context: createMockExecutionContext(),
+        },
+        () => {
+          // Read the name while the request is in flight: the gate applies at span start.
+          const activeSpan = SentryCore.getActiveSpan();
+          spanName = activeSpan ? SentryCore.spanToJSON(SentryCore.getRootSpan(activeSpan)).name : undefined;
+          return new Response('test');
+        },
+      );
+
+      return spanName;
+    }
+
+    test('names a span without a resolvable route after the request method', async () => {
+      expect(await segmentSpanNameFor('https://example.com/users/42')).toBe('GET');
+    });
+
+    test('keeps the root path, which is already low cardinality', async () => {
+      expect(await segmentSpanNameFor('https://example.com/')).toBe('GET /');
+    });
+  });
+
   test('passes through the response from the handler', async () => {
     const response = new Response('test');
     const result = await wrapRequestHandler(

packages/deno/src/wrap-deno-request-handler.ts

@@ -1,12 +1,19 @@
-import { CLIENT_ADDRESS, CLIENT_PORT, NETWORK_PROTOCOL_NAME } from '@sentry/conventions/attributes';
+import {
+  CLIENT_ADDRESS,
+  CLIENT_PORT,
+  NETWORK_PROTOCOL_NAME,
+  SENTRY_SEGMENT_NAME_SOURCE,
+} from '@sentry/conventions/attributes';
 import type { Integration, MaxRequestBodySize } from '@sentry/core';
 import {
   captureBodyFromWinterCGRequest,
   captureException,
   continueTrace,
   getClient,
   getHttpSpanDetailsFromUrlObject,
+  hasSpanStreamingEnabled,
   httpHeadersToSpanAttributes,
+  HTTP_SPAN_NAME_FALLBACK,
   parseStringToURLObject,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   setHttpStatus,
@@ -60,14 +67,20 @@ export const wrapDenoRequestHandler = <Addr extends Deno.Addr = Deno.Addr>(
     }
 
     const urlObject = parseStringToURLObject(request.url);
-    const [name, attributes] = getHttpSpanDetailsFromUrlObject(
+    const [rawName, attributes] = getHttpSpanDetailsFromUrlObject(
       urlObject,
       'server',
       'auto.http.deno',
       request,
       undefined,
       client,
     );
+    // With span streaming, span names have to be low cardinality, so we can't fall back to the URL.
+    // A `route` source means the name already is (e.g. the `/` path), so it is kept as-is.
+    const name =
+      attributes[SENTRY_SEGMENT_NAME_SOURCE] === 'route' || !hasSpanStreamingEnabled(client)
+        ? rawName
+        : request.method?.toUpperCase() || HTTP_SPAN_NAME_FALLBACK;
 
     const contentLength = request.headers.get('content-length');
     assignIfSet(attributes, 'http.request.body.size', contentLength && parseInt(contentLength, 10));

packages/elysia/src/withElysia.ts

@@ -5,6 +5,7 @@ import {
   captureException,
   continueTrace,
   getActiveSpan,
+  getClient,
   getIsolationScope,
   getRootSpan,
   getTraceData,
@@ -17,6 +18,8 @@ import {
   winterCGRequestToRequestData,
   withIsolationScope,
   filterCollectedUrl,
+  hasSpanStreamingEnabled,
+  HTTP_SPAN_NAME_FALLBACK,
 } from '@sentry/core';
 import type { AnyElysia, Elysia, ErrorContext, TraceHandler, TraceListener } from 'elysia';
 
@@ -200,10 +203,16 @@ export function withElysia<T extends AnyElysia>(app: T, options: ElysiaHandlerOp
               baggage: request.headers.get('baggage'),
             },
             () => {
+              const client = getClient();
               return startSpanManual(
                 {
                   op: 'http.server',
-                  name: `${request.method} ${new URL(request.url).pathname}`,
+                  // With span streaming, span names have to be low cardinality, so we can't fall back to the
+                  // URL path. `updateRouteTransactionName` renames the span once Elysia resolves the route.
+                  name:
+                    client && hasSpanStreamingEnabled(client)
+                      ? request.method?.toUpperCase() || HTTP_SPAN_NAME_FALLBACK
+                      : `${request.method} ${new URL(request.url).pathname}`,
                   attributes: {
                     [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ELYSIA_ORIGIN,
                     [SENTRY_SEGMENT_NAME_SOURCE]: 'url',