Merge branch 'develop' into fix/vercel-keepalive-repeated-init

Author: chargome

dev-packages/cloudflare-integration-tests/suites/tracing/propagation/worker-do-rpc-overlapping/instrument.server.ts

@@ -2,6 +2,5 @@ import { defineCloudflareOptions } from '@sentry/cloudflare';
 
 export default defineCloudflareOptions((env: { SENTRY_DSN: string }) => ({
   dsn: env.SENTRY_DSN,
-  traceLifecycle: 'static',
   tracesSampleRate: 1.0,
 }));

dev-packages/cloudflare-integration-tests/suites/tracing/propagation/worker-do-rpc-overlapping/test.ts

@@ -1,49 +1,35 @@
-import type { TransactionEvent } from '@sentry/core';
 import { expect, it } from 'vitest';
 import { createRunner } from '../../../../runner';
+import { getSpanOp } from '../../../../spanUtils';
 
 it('propagates the worker trace into each of two overlapping Durable Object RPC calls', async ({ signal }) => {
-  const doTraces: Record<string, TransactionEvent['contexts']> = {};
-  let workerTraceId: string | undefined;
-  let workerSpanId: string | undefined;
-
-  const runner = createRunner(__dirname)
-    .unordered()
-    .expect(envelope => {
-      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
-      expect(transactionEvent.transaction).toBe('work');
-      expect(transactionEvent.contexts?.trace?.op).toBe('rpc');
-      expect(transactionEvent.contexts?.trace?.data?.['test.label']).toBe('a');
-      doTraces.a = transactionEvent.contexts;
-    })
-    .expect(envelope => {
-      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
-      expect(transactionEvent.transaction).toBe('work');
-      expect(transactionEvent.contexts?.trace?.op).toBe('rpc');
-      expect(transactionEvent.contexts?.trace?.data?.['test.label']).toBe('b');
-      doTraces.b = transactionEvent.contexts;
-    })
-    .expect(envelope => {
-      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
-      expect(transactionEvent.transaction).toBe('GET /overlapping');
-      expect(transactionEvent.contexts?.trace?.op).toBe('http.server');
-      workerTraceId = transactionEvent.contexts?.trace?.trace_id;
-      workerSpanId = transactionEvent.contexts?.trace?.span_id;
-    })
-    .start(signal);
+  const runner = createRunner(__dirname).start(signal);
+
+  // The worker and the Durable Object stream from separate isolates, and both RPC segments come from
+  // the same Durable Object, so they can share an envelope.
+  const spansPromise = runner.collectStreamedSpans(
+    spansOfTrace => spansOfTrace.filter(span => span.is_segment).length === 3,
+  );
 
   const response = await runner.makeRequest<string>('get', '/overlapping');
   expect(response).toBe('a,b');
 
-  await runner.completed();
+  const segmentSpans = (await spansPromise).filter(span => span.is_segment);
+  const workerSpan = segmentSpans.find(span => getSpanOp(span) === 'http.server');
+  const rpcSpanA = segmentSpans.find(span => span.attributes['test.label']?.value === 'a');
+  const rpcSpanB = segmentSpans.find(span => span.attributes['test.label']?.value === 'b');
+
+  // `/overlapping` is a raw URL, so the streamed segment name keeps the method only.
+  expect(workerSpan?.name).toBe('GET');
+  expect(workerSpan?.attributes['url.path']).toEqual({ type: 'string', value: '/overlapping' });
 
-  expect(workerTraceId).toMatch(/^[\da-f]{32}$/);
-  expect(workerSpanId).toMatch(/^[\da-f]{16}$/);
+  expect(rpcSpanA?.name).toBe('work');
+  expect(getSpanOp(rpcSpanA!)).toBe('rpc');
+  expect(rpcSpanA?.parent_span_id).toBe(workerSpan?.span_id);
 
-  expect(doTraces.a?.trace?.trace_id).toBe(workerTraceId);
-  expect(doTraces.a?.trace?.parent_span_id).toBe(workerSpanId);
-  expect(doTraces.b?.trace?.trace_id).toBe(workerTraceId);
-  expect(doTraces.b?.trace?.parent_span_id).toBe(workerSpanId);
+  expect(rpcSpanB?.name).toBe('work');
+  expect(getSpanOp(rpcSpanB!)).toBe('rpc');
+  expect(rpcSpanB?.parent_span_id).toBe(workerSpan?.span_id);
 
-  expect(doTraces.a?.trace?.span_id).not.toBe(doTraces.b?.trace?.span_id);
+  expect(rpcSpanA?.span_id).not.toBe(rpcSpanB?.span_id);
 });

dev-packages/cloudflare-integration-tests/suites/vite-autoinstrument/workerentrypoint-reexport-instrumented/greeter.ts

@@ -14,6 +14,6 @@ class GreeterImpl extends WorkerEntrypoint<Env> {
 // Manually instrumented here, in a module separate from the worker entry, which
 // only imports and re-exports the wrapped class.
 export const GreeterEntrypoint = Sentry.withSentry(
-  (env: Env) => ({ dsn: env.SENTRY_DSN, traceLifecycle: 'static', tracesSampleRate: 1.0 }),
+  (env: Env) => ({ dsn: env.SENTRY_DSN, tracesSampleRate: 1.0 }),
   GreeterImpl,
 );

dev-packages/cloudflare-integration-tests/suites/vite-autoinstrument/workerentrypoint-reexport-instrumented/instrument.server.ts

@@ -2,6 +2,5 @@ import { defineCloudflareOptions } from '@sentry/cloudflare';
 
 export default defineCloudflareOptions((env: { SENTRY_DSN: string }) => ({
   dsn: env.SENTRY_DSN,
-  traceLifecycle: 'static',
   tracesSampleRate: 1.0,
 }));

dev-packages/cloudflare-integration-tests/suites/vite-autoinstrument/workerentrypoint-reexport-instrumented/test.ts

@@ -1,30 +1,38 @@
-import type { TransactionEvent } from '@sentry/core';
 import { expect, it } from 'vitest';
 import { createRunner } from '../../../runner';
+import { getSpanOp } from '../../../spanUtils';
 
 // `GreeterEntrypoint` is hand-wrapped in `./greeter` and only re-exported by
 // the entry, so the transform's emitted `_INTERNAL_wrapUnlessInstrumented`
 // guard must hand the manual wrap back instead of nesting a second wrapper.
-// Nested entrypoint wrappers each instrument `fetch`, which shows up as extra
-// spans on the entrypoint transaction, the strict shape below catches that.
+// A nested wrapper throws inside the entrypoint and fails the request. The
+// child-less assertion below catches a nested wrapper that runs without an
+// error but instruments `fetch` a second time.
 it('does not double-instrument an imported, already-wrapped WorkerEntrypoint', async ({ signal }) => {
-  const runner = createRunner(__dirname)
-    .unordered()
-    .expect(envelope => {
-      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
-      // The entrypoint's own transaction, child-less when wrapped exactly once.
-      expect(transactionEvent.transaction).toBe('GET /greet');
-      expect(transactionEvent.contexts?.trace?.op).toBe('http.server');
-      expect(transactionEvent.spans ?? []).toHaveLength(0);
-    })
-    .expect(envelope => {
-      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
-      // The auto-wrapped default export's transaction.
-      expect(transactionEvent.transaction).toBe('GET /call-entrypoint');
-      expect(transactionEvent.contexts?.trace?.op).toBe('http.server');
-    })
-    .start(signal);
+  const runner = createRunner(__dirname).start(signal);
+
+  // The default handler and the entrypoint stream from separate isolates, so the two segment spans
+  // of the trace arrive in separate envelopes.
+  const spansPromise = runner.collectStreamedSpans(
+    spansOfTrace => spansOfTrace.filter(span => span.is_segment).length === 2,
+  );
 
   await runner.makeRequest('get', '/call-entrypoint');
-  await runner.completed();
+
+  const spans = await spansPromise;
+  // Both routes are raw URLs, so the streamed segment names keep the method only and the route is
+  // read from `url.path`.
+  const workerSpan = spans.find(span => span.is_segment && span.attributes['url.path']?.value === '/call-entrypoint');
+  const entrypointSpan = spans.find(span => span.is_segment && span.attributes['url.path']?.value === '/greet');
+
+  // The auto-wrapped default export's segment span.
+  expect(workerSpan?.name).toBe('GET');
+  expect(getSpanOp(workerSpan!)).toBe('http.server');
+
+  expect(entrypointSpan?.name).toBe('GET');
+  expect(getSpanOp(entrypointSpan!)).toBe('http.server');
+  expect(entrypointSpan?.parent_span_id).toBe(workerSpan?.span_id);
+  // The entrypoint's spans stay buffered until its invocation flushes, so a child span would arrive
+  // in the same envelope as the entrypoint's segment span.
+  expect(spans.filter(span => span.parent_span_id === entrypointSpan?.span_id)).toEqual([]);
 });

dev-packages/cloudflare-integration-tests/suites/vite-autoinstrument/workflow-reexport-instrumented/index.ts

@@ -15,9 +15,9 @@ export default {
   async fetch(request: Request, env: Env): Promise<Response> {
     const url = new URL(request.url);
 
-    // Issued by the test after `/trigger` returned, its transaction is the
+    // Issued by the test after `/trigger` returned, its segment span is the
     // sentinel proving every earlier envelope (including a duplicate step
-    // transaction from an accidental double wrap) has been delivered.
+    // span from an accidental double wrap) has been delivered.
     if (url.pathname === '/sentinel') {
       return new Response('ok');
     }
@@ -26,7 +26,7 @@ export default {
       const instance = await env.MY_WORKFLOW.create();
       // Respond only once the workflow finished, so every step envelope (including
       // a duplicate from an accidental double wrap) is sent before this request's
-      // own transaction completes the test's expectations.
+      // own segment span completes the test's expectations.
       for (let i = 0; i < 20; i++) {
         try {
           const s = await instance.status();

dev-packages/cloudflare-integration-tests/suites/vite-autoinstrument/workflow-reexport-instrumented/instrument.server.ts

@@ -2,6 +2,5 @@ import { defineCloudflareOptions } from '@sentry/cloudflare';
 
 export default defineCloudflareOptions((env: { SENTRY_DSN: string }) => ({
   dsn: env.SENTRY_DSN,
-  traceLifecycle: 'static',
   tracesSampleRate: 1.0,
 }));

dev-packages/cloudflare-integration-tests/suites/vite-autoinstrument/workflow-reexport-instrumented/test.ts

@@ -1,48 +1,54 @@
-import type { TransactionEvent } from '@sentry/core';
 import { expect, it } from 'vitest';
 import { createRunner } from '../../../runner';
+import { getSpanOp, getSpansFromEnvelope } from '../../../spanUtils';
 
 // `MyWorkflow` is hand-wrapped in `./workflow` and only re-exported by the
 // entry, so the transform's emitted `_INTERNAL_wrapUnlessInstrumented` guard
 // must hand the manual wrap back instead of nesting a second wrapper. Nested
 // workflow wrappers each run the step through their own client, producing TWO
-// identical `step-one` transactions, each individually well-formed, so the
-// real check is the count assertion at the end.
+// identical `step-one` spans, each individually well-formed, so the real check
+// is the count assertion at the end.
 //
 // Ordering is anchored by a sentinel rather than by waiting: `/trigger`
 // responds only after the workflow finished (every step envelope, including a
 // duplicate, is flushed before then), and `/sentinel` is requested after that,
-// so its transaction arrives a full request/response cycle behind any
-// duplicate. Once the sentinel envelope has been matched, everything sent
-// before it is known to have been delivered.
+// so its span arrives a full request/response cycle behind any duplicate. Once
+// the sentinel envelope has been matched, everything sent before it is known to
+// have been delivered.
 it('does not double-instrument an imported, already-wrapped Workflow', async ({ signal }) => {
   const runner = createRunner(__dirname)
     .unordered()
     .expect(envelope => {
-      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
-      expect(transactionEvent.transaction).toBe('step-one');
-      expect(transactionEvent.contexts?.trace?.op).toBe('function');
-      expect(transactionEvent.contexts?.trace?.origin).toBe('auto.faas.cloudflare.workflow');
+      const stepSpan = getSpansFromEnvelope(envelope).find(span => span.is_segment && span.name === 'step-one');
+      expect(getSpanOp(stepSpan!)).toBe('function');
+      expect(stepSpan?.attributes['sentry.origin']).toEqual({
+        type: 'string',
+        value: 'auto.faas.cloudflare.workflow',
+      });
     })
     .expect(envelope => {
-      const transactionEvent = envelope[1]?.[0]?.[1] as TransactionEvent;
-      // The auto-wrapped default export's own transaction.
-      expect(transactionEvent.transaction).toBe('GET /trigger');
-      expect(transactionEvent.contexts?.trace?.op).toBe('http.server');
+      // The auto-wrapped default export's own segment span. `/trigger` is a raw URL, so the streamed
+      // segment name keeps the method only.
+      const segmentSpan = getSpansFromEnvelope(envelope).find(span => span.is_segment);
+      expect(segmentSpan?.name).toBe('GET');
+      expect(getSpanOp(segmentSpan!)).toBe('http.server');
+      expect(segmentSpan?.attributes['url.path']).toEqual({ type: 'string', value: '/trigger' });
     })
     // The sentinel is part of the expected set, so the runner keeps everything
     // alive (and keeps receiving envelopes) until it has arrived.
     .expect(envelope => {
-      expect((envelope[1]?.[0]?.[1] as TransactionEvent).transaction).toBe('GET /sentinel');
+      const segmentSpan = getSpansFromEnvelope(envelope).find(span => span.is_segment);
+      expect(segmentSpan?.attributes['url.path']).toEqual({ type: 'string', value: '/sentinel' });
     })
     .start(signal);
 
   await runner.makeRequest('get', '/trigger');
   await runner.makeRequest('get', '/sentinel');
   await runner.completed();
 
-  const stepTransactions = runner
+  const stepSpans = runner
     .getReceivedEnvelopes()
-    .filter(envelope => (envelope[1]?.[0]?.[1] as TransactionEvent | undefined)?.transaction === 'step-one');
-  expect(stepTransactions).toHaveLength(1);
+    .flatMap(envelope => getSpansFromEnvelope(envelope))
+    .filter(span => span.name === 'step-one');
+  expect(stepSpans).toHaveLength(1);
 });

dev-packages/cloudflare-integration-tests/suites/vite-autoinstrument/workflow-reexport-instrumented/workflow.ts

@@ -15,6 +15,6 @@ class MyWorkflowImpl extends WorkflowEntrypoint<Env> {
 // Manually instrumented here, in a module separate from the worker entry, which
 // only imports and re-exports the wrapped class.
 export const MyWorkflow = Sentry.instrumentWorkflowWithSentry(
-  (env: Env) => ({ dsn: env.SENTRY_DSN, traceLifecycle: 'static', tracesSampleRate: 1.0 }),
+  (env: Env) => ({ dsn: env.SENTRY_DSN, tracesSampleRate: 1.0 }),
   MyWorkflowImpl,
 );