test(e2e): Port nextjs-14 to span streaming

Removes the `traceLifecycle: 'static'` pins and rewrites the specs onto streamed spans.

Tests asserting on children of a segment span (generation functions, request instrumentation, trace propagation) use `collectStreamedSpans` and accumulate until the segment span, which ends last. The propagation specs match the inbound span, outbound span and the `http.client` span between them within one trace, since all three share it.

`http.client` span names are low cardinality under streaming, so the request-instrumentation spans are now named `GET github.com` rather than `GET https://github.com/`.

The transaction-side `tags` assertions were dropped, having no span v2 equivalent; the error-side assertions still cover isolation scope.

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

Author: chargome

dev-packages/e2e-tests/test-applications/nextjs-14/instrumentation-client.ts

@@ -1,7 +1,6 @@
 import * as Sentry from '@sentry/nextjs';
 
 Sentry.init({
-  traceLifecycle: 'static',
   environment: 'qa', // dynamic sampling bias to keep transactions
   dsn: process.env.NEXT_PUBLIC_E2E_TEST_DSN,
   tunnel: `http://localhost:3031/`, // proxy server

dev-packages/e2e-tests/test-applications/nextjs-14/instrumentation.ts

@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/nextjs';
 export function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs' || process.env.NEXT_RUNTIME === 'edge') {
     Sentry.init({
-      traceLifecycle: 'static',
       environment: 'qa', // dynamic sampling bias to keep transactions
       dsn: process.env.NEXT_PUBLIC_E2E_TEST_DSN,
       tunnel: `http://localhost:3031/`, // proxy server

dev-packages/e2e-tests/test-applications/nextjs-14/tests/generation-functions.test.ts

@@ -1,44 +1,48 @@
 import { expect, test } from '@playwright/test';
-import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
+import { collectStreamedSpans, waitForError, waitForStreamedSpan } from '@sentry-internal/test-utils';
+
+// The generation-function spans are children of the segment span, which ends last, so accumulate
+// spans until the segment for this request arrives.
+function collectSpansForTarget(httpTarget: string) {
+  return collectStreamedSpans('nextjs-14', spans =>
+    spans.some(span => span.is_segment && span.attributes['http.target']?.value === httpTarget),
+  );
+}
 
 test('Should emit a span for a generateMetadata() function invocation', async ({ page }) => {
   const testTitle = 'should-emit-span';
+  const httpTarget = `/generation-functions?metadataTitle=${testTitle}`;
 
-  const transactionPromise = waitForTransaction('nextjs-14', async transactionEvent => {
-    return (
-      transactionEvent.contexts?.trace?.data?.['http.target'] === `/generation-functions?metadataTitle=${testTitle}`
-    );
-  });
+  const spansPromise = collectSpansForTarget(httpTarget);
 
-  await page.goto(`/generation-functions?metadataTitle=${testTitle}`);
+  await page.goto(httpTarget);
 
-  const transaction = await transactionPromise;
+  const spans = await spansPromise;
+  const segmentSpan = spans.find(span => span.is_segment && span.attributes['http.target']?.value === httpTarget)!;
 
-  expect(transaction.spans).toContainEqual(
+  expect(spans).toContainEqual(
     expect.objectContaining({
-      description: 'generateMetadata /generation-functions/page',
-      origin: 'auto',
+      name: 'generateMetadata /generation-functions/page',
+      status: 'ok',
+      trace_id: segmentSpan.trace_id,
       parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
       span_id: expect.stringMatching(/[a-f0-9]{16}/),
-      status: 'ok',
-      trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+      attributes: expect.objectContaining({
+        'sentry.origin': { value: 'auto', type: 'string' },
+      }),
     }),
   );
 
   const pageTitle = await page.title();
   expect(pageTitle).toBe(testTitle);
 });
 
-test('Should send a transaction and an error event for a faulty generateMetadata() function invocation', async ({
-  page,
-}) => {
+test('Should send a span and an error event for a faulty generateMetadata() function invocation', async ({ page }) => {
   const testTitle = 'should-emit-error';
+  const httpTarget = `/generation-functions?metadataTitle=${testTitle}&shouldThrowInGenerateMetadata=1`;
 
-  const transactionPromise = waitForTransaction('nextjs-14', async transactionEvent => {
-    return (
-      transactionEvent.contexts?.trace?.data?.['http.target'] ===
-      `/generation-functions?metadataTitle=${testTitle}&shouldThrowInGenerateMetadata=1`
-    );
+  const spanPromise = waitForStreamedSpan('nextjs-14', span => {
+    return span.is_segment && span.attributes['http.target']?.value === httpTarget;
   });
 
   const errorEventPromise = waitForError('nextjs-14', errorEvent => {
@@ -48,61 +52,57 @@ test('Should send a transaction and an error event for a faulty generateMetadata
     );
   });
 
-  await page.goto(`/generation-functions?metadataTitle=${testTitle}&shouldThrowInGenerateMetadata=1`);
+  await page.goto(httpTarget);
 
   const errorEvent = await errorEventPromise;
-  const transactionEvent = await transactionPromise;
+  expect(await spanPromise).toBeDefined();
 
-  // Assert that isolation scope works properly
+  // Assert that isolation scope works properly. Span v2 carries no scope tags, so this is only
+  // asserted on the error event; the span-side assertions were dropped in the streaming port.
   expect(errorEvent.tags?.['my-isolated-tag']).toBe(true);
   expect(errorEvent.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
-  expect(transactionEvent.tags?.['my-isolated-tag']).toBe(true);
-  expect(transactionEvent.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
 });
 
-test('Should send a transaction event for a generateViewport() function invocation', async ({ page }) => {
+test('Should send a span for a generateViewport() function invocation', async ({ page }) => {
   const testTitle = 'floob';
+  const httpTarget = `/generation-functions?viewportThemeColor=${testTitle}`;
 
-  const transactionPromise = waitForTransaction('nextjs-14', async transactionEvent => {
-    return (
-      transactionEvent.contexts?.trace?.data?.['http.target'] ===
-      `/generation-functions?viewportThemeColor=${testTitle}`
-    );
-  });
+  const spansPromise = collectSpansForTarget(httpTarget);
+
+  await page.goto(httpTarget);
 
-  await page.goto(`/generation-functions?viewportThemeColor=${testTitle}`);
+  const spans = await spansPromise;
+  const segmentSpan = spans.find(span => span.is_segment && span.attributes['http.target']?.value === httpTarget)!;
 
-  expect((await transactionPromise).spans).toContainEqual(
+  expect(spans).toContainEqual(
     expect.objectContaining({
-      description: 'generateViewport /generation-functions/page',
-      origin: 'auto',
+      name: 'generateViewport /generation-functions/page',
+      status: 'ok',
+      trace_id: segmentSpan.trace_id,
       parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
       span_id: expect.stringMatching(/[a-f0-9]{16}/),
-      status: 'ok',
-      trace_id: expect.stringMatching(/[a-f0-9]{32}/),
+      attributes: expect.objectContaining({
+        'sentry.origin': { value: 'auto', type: 'string' },
+      }),
     }),
   );
 });
 
-test('Should send a transaction and an error event for a faulty generateViewport() function invocation', async ({
-  page,
-}) => {
+test('Should send a span and an error event for a faulty generateViewport() function invocation', async ({ page }) => {
   const testTitle = 'blargh';
+  const httpTarget = `/generation-functions?viewportThemeColor=${testTitle}&shouldThrowInGenerateViewport=1`;
 
-  const transactionPromise = waitForTransaction('nextjs-14', async transactionEvent => {
-    return (
-      transactionEvent.contexts?.trace?.data?.['http.target'] ===
-      `/generation-functions?viewportThemeColor=${testTitle}&shouldThrowInGenerateViewport=1`
-    );
+  const spanPromise = waitForStreamedSpan('nextjs-14', span => {
+    return span.is_segment && span.attributes['http.target']?.value === httpTarget;
   });
 
   const errorEventPromise = waitForError('nextjs-14', errorEvent => {
     return errorEvent?.exception?.values?.[0]?.value === 'generateViewport Error';
   });
 
-  await page.goto(`/generation-functions?viewportThemeColor=${testTitle}&shouldThrowInGenerateViewport=1`);
+  await page.goto(httpTarget);
 
-  expect(await transactionPromise).toBeDefined();
+  expect(await spanPromise).toBeDefined();
   expect(await errorEventPromise).toBeDefined();
 
   const errorEvent = await errorEventPromise;