test(cloudflare): Port the binding suites to span streaming (#24190)

Ports the binding suites off the `traceLifecycle: 'static'` pin: `d1`,
`r2`, `queue`, `prisma`, `durableobject/error`, `workflows/step-context`
and `vite/diagnostics-channel/vercelai-6`.

`durableobject/error` and `workflows/step-context` only assert on error
events, so the pin is all that goes. `cache-client` and
`durableobject-scope` were already unpinned and keep ignoring spans, so
they are untouched.

Most binding spans keep the shape they had and only the encoding
changes, so the r2 and queue suites keep one envelope expectation per
request. Two things do change.

D1 and Prisma spans carry the `db.query` op, so streaming names them
after `db.query.summary`: `SELECT * FROM users WHERE id = ?` becomes
`SELECT users`. The Prisma suite loses the description-based split
between its two `SELECT` spans, which now share the name `SELECT
main.User`. The D1 one is picked by its op instead, and the traceparent
comment that used to be matched on the description is asserted on
`db.query.text`.

`prisma` and `vercelai-6` switch to `collectStreamedSpansUntilSegment`.
Both assert on the complete child set of one request and the span buffer
flushes on a timer, so reading a single envelope would be a race.
`vercelai-6` also drops the separate span container it used to read next
to the transaction item: a streamed gen_ai span is an ordinary item of
the one span envelope.

`/` keeps its `GET /` name under streaming (the source is `route`, not
`url`), so `vercelai-6` waits on that rather than the bare method the
raw-URL suites see.

Part of #24148

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

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

Author: JPeer264

dev-packages/cloudflare-integration-tests/suites/cache-client/test.ts

@@ -110,7 +110,7 @@ it('cacheClient: true - detached work events ARE captured', async ({ signal }) =
 });
 
 it('cacheClient: false - repro #22545: detached work events are silently dropped', async ({ signal }) => {
-  const runner = createRunner(__dirname).ignore('transaction', 'span').start(signal);
+  const runner = createRunner(__dirname).ignore('span').start(signal);
 
   // Make the request that spawns detached work
   await runner.makeRequest('get', '/no-cache/detached?id=repro-1');
@@ -135,7 +135,7 @@ it('cacheClient: true - dedupe drops the same error across invocations', async (
   // A shared client shares its dedupe state, so the same error captured by two separate
   // invocations is reported only once — the second is dropped as a duplicate.
   const runner = createRunner(__dirname)
-    .ignore('transaction', 'span')
+    .ignore('span')
     .unordered()
     .failOnUnexpected()
     .expect(errorEventExpectation('Same error', CAPTURE_MECHANISM))
@@ -159,7 +159,7 @@ it('cacheClient: true - dedupe drops the same error across invocations', async (
 it('cacheClient: false - dedupe does not persist across invocations', async ({ signal }) => {
   // A fresh client per invocation means fresh dedupe state, so each invocation reports
   // the same error independently.
-  const runner = createRunner(__dirname).ignore('transaction', 'span').start(signal);
+  const runner = createRunner(__dirname).ignore('span').start(signal);
 
   for (let i = 0; i < 3; i++) {
     await runner.makeRequestAndWaitForEnvelope(
@@ -174,7 +174,7 @@ it('cacheClient: false - dedupe does not persist across invocations', async ({ s
 // also start reusing the isolation scope `setTag`/`setUser` write to. The uncached counterpart of
 // this test lives in the `durable-object-scope` suite.
 it('cacheClient: true - two consecutive invocations get different isolation scopes', async ({ signal }) => {
-  const runner = createRunner(__dirname).ignore('transaction', 'span').start(signal);
+  const runner = createRunner(__dirname).ignore('span').start(signal);
 
   await runner.makeRequestAndWaitForEnvelope('get', '/cache/scope?id=scope-shared&seed=1', (envelope: Envelope) => {
     const event = envelope[1]?.[0]?.[1] as Event;

dev-packages/cloudflare-integration-tests/suites/d1/index.ts

@@ -9,7 +9,6 @@ interface Env {
 export default Sentry.withSentry(
   (env: Env) => ({
     dsn: env.SENTRY_DSN,
-    traceLifecycle: 'static',
     tracesSampleRate: 1,
   }),
   {

dev-packages/cloudflare-integration-tests/suites/d1/test.ts

@@ -1,54 +1,37 @@
-import type { Envelope } from '@sentry/core';
+import type { Envelope, SerializedStreamedSpan } from '@sentry/core';
 import { expect, it } from 'vitest';
 import { createRunner } from '../../runner';
+import { getSpansFromEnvelope } from '../../spanUtils';
 
-function envelopeItemType(envelope: Envelope): string | undefined {
-  return envelope[1][0]?.[0]?.type as string | undefined;
-}
-
-function envelopeItem(envelope: Envelope): Record<string, unknown> {
-  return envelope[1][0]![1] as Record<string, unknown>;
-}
-
-function findD1Spans(envelope: Envelope): Array<Record<string, unknown>> {
-  if (envelopeItemType(envelope) !== 'transaction') return [];
-  const tx = envelopeItem(envelope);
-  const spans = (tx.spans as Array<Record<string, unknown>>) || [];
-  return spans.filter(s => (s.op as string) === 'db.query');
-}
+// `cloudflare.d1.duration` is only an integer when the query happens to take a whole number of
+// milliseconds, so the type can't be pinned down.
+const NUMBER_ATTRIBUTE = { type: expect.stringMatching(/^(?:integer|double)$/), value: expect.any(Number) };
 
 it('instruments D1 prepare().all() automatically via env', async ({ signal }) => {
   const runner = createRunner(__dirname)
     .ignore('event')
     .expect((envelope: Envelope) => {
-      expect(envelopeItemType(envelope)).toBe('transaction');
-      const d1Spans = findD1Spans(envelope);
-      expect(d1Spans.length).toBeGreaterThanOrEqual(1);
-
-      const querySpan = d1Spans.find(s => s.description === 'SELECT * FROM users WHERE id = ?');
-      expect(querySpan).toBeDefined();
-      expect(querySpan).toEqual({
-        data: {
-          'db.system.name': 'cloudflare-d1',
-          'db.operation.name': 'all',
-          'db.query.text': 'SELECT * FROM users WHERE id = ?',
-          'db.query.summary': 'SELECT users',
-          'cloudflare.d1.duration': expect.any(Number),
-          'cloudflare.d1.rows_read': expect.any(Number),
-          'cloudflare.d1.rows_written': expect.any(Number),
-          'sentry.op': 'db.query',
-          'sentry.origin': 'auto.db.cloudflare.d1',
-        },
-        description: 'SELECT * FROM users WHERE id = ?',
-        op: 'db.query',
-        origin: 'auto.db.cloudflare.d1',
-        status: 'ok',
-        parent_span_id: expect.any(String),
-        span_id: expect.any(String),
-        start_timestamp: expect.any(Number),
-        timestamp: expect.any(Number),
-        trace_id: expect.any(String),
-      });
+      const spans = getSpansFromEnvelope(envelope);
+      const segmentSpan = spans.find(span => span.is_segment);
+
+      // The D1 span is named after its query summary rather than the full query text.
+      const querySpan = spans.find(span => span.attributes['db.operation.name']?.value === 'all');
+      expect(querySpan?.name).toBe('SELECT users');
+      expect(querySpan?.parent_span_id).toBe(segmentSpan?.span_id);
+      expect(querySpan?.status).toBe('ok');
+      expect(querySpan?.attributes).toEqual(
+        expect.objectContaining({
+          'sentry.op': { type: 'string', value: 'db.query' },
+          'sentry.origin': { type: 'string', value: 'auto.db.cloudflare.d1' },
+          'db.system.name': { type: 'string', value: 'cloudflare-d1' },
+          'db.operation.name': { type: 'string', value: 'all' },
+          'db.query.text': { type: 'string', value: 'SELECT * FROM users WHERE id = ?' },
+          'db.query.summary': { type: 'string', value: 'SELECT users' },
+          'cloudflare.d1.duration': NUMBER_ATTRIBUTE,
+          'cloudflare.d1.rows_read': NUMBER_ATTRIBUTE,
+          'cloudflare.d1.rows_written': NUMBER_ATTRIBUTE,
+        }),
+      );
     })
     .start(signal);
 
@@ -58,10 +41,10 @@ it('instruments D1 prepare().all() automatically via env', async ({ signal }) =>
 
 it('captures error event when a D1 query references a non-existent table', async ({ signal }) => {
   const runner = createRunner(__dirname)
-    .ignore('transaction')
+    .ignore('span')
     .expect((envelope: Envelope) => {
-      expect(envelopeItemType(envelope)).toBe('event');
-      const event = envelopeItem(envelope);
+      expect(envelope[1][0]?.[0]?.type).toBe('event');
+      const event = envelope[1][0]![1] as Record<string, unknown>;
       expect(event.level).toBe('error');
 
       const values = (event.exception as { values: Array<Record<string, unknown>> })?.values;
@@ -102,32 +85,26 @@ it('instruments D1 exec() automatically via env', async ({ signal }) => {
   const runner = createRunner(__dirname)
     .ignore('event')
     .expect((envelope: Envelope) => {
-      expect(envelopeItemType(envelope)).toBe('transaction');
-      const d1Spans = findD1Spans(envelope);
-
-      const execSpan = d1Spans.find(
-        s => s.description === 'CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)',
+      const spans = getSpansFromEnvelope(envelope);
+      const segmentSpan = spans.find(span => span.is_segment);
+
+      const execSpan = spans.find(span => span.attributes['db.operation.name']?.value === 'exec');
+      expect(execSpan?.name).toBe('CREATE TABLE users');
+      expect(execSpan?.parent_span_id).toBe(segmentSpan?.span_id);
+      expect(execSpan?.status).toBe('ok');
+      expect(execSpan?.attributes).toEqual(
+        expect.objectContaining({
+          'sentry.op': { type: 'string', value: 'db.query' },
+          'sentry.origin': { type: 'string', value: 'auto.db.cloudflare.d1' },
+          'db.system.name': { type: 'string', value: 'cloudflare-d1' },
+          'db.operation.name': { type: 'string', value: 'exec' },
+          'db.query.text': {
+            type: 'string',
+            value: 'CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)',
+          },
+          'db.query.summary': { type: 'string', value: 'CREATE TABLE users' },
+        }),
       );
-      expect(execSpan).toBeDefined();
-      expect(execSpan).toEqual({
-        data: {
-          'db.system.name': 'cloudflare-d1',
-          'db.operation.name': 'exec',
-          'db.query.text': 'CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)',
-          'db.query.summary': 'CREATE TABLE users',
-          'sentry.op': 'db.query',
-          'sentry.origin': 'auto.db.cloudflare.d1',
-        },
-        description: 'CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)',
-        op: 'db.query',
-        origin: 'auto.db.cloudflare.d1',
-        status: 'ok',
-        parent_span_id: expect.any(String),
-        span_id: expect.any(String),
-        start_timestamp: expect.any(Number),
-        timestamp: expect.any(Number),
-        trace_id: expect.any(String),
-      });
     })
     .start(signal);
 
@@ -136,20 +113,30 @@ it('instruments D1 exec() automatically via env', async ({ signal }) => {
 });
 
 it('instruments D1 withSession().batch() identically to db.batch()', async ({ signal }) => {
-  let directBatchSpan: Record<string, unknown> | undefined;
-  let sessionBatchSpan: Record<string, unknown> | undefined;
+  let directBatchSpan: SerializedStreamedSpan | undefined;
+  let sessionBatchSpan: SerializedStreamedSpan | undefined;
 
   const runner = createRunner(__dirname)
     .ignore('event')
     .expect((envelope: Envelope) => {
-      expect(envelopeItem(envelope).transaction).toBe('GET /batch');
+      const spans = getSpansFromEnvelope(envelope);
+      // Both routes are raw URLs, so the streamed segment name keeps the method only and the
+      // request is identified through `url.path`.
+      expect(spans.find(span => span.is_segment)?.attributes['url.path']).toEqual({
+        type: 'string',
+        value: '/batch',
+      });
 
-      directBatchSpan = findD1Spans(envelope).find(s => s.description === 'D1 batch');
+      directBatchSpan = spans.find(span => span.name === 'D1 batch');
     })
     .expect((envelope: Envelope) => {
-      expect(envelopeItem(envelope).transaction).toBe('GET /with-session/batch');
+      const spans = getSpansFromEnvelope(envelope);
+      expect(spans.find(span => span.is_segment)?.attributes['url.path']).toEqual({
+        type: 'string',
+        value: '/with-session/batch',
+      });
 
-      sessionBatchSpan = findD1Spans(envelope).find(s => s.description === 'D1 batch');
+      sessionBatchSpan = spans.find(span => span.name === 'D1 batch');
     })
     .unordered()
     .start(signal);
@@ -161,16 +148,19 @@ it('instruments D1 withSession().batch() identically to db.batch()', async ({ si
   expect(directBatchSpan).toBeDefined();
   expect(sessionBatchSpan).toBeDefined();
 
-  const normalize = (span: Record<string, unknown>): Record<string, unknown> => {
+  // Ids and timestamps differ between the two requests, everything else must match.
+  const normalize = (span: SerializedStreamedSpan): Record<string, unknown> => {
     const {
       span_id: _spanId,
       parent_span_id: _parentSpanId,
       start_timestamp: _start,
-      timestamp: _end,
+      end_timestamp: _end,
       trace_id: _traceId,
+      attributes,
       ...rest
     } = span;
-    return rest;
+    const { 'sentry.segment.id': _segmentId, ...restAttributes } = attributes;
+    return { ...rest, attributes: restAttributes };
   };
 
   expect(normalize(sessionBatchSpan!)).toEqual(normalize(directBatchSpan!));
@@ -180,30 +170,25 @@ it('instruments D1 batch() automatically via env', async ({ signal }) => {
   const runner = createRunner(__dirname)
     .ignore('event')
     .expect((envelope: Envelope) => {
-      expect(envelopeItemType(envelope)).toBe('transaction');
-      const d1Spans = findD1Spans(envelope);
-
-      const batchSpan = d1Spans.find(s => s.description === 'D1 batch');
-      expect(batchSpan).toBeDefined();
-      expect(batchSpan).toEqual({
-        data: {
-          'db.system.name': 'cloudflare-d1',
-          'db.operation.name': 'batch',
-          'db.query.text': 'INSERT INTO users (name) VALUES (?)\nINSERT INTO users (name) VALUES (?)',
-          'db.operation.batch.size': 2,
-          'sentry.op': 'db.query',
-          'sentry.origin': 'auto.db.cloudflare.d1',
-        },
-        description: 'D1 batch',
-        op: 'db.query',
-        origin: 'auto.db.cloudflare.d1',
-        status: 'ok',
-        parent_span_id: expect.any(String),
-        span_id: expect.any(String),
-        start_timestamp: expect.any(Number),
-        timestamp: expect.any(Number),
-        trace_id: expect.any(String),
-      });
+      const spans = getSpansFromEnvelope(envelope);
+      const segmentSpan = spans.find(span => span.is_segment);
+
+      const batchSpan = spans.find(span => span.name === 'D1 batch');
+      expect(batchSpan?.parent_span_id).toBe(segmentSpan?.span_id);
+      expect(batchSpan?.status).toBe('ok');
+      expect(batchSpan?.attributes).toEqual(
+        expect.objectContaining({
+          'sentry.op': { type: 'string', value: 'db.query' },
+          'sentry.origin': { type: 'string', value: 'auto.db.cloudflare.d1' },
+          'db.system.name': { type: 'string', value: 'cloudflare-d1' },
+          'db.operation.name': { type: 'string', value: 'batch' },
+          'db.query.text': {
+            type: 'string',
+            value: 'INSERT INTO users (name) VALUES (?)\nINSERT INTO users (name) VALUES (?)',
+          },
+          'db.operation.batch.size': { type: 'integer', value: 2 },
+        }),
+      );
     })
     .start(signal);
 

dev-packages/cloudflare-integration-tests/suites/durableobject-scope/test.ts

@@ -3,7 +3,7 @@ import { expect, it } from 'vitest';
 import { createRunner } from '../../runner';
 
 it('two consecutive invocations get different isolation scopes', async ({ signal }) => {
-  const runner = createRunner(__dirname).ignore('transaction', 'span').start(signal);
+  const runner = createRunner(__dirname).ignore('span').start(signal);
 
   await runner.makeRequestAndWaitForEnvelope('get', '/scope?seed=1', (envelope: Envelope) => {
     const event = envelope[1]?.[0]?.[1] as Event;
@@ -23,7 +23,7 @@ it('two consecutive invocations get different isolation scopes', async ({ signal
 });
 
 it('a nested direct call within one invocation shares the same isolation scope', async ({ signal }) => {
-  const runner = createRunner(__dirname).ignore('transaction', 'span').start(signal);
+  const runner = createRunner(__dirname).ignore('span').start(signal);
 
   await runner.makeRequestAndWaitForEnvelope('get', '/nested', (envelope: Envelope) => {
     const event = envelope[1]?.[0]?.[1] as Event;
@@ -51,7 +51,7 @@ it('a nested direct call within one invocation shares the same isolation scope',
 });
 
 it('a nested call into another instrumented handler shares the same isolation scope', async ({ signal }) => {
-  const runner = createRunner(__dirname).ignore('transaction', 'span').start(signal);
+  const runner = createRunner(__dirname).ignore('span').start(signal);
 
   await runner.makeRequestAndWaitForEnvelope('get', '/reentrant', (envelope: Envelope) => {
     const event = envelope[1]?.[0]?.[1] as Event;

dev-packages/cloudflare-integration-tests/suites/durableobject/error/index.ts

@@ -19,7 +19,6 @@ class TestDurableObjectBase extends DurableObject<Env> {
 export const TestDurableObject = Sentry.instrumentDurableObjectWithSentry(
   (env: Env) => ({
     dsn: env.SENTRY_DSN,
-    traceLifecycle: 'static',
     tracesSampleRate: 1.0,
   }),
   TestDurableObjectBase,
@@ -28,7 +27,6 @@ export const TestDurableObject = Sentry.instrumentDurableObjectWithSentry(
 export default Sentry.withSentry(
   (env: Env) => ({
     dsn: env.SENTRY_DSN,
-    traceLifecycle: 'static',
     tracesSampleRate: 1.0,
   }),
   {

dev-packages/cloudflare-integration-tests/suites/prisma/index.ts

@@ -11,7 +11,6 @@ interface Env {
 export default Sentry.withSentry(
   (env: Env) => ({
     dsn: env.SENTRY_DSN,
-    traceLifecycle: 'static',
     tracesSampleRate: 1,
     integrations: [Sentry.prismaIntegration()],
   }),