test(cloudflare): Port the request handler suites to span streaming

Removes the `traceLifecycle: 'static'` pin from `suites/hono-sdk`,
`suites/double-instrumentation` and `suites/public-api/metrics/server-address`,
and rewrites the Hono transaction assertions to span v2.

`double-instrumentation` and the metrics suite assert on an error event and on a
metric envelope, so only the pin goes. `double-instrumentation` swaps its
`ignore('transaction')` for `ignore('span')`, which is the envelope the
`http.server` span now races the error event with.

The Hono routes are parametrized patterns, so their segment names survive
streaming unchanged. What does change is the status: span v2 carries the coarse
`error` on the span and the specific `internal_error` in the
`sentry.status.message` attribute.

`suites/basic` keeps the static pin as the package's guard for the static trace
lifecycle. It is the smallest suite that still covers a plain worker fetch.

`suites/request-handler/subpath` also stays pinned, but for a different reason:
`wrapRequestHandler` from `@sentry/cloudflare/request` still sends a transaction
envelope with the pin removed, even with `traceLifecycle: 'stream'` passed
explicitly and with `cacheClient: false`. The client it builds does carry the
`SpanStreaming` integration, so the span reaches the isolation scope's client but
`getClient()` in `_onSpanEnded` does not see a streaming client. That is an SDK
question rather than a test one, so the suite is left as it was and gets its own
issue.

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

Author: JPeer264

dev-packages/cloudflare-integration-tests/suites/double-instrumentation/index.ts

@@ -17,5 +17,5 @@ const handler = {
 // This simulates scenarios where the module is re-evaluated or the handler
 // is wrapped multiple times. The SDK should handle this gracefully
 // without double-wrapping (which would cause duplicate error reports).
-const once = Sentry.withSentry((env: Env) => ({ dsn: env.SENTRY_DSN, traceLifecycle: 'static' }), handler);
-export default Sentry.withSentry((env: Env) => ({ dsn: env.SENTRY_DSN, traceLifecycle: 'static' }), once);
+const once = Sentry.withSentry((env: Env) => ({ dsn: env.SENTRY_DSN }), handler);
+export default Sentry.withSentry((env: Env) => ({ dsn: env.SENTRY_DSN }), once);

dev-packages/cloudflare-integration-tests/suites/double-instrumentation/test.ts

@@ -31,10 +31,9 @@ it('Only sends one error event when withSentry is called twice', async ({ signal
         { includeTransaction: false },
       ),
     )
-    // The http.server span produces a transaction envelope that is sent in parallel with the
-    // error event. Either can arrive first at the mock server, so ignore it here to keep the
-    // assertion focused on the error event.
-    .ignore('transaction')
+    // The http.server span is streamed in parallel with the error event. Either can arrive first
+    // at the mock server, so ignore it here to keep the assertion focused on the error event.
+    .ignore('span')
     .start(signal);
   await runner.makeRequest('get', '/error', { expectError: true });
   await runner.completed();

dev-packages/cloudflare-integration-tests/suites/hono-sdk/index.ts

@@ -10,7 +10,6 @@ const app = new Hono<{ Bindings: Env }>();
 app.use(
   sentry(app, {
     dsn: process.env.SENTRY_DSN,
-    traceLifecycle: 'static',
     tracesSampleRate: 1.0,
   }),
 );

dev-packages/cloudflare-integration-tests/suites/hono-sdk/test.ts

@@ -1,6 +1,7 @@
 import { expect, it } from 'vitest';
-import { eventEnvelope, SHORT_UUID_MATCHER, UUID_MATCHER } from '../../expect';
+import { eventEnvelope } from '../../expect';
 import { createRunner } from '../../runner';
+import { getSpanOp, getSpansFromEnvelope } from '../../spanUtils';
 
 it('Hono app captures parametrized errors (Hono SDK)', async ({ signal }) => {
   const runner = createRunner(__dirname)
@@ -43,43 +44,23 @@ it('Hono app captures parametrized errors (Hono SDK)', async ({ signal }) => {
         { includeSamplingFields: true, includeSampleRand: true, sdk: 'hono' },
       ),
     )
-
     .expect(envelope => {
-      const [, envelopeItems] = envelope;
-      const [itemHeader, itemPayload] = envelopeItems[0];
-
-      expect(itemHeader.type).toBe('transaction');
+      const segmentSpan = getSpansFromEnvelope(envelope).find(span => span.is_segment);
 
-      expect(itemPayload).toMatchObject({
-        type: 'transaction',
-        platform: 'javascript',
-        transaction: 'GET /error/:param',
-        contexts: {
-          trace: {
-            span_id: expect.any(String),
-            trace_id: expect.any(String),
-            op: 'http.server',
-            status: 'internal_error',
-            origin: 'auto.http.cloudflare',
-          },
-        },
-        request: expect.objectContaining({
-          method: 'GET',
-          url: expect.stringContaining('/error/param-123'),
+      // The Hono route is a parametrized pattern, so the streamed segment keeps the full name.
+      expect(segmentSpan?.name).toBe('GET /error/:param');
+      // Span v2 keeps the coarse `error` status on the span and the specific one as an attribute.
+      expect(segmentSpan?.status).toBe('error');
+      expect(getSpanOp(segmentSpan!)).toBe('http.server');
+      expect(segmentSpan?.attributes).toEqual(
+        expect.objectContaining({
+          'sentry.status.message': { type: 'string', value: 'internal_error' },
+          'sentry.origin': { type: 'string', value: 'auto.http.cloudflare' },
+          'sentry.segment.name.source': { type: 'string', value: 'route' },
+          'http.request.method': { type: 'string', value: 'GET' },
+          'url.path': { type: 'string', value: '/error/param-123' },
         }),
-        breadcrumbs: [
-          {
-            timestamp: expect.any(Number),
-            category: 'console',
-            level: 'error',
-            message: 'Error: Test error from Hono app',
-            data: expect.objectContaining({
-              logger: 'console',
-              arguments: [{ message: 'Test error from Hono app', name: 'Error', stack: expect.any(String) }],
-            }),
-          },
-        ],
-      });
+      );
     })
     .unordered()
     .start(signal);
@@ -91,31 +72,20 @@ it('Hono app captures parametrized errors (Hono SDK)', async ({ signal }) => {
 it('Hono app captures parametrized names', async ({ signal }) => {
   const runner = createRunner(__dirname)
     .expect(envelope => {
-      const [, envelopeItems] = envelope;
-      const [itemHeader, itemPayload] = envelopeItems[0];
+      const segmentSpan = getSpansFromEnvelope(envelope).find(span => span.is_segment);
 
-      expect(itemHeader.type).toBe('transaction');
-
-      expect(itemPayload).toMatchObject({
-        type: 'transaction',
-        platform: 'javascript',
-        transaction: 'GET /hello/:name',
-        contexts: {
-          trace: {
-            span_id: SHORT_UUID_MATCHER,
-            trace_id: UUID_MATCHER,
-            op: 'http.server',
-            status: 'ok',
-            origin: 'auto.http.cloudflare',
-          },
-        },
-        request: expect.objectContaining({
-          method: 'GET',
-          url: expect.stringContaining('/hello/:name'),
+      expect(segmentSpan?.name).toBe('GET /hello/:name');
+      expect(segmentSpan?.status).toBe('ok');
+      expect(getSpanOp(segmentSpan!)).toBe('http.server');
+      expect(segmentSpan?.attributes).toEqual(
+        expect.objectContaining({
+          'sentry.origin': { type: 'string', value: 'auto.http.cloudflare' },
+          'sentry.segment.name.source': { type: 'string', value: 'route' },
+          'http.request.method': { type: 'string', value: 'GET' },
+          'url.path': { type: 'string', value: '/hello/:name' },
         }),
-      });
+      );
     })
-
     .unordered()
     .start(signal);
 

dev-packages/cloudflare-integration-tests/suites/public-api/metrics/server-address/index.ts

@@ -7,7 +7,6 @@ interface Env {
 export default Sentry.withSentry(
   (env: Env) => ({
     dsn: env.SENTRY_DSN,
-    traceLifecycle: 'static',
     release: '1.0.0',
     environment: 'test',
     serverName: 'mi-servidor.com',