From a3dfc27504aca70c6df64e3046a8cc6d6ebbae06 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Thu, 8 Oct 2026 15:20:26 +0200
Subject: [PATCH 01/84] test(node): Port Prisma integration tests to span
 streaming (#25152)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Port Prisma v5–v7 tests to default span streaming and fold their
query-name checks into the existing tests.

Part of #24137

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../instrument-span-streaming.mjs             |  10 -
 .../tracing/prisma-orm-v5/instrument.mjs      |   1 -
 .../suites/tracing/prisma-orm-v5/test.ts      | 198 ++++++++----------
 .../instrument-span-streaming.mjs             |  10 -
 .../tracing/prisma-orm-v6/instrument.mjs      |   1 -
 .../suites/tracing/prisma-orm-v6/test.ts      | 131 ++++++------
 .../instrument-span-streaming.mjs             |  10 -
 .../tracing/prisma-orm-v7/instrument.mjs      |   1 -
 .../suites/tracing/prisma-orm-v7/test.ts      | 127 +++++------
 9 files changed, 196 insertions(+), 293 deletions(-)
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/instrument-span-streaming.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/instrument-span-streaming.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/instrument-span-streaming.mjs

diff --git a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/instrument-span-streaming.mjs b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/instrument-span-streaming.mjs
deleted file mode 100644
index 53b9511a21f0..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/instrument-span-streaming.mjs
+++ /dev/null
@@ -1,10 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  transport: loggingTransport,
-  traceLifecycle: 'stream',
-});
diff --git a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/instrument.mjs
index 170ad6f6a702..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/test.ts b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/test.ts
index 33b8c89d0ec3..4c528b7c3aa5 100644
--- a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v5/test.ts
@@ -1,4 +1,13 @@
-import type { TransactionEvent } from '@sentry/core';
+import {
+  DB_QUERY_SUMMARY,
+  DB_STATEMENT,
+  DB_SYSTEM,
+  SENTRY_KIND,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
+import type { SerializedStreamedSpanContainer } from '@sentry/core';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
@@ -11,105 +20,123 @@ const ADDITIONAL_DEPENDENCIES = {
   prisma: '5.22.0',
 };
 
-function expectPrismaV5Spans(transaction: TransactionEvent): void {
-  expect(transaction.transaction).toBe('Test Transaction');
-  const spans = transaction.spans || [];
+function expectPrismaV5Spans(container: SerializedStreamedSpanContainer): void {
+  const segment = container.items.find(span => span.is_segment);
+  expect(segment?.name).toBe('Test Transaction');
+  const spans = container.items.filter(span => !span.is_segment);
   expect(spans.length).toBeGreaterThanOrEqual(5);
 
   // Valid parents are the transaction root or any other span within the transaction.
-  const validParentIds = new Set([transaction.contexts?.trace?.span_id, ...spans.map(s => s.span_id)]);
+  const validParentIds = new Set([segment?.span_id, ...spans.map(s => s.span_id)]);
 
-  const operationSpans = spans.filter(s => s.description === 'prisma:client:operation');
+  const operationSpans = spans.filter(s => s.name === 'prisma:client:operation');
   expect(operationSpans.length).toBeGreaterThanOrEqual(1);
 
   // The db-query spans are materialized from the raw engine event; assert they nest inside the
   // transaction rather than dangling as orphans.
-  const dbSpans = spans.filter(s => s.op === 'db');
+  const dbSpans = spans.filter(s => s.attributes[SENTRY_OP]?.value === DB);
   expect(dbSpans.length).toBeGreaterThanOrEqual(1);
   dbSpans.forEach(dbSpan => {
     expect(validParentIds.has(dbSpan.parent_span_id)).toBe(true);
   });
 
-  const txSpan = spans.find(s => s.description === 'prisma:client:transaction');
+  const txSpan = spans.find(s => s.name === 'prisma:client:transaction');
   expect(txSpan).toBeDefined();
 
   expect(spans).toEqual(
     expect.arrayContaining([
       expect.objectContaining({
-        data: {
-          method: 'create',
-          model: 'User',
-          name: 'User.create',
-          'sentry.origin': 'auto.db.prisma',
-        },
-        description: 'prisma:client:operation',
+        attributes: expect.objectContaining({
+          method: { type: 'string', value: 'create' },
+          model: { type: 'string', value: 'User' },
+          name: { type: 'string', value: 'User.create' },
+          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.db.prisma' },
+        }),
+        name: 'prisma:client:operation',
         status: 'ok',
       }),
       expect.objectContaining({
-        data: {
-          method: 'findMany',
-          model: 'User',
-          name: 'User.findMany',
-          'sentry.origin': 'auto.db.prisma',
-        },
-        description: 'prisma:client:operation',
+        attributes: expect.objectContaining({
+          method: { type: 'string', value: 'findMany' },
+          model: { type: 'string', value: 'User' },
+          name: { type: 'string', value: 'User.findMany' },
+          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.db.prisma' },
+        }),
+        name: 'prisma:client:operation',
         status: 'ok',
       }),
       expect.objectContaining({
-        data: {
-          'sentry.origin': 'auto.db.prisma',
-        },
-        description: 'prisma:client:serialize',
+        attributes: expect.objectContaining({
+          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.db.prisma' },
+        }),
+        name: 'prisma:client:serialize',
         status: 'ok',
       }),
       expect.objectContaining({
-        data: {
-          'sentry.origin': 'auto.db.prisma',
-        },
-        description: 'prisma:client:connect',
+        attributes: expect.objectContaining({
+          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.db.prisma' },
+        }),
+        name: 'prisma:client:connect',
         status: 'ok',
       }),
       expect.objectContaining({
-        data: {
-          'db.statement': expect.stringContaining('INSERT INTO'),
-          'db.query.summary': 'INSERT "public"."User"',
-          'db.system': 'postgresql',
-          'sentry.kind': 'client',
-          'sentry.op': 'db',
-          'sentry.origin': 'auto.db.prisma',
-        },
-        op: 'db',
-        description: expect.stringContaining('INSERT INTO'),
+        attributes: expect.objectContaining({
+          [DB_STATEMENT]: { type: 'string', value: expect.stringContaining('INSERT INTO') },
+          [DB_QUERY_SUMMARY]: { type: 'string', value: 'INSERT "public"."User"' },
+          [DB_SYSTEM]: { type: 'string', value: 'postgresql' },
+          [SENTRY_KIND]: { type: 'string', value: 'client' },
+          [SENTRY_OP]: { type: 'string', value: DB },
+          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.db.prisma' },
+        }),
+        name: 'INSERT "public"."User"',
         status: 'ok',
       }),
       expect.objectContaining({
-        data: {
-          'db.statement': expect.stringContaining('SELECT'),
-          'db.query.summary': 'SELECT "public"."User"',
-          'db.system': 'postgresql',
-          'sentry.kind': 'client',
-          'sentry.op': 'db',
-          'sentry.origin': 'auto.db.prisma',
-        },
-        op: 'db',
-        description: expect.stringContaining('SELECT'),
+        attributes: expect.objectContaining({
+          [DB_STATEMENT]: { type: 'string', value: expect.stringContaining('SELECT') },
+          [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "public"."User"' },
+          [DB_SYSTEM]: { type: 'string', value: 'postgresql' },
+          [SENTRY_KIND]: { type: 'string', value: 'client' },
+          [SENTRY_OP]: { type: 'string', value: DB },
+          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.db.prisma' },
+        }),
+        name: 'SELECT "public"."User"',
         status: 'ok',
       }),
       expect.objectContaining({
-        data: {
-          'db.statement': expect.stringContaining('DELETE'),
-          'db.query.summary': 'DELETE "public"."User"',
-          'db.system': 'postgresql',
-          'sentry.kind': 'client',
-          'sentry.op': 'db',
-          'sentry.origin': 'auto.db.prisma',
-        },
-        op: 'db',
-        description: expect.stringContaining('DELETE'),
+        attributes: expect.objectContaining({
+          [DB_STATEMENT]: { type: 'string', value: expect.stringContaining('DELETE') },
+          [DB_QUERY_SUMMARY]: { type: 'string', value: 'DELETE "public"."User"' },
+          [DB_SYSTEM]: { type: 'string', value: 'postgresql' },
+          [SENTRY_KIND]: { type: 'string', value: 'client' },
+          [SENTRY_OP]: { type: 'string', value: DB },
+          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.db.prisma' },
+        }),
+        name: 'DELETE "public"."User"',
         status: 'ok',
       }),
     ]),
   );
+
+  const querySpans = spans.filter(item => item.attributes[DB_STATEMENT]);
+
+  expect(
+    querySpans.map(span => ({
+      name: span.name,
+      summary: span.attributes[DB_QUERY_SUMMARY]?.value,
+    })),
+  ).toEqual([
+    { name: 'INSERT "public"."User"', summary: 'INSERT "public"."User"' },
+    { name: 'SELECT "public"."User"', summary: 'SELECT "public"."User"' },
+    { name: 'BEGIN', summary: 'BEGIN' },
+    { name: 'INSERT "public"."User"', summary: 'INSERT "public"."User"' },
+    { name: 'SELECT "public"."User"', summary: 'SELECT "public"."User"' },
+    { name: 'COMMIT', summary: 'COMMIT' },
+    { name: 'DELETE "public"."User"', summary: 'DELETE "public"."User"' },
+  ]);
+
+  // The raw engine span name must never leak through.
+  expect(spans.map(span => span.name)).not.toContain('prisma:engine:db_query');
 }
 
 const AFTER_SETUP_COMMAND = 'prisma generate --schema prisma/schema.prisma';
@@ -122,7 +149,7 @@ describeWithDockerCompose('Prisma ORM v5', { workingDirectory: [__dirname] }, ()
       'instrument.mjs',
       (createRunner, test) => {
         test('should instrument PostgreSQL queries from Prisma ORM', { timeout: 75_000 }, async () => {
-          await createRunner().expect({ transaction: expectPrismaV5Spans }).start().completed();
+          await createRunner().expect({ span: expectPrismaV5Spans }).start().completed();
         });
       },
       {
@@ -131,54 +158,5 @@ describeWithDockerCompose('Prisma ORM v5', { workingDirectory: [__dirname] }, ()
         copyPaths: ['prisma'],
       },
     );
-
-    createEsmAndCjsTests(
-      __dirname,
-      'scenario.mjs',
-      'instrument-span-streaming.mjs',
-      (createRunner, test) => {
-        test(
-          'should name db query spans after the query summary with span streaming',
-          { timeout: 75_000 },
-          async () => {
-            await createRunner()
-              // Prisma's engine startup can outlast the span buffer's flush interval, so the query spans
-              // are not guaranteed to be in the first span envelope.
-              .unordered()
-              .expect({
-                span: container => {
-                  // v5 reports the SQL on the deprecated `db.statement` rather than `db.query.text`.
-                  const querySpans = container.items.filter(item => item.attributes['db.statement']);
-
-                  expect(
-                    querySpans.map(span => ({
-                      name: span.name,
-                      summary: span.attributes['db.query.summary']?.value,
-                    })),
-                  ).toEqual([
-                    { name: 'INSERT "public"."User"', summary: 'INSERT "public"."User"' },
-                    { name: 'SELECT "public"."User"', summary: 'SELECT "public"."User"' },
-                    { name: 'BEGIN', summary: 'BEGIN' },
-                    { name: 'INSERT "public"."User"', summary: 'INSERT "public"."User"' },
-                    { name: 'SELECT "public"."User"', summary: 'SELECT "public"."User"' },
-                    { name: 'COMMIT', summary: 'COMMIT' },
-                    { name: 'DELETE "public"."User"', summary: 'DELETE "public"."User"' },
-                  ]);
-
-                  // The raw engine span name must never leak through.
-                  expect(container.items.map(span => span.name)).not.toContain('prisma:engine:db_query');
-                },
-              })
-              .start()
-              .completed();
-          },
-        );
-      },
-      {
-        additionalDependencies: ADDITIONAL_DEPENDENCIES,
-        afterSetupCommand: AFTER_SETUP_COMMAND,
-        copyPaths: ['prisma'],
-      },
-    );
   });
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/instrument-span-streaming.mjs b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/instrument-span-streaming.mjs
deleted file mode 100644
index 53b9511a21f0..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/instrument-span-streaming.mjs
+++ /dev/null
@@ -1,10 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  transport: loggingTransport,
-  traceLifecycle: 'stream',
-});
diff --git a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/instrument.mjs
index 170ad6f6a702..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/test.ts b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/test.ts
index 542c482a0fa1..18f44727b1bb 100644
--- a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v6/test.ts
@@ -1,4 +1,13 @@
-import type { SpanJSON } from '@sentry/core';
+import {
+  DB_QUERY_SUMMARY,
+  DB_QUERY_TEXT,
+  DB_SYSTEM,
+  SENTRY_KIND,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
+import type { SerializedStreamedSpan } from '@sentry/core';
 import { afterAll, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
@@ -15,142 +24,122 @@ describeWithDockerCompose('Prisma ORM v6 Tests', { workingDirectory: [__dirname]
       test('should instrument PostgreSQL queries from Prisma ORM', { timeout: 75_000 }, async () => {
         await createRunner()
           .expect({
-            transaction: transaction => {
-              expect(transaction.transaction).toBe('Test Transaction');
+            span: container => {
+              const segment = container.items.find(span => span.is_segment);
+              expect(segment?.name).toBe('Test Transaction');
 
-              const spans = transaction.spans || [];
+              const spans = container.items.filter(span => !span.is_segment);
               expect(spans.length).toBeGreaterThanOrEqual(5);
 
               // Each operation span is a direct child of the transaction; the db query span is a child of the engine query span.
-              const rootSpanId = transaction.contexts?.trace?.span_id;
+              const rootSpanId = segment?.span_id;
 
-              const operationSpans = spans.filter(s => s.description === 'prisma:client:operation');
+              const operationSpans = spans.filter(s => s.name === 'prisma:client:operation');
               expect(operationSpans.length).toBeGreaterThanOrEqual(1);
               operationSpans.forEach(operation => {
                 expect(operation.parent_span_id).toBe(rootSpanId);
               });
 
               const dbQuerySpan = spans.find(
-                s => s.data?.['sentry.origin'] === 'auto.db.prisma' && s.data?.['db.query.text'],
+                s => s.attributes[SENTRY_ORIGIN]?.value === 'auto.db.prisma' && s.attributes[DB_QUERY_TEXT],
               );
               expect(dbQuerySpan).toBeDefined();
               const dbQueryParent = spans.find(s => s.span_id === dbQuerySpan?.parent_span_id);
-              expect(dbQueryParent?.description).toBe('prisma:engine:query');
+              expect(dbQueryParent?.name).toBe('prisma:engine:query');
 
-              function expectPrismaSpanToIncludeSpanWith(span: Partial<SpanJSON>) {
+              function expectPrismaSpanToIncludeSpanWith(span: Partial<SerializedStreamedSpan>) {
                 expect(spans).toContainEqual(
                   expect.objectContaining({
                     ...span,
-                    data: {
-                      ...span.data,
-                      'sentry.origin': 'auto.db.prisma',
-                    },
+                    attributes: expect.objectContaining({
+                      ...span.attributes,
+                      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.db.prisma' },
+                    }),
                     status: 'ok',
                   }),
                 );
               }
 
               expectPrismaSpanToIncludeSpanWith({
-                description: 'prisma:client:detect_platform',
+                name: 'prisma:client:detect_platform',
               });
 
               expectPrismaSpanToIncludeSpanWith({
-                description: 'prisma:client:load_engine',
+                name: 'prisma:client:load_engine',
               });
 
               expectPrismaSpanToIncludeSpanWith({
-                description: 'prisma:client:operation',
-                data: {
-                  method: 'create',
-                  model: 'User',
-                  name: 'User.create',
+                name: 'prisma:client:operation',
+                attributes: {
+                  method: { type: 'string', value: 'create' },
+                  model: { type: 'string', value: 'User' },
+                  name: { type: 'string', value: 'User.create' },
                 },
               });
 
               expectPrismaSpanToIncludeSpanWith({
-                description: 'prisma:client:serialize',
+                name: 'prisma:client:serialize',
               });
 
               expectPrismaSpanToIncludeSpanWith({
-                description: 'prisma:client:connect',
+                name: 'prisma:client:connect',
               });
 
               expectPrismaSpanToIncludeSpanWith({
-                description: 'prisma:engine:connect',
+                name: 'prisma:engine:connect',
               });
 
               expectPrismaSpanToIncludeSpanWith({
-                description: 'prisma:engine:query',
+                name: 'prisma:engine:query',
               });
 
               expectPrismaSpanToIncludeSpanWith({
-                data: {
-                  'sentry.op': 'db',
-                  'db.query.text':
-                    'SELECT "public"."User"."id", "public"."User"."createdAt", "public"."User"."email", "public"."User"."name" FROM "public"."User" WHERE 1=1 OFFSET $1',
-                  'db.query.summary': 'SELECT "public"."User"',
-                  'db.system': 'postgresql',
-                  'sentry.kind': 'client',
+                attributes: {
+                  [SENTRY_OP]: { type: 'string', value: DB },
+                  [DB_QUERY_TEXT]: {
+                    type: 'string',
+                    value:
+                      'SELECT "public"."User"."id", "public"."User"."createdAt", "public"."User"."email", "public"."User"."name" FROM "public"."User" WHERE 1=1 OFFSET $1',
+                  },
+                  [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "public"."User"' },
+                  [DB_SYSTEM]: { type: 'string', value: 'postgresql' },
+                  [SENTRY_KIND]: { type: 'string', value: 'client' },
                 },
-                description:
-                  'SELECT "public"."User"."id", "public"."User"."createdAt", "public"."User"."email", "public"."User"."name" FROM "public"."User" WHERE 1=1 OFFSET $1',
+                name: 'SELECT "public"."User"',
               });
 
               expectPrismaSpanToIncludeSpanWith({
-                data: {
-                  'sentry.op': 'db',
-                  'db.query.text': 'DELETE FROM "public"."User" WHERE "public"."User"."email"::text LIKE $1',
-                  'db.query.summary': 'DELETE "public"."User"',
-                  'db.system': 'postgresql',
-                  'sentry.kind': 'client',
+                attributes: {
+                  [SENTRY_OP]: { type: 'string', value: DB },
+                  [DB_QUERY_TEXT]: {
+                    type: 'string',
+                    value: 'DELETE FROM "public"."User" WHERE "public"."User"."email"::text LIKE $1',
+                  },
+                  [DB_QUERY_SUMMARY]: { type: 'string', value: 'DELETE "public"."User"' },
+                  [DB_SYSTEM]: { type: 'string', value: 'postgresql' },
+                  [SENTRY_KIND]: { type: 'string', value: 'client' },
                 },
-                description: 'DELETE FROM "public"."User" WHERE "public"."User"."email"::text LIKE $1',
+                name: 'DELETE "public"."User"',
               });
 
-              // The db query span name must always be rewritten to the SQL text; the raw engine span
+              // The db query span name must always be rewritten to the query summary; the raw engine span
               // name should never leak through.
-              expect(spans.find(span => span.description === 'prisma:engine:db_query')).toBeUndefined();
-            },
-          })
-          .start()
-          .completed();
-      });
-    },
-    {
-      afterSetupCommand: 'prisma generate --schema prisma/schema.prisma',
-      copyPaths: ['prisma'],
-    },
-  );
+              expect(spans.find(span => span.name === 'prisma:engine:db_query')).toBeUndefined();
 
-  createEsmAndCjsTests(
-    __dirname,
-    'scenario.mjs',
-    'instrument-span-streaming.mjs',
-    (createRunner, test) => {
-      test('should name db query spans after the query summary with span streaming', { timeout: 75_000 }, async () => {
-        await createRunner()
-          // Prisma's engine startup can outlast the span buffer's flush interval, so the query spans
-          // are not guaranteed to be in the first span envelope.
-          .unordered()
-          .expect({
-            span: container => {
-              const querySpans = container.items.filter(item => item.attributes['db.query.text']);
+              const querySpans = spans.filter(item => item.attributes[DB_QUERY_TEXT]);
 
               expect(
                 querySpans.map(span => ({
                   name: span.name,
-                  summary: span.attributes['db.query.summary']?.value,
+                  summary: span.attributes[DB_QUERY_SUMMARY]?.value,
                 })),
               ).toEqual([
                 { name: 'INSERT "public"."User"', summary: 'INSERT "public"."User"' },
                 { name: 'SELECT "public"."User"', summary: 'SELECT "public"."User"' },
                 { name: 'DELETE "public"."User"', summary: 'DELETE "public"."User"' },
               ]);
-
-              // Neither the raw engine span name nor the full statement may end up as a span name.
-              expect(container.items.map(span => span.name)).not.toContain('prisma:engine:db_query');
               querySpans.forEach(span => {
-                expect(span.name).not.toBe(span.attributes['db.query.text']?.value);
+                expect(span.name).not.toBe(span.attributes[DB_QUERY_TEXT]?.value);
               });
             },
           })
diff --git a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/instrument-span-streaming.mjs b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/instrument-span-streaming.mjs
deleted file mode 100644
index 53b9511a21f0..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/instrument-span-streaming.mjs
+++ /dev/null
@@ -1,10 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  transport: loggingTransport,
-  traceLifecycle: 'stream',
-});
diff --git a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/instrument.mjs
index 170ad6f6a702..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/test.ts b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/test.ts
index b9fd94230350..9e11425ee539 100644
--- a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v7/test.ts
@@ -1,3 +1,11 @@
+import {
+  DB_QUERY_SUMMARY,
+  DB_QUERY_TEXT,
+  DB_SYSTEM_NAME,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
@@ -15,34 +23,35 @@ describe('Prisma ORM v7 Tests', () => {
         test('should instrument PostgreSQL queries from Prisma ORM', { timeout: 75_000 }, async () => {
           await createRunner()
             .expect({
-              transaction: transaction => {
-                expect(transaction.transaction).toBe('Test Transaction');
+              span: container => {
+                const segment = container.items.find(span => span.is_segment);
+                expect(segment?.name).toBe('Test Transaction');
 
-                const spans = transaction.spans || [];
+                const spans = container.items.filter(span => !span.is_segment);
                 expect(spans.length).toBeGreaterThanOrEqual(5);
 
                 // Each operation span is a direct child of the transaction; the db query span is a child of its operation span.
-                const rootSpanId = transaction.contexts?.trace?.span_id;
+                const rootSpanId = segment?.span_id;
 
-                const operationSpans = spans.filter(s => s.description === 'prisma:client:operation');
+                const operationSpans = spans.filter(s => s.name === 'prisma:client:operation');
                 expect(operationSpans.length).toBeGreaterThanOrEqual(1);
                 operationSpans.forEach(operation => {
                   expect(operation.parent_span_id).toBe(rootSpanId);
                 });
 
                 const prismaDbQuerySpan = spans.find(
-                  s => s.data?.['sentry.origin'] === 'auto.db.prisma' && s.data?.['db.query.text'],
+                  s => s.attributes[SENTRY_ORIGIN]?.value === 'auto.db.prisma' && s.attributes[DB_QUERY_TEXT],
                 );
                 expect(prismaDbQuerySpan).toBeDefined();
                 const dbQueryParent = spans.find(s => s.span_id === prismaDbQuerySpan?.parent_span_id);
-                expect(dbQueryParent?.description).toBe('prisma:client:operation');
+                expect(dbQueryParent?.name).toBe('prisma:client:operation');
 
                 // Verify Prisma spans have the correct origin
-                const prismaSpans = spans.filter(span => span.data && span.data['sentry.origin'] === 'auto.db.prisma');
+                const prismaSpans = spans.filter(span => span.attributes[SENTRY_ORIGIN]?.value === 'auto.db.prisma');
                 expect(prismaSpans.length).toBeGreaterThanOrEqual(5);
 
                 // Check for key Prisma span descriptions
-                const spanDescriptions = prismaSpans.map(span => span.description);
+                const spanDescriptions = prismaSpans.map(span => span.name);
                 expect(spanDescriptions).toContain('prisma:client:operation');
                 expect(spanDescriptions).toContain('prisma:client:serialize');
                 expect(spanDescriptions).toContain('prisma:client:connect');
@@ -50,27 +59,45 @@ describe('Prisma ORM v7 Tests', () => {
                 // Verify the create operation has correct metadata
                 const createSpan = prismaSpans.find(
                   span =>
-                    span.description === 'prisma:client:operation' &&
-                    span.data?.['method'] === 'create' &&
-                    span.data?.['model'] === 'User',
+                    span.name === 'prisma:client:operation' &&
+                    span.attributes['method']?.value === 'create' &&
+                    span.attributes['model']?.value === 'User',
                 );
                 expect(createSpan).toBeDefined();
 
                 // Verify db_query span has system info and correct op (v7 uses db.system.name).
-                // The SDK should rewrite the span name to the actual SQL text (same as v5/v6
-                // `prisma:engine:db_query`), so we find it via op/origin rather than description.
+                // The SDK should rewrite the span name to the query summary (same as v5/v6
+                // `prisma:engine:db_query`), so we find it via op/origin rather than name.
                 const dbQuerySpan = prismaSpans.find(
-                  span => span.data?.['sentry.op'] === 'db' && span.data?.['db.query.text'],
+                  span => span.attributes[SENTRY_OP]?.value === DB && span.attributes[DB_QUERY_TEXT]?.value,
                 );
                 expect(dbQuerySpan).toBeDefined();
-                expect(dbQuerySpan?.data?.['db.system.name']).toBe('postgresql');
-                expect(dbQuerySpan?.op).toBe('db');
-                expect(dbQuerySpan?.description).toBe(dbQuerySpan?.data?.['db.query.text']);
-                expect(dbQuerySpan?.description).not.toBe('prisma:client:db_query');
+                expect(dbQuerySpan?.attributes[DB_SYSTEM_NAME]).toEqual({ type: 'string', value: 'postgresql' });
+                expect(dbQuerySpan?.attributes[SENTRY_OP]).toEqual({ type: 'string', value: DB });
+                expect(dbQuerySpan?.name).toBe(dbQuerySpan?.attributes[DB_QUERY_SUMMARY]?.value);
+                expect(dbQuerySpan?.name).not.toBe('prisma:client:db_query');
 
-                // The db query span name must always be rewritten to the SQL text; the raw client span
+                // The db query span name must always be rewritten to the query summary; the raw client span
                 // name should never leak through.
-                expect(spans.find(span => span.description === 'prisma:client:db_query')).toBeUndefined();
+                expect(spans.find(span => span.name === 'prisma:client:db_query')).toBeUndefined();
+
+                const querySpans = spans.filter(
+                  item => item.attributes[SENTRY_ORIGIN]?.value === 'auto.db.prisma' && item.attributes[DB_QUERY_TEXT],
+                );
+
+                expect(
+                  querySpans.map(span => ({
+                    name: span.name,
+                    summary: span.attributes[DB_QUERY_SUMMARY]?.value,
+                  })),
+                ).toEqual([
+                  { name: 'INSERT "public"."User"', summary: 'INSERT "public"."User"' },
+                  { name: 'SELECT "public"."User"', summary: 'SELECT "public"."User"' },
+                  { name: 'DELETE "public"."User"', summary: 'DELETE "public"."User"' },
+                ]);
+                querySpans.forEach(span => {
+                  expect(span.name).not.toBe(span.attributes[DB_QUERY_TEXT]?.value);
+                });
               },
             })
             .start()
@@ -89,63 +116,5 @@ describe('Prisma ORM v7 Tests', () => {
         copyPaths: ['prisma', 'prisma.config.ts'],
       },
     );
-
-    createEsmAndCjsTests(
-      __dirname,
-      'scenario.mjs',
-      'instrument-span-streaming.mjs',
-      (createRunner, test) => {
-        test(
-          'should name db query spans after the query summary with span streaming',
-          { timeout: 75_000 },
-          async () => {
-            await createRunner()
-              // Prisma's engine startup can outlast the span buffer's flush interval, so the query spans
-              // are not guaranteed to be in the first span envelope.
-              .unordered()
-              .expect({
-                span: container => {
-                  // v7 runs the queries through the `pg` adapter, whose own spans are named after the full
-                  // statement by a different integration, so they are filtered out here.
-                  const querySpans = container.items.filter(
-                    item =>
-                      item.attributes['sentry.origin']?.value === 'auto.db.prisma' && item.attributes['db.query.text'],
-                  );
-
-                  expect(
-                    querySpans.map(span => ({
-                      name: span.name,
-                      summary: span.attributes['db.query.summary']?.value,
-                    })),
-                  ).toEqual([
-                    { name: 'INSERT "public"."User"', summary: 'INSERT "public"."User"' },
-                    { name: 'SELECT "public"."User"', summary: 'SELECT "public"."User"' },
-                    { name: 'DELETE "public"."User"', summary: 'DELETE "public"."User"' },
-                  ]);
-
-                  // Neither the raw client span name nor the full statement may end up as a span name.
-                  expect(container.items.map(span => span.name)).not.toContain('prisma:client:db_query');
-                  querySpans.forEach(span => {
-                    expect(span.name).not.toBe(span.attributes['db.query.text']?.value);
-                  });
-                },
-              })
-              .start()
-              .completed();
-          },
-        );
-      },
-      {
-        additionalDependencies: {
-          '@prisma/adapter-pg': '7.2.0',
-          '@prisma/client': '7.2.0',
-          pg: '^8.11.0',
-          prisma: '7.2.0',
-          typescript: '^5.9.0',
-        },
-        afterSetupCommand: 'prisma generate --schema prisma/schema.prisma && tsc -p prisma/tsconfig.json',
-        copyPaths: ['prisma', 'prisma.config.ts'],
-      },
-    );
   });
 });

From 96b7733fc4ea1c7e7399c96b0ff230764dc91ea8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 8 Oct 2026 16:48:36 +0200
Subject: [PATCH 02/84] chore(deps): Bump next from 16.2.11 to 16.3.8 in
 /dev-packages/e2e-tests/test-applications/nextjs-16 (#25179)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [next](https://github.com/vercel/next.js) from 16.2.11 to 16.3.8.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a
href="https://github.com/vercel/next.js/releases">next's
releases</a>.</em></p>
<blockquote>
<h2>v16.3.8</h2>
<p>This release contains security fixes for the following
advisories:</p>
<p>High:</p>
<ul>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-cjq9-62q9-8jv4">Server-Side
Request Forgery in Image Optimization</a></li>
</ul>
<p>Medium:</p>
<ul>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-f87g-xv8r-7p7x">Information
disclosure in Next.js App Router metadata image routes via dynamicParams
bypass</a></li>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-4jqv-mc3x-m676">Cache
poisoning of SSG and ISR pages in self-hosted Next.js
applications</a></li>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-mcj8-r9mp-w47p">Cache
poisoning in Next.js SSG/ISR rendering leads to cross-user content
substitution and persistent denial of service</a></li>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-3w37-wq28-93x7">Pending
<code>use cache</code> fill can leak Draft Mode content into regular
responses and persisted pages</a></li>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-h694-7cp9-m8p3">Cache
leak across root param values in nested 'use cache' functions</a></li>
</ul>
<p>Low:</p>
<ul>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-39w2-rjm5-chcv">Information
disclosure in the Next.js development server's Model Context Protocol
endpoint</a></li>
</ul>
<h2>v16.3.7</h2>
<blockquote>
<p>[!NOTE]
This release is backporting bug fixes. It does <strong>not</strong>
include all pending features/changes on canary.</p>
</blockquote>
<h3>Core Changes</h3>
<ul>
<li>turbo-tasks-backend: fix strongly consistent read hanging on a
canceled task (<a
href="https://redirect.github.com/vercel/next.js/issues/98931">#98931</a>)</li>
</ul>
<h3>Credits</h3>
<p>Huge thanks to <a
href="https://github.com/lukesandberg"><code>@​lukesandberg</code></a>
for helping!</p>
<h2>v16.3.6</h2>
<p>This release contains a security fix for <a
href="https://github.com/vercel/next.js/security/advisories/GHSA-vcvr-r3jv-pc5j">GHSA-vcvr-r3jv-pc5j:
Remote Code Execution in next/og ImageResponse</a></p>
<h2>v16.3.5</h2>
<p>The following bug fixes have been backported. It does not include all
pending features/changes on canary.</p>
<ul>
<li>next/image: Skip 0-byte entries when initializing disk LRU cache (<a
href="https://redirect.github.com/vercel/next.js/issues/98185">#98185</a>)</li>
<li>next/image: Reject empty images when reading/writing to the disk
cache (<a
href="https://redirect.github.com/vercel/next.js/issues/98186">#98186</a>)</li>
<li>Emit whole-app server NFTs when <code>output: 'standalone'</code> is
used with an adapter (<a
href="https://redirect.github.com/vercel/next.js/issues/98167">#98167</a>)</li>
<li>Add CSP nonce to script tags of loading and template files (<a
href="https://redirect.github.com/vercel/next.js/issues/98403">#98403</a>)</li>
<li>Fix <code>use cache</code> prerender signal retention (<a
href="https://redirect.github.com/vercel/next.js/issues/98448">#98448</a>)</li>
</ul>
<h2>v16.3.4</h2>
<p>Follow-up release to <a
href="https://github.com/vercel/next.js/releases/tag/v16.3.3">v16.3.3</a>
re-enabling AVIF Image Optimization (<a
href="https://redirect.github.com/vercel/next.js/pull/97949">#97949</a>).</p>
<p>The following bug fixes have been backported. It does
<strong>not</strong> include all pending features/changes on canary.</p>
<ul>
<li>testmode: Fix infinite recursion in testmode passthrough fetch (<a
href="https://redirect.github.com/vercel/next.js/issues/97691">#97691</a>)</li>
<li>Fix build error when aliasing typescript to
<code>@​typescript/typescript6</code> (<a
href="https://redirect.github.com/vercel/next.js/issues/97997">#97997</a>)</li>
<li>Fix unset crossOrigin in Turbopack manifests (<a
href="https://redirect.github.com/vercel/next.js/issues/97930">#97930</a>)</li>
</ul>
<h3>Credits</h3>
<!-- raw HTML omitted -->
</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/vercel/next.js/commit/b0fad0d45eb4c4430fda5eeeb442e8a5af08a5f6"><code>b0fad0d</code></a>
v16.3.8</li>
<li><a
href="https://github.com/vercel/next.js/commit/719e4c67d6e92df60246f95e1d96e2dd60789a52"><code>719e4c6</code></a>
[lts-active] Scope response cache keys to their source route (<a
href="https://redirect.github.com/vercel/next.js/issues/218">#218</a>)</li>
<li><a
href="https://github.com/vercel/next.js/commit/e92db4536a7f34ae2dbda583cfa1b4e0d06d1865"><code>e92db45</code></a>
[lts-active] Fix metadata propagation for deduplicated nested caches (<a
href="https://redirect.github.com/vercel/next.js/issues/223">#223</a>)</li>
<li><a
href="https://github.com/vercel/next.js/commit/40c2ba904289a65ed2fd4633c5dfb1bdc29b52de"><code>40c2ba9</code></a>
[lts-active] Match Next data paths case-sensitively (<a
href="https://redirect.github.com/vercel/next.js/issues/196">#196</a>)</li>
<li><a
href="https://github.com/vercel/next.js/commit/2d9f50a409312696145b82b3157aadb6b1fef476"><code>2d9f50a</code></a>
[lts-active] Fix MCP middleware DNS rebinding (<a
href="https://redirect.github.com/vercel/next.js/issues/213">#213</a>)</li>
<li><a
href="https://github.com/vercel/next.js/commit/bd9214f9a32854a011bf5fe58e481dffe1bbf598"><code>bd9214f</code></a>
[lts-active] Fix draft mode leaks through cross-request <code>'use
cache'</code> dedupli...</li>
<li><a
href="https://github.com/vercel/next.js/commit/8db4a627c91e718514406ff5644ea4985dcaaae0"><code>8db4a62</code></a>
[lts-active][webpack] Ensure <code>dynamicParams</code> is respected in
`opengraph-image...</li>
<li><a
href="https://github.com/vercel/next.js/commit/e002ad68bd676bb0ed0c87bb22e3590304763e0b"><code>e002ad6</code></a>
[lts-active] fix(next/image): Pin DNS resolution when fetching external
image...</li>
<li><a
href="https://github.com/vercel/next.js/commit/4c20699e29178d444994cf5a31b8a617ca3a2c80"><code>4c20699</code></a>
v16.3.7</li>
<li><a
href="https://github.com/vercel/next.js/commit/2521aec5815e7de2121db253d12dae9f13e25361"><code>2521aec</code></a>
[backport] turbo-tasks-backend: fix strongly consistent read hanging on
a can...</li>
<li>Additional commits viewable in <a
href="https://github.com/vercel/next.js/compare/v16.2.11...v16.3.8">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=next&package-manager=npm_and_yarn&previous-version=16.2.11&new-version=16.3.8)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the
[Security Alerts
page](https://github.com/getsentry/sentry-javascript/network/alerts).

</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 dev-packages/e2e-tests/test-applications/nextjs-16/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/package.json b/dev-packages/e2e-tests/test-applications/nextjs-16/package.json
index 80f92437f500..3bb7511d8197 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/package.json
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/package.json
@@ -36,7 +36,7 @@
     "ai": "^3.0.0",
     "import-in-the-middle": "^2",
     "ioredis": "5.10.1",
-    "next": "16.2.11",
+    "next": "16.3.8",
     "openai": "5.18.1",
     "pg": "^8.13.1",
     "react": "19.1.0",

From 032de38948c289596c9c0feeaf7389b1a444af68 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 09:31:13 +0200
Subject: [PATCH 03/84] test(node): Port HTTP propagation and transport suites
 to streaming (#25197)

Run propagation-target, baggage org ID, proxy, and IPv6 coverage with
span streaming.

Part of #24135

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 dev-packages/node-integration-tests/suites/ipv6/scenario.ts   | 1 -
 dev-packages/node-integration-tests/suites/proxy/basic.js     | 1 -
 .../baggage-org-id/server-no-explicit-org-id.ts               | 1 -
 .../baggage-org-id/server-no-org-id.ts                        | 1 -
 .../tracing/tracePropagationTargets/baggage-org-id/server.ts  | 1 -
 .../suites/tracing/tracePropagationTargets/scenario.ts        | 1 -
 .../suites/tracing/tracePropagationTargets/test.ts            | 4 ++--
 7 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/ipv6/scenario.ts b/dev-packages/node-integration-tests/suites/ipv6/scenario.ts
index 598e487ea990..0023a1bc4b48 100644
--- a/dev-packages/node-integration-tests/suites/ipv6/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/ipv6/scenario.ts
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@[2001:db8::1]/1337',
   defaultIntegrations: false,
   sendClientReports: false,
diff --git a/dev-packages/node-integration-tests/suites/proxy/basic.js b/dev-packages/node-integration-tests/suites/proxy/basic.js
index 45a8a43fd880..aaa0a958554e 100644
--- a/dev-packages/node-integration-tests/suites/proxy/basic.js
+++ b/dev-packages/node-integration-tests/suites/proxy/basic.js
@@ -7,7 +7,6 @@ proxy.listen(0, () => {
   const proxyPort = proxy.address().port;
 
   Sentry.init({
-    traceLifecycle: 'static',
     dsn: process.env.SENTRY_DSN,
     transportOptions: {
       proxy: `http://localhost:${proxyPort}`,
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server-no-explicit-org-id.ts b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server-no-explicit-org-id.ts
index 2446388da0fd..40c29de4d5b4 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server-no-explicit-org-id.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server-no-explicit-org-id.ts
@@ -4,7 +4,6 @@ import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry
 export type TestAPIResponse = { test_data: { host: string; 'sentry-trace': string; baggage: string } };
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@o01234987.ingest.sentry.io/1337',
   release: '1.0',
   environment: 'prod',
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server-no-org-id.ts b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server-no-org-id.ts
index 82ede5bb97b3..107ba3605c6b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server-no-org-id.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server-no-org-id.ts
@@ -4,7 +4,6 @@ import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry
 export type TestAPIResponse = { test_data: { host: string; 'sentry-trace': string; baggage: string } };
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@public.ingest.sentry.io/1337',
   release: '1.0',
   environment: 'prod',
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server.ts b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server.ts
index 5f9aa1397b38..d2b593da513f 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/server.ts
@@ -4,7 +4,6 @@ import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry
 export type TestAPIResponse = { test_data: { host: string; 'sentry-trace': string; baggage: string } };
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@o0000987.ingest.sentry.io/1337',
   release: '1.0',
   environment: 'prod',
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/scenario.ts b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/scenario.ts
index bb87c3096aa0..c31007afe9d0 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/scenario.ts
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts
index dc5105c9d1bb..4ef1bb6c4bfe 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts
@@ -29,8 +29,8 @@ test('HttpIntegration should instrument correct requests when tracePropagationTa
   await createRunner(__dirname, 'scenario.ts')
     .withEnv({ SERVER_URL })
     .expect({
-      transaction: {
-        // we're not too concerned with the actual transaction here since this is tested elsewhere
+      span: {
+        // Span contents are tested elsewhere.
       },
     })
     .start()

From c068f721ea0cc4cba1dec1778632be515fbc5d84 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 09:36:32 +0200
Subject: [PATCH 04/84] docs: Scope pre-PR tests to affected suites (#25198)

My agent keeps running the full repository test suite locally before
opening PRs, which is quite the waste of time and CPU.

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 AGENTS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/AGENTS.md b/AGENTS.md
index c1ac68c704ff..8d307c72d452 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -55,7 +55,7 @@ Uses **Git Flow** (see `docs/gitflow.md`).
 1. `yarn format`
 2. `yarn build:dev`
 3. `yarn lint`
-4. `yarn test`
+4. Run the unit and integration/E2E tests for the affected packages.
 5. NEVER push on `develop`
 
 ## Pull Requests

From 9d6d6f9b010a9cc4513f58f8b728d043d7fb9eb5 Mon Sep 17 00:00:00 2001
From: Charly Gomez <charly.gomez1310@gmail.com>
Date: Fri, 9 Oct 2026 09:45:19 +0200
Subject: [PATCH 05/84] ci: Run lint steps in parallel (#25187)

The Lint job ran its three lint steps one after another, about 59s in
total on `develop` (source 10s, ES compatibility 17s, types 32s). They
don't depend on each other, so this uses the new [parallel
steps](https://github.blog/changelog/2026-06-25-actions-steps-can-now-be-run-in-parallel/)
to run them together. The job should take about as long as the slowest
step, around 32s.

This is the first of several small PRs that use parallel steps in CI. I
kept each one separate so a problem with the new syntax only affects one
job.

Refs
[JS-3888](https://linear.app/getsentry/issue/JS-3888/investigate-running-action-steps-in-parallel-for-ci-wall-time)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/build.yml | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index a37d3618311f..9a4147ac902e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -337,12 +337,13 @@ jobs:
         uses: ./.github/actions/restore-cache
         with:
           dependency_cache_key: ${{ needs.job_build.outputs.dependency_cache_key }}
-      - name: Lint source files
-        run: yarn lint
-      - name: Lint for ES compatibility
-        run: yarn lint:es-compatibility
-      - name: Lint types
-        run: yarn lint:types
+      - parallel:
+          - name: Lint source files
+            run: yarn lint
+          - name: Lint for ES compatibility
+            run: yarn lint:es-compatibility
+          - name: Lint types
+            run: yarn lint:types
 
   job_check_lockfile:
     name: Check lockfile

From 3a61fbbfd9b7cc0fb30316eb62a8c8a272cf64af Mon Sep 17 00:00:00 2001
From: Sigrid <32902192+s1gr1d@users.noreply.github.com>
Date: Fri, 9 Oct 2026 10:20:43 +0200
Subject: [PATCH 06/84] feat(nuxt): Detect the server API with `@nuxt/kit` 4.6
 (#25138)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps `@nuxt/kit` to `^4.6.0` for `resolveServerVariant`. The Vite
server and other non-Nitro builders need this server-API detection.

Looks like a lot of code changes, but most of it is just moved code.
Those are the important parts:

- `resolveServerApi()` replaces `getNitroMajorVersion` and the
`local-pkg` dependency (we can get the nitro version from there). This
is actually the most important and biggest change in the PR.
- On the `nuxt` server API (no Nitro), the module skips all Nitro setup.
With this, Kit prints no `NUXT_B8024` warnings
- `addServerPlugin` → `addNitroPlugin`. Kit 4.6 deprecates the old name,
and the behavior is the same
- all nitro-related code moves to `nitroServer.ts`

Part of https://github.com/getsentry/sentry-javascript/issues/25072
---
 packages/nuxt/package.json                    |   5 +-
 packages/nuxt/src/module.ts                   | 108 ++-------------
 packages/nuxt/src/vite/addServerConfig.ts     |   4 +-
 packages/nuxt/src/vite/databaseConfig.ts      |   6 +-
 packages/nuxt/src/vite/nitroServer.ts         | 124 ++++++++++++++++++
 packages/nuxt/src/vite/storageConfig.ts       |   6 +-
 packages/nuxt/src/vite/utils.ts               |  46 ++-----
 .../nuxt/test/vite/addServerConfig.test.ts    |  23 +++-
 .../nuxt/test/vite/databaseConfig.test.ts     |   2 +-
 packages/nuxt/test/vite/nitroServer.test.ts   | 100 ++++++++++++++
 packages/nuxt/test/vite/nitroVersion.test.ts  | 107 ---------------
 packages/nuxt/test/vite/serverApi.test.ts     |  67 ++++++++++
 yarn.lock                                     | 108 ++++++++-------
 13 files changed, 401 insertions(+), 305 deletions(-)
 create mode 100644 packages/nuxt/src/vite/nitroServer.ts
 create mode 100644 packages/nuxt/test/vite/nitroServer.test.ts
 delete mode 100644 packages/nuxt/test/vite/nitroVersion.test.ts
 create mode 100644 packages/nuxt/test/vite/serverApi.test.ts

diff --git a/packages/nuxt/package.json b/packages/nuxt/package.json
index 9aa3adb592a7..b5b642144827 100644
--- a/packages/nuxt/package.json
+++ b/packages/nuxt/package.json
@@ -53,7 +53,7 @@
     }
   },
   "dependencies": {
-    "@nuxt/kit": "^4.5.2",
+    "@nuxt/kit": "^4.6.0",
     "@sentry/browser": "11.6.0",
     "@sentry/cloudflare": "11.6.0",
     "@sentry/conventions": "^0.26.0",
@@ -62,8 +62,7 @@
     "@sentry/bundler-plugins": "11.6.0",
     "@sentry/server-runtime-injection": "11.6.0",
     "@sentry/server-utils": "11.6.0",
-    "@sentry/vue": "11.6.0",
-    "local-pkg": "^1.1.2"
+    "@sentry/vue": "11.6.0"
   },
   "devDependencies": {
     "@nuxt/nitro-server": "^3.21.11",
diff --git a/packages/nuxt/src/module.ts b/packages/nuxt/src/module.ts
index bea829d335fe..f1cd456b84c6 100644
--- a/packages/nuxt/src/module.ts
+++ b/packages/nuxt/src/module.ts
@@ -1,31 +1,13 @@
-import {
-  addPlugin,
-  addPluginTemplate,
-  addServerPlugin,
-  addTemplate,
-  addVitePlugin,
-  createResolver,
-  defineNuxtModule,
-} from '@nuxt/kit';
+import { addPlugin, addPluginTemplate, addTemplate, addVitePlugin, createResolver, defineNuxtModule } from '@nuxt/kit';
 // Needed to make TS evaluate the augmentation of Nitro types (https://github.com/nuxt/nuxt/pull/34039)
 import type {} from '@nuxt/nitro-server';
 
-import { consoleSandbox } from '@sentry/core';
 import * as path from 'path';
 import type { SentryNuxtModuleOptions } from './common/types';
-import {
-  addDynamicImportEntryFileWrapper,
-  addServerConfigShimWithWarning,
-  addSentryTopImport,
-  addServerConfigPlugin,
-  addServerConfigToBuild,
-} from './vite/addServerConfig';
-import { addDatabaseInstrumentation } from './vite/databaseConfig';
-import { addMiddlewareImports, addMiddlewareInstrumentation } from './vite/middlewareConfig';
+import { setupNitroServer } from './vite/nitroServer';
 import { setupOrchestrion } from './vite/orchestrion';
 import { setupSourceMaps } from './vite/sourceMaps';
-import { addStorageInstrumentation } from './vite/storageConfig';
-import { addOTelCommonJSImportAlias, findDefaultSdkInitFile, getNitroMajorVersion } from './vite/utils';
+import { addOTelCommonJSImportAlias, findDefaultSdkInitFile, resolveServerApi } from './vite/utils';
 
 export type ModuleOptions = SentryNuxtModuleOptions;
 type NuxtPageSubset = { file?: string; path: string };
@@ -44,6 +26,8 @@ export default defineNuxtModule<ModuleOptions>({
       return;
     }
 
+    const serverApi = resolveServerApi();
+
     const moduleOptions = {
       ...moduleOptionsParam,
       // oxlint-disable-next-line typescript/no-deprecated -- supported until removal
@@ -91,7 +75,6 @@ export default defineNuxtModule<ModuleOptions>({
     }
 
     const serverConfigFile = await findDefaultSdkInitFile('server', nuxt, moduleOptions);
-    const isNitroV3 = (await getNitroMajorVersion(nuxt.options.rootDir)) >= 3;
     const nuxtMajor = parseInt((nuxt as unknown as { _version: string })._version?.split('.')[0] ?? '3', 10);
     const isMinNuxtV4 = nuxtMajor >= 4;
 
@@ -100,43 +83,21 @@ export default defineNuxtModule<ModuleOptions>({
     // Cloudflare detection happens inside, keyed off the resolved Nitro preset.
     setupOrchestrion(nuxt, !!serverConfigFile, moduleOptions.buildTimeInstrumentation);
 
-    // The deprecated inject modes replace the default in-bundle initialization until their removal
-    const usesDeprecatedInjectMode =
-      moduleOptions.autoInjectServerSentry === 'top-level-import' ||
-      moduleOptions.autoInjectServerSentry === 'experimental_dynamic-import';
-
     if (serverConfigFile) {
-      if (!usesDeprecatedInjectMode) {
-        addServerConfigPlugin(nuxt, serverConfigFile, !isNitroV3);
-      }
-
-      if (isNitroV3) {
-        addServerPlugin(moduleDirResolver.resolve('./runtime/plugins/handler.server'));
-        addServerPlugin(moduleDirResolver.resolve('./runtime/plugins/update-route-name.server'));
-      } else {
-        addServerPlugin(moduleDirResolver.resolve('./runtime/plugins/handler-legacy.server'));
-        addServerPlugin(moduleDirResolver.resolve('./runtime/plugins/update-route-name-legacy.server'));
-      }
-
-      addServerPlugin(moduleDirResolver.resolve('./runtime/plugins/sentry.server'));
+      setupNitroServer(nuxt, serverApi, serverConfigFile, moduleOptions);
 
       if (isMinNuxtV4) {
         addPlugin({ src: moduleDirResolver.resolve('./runtime/plugins/route-detector.server'), mode: 'server' });
       } else {
         addPlugin({ src: moduleDirResolver.resolve('./runtime/plugins/route-detector-legacy.server'), mode: 'server' });
       }
-
-      // Preps the middleware instrumentation module.
-      addMiddlewareImports();
-      addStorageInstrumentation(nuxt, !isNitroV3);
-      addDatabaseInstrumentation(nuxt.options.nitro, !isNitroV3, moduleOptions);
     }
 
     if (clientConfigFile || serverConfigFile) {
       setupSourceMaps(moduleOptions, nuxt, addVitePlugin);
     }
 
-    addOTelCommonJSImportAlias(nuxt, isNitroV3);
+    addOTelCommonJSImportAlias(nuxt, serverApi === 'nitro3');
 
     let pagesData: NuxtPageSubset[] = [];
 
@@ -155,8 +116,8 @@ export default defineNuxtModule<ModuleOptions>({
       // Vite virtual plugin (for the Vite SSR build, where addPlugin mode:'server' plugins are bundled)
       addVitePlugin({
         name: 'sentry-nuxt-pages-data-virtual',
-        resolveId: id => (id === pagesDataVirtualModuleId ? `\0${pagesDataVirtualModuleId}` : null),
-        load: id =>
+        resolveId: (id: string) => (id === pagesDataVirtualModuleId ? `\0${pagesDataVirtualModuleId}` : null),
+        load: (id: string) =>
           id === `\0${pagesDataVirtualModuleId}` ? `export default ${JSON.stringify(pagesData, null, 2)};` : undefined,
       });
     } else {
@@ -186,56 +147,5 @@ export default defineNuxtModule<ModuleOptions>({
         tsConfig.include.push(relativePath);
       }
     });
-
-    nuxt.hooks.hook('nitro:init', nitro => {
-      if (nuxt.options?._prepare) {
-        return;
-      }
-
-      if (serverConfigFile) {
-        addMiddlewareInstrumentation(nitro, isNitroV3);
-
-        if (!usesDeprecatedInjectMode) {
-          addServerConfigShimWithWarning(nitro);
-
-          if (moduleOptions.debug) {
-            consoleSandbox(() => {
-              // eslint-disable-next-line no-console
-              console.log(
-                `[Sentry] Bundled \`${serverConfigFile}\` into the Nitro server build. The SDK initializes itself at server startup — no \`node --import\` preload needed.`,
-              );
-            });
-          }
-        } else {
-          consoleSandbox(() => {
-            // eslint-disable-next-line no-console
-            console.warn(
-              `[Sentry] \`autoInjectServerSentry: '${moduleOptions.autoInjectServerSentry}'\` is deprecated and will be removed in a future major version. The Sentry server config is bundled into the Nitro server build by default now. Remove the option to use the default behavior.`,
-            );
-          });
-
-          if (moduleOptions.autoInjectServerSentry === 'top-level-import') {
-            // Nitro 3 (in Nuxt 5) is not bundled in dev mode, so there is no build to emit into.
-            if (!(isNitroV3 && nitro.options.dev)) {
-              addServerConfigToBuild(moduleOptions, nitro, serverConfigFile);
-            }
-            addSentryTopImport(moduleOptions, nitro);
-          }
-
-          if (moduleOptions.autoInjectServerSentry === 'experimental_dynamic-import') {
-            addDynamicImportEntryFileWrapper(nitro, serverConfigFile, moduleOptions);
-
-            if (moduleOptions.debug) {
-              consoleSandbox(() => {
-                // eslint-disable-next-line no-console
-                console.log(
-                  '[Sentry] Wrapping the server entry file with a dynamic `import()`, so Sentry can be preloaded before the server initializes.',
-                );
-              });
-            }
-          }
-        }
-      }
-    });
   },
 });
diff --git a/packages/nuxt/src/vite/addServerConfig.ts b/packages/nuxt/src/vite/addServerConfig.ts
index 7b90d568216c..7b0970ef3f6d 100644
--- a/packages/nuxt/src/vite/addServerConfig.ts
+++ b/packages/nuxt/src/vite/addServerConfig.ts
@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { basename } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { addServerPlugin, addTemplate, createResolver } from '@nuxt/kit';
+import { addNitroPlugin, addTemplate, createResolver } from '@nuxt/kit';
 import type { Nuxt } from '@nuxt/schema';
 import { consoleSandbox, debug } from '@sentry/core';
 import * as fs from 'fs';
@@ -132,7 +132,7 @@ export function addServerConfigPlugin(nuxt: Nuxt, serverConfigFile: string, isLe
       `import ${JSON.stringify(runtimeFlagsTemplate.dst)};\nimport ${JSON.stringify(configPath)};\nexport default () => {};\n`,
   });
 
-  addServerPlugin(configPluginTemplate.dst);
+  addNitroPlugin(configPluginTemplate.dst);
 
   // Nitro v2 treeshakes side-effect-only imports outside its runtime dir, which would silently drop
   // the top-level `Sentry.init` and the flag assignments.
diff --git a/packages/nuxt/src/vite/databaseConfig.ts b/packages/nuxt/src/vite/databaseConfig.ts
index b025157339b3..54f83943191f 100644
--- a/packages/nuxt/src/vite/databaseConfig.ts
+++ b/packages/nuxt/src/vite/databaseConfig.ts
@@ -1,4 +1,4 @@
-import { addServerPlugin, createResolver } from '@nuxt/kit';
+import { addNitroPlugin, createResolver } from '@nuxt/kit';
 import { consoleSandbox } from '@sentry/core';
 import type { NitroConfig } from 'nitropack/types';
 import type { SentryNuxtModuleOptions } from '../common/types';
@@ -43,8 +43,8 @@ export function addDatabaseInstrumentation(
   });
 
   if (isLegacyNitro) {
-    addServerPlugin(createResolver(import.meta.url).resolve('./runtime/plugins/database-legacy.server'));
+    addNitroPlugin(createResolver(import.meta.url).resolve('./runtime/plugins/database-legacy.server'));
   } else {
-    addServerPlugin(createResolver(import.meta.url).resolve('./runtime/plugins/database.server'));
+    addNitroPlugin(createResolver(import.meta.url).resolve('./runtime/plugins/database.server'));
   }
 }
diff --git a/packages/nuxt/src/vite/nitroServer.ts b/packages/nuxt/src/vite/nitroServer.ts
new file mode 100644
index 000000000000..c999b29cd186
--- /dev/null
+++ b/packages/nuxt/src/vite/nitroServer.ts
@@ -0,0 +1,124 @@
+import { addNitroPlugin, createResolver } from '@nuxt/kit';
+import type { Nuxt } from '@nuxt/schema';
+import { consoleSandbox } from '@sentry/core';
+import type { Nitro } from 'nitropack/types';
+import type { SentryNuxtModuleOptions } from '../common/types';
+import {
+  addDynamicImportEntryFileWrapper,
+  addSentryTopImport,
+  addServerConfigPlugin,
+  addServerConfigShimWithWarning,
+  addServerConfigToBuild,
+} from './addServerConfig';
+import { addDatabaseInstrumentation } from './databaseConfig';
+import { addMiddlewareImports, addMiddlewareInstrumentation } from './middlewareConfig';
+import { addStorageInstrumentation } from './storageConfig';
+import type { ServerApi } from './utils';
+
+type NitroModuleOptions = Omit<SentryNuxtModuleOptions, 'experimental_entrypointWrappedFunctions'> &
+  Required<Pick<SentryNuxtModuleOptions, 'experimental_entrypointWrappedFunctions'>>;
+
+/**
+ * Sets up the server SDK on the Nitro side: the server config plugin, the server plugins, and the
+ * middleware, storage and database instrumentation.
+ *
+ * A host on the `nuxt` server API runs no Nitro, so it gets none of this. Kit would skip each
+ * Nitro-only registration there with a `NUXT_B8024` warning.
+ */
+export function setupNitroServer(
+  nuxt: Nuxt,
+  serverApi: ServerApi,
+  serverConfigFile: string,
+  moduleOptions: NitroModuleOptions,
+): void {
+  if (serverApi === 'nuxt') {
+    return;
+  }
+
+  const isNitroV3 = serverApi === 'nitro3';
+  const moduleDirResolver = createResolver(import.meta.url);
+  // oxlint-disable-next-line typescript/no-deprecated -- supported until removal
+  const injectMode = moduleOptions.autoInjectServerSentry;
+  // The deprecated inject modes replace the default in-bundle initialization until their removal
+  const deprecatedInjectMode =
+    injectMode === 'top-level-import' || injectMode === 'experimental_dynamic-import' ? injectMode : undefined;
+
+  if (!deprecatedInjectMode) {
+    addServerConfigPlugin(nuxt, serverConfigFile, !isNitroV3);
+  }
+
+  if (isNitroV3) {
+    addNitroPlugin(moduleDirResolver.resolve('./runtime/plugins/handler.server'));
+    addNitroPlugin(moduleDirResolver.resolve('./runtime/plugins/update-route-name.server'));
+  } else {
+    addNitroPlugin(moduleDirResolver.resolve('./runtime/plugins/handler-legacy.server'));
+    addNitroPlugin(moduleDirResolver.resolve('./runtime/plugins/update-route-name-legacy.server'));
+  }
+
+  addNitroPlugin(moduleDirResolver.resolve('./runtime/plugins/sentry.server'));
+
+  // Preps the middleware instrumentation module.
+  addMiddlewareImports();
+  addStorageInstrumentation(nuxt, !isNitroV3);
+  addDatabaseInstrumentation(nuxt.options.nitro, !isNitroV3, moduleOptions);
+
+  nuxt.hooks.hook('nitro:init', nitro => {
+    if (nuxt.options?._prepare) {
+      return;
+    }
+
+    addMiddlewareInstrumentation(nitro, isNitroV3);
+
+    if (deprecatedInjectMode) {
+      setupDeprecatedInjectMode(nitro, deprecatedInjectMode, isNitroV3, serverConfigFile, moduleOptions);
+      return;
+    }
+
+    addServerConfigShimWithWarning(nitro);
+
+    if (moduleOptions.debug) {
+      consoleSandbox(() => {
+        // eslint-disable-next-line no-console
+        console.log(
+          `[Sentry] Bundled \`${serverConfigFile}\` into the Nitro server build. The SDK initializes itself at server startup — no \`node --import\` preload needed.`,
+        );
+      });
+    }
+  });
+}
+
+function setupDeprecatedInjectMode(
+  nitro: Nitro,
+  injectMode: 'top-level-import' | 'experimental_dynamic-import',
+  isNitroV3: boolean,
+  serverConfigFile: string,
+  moduleOptions: NitroModuleOptions,
+): void {
+  consoleSandbox(() => {
+    // eslint-disable-next-line no-console
+    console.warn(
+      `[Sentry] \`autoInjectServerSentry: '${injectMode}'\` is deprecated and will be removed in a future major version. The Sentry server config is bundled into the Nitro server build by default now. Remove the option to use the default behavior.`,
+    );
+  });
+
+  if (injectMode === 'top-level-import') {
+    // Nitro 3 (in Nuxt 5) is not bundled in dev mode, so there is no build to emit into.
+    if (!(isNitroV3 && nitro.options.dev)) {
+      addServerConfigToBuild(moduleOptions, nitro, serverConfigFile);
+    }
+    addSentryTopImport(moduleOptions, nitro);
+  }
+
+  if (injectMode === 'experimental_dynamic-import') {
+    addDynamicImportEntryFileWrapper(nitro, serverConfigFile, moduleOptions);
+
+    if (moduleOptions.debug) {
+      consoleSandbox(() => {
+        // eslint-disable-next-line no-console
+        console.log(
+          '[Sentry] Wrapping the server entry file with a dynamic `import()`, so Sentry can be preloaded before the server initializes.',
+        );
+      });
+    }
+  }
+}
diff --git a/packages/nuxt/src/vite/storageConfig.ts b/packages/nuxt/src/vite/storageConfig.ts
index 393f8b12e59b..517c7884e36c 100644
--- a/packages/nuxt/src/vite/storageConfig.ts
+++ b/packages/nuxt/src/vite/storageConfig.ts
@@ -1,4 +1,4 @@
-import { addServerPlugin, createResolver } from '@nuxt/kit';
+import { addNitroPlugin, createResolver } from '@nuxt/kit';
 import type { Nuxt } from '@nuxt/schema';
 import { addServerTemplate } from '../vendor/server-template';
 
@@ -18,8 +18,8 @@ export function addStorageInstrumentation(nuxt: Nuxt, isLegacyNitro: boolean): v
   });
 
   if (isLegacyNitro) {
-    addServerPlugin(moduleDirResolver.resolve('./runtime/plugins/storage-legacy.server'));
+    addNitroPlugin(moduleDirResolver.resolve('./runtime/plugins/storage-legacy.server'));
   } else {
-    addServerPlugin(moduleDirResolver.resolve('./runtime/plugins/storage.server'));
+    addNitroPlugin(moduleDirResolver.resolve('./runtime/plugins/storage.server'));
   }
 }
diff --git a/packages/nuxt/src/vite/utils.ts b/packages/nuxt/src/vite/utils.ts
index 4c95658e48b3..cab39bc95f19 100644
--- a/packages/nuxt/src/vite/utils.ts
+++ b/packages/nuxt/src/vite/utils.ts
@@ -4,45 +4,19 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'node:url';
 import type { SentryNuxtModuleOptions } from '../common/types';
-import { resolvePath } from '@nuxt/kit';
+import { resolvePath, resolveServerVariant } from '@nuxt/kit';
 
-/**
- * Gets the major version of the Nitro package used by the app's Nuxt installation.
- * Returns 2 as the default if the version cannot be determined.
- *
- * Nitro v2 is published as `nitropack`, v3 as `nitro`. Resolving `nitro` directly is
- * unreliable: module resolution walks up the directory tree, so in a monorepo an
- * unrelated `nitro` v3 above the app wins even when the app's Nuxt uses `nitropack` v2.
- * Instead, follow the dependency chain Nuxt itself imports Nitro through:
- * `nuxt` -> (`@nuxt/nitro-server` ->) `nitro` | `nitropack`.
- */
-export async function getNitroMajorVersion(rootDir: string): Promise<number> {
-  try {
-    const { getPackageInfo } = await import('local-pkg');
-
-    // `paths` entries must point at a file: for a bare directory, resolution starts at the
-    // directory's parent and skips the directory's own `node_modules`, so a hoisted copy higher
-    // up the tree (e.g. a monorepo root) wins over the app's actual dependency.
-    const fromPackage = (dir: string): { paths: string[] } => ({ paths: [path.join(dir, 'package.json')] });
-
-    // The package that declares the Nitro dependency: `nuxt` itself, or `@nuxt/nitro-server` (Nuxt >= 3.21) when nuxt delegates to it
-    let provider = await getPackageInfo('nuxt', fromPackage(rootDir));
-    if (provider?.packageJson.dependencies?.['@nuxt/nitro-server']) {
-      provider = (await getPackageInfo('@nuxt/nitro-server', fromPackage(provider.rootPath))) ?? provider;
-    }
+const SERVER_API_VARIANTS = { nitro2: 'nitro2', nitro3: 'nitro3', nuxt: 'nuxt' } as const;
 
-    if (!provider?.packageJson.dependencies?.nitro) {
-      return 2;
-    }
+/** The upstream server API the host runs. `nuxt` means the host runs no Nitro, for example the Vite server. */
+export type ServerApi = keyof typeof SERVER_API_VARIANTS;
 
-    const info = await getPackageInfo('nitro', fromPackage(provider.rootPath));
-    const major = parseInt(info?.version?.split('.')[0] ?? '', 10);
-    // The provider imports `nitro` (not `nitropack`), so it is at least v3 even if the version is unreadable
-    return isNaN(major) ? 3 : major;
-  } catch {
-    // If local-pkg is unavailable or resolution fails, default to v2
-    return 2;
-  }
+/**
+ * Resolves the server API of the current Nuxt host. Call it once in the module setup and pass the result on.
+ */
+export function resolveServerApi(): ServerApi {
+  // Kit returns `undefined` only when the host runs none of the given keys, and every host runs one of these.
+  return resolveServerVariant(SERVER_API_VARIANTS) ?? 'nitro2';
 }
 
 /**
diff --git a/packages/nuxt/test/vite/addServerConfig.test.ts b/packages/nuxt/test/vite/addServerConfig.test.ts
index 655c5b96ccb3..d73e66af2530 100644
--- a/packages/nuxt/test/vite/addServerConfig.test.ts
+++ b/packages/nuxt/test/vite/addServerConfig.test.ts
@@ -114,11 +114,11 @@ describe('wrapEntryWithDynamicImport', () => {
 });
 
 const addTemplateMock = vi.hoisted(() => vi.fn());
-const addServerPluginMock = vi.hoisted(() => vi.fn());
+const addNitroPluginMock = vi.hoisted(() => vi.fn());
 
 vi.mock('@nuxt/kit', () => ({
   addTemplate: addTemplateMock,
-  addServerPlugin: addServerPluginMock,
+  addNitroPlugin: addNitroPluginMock,
   // `@nuxt/kit` resolves rather than joins, which is what lets an absolute layer path win over the base.
   createResolver: (base: string) => ({ resolve: (input: string) => path.resolve(base, input) }),
 }));
@@ -167,7 +167,7 @@ describe('addServerConfigPlugin', () => {
     expect(templateContents('sentry-server-config-plugin.mjs')).toBe(
       `import ${JSON.stringify(flagsDst)};\nimport ${JSON.stringify(APP_CONFIG)};\nexport default () => {};\n`,
     );
-    expect(addServerPluginMock).toHaveBeenCalledWith(pluginDst);
+    expect(addNitroPluginMock).toHaveBeenCalledWith(pluginDst);
   });
 
   it('derives the runtime flags from the build-time `import.meta` values', () => {
@@ -256,6 +256,23 @@ describe('addServerConfigPlugin', () => {
     consoleWarnSpy.mockRestore();
   });
 
+  it('removes the plugin on `nitro:init` when Nuxt adds the server plugins after `nitro:config` (Nuxt >= 4.6)', () => {
+    const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const { nuxt, hooks } = createFakeNuxt();
+    const serverPlugins: string[] = [];
+    addNitroPluginMock.mockImplementationOnce((plugin: string) => serverPlugins.push(plugin));
+    addServerConfigPlugin(nuxt, APP_CONFIG, true);
+    const nitroConfig: NitroConfig = { preset: 'cloudflare_module', plugins: ['other-plugin.mjs'] };
+
+    hooks['nitro:config']!(nitroConfig);
+    // Nuxt's `collectServerRegistrations` runs after `nitro:config`, so the early filter cannot see the plugin
+    const nitro = { options: { preset: 'cloudflare_module', plugins: [...nitroConfig.plugins!, ...serverPlugins] } };
+    hooks['nitro:init']!(nitro as never);
+
+    expect(nitro.options.plugins).toEqual(['other-plugin.mjs']);
+    consoleWarnSpy.mockRestore();
+  });
+
   it('keeps the plugin when the resolved preset is not Cloudflare', () => {
     const { nuxt, hooks } = createFakeNuxt();
     addServerConfigPlugin(nuxt, APP_CONFIG, true);
diff --git a/packages/nuxt/test/vite/databaseConfig.test.ts b/packages/nuxt/test/vite/databaseConfig.test.ts
index e987ab3984a5..df66e7f180c3 100644
--- a/packages/nuxt/test/vite/databaseConfig.test.ts
+++ b/packages/nuxt/test/vite/databaseConfig.test.ts
@@ -8,7 +8,7 @@ vi.mock('@sentry/core', () => ({
 }));
 
 vi.mock('@nuxt/kit', () => ({
-  addServerPlugin: vi.fn(),
+  addNitroPlugin: vi.fn(),
   createResolver: vi.fn(() => ({
     resolve: vi.fn((path: string) => path),
   })),
diff --git a/packages/nuxt/test/vite/nitroServer.test.ts b/packages/nuxt/test/vite/nitroServer.test.ts
new file mode 100644
index 000000000000..a1ab7e7d40e2
--- /dev/null
+++ b/packages/nuxt/test/vite/nitroServer.test.ts
@@ -0,0 +1,100 @@
+import type { Nuxt } from '@nuxt/schema';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { setupNitroServer } from '../../src/vite/nitroServer';
+
+const addNitroPluginMock = vi.hoisted(() => vi.fn());
+const addServerImportsMock = vi.hoisted(() => vi.fn());
+const addTemplateMock = vi.hoisted(() => vi.fn());
+const addServerTemplateMock = vi.hoisted(() => vi.fn());
+
+vi.mock('@nuxt/kit', () => ({
+  addNitroPlugin: addNitroPluginMock,
+  addServerImports: addServerImportsMock,
+  addTemplate: addTemplateMock,
+  createResolver: () => ({ resolve: (input: string) => input }),
+}));
+
+vi.mock('../../src/vendor/server-template', () => ({
+  addServerTemplate: addServerTemplateMock,
+}));
+
+const APP_ROOT = '/my/app';
+const SERVER_CONFIG = `${APP_ROOT}/sentry.server.config.ts`;
+const MODULE_OPTIONS = { experimental_entrypointWrappedFunctions: ['default', 'handler', 'server'] };
+
+type HookCallback = (arg: unknown) => void;
+
+function createFakeNuxt(): {
+  nuxt: Nuxt;
+  hook: ReturnType<typeof vi.fn>;
+  callHook: (name: string, arg: unknown) => void;
+} {
+  const callbacks = new Map<string, HookCallback[]>();
+  const hook = vi.fn((name: string, callback: HookCallback) => {
+    callbacks.set(name, [...(callbacks.get(name) ?? []), callback]);
+  });
+  const nuxt = {
+    options: { rootDir: APP_ROOT, buildDir: `${APP_ROOT}/.nuxt`, nitro: {} },
+    hook,
+    hooks: { hook },
+  } as unknown as Nuxt;
+
+  return { nuxt, hook, callHook: (name, arg) => callbacks.get(name)?.forEach(callback => callback(arg)) };
+}
+
+describe('setupNitroServer', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    addTemplateMock.mockImplementation((opts: { filename: string }) => ({ dst: `${APP_ROOT}/.nuxt/${opts.filename}` }));
+  });
+
+  it('registers nothing on a host without Nitro', () => {
+    const { nuxt, hook } = createFakeNuxt();
+
+    setupNitroServer(nuxt, 'nuxt', SERVER_CONFIG, MODULE_OPTIONS);
+
+    expect(addNitroPluginMock).not.toHaveBeenCalled();
+    expect(addServerImportsMock).not.toHaveBeenCalled();
+    expect(addTemplateMock).not.toHaveBeenCalled();
+    expect(addServerTemplateMock).not.toHaveBeenCalled();
+    expect(hook).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    {
+      serverApi: 'nitro2',
+      handler: 'handler-legacy.server',
+      updateRouteName: 'update-route-name-legacy.server',
+      storage: 'storage-legacy.server',
+    },
+    {
+      serverApi: 'nitro3',
+      handler: 'handler.server',
+      updateRouteName: 'update-route-name.server',
+      storage: 'storage.server',
+    },
+  ] as const)('registers the $handler plugins on $serverApi', ({ serverApi, handler, updateRouteName, storage }) => {
+    const { nuxt } = createFakeNuxt();
+
+    setupNitroServer(nuxt, serverApi, SERVER_CONFIG, MODULE_OPTIONS);
+
+    expect(addNitroPluginMock).toHaveBeenCalledTimes(5);
+    expect(addNitroPluginMock).toHaveBeenNthCalledWith(1, `${APP_ROOT}/.nuxt/sentry-server-config-plugin.mjs`);
+    expect(addNitroPluginMock).toHaveBeenNthCalledWith(2, `./runtime/plugins/${handler}`);
+    expect(addNitroPluginMock).toHaveBeenNthCalledWith(3, `./runtime/plugins/${updateRouteName}`);
+    expect(addNitroPluginMock).toHaveBeenNthCalledWith(4, './runtime/plugins/sentry.server');
+    expect(addNitroPluginMock).toHaveBeenNthCalledWith(5, `./runtime/plugins/${storage}`);
+  });
+
+  it('instruments the middleware and adds the config shim once Nitro initializes', () => {
+    const { nuxt, callHook } = createFakeNuxt();
+    const nitro = { options: { preset: 'node-server', plugins: [] }, hooks: { hook: vi.fn() } };
+    setupNitroServer(nuxt, 'nitro2', SERVER_CONFIG, MODULE_OPTIONS);
+
+    callHook('nitro:init', nitro);
+
+    expect(nitro.hooks.hook).toHaveBeenCalledTimes(2);
+    expect(nitro.hooks.hook).toHaveBeenCalledWith('rollup:before', expect.any(Function));
+    expect(nitro.hooks.hook).toHaveBeenCalledWith('close', expect.any(Function));
+  });
+});
diff --git a/packages/nuxt/test/vite/nitroVersion.test.ts b/packages/nuxt/test/vite/nitroVersion.test.ts
deleted file mode 100644
index a9228231d395..000000000000
--- a/packages/nuxt/test/vite/nitroVersion.test.ts
+++ /dev/null
@@ -1,107 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { getNitroMajorVersion } from '../../src/vite/utils';
-
-// Real filesystem fixtures instead of mocks: the bug this guards against lives in
-// module resolution walking up the directory tree, which mocks cannot reproduce.
-let monorepoRoot: string;
-
-function writePackage(dir: string, packageJson: Record<string, unknown>): void {
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ main: 'index.js', ...packageJson }));
-  fs.writeFileSync(path.join(dir, 'index.js'), '');
-}
-
-function createApp(appName: string, packages: Record<string, Record<string, unknown>>): string {
-  const appDir = path.join(monorepoRoot, 'apps', appName);
-  fs.mkdirSync(appDir, { recursive: true });
-  for (const [name, packageJson] of Object.entries(packages)) {
-    writePackage(path.join(appDir, 'node_modules', name), packageJson);
-  }
-  return appDir;
-}
-
-beforeAll(() => {
-  monorepoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sentry-nitro-version-'));
-  // An unrelated Nitro v3 above the apps, like a monorepo root devDependency
-  writePackage(path.join(monorepoRoot, 'node_modules', 'nitro'), { name: 'nitro', version: '3.0.0-beta.1' });
-});
-
-afterAll(() => {
-  fs.rmSync(monorepoRoot, { recursive: true, force: true });
-});
-
-describe('getNitroMajorVersion', () => {
-  it('detects v2 when nuxt depends on nitropack directly (Nuxt 3 / <=4.1), ignoring a nitro v3 higher up the tree', async () => {
-    const appDir = createApp('nuxt-4-old', {
-      nuxt: { name: 'nuxt', version: '4.1.0', dependencies: { nitropack: '^2.12.0' } },
-      nitropack: { name: 'nitropack', version: '2.12.0' },
-    });
-
-    await expect(getNitroMajorVersion(appDir)).resolves.toBe(2);
-  });
-
-  it('detects v2 through @nuxt/nitro-server when it depends on nitropack (Nuxt >=3.21 stable)', async () => {
-    const appDir = createApp('nuxt-4-stable', {
-      nuxt: { name: 'nuxt', version: '4.5.2', dependencies: { '@nuxt/nitro-server': '4.5.2' } },
-      '@nuxt/nitro-server': { name: '@nuxt/nitro-server', version: '4.5.2', dependencies: { nitropack: '^2.13.4' } },
-      nitropack: { name: 'nitropack', version: '2.13.4' },
-    });
-
-    await expect(getNitroMajorVersion(appDir)).resolves.toBe(2);
-  });
-
-  it('detects v3 through @nuxt/nitro-server when it depends on nitro (Nuxt 5)', async () => {
-    const appDir = createApp('nuxt-5', {
-      nuxt: {
-        name: 'nuxt',
-        version: '5.0.0',
-        dependencies: { '@nuxt/nitro-server': 'npm:@nuxt/nitro-server-nightly' },
-      },
-      '@nuxt/nitro-server': {
-        name: '@nuxt/nitro-server-nightly',
-        version: '5.0.0-nightly',
-        dependencies: { nitro: '^3.0.0-beta' },
-      },
-      nitro: { name: 'nitro', version: '3.0.0-beta.2' },
-    });
-
-    await expect(getNitroMajorVersion(appDir)).resolves.toBe(3);
-  });
-
-  it('detects v3 when nuxt depends on nitro directly, without @nuxt/nitro-server', async () => {
-    const appDir = createApp('nuxt-direct-nitro', {
-      nuxt: { name: 'nuxt', version: '5.1.0', dependencies: { nitro: '^3.1.0' } },
-      nitro: { name: 'nitro', version: '3.1.0' },
-    });
-
-    await expect(getNitroMajorVersion(appDir)).resolves.toBe(3);
-  });
-
-  it('falls back to v3 when the declared nitro package has no readable version (stub package)', async () => {
-    const appDir = createApp('nuxt-5-stub', {
-      nuxt: {
-        name: 'nuxt',
-        version: '5.0.0',
-        dependencies: { '@nuxt/nitro-server': 'npm:@nuxt/nitro-server-nightly' },
-      },
-      '@nuxt/nitro-server': {
-        name: '@nuxt/nitro-server-nightly',
-        version: '5.0.0-nightly',
-        dependencies: { nitro: '^3.0.0-beta' },
-      },
-      nitro: { name: 'nitro' },
-    });
-
-    await expect(getNitroMajorVersion(appDir)).resolves.toBe(3);
-  });
-
-  it('defaults to v2 when nuxt cannot be resolved', async () => {
-    const appDir = path.join(monorepoRoot, 'apps', 'no-nuxt');
-    fs.mkdirSync(appDir, { recursive: true });
-
-    await expect(getNitroMajorVersion(appDir)).resolves.toBe(2);
-  });
-});
diff --git a/packages/nuxt/test/vite/serverApi.test.ts b/packages/nuxt/test/vite/serverApi.test.ts
new file mode 100644
index 000000000000..db453a699025
--- /dev/null
+++ b/packages/nuxt/test/vite/serverApi.test.ts
@@ -0,0 +1,67 @@
+import { runWithNuxtContext } from '@nuxt/kit';
+import type { Nuxt } from '@nuxt/schema';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { resolveServerApi } from '../../src/vite/utils';
+
+// The real kit, not a mock: on older hosts kit resolves `nitropack` from the project, so the
+// fixture gives it a project with only `nitropack` installed. A temp dir has nothing hoisted above it.
+let rootDir: string;
+
+beforeAll(() => {
+  rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sentry-nuxt-server-api-'));
+  const nitropackDir = path.join(rootDir, 'node_modules', 'nitropack');
+  fs.mkdirSync(nitropackDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(nitropackDir, 'package.json'),
+    JSON.stringify({ name: 'nitropack', version: '2.13.4', main: 'index.js' }),
+  );
+  fs.writeFileSync(path.join(nitropackDir, 'index.js'), '');
+});
+
+afterAll(() => {
+  fs.rmSync(rootDir, { recursive: true, force: true });
+});
+
+function resolveForHost(version: string, options: Record<string, unknown>): ReturnType<typeof resolveServerApi> {
+  const nuxt = {
+    _version: version,
+    options: { rootDir, modulesDir: [path.join(rootDir, 'node_modules')], ...options },
+  } as unknown as Nuxt;
+
+  return runWithNuxtContext(nuxt, resolveServerApi);
+}
+
+describe('resolveServerApi', () => {
+  it.each([
+    { host: 'Nuxt 3.7', version: '3.7.0', options: {} },
+    {
+      host: 'Nuxt 4.2 to 4.5',
+      version: '4.5.2',
+      options: { server: { builder: '@nuxt/nitro-server' } },
+    },
+  ])(
+    'resolves `nitro2` from the installed `nitropack` on $host, which declares no Nitro major',
+    ({ version, options }) => {
+      expect(resolveForHost(version, options)).toBe('nitro2');
+    },
+  );
+
+  it('resolves `nitro2` when the host declares Nitro v2 (Nuxt 4.6)', () => {
+    expect(resolveForHost('4.6.0', { server: { builder: '@nuxt/nitro-server' }, _nitroMajor: 2 })).toBe('nitro2');
+  });
+
+  it('resolves `nitro3` when the host declares Nitro v3 (Nuxt 5)', () => {
+    expect(resolveForHost('5.0.0', { server: { builder: '@nuxt/nitro-server' }, _nitroMajor: 3 })).toBe('nitro3');
+  });
+
+  it('resolves `nuxt` for the Vite server builder', () => {
+    expect(resolveForHost('4.6.0', { server: { builder: '@nuxt/vite-server' }, _nitroMajor: 2 })).toBe('nuxt');
+  });
+
+  it('resolves `nuxt` for a custom builder object', () => {
+    expect(resolveForHost('4.6.0', { server: { builder: { bundle() {} } }, _nitroMajor: 2 })).toBe('nuxt');
+  });
+});
diff --git a/yarn.lock b/yarn.lock
index abf7f58320c1..0feac03098c9 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5996,32 +5996,29 @@
     unctx "^2.5.0"
     untyped "^2.0.0"
 
-"@nuxt/kit@^4.5.1", "@nuxt/kit@^4.5.2":
-  version "4.5.2"
-  resolved "https://registry.yarnpkg.com/@nuxt/kit/-/kit-4.5.2.tgz#fa338b169d14d9e66f973ded551d2376edb72398"
-  integrity sha512-l66LU9DcJYjmNwqwAj2I5UGRrUbnG2DOKGChnN70zIGtn0eq/z87gi/FRgha6eMb9/FmB1PFHgtx6PWVml1C2Q==
+"@nuxt/kit@^4.5.1", "@nuxt/kit@^4.6.0":
+  version "4.6.0"
+  resolved "https://sfw.security.sentry.io/npm/@nuxt/kit/-/kit-4.6.0.tgz#bc2d003484d800398927976fa50c104aa9a76f45"
+  integrity sha512-UXTajJ+MFJgwV9UL1CTNNd2PSw5PC3Pjb2rM7FsSYcr92ySQKXEslBnUKbvnXT+gG3NbZ/EF70+WenoNIHX2tw==
   dependencies:
-    c12 "^3.3.4"
     consola "^3.4.2"
     defu "^6.1.7"
     destr "^2.0.5"
-    errx "^0.1.2"
-    exsolve "^1.1.1"
-    ignore "^7.0.6"
-    jiti "^2.7.0"
+    errx "^0.2.2"
+    exsolve "^1.1.3"
+    ignore "^7.0.12"
     klona "^2.0.6"
-    mlly "^1.8.2"
-    nostics "^1.2.0"
-    ohash "^2.0.11"
+    microdiff "^1.6.0"
+    nostics "^1.3.0"
+    package-manager-detector "^1.8.0"
     pathe "^2.0.3"
-    pkg-types "^2.3.1"
-    rc9 "^3.0.1"
+    rc9 "^3.1.0"
     scule "^1.3.0"
+    std-env "^4.3.0"
+    tinyexec "^1.3.1"
     tinyglobby "^0.2.17"
-    ufo "^1.6.4"
-    unctx "^3.0.0"
-    untyped "^2.0.0"
-    verkit "^0.3.1"
+    unctx "^3.0.1"
+    verkit "^0.5.0"
 
 "@nuxt/nitro-server@3.21.11", "@nuxt/nitro-server@^3.21.11":
   version "3.21.11"
@@ -14485,6 +14482,11 @@ errx@^0.1.2:
   resolved "https://registry.yarnpkg.com/errx/-/errx-0.1.2.tgz#cd870178afe9072700d8486af4eb3c358892f40c"
   integrity sha512-chfpPHmCerdo/rXr/nNvPZRkV4WwDRwzwnsJ0Uzz3tVi8Z41tDctRjduYy1138ii77AFlts1qvWtX3g/Acg91Q==
 
+errx@^0.2.2:
+  version "0.2.2"
+  resolved "https://sfw.security.sentry.io/npm/errx/-/errx-0.2.2.tgz#33a094dc8238e13b2182d20e8d406572a09ae86b"
+  integrity sha512-HaPN6cxm6iZ9bIbQQ5orChcw7SY5smUzM08ZMc6OtV4UQhrrc3Ms1G8Ww2n/9lXkWqiioNTssF8bCvchrSbFEQ==
+
 es-abstract@^1.23.2, es-abstract@^1.23.5, es-abstract@^1.23.9, es-abstract@^1.24.0:
   version "1.24.0"
   resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.24.0.tgz#c44732d2beb0acc1ed60df840869e3106e7af328"
@@ -15547,10 +15549,10 @@ express@^4.17.3, express@^4.21.2:
     utils-merge "1.0.1"
     vary "~1.1.2"
 
-exsolve@^1.0.7, exsolve@^1.0.8, exsolve@^1.1.0, exsolve@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/exsolve/-/exsolve-1.1.1.tgz#c055418255459b6ecde4e59de0060a3e97bc7572"
-  integrity sha512-9U/jZUgjnSGyntRr6y5Muu1MJcwFl6kPu7k8qLF0IMNfLqvw0NZ4nnVDq0RVoZ0RvCyumib4Ez3KYrVfilrw+g==
+exsolve@^1.0.7, exsolve@^1.0.8, exsolve@^1.1.0, exsolve@^1.1.1, exsolve@^1.1.3:
+  version "1.1.3"
+  resolved "https://sfw.security.sentry.io/npm/exsolve/-/exsolve-1.1.3.tgz#175a6336d6cb1c9cfee822a092665ee0b79e716d"
+  integrity sha512-kuzL9zherLQoqDeQaS55AiiIg1kb4KYXaSusTtgZTPlvKP2gGCI82LNmBNh5RjDVUXIcmgx+/Mx7vPwRzBbhJA==
 
 extend-shallow@^2.0.1:
   version "2.0.1"
@@ -17404,10 +17406,10 @@ ignore@^5.0.4, ignore@^5.2.0, ignore@^5.2.4:
   resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.3.2.tgz#3cd40e729f3643fd87cb04e50bf0eb722bc596f5"
   integrity sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==
 
-ignore@^7.0.5, ignore@^7.0.6:
-  version "7.0.6"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-7.0.6.tgz#6a57aaef4c90df27ac3590875d29e8f11988c88e"
-  integrity sha512-BAg6QkE8W+TuQLrrw0Ugr7HegXduRuuj8/ti2kSOc+jz1dmx8/WNcjr6XGnq5YpDWxFwwaavqD0+jIUOKelTsw==
+ignore@^7.0.12, ignore@^7.0.5, ignore@^7.0.6:
+  version "7.0.12"
+  resolved "https://sfw.security.sentry.io/npm/ignore/-/ignore-7.0.12.tgz#36048ce2e8d8e0f97fd87863a1cb595ea0a5c69f"
+  integrity sha512-/8UvqAPU9DGTI9k4mxtf49U37Isfwr8Uts96+SBHIkFxPJnHS0Ew4f00sM4Scd8V8EjM0jUNtVDdv1kPdt35lg==
 
 image-meta@^0.2.2:
   version "0.2.2"
@@ -19580,6 +19582,11 @@ methods@^1.1.2, methods@~1.1.2:
   resolved "https://registry.yarnpkg.com/methods/-/methods-1.1.2.tgz#5529a4d67654134edcc5266656835b0f851afcee"
   integrity sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4=
 
+microdiff@^1.6.0:
+  version "1.6.0"
+  resolved "https://sfw.security.sentry.io/npm/microdiff/-/microdiff-1.6.0.tgz#5a205ff44ab63c2eea7761b1578b6c0e2d4d119b"
+  integrity sha512-w7JWt8Bno6I8h0rEqlxr4lNG4UbT1FVtWo42wWosIiaJ+rP3pXh7shCYDnyqBrYx36LJ1CZ64p8A62aVp0sJpQ==
+
 micromark-core-commonmark@^2.0.0:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz#c691630e485021a68cf28dbc2b2ca27ebf678cd4"
@@ -20810,10 +20817,10 @@ normalize-path@^3.0.0, normalize-path@~3.0.0:
   resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
   integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
 
-nostics@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/nostics/-/nostics-1.2.0.tgz#1362df6de2ca8456b521914501abf6c52c4d7fb5"
-  integrity sha512-FGqEfhQjrvo1lL8KFifdTQiNwwQHJxC1jtYE1Rc54qF/jxONUNL+kC9gS1krX8Q65PgrQ5fCqH/I4NhWBvdSqg==
+nostics@^1.3.0:
+  version "1.3.0"
+  resolved "https://sfw.security.sentry.io/npm/nostics/-/nostics-1.3.0.tgz#e1d538463acb0207f9a0ef9ec551b075930559c4"
+  integrity sha512-wzRsrJwNlFbqIRQt8aCeL2WE8USip/uuvGSOZV1D02CxX8ABTMbw8IywKjH7yWHETMXbWJI4OBpihg9rmz2Vyg==
 
 npm-bundled@^1.1.1:
   version "1.1.2"
@@ -21815,6 +21822,11 @@ package-json-from-dist@^1.0.0, package-json-from-dist@^1.0.1:
   resolved "https://registry.yarnpkg.com/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz#4f1471a010827a86f94cfd9b0727e36d267de505"
   integrity sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==
 
+package-manager-detector@^1.8.0:
+  version "1.9.0"
+  resolved "https://sfw.security.sentry.io/npm/package-manager-detector/-/package-manager-detector-1.9.0.tgz#217ed03645bfeb563e9efce4c5bbbfbb652754ab"
+  integrity sha512-zAMfbta9nPA8AKkA4WdmNAT8R8s6Dk0/xwPsqNnRidMFcLo1YkLuPDTgs2f64XdzS8vbLNnoJ+uUIkgbz7oRHA==
+
 package-name-regex@^2.0.6:
   version "2.0.6"
   resolved "https://registry.yarnpkg.com/package-name-regex/-/package-name-regex-2.0.6.tgz#b54bcb04d950e38082b7bb38fa558e01c1679334"
@@ -23375,12 +23387,12 @@ rc9@^2.1.2:
     defu "^6.1.4"
     destr "^2.0.3"
 
-rc9@^3.0.0, rc9@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/rc9/-/rc9-3.0.1.tgz#3895e5834a2b5c2d8fb76d93e802fbcbc2579bc7"
-  integrity sha512-gMDyleLWVE+i6Sgtc0QbbY6pEKqYs97NGi6isHQPqYlLemPoO8dxQ3uGi0f4NiP98c+jMW6cG1Kx9dDwfvqARQ==
+rc9@^3.0.0, rc9@^3.0.1, rc9@^3.1.0:
+  version "3.1.0"
+  resolved "https://sfw.security.sentry.io/npm/rc9/-/rc9-3.1.0.tgz#383f44c0f0bdefcf411c1ce9403c528064a8bd1a"
+  integrity sha512-ufjkNVzbRHKcCOmTahZkmVsyc3W+MSk3jY03m+a7tGHkIsdVMG9l10/3HvFbWkkKzY5VFp3pkRsIo/UYgmFL7Q==
   dependencies:
-    defu "^6.1.6"
+    defu "^6.1.7"
     destr "^2.0.5"
 
 rc@^1.2.8:
@@ -25509,10 +25521,10 @@ std-env@^3.7.0:
   resolved "https://registry.yarnpkg.com/std-env/-/std-env-3.10.0.tgz#d810b27e3a073047b2b5e40034881f5ea6f9c83b"
   integrity sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==
 
-std-env@^4.0.0, std-env@^4.0.0-rc.1, std-env@^4.1.0, std-env@^4.2.0:
-  version "4.2.0"
-  resolved "https://sfw.security.sentry.io/npm/std-env/-/std-env-4.2.0.tgz#8ebe0ec60485668ab47227b312f4254cdf80c9d3"
-  integrity sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==
+std-env@^4.0.0, std-env@^4.0.0-rc.1, std-env@^4.1.0, std-env@^4.2.0, std-env@^4.3.0:
+  version "4.3.0"
+  resolved "https://sfw.security.sentry.io/npm/std-env/-/std-env-4.3.0.tgz#4e7231b61fd83219aa7f76f71fa8818b07e41321"
+  integrity sha512-OtU/EgQ1kIm5KwqQpBC6ZEMXrZRui11w8zgfTWp8cdO9B8OaPsbA8bTHO2P+HNo1VlUTGMVBwPhydu6poeXiag==
 
 stdin-discarder@^0.2.2:
   version "0.2.2"
@@ -26196,7 +26208,7 @@ tinyexec@^0.3.1:
   resolved "https://registry.yarnpkg.com/tinyexec/-/tinyexec-0.3.2.tgz#941794e657a85e496577995c6eef66f53f42b3d2"
   integrity sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==
 
-tinyexec@^1.0.2, tinyexec@^1.2.4:
+tinyexec@^1.0.2, tinyexec@^1.2.4, tinyexec@^1.3.1:
   version "1.3.1"
   resolved "https://sfw.security.sentry.io/npm/tinyexec/-/tinyexec-1.3.1.tgz#16a2e3c6e23fafce72640e678e651db36145b9c6"
   integrity sha512-GCvB3aoys96IuDFBMcTB46JOR6mdMtAToqwiW8JlWhsoh1mhHi/xn9ss/Dg7N555GiJyEt2qzoG/NHCwM6h1EA==
@@ -26730,10 +26742,10 @@ unctx@^2.4.1, unctx@^2.5.0:
     magic-string "^0.30.21"
     unplugin "^2.3.11"
 
-unctx@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/unctx/-/unctx-3.0.0.tgz#82e2f20c8f9db13a443871caddfdd1af7af2eff1"
-  integrity sha512-DoXdZVeyi2jyEsn86i8MO5RTItm1kffUkH9/+DQORn3Q688AMOy2551CIl6AdGL2UpwD675wtbNOl75wIQN/uA==
+unctx@^3.0.1:
+  version "3.0.1"
+  resolved "https://sfw.security.sentry.io/npm/unctx/-/unctx-3.0.1.tgz#16dc56fc256a2bf4df485d9f38866634109058a1"
+  integrity sha512-5RAt2etv7g362RXyd33R82gm9u/kbtQlpoaOs9Bgm4E32GRMJ0xjbZyvdxUTmiuHk3V1IQb1aUNrp5IWY+JaWw==
 
 undefsafe@^2.0.5:
   version "2.0.5"
@@ -27265,10 +27277,10 @@ vary@^1, vary@^1.1.2, vary@~1.1.2:
   resolved "https://registry.yarnpkg.com/vary/-/vary-1.1.2.tgz#2299f02c6ded30d4a5961b0b9f74524a18f634fc"
   integrity sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=
 
-verkit@^0.3.1:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/verkit/-/verkit-0.3.2.tgz#0511ea63310551b62a20c010aa820350c5c350c6"
-  integrity sha512-zj/ob3UsvJGN0whEAKFp53REA5X66hvffVqoCtVQAakJKnKlH+/PcOfMoFwIG/o4rElqLv/ycAFlx8ZlXUorCg==
+verkit@^0.5.0:
+  version "0.5.0"
+  resolved "https://sfw.security.sentry.io/npm/verkit/-/verkit-0.5.0.tgz#8b7617dda9ad2edb7851c6a4ff5f3ca428482401"
+  integrity sha512-u4J1hr6Y+C/hit34GwL3eIcUf3wngT8TlYUjK7tk0jxydKLAq3sYvifjdTDA6U3KCKRcQCQDGf/srjxfZF3l7g==
 
 vfile-location@^5.0.0:
   version "5.0.3"

From d489a0828ec15e4babf4926e375704ac0bffc67e Mon Sep 17 00:00:00 2001
From: Sigrid <32902192+s1gr1d@users.noreply.github.com>
Date: Fri, 9 Oct 2026 10:34:53 +0200
Subject: [PATCH 07/84] fix(server-utils): Record amqplib consumer info before
 the first delivery and instrument the callback API (#25047)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When a worker subscribes to a queue that already has messages, amqplib
can decode `BasicConsumeOk` and the first message in one socket read. We
recorded each consumer's queue and `noAck` flag when `consume()`
resolved. That happens too late:

```
one socket read, decoded synchronously
│
├─ BasicConsumeOk ─► registerConsumer(tag)         ◄─ now: info recorded here
├─ BasicDeliver   ─► dispatchMessage(tag)          ◄─ lookup missed here
│
└─ decode ends ─► microtasks ─► consume().then()   ◄─ before: info recorded here
```

The first message's span got the routing key as its name, and `noAck`
spans ended as errors at channel close. Now we record the info in
`registerConsumer`, which amqplib always calls before dispatch.

This PR also instruments the callback API (`lib/callback_model.js`). It
has the same classes and signatures as the promise API.

Follow-up on this PR (noticed the bug while working on this):
https://github.com/getsentry/sentry-javascript/pull/23652
---
 .../tracing/amqplib/scenario-callback-api.mjs |  51 +++++++++
 .../tracing/amqplib/scenario-topic-noack.mjs  |  63 +++++++++++
 .../suites/tracing/amqplib/test.ts            |  51 +++++++++
 .../server-utils/src/integrations/amqplib.ts  |  77 ++++++++++---
 .../src/orchestrion/config/amqplib.ts         | 106 ++++++++++--------
 5 files changed, 287 insertions(+), 61 deletions(-)
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/amqplib/scenario-callback-api.mjs
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/amqplib/scenario-topic-noack.mjs

diff --git a/dev-packages/node-integration-tests/suites/tracing/amqplib/scenario-callback-api.mjs b/dev-packages/node-integration-tests/suites/tracing/amqplib/scenario-callback-api.mjs
new file mode 100644
index 000000000000..4870e99da9bd
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/amqplib/scenario-callback-api.mjs
@@ -0,0 +1,51 @@
+import * as Sentry from '@sentry/node';
+import amqp from 'amqplib/callback_api.js';
+
+const queueName = 'callback-queue';
+const amqpUsername = 'sentry';
+const amqpPassword = 'sentry';
+
+const AMQP_URL = `amqp://${amqpUsername}:${amqpPassword}@localhost:5672/`;
+
+(async () => {
+  const connection = await connectToRabbitMQ();
+  const channel = await toPromise(cb => connection.createChannel(cb));
+  await toPromise(cb => channel.assertQueue(queueName, { durable: false, exclusive: true }, cb));
+
+  // Without the info from `consume`, a `noAck` span stays open until the channel closes and ends as an error.
+  const received = new Promise((resolve, reject) => {
+    channel.consume(
+      queueName,
+      message => (message ? resolve() : reject(new Error('No message received'))),
+      { noAck: true },
+      err => err && reject(err),
+    );
+  });
+
+  await Sentry.startSpan({ name: 'root span' }, async () => {
+    channel.sendToQueue(queueName, Buffer.from(JSON.stringify({ foo: 'bar01' })));
+  });
+
+  await received;
+
+  await toPromise(cb => channel.close(cb));
+  await toPromise(cb => connection.close(cb));
+})();
+
+async function connectToRabbitMQ() {
+  // The broker accepts TCP before AMQP handshakes succeed, so early connects can fail while it boots.
+  let lastError;
+  for (let attempt = 0; attempt < 5; attempt++) {
+    try {
+      return await toPromise(cb => amqp.connect(AMQP_URL, cb));
+    } catch (err) {
+      lastError = err;
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  }
+  throw lastError;
+}
+
+function toPromise(fn) {
+  return new Promise((resolve, reject) => fn((err, result) => (err ? reject(err) : resolve(result))));
+}
diff --git a/dev-packages/node-integration-tests/suites/tracing/amqplib/scenario-topic-noack.mjs b/dev-packages/node-integration-tests/suites/tracing/amqplib/scenario-topic-noack.mjs
new file mode 100644
index 000000000000..819f1181cb1f
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/amqplib/scenario-topic-noack.mjs
@@ -0,0 +1,63 @@
+import * as Sentry from '@sentry/node';
+import amqp from 'amqplib';
+
+// A topic exchange, so the routing key and the queue name differ.
+const exchangeName = 'orders';
+const queueName = 'orders-worker';
+const routingKey = 'order.created.12345';
+const amqpUsername = 'sentry';
+const amqpPassword = 'sentry';
+
+const AMQP_URL = `amqp://${amqpUsername}:${amqpPassword}@localhost:5672/`;
+
+// A `noAck` consumer never settles a message, so its span has to end when dispatch returns.
+const NO_ACKNOWLEDGEMENT = { noAck: true };
+
+(async () => {
+  const { connection, channel } = await connectToRabbitMQ();
+
+  await channel.assertExchange(exchangeName, 'topic', { durable: false, autoDelete: true });
+  await channel.assertQueue(queueName, { durable: false, exclusive: true });
+  await channel.bindQueue(queueName, exchangeName, 'order.created.#');
+
+  // Publish before consuming, so the broker sends `BasicConsumeOk` and the delivery back to back.
+  await Sentry.startSpan({ name: 'root span' }, async () => {
+    channel.publish(exchangeName, routingKey, Buffer.from(JSON.stringify({ foo: 'bar01' })));
+  });
+
+  await consumeMessageFromQueue(queueName, channel);
+
+  await channel.close();
+  await connection.close();
+})();
+
+async function connectToRabbitMQ() {
+  // The broker accepts TCP before AMQP handshakes succeed, so early connects can reject while it boots.
+  let lastError;
+  for (let attempt = 0; attempt < 5; attempt++) {
+    try {
+      const connection = await amqp.connect(AMQP_URL);
+      const channel = await connection.createChannel();
+      return { connection, channel };
+    } catch (err) {
+      lastError = err;
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  }
+  throw lastError;
+}
+
+async function consumeMessageFromQueue(queueName, channel) {
+  return new Promise((resolve, reject) => {
+    const onMessage = message => (message ? resolve() : reject(new Error('No message received')));
+
+    // Invalid `arguments` throw before the RPC, so the channel stays open for the next `consume`.
+    try {
+      channel.consume('orders-archive', onMessage, { arguments: 'invalid' });
+    } catch {
+      // Expected.
+    }
+
+    channel.consume(queueName, onMessage, NO_ACKNOWLEDGEMENT).catch(reject);
+  });
+}
diff --git a/dev-packages/node-integration-tests/suites/tracing/amqplib/test.ts b/dev-packages/node-integration-tests/suites/tracing/amqplib/test.ts
index 9e162e07490c..cd86d01459ec 100644
--- a/dev-packages/node-integration-tests/suites/tracing/amqplib/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/amqplib/test.ts
@@ -168,5 +168,56 @@ describeWithDockerCompose('amqplib auto-instrumentation', { workingDirectory: [_
       },
       { additionalDependencies },
     );
+
+    createEsmAndCjsTests(
+      __dirname,
+      'scenario-topic-noack.mjs',
+      'instrument.mjs',
+      (createTestRunner, test) => {
+        test('ends a noAck consumer span as ok', { timeout: 60_000 }, async () => {
+          await createTestRunner()
+            .expect({
+              span: container => {
+                const consumer = container.items.find(
+                  span => span.attributes[SENTRY_ORIGIN]?.value === 'auto.amqplib.consumer',
+                );
+
+                expect(consumer).toBeDefined();
+                expect(consumer!.name).toBe('process orders');
+                expect(consumer!.status).toBe('ok');
+                expect(consumer!.attributes[MESSAGING_DESTINATION_NAME]?.value).toBe('orders');
+                expect(consumer!.attributes[MESSAGING_RABBITMQ_DESTINATION_ROUTING_KEY]?.value).toBe(
+                  'order.created.12345',
+                );
+              },
+            })
+            .start()
+            .completed();
+        });
+      },
+      { additionalDependencies },
+    );
+  });
+
+  createEsmAndCjsTests(__dirname, 'scenario-callback-api.mjs', 'instrument.mjs', (createTestRunner, test) => {
+    test('instruments publish and noAck consume on the callback API', { timeout: 60_000 }, async () => {
+      await createTestRunner()
+        .expect({
+          span: container => {
+            const producerSpan = container.items.find(
+              span => span.attributes[SENTRY_ORIGIN]?.value === 'auto.amqplib.publisher',
+            );
+            expect(producerSpan?.name).toBe('send callback-queue');
+
+            const consumerSpan = container.items.find(
+              span => span.attributes[SENTRY_ORIGIN]?.value === 'auto.amqplib.consumer',
+            );
+            expect(consumerSpan?.name).toBe('process callback-queue');
+            expect(consumerSpan?.status).toBe('ok');
+          },
+        })
+        .start()
+        .completed();
+    });
   });
 });
diff --git a/packages/server-utils/src/integrations/amqplib.ts b/packages/server-utils/src/integrations/amqplib.ts
index 9b227d7e0e2c..9768cf27a26c 100644
--- a/packages/server-utils/src/integrations/amqplib.ts
+++ b/packages/server-utils/src/integrations/amqplib.ts
@@ -68,6 +68,7 @@ const MESSAGE_STORED_SPAN: unique symbol = Symbol('sentry.amqplib.message.stored
 const CHANNEL_SPANS_NOT_ENDED: unique symbol = Symbol('sentry.amqplib.channel.spans-not-ended');
 const CHANNEL_CONSUME_TIMEOUT_TIMER: unique symbol = Symbol('sentry.amqplib.channel.consume-timeout-timer');
 const CHANNEL_CONSUMER_INFO: unique symbol = Symbol('sentry.amqplib.channel.consumer-info');
+const CHANNEL_PENDING_CONSUMERS: unique symbol = Symbol('sentry.amqplib.channel.pending-consumers');
 const CHANNEL_IS_CONFIRM_PUBLISHING: unique symbol = Symbol('sentry.amqplib.channel.is-confirm-publishing');
 const CONNECTION_ATTRIBUTES: unique symbol = Symbol('sentry.amqplib.connection.attributes');
 
@@ -108,12 +109,19 @@ interface ConsumerInfo {
   queue: string;
 }
 
+/** A `consume` call waiting for the broker to assign it a consumer tag. */
+interface PendingConsumer {
+  callback: unknown;
+  info: ConsumerInfo;
+}
+
 interface ChannelLike {
   connection?: ConnectionLike;
   on?: (event: string, listener: (...args: unknown[]) => void) => unknown;
   [CHANNEL_SPANS_NOT_ENDED]?: { msg: ConsumeMessage; timeOfConsume: number }[];
   [CHANNEL_CONSUME_TIMEOUT_TIMER]?: ReturnType<typeof setInterval>;
   [CHANNEL_CONSUMER_INFO]?: Map<string, ConsumerInfo>;
+  [CHANNEL_PENDING_CONSUMERS]?: PendingConsumer[];
   [CHANNEL_IS_CONFIRM_PUBLISHING]?: boolean;
 }
 
@@ -135,6 +143,11 @@ interface AmqpDispatchContext extends AmqpChannelContext {
   _sentryNoAck?: boolean;
 }
 
+interface AmqpConsumeContext extends AmqpChannelContext {
+  // The entry this call queued, so the error hook can drop it.
+  _sentryPendingConsumer?: PendingConsumer;
+}
+
 interface AmqpConnectContext {
   arguments?: unknown[];
   result?: unknown;
@@ -156,6 +169,7 @@ function instrumentAmqplib(): void {
   subscribePublish();
   subscribeConfirmPublish();
   subscribeConsume();
+  subscribeRegisterConsumer();
   subscribeDispatch();
   subscribeSettle();
 }
@@ -199,32 +213,68 @@ function subscribeConfirmPublish(): void {
   });
 }
 
-/**
- * Records `consumerTag -> { noAck, queue }` when a consumer is registered, so the per-message
- * dispatch hook can name the span after the queue and know when to end it.
- */
+/** Stashes the `{ noAck, queue }` each `consume` asks for until the broker assigns it a tag. */
 function subscribeConsume(): void {
-  const channel = diagnosticsChannel.tracingChannel<AmqpChannelContext>(CHANNELS.AMQPLIB_CONSUME);
+  const channel = diagnosticsChannel.tracingChannel<AmqpConsumeContext>(CHANNELS.AMQPLIB_CONSUME);
 
-  // A `start` subscriber is required for orchestrion to wrap `consume` at all.
-  channel.start.subscribe(NOOP);
-  channel.asyncEnd.subscribe(message => {
-    const data = message as AmqpChannelContext;
+  channel.start.subscribe(message => {
+    const data = message as AmqpConsumeContext;
     const consumerChannel = data.self;
-    const result = data.result as { consumerTag?: string } | undefined;
-    const consumerTag = result?.consumerTag;
-    if (!consumerChannel || !consumerTag) {
+    if (!consumerChannel) {
       return;
     }
 
     ensureChannelState(consumerChannel);
     const queueArg = data.arguments[0];
     const queue = typeof queueArg === 'string' ? queueArg : '<unknown>';
+    const callback = data.arguments[1];
     const options = data.arguments[2] as { noAck?: boolean } | undefined;
-    consumerChannel[CHANNEL_CONSUMER_INFO]?.set(consumerTag, { noAck: !!options?.noAck, queue });
+    const entry = { callback, info: { noAck: !!options?.noAck, queue } };
+    consumerChannel[CHANNEL_PENDING_CONSUMERS]?.push(entry);
+    data._sentryPendingConsumer = entry;
+  });
+
+  // A synchronous throw, such as for invalid `arguments`, leaves the channel open. RPC failures close it.
+  // A stale entry would label the next consumer that shares this callback.
+  channel.error.subscribe(message => {
+    const data = message as AmqpConsumeContext;
+    if (data.self && data._sentryPendingConsumer) {
+      removePendingConsumer(data.self, data._sentryPendingConsumer);
+    }
+  });
+}
+
+/**
+ * Records `consumerTag -> { noAck, queue }` for the dispatch hook. `consume`'s promise resolves too late,
+ * because amqplib can decode `BasicConsumeOk` and the first delivery in one socket read. amqplib always
+ * registers a consumer before it dispatches to it.
+ */
+function subscribeRegisterConsumer(): void {
+  const channel = diagnosticsChannel.tracingChannel<AmqpChannelContext>(CHANNELS.AMQPLIB_REGISTER_CONSUMER);
+
+  channel.start.subscribe(message => {
+    const data = message as AmqpChannelContext;
+    const consumerChannel = data.self;
+    const consumerTag = data.arguments[0];
+    const callback = data.arguments[1];
+    if (!consumerChannel || typeof consumerTag !== 'string') {
+      return;
+    }
+
+    const entry = consumerChannel[CHANNEL_PENDING_CONSUMERS]?.find(pending => pending.callback === callback);
+    if (!entry) {
+      return;
+    }
+
+    removePendingConsumer(consumerChannel, entry);
+    consumerChannel[CHANNEL_CONSUMER_INFO]?.set(consumerTag, entry.info);
   });
 }
 
+function removePendingConsumer(channel: ChannelLike, entry: PendingConsumer): void {
+  channel[CHANNEL_PENDING_CONSUMERS] = channel[CHANNEL_PENDING_CONSUMERS]?.filter(pending => pending !== entry);
+}
+
 /**
  * Per delivered message (`BaseChannel.prototype.dispatchMessage`): continues the producer's trace,
  * opens a CONSUMER span, and runs the user callback under it. Manual-ack consumers keep the span open
@@ -356,6 +406,7 @@ function ensureChannelState(channel: ChannelLike): void {
 
   channel[CHANNEL_SPANS_NOT_ENDED] = [];
   channel[CHANNEL_CONSUMER_INFO] = new Map();
+  channel[CHANNEL_PENDING_CONSUMERS] = [];
 
   const timer = setInterval(() => checkConsumeTimeoutOnChannel(channel), CONSUME_TIMEOUT_MS);
   timer.unref?.();
diff --git a/packages/server-utils/src/orchestrion/config/amqplib.ts b/packages/server-utils/src/orchestrion/config/amqplib.ts
index a8f0e4fe61b4..184844a8d799 100644
--- a/packages/server-utils/src/orchestrion/config/amqplib.ts
+++ b/packages/server-utils/src/orchestrion/config/amqplib.ts
@@ -2,9 +2,11 @@ import type { InstrumentationConfig } from '../apmTypes';
 
 import { getModuleNames } from './module-names';
 
-// `amqplib` splits its API across three files:
-// - `lib/channel_model.js` holds `class Channel` (publish/consume/ack/nack/reject/…) and
-//   `class ConfirmChannel extends Channel` (a `publish` that takes a broker-confirm callback).
+// `amqplib` splits its API across these files:
+// - `lib/channel_model.js` (promise API) and `lib/callback_model.js` (callback API) each hold a
+//   `class Channel` (publish/consume/ack/nack/reject/…) and a `class ConfirmChannel extends Channel`
+//   (a `publish` that takes a broker-confirm callback). The method signatures match, so both files
+//   publish to the same channels.
 // - `lib/channel.js` holds `class BaseChannel` whose `dispatchMessage` invokes the registered
 //   consumer callback once per delivered message — the natural per-message hook for consumer spans
 //   (`Channel.consume` itself only registers the callback, it isn't called per message).
@@ -15,26 +17,59 @@ import { getModuleNames } from './module-names';
 const module = { name: 'amqplib', versionRange: '>=0.5.5 <3' } as const;
 
 export const amqplibConfig = [
-  // Producer span + trace-header injection. `sendToQueue` delegates to `publish`, so it's covered.
+  ...['lib/channel_model.js', 'lib/callback_model.js'].flatMap((filePath): InstrumentationConfig[] => [
+    // Producer span + trace-header injection. `sendToQueue` delegates to `publish`, so it's covered.
+    {
+      channelName: 'publish',
+      module: { ...module, filePath },
+      functionQuery: { className: 'Channel', methodName: 'publish', kind: 'Sync' },
+    },
+    // Confirm-channel producer span; the trailing broker-confirm callback ends the span when the
+    // broker acks/nacks. It internally calls the base `publish`, so the subscriber skips that nested call.
+    {
+      channelName: 'confirmPublish',
+      module: { ...module, filePath },
+      functionQuery: { className: 'ConfirmChannel', methodName: 'publish', kind: 'Callback' },
+    },
+    // `consume` knows the queue and `noAck`, and `registerConsumer` knows the tag. Together they tell the
+    // dispatch hook how to name the consumer span and when to end it. `Sync`, because the callback API
+    // returns the channel and only a synchronous throw leaves the channel open.
+    {
+      channelName: 'consume',
+      module: { ...module, filePath },
+      functionQuery: { className: 'Channel', methodName: 'consume', kind: 'Sync' },
+    },
+    // End the consumer span when the user settles the message.
+    {
+      channelName: 'ack',
+      module: { ...module, filePath },
+      functionQuery: { className: 'Channel', methodName: 'ack', kind: 'Sync' },
+    },
+    {
+      channelName: 'nack',
+      module: { ...module, filePath },
+      functionQuery: { className: 'Channel', methodName: 'nack', kind: 'Sync' },
+    },
+    {
+      channelName: 'reject',
+      module: { ...module, filePath },
+      functionQuery: { className: 'Channel', methodName: 'reject', kind: 'Sync' },
+    },
+    {
+      channelName: 'ackAll',
+      module: { ...module, filePath },
+      functionQuery: { className: 'Channel', methodName: 'ackAll', kind: 'Sync' },
+    },
+    {
+      channelName: 'nackAll',
+      module: { ...module, filePath },
+      functionQuery: { className: 'Channel', methodName: 'nackAll', kind: 'Sync' },
+    },
+  ]),
   {
-    channelName: 'publish',
-    module: { ...module, filePath: 'lib/channel_model.js' },
-    functionQuery: { className: 'Channel', methodName: 'publish', kind: 'Sync' },
-  },
-  // Confirm-channel producer span; the trailing broker-confirm callback ends the span when the
-  // broker acks/nacks. It internally calls `super.publish`, so the subscriber guards against the
-  // base `publish` channel double-instrumenting.
-  {
-    channelName: 'confirmPublish',
-    module: { ...module, filePath: 'lib/channel_model.js' },
-    functionQuery: { className: 'ConfirmChannel', methodName: 'publish', kind: 'Callback' },
-  },
-  // Records `consumerTag -> { noAck, queue }` so the per-message dispatch hook knows how to name and
-  // when to end the consumer span.
-  {
-    channelName: 'consume',
-    module: { ...module, filePath: 'lib/channel_model.js' },
-    functionQuery: { className: 'Channel', methodName: 'consume', kind: 'Async' },
+    channelName: 'registerConsumer',
+    module: { ...module, filePath: 'lib/channel.js' },
+    functionQuery: { className: 'BaseChannel', methodName: 'registerConsumer', kind: 'Sync' },
   },
   // Per delivered message: creates the consumer span and runs the user callback under it.
   {
@@ -42,32 +77,6 @@ export const amqplibConfig = [
     module: { ...module, filePath: 'lib/channel.js' },
     functionQuery: { className: 'BaseChannel', methodName: 'dispatchMessage', kind: 'Sync' },
   },
-  // End the consumer span when the user settles the message.
-  {
-    channelName: 'ack',
-    module: { ...module, filePath: 'lib/channel_model.js' },
-    functionQuery: { className: 'Channel', methodName: 'ack', kind: 'Sync' },
-  },
-  {
-    channelName: 'nack',
-    module: { ...module, filePath: 'lib/channel_model.js' },
-    functionQuery: { className: 'Channel', methodName: 'nack', kind: 'Sync' },
-  },
-  {
-    channelName: 'reject',
-    module: { ...module, filePath: 'lib/channel_model.js' },
-    functionQuery: { className: 'Channel', methodName: 'reject', kind: 'Sync' },
-  },
-  {
-    channelName: 'ackAll',
-    module: { ...module, filePath: 'lib/channel_model.js' },
-    functionQuery: { className: 'Channel', methodName: 'ackAll', kind: 'Sync' },
-  },
-  {
-    channelName: 'nackAll',
-    module: { ...module, filePath: 'lib/channel_model.js' },
-    functionQuery: { className: 'Channel', methodName: 'nackAll', kind: 'Sync' },
-  },
   // Stashes connection attributes (url/host/port/protocol/server product) on the connection object
   // for span-time reads via `channel.connection`.
   {
@@ -83,6 +92,7 @@ export const amqplibChannels = {
   AMQPLIB_PUBLISH: 'orchestrion:amqplib:publish',
   AMQPLIB_CONFIRM_PUBLISH: 'orchestrion:amqplib:confirmPublish',
   AMQPLIB_CONSUME: 'orchestrion:amqplib:consume',
+  AMQPLIB_REGISTER_CONSUMER: 'orchestrion:amqplib:registerConsumer',
   AMQPLIB_DISPATCH: 'orchestrion:amqplib:dispatch',
   AMQPLIB_ACK: 'orchestrion:amqplib:ack',
   AMQPLIB_NACK: 'orchestrion:amqplib:nack',

From 9e98e4bdfe6671d0f4532d8365621aa2f72dfb6c Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 10:57:54 +0200
Subject: [PATCH 08/84] test(node): Port incoming HTTP behavior to span
 streaming (#25194)

Port incoming HTTP behavior test suites to span streaming.

Part of #24135

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../node-suites/excludes.ts                   |   4 +-
 .../httpIntegration-streamed/instrument.mjs   |   1 -
 .../instrument-overwrite-server-emit.mjs      |   1 -
 .../suites/tracing/httpIntegration/test.ts    | 234 ++++++++++--------
 .../instrument.mjs                            |   1 -
 .../server.mjs                                |   0
 .../test.ts                                   |   2 +-
 ...rument-with-datacollection-no-userinfo.mjs |   1 -
 .../instrument-without-request-data.mjs       |   1 -
 .../instrument.mjs                            |   1 -
 .../server.mjs                                |   0
 .../test.ts                                   |   2 +-
 12 files changed, 128 insertions(+), 120 deletions(-)
 rename dev-packages/node-integration-tests/suites/tracing/{httpServerSpans-streamed-unrouted => httpServerSpans-unrouted}/instrument.mjs (90%)
 rename dev-packages/node-integration-tests/suites/tracing/{httpServerSpans-streamed-unrouted => httpServerSpans-unrouted}/server.mjs (100%)
 rename dev-packages/node-integration-tests/suites/tracing/{httpServerSpans-streamed-unrouted => httpServerSpans-unrouted}/test.ts (96%)
 rename dev-packages/node-integration-tests/suites/tracing/{requestData-streamed => requestData}/instrument-with-datacollection-no-userinfo.mjs (91%)
 rename dev-packages/node-integration-tests/suites/tracing/{requestData-streamed => requestData}/instrument-without-request-data.mjs (92%)
 rename dev-packages/node-integration-tests/suites/tracing/{requestData-streamed => requestData}/instrument.mjs (90%)
 rename dev-packages/node-integration-tests/suites/tracing/{requestData-streamed => requestData}/server.mjs (100%)
 rename dev-packages/node-integration-tests/suites/tracing/{requestData-streamed => requestData}/test.ts (99%)

diff --git a/dev-packages/bun-integration-tests/node-suites/excludes.ts b/dev-packages/bun-integration-tests/node-suites/excludes.ts
index 5b99ffc866ab..427f5cc0c2cd 100644
--- a/dev-packages/bun-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/bun-integration-tests/node-suites/excludes.ts
@@ -21,11 +21,11 @@ const NO_HTTP_SERVER_SPANS = [
   'suites/tracing/envelope-header/sampleRate-propagation/test.ts',
   'suites/tracing/httpIntegration-streamed/test.ts',
   'suites/tracing/httpIntegration/test.ts',
-  'suites/tracing/httpServerSpans-streamed-unrouted/test.ts',
+  'suites/tracing/httpServerSpans-unrouted/test.ts',
   'suites/tracing/ignoreSpans-streamed/**',
   'suites/tracing/meta-tags-twp-errors/test.ts',
   'suites/tracing/meta-tags/test.ts',
-  'suites/tracing/requestData-streamed/test.ts',
+  'suites/tracing/requestData/test.ts',
   'suites/tracing/sample-rand-propagation/test.ts',
   'suites/tracing/sample-rate-propagation/**',
   'suites/tracing/sampling-static/test.ts',
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpIntegration-streamed/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/httpIntegration-streamed/instrument.mjs
index 53b9511a21f0..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpIntegration-streamed/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/httpIntegration-streamed/instrument.mjs
@@ -6,5 +6,4 @@ Sentry.init({
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/instrument-overwrite-server-emit.mjs b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/instrument-overwrite-server-emit.mjs
index 680ed3d3c156..94ad8df95439 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/instrument-overwrite-server-emit.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/instrument-overwrite-server-emit.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts
index 3cbe232bb061..1225b5891e8f 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts
@@ -1,5 +1,6 @@
+import { HTTP_SERVER } from '@sentry/conventions/op';
 import { createTestServer } from '@sentry-internal/test-utils';
-import { URL_FULL, URL_PATH } from '@sentry/conventions/attributes';
+import { HTTP_RESPONSE_STATUS_CODE, SENTRY_OP, URL_FULL, URL_PATH } from '@sentry/conventions/attributes';
 import { afterAll, describe, expect, test } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests, createRunner } from '../../../utils/runner';
 import { RUNTIME } from '../../../utils';
@@ -205,51 +206,54 @@ describe('httpIntegration', () => {
           test('handles server.emit being overwritten via classic monkey patching', async () => {
             const runner = createRunner()
               .expect({
-                transaction: {
-                  transaction: 'GET /test1',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: [
+                    {
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
+                      attributes: {
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test1' },
                       },
                     },
-                  },
-                  spans: [],
+                  ],
                 },
               })
               .expect({
-                transaction: {
-                  transaction: 'GET /test2',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: [
+                    {
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
+                      attributes: {
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test2' },
                       },
                     },
-                  },
-                  spans: [],
+                  ],
                 },
               })
               .expect({
-                transaction: {
-                  transaction: 'GET /test3',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: [
+                    {
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
+                      attributes: {
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test3' },
                       },
                     },
-                  },
-                  spans: [],
+                  ],
                 },
               })
               .start();
@@ -263,50 +267,54 @@ describe('httpIntegration', () => {
           test('handles server.emit being overwritten via proxy', async () => {
             const runner = createRunner()
               .expect({
-                transaction: {
-                  transaction: 'GET /test1-proxy',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: [
+                    {
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
+                      attributes: {
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test1-proxy' },
                       },
                     },
-                  },
-                  spans: [],
+                  ],
                 },
               })
               .expect({
-                transaction: {
-                  transaction: 'GET /test2-proxy',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: [
+                    {
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
+                      attributes: {
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test2-proxy' },
                       },
                     },
-                  },
-                  spans: [],
+                  ],
                 },
               })
               .expect({
-                transaction: {
-                  transaction: 'GET /test3-proxy',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: expect.arrayContaining([
+                    expect.objectContaining({
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
-                      },
-                    },
-                  },
+                      attributes: expect.objectContaining({
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test3-proxy' },
+                      }),
+                    }),
+                  ]),
                 },
               })
               .start();
@@ -320,51 +328,54 @@ describe('httpIntegration', () => {
           test('handles server.emit being overwritten via classic monkey patching, using initial server.emit', async () => {
             const runner = createRunner()
               .expect({
-                transaction: {
-                  transaction: 'GET /test1-original',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: [
+                    {
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
+                      attributes: {
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test1-original' },
                       },
                     },
-                  },
-                  spans: [],
+                  ],
                 },
               })
               .expect({
-                transaction: {
-                  transaction: 'GET /test2-original',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: [
+                    {
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
+                      attributes: {
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test2-original' },
                       },
                     },
-                  },
-                  spans: [],
+                  ],
                 },
               })
               .expect({
-                transaction: {
-                  transaction: 'GET /test3-original',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: [
+                    {
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
+                      attributes: {
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test3-original' },
                       },
                     },
-                  },
-                  spans: [],
+                  ],
                 },
               })
               .start();
@@ -378,51 +389,54 @@ describe('httpIntegration', () => {
           test('handles server.emit being overwritten via proxy, using initial server.emit', async () => {
             const runner = createRunner()
               .expect({
-                transaction: {
-                  transaction: 'GET /test1-proxy-original',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: [
+                    {
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
+                      attributes: {
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test1-proxy-original' },
                       },
                     },
-                  },
-                  spans: [],
+                  ],
                 },
               })
               .expect({
-                transaction: {
-                  transaction: 'GET /test2-proxy-original',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: [
+                    {
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
+                      attributes: {
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test2-proxy-original' },
                       },
                     },
-                  },
-                  spans: [],
+                  ],
                 },
               })
               .expect({
-                transaction: {
-                  transaction: 'GET /test3-proxy-original',
-                  contexts: {
-                    trace: {
+                span: {
+                  items: [
+                    {
+                      name: 'GET',
+                      is_segment: true,
                       span_id: expect.stringMatching(/[a-f\d]{16}/),
                       trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                      data: {
-                        'http.response.status_code': 200,
-                        'sentry.op': 'http.server',
+                      attributes: {
+                        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                        [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                        [URL_PATH]: { type: 'string', value: '/test3-proxy-original' },
                       },
                     },
-                  },
-                  spans: [],
+                  ],
                 },
               })
               .start();
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpServerSpans-streamed-unrouted/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/httpServerSpans-unrouted/instrument.mjs
similarity index 90%
rename from dev-packages/node-integration-tests/suites/tracing/httpServerSpans-streamed-unrouted/instrument.mjs
rename to dev-packages/node-integration-tests/suites/tracing/httpServerSpans-unrouted/instrument.mjs
index 53b9511a21f0..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpServerSpans-streamed-unrouted/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/httpServerSpans-unrouted/instrument.mjs
@@ -6,5 +6,4 @@ Sentry.init({
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpServerSpans-streamed-unrouted/server.mjs b/dev-packages/node-integration-tests/suites/tracing/httpServerSpans-unrouted/server.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/httpServerSpans-streamed-unrouted/server.mjs
rename to dev-packages/node-integration-tests/suites/tracing/httpServerSpans-unrouted/server.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpServerSpans-streamed-unrouted/test.ts b/dev-packages/node-integration-tests/suites/tracing/httpServerSpans-unrouted/test.ts
similarity index 96%
rename from dev-packages/node-integration-tests/suites/tracing/httpServerSpans-streamed-unrouted/test.ts
rename to dev-packages/node-integration-tests/suites/tracing/httpServerSpans-unrouted/test.ts
index d488bf9bcd5a..b2bbda3797d4 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpServerSpans-streamed-unrouted/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/httpServerSpans-unrouted/test.ts
@@ -1,7 +1,7 @@
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
-describe('httpServerSpans-streamed (no route)', () => {
+describe('httpServerSpans (no route)', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/requestData-streamed/instrument-with-datacollection-no-userinfo.mjs b/dev-packages/node-integration-tests/suites/tracing/requestData/instrument-with-datacollection-no-userinfo.mjs
similarity index 91%
rename from dev-packages/node-integration-tests/suites/tracing/requestData-streamed/instrument-with-datacollection-no-userinfo.mjs
rename to dev-packages/node-integration-tests/suites/tracing/requestData/instrument-with-datacollection-no-userinfo.mjs
index 0ae53602ff0c..d12edc0ab2fa 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requestData-streamed/instrument-with-datacollection-no-userinfo.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requestData/instrument-with-datacollection-no-userinfo.mjs
@@ -6,7 +6,6 @@ Sentry.init({
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
   dataCollection: {
     userInfo: false,
   },
diff --git a/dev-packages/node-integration-tests/suites/tracing/requestData-streamed/instrument-without-request-data.mjs b/dev-packages/node-integration-tests/suites/tracing/requestData/instrument-without-request-data.mjs
similarity index 92%
rename from dev-packages/node-integration-tests/suites/tracing/requestData-streamed/instrument-without-request-data.mjs
rename to dev-packages/node-integration-tests/suites/tracing/requestData/instrument-without-request-data.mjs
index c1f011300062..a68ae15e47b1 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requestData-streamed/instrument-without-request-data.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requestData/instrument-without-request-data.mjs
@@ -6,6 +6,5 @@ Sentry.init({
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
   integrations: defaults => defaults.filter(i => i.name !== 'RequestData'),
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/requestData-streamed/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requestData/instrument.mjs
similarity index 90%
rename from dev-packages/node-integration-tests/suites/tracing/requestData-streamed/instrument.mjs
rename to dev-packages/node-integration-tests/suites/tracing/requestData/instrument.mjs
index 53b9511a21f0..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requestData-streamed/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requestData/instrument.mjs
@@ -6,5 +6,4 @@ Sentry.init({
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/requestData-streamed/server.mjs b/dev-packages/node-integration-tests/suites/tracing/requestData/server.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/requestData-streamed/server.mjs
rename to dev-packages/node-integration-tests/suites/tracing/requestData/server.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/requestData-streamed/test.ts b/dev-packages/node-integration-tests/suites/tracing/requestData/test.ts
similarity index 99%
rename from dev-packages/node-integration-tests/suites/tracing/requestData-streamed/test.ts
rename to dev-packages/node-integration-tests/suites/tracing/requestData/test.ts
index 5a356e3d91e9..c6028677a738 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requestData-streamed/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requestData/test.ts
@@ -1,7 +1,7 @@
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
-describe('requestData-streamed', () => {
+describe('requestData', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });

From 31717a4faffed05c0caea9781da3108e92d5ed32 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 11:23:13 +0200
Subject: [PATCH 09/84] ref(server-utils): Share Orchestrion channel context
 (#25208)

Consolidate Orchestrion payload types into a shared interface used by
server-utils, NestJS, and Remix. Integrations extend it only for
narrower payload types or local bookkeeping, keeping the common fields
consistent without changing instrumentation behavior.

Fixes #25173

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../integrations/orchestrion-subscriber.ts    | 35 +++++++--------
 .../orchestrion-subscriber.test.ts            | 39 ++++++----------
 .../server/integrations/tracing-channel.ts    | 38 +++++++---------
 packages/remix/src/v3/assetServer.ts          |  5 +--
 packages/remix/src/v3/server/instrument.ts    | 44 +++++++++----------
 packages/server-utils/src/index.ts            |  1 +
 .../server-utils/src/integrations/amqplib.ts  | 20 ++-------
 .../src/integrations/anthropic.ts             | 12 ++---
 .../src/integrations/aws-sdk/index.ts         |  6 +--
 .../src/integrations/dataloader.ts            | 10 +----
 .../src/integrations/express/types.ts         |  8 ++--
 .../src/integrations/firebase/functions.ts    | 11 +----
 .../integrations/firebase/instrumentation.ts  | 12 ++---
 .../src/integrations/generic-pool.ts          |  7 +--
 .../src/integrations/google-genai.ts          | 15 ++-----
 .../src/integrations/graphql/index.ts         | 14 ++----
 .../src/integrations/hapi/index.ts            |  6 +--
 .../src/integrations/hono/honoIntegration.ts  | 11 +++--
 .../src/integrations/kafkajs/index.ts         |  6 +--
 .../server-utils/src/integrations/knex.ts     | 16 ++-----
 .../src/integrations/koa/index.ts             | 11 ++---
 .../src/integrations/langchain.ts             | 23 +++-------
 .../src/integrations/langgraph.ts             | 21 +++------
 .../src/integrations/lru-memoizer.ts          |  7 +--
 .../src/integrations/mastra-classifier.ts     | 16 ++-----
 .../server-utils/src/integrations/mastra.ts   | 21 +++------
 .../src/integrations/mcp-server.ts            | 10 ++---
 .../server-utils/src/integrations/mistral.ts  | 14 ++----
 .../src/integrations/mongodb/index.ts         |  4 +-
 .../src/integrations/mongoose/index.ts        |  7 +--
 .../server-utils/src/integrations/mysql.ts    |  8 +---
 .../src/integrations/mysql2/index.ts          |  9 +---
 .../src/integrations/openai-compatible.ts     | 16 ++-----
 .../server-utils/src/integrations/openai.ts   | 17 ++-----
 .../src/integrations/pi-durable.ts            | 20 +++------
 .../src/integrations/postgres-js.ts           | 11 +++--
 .../server-utils/src/integrations/postgres.ts |  8 +---
 .../src/integrations/prisma/orchestrion.ts    |  7 +--
 .../src/integrations/redis/index.ts           | 33 +++++++-------
 .../redis/ioredis-channel-subscriber.ts       | 10 ++---
 .../server-utils/src/integrations/tedious.ts  |  7 ++-
 .../server-utils/src/integrations/typesafe.ts | 15 +------
 .../vercel-ai-orchestrion-subscriber.ts       | 18 +++-----
 .../server-utils/src/orchestrion/types.ts     |  7 +++
 .../integrations/mastra/error-capture.test.ts |  3 +-
 .../integrations/postgres/postgres.test.ts    | 23 +++++-----
 46 files changed, 228 insertions(+), 434 deletions(-)
 create mode 100644 packages/server-utils/src/orchestrion/types.ts

diff --git a/packages/nestjs/src/integrations/orchestrion-subscriber.ts b/packages/nestjs/src/integrations/orchestrion-subscriber.ts
index e2ac9e7524f2..53e21dda735f 100644
--- a/packages/nestjs/src/integrations/orchestrion-subscriber.ts
+++ b/packages/nestjs/src/integrations/orchestrion-subscriber.ts
@@ -1,5 +1,6 @@
 import * as diagnosticsChannel from 'node:diagnostics_channel';
 import { debug, startInactiveSpan, waitForTracingChannelBinding } from '@sentry/core';
+import type { OrchestrionChannelContext } from '@sentry/server-utils';
 import { bindTracingChannelToSpan } from '@sentry/server-utils';
 import { nestjsChannels as CHANNELS } from '@sentry/server-utils/orchestrion/config';
 import { DEBUG_BUILD } from '../debug-build';
@@ -21,18 +22,6 @@ import { getAppCreationSpanOptions, wrapRequestContextHandler, wrapRouteHandler
 
 const NOOP = (): void => {};
 
-/**
- * The orchestrion tracing-channel context. `arguments` is the live call args
- * array; `result` is the return value, which an `end` handler may reassign to
- * substitute it (`traceSync`/`tracePromise` always return `ctx.result`).
- */
-interface ChannelContext {
-  arguments: unknown[];
-  moduleVersion?: string;
-  result?: unknown;
-  error?: unknown;
-}
-
 /**
  * Subscribe to a decorator channel (`Injectable`/`Catch`).
  *
@@ -42,7 +31,7 @@ interface ChannelContext {
  * spans later.
  */
 function subscribeDecoratorChannel<T>(channelName: string, patch: (target: T) => void): void {
-  diagnosticsChannel.tracingChannel<ChannelContext>(channelName).subscribe({
+  diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(channelName).subscribe({
     start(data) {
       const target = data.arguments?.[0] as T | undefined;
       if (target) {
@@ -90,8 +79,11 @@ function makeProcessorDecorator(original: AnyFn, queueName: string | undefined):
  * whatever `end` leaves there. `wrap` receives the original decorator and the
  * channel context (for the factory's args, e.g. the BullMQ queue name).
  */
-function subscribeFactoryDecorator(channelName: string, wrap: (decorator: AnyFn, data: ChannelContext) => AnyFn): void {
-  diagnosticsChannel.tracingChannel<ChannelContext>(channelName).subscribe({
+function subscribeFactoryDecorator(
+  channelName: string,
+  wrap: (decorator: AnyFn, data: OrchestrionChannelContext) => AnyFn,
+): void {
+  diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(channelName).subscribe({
     start: NOOP,
     end(data) {
       const decorator = data.result;
@@ -134,10 +126,13 @@ export function subscribeToNestChannels(): void {
   // calls below stay synchronous because the decorator channels fire at
   // module-load time, which a deferred subscription could miss.
   waitForTracingChannelBinding(() => {
-    bindTracingChannelToSpan(diagnosticsChannel.tracingChannel<ChannelContext>(CHANNELS.NESTJS_APP_CREATION), data => {
-      const moduleCls = data.arguments?.[0] as { name?: string } | undefined;
-      return startInactiveSpan(getAppCreationSpanOptions(data.moduleVersion, moduleCls?.name));
-    });
+    bindTracingChannelToSpan(
+      diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.NESTJS_APP_CREATION),
+      data => {
+        const moduleCls = data.arguments?.[0] as { name?: string } | undefined;
+        return startInactiveSpan(getAppCreationSpanOptions(data.moduleVersion, moduleCls?.name));
+      },
+    );
   });
 
   // request_context + request_handler. `RouterExecutionContext.create`
@@ -146,7 +141,7 @@ export function subscribeToNestChannels(): void {
   // (-> handler span per call) and `end` reassigns `data.result` to
   // replace the returned handler (-> request_context span per request).
   const routerMeta = new WeakMap<object, { instanceName: string; callbackName: string; moduleVersion?: string }>();
-  diagnosticsChannel.tracingChannel<ChannelContext>(CHANNELS.NESTJS_ROUTER_CONTEXT).subscribe({
+  diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.NESTJS_ROUTER_CONTEXT).subscribe({
     start(data) {
       const instance = data.arguments?.[0] as { constructor?: { name?: string } } | undefined;
       const callback = data.arguments?.[1];
diff --git a/packages/nestjs/test/integrations/orchestrion-subscriber.test.ts b/packages/nestjs/test/integrations/orchestrion-subscriber.test.ts
index 04d6d5598c63..37409a4312d1 100644
--- a/packages/nestjs/test/integrations/orchestrion-subscriber.test.ts
+++ b/packages/nestjs/test/integrations/orchestrion-subscriber.test.ts
@@ -15,6 +15,7 @@ import {
   spanToJSON,
 } from '@sentry/core';
 import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { OrchestrionChannelContext } from '@sentry/server-utils';
 import { nestjsChannels as CHANNELS } from '@sentry/server-utils/orchestrion/config';
 import { subscribeToNestChannels } from '../../src/integrations/orchestrion-subscriber';
 
@@ -94,13 +95,6 @@ function installTestAsyncContextStrategy(): void {
   });
 }
 
-interface NestFactoryCreateData {
-  arguments: unknown[];
-  moduleVersion?: string;
-  result?: unknown;
-  error?: unknown;
-}
-
 describe('NestJS orchestrion subscriber: app_creation', () => {
   afterEach(() => {
     setAsyncContextStrategy(undefined);
@@ -112,12 +106,12 @@ describe('NestJS orchestrion subscriber: app_creation', () => {
   // `data._sentrySpan`
   function captureSpan(): { getSpan: () => Span | undefined } {
     let span: Span | undefined;
-    const grab = (data: NestFactoryCreateData): void => {
+    const grab = (data: OrchestrionChannelContext): void => {
       span ??= (data as { _sentrySpan?: Span })._sentrySpan;
     };
     // The raw node `tracingChannel` type wants all five handlers; only
     // `end`/`asyncEnd` carry the bound span by the time it settles.
-    tracingChannel<NestFactoryCreateData>(CHANNELS.NESTJS_APP_CREATION).subscribe({
+    tracingChannel<OrchestrionChannelContext>(CHANNELS.NESTJS_APP_CREATION).subscribe({
       start: () => undefined,
       asyncStart: () => undefined,
       asyncEnd: grab,
@@ -133,7 +127,7 @@ describe('NestJS orchestrion subscriber: app_creation', () => {
     subscribeToNestChannels();
 
     const { getSpan } = captureSpan();
-    const channel = tracingChannel<NestFactoryCreateData>(CHANNELS.NESTJS_APP_CREATION);
+    const channel = tracingChannel<OrchestrionChannelContext>(CHANNELS.NESTJS_APP_CREATION);
 
     class AppModule {}
     await channel.tracePromise(async () => ({ app: true }), { arguments: [AppModule], moduleVersion: '10.4.1' });
@@ -160,7 +154,7 @@ describe('NestJS orchestrion subscriber: app_creation', () => {
     subscribeToNestChannels();
 
     const { getSpan } = captureSpan();
-    const channel = tracingChannel<NestFactoryCreateData>(CHANNELS.NESTJS_APP_CREATION);
+    const channel = tracingChannel<OrchestrionChannelContext>(CHANNELS.NESTJS_APP_CREATION);
 
     await channel.tracePromise(async () => ({ app: true }), { arguments: [] });
 
@@ -173,13 +167,6 @@ describe('NestJS orchestrion subscriber: app_creation', () => {
 
 type AnyFn = (this: unknown, ...args: unknown[]) => unknown;
 
-interface RouterCreateData {
-  arguments: unknown[];
-  moduleVersion?: string;
-  result?: unknown;
-  error?: unknown;
-}
-
 describe('NestJS orchestrion subscriber: request_context / request_handler', () => {
   afterEach(() => {
     setAsyncContextStrategy(undefined);
@@ -195,10 +182,10 @@ describe('NestJS orchestrion subscriber: request_context / request_handler', ()
     instance: object,
     callback: AnyFn,
     moduleVersion: string | undefined,
-    makeHandler: (data: RouterCreateData) => AnyFn,
+    makeHandler: (data: OrchestrionChannelContext) => AnyFn,
   ): { effectiveHandler: AnyFn; wrappedCallback: AnyFn } {
-    const channel = tracingChannel<RouterCreateData>(CHANNELS.NESTJS_ROUTER_CONTEXT);
-    const data: RouterCreateData = { arguments: [instance, callback], moduleVersion };
+    const channel = tracingChannel<OrchestrionChannelContext>(CHANNELS.NESTJS_ROUTER_CONTEXT);
+    const data: OrchestrionChannelContext = { arguments: [instance, callback], moduleVersion };
     channel.traceSync(() => makeHandler(data), data);
     return { effectiveHandler: data.result as AnyFn, wrappedCallback: data.arguments[1] as AnyFn };
   }
@@ -340,7 +327,7 @@ describe('NestJS orchestrion subscriber: @Injectable (middleware/guard/pipe/inte
   // Fire the @Injectable channel against `target` (as if its decorator arrow
   // ran), so the subscriber's `start` patches `target.prototype`.
   function applyInjectable(target: object): void {
-    tracingChannel<{ arguments: unknown[] }>(CHANNELS.NESTJS_INJECTABLE).traceSync(() => undefined, {
+    tracingChannel<OrchestrionChannelContext>(CHANNELS.NESTJS_INJECTABLE).traceSync(() => undefined, {
       arguments: [target],
     });
   }
@@ -643,7 +630,7 @@ describe('NestJS orchestrion subscriber: @Catch (exception filter)', () => {
   });
 
   function applyCatch(target: object): void {
-    tracingChannel<{ arguments: unknown[] }>(CHANNELS.NESTJS_CATCH).traceSync(() => undefined, {
+    tracingChannel<OrchestrionChannelContext>(CHANNELS.NESTJS_CATCH).traceSync(() => undefined, {
       arguments: [target],
     });
   }
@@ -697,7 +684,7 @@ describe('NestJS orchestrion subscriber: @Catch (exception filter)', () => {
   // @Catch first. Because the two passes use separate patched-flags, both
   // must wrap their own methods regardless of which channel fires first.
   function fireInjectable(target: object): void {
-    tracingChannel<{ arguments: unknown[] }>(CHANNELS.NESTJS_INJECTABLE).traceSync(() => undefined, {
+    tracingChannel<OrchestrionChannelContext>(CHANNELS.NESTJS_INJECTABLE).traceSync(() => undefined, {
       arguments: [target],
     });
   }
@@ -801,8 +788,8 @@ describe('NestJS orchestrion subscriber: schedule / event / bullmq', () => {
   // to the factory's return (our `originalDecorator`), then the subscriber's
   // `end` reassigns `data.result`. Returns effective (wrapped) decorator.
   function driveFactory(channelName: string, factoryArgs: unknown[], originalDecorator: AnyFn): AnyFn {
-    const data: { arguments: unknown[]; result?: unknown } = { arguments: factoryArgs };
-    tracingChannel<{ arguments: unknown[]; result?: unknown }>(channelName).traceSync(() => originalDecorator, data);
+    const data: OrchestrionChannelContext = { arguments: factoryArgs };
+    tracingChannel<OrchestrionChannelContext>(channelName).traceSync(() => originalDecorator, data);
     return data.result as AnyFn;
   }
 
diff --git a/packages/remix/src/server/integrations/tracing-channel.ts b/packages/remix/src/server/integrations/tracing-channel.ts
index 6ab1645ca503..8e93813a19dd 100644
--- a/packages/remix/src/server/integrations/tracing-channel.ts
+++ b/packages/remix/src/server/integrations/tracing-channel.ts
@@ -14,6 +14,7 @@ import {
   waitForTracingChannelBinding,
   filterCollectedUrl,
 } from '@sentry/core';
+import type { OrchestrionChannelContext } from '@sentry/server-utils';
 import { bindTracingChannelToSpan } from '@sentry/server-utils';
 import {
   SENTRY_SEGMENT_NAME_SOURCE,
@@ -41,17 +42,6 @@ const NOOP = (): void => {};
 const MATCH_ROUTE_ID = 'match.route.id';
 const MATCH_PARAMS = 'match.params';
 
-/**
- * The shape orchestrion's transform attaches to a tracing-channel `context` object. Documented here
- * rather than imported because orchestrion's runtime doesn't export it.
- */
-interface ChannelContext {
-  // The live `arguments` of the wrapped call.
-  arguments: unknown[];
-  result?: unknown;
-  error?: unknown;
-}
-
 // `callRouteLoader`/`callRouteAction` receive a single options object as `arguments[0]`.
 interface RouteCallParams {
   request?: Request;
@@ -61,7 +51,7 @@ interface RouteCallParams {
 
 // The in-flight form-data read, started at span start (before the action consumes the body) so it
 // overlaps the action's execution rather than starting after it settles.
-interface ActionChannelContext extends ChannelContext {
+interface ActionChannelContext extends OrchestrionChannelContext {
   _sentryFormData?: Promise<FormData>;
 }
 
@@ -140,7 +130,7 @@ function enrichActiveSpanWithRoute(result: unknown): void {
 }
 
 function subscribeRequestHandler(): void {
-  bindTracingChannelToSpan<ChannelContext>(
+  bindTracingChannelToSpan<OrchestrionChannelContext>(
     diagnosticsChannel.tracingChannel(remixChannels.REMIX_REQUEST_HANDLER),
     data => {
       const requestAttributes = getRequestAttributes(data.arguments[0]);
@@ -178,19 +168,21 @@ function subscribeRequestHandler(): void {
 function subscribeMatchServerRoutes(): void {
   // `matchServerRoutes` is synchronous, so only the `end` event carries a result; the rest are
   // no-ops. `subscribe` types demand a handler for each channel.
-  diagnosticsChannel.tracingChannel<ChannelContext, ChannelContext>(remixChannels.REMIX_MATCH_SERVER_ROUTES).subscribe({
-    start: NOOP,
-    end(data) {
-      enrichActiveSpanWithRoute(data.result);
-    },
-    asyncStart: NOOP,
-    asyncEnd: NOOP,
-    error: NOOP,
-  });
+  diagnosticsChannel
+    .tracingChannel<OrchestrionChannelContext, OrchestrionChannelContext>(remixChannels.REMIX_MATCH_SERVER_ROUTES)
+    .subscribe({
+      start: NOOP,
+      end(data) {
+        enrichActiveSpanWithRoute(data.result);
+      },
+      asyncStart: NOOP,
+      asyncEnd: NOOP,
+      error: NOOP,
+    });
 }
 
 function subscribeCallRouteLoader(): void {
-  bindTracingChannelToSpan<ChannelContext>(
+  bindTracingChannelToSpan<OrchestrionChannelContext>(
     diagnosticsChannel.tracingChannel(remixChannels.REMIX_CALL_ROUTE_LOADER),
     data => {
       const params = (data.arguments[0] ?? {}) as RouteCallParams;
diff --git a/packages/remix/src/v3/assetServer.ts b/packages/remix/src/v3/assetServer.ts
index 88ce5060662a..2c1c1bd649f2 100644
--- a/packages/remix/src/v3/assetServer.ts
+++ b/packages/remix/src/v3/assetServer.ts
@@ -1,5 +1,6 @@
 import * as diagnosticsChannel from 'node:diagnostics_channel';
 import { consoleSandbox } from '@sentry/core';
+import type { OrchestrionChannelContext } from '@sentry/server-utils';
 import { remixV3Channels } from '@sentry/server-utils/orchestrion/config';
 import { addDebugIdToSourceMap, findDebugId, getDebugId, injectDebugIdSnippet } from './debugId';
 import { getShimUrl, isOrchestrionLoader, orchestrionLoader, resolveShimPath } from './orchestrionLoader';
@@ -39,9 +40,7 @@ interface AssetServer {
   fetch: (request: Request) => Promise<Response | null>;
 }
 
-interface CreateAssetServerContext {
-  arguments: unknown[];
-  result?: unknown;
+interface CreateAssetServerContext extends OrchestrionChannelContext {
   _sentryHideSourceMaps?: boolean;
 }
 
diff --git a/packages/remix/src/v3/server/instrument.ts b/packages/remix/src/v3/server/instrument.ts
index 2fee25db560b..f348c9ae01b0 100644
--- a/packages/remix/src/v3/server/instrument.ts
+++ b/packages/remix/src/v3/server/instrument.ts
@@ -1,6 +1,7 @@
 import * as diagnosticsChannel from 'node:diagnostics_channel';
 import { createMultiMatcher } from 'remix/route-pattern/match';
 import { consoleSandbox } from '@sentry/core';
+import type { OrchestrionChannelContext } from '@sentry/server-utils';
 import { remixV3Channels } from '@sentry/server-utils/orchestrion/config';
 
 import type { MatcherLike, RequestListenerOptionsLike, RouterOptionsLike } from '../types';
@@ -9,11 +10,6 @@ import { sentryRemixMiddleware } from './middleware';
 
 const NOOP = (): void => {};
 
-/** The call's arguments, as orchestrion's transform attaches them to a tracing channel context. */
-interface ChannelContext {
-  arguments: unknown[];
-}
-
 // Marks an options object already injected into, so the same mutation cannot be applied twice.
 const INJECTED = Symbol.for('SentryRemixV3Injected');
 
@@ -41,22 +37,24 @@ export function instrumentRemixV3(): void {
 }
 
 function subscribeToCreateRouter(): void {
-  diagnosticsChannel.tracingChannel<ChannelContext, ChannelContext>(remixV3Channels.REMIX_V3_CREATE_ROUTER).subscribe({
-    start(data) {
-      // Node rethrows anything this handler throws as an uncaught exception, which would kill an app
-      // that runs fine without Sentry. Frozen options, a non-writable property and a `route-pattern`
-      // copy that cannot build a matcher all reach here, so the router is left uninstrumented instead.
-      try {
-        injectRouterMiddleware(ensureOptions(data.arguments));
-      } catch {
-        // Ignored on purpose.
-      }
-    },
-    end: NOOP,
-    asyncStart: NOOP,
-    asyncEnd: NOOP,
-    error: NOOP,
-  });
+  diagnosticsChannel
+    .tracingChannel<OrchestrionChannelContext, OrchestrionChannelContext>(remixV3Channels.REMIX_V3_CREATE_ROUTER)
+    .subscribe({
+      start(data) {
+        // Node rethrows anything this handler throws as an uncaught exception, which would kill an app
+        // that runs fine without Sentry. Frozen options, a non-writable property and a `route-pattern`
+        // copy that cannot build a matcher all reach here, so the router is left uninstrumented instead.
+        try {
+          injectRouterMiddleware(ensureOptions(data.arguments));
+        } catch {
+          // Ignored on purpose.
+        }
+      },
+      end: NOOP,
+      asyncStart: NOOP,
+      asyncEnd: NOOP,
+      error: NOOP,
+    });
 }
 
 /**
@@ -66,7 +64,9 @@ function subscribeToCreateRouter(): void {
  */
 function subscribeToCreateRequestListener(): void {
   diagnosticsChannel
-    .tracingChannel<ChannelContext, ChannelContext>(remixV3Channels.REMIX_V3_CREATE_REQUEST_LISTENER)
+    .tracingChannel<OrchestrionChannelContext, OrchestrionChannelContext>(
+      remixV3Channels.REMIX_V3_CREATE_REQUEST_LISTENER,
+    )
     .subscribe({
       start(data) {
         try {
diff --git a/packages/server-utils/src/index.ts b/packages/server-utils/src/index.ts
index 446812f8eed5..22b7470fa7b7 100644
--- a/packages/server-utils/src/index.ts
+++ b/packages/server-utils/src/index.ts
@@ -8,6 +8,7 @@ import { attachHapiErrorHandler as _attachHapiErrorHandler } from './integration
 export { bindTracingChannelToSpan } from './tracing-channel';
 export type { TracingChannelPayloadWithSpan } from './tracing-channel';
 export type { InstrumentationConfig } from './orchestrion/apmTypes';
+export type { OrchestrionChannelContext } from './orchestrion/types';
 // Runtime target of the bundler-injected module snippet. The snippet imports it
 // from this entry alongside the module's subscriber factory (see
 // `orchestrion/bundler/moduleInjectedTransform.ts`); it is a plain runtime
diff --git a/packages/server-utils/src/integrations/amqplib.ts b/packages/server-utils/src/integrations/amqplib.ts
index 9768cf27a26c..ec1d29db3b66 100644
--- a/packages/server-utils/src/integrations/amqplib.ts
+++ b/packages/server-utils/src/integrations/amqplib.ts
@@ -28,6 +28,7 @@ import {
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
 import { QUEUE_PROCESS, QUEUE_PUBLISH } from '@sentry/conventions/op';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { amqplibModuleNames } from '../orchestrion/config/amqplib';
 import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation';
 import { CHANNELS } from '../orchestrion/channels';
@@ -125,16 +126,8 @@ interface ChannelLike {
   [CHANNEL_IS_CONFIRM_PUBLISHING]?: boolean;
 }
 
-/**
- * The shape orchestrion's transform attaches to the tracing-channel `context`. Documented here rather
- * than imported because orchestrion's runtime doesn't export it.
- */
-interface AmqpChannelContext {
-  // The live args array passed to the wrapped call.
-  arguments: unknown[];
+interface AmqpChannelContext extends OrchestrionChannelContext {
   self?: ChannelLike;
-  result?: unknown;
-  error?: unknown;
 }
 
 interface AmqpDispatchContext extends AmqpChannelContext {
@@ -148,11 +141,6 @@ interface AmqpConsumeContext extends AmqpChannelContext {
   _sentryPendingConsumer?: PendingConsumer;
 }
 
-interface AmqpConnectContext {
-  arguments?: unknown[];
-  result?: unknown;
-}
-
 const NOOP = (): void => {};
 
 const _amqplibIntegration = (() => {
@@ -352,11 +340,11 @@ function subscribeSettle(): void {
 
 /** Captures connection attributes on the connection object for span-time reads via `channel.connection`. */
 function subscribeConnect(): void {
-  const channel = diagnosticsChannel.tracingChannel<AmqpConnectContext>(CHANNELS.AMQPLIB_CONNECT);
+  const channel = diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.AMQPLIB_CONNECT);
   // A `start` subscriber is required for orchestrion to wrap the callback-style `connect` at all.
   channel.start.subscribe(NOOP);
   channel.asyncEnd.subscribe(message => {
-    const data = message as AmqpConnectContext;
+    const data = message as OrchestrionChannelContext;
     const conn = data.result as ConnectionLike | undefined;
     if (!conn || typeof conn !== 'object') {
       return;
diff --git a/packages/server-utils/src/integrations/anthropic.ts b/packages/server-utils/src/integrations/anthropic.ts
index d14d3cbb2f6a..a45bbf02496f 100644
--- a/packages/server-utils/src/integrations/anthropic.ts
+++ b/packages/server-utils/src/integrations/anthropic.ts
@@ -14,6 +14,7 @@ import { wrapApiPromiseResponse } from '../ai/core/apiPromise';
 import { addPrivateRequestAttributes, addResponseAttributes, extractRequestAttributes } from '../ai/anthropic-ai';
 import { instrumentAsyncIterableStream, instrumentMessageStream } from '../ai/anthropic-ai/streaming';
 import type { AnthropicAiOptions, AnthropicAiResponse } from '../ai/anthropic-ai/types';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../tracing-channel';
 import { anthropicAiModuleNames } from '../orchestrion/config/anthropic-ai';
@@ -37,11 +38,6 @@ const INSTRUMENTED_CHANNELS = [
 
 type StreamMode = (typeof INSTRUMENTED_CHANNELS)[number]['stream'];
 
-interface AnthropicChannelContext {
-  arguments: unknown[];
-  result?: unknown;
-}
-
 const _anthropicAIIntegration = ((options: AnthropicAiOptions = {}) => {
   return {
     name: INTEGRATION_NAME,
@@ -54,7 +50,7 @@ const _anthropicAIIntegration = ((options: AnthropicAiOptions = {}) => {
 function instrumentAnthropic(options: AnthropicAiOptions): void {
   for (const { channel, operation, stream } of INSTRUMENTED_CHANNELS) {
     bindTracingChannelToSpan(
-      diagnosticsChannel.tracingChannel<AnthropicChannelContext>(channel),
+      diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(channel),
       data => createGenAiSpan(data, operation, options, stream),
       {
         beforeSpanEnd: (span, data) => {
@@ -85,7 +81,7 @@ function instrumentAnthropic(options: AnthropicAiOptions): void {
  * Returning `undefined` opts the payload out so no span is opened.
  */
 function createGenAiSpan(
-  data: AnthropicChannelContext,
+  data: OrchestrionChannelContext,
   operation: string,
   options: AnthropicAiOptions,
   stream: StreamMode,
@@ -191,7 +187,7 @@ function isMessageStream(value: unknown): value is MessageStreamEmitter {
  */
 function wrapStreamResult(
   span: Span,
-  data: AnthropicChannelContext,
+  data: OrchestrionChannelContext,
   stream: StreamMode,
   options: AnthropicAiOptions,
 ): boolean {
diff --git a/packages/server-utils/src/integrations/aws-sdk/index.ts b/packages/server-utils/src/integrations/aws-sdk/index.ts
index 25a75931deb7..95b38b41eece 100644
--- a/packages/server-utils/src/integrations/aws-sdk/index.ts
+++ b/packages/server-utils/src/integrations/aws-sdk/index.ts
@@ -10,6 +10,7 @@ import {
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
 import { RPC } from '@sentry/conventions/op';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { awsSdkModuleNames } from '../../orchestrion/config/aws-sdk';
 import { invokeOrchestrionInstrumentation } from '../../orchestrion/instrumentation';
@@ -26,11 +27,8 @@ const INTEGRATION_NAME = 'Aws' as const;
 // The context orchestrion's transform attaches to the channel: `arguments` is the live args of the
 // wrapped `Client.prototype.send` call (`[command, ...]`), `self` the client, `result`/`error` the
 // settled value. The `_sentry*` fields are stashed by us across the call's lifecycle.
-interface AwsSendChannelContext {
-  arguments: unknown[];
+interface AwsSendChannelContext extends OrchestrionChannelContext {
   self?: { config?: AwsClientConfig; constructor?: { name?: string } };
-  result?: unknown;
-  error?: unknown;
   _sentryNormalizedRequest?: NormalizedRequest;
   _sentryRequestMetadata?: RequestMetadata;
   _sentryRegion?: { settled: boolean; promise: Promise<void> };
diff --git a/packages/server-utils/src/integrations/dataloader.ts b/packages/server-utils/src/integrations/dataloader.ts
index 89decb7338e9..5fb50a577325 100644
--- a/packages/server-utils/src/integrations/dataloader.ts
+++ b/packages/server-utils/src/integrations/dataloader.ts
@@ -21,6 +21,7 @@ import {
   waitForTracingChannelBinding,
 } from '@sentry/core';
 import { DEBUG_BUILD } from '../debug-build';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import type { ChannelName } from '../orchestrion/channels';
 import { CHANNELS } from '../orchestrion/channels';
 import type { TracingChannelPayloadWithSpan } from '../tracing-channel';
@@ -63,15 +64,8 @@ interface DataLoaderInstance {
   _batch?: DataLoaderBatch | null;
 }
 
-/**
- * The shape orchestrion's transform attaches to the tracing-channel `context`. Documented here rather
- * than imported because orchestrion's runtime doesn't export it.
- */
-interface DataLoaderChannelContext {
-  arguments: unknown[];
+interface DataLoaderChannelContext extends OrchestrionChannelContext {
   self?: DataLoaderInstance;
-  result?: unknown;
-  error?: unknown;
 }
 
 // Marks a wrapped `batchLoadFn` so a re-used loader (or a double construct) isn't wrapped twice.
diff --git a/packages/server-utils/src/integrations/express/types.ts b/packages/server-utils/src/integrations/express/types.ts
index 5536f524e849..ea1d979a18af 100644
--- a/packages/server-utils/src/integrations/express/types.ts
+++ b/packages/server-utils/src/integrations/express/types.ts
@@ -1,3 +1,4 @@
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import type { Span } from '@sentry/core';
 
 export type ExpressLayerType = 'router' | 'middleware' | 'request_handler';
@@ -40,13 +41,11 @@ export interface ExpressResponse {
  * for this layer by `bindTracingChannelToSpan`, and `error` is present on the
  * channel's `error` event.
  */
-export interface HandleChannelContext {
+export interface HandleChannelContext extends OrchestrionChannelContext {
   self?: ExpressLayer;
-  arguments?: unknown[];
   _sentryCleanup?: () => void;
   _sentryStoredLayer?: boolean;
   _sentrySpan?: Span;
-  error?: unknown;
 }
 
 /**
@@ -55,9 +54,8 @@ export interface HandleChannelContext {
  * the last entry in `stack`) and `arguments` are the registration args (the
  * first of which is the path pattern).
  */
-export interface RegistrationChannelContext {
+export interface RegistrationChannelContext extends OrchestrionChannelContext {
   self?: { stack?: ExpressLayer[] };
-  arguments?: unknown[];
 }
 
 /** An Express error carrying an optional HTTP status, in the various shapes middleware use. */
diff --git a/packages/server-utils/src/integrations/firebase/functions.ts b/packages/server-utils/src/integrations/firebase/functions.ts
index 75fd439a3cd6..1ad3d8c03f90 100644
--- a/packages/server-utils/src/integrations/firebase/functions.ts
+++ b/packages/server-utils/src/integrations/firebase/functions.ts
@@ -1,3 +1,4 @@
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import {
   FAAS_NAME,
   FAAS_TRIGGER,
@@ -26,14 +27,6 @@ const WRAPPED = '__sentryFirebaseWrapped';
 
 type Handler = (this: unknown, ...args: unknown[]) => unknown;
 
-interface FunctionsChannelContext {
-  // The live args of the `onX(...)` registration call. firebase-functions accepts either
-  // `onX(handler)` or `onX(documentOrOptions, handler)`, so the handler is `arguments[0]` when it's a
-  // function, otherwise `arguments[1]`. Mutating the entry here swaps in the wrapped handler.
-  arguments: unknown[];
-  self?: unknown;
-}
-
 /**
  * Rewrap the handler argument of a firebase-functions `onX(...)` registration so the returned cloud
  * function opens a `SERVER` span (and error boundary) each time it's invoked. Runs as the tracing
@@ -42,7 +35,7 @@ interface FunctionsChannelContext {
  * The registration call itself is trivial and synchronous, so — unlike the firestore path — this does
  * not bind a span to the channel; it only uses the channel as an injection point.
  */
-export function wrapFunctionsRegistration(data: FunctionsChannelContext, triggerType: string): void {
+export function wrapFunctionsRegistration(data: OrchestrionChannelContext, triggerType: string): void {
   const args = data.arguments;
   if (!Array.isArray(args) || args.length === 0) {
     return;
diff --git a/packages/server-utils/src/integrations/firebase/instrumentation.ts b/packages/server-utils/src/integrations/firebase/instrumentation.ts
index 5fcadfd2ae45..b10534aea30a 100644
--- a/packages/server-utils/src/integrations/firebase/instrumentation.ts
+++ b/packages/server-utils/src/integrations/firebase/instrumentation.ts
@@ -1,4 +1,5 @@
 import * as diagnosticsChannel from '../../utils/diagnosticsChannel';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { bindTracingChannelToSpan, safeChannelCallback } from '../../tracing-channel';
 import type { FirestoreReference } from './firestore-types';
@@ -7,13 +8,6 @@ import { wrapFunctionsRegistration } from './functions';
 
 // The context orchestrion's transform attaches to each firestore channel: `arguments` is the live args
 // of the wrapped `addDoc`/`getDocs`/`setDoc`/`deleteDoc` call, `arguments[0]` the reference.
-interface FirestoreChannelContext {
-  arguments: unknown[];
-  self?: unknown;
-  result?: unknown;
-  error?: unknown;
-}
-
 // The firestore operations, keyed by channel. `useParent` mirrors the OTel integration: `setDoc`/
 // `deleteDoc` take a *document* reference but the span is named after its parent *collection*.
 const FIRESTORE_OPERATIONS: Array<{ channel: string; spanName: string; useParent: boolean }> = [
@@ -43,7 +37,7 @@ const NOOP = (): void => {};
 
 export function instrumentFirebase() {
   for (const { channel, spanName, useParent } of FIRESTORE_OPERATIONS) {
-    bindTracingChannelToSpan(diagnosticsChannel.tracingChannel<FirestoreChannelContext>(channel), data =>
+    bindTracingChannelToSpan(diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(channel), data =>
       safeChannelCallback(() => {
         const reference = data.arguments[0] as FirestoreReference | undefined;
         if (!reference) {
@@ -61,7 +55,7 @@ export function instrumentFirebase() {
     // span inside that wrapper. The other lifecycle events are irrelevant, so no-op them.
     diagnosticsChannel.tracingChannel(channel).subscribe({
       start: data =>
-        safeChannelCallback(() => wrapFunctionsRegistration(data as { arguments: unknown[] }, triggerType)),
+        safeChannelCallback(() => wrapFunctionsRegistration(data as OrchestrionChannelContext, triggerType)),
       end: NOOP,
       asyncStart: NOOP,
       asyncEnd: NOOP,
diff --git a/packages/server-utils/src/integrations/generic-pool.ts b/packages/server-utils/src/integrations/generic-pool.ts
index f5236f5a364c..ca27d9bd29ff 100644
--- a/packages/server-utils/src/integrations/generic-pool.ts
+++ b/packages/server-utils/src/integrations/generic-pool.ts
@@ -3,6 +3,7 @@ import { SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { DB } from '@sentry/conventions/op';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration, startInactiveSpan } from '@sentry/core';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { genericPoolModuleNames } from '../orchestrion/config/generic-pool';
 import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation';
@@ -12,10 +13,6 @@ import { bindTracingChannelToSpan } from '../tracing-channel';
 // 'GenericPool' integration is omitted from the default set.
 const INTEGRATION_NAME = 'GenericPool' as const;
 
-interface GenericPoolAcquireContext {
-  arguments: unknown[];
-}
-
 const _genericPoolIntegration = (() => {
   return {
     name: INTEGRATION_NAME,
@@ -35,7 +32,7 @@ export const genericPoolIntegration = defineIntegration(_genericPoolIntegration)
 
 function instrumentGenericPool(): void {
   bindTracingChannelToSpan(
-    diagnosticsChannel.tracingChannel<GenericPoolAcquireContext>(CHANNELS.GENERIC_POOL_ACQUIRE),
+    diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.GENERIC_POOL_ACQUIRE),
     () =>
       startInactiveSpan({
         name: 'generic-pool.acquire',
diff --git a/packages/server-utils/src/integrations/google-genai.ts b/packages/server-utils/src/integrations/google-genai.ts
index b191c503df5b..846ba9ae40cf 100644
--- a/packages/server-utils/src/integrations/google-genai.ts
+++ b/packages/server-utils/src/integrations/google-genai.ts
@@ -19,6 +19,7 @@ import {
 } from '../ai/google-genai';
 import { instrumentStream } from '../ai/google-genai/streaming';
 import type { GoogleGenAIOptions, GoogleGenAIResponse } from '../ai/google-genai/types';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../tracing-channel';
 import { googleGenAiModuleNames } from '../orchestrion/config/google-genai';
@@ -37,14 +38,6 @@ const INSTRUMENTED_CHANNELS = [
   { channel: CHANNELS.GOOGLE_GENAI_CHAT, operation: 'chat' },
 ] as const;
 
-interface GoogleGenAIChannelContext {
-  arguments: unknown[];
-  // The transform stashes the call's `this` here, which chat methods need since the model lives on
-  // the `Chat` instance (`this.model`/`this.modelVersion`), not in the call arguments.
-  self?: unknown;
-  result?: unknown;
-}
-
 const _googleGenAIIntegration = ((options: GoogleGenAIOptions = {}) => {
   return {
     name: INTEGRATION_NAME,
@@ -57,7 +50,7 @@ const _googleGenAIIntegration = ((options: GoogleGenAIOptions = {}) => {
 function instrumentGoogleGenai(options: GoogleGenAIOptions): void {
   for (const { channel, operation } of INSTRUMENTED_CHANNELS) {
     bindTracingChannelToSpan(
-      diagnosticsChannel.tracingChannel<GoogleGenAIChannelContext>(channel),
+      diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(channel),
       data => createGenAiSpan(data, operation, options),
       {
         beforeSpanEnd: (span, data) => {
@@ -81,7 +74,7 @@ function instrumentGoogleGenai(options: GoogleGenAIOptions): void {
  * Returning `undefined` opts the payload out so no span is opened.
  */
 function createGenAiSpan(
-  data: GoogleGenAIChannelContext,
+  data: OrchestrionChannelContext,
   operation: string,
   options: GoogleGenAIOptions,
 ): Span | undefined {
@@ -143,7 +136,7 @@ function isAsyncIterable(value: unknown): value is AsyncIterableStream {
  * For a stream we patch `result[Symbol.asyncIterator]` in place so `instrumentStream` ends the
  * span when iteration finishes.
  */
-function wrapStreamResult(span: Span, data: GoogleGenAIChannelContext, options: GoogleGenAIOptions): boolean {
+function wrapStreamResult(span: Span, data: OrchestrionChannelContext, options: GoogleGenAIOptions): boolean {
   const result = data.result;
   if (!isAsyncIterable(result)) {
     return false;
diff --git a/packages/server-utils/src/integrations/graphql/index.ts b/packages/server-utils/src/integrations/graphql/index.ts
index e0397b1ac769..b217b84e45f5 100644
--- a/packages/server-utils/src/integrations/graphql/index.ts
+++ b/packages/server-utils/src/integrations/graphql/index.ts
@@ -2,6 +2,7 @@ import * as diagnosticsChannel from '../../utils/diagnosticsChannel';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration, waitForTracingChannelBinding } from '@sentry/core';
 import { subscribeGraphqlDiagnosticChannels, type GraphQLOptions } from './graphql-dc-subscriber';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { graphqlModuleNames } from '../../orchestrion/config/graphql';
 import { invokeOrchestrionInstrumentation } from '../../orchestrion/instrumentation';
@@ -20,13 +21,6 @@ const INTEGRATION_NAME = 'Graphql' as const;
 
 // The context orchestrion's transform attaches to each channel: `arguments` is the live args of the
 // wrapped call, `result` the settled return value.
-interface GraphqlChannelContext {
-  arguments: unknown[];
-  self?: unknown;
-  result?: unknown;
-  error?: unknown;
-}
-
 function getOptionsWithDefaults(options: GraphQLOptions): GraphqlResolvedConfig {
   return {
     ignoreResolveSpans: options.ignoreResolveSpans !== false,
@@ -51,18 +45,18 @@ const _graphqlIntegration = ((options: GraphQLOptions = {}) => {
 }) satisfies IntegrationFn;
 
 function instrumentGraphql(config: GraphqlResolvedConfig, getConfig: () => GraphqlResolvedConfig): void {
-  bindTracingChannelToSpan(diagnosticsChannel.tracingChannel<GraphqlChannelContext>(CHANNELS.GRAPHQL_PARSE), () =>
+  bindTracingChannelToSpan(diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.GRAPHQL_PARSE), () =>
     safeChannelCallback(() => startParseSpan()),
   );
 
   bindTracingChannelToSpan(
-    diagnosticsChannel.tracingChannel<GraphqlChannelContext>(CHANNELS.GRAPHQL_VALIDATE),
+    diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.GRAPHQL_VALIDATE),
     data => safeChannelCallback(() => startValidateSpan(data.arguments[1])),
     { beforeSpanEnd: (span, data) => safeChannelCallback(() => finalizeValidateSpan(span, data.result)) },
   );
 
   bindTracingChannelToSpan(
-    diagnosticsChannel.tracingChannel<GraphqlChannelContext>(CHANNELS.GRAPHQL_EXECUTE),
+    diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.GRAPHQL_EXECUTE),
     data => safeChannelCallback(() => startExecuteSpan(data.arguments, data.self, config, getConfig)),
     { beforeSpanEnd: (span, data) => safeChannelCallback(() => finalizeExecuteSpan(span, data.result)) },
   );
diff --git a/packages/server-utils/src/integrations/hapi/index.ts b/packages/server-utils/src/integrations/hapi/index.ts
index e7b8af943694..a4e83be91e1d 100644
--- a/packages/server-utils/src/integrations/hapi/index.ts
+++ b/packages/server-utils/src/integrations/hapi/index.ts
@@ -1,6 +1,7 @@
 import * as diagnosticsChannel from '../../utils/diagnosticsChannel';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { hapiModuleNames } from '../../orchestrion/config/hapi';
 import { invokeOrchestrionInstrumentation } from '../../orchestrion/instrumentation';
@@ -46,8 +47,7 @@ interface HapiIntegrationOptions {
  * the hapi server instance: the root server has `self.realm.plugin === undefined`,
  * while a plugin's clone server exposes the registering plugin's name there.
  */
-interface HapiChannelContext {
-  arguments: unknown[];
+interface HapiChannelContext extends OrchestrionChannelContext {
   self?: { realm?: { plugin?: string } };
 }
 
@@ -55,7 +55,7 @@ interface HapiChannelContext {
  * The `start`/`initialize` channel `context` shape: `self` is the live server
  * we attach the auto-registered error listener to.
  */
-interface HapiServerContext {
+interface HapiServerContext extends OrchestrionChannelContext {
   self?: HapiServer;
 }
 
diff --git a/packages/server-utils/src/integrations/hono/honoIntegration.ts b/packages/server-utils/src/integrations/hono/honoIntegration.ts
index d62e949125ef..c2b504db2dab 100644
--- a/packages/server-utils/src/integrations/hono/honoIntegration.ts
+++ b/packages/server-utils/src/integrations/hono/honoIntegration.ts
@@ -6,6 +6,7 @@ import type { IntegrationFn } from '@sentry/core';
 import { debug, defineIntegration, startInactiveSpan } from '@sentry/core';
 import { DEBUG_BUILD } from '../../debug-build';
 import type { Env, GetConnInfo, Hono, MiddlewareHandler } from './honoTypes';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { honoModuleNames } from '../../orchestrion/config/hono';
 import { invokeOrchestrionInstrumentation } from '../../orchestrion/instrumentation';
@@ -82,8 +83,6 @@ export function honoMiddleware<E extends Env>(app: Hono<E>, options: HonoIntegra
   });
 }
 
-type ChannelArgs = { arguments: unknown[] };
-
 // A Hono `matchResult[0]` entry: `[[handler, routeMeta], paramIndexMap]` — `compose` runs the
 // handler (`entry[0][0]`) and the `matchedRoutes` getter reads `routeMeta` (`entry[0][1]`).
 // oxlint-disable-next-line typescript/no-explicit-any
@@ -100,7 +99,7 @@ type MatchedHandlerEntry = [[any, any], any];
  * Running per request (no module-scope state) is what lets this work on Cloudflare.
  */
 function injectHonoInstrumentation(
-  message: ChannelArgs,
+  message: OrchestrionChannelContext,
   requestMiddleware: MiddlewareHandler,
   injectedHandlerLists: WeakSet<object>,
 ): void {
@@ -155,7 +154,7 @@ function injectHonoInstrumentation(
  */
 function instrumentInternalRequests(): void {
   bindTracingChannelToSpan(
-    diagnosticsChannel.tracingChannel<ChannelArgs>(CHANNELS.HONO_REQUEST),
+    diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.HONO_REQUEST),
     data => {
       // Alongside the manual middleware, the instance `app.request` Proxy has already opened this
       // span and is calling through — returning `undefined` (no span) avoids nesting a duplicate.
@@ -202,9 +201,9 @@ function instrumentHono(options: HonoIntegrationOptions): void {
 
   // The Context constructor's `end` fires synchronously inside `new Context()`, before `#dispatch`
   // reads `matchResult[0].length`, so the injected middleware is in place for the same request.
-  diagnosticsChannel.tracingChannel<ChannelArgs>(CHANNELS.HONO_CONTEXT).end.subscribe(message => {
+  diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.HONO_CONTEXT).end.subscribe(message => {
     safeChannelCallback(() =>
-      injectHonoInstrumentation(message as ChannelArgs, requestMiddleware, injectedHandlerLists),
+      injectHonoInstrumentation(message as OrchestrionChannelContext, requestMiddleware, injectedHandlerLists),
     );
   });
 
diff --git a/packages/server-utils/src/integrations/kafkajs/index.ts b/packages/server-utils/src/integrations/kafkajs/index.ts
index 5160dedf80ca..0bc54f12f892 100644
--- a/packages/server-utils/src/integrations/kafkajs/index.ts
+++ b/packages/server-utils/src/integrations/kafkajs/index.ts
@@ -2,6 +2,7 @@ import * as diagnosticsChannel from '../../utils/diagnosticsChannel';
 import type { TracingChannelSubscribers } from 'node:diagnostics_channel';
 import type { IntegrationFn, Span } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { kafkajsModuleNames } from '../../orchestrion/config/kafkajs';
 import { invokeOrchestrionInstrumentation } from '../../orchestrion/instrumentation';
@@ -14,16 +15,15 @@ import type { ConsumerRunConfig, ProducerBatch } from './types';
 const INTEGRATION_NAME = 'Kafka' as const;
 
 /** The tracing-channel context the transform attaches around `messageProducer.js`'s `sendBatch`. */
-interface SendBatchChannelContext {
+interface SendBatchChannelContext extends OrchestrionChannelContext {
   // `arguments[0]` is the `{ topicMessages }` batch (kafkajs normalizes `send` into `sendBatch`).
   arguments: [ProducerBatch?, ...unknown[]];
-  error?: unknown;
   // The producer spans opened at `start`, ended on `asyncEnd` (and marked errored on `error`).
   _sentrySpans?: Span[];
 }
 
 /** The tracing-channel context the transform attaches around `consumer/index.js`'s `run`. */
-interface ConsumerRunChannelContext {
+interface ConsumerRunChannelContext extends OrchestrionChannelContext {
   // `arguments[0]` is the `run(config)` config whose `eachMessage`/`eachBatch` we swap in place.
   arguments: [ConsumerRunConfig?, ...unknown[]];
 }
diff --git a/packages/server-utils/src/integrations/knex.ts b/packages/server-utils/src/integrations/knex.ts
index 781d26aa70c8..bdc3d4dac16f 100644
--- a/packages/server-utils/src/integrations/knex.ts
+++ b/packages/server-utils/src/integrations/knex.ts
@@ -31,6 +31,7 @@ import {
 } from '@sentry/conventions/attributes';
 import { DB } from '@sentry/conventions/op';
 import { DEBUG_BUILD } from '../debug-build';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../tracing-channel';
 import { sanitizeSqlQueryWithSummary, toSqlDialect } from '../utils/sql';
@@ -89,21 +90,10 @@ interface KnexRunner {
 }
 
 /** Context orchestrion attaches to the `orchestrion:knex:query` channel (wrapping `Runner.query`). */
-interface KnexQueryChannelContext {
+interface KnexQueryChannelContext extends OrchestrionChannelContext {
   // `arguments[0]` is the query object (`{ sql, method, bindings }`).
   arguments: [KnexQuery?];
   self?: KnexRunner;
-  moduleVersion?: string;
-  result?: unknown;
-  error?: unknown;
-}
-
-/** Context orchestrion attaches to the `Client.queryBuilder`/`schemaBuilder`/`raw` channels. */
-interface KnexBuilderChannelContext {
-  arguments: unknown[];
-  self?: unknown;
-  // The builder returned by the wrapped method.
-  result?: KnexBuilder;
 }
 
 const _knexIntegration = (() => {
@@ -135,7 +125,7 @@ const _knexIntegration = (() => {
  */
 function subscribeBuilder(channelName: string): void {
   diagnosticsChannel.tracingChannel(channelName).end.subscribe(message => {
-    const builder = (message as KnexBuilderChannelContext).result;
+    const builder = (message as OrchestrionChannelContext).result;
     if (!builder || typeof builder !== 'object' || parentSpanSymbol in builder) {
       return;
     }
diff --git a/packages/server-utils/src/integrations/koa/index.ts b/packages/server-utils/src/integrations/koa/index.ts
index e3f1c10690c0..d2bba675abfe 100644
--- a/packages/server-utils/src/integrations/koa/index.ts
+++ b/packages/server-utils/src/integrations/koa/index.ts
@@ -15,6 +15,7 @@ import {
 import { CODE_FUNCTION_NAME, HTTP_ROUTE, KOA_TYPE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { MIDDLEWARE, ROUTER } from '@sentry/conventions/op';
 import { DEBUG_BUILD } from '../../debug-build';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { koaModuleNames } from '../../orchestrion/config/koa';
 import { invokeOrchestrionInstrumentation } from '../../orchestrion/instrumentation';
@@ -66,12 +67,8 @@ interface KoaMiddlewareMetadata {
   name: string;
 }
 
-interface KoaUseContext {
-  arguments: unknown[];
-}
-
 /** The `callback` channel `context` shape: `self` is the live app to attach the error listener to. */
-interface KoaCallbackContext {
+interface KoaCallbackContext extends OrchestrionChannelContext {
   self?: KoaApp;
 }
 
@@ -96,7 +93,7 @@ const _koaIntegration = ((options: KoaIntegrationOptions = {}) => {
 function instrumentKoa(ignoreLayersType: KoaLayerType[]): void {
   diagnosticsChannel.tracingChannel(CHANNELS.KOA_USE).subscribe({
     start(rawCtx) {
-      handleUse(rawCtx as KoaUseContext, ignoreLayersType);
+      handleUse(rawCtx as OrchestrionChannelContext, ignoreLayersType);
     },
     end() {},
     asyncStart() {},
@@ -123,7 +120,7 @@ function instrumentKoa(ignoreLayersType: KoaLayerType[]): void {
   });
 }
 
-function handleUse(ctx: KoaUseContext, ignoreLayersType: KoaLayerType[]): void {
+function handleUse(ctx: OrchestrionChannelContext, ignoreLayersType: KoaLayerType[]): void {
   const middleware = ctx.arguments[0];
   if (typeof middleware === 'function') {
     ctx.arguments[0] = patchUse(middleware as KoaMiddleware, ignoreLayersType);
diff --git a/packages/server-utils/src/integrations/langchain.ts b/packages/server-utils/src/integrations/langchain.ts
index c10b9c79b6ae..54492e5f2b4f 100644
--- a/packages/server-utils/src/integrations/langchain.ts
+++ b/packages/server-utils/src/integrations/langchain.ts
@@ -16,6 +16,7 @@ import {
 import { MISTRAL_INTEGRATION_NAME } from '../ai/mistral/constants';
 import { OPENAI_INTEGRATION_NAME } from '../ai/openai/constants';
 import { GROQ_INTEGRATION_NAME } from './groq';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { langchainEmbeddingsChannels } from '../orchestrion/config/langchain';
 import { bindTracingChannelToSpan } from '../tracing-channel';
@@ -38,17 +39,7 @@ const SKIPPED_PROVIDERS = [
 ];
 
 // The chat-model channels carry the live args array of `invoke(input, options)` / `_streamIterator(input, options)`.
-interface RunnableChannelContext {
-  arguments: unknown[];
-  self?: unknown;
-}
-
 // The embeddings channels carry the instance (`self`) and the `embedQuery(text)` / `embedDocuments(texts)` args.
-interface EmbeddingsChannelContext {
-  self?: unknown;
-  arguments: unknown[];
-}
-
 // Registered lazily on the first LangChain call (not at `setupOnce`) so a direct provider call made
 // before any LangChain call still gets its own span — matches the OTel patch-on-import timing. It
 // also stops the underlying SDK from double-instrumenting embeddings, whose `embedQuery`/
@@ -83,7 +74,7 @@ function instrumentChatModels(options: LangChainOptions): void {
   // callback dispatch then creates the spans, exactly as in the OTel path, so no span is opened
   // here — a `start` subscriber (which also makes orchestrion wrap the function) is enough.
   const injectHandler = (message: unknown): void => {
-    const args = (message as RunnableChannelContext).arguments;
+    const args = (message as OrchestrionChannelContext).arguments;
     if (!Array.isArray(args)) {
       return;
     }
@@ -107,7 +98,7 @@ function instrumentChatModels(options: LangChainOptions): void {
   };
 
   for (const channelName of [CHANNELS.LANGCHAIN_CHAT_MODEL_INVOKE, CHANNELS.LANGCHAIN_CHAT_MODEL_STREAM]) {
-    diagnosticsChannel.tracingChannel<RunnableChannelContext>(channelName).start.subscribe(message => {
+    diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(channelName).start.subscribe(message => {
       markProvidersSkipped();
       injectHandler(message);
     });
@@ -115,10 +106,10 @@ function instrumentChatModels(options: LangChainOptions): void {
 
   // `TypeSafeClassifier` calls Jev with `fetch`, not through a provider SDK, so nothing needs skipping.
   diagnosticsChannel
-    .tracingChannel<RunnableChannelContext>(CHANNELS.LANGCHAIN_TYPESAFE_CLASSIFIER_INVOKE)
+    .tracingChannel<OrchestrionChannelContext>(CHANNELS.LANGCHAIN_TYPESAFE_CLASSIFIER_INVOKE)
     .start.subscribe(message => {
       injectHandler(message);
-      const { self, arguments: args } = message as RunnableChannelContext;
+      const { self, arguments: args } = message as OrchestrionChannelContext;
       recordTypeSafeClassifierState(self, args?.[0]);
     });
 }
@@ -128,13 +119,13 @@ function instrumentChatModels(options: LangChainOptions): void {
 // still marks failed on error) and do not capture them.
 function instrumentEmbeddings(options: LangChainOptions): void {
   for (const channelName of langchainEmbeddingsChannels) {
-    bindTracingChannelToSpan(diagnosticsChannel.tracingChannel<EmbeddingsChannelContext>(channelName), data =>
+    bindTracingChannelToSpan(diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(channelName), data =>
       createEmbeddingsSpan(data, options),
     );
   }
 }
 
-function createEmbeddingsSpan(data: EmbeddingsChannelContext, options: LangChainOptions): Span {
+function createEmbeddingsSpan(data: OrchestrionChannelContext, options: LangChainOptions): Span {
   // `embedQuery`/`embedDocuments` call the provider SDK internally, so skip that SDK's own
   // instrumentation before its channel fires (the producer runs at the embeddings channel's `start`).
   markProvidersSkipped();
diff --git a/packages/server-utils/src/integrations/langgraph.ts b/packages/server-utils/src/integrations/langgraph.ts
index 5a41a8296aa3..d9d5bd863144 100644
--- a/packages/server-utils/src/integrations/langgraph.ts
+++ b/packages/server-utils/src/integrations/langgraph.ts
@@ -8,6 +8,7 @@ import { LANGGRAPH_INTEGRATION_NAME } from '../ai/langgraph/constants';
 import type { CompiledGraph, LangGraphOptions } from '../ai/langgraph/types';
 import { extractAgentNameFromParams, extractLLMFromParams, wrapToolsWithSpans } from '../ai/langgraph/utils';
 import { DEBUG_BUILD } from '../debug-build';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { langgraphModuleNames } from '../orchestrion/config/langgraph';
 import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation';
@@ -16,16 +17,6 @@ import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation
 // deduplicated out of the default set.
 const INTEGRATION_NAME = LANGGRAPH_INTEGRATION_NAME;
 
-interface CompileChannelContext {
-  arguments: unknown[];
-  result?: unknown;
-}
-
-interface CreateReactAgentChannelContext {
-  arguments: unknown[];
-  result?: unknown;
-}
-
 // `createReactAgent` compiles a `StateGraph` internally. When set, the compile subscriber skips that
 // nested graph so its `invoke` is wrapped once (by the createReactAgent handler), not twice.
 let insideCreateReactAgent = false;
@@ -49,18 +40,18 @@ function instrumentLanggraph(options: LangGraphOptions): void {
 
   // StateGraph.compile returns synchronously; wrap the returned graph's `invoke` at `end`.
   diagnosticsChannel
-    .tracingChannel<CompileChannelContext>(CHANNELS.LANGGRAPH_STATE_GRAPH_COMPILE)
+    .tracingChannel<OrchestrionChannelContext>(CHANNELS.LANGGRAPH_STATE_GRAPH_COMPILE)
     .end.subscribe(message => {
       if (insideCreateReactAgent) {
         return;
       }
-      const { arguments: args, result } = message as CompileChannelContext;
+      const { arguments: args, result } = message as OrchestrionChannelContext;
       wrapCompiledGraphInvoke(result, getFirstArgObject(args) ?? {}, resolvedOptions, null, sentryHandler);
     });
 
   // createReactAgent only wraps tools and the returned graph's `invoke`. Tools are wrapped at
   // `start` (before the agent runs), invoke at `end`.
-  const reactAgentChannel = diagnosticsChannel.tracingChannel<CreateReactAgentChannelContext>(
+  const reactAgentChannel = diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(
     CHANNELS.LANGGRAPH_CREATE_REACT_AGENT,
   );
   reactAgentChannel.start.subscribe(message => {
@@ -70,7 +61,7 @@ function instrumentLanggraph(options: LangGraphOptions): void {
     // stay off during this call's nested compile. Tool wrapping is guarded for the same reason.
     insideCreateReactAgent = true;
     try {
-      const { arguments: args } = message as CreateReactAgentChannelContext;
+      const { arguments: args } = message as OrchestrionChannelContext;
       const params = getFirstArgObject(args);
       if (params && Array.isArray(params.tools) && params.tools.length > 0) {
         wrapToolsWithSpans(params.tools, resolvedOptions, extractAgentNameFromParams(args) ?? undefined);
@@ -81,7 +72,7 @@ function instrumentLanggraph(options: LangGraphOptions): void {
   });
   reactAgentChannel.end.subscribe(message => {
     insideCreateReactAgent = false;
-    const { arguments: args, result } = message as CreateReactAgentChannelContext;
+    const { arguments: args, result } = message as OrchestrionChannelContext;
     const agentName = extractAgentNameFromParams(args) ?? undefined;
     const compileOptions = agentName ? { name: agentName } : {};
     wrapCompiledGraphInvoke(result, compileOptions, resolvedOptions, extractLLMFromParams(args), sentryHandler);
diff --git a/packages/server-utils/src/integrations/lru-memoizer.ts b/packages/server-utils/src/integrations/lru-memoizer.ts
index 6bb2b8acbd53..8b4ec5c0391b 100644
--- a/packages/server-utils/src/integrations/lru-memoizer.ts
+++ b/packages/server-utils/src/integrations/lru-memoizer.ts
@@ -1,6 +1,7 @@
 import * as diagnosticsChannel from '../utils/diagnosticsChannel';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../tracing-channel';
 import { lruMemoizerModuleNames } from '../orchestrion/config/lru-memoizer';
@@ -10,10 +11,6 @@ import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation
 // 'LruMemoizer' integration is omitted from the default set.
 const INTEGRATION_NAME = 'LruMemoizer' as const;
 
-interface LruMemoizerLoadContext {
-  arguments: unknown[];
-}
-
 const _lruMemoizerIntegration = (() => {
   return {
     name: INTEGRATION_NAME,
@@ -25,7 +22,7 @@ const _lruMemoizerIntegration = (() => {
 
 function instrumentLruMemoizer(): void {
   bindTracingChannelToSpan(
-    diagnosticsChannel.tracingChannel<LruMemoizerLoadContext>(CHANNELS.LRU_MEMOIZER_LOAD),
+    diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.LRU_MEMOIZER_LOAD),
     // We only want the helper's caller-context restore for the callback lru-memoizer fires from a detached `setImmediate`.
     () => undefined,
   );
diff --git a/packages/server-utils/src/integrations/mastra-classifier.ts b/packages/server-utils/src/integrations/mastra-classifier.ts
index d25434bb2c9d..5db546336779 100644
--- a/packages/server-utils/src/integrations/mastra-classifier.ts
+++ b/packages/server-utils/src/integrations/mastra-classifier.ts
@@ -3,25 +3,17 @@ import { isObjectLike } from '@sentry/core';
 import type { ClassifierEvaluationCall } from '../ai/mastra/classifier-evaluation';
 import { processClassifierEvaluationData, setStartingClassifierEvaluation } from '../ai/mastra/classifier-evaluation';
 import { getEvaluationInputMessages, getEvaluationOutputMessages } from '../ai/core/utils';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { safeChannelCallback } from '../tracing-channel';
 import * as diagnosticsChannel from '../utils/diagnosticsChannel';
 
-interface ClassifierEvaluateChannelContext {
-  // `evaluate({ state, questions? })`; `self` is the `Classifier`.
-  arguments: unknown[];
-  self?: unknown;
-  result?: unknown;
-}
-
 /**
  * Add the evaluated state, questions and answers of a `Classifier.evaluate()` call to the exporter's
  * `classifier_evaluation` span, which Mastra leaves without input or output.
  */
 export function recordClassifierEvaluations(): void {
-  const channel = diagnosticsChannel.tracingChannel<ClassifierEvaluateChannelContext>(
-    CHANNELS.MASTRA_CLASSIFIER_EVALUATE,
-  );
+  const channel = diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.MASTRA_CLASSIFIER_EVALUATE);
   const calls = new WeakMap<object, ClassifierEvaluationCall>();
 
   channel.start.subscribe(message => {
@@ -39,13 +31,13 @@ export function recordClassifierEvaluations(): void {
     safeChannelCallback(() => {
       const call = calls.get(message as object);
       if (call) {
-        finishClassifierEvaluation(call, message as ClassifierEvaluateChannelContext);
+        finishClassifierEvaluation(call, message as OrchestrionChannelContext);
       }
     });
   });
 }
 
-function finishClassifierEvaluation(call: ClassifierEvaluationCall, message: ClassifierEvaluateChannelContext): void {
+function finishClassifierEvaluation(call: ClassifierEvaluationCall, message: OrchestrionChannelContext): void {
   call.settled = true;
   const { span, recordInputs, recordOutputs } = call;
   if (!span) {
diff --git a/packages/server-utils/src/integrations/mastra.ts b/packages/server-utils/src/integrations/mastra.ts
index 1f541fe83303..126afd052d15 100644
--- a/packages/server-utils/src/integrations/mastra.ts
+++ b/packages/server-utils/src/integrations/mastra.ts
@@ -22,6 +22,7 @@ import type { MastraExporterOptions } from '../ai/mastra';
 import { getSentrySpanForMastraId } from '../ai/mastra/span-registry';
 import type { MastraObservabilityExporter } from '../ai/mastra/types';
 import { DEBUG_BUILD } from '../debug-build';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { mastraModuleNames } from '../orchestrion/config/mastra';
 import { recordClassifierEvaluations } from './mastra-classifier';
@@ -45,16 +46,6 @@ interface MastraInstance {
   observability?: { getDefaultInstance?: () => MastraObservabilityInstance | undefined };
 }
 
-interface ConstructorChannelContext {
-  arguments: unknown[];
-  self?: unknown;
-}
-
-interface ExecuteWithContextChannelContext {
-  // `executeWithContext({ span, fn })` — the first arg carries the Mastra AISpan.
-  arguments: unknown[];
-}
-
 /** Mastra AISpan → the id the exporter keys its Sentry span on. */
 function mastraSpanId(span: unknown): string | undefined {
   if (!isObjectLike(span)) {
@@ -89,9 +80,9 @@ const _mastraIntegration = ((options: MastraOptions = {}) => {
 }) satisfies IntegrationFn;
 
 function instrumentExporter(options: MastraOptions): void {
-  diagnosticsChannel.tracingChannel<ConstructorChannelContext>(CHANNELS.MASTRA_CONSTRUCTOR).end.subscribe(message => {
+  diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.MASTRA_CONSTRUCTOR).end.subscribe(message => {
     safeChannelCallback(() => {
-      const { self } = message as ConstructorChannelContext;
+      const { self } = message as OrchestrionChannelContext;
       attachExporter(self, options);
     });
   });
@@ -109,10 +100,10 @@ function instrumentExporter(options: MastraOptions): void {
  */
 function captureExecuteWithContextErrors(): void {
   diagnosticsChannel
-    .tracingChannel<ExecuteWithContextChannelContext>(CHANNELS.MASTRA_EXECUTE_WITH_CONTEXT)
+    .tracingChannel<OrchestrionChannelContext>(CHANNELS.MASTRA_EXECUTE_WITH_CONTEXT)
     .error.subscribe(message => {
       safeChannelCallback(() => {
-        const data = message as ExecuteWithContextChannelContext & { error: unknown };
+        const data = message as OrchestrionChannelContext;
         captureMastraError(data.error, (data.arguments as unknown[] | undefined)?.[0]);
       });
     });
@@ -168,7 +159,7 @@ function captureMastraError(error: unknown, params: unknown): void {
  */
 function instrumentExecuteWithContext(): void {
   bindSpanToChannelStore(
-    diagnosticsChannel.tracingChannel<ExecuteWithContextChannelContext>(CHANNELS.MASTRA_EXECUTE_WITH_CONTEXT),
+    diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.MASTRA_EXECUTE_WITH_CONTEXT),
     data => {
       const params = (data.arguments as unknown[] | undefined)?.[0];
       const id = isObjectLike(params) ? mastraSpanId(params.span) : undefined;
diff --git a/packages/server-utils/src/integrations/mcp-server.ts b/packages/server-utils/src/integrations/mcp-server.ts
index 8f3a75f1a0f1..d3a4823cf389 100644
--- a/packages/server-utils/src/integrations/mcp-server.ts
+++ b/packages/server-utils/src/integrations/mcp-server.ts
@@ -2,6 +2,7 @@ import * as diagnosticsChannel from '../utils/diagnosticsChannel';
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
 import { wrapMcpServerWithSentry } from '@sentry/core/server';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { mcpServerModuleNames } from '../orchestrion/config/mcp-server';
 import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation';
@@ -9,11 +10,6 @@ import { safeChannelCallback } from '../tracing-channel';
 
 const INTEGRATION_NAME = 'McpServer';
 
-interface ConstructorChannelContext {
-  arguments: unknown[];
-  self?: unknown;
-}
-
 const _mcpServerIntegration = (() => {
   return {
     name: INTEGRATION_NAME,
@@ -34,9 +30,9 @@ function subscribe(): void {
   // wrap's own `WeakSet` guard makes a later manual call on the same instance a no-op, so the two
   // paths coexist safely.
   for (const channel of [CHANNELS.MCP_SERVER_V2_CONSTRUCTOR, CHANNELS.MCP_SERVER_V1_CONSTRUCTOR]) {
-    diagnosticsChannel.tracingChannel<ConstructorChannelContext>(channel).end.subscribe(message => {
+    diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(channel).end.subscribe(message => {
       safeChannelCallback(() => {
-        const { self } = message as ConstructorChannelContext;
+        const { self } = message as OrchestrionChannelContext;
         if (self) {
           wrapMcpServerWithSentry(self);
         }
diff --git a/packages/server-utils/src/integrations/mistral.ts b/packages/server-utils/src/integrations/mistral.ts
index f70d026cf358..f916321bd31c 100644
--- a/packages/server-utils/src/integrations/mistral.ts
+++ b/packages/server-utils/src/integrations/mistral.ts
@@ -8,6 +8,7 @@ import { MISTRAL_INTEGRATION_NAME, MISTRAL_ORIGIN } from '../ai/mistral/constant
 import { instrumentEventStream } from '../ai/mistral/streaming';
 import type { MistralOptions } from '../ai/mistral/types';
 import { addResponseAttributes, getSpanName } from '../ai/mistral/utils';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { mistralModuleNames } from '../orchestrion/config/mistral';
 import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation';
@@ -25,15 +26,6 @@ const INSTRUMENTED_CHANNELS = [
   { channel: CHANNELS.MISTRAL_AGENTS_STREAM, operation: 'invoke_agent', streaming: true },
 ] as const;
 
-/**
- * The context orchestrion shares across the tracing-channel lifecycle hooks: `arguments` is the live
- * args array passed to the SDK method, and Node's `tracingChannel` attaches `result` when it settles.
- */
-interface MistralChannelContext {
-  arguments: unknown[];
-  result?: unknown;
-}
-
 const _mistralAIIntegration = ((options: MistralOptions = {}) => {
   return {
     name: INTEGRATION_NAME,
@@ -46,7 +38,7 @@ const _mistralAIIntegration = ((options: MistralOptions = {}) => {
 function instrumentMistral(options: MistralOptions): void {
   for (const { channel, operation, streaming } of INSTRUMENTED_CHANNELS) {
     bindTracingChannelToSpan(
-      diagnosticsChannel.tracingChannel<MistralChannelContext>(channel),
+      diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(channel),
       data => createGenAiSpan(data, operation, streaming, options),
       {
         beforeSpanEnd: (span, data) => {
@@ -65,7 +57,7 @@ function instrumentMistral(options: MistralOptions): void {
  * Returning `undefined` opts the payload out so no span is opened.
  */
 function createGenAiSpan(
-  data: MistralChannelContext,
+  data: OrchestrionChannelContext,
   operation: string,
   streaming: boolean,
   options: MistralOptions,
diff --git a/packages/server-utils/src/integrations/mongodb/index.ts b/packages/server-utils/src/integrations/mongodb/index.ts
index 6f492a575a6b..593638025c6f 100644
--- a/packages/server-utils/src/integrations/mongodb/index.ts
+++ b/packages/server-utils/src/integrations/mongodb/index.ts
@@ -3,6 +3,7 @@ import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
 import type { MongodbNamespace, MongoV3Topology } from './mongodb-span';
 import { getV3CommandOperation, getV3SpanAttributes, getV4SpanAttributes, startMongoSpan } from './mongodb-span';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../../tracing-channel';
 import { mongodbModuleNames } from '../../orchestrion/config/mongodb';
@@ -16,9 +17,8 @@ const ORIGIN = 'auto.db.mongo';
  * what orchestrion's transform attaches to a channel context:
  * `self` is the `this`, plus args.
  */
-interface MongoChannelContext {
+interface MongoChannelContext extends OrchestrionChannelContext {
   self?: { address?: string };
-  arguments?: unknown[];
 }
 
 // Details extracted from a v3 wireprotocol call's arguments to build its span.
diff --git a/packages/server-utils/src/integrations/mongoose/index.ts b/packages/server-utils/src/integrations/mongoose/index.ts
index 4e00635939c1..62b7ead8b720 100644
--- a/packages/server-utils/src/integrations/mongoose/index.ts
+++ b/packages/server-utils/src/integrations/mongoose/index.ts
@@ -4,6 +4,7 @@ import { defineIntegration, getActiveSpan, waitForTracingChannelBinding } from '
 import { subscribeMongooseDiagnosticChannels } from './mongoose-dc-subscriber';
 import type { MongooseLegacyCollection } from './mongoose-legacy-span';
 import { startMongooseLegacySpan } from './mongoose-legacy-span';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { MONGOOSE_CONTEXT_CAPTURE_CHANNELS } from '../../orchestrion/config/mongoose';
 import type { SentryTracingChannel } from '../../tracing-channel';
@@ -38,12 +39,8 @@ interface MongooseDocument {
  * The shape orchestrion's transform attaches to the tracing-channel context
  * object. `self` is the `this` of the traced method
  */
-interface MongooseChannelContext {
+interface MongooseChannelContext extends OrchestrionChannelContext {
   self?: object;
-  arguments?: unknown[];
-  result?: unknown;
-  error?: unknown;
-  moduleVersion?: string;
 }
 
 // The active span captured when a query/aggregate was *built*, keyed by the
diff --git a/packages/server-utils/src/integrations/mysql.ts b/packages/server-utils/src/integrations/mysql.ts
index e4049b65d30a..d3e8010cb1ba 100644
--- a/packages/server-utils/src/integrations/mysql.ts
+++ b/packages/server-utils/src/integrations/mysql.ts
@@ -23,6 +23,7 @@ import {
   startInactiveSpan,
 } from '@sentry/core';
 import { sanitizeSqlQueryWithSummary } from '../utils/sql';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../tracing-channel';
 import { mysqlModuleNames } from '../orchestrion/config/mysql';
@@ -42,13 +43,8 @@ const DB_SYSTEM_NAME_VALUE_MYSQL = 'mysql' as const;
  * The shape orchestrion's transform attaches to the tracing-channel `context` object. Documented here
  * rather than imported because orchestrion's runtime doesn't export it.
  */
-interface MysqlQueryChannelContext {
-  // The live args array passed to the wrapped `connection.query` call; `arguments[0]` is the SQL.
-  arguments: unknown[];
+interface MysqlQueryChannelContext extends OrchestrionChannelContext {
   self?: MysqlConnection;
-  moduleVersion?: string;
-  result?: unknown;
-  error?: unknown;
   // The caller's scope, captured at `start` and replayed onto the streamed `Query` emitter (see below).
   _sentryCallerScope?: Scope;
 }
diff --git a/packages/server-utils/src/integrations/mysql2/index.ts b/packages/server-utils/src/integrations/mysql2/index.ts
index b8f6501a26ba..5f337d21a41d 100644
--- a/packages/server-utils/src/integrations/mysql2/index.ts
+++ b/packages/server-utils/src/integrations/mysql2/index.ts
@@ -10,6 +10,7 @@ import {
 } from '@sentry/core';
 import { sanitizeSqlQueryWithSummary } from '../../utils/sql';
 import { subscribeMysql2DiagnosticChannels } from './mysql2-dc-subscriber';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import type { ChannelName } from '../../orchestrion/channels';
 import { CHANNELS } from '../../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../../tracing-channel';
@@ -38,14 +39,8 @@ const DB_SYSTEM_VALUE_MYSQL = 'mysql';
  * object. Documented here rather than imported because orchestrion's runtime
  * doesn't export it.
  */
-interface Mysql2QueryChannelContext {
-  // The live args array passed to the wrapped `query`/`execute` call:
-  // `arguments[0]` is the SQL (a string, `Query`, or `{ sql, values }`),
-  // `arguments[1]` is the values array or a callback.
-  arguments: unknown[];
+interface Mysql2QueryChannelContext extends OrchestrionChannelContext {
   self?: Mysql2Connection;
-  result?: unknown;
-  error?: unknown;
 }
 
 interface Mysql2ConnectionConfig {
diff --git a/packages/server-utils/src/integrations/openai-compatible.ts b/packages/server-utils/src/integrations/openai-compatible.ts
index 2c23c711b60f..48bacae5bcf8 100644
--- a/packages/server-utils/src/integrations/openai-compatible.ts
+++ b/packages/server-utils/src/integrations/openai-compatible.ts
@@ -13,6 +13,7 @@ import { addRequestAttributes, extractRequestAttributes } from '../ai/openai';
 import { instrumentStream } from '../ai/openai/streaming';
 import type { OpenAiOptions } from '../ai/openai/types';
 import { addResponseAttributes } from '../ai/openai/utils';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation';
 import { bindTracingChannelToSpan } from '../tracing-channel';
 
@@ -33,15 +34,6 @@ export interface OpenAiCompatibleProvider {
   channels: { chat: string; embeddings: string };
 }
 
-/**
- * The context orchestrion shares across the tracing-channel lifecycle hooks: `arguments` is the live args
- * array passed to `Completions.create(body, options)`, and `result` holds its returned `APIPromise`.
- */
-interface OpenAiCompatibleChannelContext {
-  arguments: unknown[];
-  result?: unknown;
-}
-
 /**
  * Builds a diagnostics-channel integration for an OpenAI-compatible provider SDK. It subscribes to the
  * `orchestrion:<module>:{chat,embeddings}` channels injected into the SDK's `create` methods, so it
@@ -60,7 +52,7 @@ export function createOpenAiCompatibleIntegration<T extends OpenAiCompatibleProv
   function instrument(options: OpenAiOptions): void {
     for (const { channel, operation } of instrumentedChannels) {
       bindTracingChannelToSpan(
-        diagnosticsChannel.tracingChannel<OpenAiCompatibleChannelContext>(channel),
+        diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(channel),
         data => createGenAiSpan(data, operation, provider, options),
         {
           beforeSpanEnd: (span, data) => {
@@ -97,7 +89,7 @@ export function createOpenAiCompatibleIntegration<T extends OpenAiCompatibleProv
  * Returning `undefined` opts the payload out so no span is opened.
  */
 function createGenAiSpan(
-  data: OpenAiCompatibleChannelContext,
+  data: OrchestrionChannelContext,
   operation: string,
   provider: OpenAiCompatibleProvider,
   options: OpenAiOptions,
@@ -149,7 +141,7 @@ function isAsyncIterable(value: unknown): value is AsyncIterableStream {
  * to hand span-ending ownership to `instrumentStream`; `false` for non-streaming/errored results, which end
  * via the normal `beforeSpanEnd` path.
  */
-function wrapStreamResult(span: Span, data: OpenAiCompatibleChannelContext, options: OpenAiOptions): boolean {
+function wrapStreamResult(span: Span, data: OrchestrionChannelContext, options: OpenAiOptions): boolean {
   const result = data.result;
   if (!isAsyncIterable(result)) {
     return false;
diff --git a/packages/server-utils/src/integrations/openai.ts b/packages/server-utils/src/integrations/openai.ts
index a5375794033e..ec7c852e9010 100644
--- a/packages/server-utils/src/integrations/openai.ts
+++ b/packages/server-utils/src/integrations/openai.ts
@@ -14,6 +14,7 @@ import { wrapApiPromiseResponse } from '../ai/core/apiPromise';
 import { instrumentStream } from '../ai/openai/streaming';
 import type { OpenAiOptions } from '../ai/openai/types';
 import { addResponseAttributes } from '../ai/openai/utils';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../tracing-channel';
 import { openaiModuleNames } from '../orchestrion/config/openai';
@@ -31,16 +32,6 @@ const INSTRUMENTED_CHANNELS = [
   { channel: CHANNELS.OPENAI_EMBEDDINGS, operation: 'embeddings' },
 ] as const;
 
-/**
- * The context object orchestrion shares across the tracing-channel lifecycle hooks: `arguments` is the
- * live args array passed to `Completions.create(body, options)`. `result` holds the returned
- * `APIPromise` for sync instrumentation.
- */
-interface OpenAiChatChannelContext {
-  arguments: unknown[];
-  result?: unknown;
-}
-
 const _openAIIntegration = ((options: OpenAiOptions = {}) => {
   return {
     name: INTEGRATION_NAME,
@@ -53,7 +44,7 @@ const _openAIIntegration = ((options: OpenAiOptions = {}) => {
 function instrumentOpenai(options: OpenAiOptions): void {
   for (const { channel, operation } of INSTRUMENTED_CHANNELS) {
     bindTracingChannelToSpan(
-      diagnosticsChannel.tracingChannel<OpenAiChatChannelContext>(channel),
+      diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(channel),
       data => createGenAiSpan(data, operation, options),
       {
         beforeSpanEnd: (span, data) => {
@@ -80,7 +71,7 @@ function instrumentOpenai(options: OpenAiOptions): void {
  * Build the span for an instrumented `create` call.
  * Returning `undefined` opts the payload out so no span is opened.
  */
-function createGenAiSpan(data: OpenAiChatChannelContext, operation: string, options: OpenAiOptions): Span | undefined {
+function createGenAiSpan(data: OrchestrionChannelContext, operation: string, options: OpenAiOptions): Span | undefined {
   // When another provider (e.g. LangChain) is driving the SDK, it records the spans itself and marks this
   // provider as skipped; skip here to avoid double spans.
   if (_INTERNAL_shouldSkipAiProviderWrapping(INTEGRATION_NAME)) {
@@ -126,7 +117,7 @@ function isAsyncIterable(value: unknown): value is AsyncIterableStream {
  * to hand span-ending ownership to `instrumentStream`; `false` for non-streaming/errored results, which end
  * via the normal `beforeSpanEnd` path.
  */
-function wrapStreamResult(span: Span, data: OpenAiChatChannelContext, options: OpenAiOptions): boolean {
+function wrapStreamResult(span: Span, data: OrchestrionChannelContext, options: OpenAiOptions): boolean {
   const result = data.result;
   if (!isAsyncIterable(result)) {
     return false;
diff --git a/packages/server-utils/src/integrations/pi-durable.ts b/packages/server-utils/src/integrations/pi-durable.ts
index b5b115ec6c7b..a9bd9e1b6a99 100644
--- a/packages/server-utils/src/integrations/pi-durable.ts
+++ b/packages/server-utils/src/integrations/pi-durable.ts
@@ -7,19 +7,11 @@ import { PI_DURABLE_INTEGRATION_NAME } from '../ai/pi-durable/constants';
 import { markBuiltInTool } from '../ai/pi-durable/tools';
 import type { PiHarnessOptions } from '../ai/pi-durable/types';
 import { DEBUG_BUILD } from '../debug-build';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { piDurableModuleNames } from '../orchestrion/config/pi-durable';
 import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation';
 
-interface HarnessOpenChannelContext {
-  arguments: unknown[];
-  result?: unknown;
-}
-
-interface CodingToolChannelContext {
-  result?: unknown;
-}
-
 const _piDurableIntegration = ((options: PiDurableOptions = {}) => {
   return {
     name: PI_DURABLE_INTEGRATION_NAME,
@@ -33,10 +25,10 @@ const _piDurableIntegration = ((options: PiDurableOptions = {}) => {
 }) satisfies IntegrationFn;
 
 function instrumentPiDurable(options: PiDurableOptions): void {
-  const harnessOpen = diagnosticsChannel.tracingChannel<HarnessOpenChannelContext>(CHANNELS.PI_DURABLE_HARNESS_OPEN);
+  const harnessOpen = diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.PI_DURABLE_HARNESS_OPEN);
 
   harnessOpen.start.subscribe(message => {
-    const args = (message as HarnessOpenChannelContext).arguments;
+    const args = (message as OrchestrionChannelContext).arguments;
     try {
       if (args && isObjectLike(args[1])) {
         args[1] = instrumentPiDurableHarnessOptions(args[1] as PiHarnessOptions, options);
@@ -47,7 +39,7 @@ function instrumentPiDurable(options: PiDurableOptions): void {
   });
 
   harnessOpen.asyncEnd.subscribe(message => {
-    const { arguments: args, result } = message as HarnessOpenChannelContext;
+    const { arguments: args, result } = message as OrchestrionChannelContext;
     try {
       if (args && isObjectLike(args[1])) {
         endRunsOnClose(args[1], result);
@@ -58,8 +50,8 @@ function instrumentPiDurable(options: PiDurableOptions): void {
   });
 
   diagnosticsChannel
-    .tracingChannel<CodingToolChannelContext>(CHANNELS.PI_DURABLE_CODING_TOOL)
-    .end.subscribe(message => markBuiltInTool((message as CodingToolChannelContext).result));
+    .tracingChannel<OrchestrionChannelContext>(CHANNELS.PI_DURABLE_CODING_TOOL)
+    .end.subscribe(message => markBuiltInTool((message as OrchestrionChannelContext).result));
 }
 
 /**
diff --git a/packages/server-utils/src/integrations/postgres-js.ts b/packages/server-utils/src/integrations/postgres-js.ts
index 5d3b865cd20d..0ac51daa8f54 100644
--- a/packages/server-utils/src/integrations/postgres-js.ts
+++ b/packages/server-utils/src/integrations/postgres-js.ts
@@ -28,6 +28,7 @@ import {
   _reconstructQuery,
   type PostgresConnectionContext,
 } from './postgresjs';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../tracing-channel';
 import { postgresJsModuleNames } from '../orchestrion/config/postgres';
@@ -81,11 +82,9 @@ interface PostgresQuery {
   reject?: (...args: unknown[]) => unknown;
 }
 
-interface PostgresJsQueryContext {
-  arguments?: unknown[];
+interface PostgresJsQueryContext extends OrchestrionChannelContext {
   self?: PostgresQuery;
-  result?: unknown;
-  error?: unknown;
+  [SPAN_ENDED]?: boolean;
 }
 
 // A connection object -> its resolved context, populated on the `connection`
@@ -178,7 +177,7 @@ function wrapQuerySettlement(data: PostgresJsQueryContext, span: Span, sanitized
   // Claim ownership of ending the span up front, so `deferSpanEnd` defers to the
   // wrapper even if `span.end()` below throws.
   const markEnded = (): void => {
-    (data as Record<symbol, unknown>)[SPAN_ENDED] = true;
+    data[SPAN_ENDED] = true;
   };
 
   const originalResolve = query.resolve;
@@ -332,7 +331,7 @@ function instrumentPostgresJs(options: PostgresJsIntegrationOptions): void {
       deferSpanEnd({ data }) {
         // `handle` is async: its promise settles on dispatch (asyncEnd), long
         // before the query does. The resolve/reject wrappers own the ending.
-        if ((data as Record<symbol, unknown>)[SPAN_ENDED]) {
+        if (data[SPAN_ENDED]) {
           return true; // wrappers already ended it
         }
         if ('error' in data) {
diff --git a/packages/server-utils/src/integrations/postgres.ts b/packages/server-utils/src/integrations/postgres.ts
index 5d93ac17769f..c1a2980943db 100644
--- a/packages/server-utils/src/integrations/postgres.ts
+++ b/packages/server-utils/src/integrations/postgres.ts
@@ -23,6 +23,7 @@ import {
   startInactiveSpan,
 } from '@sentry/core';
 import { sanitizeSqlQueryWithSummary } from '../utils/sql';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../tracing-channel';
 import { pgModuleNames } from '../orchestrion/config/pg';
@@ -59,12 +60,7 @@ const SPAN_POOL_CONNECT = 'pg-pool.connect';
  * The shape orchestrion's transform attaches to the tracing-channel `context`. Documented here rather
  * than imported because orchestrion's runtime doesn't export it.
  */
-interface PgChannelContext {
-  // The live args array passed to the wrapped `query`/`connect` call.
-  arguments: unknown[];
-  self?: unknown;
-  result?: unknown;
-  error?: unknown;
+interface PgChannelContext extends OrchestrionChannelContext {
   // The caller's scope, captured at `start` and replayed onto a streamed `Submittable` emitter (see below).
   _sentryCallerScope?: Scope;
 }
diff --git a/packages/server-utils/src/integrations/prisma/orchestrion.ts b/packages/server-utils/src/integrations/prisma/orchestrion.ts
index 656b7cf8fc75..de209f694d71 100644
--- a/packages/server-utils/src/integrations/prisma/orchestrion.ts
+++ b/packages/server-utils/src/integrations/prisma/orchestrion.ts
@@ -3,6 +3,7 @@ import type { Span } from '@sentry/core';
 import { getActiveSpan, getRootSpan, spanIsIgnored, startInactiveSpan, withActiveSpan } from '@sentry/core';
 import { DB_COLLECTION_NAME, DB_OPERATION_NAME, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { DB } from '@sentry/conventions/op';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { prismaChannels, PRISMA_LAZY_TERMINALS } from '../../orchestrion/config/prisma';
 import type { TracingChannelLifeCycleOptions } from '../../tracing-channel';
 import { bindTracingChannelToSpan, safeChannelCallback } from '../../tracing-channel';
@@ -20,12 +21,8 @@ interface PrismaCollection {
   tableName?: unknown;
 }
 
-interface PrismaTerminalChannelContext {
-  arguments: unknown[];
+interface PrismaTerminalChannelContext extends OrchestrionChannelContext {
   self?: PrismaCollection;
-  moduleVersion?: string;
-  result?: unknown;
-  error?: unknown;
 }
 
 // Prisma's `AsyncIterableResult`: `await`, `.then()` and `.first()` all funnel through `toArray()`; only
diff --git a/packages/server-utils/src/integrations/redis/index.ts b/packages/server-utils/src/integrations/redis/index.ts
index 4140156cee57..7176a14b57ec 100644
--- a/packages/server-utils/src/integrations/redis/index.ts
+++ b/packages/server-utils/src/integrations/redis/index.ts
@@ -21,6 +21,7 @@ import {
   withActiveSpan,
   waitForTracingChannelBinding,
 } from '@sentry/core';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { getRedisQueryNaming } from './redis-span-name';
 import { defaultDbStatementSerializer } from './redis-statement-serializer';
@@ -67,13 +68,6 @@ interface NodeRedisClient {
   options?: NodeRedisClientOptions;
 }
 
-interface CommandContext {
-  arguments?: unknown[];
-  self?: unknown;
-  result?: unknown;
-  error?: unknown;
-}
-
 function endSpan(span: Span, err: unknown): void {
   if (err) {
     span.setStatus({ code: SPAN_STATUS_ERROR, message: err instanceof Error ? err.message : String(err) });
@@ -140,7 +134,7 @@ function startCommandSpan(
 // Settles via `command_obj.callback`, not the sync return — so instead of
 // `bindTracingChannelToSpan` we open the span in `start`, wrap the callback to end it, and end on `error` for sync throws.
 function subscribeLegacyRedisCommand(cacheOptions: RedisCacheOptions): void {
-  const channel = diagnosticsChannel.tracingChannel<CommandContext>(CHANNELS.REDIS_COMMAND);
+  const channel = diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.REDIS_COMMAND);
   const noop = (): void => {};
   channel.subscribe({
     end: noop,
@@ -170,7 +164,7 @@ function subscribeLegacyRedisCommand(cacheOptions: RedisCacheOptions): void {
         attributes[SERVER_PORT] = client.connection_options.port;
       }
       const span = startCommandSpan(command.command, command.args ?? [], attributes, cacheOptions);
-      (data as CommandContext & { _sentrySpan?: Span })._sentrySpan = span;
+      (data as OrchestrionChannelContext & { _sentrySpan?: Span })._sentrySpan = span;
 
       const parentSpan = getActiveSpan();
       command.callback = function (this: unknown, err: Error | null | undefined, reply: unknown) {
@@ -185,7 +179,7 @@ function subscribeLegacyRedisCommand(cacheOptions: RedisCacheOptions): void {
     },
     error(data) {
       // Synchronous throw: the wrapped callback never fires, so end here instead.
-      const span = (data as CommandContext & { _sentrySpan?: Span })._sentrySpan;
+      const span = (data as OrchestrionChannelContext & { _sentrySpan?: Span })._sentrySpan;
       if (span) {
         endSpan(span, data.error);
       }
@@ -197,10 +191,10 @@ function subscribeLegacyRedisCommand(cacheOptions: RedisCacheOptions): void {
 
 function bindNodeRedisCommandChannel(
   channelName: string,
-  getWireArgs: (data: CommandContext) => Array<string | Buffer> | undefined,
+  getWireArgs: (data: OrchestrionChannelContext) => Array<string | Buffer> | undefined,
   cacheOptions: RedisCacheOptions,
 ): void {
-  const channel = diagnosticsChannel.tracingChannel<CommandContext, CommandContext>(channelName);
+  const channel = diagnosticsChannel.tracingChannel<OrchestrionChannelContext, OrchestrionChannelContext>(channelName);
   bindTracingChannelToSpan(
     channel,
     data => {
@@ -223,14 +217,14 @@ function bindNodeRedisCommandChannel(
 }
 
 // `sendCommand(args, options)` — `args` are already the wire arguments.
-function getSendCommandArgs(data: CommandContext): Array<string | Buffer> | undefined {
+function getSendCommandArgs(data: OrchestrionChannelContext): Array<string | Buffer> | undefined {
   const args = data.arguments?.[0];
   return Array.isArray(args) ? (args as Array<string | Buffer>) : undefined;
 }
 
 // `commandsExecutor(command, jsArgs)` — derive the wire arguments the same way
 // `@redis/client` does internally, via `command.transformArguments`.
-function getExecutorArgs(data: CommandContext): Array<string | Buffer> | undefined {
+function getExecutorArgs(data: OrchestrionChannelContext): Array<string | Buffer> | undefined {
   const command = data.arguments?.[0] as RedisCommandDefinition | undefined;
   const jsArgs = data.arguments?.[1];
   if (typeof command?.transformArguments !== 'function' || !Array.isArray(jsArgs)) {
@@ -244,7 +238,9 @@ function getExecutorArgs(data: CommandContext): Array<string | Buffer> | undefin
 }
 
 function bindNodeRedisConnectChannel(): void {
-  const channel = diagnosticsChannel.tracingChannel<CommandContext, CommandContext>(CHANNELS.NODE_REDIS_CONNECT);
+  const channel = diagnosticsChannel.tracingChannel<OrchestrionChannelContext, OrchestrionChannelContext>(
+    CHANNELS.NODE_REDIS_CONNECT,
+  );
   bindTracingChannelToSpan(channel, data => {
     const options = (data.self as NodeRedisClient | undefined)?.options;
     return startInactiveSpan({
@@ -261,8 +257,11 @@ function bindNodeRedisConnectChannel(): void {
 // Batch (multi/pipeline): one span per `exec`. Batched commands bypass `sendCommand`, so
 // the executor's `ctx.arguments[0]` (the queued commands) gives the batch size. Span shape
 // mirrors the native `node-redis:batch` span (see `redis-dc-subscriber.ts`).
-function bindNodeRedisBatchChannel(channelName: string, getOperation: (data: CommandContext) => string): void {
-  const channel = diagnosticsChannel.tracingChannel<CommandContext, CommandContext>(channelName);
+function bindNodeRedisBatchChannel(
+  channelName: string,
+  getOperation: (data: OrchestrionChannelContext) => string,
+): void {
+  const channel = diagnosticsChannel.tracingChannel<OrchestrionChannelContext, OrchestrionChannelContext>(channelName);
   bindTracingChannelToSpan(channel, data => {
     const commands = data.arguments?.[0];
     const size = Array.isArray(commands) ? commands.length : undefined;
diff --git a/packages/server-utils/src/integrations/redis/ioredis-channel-subscriber.ts b/packages/server-utils/src/integrations/redis/ioredis-channel-subscriber.ts
index 0e91d59c03bb..d918d080f749 100644
--- a/packages/server-utils/src/integrations/redis/ioredis-channel-subscriber.ts
+++ b/packages/server-utils/src/integrations/redis/ioredis-channel-subscriber.ts
@@ -12,6 +12,7 @@ import {
 import { DB_QUERY, DB } from '@sentry/conventions/op';
 import type { Span, SpanAttributes } from '@sentry/core';
 import { startInactiveSpan } from '@sentry/core';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { bindTracingChannelToSpan } from '../../tracing-channel';
 import type { RedisCacheOptions } from './redis-cache';
@@ -33,15 +34,10 @@ interface RedisClientLike {
   options?: { host?: string; port?: number };
 }
 
-interface IORedisCommandContext {
-  arguments?: unknown[];
+interface IORedisCommandContext extends OrchestrionChannelContext {
   self?: RedisClientLike;
-  result?: unknown;
-  error?: unknown;
 }
 
-type IORedisConnectContext = Omit<IORedisCommandContext, 'arguments'>;
-
 function getConnectionOptions(self: RedisClientLike | undefined): { host?: string; port?: number } {
   return { host: self?.options?.host, port: self?.options?.port };
 }
@@ -111,7 +107,7 @@ export function instrumentIoredis(options: RedisCacheOptions): void {
   const commandChannel = diagnosticsChannel.tracingChannel<IORedisCommandContext, IORedisCommandContext>(
     CHANNELS.IOREDIS_COMMAND,
   );
-  const connectChannel = diagnosticsChannel.tracingChannel<IORedisConnectContext, IORedisConnectContext>(
+  const connectChannel = diagnosticsChannel.tracingChannel<IORedisCommandContext, IORedisCommandContext>(
     CHANNELS.IOREDIS_CONNECT,
   );
 
diff --git a/packages/server-utils/src/integrations/tedious.ts b/packages/server-utils/src/integrations/tedious.ts
index 21ff279dd13f..0878dc5e3118 100644
--- a/packages/server-utils/src/integrations/tedious.ts
+++ b/packages/server-utils/src/integrations/tedious.ts
@@ -25,6 +25,7 @@ import {
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
 import { DB } from '@sentry/conventions/op';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { tediousModuleNames } from '../orchestrion/config/tedious';
 import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation';
@@ -66,16 +67,14 @@ interface TediousRequest extends EventEmitter {
 }
 
 /** Context orchestrion attaches to the query channels (wrapping the `Connection` request methods). */
-interface TediousQueryChannelContext {
+interface TediousQueryChannelContext extends OrchestrionChannelContext {
   // `arguments[0]` is the `Request` (or `BulkLoad` for `execBulkLoad`), both `EventEmitter`s.
   arguments: [TediousRequest?, ...unknown[]];
   self?: TediousConnection;
-  moduleVersion?: string;
 }
 
 /** Context orchestrion attaches to the `Connection.connect` channel. */
-interface TediousConnectChannelContext {
-  arguments: unknown[];
+interface TediousConnectChannelContext extends OrchestrionChannelContext {
   self?: TediousConnection;
 }
 
diff --git a/packages/server-utils/src/integrations/typesafe.ts b/packages/server-utils/src/integrations/typesafe.ts
index 594f9df7a068..9575e1206435 100644
--- a/packages/server-utils/src/integrations/typesafe.ts
+++ b/packages/server-utils/src/integrations/typesafe.ts
@@ -5,23 +5,12 @@ import type { GenAiOptions } from '../ai/core/utils';
 import { resolveAIRecordingOptions } from '../ai/core/utils';
 import { addResponseAttributes, onSystemOneResponse, startEvaluateSpan } from '../ai/typesafe';
 import { TYPESAFE_INTEGRATION_NAME } from '../ai/typesafe/constants';
+import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
 import { typesafeModuleNames } from '../orchestrion/config/typesafe';
 import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation';
 import { bindTracingChannelToSpan } from '../tracing-channel';
 
-/**
- * The context orchestrion shares across the tracing-channel lifecycle hooks: `arguments` is the live
- * args array passed to `systemOne(request, options)`, `self` the `TypeSafeClient`, and `result` the
- * returned `APIPromise` (replaced by the parsed response body once it arrives). `Sync` tracing keeps
- * orchestrion from calling `.then()` on it, see `orchestrion/config/typesafe.ts`.
- */
-interface TypeSafeChannelContext {
-  arguments: unknown[];
-  self?: unknown;
-  result?: unknown;
-}
-
 const _typesafeIntegration = ((options: GenAiOptions = {}) => {
   return {
     name: TYPESAFE_INTEGRATION_NAME,
@@ -33,7 +22,7 @@ const _typesafeIntegration = ((options: GenAiOptions = {}) => {
 
 function instrumentTypeSafe(options: GenAiOptions): void {
   bindTracingChannelToSpan(
-    diagnosticsChannel.tracingChannel<TypeSafeChannelContext>(CHANNELS.TYPESAFE_SYSTEM_ONE),
+    diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.TYPESAFE_SYSTEM_ONE),
     data => startEvaluateSpan(data.arguments?.[0], data.self, resolveAIRecordingOptions(options).recordInputs),
     {
       beforeSpanEnd: (span, data) => {
diff --git a/packages/server-utils/src/integrations/vercel-ai/vercel-ai-orchestrion-subscriber.ts b/packages/server-utils/src/integrations/vercel-ai/vercel-ai-orchestrion-subscriber.ts
index daf4ee24584c..2a59de79b4f8 100644
--- a/packages/server-utils/src/integrations/vercel-ai/vercel-ai-orchestrion-subscriber.ts
+++ b/packages/server-utils/src/integrations/vercel-ai/vercel-ai-orchestrion-subscriber.ts
@@ -9,6 +9,7 @@ import {
   withActiveSpan,
 } from '@sentry/core';
 import { DEBUG_BUILD } from '../../debug-build';
+import type { OrchestrionChannelContext } from '../../orchestrion/types';
 import { CHANNELS } from '../../orchestrion/channels';
 import { bindTracingChannelToSpan, type TracingChannelPayloadWithSpan } from '../../tracing-channel';
 import {
@@ -56,13 +57,6 @@ import { asString, isReadableStream, tapModelCallStream } from './util';
  * double-counts tool spans.
  */
 
-/** Shape orchestrion's transform attaches to the tracing-channel context. */
-interface OrchestrionContext {
-  arguments: unknown[];
-  result?: unknown;
-  error?: unknown;
-}
-
 /** Builds the normalized message for a channel from the wrapped call's first-arg options. */
 type MessageBuilder = (options: Record<string, unknown>, telemetry: Record<string, unknown>) => VercelAiChannelMessage;
 
@@ -227,13 +221,13 @@ function bindOperation(
   build: MessageBuilder,
   options: VercelAiChannelOptions,
 ): void {
-  const channel = tracingChannel<OrchestrionContext>(channelName);
+  const channel = tracingChannel<OrchestrionChannelContext>(channelName);
 
   // Build the operation span from the wrapped call's first argument and track it (so a model call can
   // resolve it as its parent). `bindTracingChannelToSpan` calls this once at channel `start` and makes
   // the returned span the active async context for the operation's duration — that active span is what
   // `resolveModelCallParent` reads. It also sets `data._sentrySpan`, so we don't here.
-  const buildOperationSpan = (data: TracingChannelPayloadWithSpan<OrchestrionContext>): Span | undefined => {
+  const buildOperationSpan = (data: TracingChannelPayloadWithSpan<OrchestrionChannelContext>): Span | undefined => {
     const callOptions = isObjectLike(data.arguments[0]) ? data.arguments[0] : {};
     const telemetry = isObjectLike(callOptions.experimental_telemetry) ? callOptions.experimental_telemetry : {};
     // `isEnabled === false` means the user opted out — emit no span. But `isEnabled` is also `false` on
@@ -288,7 +282,7 @@ function bindOperation(
 
   bindTracingChannelToSpan(
     channel,
-    (data: TracingChannelPayloadWithSpan<OrchestrionContext>) => buildOperationSpan(data),
+    (data: TracingChannelPayloadWithSpan<OrchestrionChannelContext>) => buildOperationSpan(data),
     {
       beforeSpanEnd: (span, data) => {
         const message = messages.get(data);
@@ -334,7 +328,7 @@ function bindOperation(
  * anything that isn't a streamed `streamText` result, so the helper ends the span as usual.
  */
 function deferStreamTextOperationEnd(
-  data: TracingChannelPayloadWithSpan<OrchestrionContext>,
+  data: TracingChannelPayloadWithSpan<OrchestrionChannelContext>,
   end: (error?: unknown) => void,
 ): boolean {
   if (messages.get(data)?.type !== 'streamText' || 'error' in data || !isStreamingResult(data.result)) {
@@ -404,7 +398,7 @@ function subscribeResolveLanguageModel(
   channelName: string,
   options: VercelAiChannelOptions,
 ): void {
-  tracingChannel<OrchestrionContext>(channelName).subscribe({
+  tracingChannel<OrchestrionChannelContext>(channelName).subscribe({
     end(rawCtx) {
       const ctx = rawCtx;
       if (!isObjectLike(ctx.result)) {
diff --git a/packages/server-utils/src/orchestrion/types.ts b/packages/server-utils/src/orchestrion/types.ts
new file mode 100644
index 000000000000..b30376cb44fb
--- /dev/null
+++ b/packages/server-utils/src/orchestrion/types.ts
@@ -0,0 +1,7 @@
+export interface OrchestrionChannelContext {
+  arguments: unknown[];
+  self?: unknown;
+  result?: unknown;
+  error?: unknown;
+  moduleVersion?: string;
+}
diff --git a/packages/server-utils/test/integrations/mastra/error-capture.test.ts b/packages/server-utils/test/integrations/mastra/error-capture.test.ts
index d0bd26dd7335..2ee0f7e368c3 100644
--- a/packages/server-utils/test/integrations/mastra/error-capture.test.ts
+++ b/packages/server-utils/test/integrations/mastra/error-capture.test.ts
@@ -1,3 +1,4 @@
+import type { OrchestrionChannelContext } from '../../../src/orchestrion/types';
 import { tracingChannel } from 'node:diagnostics_channel';
 import { GLOBAL_OBJ, setCurrentClient } from '@sentry/core';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -5,7 +6,7 @@ import { mastraIntegration } from '../../../src/integrations/mastra';
 import { CHANNELS } from '../../../src/orchestrion/channels';
 import { getDefaultTestClientOptions, TestClient } from '../../mocks/client';
 
-const channel = tracingChannel<{ error: unknown; arguments: unknown[] }>(CHANNELS.MASTRA_EXECUTE_WITH_CONTEXT);
+const channel = tracingChannel<OrchestrionChannelContext>(CHANNELS.MASTRA_EXECUTE_WITH_CONTEXT);
 
 describe('mastraIntegration error capture', () => {
   let client: TestClient;
diff --git a/packages/server-utils/test/integrations/postgres/postgres.test.ts b/packages/server-utils/test/integrations/postgres/postgres.test.ts
index 376edf60c883..db64ef9e137c 100644
--- a/packages/server-utils/test/integrations/postgres/postgres.test.ts
+++ b/packages/server-utils/test/integrations/postgres/postgres.test.ts
@@ -1,3 +1,4 @@
+import type { OrchestrionChannelContext } from '../../../src/orchestrion/types';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { tracingChannel } from 'node:diagnostics_channel';
 import type { Client, Scope, Span } from '@sentry/core';
@@ -73,11 +74,6 @@ function makeSpan(): Span {
   return { end: vi.fn(), setStatus: vi.fn(), setAttributes: vi.fn() } as unknown as Span;
 }
 
-interface ChannelContext {
-  arguments: unknown[];
-  self?: unknown;
-}
-
 describe('postgresIntegration', () => {
   let startInactiveSpanSpy: MockInstance;
   let getActiveSpanSpy: MockInstance;
@@ -113,7 +109,10 @@ describe('postgresIntegration', () => {
   const CONNECTION = { database: 'tests', host: 'localhost', port: 5432, user: 'tim' };
 
   it('query: builds a `pg.query` span with db attributes and the orchestrion origin', async () => {
-    const ctx: ChannelContext = { arguments: ['SELECT * FROM "User"'], self: { connectionParameters: CONNECTION } };
+    const ctx: OrchestrionChannelContext = {
+      arguments: ['SELECT * FROM "User"'],
+      self: { connectionParameters: CONNECTION },
+    };
 
     await tracingChannel(CHANNELS.PG_QUERY).tracePromise(async () => ({ rows: [] }), ctx);
 
@@ -138,7 +137,7 @@ describe('postgresIntegration', () => {
   });
 
   it('query: records the prepared-statement name as `db.postgresql.plan`', async () => {
-    const ctx: ChannelContext = {
+    const ctx: OrchestrionChannelContext = {
       arguments: [{ name: 'select-user-by-email', text: 'SELECT * FROM "User" WHERE "email" = $1', values: ['x'] }],
       self: { connectionParameters: CONNECTION },
     };
@@ -159,7 +158,7 @@ describe('postgresIntegration', () => {
   });
 
   it('query: sets error status and ends the span when the query rejects', async () => {
-    const ctx: ChannelContext = { arguments: ['SELECT 1'], self: { connectionParameters: CONNECTION } };
+    const ctx: OrchestrionChannelContext = { arguments: ['SELECT 1'], self: { connectionParameters: CONNECTION } };
 
     await expect(
       tracingChannel(CHANNELS.PG_QUERY).tracePromise(async () => {
@@ -172,7 +171,7 @@ describe('postgresIntegration', () => {
   });
 
   it('connect: builds a `pg.connect` span with no origin (defaults to manual)', async () => {
-    const ctx: ChannelContext = { arguments: [], self: { connectionParameters: CONNECTION } };
+    const ctx: OrchestrionChannelContext = { arguments: [], self: { connectionParameters: CONNECTION } };
 
     await tracingChannel(CHANNELS.PG_CONNECT).tracePromise(async () => undefined, ctx);
 
@@ -193,7 +192,7 @@ describe('postgresIntegration', () => {
   });
 
   it('pool connect: builds a `pg-pool.connect` span with masked connection string + pool attributes', async () => {
-    const ctx: ChannelContext = {
+    const ctx: OrchestrionChannelContext = {
       arguments: [],
       self: {
         options: {
@@ -229,7 +228,7 @@ describe('postgresIntegration', () => {
   });
 
   it('pool connect: falls back to the explicit `port` when the connection string omits it (OTel parity)', async () => {
-    const ctx: ChannelContext = {
+    const ctx: OrchestrionChannelContext = {
       arguments: [],
       self: {
         options: {
@@ -254,7 +253,7 @@ describe('postgresIntegration', () => {
 
   it('requireParentSpan: does not create a span when there is no active span', async () => {
     getActiveSpanSpy.mockReturnValue(undefined);
-    const ctx: ChannelContext = { arguments: ['SELECT 1'], self: { connectionParameters: CONNECTION } };
+    const ctx: OrchestrionChannelContext = { arguments: ['SELECT 1'], self: { connectionParameters: CONNECTION } };
 
     await tracingChannel(CHANNELS.PG_QUERY).tracePromise(async () => ({ rows: [] }), ctx);
 

From 84d63780e31fb258d9f5bcd7c0677bb7e39ff803 Mon Sep 17 00:00:00 2001
From: Sigrid <32902192+s1gr1d@users.noreply.github.com>
Date: Fri, 9 Oct 2026 11:26:50 +0200
Subject: [PATCH 10/84] fix(profiling-node): Stop the trace lifecycle profiler
 when spans are unsampled (#25210)

With `profileLifecycle: 'trace'`, the profiler counted every `spanStart`
and `spanEnd`. Unsampled child spans emit `spanStart` but never
`spanEnd`, so the count never got back to 0. The profiler kept running,
and Node never exited.

- Trace mode now tracks only sampled spans, by span ID.
- A stop just before the next 60s chunk started did not prevent that
chunk, so profiling started again (manual and trace mode). A stop now
cancels the scheduled chunk.
- New debug logs show skipped unsampled traces and cancelled chunks.

A fake-timer test stops profiling in the gap between two chunks and
checks that no new chunk starts.

Fixes #25174
---
 packages/profiling-node/src/integration.ts    |  78 +++++--
 .../profiling-node/test/integration.test.ts   | 190 ++++++++++++++++++
 2 files changed, 253 insertions(+), 15 deletions(-)

diff --git a/packages/profiling-node/src/integration.ts b/packages/profiling-node/src/integration.ts
index a158019ee036..0832bd379c11 100644
--- a/packages/profiling-node/src/integration.ts
+++ b/packages/profiling-node/src/integration.ts
@@ -1,6 +1,15 @@
 /* eslint-disable max-lines */
 import type { Event, IntegrationFn, ProfileChunk, ProfilingIntegration } from '@sentry/core';
-import { consoleSandbox, debug, defineIntegration, getCurrentScope, getGlobalScope, uuid4 } from '@sentry/core';
+import {
+  consoleSandbox,
+  debug,
+  defineIntegration,
+  getCurrentScope,
+  getGlobalScope,
+  getRootSpan,
+  spanIsSampled,
+  uuid4,
+} from '@sentry/core';
 import type { NodeClient } from '@sentry/node';
 import { CpuProfilerBindings, ProfileFormat } from '@sentry/node-cpu-profiler';
 import { isMainThread } from 'worker_threads';
@@ -24,6 +33,7 @@ class ContinuousProfiler {
   private _profilerId: string | undefined;
   private _client: NodeClient | undefined = undefined;
   private _chunkData: ChunkData | undefined = undefined;
+  private _pendingChunkRestart: NodeJS.Immediate | undefined = undefined;
   private _profileLifecycle: 'manual' | 'trace' | undefined = undefined;
   private _sampled: boolean | undefined = undefined;
   private _sessionSamplingRate: number | undefined = undefined;
@@ -95,7 +105,7 @@ class ContinuousProfiler {
   }
 
   private _startProfiler(): void {
-    if (this._chunkData !== undefined) {
+    if (this._isSessionRunning()) {
       DEBUG_BUILD && debug.log('[Profiling] Profile session already running, no-op.');
       return;
     }
@@ -125,7 +135,7 @@ class ContinuousProfiler {
       return;
     }
 
-    if (!this._chunkData) {
+    if (!this._isSessionRunning()) {
       DEBUG_BUILD && debug.log('[Profiling] No profile session running, no-op.');
       return;
     }
@@ -151,19 +161,30 @@ class ContinuousProfiler {
       return;
     }
 
-    let activeSpanCounter = 0;
-    this._client.on('spanStart', _span => {
-      if (activeSpanCounter === 0) {
+    // Unsampled child spans emit `spanStart` but never `spanEnd`, so only sampled spans are tracked.
+    const activeSpanIds = new Set<string>();
+    this._client.on('spanStart', span => {
+      if (!spanIsSampled(span)) {
+        if (DEBUG_BUILD && span === getRootSpan(span)) {
+          debug.log('[Profiling] Not profiling trace because its root span was not sampled.');
+        }
+        return;
+      }
+      if (activeSpanIds.size === 0) {
         this._startChunkProfiling();
       }
-      activeSpanCounter++;
+      activeSpanIds.add(span.spanContext().spanId);
     });
 
-    this._client.on('spanEnd', _span => {
-      if (activeSpanCounter === 1) {
+    this._client.on('spanEnd', span => {
+      const spanId = span.spanContext().spanId;
+      if (!activeSpanIds.has(spanId)) {
+        return;
+      }
+      activeSpanIds.delete(spanId);
+      if (activeSpanIds.size === 0) {
         this._stopChunkProfiling();
       }
-      activeSpanCounter--;
     });
   }
 
@@ -194,6 +215,10 @@ class ContinuousProfiler {
    * Stops profiling of the current chunks and flushes the profile to Sentry
    */
   private _stopChunkProfiling(): void {
+    // The chunk timer stops the current chunk before it schedules the next one, so a stop that lands
+    // in between must also cancel that restart, or profiling continues with nothing left to profile.
+    this._cancelPendingChunkRestart();
+
     if (!this._chunkData) {
       DEBUG_BUILD && debug.log('[Profiling] No chunk data found, no-op.');
       return;
@@ -257,10 +282,6 @@ class ContinuousProfiler {
     }
 
     this._flush(chunk);
-    // Depending on the profile and stack sizes, stopping the profile and converting
-    // the format may negatively impact the performance of the application. To avoid
-    // blocking for too long, enqueue the next chunk start inside the next macrotask.
-    // clear current chunk
     this._resetChunkData();
   }
 
@@ -305,13 +326,40 @@ class ContinuousProfiler {
       DEBUG_BUILD && debug.log(`[Profiling] Stopping profiling chunk: ${chunk.id}`);
       this._stopChunkProfiling();
       DEBUG_BUILD && debug.log('[Profiling] Starting new profiling chunk.');
-      setImmediate(this._restartChunkProfiling.bind(this));
+      // Depending on the profile and stack sizes, stopping the profile and converting
+      // the format may negatively impact the performance of the application. To avoid
+      // blocking for too long, enqueue the next chunk start inside the next macrotask.
+      this._pendingChunkRestart = setImmediate(() => {
+        this._pendingChunkRestart = undefined;
+        this._restartChunkProfiling();
+      });
     }, CHUNK_INTERVAL_MS);
 
     // Unref timeout so it doesn't keep the process alive.
     chunk.timer.unref();
   }
 
+  /**
+   * A session is also running in the gap after the chunk timer stopped one chunk and before the next one starts.
+   */
+  private _isSessionRunning(): boolean {
+    return this._chunkData !== undefined || this._pendingChunkRestart !== undefined;
+  }
+
+  /**
+   * Cancels the next chunk if the chunk timer scheduled one that has not started yet.
+   */
+  private _cancelPendingChunkRestart(): void {
+    if (!this._pendingChunkRestart) {
+      return;
+    }
+
+    clearImmediate(this._pendingChunkRestart);
+    this._pendingChunkRestart = undefined;
+    DEBUG_BUILD &&
+      debug.log('[Profiling] Profiling stopped before the next chunk started, cancelled the scheduled chunk.');
+  }
+
   /**
    * Attaches profiling information to spans that were started
    * during a profiling session.
diff --git a/packages/profiling-node/test/integration.test.ts b/packages/profiling-node/test/integration.test.ts
index b7c24525419d..cff99664dc78 100644
--- a/packages/profiling-node/test/integration.test.ts
+++ b/packages/profiling-node/test/integration.test.ts
@@ -1,4 +1,5 @@
 import type { Transport } from '@sentry/core';
+import { debug } from '@sentry/core';
 import * as Sentry from '@sentry/node';
 import type { NodeClientOptions } from '@sentry/node/build/types/types';
 import { CpuProfilerBindings } from '@sentry/node-cpu-profiler';
@@ -54,6 +55,21 @@ describe('ProfilingIntegration', () => {
       expect(stopProfilingSpy).toHaveBeenCalled();
     });
 
+    it('logs a no-op when stopping without a running profile session', () => {
+      const [client] = makeSpanProfilingClient({
+        profileLifecycle: 'manual',
+        profileSessionSampleRate: 1,
+      });
+      Sentry.setCurrentClient(client);
+      client.init();
+
+      const debugLogSpy = vi.spyOn(debug, 'log');
+
+      Sentry.profiler.stopProfiler();
+
+      expect(debugLogSpy).toHaveBeenCalledWith('[Profiling] No profile session running, no-op.');
+    });
+
     it('calling start and stop while profile session is running does nothing', () => {
       const [client] = makeSpanProfilingClient({
         profileLifecycle: 'manual',
@@ -305,6 +321,90 @@ describe('ProfilingIntegration', () => {
       expect(stopProfilingSpy).toHaveBeenCalled();
     });
 
+    it('logs when it skips a trace because the root span is not sampled', () => {
+      const [client] = makeSpanProfilingClient({
+        profileLifecycle: 'trace',
+        profileSessionSampleRate: 1,
+        tracesSampleRate: 0,
+      });
+
+      Sentry.setCurrentClient(client);
+      client.init();
+
+      const debugLogSpy = vi.spyOn(debug, 'log');
+
+      Sentry.startInactiveSpan({ name: 'GET /users/:id' });
+
+      expect(debugLogSpy).toHaveBeenCalledWith(
+        '[Profiling] Not profiling trace because its root span was not sampled.',
+      );
+    });
+
+    it('does not log skipped unsampled child spans', () => {
+      const [client] = makeSpanProfilingClient({
+        profileLifecycle: 'trace',
+        profileSessionSampleRate: 1,
+        tracesSampleRate: 0,
+      });
+
+      Sentry.setCurrentClient(client);
+      client.init();
+
+      const rootSpan = Sentry.startInactiveSpan({ name: 'GET /users/:id' });
+      const debugLogSpy = vi.spyOn(debug, 'log');
+
+      Sentry.startInactiveSpan({ name: 'SELECT * FROM users', parentSpan: rootSpan });
+
+      expect(debugLogSpy).not.toHaveBeenCalledWith(
+        '[Profiling] Not profiling trace because its root span was not sampled.',
+      );
+    });
+
+    it('does not start the profiler for unsampled spans', () => {
+      const [client] = makeSpanProfilingClient({
+        profileLifecycle: 'trace',
+        profileSessionSampleRate: 1,
+        tracesSampleRate: 0,
+      });
+
+      Sentry.setCurrentClient(client);
+      client.init();
+
+      const startProfilingSpy = vi.spyOn(CpuProfilerBindings, 'startProfiling');
+
+      Sentry.startSpan({ name: 'root' }, () => {
+        Sentry.startSpan({ name: 'child' }, () => {});
+      });
+
+      expect(startProfilingSpy).not.toHaveBeenCalled();
+    });
+
+    it('stops the profiler after the last sampled span ends, ignoring unsampled spans', () => {
+      const [client] = makeSpanProfilingClient({
+        profileLifecycle: 'trace',
+        profileSessionSampleRate: 1,
+        tracesSampler: ({ name }) => (name === 'sampled' ? 1 : 0),
+      });
+
+      Sentry.setCurrentClient(client);
+      client.init();
+
+      const startProfilingSpy = vi.spyOn(CpuProfilerBindings, 'startProfiling');
+      const stopProfilingSpy = vi.spyOn(CpuProfilerBindings, 'stopProfiling');
+
+      Sentry.startSpan({ name: 'unsampled' }, () => {
+        Sentry.startSpan({ name: 'unsampled-child' }, () => {});
+      });
+
+      Sentry.startSpan({ name: 'sampled' }, () => {
+        Sentry.startSpan({ name: 'sampled-child' }, () => {});
+        expect(startProfilingSpy).toHaveBeenCalledTimes(1);
+        expect(stopProfilingSpy).not.toHaveBeenCalled();
+      });
+
+      expect(stopProfilingSpy).toHaveBeenCalledTimes(1);
+    });
+
     describe('envelope', () => {
       beforeEach(() => {
         vi.useRealTimers();
@@ -345,6 +445,96 @@ describe('ProfilingIntegration', () => {
       });
     });
   });
+
+  describe('chunk restart', () => {
+    const lifecycles = [
+      {
+        profileLifecycle: 'manual',
+        startProfiling: () => {
+          Sentry.profiler.startProfiler();
+          return () => Sentry.profiler.stopProfiler();
+        },
+      },
+      {
+        profileLifecycle: 'trace',
+        startProfiling: () => {
+          const span = Sentry.startInactiveSpan({ name: 'GET /users/:id' });
+          return () => span.end();
+        },
+      },
+    ] as const;
+
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it.each(lifecycles)(
+      'does not start a new chunk when $profileLifecycle profiling stops before the scheduled restart',
+      ({ profileLifecycle, startProfiling }) => {
+        const [client] = makeSpanProfilingClient({ profileLifecycle, profileSessionSampleRate: 1 });
+        Sentry.setCurrentClient(client);
+        client.init();
+
+        const startProfilingSpy = vi.spyOn(CpuProfilerBindings, 'startProfiling');
+        const stopProfilingSpy = vi.spyOn(CpuProfilerBindings, 'stopProfiling');
+        const debugLogSpy = vi.spyOn(debug, 'log');
+        const stopProfiling = startProfiling();
+        vi.advanceTimersToNextTimer();
+        expect(stopProfilingSpy).toHaveBeenCalledTimes(1);
+
+        stopProfiling();
+        vi.runOnlyPendingTimers();
+
+        expect(startProfilingSpy).toHaveBeenCalledTimes(1);
+        expect(debugLogSpy).toHaveBeenCalledWith(
+          '[Profiling] Profiling stopped before the next chunk started, cancelled the scheduled chunk.',
+        );
+      },
+    );
+
+    it('does not start a second chunk when manual profiling starts between two chunks', () => {
+      const [client] = makeSpanProfilingClient({ profileLifecycle: 'manual', profileSessionSampleRate: 1 });
+      Sentry.setCurrentClient(client);
+      client.init();
+
+      const startProfilingSpy = vi.spyOn(CpuProfilerBindings, 'startProfiling');
+      const stopProfilingSpy = vi.spyOn(CpuProfilerBindings, 'stopProfiling');
+      Sentry.profiler.startProfiler();
+      vi.advanceTimersToNextTimer();
+
+      Sentry.profiler.startProfiler();
+      vi.runOnlyPendingTimers();
+
+      expect(startProfilingSpy).toHaveBeenCalledTimes(2);
+      expect(stopProfilingSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it.each(lifecycles)(
+      'does not report a cancelled chunk when $profileLifecycle profiling stops after the restart',
+      ({ profileLifecycle, startProfiling }) => {
+        const [client] = makeSpanProfilingClient({ profileLifecycle, profileSessionSampleRate: 1 });
+        Sentry.setCurrentClient(client);
+        client.init();
+
+        const startProfilingSpy = vi.spyOn(CpuProfilerBindings, 'startProfiling');
+        const debugLogSpy = vi.spyOn(debug, 'log');
+        const stopProfiling = startProfiling();
+        vi.advanceTimersToNextTimer();
+        vi.runOnlyPendingTimers();
+        expect(startProfilingSpy).toHaveBeenCalledTimes(2);
+
+        stopProfiling();
+
+        expect(debugLogSpy).not.toHaveBeenCalledWith(
+          '[Profiling] Profiling stopped before the next chunk started, cancelled the scheduled chunk.',
+        );
+      },
+    );
+  });
 });
 
 describe('NODE_VERSION', () => {

From 83e3b70dd456fa65f6a90bec231299e24a527d59 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 11:29:36 +0200
Subject: [PATCH 11/84] test(node): Port HTTP options and hooks to span
 streaming (#25195)

Exercise HTTP hooks, ignored requests, and static-asset handling with
streamed spans.

Part of #24135

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../httpIntegration/instrument-options.mjs    |  11 +-
 .../server-ignoreIncomingRequests.js          |   9 +-
 .../server-ignoreOutgoingRequests.js          |   3 +-
 .../server-ignoreStaticAssets.js              |  12 +-
 .../httpIntegration/server-outgoingHooks.js   |   1 -
 .../server-traceStaticAssets.js               |   1 -
 .../suites/tracing/httpIntegration/test.ts    | 168 ++++++++++--------
 7 files changed, 117 insertions(+), 88 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/instrument-options.mjs b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/instrument-options.mjs
index 6908a019faa3..d283ccff7951 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/instrument-options.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/instrument-options.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
@@ -12,11 +11,11 @@ Sentry.init({
     Sentry.httpIntegration({
       onSpanCreated: (span, req, res) => {
         span.setAttribute('onSpanCreated', 'yes');
-        Sentry.setExtra('onSpanCreatedCalled', {
-          reqUrl: req.url,
-          reqMethod: req.method,
-          resUrl: res.req.url,
-          resMethod: res.req.method,
+        span.setAttributes({
+          'onSpanCreated.reqUrl': req.url,
+          'onSpanCreated.reqMethod': req.method,
+          'onSpanCreated.resUrl': res.req.url,
+          'onSpanCreated.resMethod': res.req.method,
         });
       },
     }),
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreIncomingRequests.js b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreIncomingRequests.js
index fa075766b2b0..bd5d776d3a66 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreIncomingRequests.js
+++ b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreIncomingRequests.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
@@ -11,6 +10,9 @@ Sentry.init({
   integrations: [
     Sentry.httpIntegration({
       ignoreIncomingRequests: (url, request) => {
+        if (request.url === '/flush') {
+          return true;
+        }
         if (url.includes('/liveness')) {
           return true;
         }
@@ -32,6 +34,11 @@ const app = express();
 
 app.use(cors());
 
+app.get('/flush', async (_req, res) => {
+  await Sentry.flush();
+  res.send({ response: 'flushed' });
+});
+
 app.get('/test', (_req, res) => {
   res.send({ response: 'response 1' });
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreOutgoingRequests.js b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreOutgoingRequests.js
index 79f6023fe441..9ff591659f39 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreOutgoingRequests.js
+++ b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreOutgoingRequests.js
@@ -4,7 +4,6 @@ const Sentry = require('@sentry/node');
 const url = process.env.SERVER_URL;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
@@ -40,6 +39,7 @@ app.use(cors());
 app.get('/testUrl', (_req, response) => {
   makeHttpRequest(`${url}/blockUrl`).then(() => {
     makeHttpRequest(`${url}/pass`).then(() => {
+      Sentry.captureMessage('outgoing requests completed');
       response.send({ response: 'done' });
     });
   });
@@ -48,6 +48,7 @@ app.get('/testUrl', (_req, response) => {
 app.get('/testRequest', (_req, response) => {
   makeHttpRequest(`${url}/blockRequest`).then(() => {
     makeHttpRequest(`${url}/pass`).then(() => {
+      Sentry.captureMessage('outgoing requests completed');
       response.send({ response: 'done' });
     });
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreStaticAssets.js b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreStaticAssets.js
index d6c17309f66b..edbe00116bf2 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreStaticAssets.js
+++ b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-ignoreStaticAssets.js
@@ -2,13 +2,16 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
   // Test default for ignoreStaticAssets: true
-  integrations: [Sentry.httpIntegration()],
+  integrations: [
+    Sentry.httpIntegration({
+      ignoreIncomingRequests: (_url, request) => request.url === '/flush',
+    }),
+  ],
 });
 
 const express = require('express');
@@ -19,6 +22,11 @@ const app = express();
 
 app.use(cors());
 
+app.get('/flush', async (_req, res) => {
+  await Sentry.flush();
+  res.send({ response: 'flushed' });
+});
+
 app.get('/test', (_req, res) => {
   res.send({ response: 'ok' });
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-outgoingHooks.js b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-outgoingHooks.js
index 23a9006a63b5..7ddda2264933 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-outgoingHooks.js
+++ b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-outgoingHooks.js
@@ -4,7 +4,6 @@ const Sentry = require('@sentry/node');
 const url = process.env.SERVER_URL;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-traceStaticAssets.js b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-traceStaticAssets.js
index e1fd410500a1..9c2b3afd24ae 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-traceStaticAssets.js
+++ b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/server-traceStaticAssets.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts
index 1225b5891e8f..d0508d189bb3 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts
@@ -1,4 +1,4 @@
-import { HTTP_SERVER } from '@sentry/conventions/op';
+import { HTTP_CLIENT, HTTP_SERVER } from '@sentry/conventions/op';
 import { createTestServer } from '@sentry-internal/test-utils';
 import { HTTP_RESPONSE_STATUS_CODE, SENTRY_OP, URL_FULL, URL_PATH } from '@sentry/conventions/attributes';
 import { afterAll, describe, expect, test } from 'vitest';
@@ -27,28 +27,25 @@ describe('httpIntegration', () => {
       test('allows to configure onSpanCreated', async () => {
         const runner = createRunner()
           .expect({
-            transaction: {
-              contexts: {
-                trace: {
+            span: {
+              items: expect.arrayContaining([
+                expect.objectContaining({
+                  is_segment: true,
                   span_id: expect.stringMatching(/[a-f\d]{16}/),
                   trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                  data: {
-                    'url.full': expect.stringMatching(/\/test$/),
-                    'http.response.status_code': 200,
-                    onSpanCreated: 'yes',
-                  },
-                  op: 'http.server',
                   status: 'ok',
-                },
-              },
-              extra: expect.objectContaining({
-                onSpanCreatedCalled: {
-                  reqUrl: expect.stringMatching(/\/test$/),
-                  reqMethod: 'GET',
-                  resUrl: expect.stringMatching(/\/test$/),
-                  resMethod: 'GET',
-                },
-              }),
+                  attributes: expect.objectContaining({
+                    [URL_FULL]: { type: 'string', value: expect.stringMatching(/\/test$/) },
+                    [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                    [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                    onSpanCreated: { type: 'string', value: 'yes' },
+                    'onSpanCreated.reqUrl': { type: 'string', value: expect.stringMatching(/\/test$/) },
+                    'onSpanCreated.reqMethod': { type: 'string', value: 'GET' },
+                    'onSpanCreated.resUrl': { type: 'string', value: expect.stringMatching(/\/test$/) },
+                    'onSpanCreated.resMethod': { type: 'string', value: 'GET' },
+                  }),
+                }),
+              ]),
             },
           })
           .start();
@@ -67,15 +64,15 @@ describe('httpIntegration', () => {
       const runner = createRunner(__dirname, 'server-outgoingHooks.js')
         .withEnv({ SERVER_URL })
         .expect({
-          transaction: event => {
-            const clientSpans = event.spans?.filter(span => span.op === 'http.client');
+          span: container => {
+            const clientSpans = container.items.filter(span => span.attributes[SENTRY_OP]?.value === HTTP_CLIENT);
             expect(clientSpans).toHaveLength(1);
 
             // All three hooks run before the span ends, so every attribute has to survive to the envelope.
-            const data = clientSpans![0]?.data;
-            expect(data?.['outgoingRequestHook']).toBe('GET');
-            expect(data?.['outgoingResponseHook']).toBe(200);
-            expect(data?.['outgoingRequestApplyCustomAttributes']).toBe('GET 200');
+            const attributes = clientSpans[0]?.attributes;
+            expect(attributes?.['outgoingRequestHook']).toEqual({ type: 'string', value: 'GET' });
+            expect(attributes?.['outgoingResponseHook']).toEqual({ type: 'integer', value: 200 });
+            expect(attributes?.['outgoingRequestApplyCustomAttributes']).toEqual({ type: 'string', value: 'GET 200' });
           },
         })
         .start();
@@ -455,52 +452,58 @@ describe('httpIntegration', () => {
     test('via the url param', async () => {
       const runner = createRunner(__dirname, 'server-ignoreIncomingRequests.js')
         .expect({
-          transaction: {
-            contexts: {
-              trace: {
+          span: {
+            items: expect.arrayContaining([
+              expect.objectContaining({
+                name: 'GET /test',
+                is_segment: true,
                 span_id: expect.stringMatching(/[a-f\d]{16}/),
                 trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                data: {
-                  'url.full': expect.stringMatching(/\/test$/),
-                  'http.response.status_code': 200,
-                },
-                op: 'http.server',
                 status: 'ok',
-              },
-            },
-            transaction: 'GET /test',
+                attributes: expect.objectContaining({
+                  [URL_FULL]: { type: 'string', value: expect.stringMatching(/\/test$/) },
+                  [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                  [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                }),
+              }),
+            ]),
           },
         })
         .start();
 
-      runner.makeRequest('get', '/liveness'); // should be ignored
-      runner.makeRequest('get', '/test');
+      await runner.makeRequest('get', '/liveness'); // should be ignored
+      // Flush so any span from the ignored request fails the expectation before /test runs.
+      await runner.makeRequest('get', '/flush');
+      await runner.makeRequest('get', '/test');
       await runner.completed();
     });
 
     test('via the request param', async () => {
       const runner = createRunner(__dirname, 'server-ignoreIncomingRequests.js')
         .expect({
-          transaction: {
-            contexts: {
-              trace: {
+          span: {
+            items: expect.arrayContaining([
+              expect.objectContaining({
+                name: 'GET /test',
+                is_segment: true,
                 span_id: expect.stringMatching(/[a-f\d]{16}/),
                 trace_id: expect.stringMatching(/[a-f\d]{32}/),
-                data: {
-                  'url.full': expect.stringMatching(/\/test$/),
-                  'http.response.status_code': 200,
-                },
-                op: 'http.server',
                 status: 'ok',
-              },
-            },
-            transaction: 'GET /test',
+                attributes: expect.objectContaining({
+                  [URL_FULL]: { type: 'string', value: expect.stringMatching(/\/test$/) },
+                  [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                  [SENTRY_OP]: { type: 'string', value: HTTP_SERVER },
+                }),
+              }),
+            ]),
           },
         })
         .start();
 
-      runner.makeRequest('post', '/readiness'); // should be ignored
-      runner.makeRequest('get', '/test');
+      await runner.makeRequest('post', '/readiness'); // should be ignored
+      // Flush so any span from the ignored request fails the expectation before /test runs.
+      await runner.makeRequest('get', '/flush');
+      await runner.makeRequest('get', '/test');
       await runner.completed();
     });
   });
@@ -515,18 +518,22 @@ describe('httpIntegration', () => {
       const runner = createRunner(__dirname, 'server-ignoreOutgoingRequests.js')
         .withEnv({ SERVER_URL })
         .expect({
-          transaction: event => {
-            expect(event.transaction).toBe('GET /testUrl');
-
-            const requestSpans = event.spans?.filter(span => span.op === 'http.client');
-            expect(requestSpans).toHaveLength(1);
-            expect(requestSpans![0]?.description).toBe(`GET ${SERVER_URL}/pass`);
-
+          event: event => {
             const breadcrumbs = event.breadcrumbs?.filter(b => b.category === 'http');
             expect(breadcrumbs).toHaveLength(1);
             expect(breadcrumbs![0]?.data?.url).toEqual(`${SERVER_URL}/pass`);
           },
         })
+        .expect({
+          span: container => {
+            expect(container.items.find(span => span.is_segment)?.name).toBe('GET /testUrl');
+
+            const requestSpans = container.items.filter(span => span.attributes[SENTRY_OP]?.value === HTTP_CLIENT);
+            expect(requestSpans).toHaveLength(1);
+            expect(requestSpans[0]?.name).toBe('GET localhost');
+            expect(requestSpans[0]?.attributes[URL_FULL]).toEqual({ type: 'string', value: `${SERVER_URL}/pass` });
+          },
+        })
         .start();
       runner.makeRequest('get', '/testUrl');
       await runner.completed();
@@ -542,18 +549,22 @@ describe('httpIntegration', () => {
       const runner = createRunner(__dirname, 'server-ignoreOutgoingRequests.js')
         .withEnv({ SERVER_URL })
         .expect({
-          transaction: event => {
-            expect(event.transaction).toBe('GET /testRequest');
-
-            const requestSpans = event.spans?.filter(span => span.op === 'http.client');
-            expect(requestSpans).toHaveLength(1);
-            expect(requestSpans![0]?.description).toBe(`GET ${SERVER_URL}/pass`);
-
+          event: event => {
             const breadcrumbs = event.breadcrumbs?.filter(b => b.category === 'http');
             expect(breadcrumbs).toHaveLength(1);
             expect(breadcrumbs![0]?.data?.url).toEqual(`${SERVER_URL}/pass`);
           },
         })
+        .expect({
+          span: container => {
+            expect(container.items.find(span => span.is_segment)?.name).toBe('GET /testRequest');
+
+            const requestSpans = container.items.filter(span => span.attributes[SENTRY_OP]?.value === HTTP_CLIENT);
+            expect(requestSpans).toHaveLength(1);
+            expect(requestSpans[0]?.name).toBe('GET localhost');
+            expect(requestSpans[0]?.attributes[URL_FULL]).toEqual({ type: 'string', value: `${SERVER_URL}/pass` });
+          },
+        })
         .start();
       runner.makeRequest('get', '/testRequest');
 
@@ -565,11 +576,12 @@ describe('httpIntegration', () => {
   test('ignores static asset requests by default', async () => {
     const runner = createRunner(__dirname, 'server-ignoreStaticAssets.js')
       .expect({
-        transaction: event => {
-          expect(event.transaction).toBe('GET /test');
-          expect(event.contexts?.trace?.data?.['url.full']).toMatch(/\/test$/);
-          expect(event.contexts?.trace?.op).toBe('http.server');
-          expect(event.contexts?.trace?.status).toBe('ok');
+        span: container => {
+          const segment = container.items.find(span => span.is_segment);
+          expect(segment?.name).toBe('GET /test');
+          expect(segment?.attributes[URL_FULL]?.value).toMatch(/\/test$/);
+          expect(segment?.attributes[SENTRY_OP]).toEqual({ type: 'string', value: HTTP_SERVER });
+          expect(segment?.status).toBe('ok');
         },
       })
       .start();
@@ -579,6 +591,9 @@ describe('httpIntegration', () => {
     await runner.makeRequest('get', '/robots.txt');
     await runner.makeRequest('get', '/assets/app.js');
 
+    // Flush so any static-asset span fails the expectation before /test runs.
+    await runner.makeRequest('get', '/flush');
+
     // This one should be traced
     await runner.makeRequest('get', '/test');
 
@@ -588,11 +603,12 @@ describe('httpIntegration', () => {
   test('traces static asset requests when ignoreStaticAssets is false', async () => {
     const runner = createRunner(__dirname, 'server-traceStaticAssets.js')
       .expect({
-        transaction: event => {
-          expect(event.transaction).toBe('GET /favicon.ico');
-          expect(event.contexts?.trace?.data?.['url.full']).toMatch(/\/favicon.ico$/);
-          expect(event.contexts?.trace?.op).toBe('http.server');
-          expect(event.contexts?.trace?.status).toBe('ok');
+        span: container => {
+          const segment = container.items.find(span => span.is_segment);
+          expect(segment?.name).toBe('GET /favicon.ico');
+          expect(segment?.attributes[URL_FULL]?.value).toMatch(/\/favicon.ico$/);
+          expect(segment?.attributes[SENTRY_OP]).toEqual({ type: 'string', value: HTTP_SERVER });
+          expect(segment?.status).toBe('ok');
         },
       })
       .start();

From 668a513a62f6cd1722dc91bf1a35e3297324fce7 Mon Sep 17 00:00:00 2001
From: Charly Gomez <charly.gomez1310@gmail.com>
Date: Fri, 9 Oct 2026 11:37:41 +0200
Subject: [PATCH 12/84] ci: Install Playwright in the background during E2E app
 builds (#25207)

E2E jobs installed Playwright after the app build. This uses the new
[parallel
steps](https://github.blog/changelog/2026-06-25-actions-steps-can-now-be-run-in-parallel/)
to install the root workspace's Playwright version in the background
while the app builds. Apps on a different version still get theirs
installed after the build. This saves about 16-19s per E2E job.

The background install starts after the artifact downloads on purpose.
Starting it next to `download-artifact` made about 5% of jobs fail with
"Unexpected end of JSON input".

Refs #25134

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/actions/install-playwright/action.yml | 12 ++++++++
 .github/workflows/build.yml                   | 30 +++++++++++++++++--
 2 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/.github/actions/install-playwright/action.yml b/.github/actions/install-playwright/action.yml
index d2f1fd723b1a..6c8ea05d3c91 100644
--- a/.github/actions/install-playwright/action.yml
+++ b/.github/actions/install-playwright/action.yml
@@ -7,6 +7,15 @@ inputs:
   cwd:
     description: 'The working directory to run Playwright in.'
     default: '.'
+  installed-version:
+    description:
+      'A Playwright version that an earlier run of this action already installed. Skips the install if it matches.'
+    default: ''
+
+outputs:
+  version:
+    description: 'The resolved Playwright version, empty if Playwright is not installed or the install was skipped.'
+    value: ${{ steps.playwright-version.outputs.version }}
 
 runs:
   using: 'composite'
@@ -18,8 +27,11 @@ runs:
       id: playwright-version
       run: |
         version=$(node -e "let v = ''; try { v = require('@playwright/test/package.json').version; } catch {} process.stdout.write(String(v));")
+        if [ "$version" = "$INSTALLED_VERSION" ]; then version=''; fi
         echo "version=$version" >> "$GITHUB_OUTPUT"
       shell: bash
+      env:
+        INSTALLED_VERSION: ${{ inputs.installed-version }}
       working-directory: ${{ inputs.cwd }}
 
     - name: Restore cached playwright binaries
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 9a4147ac902e..658fd862749c 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1092,6 +1092,16 @@ jobs:
           name: build-layer-output
           path: ${{ env.BUILD_LAYER_PATH }}
 
+      # Installs the root workspace's Playwright version while the app builds. Most apps use the same version.
+      # The app's own version is only known after its build, so it gets installed then if it differs.
+      # Started after the artifact downloads: starting next to them made `download-artifact` fail to read the event file.
+      - name: Install Playwright
+        id: install-playwright
+        background: true
+        uses: ./.github/actions/install-playwright
+        with:
+          browsers: chromium
+
       - name: Prepare e2e tests
         run: yarn test:prepare
         working-directory: dev-packages/e2e-tests
@@ -1117,11 +1127,14 @@ jobs:
         env:
           SENTRY_E2E_WORKSPACE_ROOT: ${{ github.workspace }}
 
-      - name: Install Playwright
+      - wait: [install-playwright]
+
+      - name: Install Playwright for the app's version
         uses: ./.github/actions/install-playwright
         with:
           browsers: chromium
           cwd: ${{ runner.temp }}/test-application
+          installed-version: ${{ steps.install-playwright.outputs.version }}
 
       - name: Run E2E test
         working-directory: ${{ runner.temp }}/test-application
@@ -1221,6 +1234,16 @@ jobs:
           name: build-tarball-output
           path: ${{ env.TARBALL_ARTIFACT_DOWNLOAD_PATH }}
 
+      # Installs the root workspace's Playwright version while the app builds. Most apps use the same version.
+      # The app's own version is only known after its build, so it gets installed then if it differs.
+      # Started after the artifact downloads: starting next to them made `download-artifact` fail to read the event file.
+      - name: Install Playwright
+        id: install-playwright
+        background: true
+        uses: ./.github/actions/install-playwright
+        with:
+          browsers: chromium
+
       - name: Prepare E2E tests
         run: yarn test:prepare
         working-directory: dev-packages/e2e-tests
@@ -1244,11 +1267,14 @@ jobs:
         timeout-minutes: 7
         run: ${{ matrix.build-command || 'pnpm test:build' }}
 
-      - name: Install Playwright
+      - wait: [install-playwright]
+
+      - name: Install Playwright for the app's version
         uses: ./.github/actions/install-playwright
         with:
           browsers: chromium
           cwd: ${{ runner.temp }}/test-application
+          installed-version: ${{ steps.install-playwright.outputs.version }}
 
       - name: Run E2E test
         working-directory: ${{ runner.temp }}/test-application

From 4422cef113bcaae1cde729daa68043564d8b5b51 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 11:41:05 +0200
Subject: [PATCH 13/84] test(node): Port outgoing HTTP client spans to
 streaming (#25192)

Exercise outgoing request hooks, header collection, query handling, and
fetch errors through streamed spans. Preserve the existing basic HTTP
and fetch transaction suites as static coverage, along with the request
and correlation checks in the migrated cases.

Part of #24135

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../node-suites/excludes.ts                   |  2 +-
 .../node-suites/excludes.ts                   |  2 +-
 .../instrument.mjs                            |  1 -
 .../scenario-fetch.mjs                        |  0
 .../test.ts                                   |  3 +-
 .../fetch-basic-streamed/instrument.mjs       |  1 -
 .../fetch-error/instrument.mjs                |  1 -
 .../http-client-spans/fetch-error/test.ts     | 27 +++++---
 .../fetch-forward-request-hook/instrument.mjs |  1 -
 .../fetch-forward-request-hook/test.ts        | 46 +++++++------
 .../instrument.mjs                            |  1 -
 .../fetch-headers-to-span-attributes/test.ts  | 46 ++++++++-----
 .../fetch-strip-query/instrument.mjs          |  1 -
 .../fetch-strip-query/test.ts                 | 67 ++++++++++++-------
 .../http-strip-query/instrument.mjs           |  1 -
 .../http-strip-query/test.ts                  | 62 ++++++++++-------
 16 files changed, 155 insertions(+), 107 deletions(-)
 rename dev-packages/node-integration-tests/suites/tracing/{http-client-span-streamed => http-client-span}/instrument.mjs (91%)
 rename dev-packages/node-integration-tests/suites/tracing/{http-client-span-streamed => http-client-span}/scenario-fetch.mjs (100%)
 rename dev-packages/node-integration-tests/suites/tracing/{http-client-span-streamed => http-client-span}/test.ts (90%)

diff --git a/dev-packages/bun-integration-tests/node-suites/excludes.ts b/dev-packages/bun-integration-tests/node-suites/excludes.ts
index 427f5cc0c2cd..495ca29dec35 100644
--- a/dev-packages/bun-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/bun-integration-tests/node-suites/excludes.ts
@@ -39,7 +39,7 @@ const NO_HTTP_SERVER_SPANS = [
 // project runs these suites, except the ones in `SENTRY_BUN_EXCLUDE`.
 const NO_FETCH_INSTRUMENTATION = [
   'suites/tracing/double-baggage/**',
-  'suites/tracing/http-client-span-streamed/test.ts',
+  'suites/tracing/http-client-span/test.ts',
   'suites/tracing/http-client-spans/fetch-basic-streamed/test.ts',
   'suites/tracing/http-client-spans/fetch-basic/test.ts',
   'suites/tracing/http-client-spans/fetch-error/test.ts',
diff --git a/dev-packages/deno-integration-tests/node-suites/excludes.ts b/dev-packages/deno-integration-tests/node-suites/excludes.ts
index 36098da333df..e5ec281a7a52 100644
--- a/dev-packages/deno-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/deno-integration-tests/node-suites/excludes.ts
@@ -9,7 +9,7 @@ const NODE_ONLY = ['suites/anr/test.ts', 'suites/breadcrumbs/**', 'suites/thread
 // spans, breadcrumbs or headers of outgoing `fetch` requests.
 const NO_FETCH_INSTRUMENTATION = [
   'suites/tracing/double-baggage/**',
-  'suites/tracing/http-client-span-streamed/test.ts',
+  'suites/tracing/http-client-span/test.ts',
   'suites/tracing/http-client-spans/fetch-basic-streamed/test.ts',
   'suites/tracing/http-client-spans/fetch-basic/test.ts',
   'suites/tracing/http-client-spans/fetch-error/test.ts',
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-span-streamed/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/http-client-span/instrument.mjs
similarity index 91%
rename from dev-packages/node-integration-tests/suites/tracing/http-client-span-streamed/instrument.mjs
rename to dev-packages/node-integration-tests/suites/tracing/http-client-span/instrument.mjs
index b56505ef5e2d..3a69e61ceb90 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-span-streamed/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-span/instrument.mjs
@@ -6,6 +6,5 @@ Sentry.init({
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
   clientReportFlushInterval: 1_000,
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-span-streamed/scenario-fetch.mjs b/dev-packages/node-integration-tests/suites/tracing/http-client-span/scenario-fetch.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/http-client-span-streamed/scenario-fetch.mjs
rename to dev-packages/node-integration-tests/suites/tracing/http-client-span/scenario-fetch.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-span-streamed/test.ts b/dev-packages/node-integration-tests/suites/tracing/http-client-span/test.ts
similarity index 90%
rename from dev-packages/node-integration-tests/suites/tracing/http-client-span-streamed/test.ts
rename to dev-packages/node-integration-tests/suites/tracing/http-client-span/test.ts
index d5187a062b08..11e3e07fd557 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-span-streamed/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-span/test.ts
@@ -1,7 +1,7 @@
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
-describe('http.client span with streaming enabled', () => {
+describe('http.client span without a local parent', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
@@ -18,6 +18,7 @@ describe('http.client span with streaming enabled', () => {
             );
 
             expect(httpClientSpan).toBeDefined();
+            expect(httpClientSpan?.is_segment).toBe(true);
             // The URL path is high cardinality, so a streamed span name keeps only the domain.
             expect(httpClientSpan?.name).toBe('GET localhost');
             expect(httpClientSpan?.attributes['url.domain']?.value).toBe('localhost');
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-basic-streamed/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-basic-streamed/instrument.mjs
index b52ee5c5fdf1..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-basic-streamed/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-basic-streamed/instrument.mjs
@@ -5,6 +5,5 @@ Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
-  traceLifecycle: 'stream',
   transport: loggingTransport,
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-error/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-error/instrument.mjs
index 170ad6f6a702..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-error/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-error/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-error/test.ts b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-error/test.ts
index dcd890b1d766..27a9a0ba941e 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-error/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-error/test.ts
@@ -1,3 +1,5 @@
+import { HTTP_CLIENT } from '@sentry/conventions/op';
+import { SENTRY_OP, SENTRY_ORIGIN, URL_FULL } from '@sentry/conventions/attributes';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createCjsTests } from '../../../../utils/runner';
 
@@ -10,16 +12,21 @@ describe('outgoing fetch spans - error', () => {
     test('captures an errored span for a failed outgoing fetch request', async () => {
       await createRunner()
         .expect({
-          transaction: {
-            transaction: 'test_transaction',
-            spans: expect.arrayContaining([
-              expect.objectContaining({
-                description: expect.stringMatching(/GET http:\/\/localhost:\d+\//),
-                op: 'http.client',
-                origin: 'auto.http.node_fetch',
-                status: 'internal_error',
-              }),
-            ]),
+          span: container => {
+            expect(container.items.find(span => span.is_segment)?.name).toBe('test_transaction');
+            expect(container.items.filter(span => !span.is_segment)).toEqual(
+              expect.arrayContaining([
+                expect.objectContaining({
+                  name: 'GET localhost',
+                  status: 'error',
+                  attributes: expect.objectContaining({
+                    [URL_FULL]: { type: 'string', value: expect.stringMatching(/http:\/\/localhost:\d+\//) },
+                    [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+                    [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.node_fetch' },
+                  }),
+                }),
+              ]),
+            );
           },
         })
         .start()
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-forward-request-hook/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-forward-request-hook/instrument.mjs
index 04a31f91c150..8cb369af50dc 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-forward-request-hook/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-forward-request-hook/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-forward-request-hook/test.ts b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-forward-request-hook/test.ts
index 84c79873d8dd..9e533959e3e7 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-forward-request-hook/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-forward-request-hook/test.ts
@@ -1,3 +1,5 @@
+import { HTTP_CLIENT } from '@sentry/conventions/op';
+import { HTTP_RESPONSE_STATUS_CODE, SENTRY_OP, SENTRY_ORIGIN, URL_FULL } from '@sentry/conventions/attributes';
 import { createTestServer } from '@sentry-internal/test-utils';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createCjsTests } from '../../../../utils/runner';
@@ -9,7 +11,7 @@ describe('outgoing fetch spans - request/response hooks', () => {
 
   createCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     test('adds requestHook and responseHook attributes to spans of outgoing fetch requests', async () => {
-      expect.assertions(3);
+      expect.assertions(4);
 
       const [SERVER_URL, closeTestServer] = await createTestServer()
         .get('/api/v0', () => {
@@ -29,33 +31,35 @@ describe('outgoing fetch spans - request/response hooks', () => {
       await createRunner()
         .withEnv({ SERVER_URL })
         .expect({
-          transaction: {
-            transaction: 'test_transaction',
-            spans: [
+          span: container => {
+            expect(container.items.find(span => span.is_segment)?.name).toBe('test_transaction');
+            expect(container.items.filter(span => !span.is_segment)).toEqual([
               expect.objectContaining({
-                description: expect.stringMatching(/GET .*\/api\/v0/),
-                op: 'http.client',
-                origin: 'auto.http.node_fetch',
+                name: 'GET localhost',
                 status: 'ok',
-                data: expect.objectContaining({
-                  'sentry.request.hook': '/api/v0',
-                  'sentry.response.hook.path': '/api/v0',
-                  'sentry.response.hook.status_code': 200,
+                attributes: expect.objectContaining({
+                  [URL_FULL]: { type: 'string', value: expect.stringMatching(/.*\/api\/v0/) },
+                  [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+                  [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.node_fetch' },
+                  'sentry.request.hook': { type: 'string', value: '/api/v0' },
+                  'sentry.response.hook.path': { type: 'string', value: '/api/v0' },
+                  'sentry.response.hook.status_code': { type: 'integer', value: 200 },
                 }),
               }),
               expect.objectContaining({
-                description: expect.stringMatching(/GET .*\/api\/v1/),
-                op: 'http.client',
-                origin: 'auto.http.node_fetch',
-                status: 'not_found',
-                data: expect.objectContaining({
-                  'sentry.request.hook': '/api/v1',
-                  'sentry.response.hook.path': '/api/v1',
-                  'sentry.response.hook.status_code': 404,
-                  'http.response.status_code': 404,
+                name: 'GET localhost',
+                status: 'error',
+                attributes: expect.objectContaining({
+                  [URL_FULL]: { type: 'string', value: expect.stringMatching(/.*\/api\/v1/) },
+                  [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+                  [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.node_fetch' },
+                  'sentry.request.hook': { type: 'string', value: '/api/v1' },
+                  'sentry.response.hook.path': { type: 'string', value: '/api/v1' },
+                  'sentry.response.hook.status_code': { type: 'integer', value: 404 },
+                  [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 404 },
                 }),
               }),
-            ],
+            ]);
           },
         })
         .start()
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-headers-to-span-attributes/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-headers-to-span-attributes/instrument.mjs
index 11ff9c8eb451..cf8fec6e7e1d 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-headers-to-span-attributes/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-headers-to-span-attributes/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-headers-to-span-attributes/test.ts b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-headers-to-span-attributes/test.ts
index 6bfb18909525..d0bd81d8d5ea 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-headers-to-span-attributes/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-headers-to-span-attributes/test.ts
@@ -1,3 +1,10 @@
+import { HTTP_CLIENT } from '@sentry/conventions/op';
+import {
+  HTTP_RESPONSE_HEADER_CONTENT_LENGTH,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  URL_FULL,
+} from '@sentry/conventions/attributes';
 import { createTestServer } from '@sentry-internal/test-utils';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createCjsTests } from '../../../../utils/runner';
@@ -9,7 +16,7 @@ describe('outgoing fetch spans - headers to span attributes', () => {
 
   createCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     test('maps configured request & response headers to span attributes', async () => {
-      expect.assertions(2);
+      expect.assertions(3);
 
       const [SERVER_URL, closeTestServer] = await createTestServer()
         .get('/api/v0', headers => {
@@ -20,24 +27,27 @@ describe('outgoing fetch spans - headers to span attributes', () => {
       await createRunner()
         .withEnv({ SERVER_URL })
         .expect({
-          transaction: {
-            transaction: 'test_transaction',
-            spans: expect.arrayContaining([
-              expect.objectContaining({
-                description: expect.stringMatching(/GET .*\/api\/v0/),
-                op: 'http.client',
-                origin: 'auto.http.node_fetch',
-                data: expect.objectContaining({
-                  'http.request.header.x-test-header': ['test-value'],
-                  // Listed in `headersToSpanAttributes`, but the built-in denylist still wins.
-                  'http.request.header.authorization': ['[Filtered]'],
-                  // Listed in `headersToSpanAttributes`, but denied via `dataCollection.httpHeaders`.
-                  'http.request.header.x-tenant-id': ['[Filtered]'],
-                  'http.response.header.x-powered-by': ['Express'],
-                  'http.response.header.content-length': ['[Filtered]'],
+          span: container => {
+            expect(container.items.find(span => span.is_segment)?.name).toBe('test_transaction');
+            expect(container.items.filter(span => !span.is_segment)).toEqual(
+              expect.arrayContaining([
+                expect.objectContaining({
+                  name: 'GET localhost',
+                  attributes: expect.objectContaining({
+                    [URL_FULL]: { type: 'string', value: expect.stringMatching(/.*\/api\/v0/) },
+                    [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+                    [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.node_fetch' },
+                    'http.request.header.x-test-header': { type: 'array', value: ['test-value'] },
+                    // Listed in `headersToSpanAttributes`, but the built-in denylist still wins.
+                    'http.request.header.authorization': { type: 'array', value: ['[Filtered]'] },
+                    // Listed in `headersToSpanAttributes`, but denied via `dataCollection.httpHeaders`.
+                    'http.request.header.x-tenant-id': { type: 'array', value: ['[Filtered]'] },
+                    'http.response.header.x-powered-by': { type: 'array', value: ['Express'] },
+                    [HTTP_RESPONSE_HEADER_CONTENT_LENGTH]: { type: 'array', value: ['[Filtered]'] },
+                  }),
                 }),
-              }),
-            ]),
+              ]),
+            );
           },
         })
         .start()
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-strip-query/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-strip-query/instrument.mjs
index 170ad6f6a702..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-strip-query/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-strip-query/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-strip-query/test.ts b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-strip-query/test.ts
index 8d2a20e79d9e..99b485b76141 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-strip-query/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/fetch-strip-query/test.ts
@@ -1,3 +1,20 @@
+import { HTTP_CLIENT } from '@sentry/conventions/op';
+import {
+  HTTP_REQUEST_METHOD,
+  HTTP_RESPONSE_STATUS_CODE,
+  NETWORK_PEER_ADDRESS,
+  NETWORK_PEER_PORT,
+  SENTRY_KIND,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SERVER_ADDRESS,
+  SERVER_PORT,
+  URL_FULL,
+  URL_PATH,
+  URL_QUERY,
+  URL_SCHEME,
+  USER_AGENT_ORIGINAL,
+} from '@sentry/conventions/attributes';
 import { createTestServer } from '@sentry-internal/test-utils';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createCjsTests } from '../../../../utils/runner';
@@ -21,34 +38,34 @@ describe('outgoing fetch spans - strip query', () => {
       await createRunner()
         .withEnv({ SERVER_URL })
         .expect({
-          transaction: txn => {
-            expect(txn.transaction).toEqual('test_transaction');
-            expect(txn.spans).toHaveLength(1);
-            expect(txn.spans?.[0]).toMatchObject({
-              data: {
-                'url.full': `${SERVER_URL}/api/v0/users?id=1`,
-                'url.path': '/api/v0/users',
-                'url.query': 'id=1',
-                'url.scheme': 'http',
-                'http.request.method': 'GET',
-                'http.request.method_original': 'GET',
-                'http.response.status_code': 200,
-                'network.peer.address': '::1',
-                'network.peer.port': expect.any(Number),
-                'sentry.kind': 'client',
-                'server.port': expect.any(Number),
-                'user_agent.original': 'node',
-                'sentry.op': 'http.client',
-                'sentry.origin': 'auto.http.node_fetch',
-                'server.address': 'localhost',
+          span: container => {
+            const segment = container.items.find(span => span.is_segment);
+            const spans = container.items.filter(span => !span.is_segment);
+            expect(segment?.name).toEqual('test_transaction');
+            expect(spans).toHaveLength(1);
+            expect(spans[0]).toMatchObject({
+              attributes: {
+                [URL_FULL]: { type: 'string', value: `${SERVER_URL}/api/v0/users?id=1` },
+                [URL_PATH]: { type: 'string', value: '/api/v0/users' },
+                [URL_QUERY]: { type: 'string', value: 'id=1' },
+                [URL_SCHEME]: { type: 'string', value: 'http' },
+                [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+                'http.request.method_original': { type: 'string', value: 'GET' },
+                [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                [NETWORK_PEER_ADDRESS]: { type: 'string', value: '::1' },
+                [NETWORK_PEER_PORT]: { type: 'integer', value: expect.any(Number) },
+                [SENTRY_KIND]: { type: 'string', value: 'client' },
+                [SERVER_PORT]: { type: 'integer', value: expect.any(Number) },
+                [USER_AGENT_ORIGINAL]: { type: 'string', value: 'node' },
+                [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+                [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.node_fetch' },
+                [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
               },
-              description: `GET ${SERVER_URL}/api/v0/users`,
-              op: 'http.client',
-              origin: 'auto.http.node_fetch',
+              name: 'GET localhost',
               status: 'ok',
-              parent_span_id: txn.contexts?.trace?.span_id,
+              parent_span_id: segment?.span_id,
               span_id: expect.stringMatching(/[a-f\d]{16}/),
-              trace_id: txn.contexts?.trace?.trace_id,
+              trace_id: segment?.trace_id,
             });
           },
         })
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/instrument.mjs
index 170ad6f6a702..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/test.ts b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/test.ts
index 115b2517e81f..e018a905ba28 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/test.ts
@@ -1,3 +1,19 @@
+import { HTTP_CLIENT } from '@sentry/conventions/op';
+import {
+  HTTP_REQUEST_METHOD,
+  HTTP_RESPONSE_BODY_SIZE,
+  HTTP_RESPONSE_STATUS_CODE,
+  HTTP_RESPONSE_STATUS_TEXT,
+  NETWORK_PEER_ADDRESS,
+  NETWORK_PEER_PORT,
+  NETWORK_TRANSPORT,
+  SENTRY_KIND,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SERVER_ADDRESS,
+  URL_FULL,
+  URL_QUERY,
+} from '@sentry/conventions/attributes';
 import { createTestServer } from '@sentry-internal/test-utils';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createCjsTests } from '../../../../utils/runner';
@@ -21,32 +37,32 @@ describe('outgoing http spans - strip query', () => {
       await createRunner()
         .withEnv({ SERVER_URL })
         .expect({
-          transaction: txn => {
-            expect(txn.transaction).toEqual('test_transaction');
-            expect(txn.spans).toHaveLength(1);
-            expect(txn.spans?.[0]).toMatchObject({
-              data: {
-                'url.full': `${SERVER_URL}/api/v0/users?id=1`,
-                'http.request.method': 'GET',
-                'url.query': 'id=1',
-                'http.response.status_code': 200,
-                'http.response.body.size': 0,
-                'http.response.status_text': 'OK',
-                'network.peer.address': '::1',
-                'server.address': 'localhost',
-                'network.peer.port': expect.any(Number),
-                'network.transport': 'tcp',
-                'sentry.kind': 'client',
-                'sentry.op': 'http.client',
-                'sentry.origin': 'auto.http.client',
+          span: container => {
+            const segment = container.items.find(span => span.is_segment);
+            const spans = container.items.filter(span => !span.is_segment);
+            expect(segment?.name).toEqual('test_transaction');
+            expect(spans).toHaveLength(1);
+            expect(spans[0]).toMatchObject({
+              attributes: {
+                [URL_FULL]: { type: 'string', value: `${SERVER_URL}/api/v0/users?id=1` },
+                [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+                [URL_QUERY]: { type: 'string', value: 'id=1' },
+                [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+                [HTTP_RESPONSE_BODY_SIZE]: { type: 'integer', value: 0 },
+                [HTTP_RESPONSE_STATUS_TEXT]: { type: 'string', value: 'OK' },
+                [NETWORK_PEER_ADDRESS]: { type: 'string', value: '::1' },
+                [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+                [NETWORK_PEER_PORT]: { type: 'integer', value: expect.any(Number) },
+                [NETWORK_TRANSPORT]: { type: 'string', value: 'tcp' },
+                [SENTRY_KIND]: { type: 'string', value: 'client' },
+                [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+                [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.client' },
               },
-              description: `GET ${SERVER_URL}/api/v0/users`,
-              op: 'http.client',
-              origin: 'auto.http.client',
+              name: 'GET localhost',
               status: 'ok',
-              parent_span_id: txn.contexts?.trace?.span_id,
+              parent_span_id: segment?.span_id,
               span_id: expect.stringMatching(/[a-f\d]{16}/),
-              trace_id: txn.contexts?.trace?.trace_id,
+              trace_id: segment?.trace_id,
             });
           },
         })

From ee6df73b4a100167bbfc7e45ddd23339b59ed9f4 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 11:41:21 +0200
Subject: [PATCH 14/84] test(node): Port HTTP request suites to span streaming
 (#25191)

Run the HTTP request suites with the default span-streaming lifecycle.

Part of #24135

---------

Co-authored-by: GPT-6 <codex@openai.com>
Co-authored-by: Lukas Stracke <lukas.stracke@sentry.io>
---
 .../requests/http-breadcrumbs/instrument.mjs       |  1 -
 .../requests/http-maxed-out-sockets/instrument.mjs |  1 -
 .../requests/http-maxed-out-sockets/test.ts        |  4 ++--
 .../http-no-trace-propagation/instrument.mjs       |  1 -
 .../http-no-tracing-no-spans/instrument.mjs        |  1 -
 .../requests/http-no-tracing/instrument.mjs        |  1 -
 .../http-sampled-no-active-span/instrument.mjs     |  1 -
 .../tracing/requests/http-sampled/instrument.mjs   |  1 -
 .../suites/tracing/requests/http-sampled/test.ts   |  4 ++--
 .../tracing/requests/http-unsampled/instrument.mjs |  1 -
 .../tracing/requests/traceparent/instrument.mjs    |  1 -
 .../suites/tracing/requests/traceparent/test.ts    | 14 ++++++++------
 12 files changed, 12 insertions(+), 19 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-breadcrumbs/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/http-breadcrumbs/instrument.mjs
index 3e95fc68c6bc..dfe7b95bfeb7 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-breadcrumbs/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-breadcrumbs/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracePropagationTargets: [/\/v0/, 'v1'],
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/instrument.mjs
index 170ad6f6a702..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/test.ts
index 0dbe7867110f..1f3f507c699f 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/test.ts
@@ -21,8 +21,8 @@ describe('outgoing http with maxed-out agent sockets', () => {
       await createRunner()
         .withEnv({ SERVER_URL })
         .expect({
-          transaction: {
-            // we're not too concerned with the actual transaction here since this is tested elsewhere
+          span: {
+            // Span contents are tested elsewhere.
           },
         })
         .start()
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-trace-propagation/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-trace-propagation/instrument.mjs
index 8d1cf5e660fb..3eacba8fd6c8 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-trace-propagation/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-trace-propagation/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   integrations: [Sentry.httpIntegration({ tracePropagation: false, spans: false })],
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing-no-spans/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing-no-spans/instrument.mjs
index 5a2c1a2ab1fd..9f713557b30a 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing-no-spans/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing-no-spans/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracePropagationTargets: [/\/v0/, 'v1'],
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing/instrument.mjs
index 3e95fc68c6bc..dfe7b95bfeb7 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracePropagationTargets: [/\/v0/, 'v1'],
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/instrument.mjs
index 459b690e0801..518e3f83de83 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/instrument.mjs
index 459b690e0801..518e3f83de83 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts
index ebd6198bfd4e..fe3621236b80 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts
@@ -31,8 +31,8 @@ describe('outgoing http', () => {
       await createRunner()
         .withEnv({ SERVER_URL })
         .expect({
-          transaction: {
-            // we're not too concerned with the actual transaction here since this is tested elsewhere
+          span: {
+            // Span contents are tested elsewhere, we just want to know that a span envelope was sent
           },
         })
         .start()
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/instrument.mjs
index 0aa2b791f9cd..9063352bc6d9 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracePropagationTargets: [/\/v0/, 'v1'],
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/instrument.mjs
index dbbe03ce5e0c..886377ef59e7 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1,
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts
index 1367c3ed3a07..32c7204baeb2 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts
@@ -1,3 +1,5 @@
+import { SENTRY_OP } from '@sentry/conventions/attributes';
+import { HTTP_CLIENT } from '@sentry/conventions/op';
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { RUNTIME } from '../../../../utils';
@@ -23,14 +25,14 @@ describe('outgoing traceparent', () => {
       await createRunner()
         .withEnv({ SERVER_URL })
         .expect({
-          // The propagated `sentry-trace` must reference the `http.client` span, not the surrounding transaction span.
-          transaction: event => {
+          // The propagated `sentry-trace` must reference the `http.client` span, not the surrounding segment span.
+          span: container => {
             const propagatedSpanId = outgoingSentryTrace?.split('-')[1];
-            const httpClientSpan = event.spans?.find(span => span.op === 'http.client');
+            const httpClientSpan = container.items.find(span => span.attributes[SENTRY_OP]?.value === HTTP_CLIENT);
 
             expect(httpClientSpan).toBeDefined();
             expect(propagatedSpanId).toBe(httpClientSpan?.span_id);
-            expect(propagatedSpanId).not.toBe(event.contexts?.trace?.span_id);
+            expect(propagatedSpanId).not.toBe(container.items.find(span => span.is_segment)?.span_id);
           },
         })
         .start()
@@ -57,8 +59,8 @@ describe('outgoing traceparent', () => {
       await createRunner()
         .withEnv({ SERVER_URL })
         .expect({
-          transaction: {
-            // we're not too concerned with the actual transaction here since this is tested elsewhere
+          span: {
+            // Span contents are tested elsewhere.
           },
         })
         .start()

From 861710dea2c580a65eff03879f06457f34335be9 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 11:41:39 +0200
Subject: [PATCH 15/84] test(node): Port fetch request suites to span streaming
 (#25189)

Run the fetch request suites with the default span-streaming lifecycle.

Part of #24135

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../requests/fetch-breadcrumbs/instrument.mjs |  1 -
 .../fetch-no-trace-propagation/instrument.mjs |  1 -
 .../fetch-no-tracing-no-spans/instrument.mjs  |  1 -
 .../requests/fetch-no-tracing/instrument.mjs  |  1 -
 .../instrument.mjs                            |  1 -
 .../fetch-sampled-no-active-span/test.ts      | 30 +++++++++++++++----
 .../requests/fetch-unsampled/instrument.mjs   |  1 -
 7 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-breadcrumbs/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-breadcrumbs/instrument.mjs
index de0f2b480962..76fc52f6a863 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-breadcrumbs/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-breadcrumbs/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracePropagationTargets: [/\/v0/, 'v1'],
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-trace-propagation/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-trace-propagation/instrument.mjs
index c5aa203f5359..1330c5c2baed 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-trace-propagation/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-trace-propagation/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   integrations: [Sentry.nativeNodeFetchIntegration({ tracePropagation: false })],
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing-no-spans/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing-no-spans/instrument.mjs
index 50d1d8e5c30d..c3c5e4fdb3de 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing-no-spans/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing-no-spans/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracePropagationTargets: [/\/v0/, 'v1'],
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing/instrument.mjs
index da94a1c511b3..0a2184dacd2e 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-no-tracing/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracePropagationTargets: [/\/v0/, 'v1'],
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/instrument.mjs
index 1a3c6c3e401f..99792f59545a 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracePropagationTargets: [/\/v0/, 'v1'],
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/test.ts
index cd7f91dd97f2..ec155b8c5c38 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/test.ts
@@ -1,3 +1,5 @@
+import { SENTRY_OP, URL_FULL } from '@sentry/conventions/attributes';
+import { HTTP_CLIENT } from '@sentry/conventions/op';
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
@@ -5,18 +7,18 @@ import { createEsmAndCjsTests } from '../../../../utils/runner';
 describe('outgoing fetch', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     test('outgoing sampled fetch requests without active span are correctly instrumented', async () => {
-      expect.assertions(11);
+      expect.assertions(21);
 
       const [SERVER_URL, closeTestServer] = await createTestServer()
         .get('/api/v0', headers => {
           expect(headers['baggage']).toEqual(expect.any(String));
-          expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-0$/));
-          expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+          expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/));
+          expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
         })
         .get('/api/v1', headers => {
           expect(headers['baggage']).toEqual(expect.any(String));
-          expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-0$/));
-          expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+          expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/));
+          expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
         })
         .get('/api/v2', headers => {
           expect(headers['baggage']).toBeUndefined();
@@ -30,6 +32,7 @@ describe('outgoing fetch', () => {
 
       await createRunner()
         .withEnv({ SERVER_URL })
+        .unordered()
         .expect({
           event: {
             exception: {
@@ -42,6 +45,23 @@ describe('outgoing fetch', () => {
             },
           },
         })
+        .expect({
+          span: container => {
+            const spans = container.items;
+            expect(spans).toHaveLength(4);
+            expect(spans.map(span => span.attributes[URL_FULL]?.value).sort()).toEqual([
+              `${SERVER_URL}/api/v0`,
+              `${SERVER_URL}/api/v1`,
+              `${SERVER_URL}/api/v2`,
+              `${SERVER_URL}/api/v3`,
+            ]);
+
+            for (const span of spans) {
+              expect(span.attributes[SENTRY_OP]?.value).toBe(HTTP_CLIENT);
+              expect(span.is_segment).toBe(true);
+            }
+          },
+        })
         .start()
         .completed();
       closeTestServer();
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/instrument.mjs
index 0aa2b791f9cd..9063352bc6d9 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/fetch-unsampled/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracePropagationTargets: [/\/v0/, 'v1'],

From 148960a0e3c33f48723e0d45dffb7e2b41f5c2ec Mon Sep 17 00:00:00 2001
From: "javascript-sdk-gitflow[bot]"
 <255134079+javascript-sdk-gitflow[bot]@users.noreply.github.com>
Date: Fri, 9 Oct 2026 11:56:48 +0200
Subject: [PATCH 16/84] chore(size-limit): weekly auto-bump (#25213)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Size limit auto-bump

| Entry | Old limit | New limit | Δ |
| --- | --- | --- | --- |
| @sentry/browser (incl. Tracing, Replay with Canvas) | 101 KB | 102 KB
| +1 KB |
| @sentry/browser (incl. Tracing, Replay, Feedback) | 114 KB | 115 KB |
+1 KB |
| @sentry/browser (incl. Logs) | 36 KB | 37 KB | +1 KB |
| @sentry/react (incl. Tracing) | 59 KB | 60 KB | +1 KB |
| @sentry/remix (Remix 3 client bundle) | 61 KB | 62 KB | +1 KB |
| CDN Bundle (incl. Tracing) | 57 KB | 58 KB | +1 KB |
| CDN Bundle (incl. Tracing, Logs, Metrics) | 59 KB | 60 KB | +1 KB |
| CDN Bundle (incl. Tracing, Replay) | 95 KB | 96 KB | +1 KB |
| CDN Bundle (incl. Tracing, Replay, Feedback) | 101 KB | 102 KB | +1 KB
|
| CDN Bundle (incl. Tracing, Replay, Feedback, Logs, Metrics) | 103 KB |
104 KB | +1 KB |
| CDN Bundle (incl. Tracing) - uncompressed | 160 KB | 161 KB | +1 KB |
| CDN Bundle (incl. Logs, Metrics) - uncompressed | 104 KB | 105 KB | +1
KB |
| CDN Bundle (incl. Tracing, Logs, Metrics) - uncompressed | 166 KB |
167 KB | +1 KB |
| CDN Bundle (incl. Replay, Logs, Metrics) - uncompressed | 234 KB | 235
KB | +1 KB |
| CDN Bundle (incl. Tracing, Replay) - uncompressed | 280 KB | 281 KB |
+1 KB |
| CDN Bundle (incl. Tracing, Replay, Logs, Metrics) - uncompressed | 286
KB | 287 KB | +1 KB |
| CDN Bundle (incl. Tracing, Replay, Feedback) - uncompressed | 293 KB |
295 KB | +2 KB |
| CDN Bundle (incl. Tracing, Replay, Feedback, Logs, Metrics) -
uncompressed | 299 KB | 301 KB | +2 KB |
| @sentry/sveltekit (client) | 57 KB | 58 KB | +1 KB |
| @sentry/node | 151 KB | 156 KB | +5 KB |
| @sentry/node - without tracing | 99 KB | 100 KB | +1 KB |
| @sentry/node - without channel injection | 130 KB | 135 KB | +5 KB |
| @sentry/aws-serverless | 107 KB | 108 KB | +1 KB |
| @sentry/cloudflare (withSentry) - minified | 209 KiB | 210 KiB | +1
KiB |
| @sentry/cloudflare (withSentry) | 512 KiB | 514 KiB | +2 KiB |
| @sentry/nextjs/cloudflare (withSentry) - minified | 223 KiB | 228 KiB
| +5 KiB |

Co-authored-by: chargome <20254395+chargome@users.noreply.github.com>
---
 .size-limit.js | 52 +++++++++++++++++++++++++-------------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/.size-limit.js b/.size-limit.js
index 6e085d4f6e52..b276522b06e3 100644
--- a/.size-limit.js
+++ b/.size-limit.js
@@ -121,7 +121,7 @@ module.exports = [
     path: 'packages/browser/build/npm/esm/prod/index.js',
     import: createImport('init', 'browserTracingIntegration', 'replayIntegration', 'replayCanvasIntegration'),
     gzip: true,
-    limit: '101 KB',
+    limit: '102 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -129,7 +129,7 @@ module.exports = [
     path: 'packages/browser/build/npm/esm/prod/index.js',
     import: createImport('init', 'browserTracingIntegration', 'replayIntegration', 'feedbackIntegration'),
     gzip: true,
-    limit: '114 KB',
+    limit: '115 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -169,7 +169,7 @@ module.exports = [
     path: 'packages/browser/build/npm/esm/prod/index.js',
     import: createImport('init', 'logger'),
     gzip: true,
-    limit: '36 KB',
+    limit: '37 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -196,7 +196,7 @@ module.exports = [
     import: createImport('init', 'ErrorBoundary', 'reactRouterV6BrowserTracingIntegration'),
     ignore: ['react/jsx-runtime'],
     gzip: true,
-    limit: '59 KB',
+    limit: '60 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   // Vue SDK (ESM)
@@ -235,7 +235,7 @@ module.exports = [
     path: 'packages/remix/build/esm/v3/client-bundle.js',
     import: '*',
     gzip: true,
-    limit: '61 KB',
+    limit: '62 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   // Browser CDN bundles
@@ -250,7 +250,7 @@ module.exports = [
     name: 'CDN Bundle (incl. Tracing)',
     path: createCDNPath('bundle.tracing.min.js'),
     gzip: true,
-    limit: '57 KB',
+    limit: '58 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -264,7 +264,7 @@ module.exports = [
     name: 'CDN Bundle (incl. Tracing, Logs, Metrics)',
     path: createCDNPath('bundle.tracing.logs.metrics.min.js'),
     gzip: true,
-    limit: '59 KB',
+    limit: '60 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -278,7 +278,7 @@ module.exports = [
     name: 'CDN Bundle (incl. Tracing, Replay)',
     path: createCDNPath('bundle.tracing.replay.min.js'),
     gzip: true,
-    limit: '95 KB',
+    limit: '96 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -292,14 +292,14 @@ module.exports = [
     name: 'CDN Bundle (incl. Tracing, Replay, Feedback)',
     path: createCDNPath('bundle.tracing.replay.feedback.min.js'),
     gzip: true,
-    limit: '101 KB',
+    limit: '102 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
     name: 'CDN Bundle (incl. Tracing, Replay, Feedback, Logs, Metrics)',
     path: createCDNPath('bundle.tracing.replay.feedback.logs.metrics.min.js'),
     gzip: true,
-    limit: '103 KB',
+    limit: '104 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   // browser CDN bundles (non-gzipped)
@@ -316,7 +316,7 @@ module.exports = [
     path: createCDNPath('bundle.tracing.min.js'),
     gzip: false,
     brotli: false,
-    limit: '160 KB',
+    limit: '161 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -324,7 +324,7 @@ module.exports = [
     path: createCDNPath('bundle.logs.metrics.min.js'),
     gzip: false,
     brotli: false,
-    limit: '104 KB',
+    limit: '105 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -332,7 +332,7 @@ module.exports = [
     path: createCDNPath('bundle.tracing.logs.metrics.min.js'),
     gzip: false,
     brotli: false,
-    limit: '166 KB',
+    limit: '167 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -340,7 +340,7 @@ module.exports = [
     path: createCDNPath('bundle.replay.logs.metrics.min.js'),
     gzip: false,
     brotli: false,
-    limit: '234 KB',
+    limit: '235 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -348,7 +348,7 @@ module.exports = [
     path: createCDNPath('bundle.tracing.replay.min.js'),
     gzip: false,
     brotli: false,
-    limit: '280 KB',
+    limit: '281 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -356,7 +356,7 @@ module.exports = [
     path: createCDNPath('bundle.tracing.replay.logs.metrics.min.js'),
     gzip: false,
     brotli: false,
-    limit: '286 KB',
+    limit: '287 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -364,7 +364,7 @@ module.exports = [
     path: createCDNPath('bundle.tracing.replay.feedback.min.js'),
     gzip: false,
     brotli: false,
-    limit: '293 KB',
+    limit: '295 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -372,7 +372,7 @@ module.exports = [
     path: createCDNPath('bundle.tracing.replay.feedback.logs.metrics.min.js'),
     gzip: false,
     brotli: false,
-    limit: '299 KB',
+    limit: '301 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   // Next.js SDK (ESM)
@@ -392,7 +392,7 @@ module.exports = [
     import: createImport('init'),
     ignore: ['$app/stores'],
     gzip: true,
-    limit: '57 KB',
+    limit: '58 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   // Core SDK subpath entry points (ESM)
@@ -419,7 +419,7 @@ module.exports = [
     import: createImport('init'),
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     gzip: true,
-    limit: '151 KB',
+    limit: '156 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -443,7 +443,7 @@ module.exports = [
     path: 'packages/node/build/esm/index.js',
     import: createImport('initWithoutDefaultIntegrations', 'getDefaultIntegrationsWithoutPerformance'),
     gzip: true,
-    limit: '99 KB',
+    limit: '100 KB',
     disablePlugins: ['@size-limit/esbuild'],
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     modifyWebpackConfig: function (config) {
@@ -465,7 +465,7 @@ module.exports = [
     path: 'packages/node/build/esm/index.js',
     import: createImport('init'),
     gzip: true,
-    limit: '130 KB',
+    limit: '135 KB',
     disablePlugins: ['@size-limit/esbuild'],
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     modifyWebpackConfig: function (config) {
@@ -486,7 +486,7 @@ module.exports = [
     import: createImport('init'),
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     gzip: true,
-    limit: '107 KB',
+    limit: '108 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   // Cloudflare SDK (ESM) - compressed, minified to match `wrangler deploy --dry-run --minify` output
@@ -497,7 +497,7 @@ module.exports = [
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     gzip: false,
     brotli: false,
-    limit: '209 KiB',
+    limit: '210 KiB',
     disablePlugins: ['@size-limit/webpack'],
     webpack: false,
     modifyEsbuildConfig: function (config) {
@@ -517,7 +517,7 @@ module.exports = [
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     gzip: false,
     brotli: false,
-    limit: '512 KiB',
+    limit: '514 KiB',
     disablePlugins: ['@size-limit/webpack'],
     webpack: false,
     modifyEsbuildConfig: function (config) {
@@ -542,7 +542,7 @@ module.exports = [
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     gzip: false,
     brotli: false,
-    limit: '223 KiB',
+    limit: '228 KiB',
     disablePlugins: ['@size-limit/webpack'],
     webpack: false,
     modifyEsbuildConfig: function (config) {

From cb34995af083147991d37712d162b8c1674b8c4b Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 12:15:31 +0200
Subject: [PATCH 17/84] test(node): Run sampling propagation tests with default
 streaming (#25221)

Run sample-rate and sample-rand propagation scenarios with the default
streaming lifecycle.

Part of #24140

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../suites/tracing/sample-rand-propagation/server.js             | 1 -
 .../tracing/sample-rate-propagation/no-tracing-enabled/server.js | 1 -
 .../tracing/sample-rate-propagation/tracesSampleRate-0/server.js | 1 -
 .../tracing/sample-rate-propagation/tracesSampleRate/server.js   | 1 -
 .../tracing/sample-rate-propagation/tracesSampler/server.js      | 1 -
 5 files changed, 5 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/tracing/sample-rand-propagation/server.js b/dev-packages/node-integration-tests/suites/tracing/sample-rand-propagation/server.js
index 26699a3d642d..9203829df912 100644
--- a/dev-packages/node-integration-tests/suites/tracing/sample-rand-propagation/server.js
+++ b/dev-packages/node-integration-tests/suites/tracing/sample-rand-propagation/server.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   transport: loggingTransport,
   tracesSampleRate: 0.00000001, // It's important that this is not 1, so that we also check logic for NonRecordingSpans, which is usually the edge-case
diff --git a/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/no-tracing-enabled/server.js b/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/no-tracing-enabled/server.js
index 828606a12514..683b646104f4 100644
--- a/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/no-tracing-enabled/server.js
+++ b/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/no-tracing-enabled/server.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   transport: loggingTransport,
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampleRate-0/server.js b/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampleRate-0/server.js
index 453a43dd48f5..c94638c4491b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampleRate-0/server.js
+++ b/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampleRate-0/server.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   transport: loggingTransport,
   tracesSampleRate: 0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampleRate/server.js b/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampleRate/server.js
index 54a61482e577..96f9b84e4ffd 100644
--- a/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampleRate/server.js
+++ b/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampleRate/server.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   transport: loggingTransport,
   tracesSampleRate: 0.69,
diff --git a/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampler/server.js b/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampler/server.js
index e7c89eda341b..f057a870d0df 100644
--- a/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampler/server.js
+++ b/dev-packages/node-integration-tests/suites/tracing/sample-rate-propagation/tracesSampler/server.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   transport: loggingTransport,
   tracesSampler: ({ inheritOrSampleWith }) => {

From e144978ba8f5e175096cdb3a290df4625bf63129 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Fri, 9 Oct 2026 12:17:34 +0200
Subject: [PATCH 18/84] test(core): Fix flaky span end timestamp test (#25211)

Since #24903 a span's end time is its start time plus the
`performance.now()` duration, which can differ from a
`timestampInSeconds()` value taken mid-span by fractions of a
microsecond in either direction. Basically because a double can't
reliably hold the very minimal time difference here. This PR relaxes the
test assertion a bit while still asserting that the span ended at the
current time.

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 packages/core/test/lib/tracing/sentrySpan.test.ts | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/packages/core/test/lib/tracing/sentrySpan.test.ts b/packages/core/test/lib/tracing/sentrySpan.test.ts
index 521d30b63ae8..15ebe588d4c1 100644
--- a/packages/core/test/lib/tracing/sentrySpan.test.ts
+++ b/packages/core/test/lib/tracing/sentrySpan.test.ts
@@ -12,7 +12,13 @@ import { markSpanAsTracerProviderSpan } from '../../../src/tracing/utils';
 import { withStaticSpan } from '../../../src/tracing/spans/beforeSendSpan';
 import type { Envelope } from '../../../src/types/envelope';
 import type { Span, SpanJSON } from '../../../src/types/span';
-import { getRootSpan, spanToStaticSpanJSON, TRACE_FLAG_NONE, TRACE_FLAG_SAMPLED } from '../../../src/utils/spanUtils';
+import {
+  getRootSpan,
+  spanToJSON,
+  spanToStaticSpanJSON,
+  TRACE_FLAG_NONE,
+  TRACE_FLAG_SAMPLED,
+} from '../../../src/utils/spanUtils';
 import { timestampInSeconds } from '../../../src/utils/time';
 import { getDefaultTestClientOptions, TestClient } from '../../mocks/client';
 import { SENTRY_SEGMENT_NAME_SOURCE } from '@sentry/conventions/attributes';
@@ -588,7 +594,9 @@ describe('SentrySpan', () => {
       const now = timestampInSeconds();
       span.end();
 
-      expect(spanToStaticSpanJSON(span).timestamp).toBeGreaterThanOrEqual(now);
+      const { start_timestamp, end_timestamp } = spanToJSON(span);
+      expect(end_timestamp).toBeGreaterThanOrEqual(start_timestamp);
+      expect(end_timestamp).toBeCloseTo(now, 2);
     });
 
     it('works with endTimestamp in seconds', () => {

From 9ef8a0ec61cc08e76909ce4a5e973b89cc565ec7 Mon Sep 17 00:00:00 2001
From: Charly Gomez <charly.gomez1310@gmail.com>
Date: Fri, 9 Oct 2026 12:41:00 +0200
Subject: [PATCH 19/84] ref(server-utils): Export the pg query span helpers
 (#25163)

Exports the pg query-channel binding, the connection attribute builder
and `PgConnectionParams` so a driver that bundles its own copy of pg can
emit the same span shape. The Neon integration in #25164 is the first
consumer.

The deprecated `db.connection_string` attribute moves behind an opt-in.
Only the pg integration sets it, for parity with its OTel predecessor,
so new callers describe the connection with `server.address` and
`server.port` alone. No behavior change for pg.

Refs #25144

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../server-utils/src/integrations/postgres.ts | 41 ++++++++++++++-----
 1 file changed, 31 insertions(+), 10 deletions(-)

diff --git a/packages/server-utils/src/integrations/postgres.ts b/packages/server-utils/src/integrations/postgres.ts
index c1a2980943db..9dc4e62bf01e 100644
--- a/packages/server-utils/src/integrations/postgres.ts
+++ b/packages/server-utils/src/integrations/postgres.ts
@@ -65,7 +65,7 @@ interface PgChannelContext extends OrchestrionChannelContext {
   _sentryCallerScope?: Scope;
 }
 
-interface PgConnectionParams {
+export interface PgConnectionParams {
   database?: string;
   host?: string;
   port?: number;
@@ -92,9 +92,7 @@ const _postgresIntegration = ((options: { ignoreConnectSpans?: boolean } = {}) =
 }) satisfies IntegrationFn;
 
 function instrumentPostgres(options: { ignoreConnectSpans?: boolean }): void {
-  // Query spans: `pg`/native `Client.prototype.query`. Only this channel can return a streamable
-  // `Submittable` result, so it's the only one that defers span-ending to the emitter (see below).
-  subscribeQueryLikeChannel(CHANNELS.PG_QUERY, querySpanOptions, { deferStreamedResult: true });
+  bindPgQueryChannel(CHANNELS.PG_QUERY, { origin: ORIGIN, connectionString: true });
 
   // Connect spans, gated by `ignoreConnectSpans` (same as OTel pg).
   // `Client.prototype.connect` (pg + native)
@@ -105,6 +103,22 @@ function instrumentPostgres(options: { ignoreConnectSpans?: boolean }): void {
   }
 }
 
+export interface PgQuerySpanOptions {
+  origin: string;
+  // `db.connection_string` is deprecated in favor of `server.address`/`server.port`. Only the pg
+  // integration keeps emitting it, for parity with its OTel predecessor.
+  connectionString?: boolean;
+}
+
+/**
+ * Query spans for a channel carrying `pg` `Client.prototype.query` calls, from `pg` itself or from
+ * a copy bundled into another driver (`@neondatabase/serverless`). Only this call can return a
+ * streamable `Submittable` result, so it's the only one that defers span-ending to the emitter.
+ */
+export function bindPgQueryChannel(channelName: string, options: PgQuerySpanOptions): void {
+  subscribeQueryLikeChannel(channelName, ctx => querySpanOptions(ctx, options), { deferStreamedResult: true });
+}
+
 /**
  * Subscribe to a pg tracing-channel and manage a span across its lifecycle.
  * Shared by the query/connect/pool-connect channels. They differ only in how
@@ -172,7 +186,10 @@ function subscribeQueryLikeChannel(
   );
 }
 
-function querySpanOptions(ctx: PgChannelContext): { name: string; attributes: SpanAttributes } {
+function querySpanOptions(
+  ctx: PgChannelContext,
+  { origin, connectionString }: PgQuerySpanOptions,
+): { name: string; attributes: SpanAttributes } {
   const params = (ctx.self as { connectionParameters?: PgConnectionParams } | undefined)?.connectionParameters ?? {};
   const queryConfig = extractQueryConfig(ctx.arguments);
   const client = getClient();
@@ -186,8 +203,8 @@ function querySpanOptions(ctx: PgChannelContext): { name: string; attributes: Sp
     name,
     attributes: {
       [SENTRY_OP]: DB,
-      ...getConnectionAttributes(params),
-      [SENTRY_ORIGIN]: ORIGIN,
+      ...(connectionString ? getPgConnectionAttributes(params) : getConnectionAttributes(params)),
+      [SENTRY_ORIGIN]: origin,
       [DB_QUERY_TEXT]: queryText || undefined,
       [DB_QUERY_SUMMARY]: querySummary,
       [ATTR_PG_PLAN]: typeof queryConfig?.name === 'string' ? queryConfig.name : undefined,
@@ -198,7 +215,7 @@ function querySpanOptions(ctx: PgChannelContext): { name: string; attributes: Sp
 function connectSpanOptions(ctx: PgChannelContext): { name: string; attributes: SpanAttributes } {
   const params = (ctx.self as { connectionParameters?: PgConnectionParams } | undefined)?.connectionParameters ?? {};
   // No origin set -> defaults to 'manual'
-  return { name: SPAN_CONNECT, attributes: { [SENTRY_OP]: DB, ...getConnectionAttributes(params) } };
+  return { name: SPAN_CONNECT, attributes: { [SENTRY_OP]: DB, ...getPgConnectionAttributes(params) } };
 }
 
 function poolConnectSpanOptions(ctx: PgChannelContext): { name: string; attributes: SpanAttributes } {
@@ -225,10 +242,10 @@ function extractQueryConfig(args: unknown[]): { text: string; name?: unknown } |
   return undefined;
 }
 
-function getConnectionAttributes(params: PgConnectionParams): SpanAttributes {
+/** The `db.*`/`server.*` attributes for a pg-style set of connection parameters. */
+export function getConnectionAttributes(params: PgConnectionParams): SpanAttributes {
   return {
     [DB_SYSTEM_NAME]: DB_SYSTEM_POSTGRESQL,
-    [ATTR_DB_CONNECTION_STRING]: getConnectionString(params),
     [DB_NAMESPACE]: params.database,
     [DB_USER]: params.user,
     [SERVER_ADDRESS]: params.host,
@@ -236,6 +253,10 @@ function getConnectionAttributes(params: PgConnectionParams): SpanAttributes {
   };
 }
 
+function getPgConnectionAttributes(params: PgConnectionParams): SpanAttributes {
+  return { ...getConnectionAttributes(params), [ATTR_DB_CONNECTION_STRING]: getConnectionString(params) };
+}
+
 function getPoolConnectionAttributes(opts: PgPoolOptions): SpanAttributes {
   let url: URL | undefined;
   try {

From 541c8cf4c75d380b7abc73fb115d5f1719f3e4bc Mon Sep 17 00:00:00 2001
From: Charly Gomez <charly.gomez1310@gmail.com>
Date: Fri, 9 Oct 2026 12:41:00 +0200
Subject: [PATCH 20/84] feat(server-utils): Add the orchestrion config for
 @neondatabase/serverless (#25176)

Adds the orchestrion config for `@neondatabase/serverless`, so the
bundler plugins and the runtime hook can inject channels into it. The
integration that subscribes to those channels follows in #25164 and
registers the config there, which keeps every layer's CI green on its
own.

The package ships two minified esbuild bundles with mangled identifiers
that differ between CJS and ESM, so the name-based matchers find
nothing. The selectors key on property names and string literals that
survive minification: pg's `_pulseQueryQueue` sibling method for
`Client.prototype.query`, the `Neon-Connection-String` header literal
for the HTTP executor, and the `resolvedURL` return shape for the
connection resolver.

`@neondatabase/serverless` becomes a dev dependency of server-utils for
a test that transforms and executes the published bundles, so a Neon
release that reshapes them fails CI. The version range is capped at
`<2`.

Stacked on #25163.

Refs #25144

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
---
 packages/server-utils/package.json            |   1 +
 .../src/orchestrion/config/neon.ts            |  51 ++++++++
 .../test/orchestrion/neon-bundle.test.ts      | 121 ++++++++++++++++++
 yarn.lock                                     |   5 +
 4 files changed, 178 insertions(+)
 create mode 100644 packages/server-utils/src/orchestrion/config/neon.ts
 create mode 100644 packages/server-utils/test/orchestrion/neon-bundle.test.ts

diff --git a/packages/server-utils/package.json b/packages/server-utils/package.json
index a247fd8ae307..92ccae7b686b 100644
--- a/packages/server-utils/package.json
+++ b/packages/server-utils/package.json
@@ -102,6 +102,7 @@
   },
   "devDependencies": {
     "@apm-js-collab/code-transformer-bundler-plugins": "^0.7.4",
+    "@neondatabase/serverless": "1.2.0",
     "@types/node": "^18.19.1",
     "meriyah": "^6.1.4",
     "vite": "^8.3.1"
diff --git a/packages/server-utils/src/orchestrion/config/neon.ts b/packages/server-utils/src/orchestrion/config/neon.ts
new file mode 100644
index 000000000000..011e94deacc7
--- /dev/null
+++ b/packages/server-utils/src/orchestrion/config/neon.ts
@@ -0,0 +1,51 @@
+import type { InstrumentationConfig } from '../apmTypes';
+
+import { getModuleNames } from './module-names';
+
+// `@neondatabase/serverless` ships as two minified esbuild bundles (`index.js` for CJS,
+// `index.mjs` for ESM) that inline their own copy of `pg`. Class and function identifiers are
+// mangled and differ between the two builds, so the name-based `functionQuery` matchers can't
+// find anything. Every selector below keys on property names and string literals, which survive
+// minification and are identical in both bundles.
+const module = { name: '@neondatabase/serverless', versionRange: '>=1.0.0 <2', filePath: /^index\.m?js$/ };
+
+export const neonConfig = [
+  // The bundled pg `Client.prototype.query` (WebSocket driver). `_pulseQueryQueue` is a pg
+  // internal that only `Client` defines, which keeps the pool and wire-protocol `query` methods
+  // out. `methodName` is ignored for matching (`astQuery` wins) but makes the transformer emit a
+  // method wrapper that exposes `self`, which carries `connectionParameters`.
+  {
+    channelName: 'query',
+    module,
+    astQuery:
+      'ClassBody:has(MethodDefinition[key.name="_pulseQueryQueue"]) > MethodDefinition[key.name="query"] > FunctionExpression',
+    functionQuery: { methodName: 'query', kind: 'Auto' },
+  },
+  // The HTTP executor nested inside `neon()`. Every HTTP query funnels through it: lazy
+  // `NeonQueryPromise`s call it from `then`/`catch`/`finally`, and `transaction()` calls it once
+  // with the whole batch, so wrapping it gives one span per request with no double counting.
+  {
+    channelName: 'http-query',
+    module,
+    astQuery: 'FunctionDeclaration[async=true]:has(Literal[value="Neon-Connection-String"])',
+    functionQuery: { kind: 'Async' },
+  },
+  // `resolveConnectionParams`, awaited by the HTTP executor. The connection string lives in the
+  // `neon()` closure and never reaches the executor's channel context, so the subscriber reads
+  // `server.address`/`db.namespace` from this call's result instead, inside the query span.
+  {
+    channelName: 'resolve-connection',
+    module,
+    astQuery:
+      'FunctionDeclaration[async=true]:has(ReturnStatement > ObjectExpression > Property[key.name="resolvedURL"])',
+    functionQuery: { kind: 'Async' },
+  },
+] satisfies InstrumentationConfig[];
+
+export const neonModuleNames = getModuleNames(neonConfig);
+
+export const neonChannels = {
+  NEON_QUERY: 'orchestrion:@neondatabase/serverless:query',
+  NEON_HTTP_QUERY: 'orchestrion:@neondatabase/serverless:http-query',
+  NEON_RESOLVE_CONNECTION: 'orchestrion:@neondatabase/serverless:resolve-connection',
+} as const;
diff --git a/packages/server-utils/test/orchestrion/neon-bundle.test.ts b/packages/server-utils/test/orchestrion/neon-bundle.test.ts
new file mode 100644
index 000000000000..e84a1d35ebe9
--- /dev/null
+++ b/packages/server-utils/test/orchestrion/neon-bundle.test.ts
@@ -0,0 +1,121 @@
+import { createCodeTransformer } from '@apm-js-collab/code-transformer-bundler-plugins/core';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { tracingChannel } from 'node:diagnostics_channel';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { neonChannels, neonConfig } from '../../src/orchestrion/config/neon';
+
+// The selectors key on internals of Neon's minified bundles, so this runs the bundler plugins'
+// code transformer over the real published files and executes the result: a release that
+// reshapes the bundle fails here rather than silently dropping spans.
+const nodeRequire = createRequire(import.meta.url);
+const packageDir = dirname(nodeRequire.resolve('@neondatabase/serverless'));
+
+interface NeonModule {
+  neon: (connectionString: string) => {
+    (strings: TemplateStringsArray, ...values: unknown[]): Promise<unknown>;
+    query: (text: string, params?: unknown[]) => Promise<unknown>;
+    transaction: (queries: Promise<unknown>[]) => Promise<unknown>;
+  };
+  neonConfig: { fetchFunction: unknown };
+  Client: new (connectionString: string) => {
+    query: (text: string) => Promise<unknown>;
+    end: () => Promise<void>;
+  };
+}
+
+function neonResponse(body: unknown): () => Promise<Response> {
+  return () => Promise.resolve(new Response(JSON.stringify(body), { status: 200 }));
+}
+
+const EMPTY_RESULT = { rows: [], fields: [], command: 'SELECT', rowCount: 0 };
+
+// Every wrapper opens with a `hasSubscribers` guard on its channel, one per instrumented site.
+function countWrappedSites(code: string, channelVariable: string): number {
+  return code.split(`tr_ch_apm_hasSubscribers(${channelVariable})`).length - 1;
+}
+
+describe('neon orchestrion config on the published bundles', () => {
+  let outDir: string;
+  const events: string[] = [];
+
+  beforeAll(() => {
+    outDir = mkdtempSync(join(tmpdir(), 'neon-bundle-'));
+    for (const name of ['query', 'http-query', 'resolve-connection']) {
+      tracingChannel(`orchestrion:@neondatabase/serverless:${name}`).subscribe({
+        start: data => {
+          const ctx = data as { arguments: unknown[]; self?: { connectionParameters?: { database?: string } } };
+          events.push(`${name}:start:${ctx.self?.connectionParameters?.database ?? JSON.stringify(ctx.arguments[0])}`);
+        },
+        end: () => {},
+        asyncStart: () => {},
+        asyncEnd: data => {
+          const ctx = data as { result?: { resolvedURL?: URL } };
+          events.push(`${name}:asyncEnd:${ctx.result?.resolvedURL?.hostname ?? ''}`);
+        },
+        error: () => {},
+      });
+    }
+  });
+
+  afterAll(() => rmSync(outDir, { recursive: true, force: true }));
+
+  it.each([
+    ['index.js', 'cjs'],
+    ['index.mjs', 'esm'],
+  ])('instruments both drivers in %s', async (file, format) => {
+    const transformer = createCodeTransformer({ instrumentations: neonConfig });
+    const source = join(packageDir, file);
+    const result = transformer.transform(readFileSync(source, 'utf8'), source);
+    expect(result).not.toBeNull();
+
+    for (const channel of Object.values(neonChannels)) {
+      expect(result!.code).toContain(channel);
+    }
+    // Only pg's `Client.prototype.query` gets the channel, not the pool or wire-protocol `query`.
+    expect(countWrappedSites(result!.code, 'tr_ch_apm$query')).toBe(1);
+    expect(countWrappedSites(result!.code, 'tr_ch_apm$http_query')).toBe(1);
+    expect(countWrappedSites(result!.code, 'tr_ch_apm$resolve_connection')).toBe(1);
+    // The query wrapper exposes `self`, which carries pg's `connectionParameters`.
+    const querySite = result!.code.indexOf('Client was passed a null or undefined query');
+    expect(result!.code.slice(result!.code.lastIndexOf('__apm$ctx = {', querySite), querySite)).toContain('self: this');
+
+    const outFile = join(outDir, file);
+    writeFileSync(outFile, result!.code);
+    const mod: NeonModule =
+      format === 'cjs' ? nodeRequire(outFile) : ((await import(pathToFileURL(outFile).href)) as NeonModule);
+
+    events.length = 0;
+    mod.neonConfig.fetchFunction = neonResponse(EMPTY_RESULT);
+    const sql = mod.neon('postgres://user:pass@ep-x.aws.neon.tech/neondb');
+    await sql.query('SELECT $1', [1]);
+    await sql`SELECT 2`;
+    mod.neonConfig.fetchFunction = neonResponse({ results: [EMPTY_RESULT, EMPTY_RESULT] });
+    await sql.transaction([sql`SELECT 3`, sql`SELECT 4`]);
+
+    const client = new mod.Client('postgres://user:pass@ep-x.aws.neon.tech/neondb');
+    // Never connects: the channel fires at the call, before the socket is needed.
+    client.query('SELECT 5').catch(() => {});
+    await client.end().catch(() => {});
+
+    const resolve = [
+      'resolve-connection:start:"postgres://user:pass@ep-x.aws.neon.tech/neondb"',
+      'resolve-connection:asyncEnd:ep-x.aws.neon.tech',
+    ];
+    expect(events).toEqual([
+      'http-query:start:{"query":"SELECT $1","params":[1]}',
+      ...resolve,
+      'http-query:asyncEnd:',
+      'http-query:start:{"strings":["SELECT 2"],"values":[]}',
+      ...resolve,
+      'http-query:asyncEnd:',
+      'http-query:start:[{"strings":["SELECT 3"],"values":[]},{"strings":["SELECT 4"],"values":[]}]',
+      ...resolve,
+      'http-query:asyncEnd:',
+      'query:start:neondb',
+    ]);
+  });
+});
diff --git a/yarn.lock b/yarn.lock
index 0feac03098c9..190af4e5ae9e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5664,6 +5664,11 @@
     "@emnapi/runtime" "^1.1.0"
     "@tybys/wasm-util" "^0.9.0"
 
+"@neondatabase/serverless@1.2.0":
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/@neondatabase/serverless/-/serverless-1.2.0.tgz#d58553f0804eb9ddacb09662d607756b7dc74b77"
+  integrity sha512-tnaqgixUengZQNd9ZrS3ytQfamJzLKY8QxgqWQTNHHtB+KrFQWk77JTbbpg4RD+J3qE4eO2lVytvGDX5Kj6FdQ==
+
 "@nestjs/common@^10.0.0":
   version "10.4.15"
   resolved "https://registry.yarnpkg.com/@nestjs/common/-/common-10.4.15.tgz#27c291466d9100eb86fdbe6f7bbb4d1a6ad55f70"

From 9f8f8485f6aa9b00fe2f01cbc063655c1a41e6ca Mon Sep 17 00:00:00 2001
From: Charly Gomez <charly.gomez1310@gmail.com>
Date: Fri, 9 Oct 2026 12:41:01 +0200
Subject: [PATCH 21/84] feat(node): Add neonIntegration for
 @neondatabase/serverless (#25164)

Adds `neonIntegration` for `@neondatabase/serverless`. Both drivers emit
`db` spans with the pg span shape: the WebSocket `Client`/`Pool` and the
HTTP `neon()` function, including Drizzle's `neon-http` and
`neon-serverless` adapters.

Subscribes to the channels from #25176 and registers the config, so
build-time bundler plugins get the same coverage as the runtime hook.

- The HTTP span wraps the executor inside `neon()`, not the lazy query
promise, so `transaction()` batches get one span instead of one per
statement plus one for the batch.
- Connection attributes for HTTP come from the connection resolver,
which runs inside the query span. The executor itself never sees the
connection string.
- `db.connection_string` is deprecated and not emitted.

End-to-end tests follow in #25177.

Stacked on #25176.

Fixes #25144

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
---
 packages/astro/src/index.server.ts            |   1 +
 packages/aws-serverless/src/index.ts          |   1 +
 packages/bun/src/index.ts                     |   1 +
 packages/deno/src/index.ts                    |   1 +
 packages/elysia/src/index.ts                  |   1 +
 packages/google-cloud-serverless/src/index.ts |   1 +
 packages/node/src/index.ts                    |   1 +
 packages/server-utils/src/index.ts            |   1 +
 .../server-utils/src/integrations/index.ts    |   2 +
 .../server-utils/src/integrations/neon.ts     | 158 ++++++++++
 .../server-utils/src/orchestrion/channels.ts  |   2 +
 .../config/channel-integration-definitions.ts |   1 +
 .../src/orchestrion/config/index.ts           |   2 +
 .../test/integrations/neon.test.ts            | 286 ++++++++++++++++++
 .../test/orchestrion/neon-bundle.test.ts      |  16 +-
 packages/solidstart/src/server/index.ts       |   1 +
 packages/sveltekit/src/server/index.ts        |   1 +
 17 files changed, 475 insertions(+), 2 deletions(-)
 create mode 100644 packages/server-utils/src/integrations/neon.ts
 create mode 100644 packages/server-utils/test/integrations/neon.test.ts

diff --git a/packages/astro/src/index.server.ts b/packages/astro/src/index.server.ts
index 7c997a3de32f..dc77f7d5f6b9 100644
--- a/packages/astro/src/index.server.ts
+++ b/packages/astro/src/index.server.ts
@@ -109,6 +109,7 @@ export {
   pinoIntegration,
   postgresIntegration,
   postgresJsIntegration,
+  neonIntegration,
   prismaIntegration,
   openTelemetryIntegration,
   getOtlpTracesEndpoint,
diff --git a/packages/aws-serverless/src/index.ts b/packages/aws-serverless/src/index.ts
index d5aabe372bd0..cd302d5523f0 100644
--- a/packages/aws-serverless/src/index.ts
+++ b/packages/aws-serverless/src/index.ts
@@ -129,6 +129,7 @@ export {
   pinoIntegration,
   postgresIntegration,
   postgresJsIntegration,
+  neonIntegration,
   processSessionIntegration,
   prismaIntegration,
   openTelemetryIntegration,
diff --git a/packages/bun/src/index.ts b/packages/bun/src/index.ts
index aa7b2cfc74bf..c0cc191e2850 100644
--- a/packages/bun/src/index.ts
+++ b/packages/bun/src/index.ts
@@ -150,6 +150,7 @@ export {
   tediousIntegration,
   postgresIntegration,
   postgresJsIntegration,
+  neonIntegration,
   prismaIntegration,
   openTelemetryIntegration,
   getOtlpTracesEndpoint,
diff --git a/packages/deno/src/index.ts b/packages/deno/src/index.ts
index dd23caea66cc..c47dc1628c74 100644
--- a/packages/deno/src/index.ts
+++ b/packages/deno/src/index.ts
@@ -156,6 +156,7 @@ export {
   typesafeIntegration,
   postgresIntegration,
   postgresJsIntegration,
+  neonIntegration,
   tediousIntegration,
   eveConversationHook,
   eveIntegration,
diff --git a/packages/elysia/src/index.ts b/packages/elysia/src/index.ts
index 659cb35cf870..865ace1fc978 100644
--- a/packages/elysia/src/index.ts
+++ b/packages/elysia/src/index.ts
@@ -129,6 +129,7 @@ export {
   tediousIntegration,
   postgresIntegration,
   postgresJsIntegration,
+  neonIntegration,
   prismaIntegration,
   processSessionIntegration,
   hapiIntegration,
diff --git a/packages/google-cloud-serverless/src/index.ts b/packages/google-cloud-serverless/src/index.ts
index 828f77501a48..5bbf486e2342 100644
--- a/packages/google-cloud-serverless/src/index.ts
+++ b/packages/google-cloud-serverless/src/index.ts
@@ -129,6 +129,7 @@ export {
   pinoIntegration,
   postgresIntegration,
   postgresJsIntegration,
+  neonIntegration,
   prismaIntegration,
   openTelemetryIntegration,
   getOtlpTracesEndpoint,
diff --git a/packages/node/src/index.ts b/packages/node/src/index.ts
index 0dbf9dc692b9..df5d309ee9e6 100644
--- a/packages/node/src/index.ts
+++ b/packages/node/src/index.ts
@@ -38,6 +38,7 @@ export {
   typesafeIntegration,
   postgresIntegration,
   postgresJsIntegration,
+  neonIntegration,
   redisIntegration,
   tediousIntegration,
   vercelAIIntegration,
diff --git a/packages/server-utils/src/index.ts b/packages/server-utils/src/index.ts
index 22b7470fa7b7..41eb3845cf1a 100644
--- a/packages/server-utils/src/index.ts
+++ b/packages/server-utils/src/index.ts
@@ -68,6 +68,7 @@ export { mysql2Integration } from './integrations/mysql2';
 export { openAIIntegration } from './integrations/openai';
 export { postgresIntegration } from './integrations/postgres';
 export { postgresJsIntegration } from './integrations/postgres-js';
+export { neonIntegration } from './integrations/neon';
 export { tediousIntegration } from './integrations/tedious';
 export { vercelAIIntegration } from './integrations/vercel-ai';
 export { expressIntegration } from './integrations/express';
diff --git a/packages/server-utils/src/integrations/index.ts b/packages/server-utils/src/integrations/index.ts
index a09d590e1121..5b044dd29430 100644
--- a/packages/server-utils/src/integrations/index.ts
+++ b/packages/server-utils/src/integrations/index.ts
@@ -27,6 +27,7 @@ import { groqIntegration } from './groq';
 import { togetherAIIntegration } from './together-ai';
 import { typesafeIntegration } from './typesafe';
 import { postgresJsIntegration } from './postgres-js';
+import { neonIntegration } from './neon';
 import { firebaseIntegration } from './firebase';
 import { expressIntegration } from './express';
 import { fastifyIntegration } from './fastify';
@@ -70,6 +71,7 @@ export function getTracingIntegrations(): Integration[] {
     togetherAIIntegration(),
     typesafeIntegration(),
     postgresJsIntegration(),
+    neonIntegration(),
     firebaseIntegration(),
     mcpServerIntegration(),
   ];
diff --git a/packages/server-utils/src/integrations/neon.ts b/packages/server-utils/src/integrations/neon.ts
new file mode 100644
index 000000000000..f7e66ff953a2
--- /dev/null
+++ b/packages/server-utils/src/integrations/neon.ts
@@ -0,0 +1,158 @@
+import * as diagnosticsChannel from '../utils/diagnosticsChannel';
+import {
+  DB_OPERATION_BATCH_SIZE,
+  DB_QUERY_SUMMARY,
+  DB_QUERY_TEXT,
+  DB_SYSTEM_NAME,
+  SENTRY_KIND,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
+import type { IntegrationFn, Span } from '@sentry/core';
+import { defineIntegration, getActiveSpan, startInactiveSpan } from '@sentry/core';
+import { sanitizeSqlQueryWithSummary } from '../utils/sql';
+import { CHANNELS } from '../orchestrion/channels';
+import { neonModuleNames } from '../orchestrion/config/neon';
+import { invokeOrchestrionInstrumentation } from '../orchestrion/instrumentation';
+import { bindTracingChannelToSpan } from '../tracing-channel';
+import { bindPgQueryChannel, getConnectionAttributes } from './postgres';
+
+const INTEGRATION_NAME = 'Neon' as const;
+const ORIGIN = 'auto.db.neon';
+const DB_SYSTEM_POSTGRESQL = 'postgresql';
+const DEFAULT_PORT = 5432;
+const NOOP = (): void => {};
+
+// `sql.query(text, params)` builds the first shape, a tagged-template call the second.
+type NeonQueryData = { query: string; params?: unknown[] } | NeonSqlTemplate;
+
+interface NeonSqlTemplate {
+  strings: readonly string[];
+  values: unknown[];
+  toParameterizedQuery?: () => { query: string };
+}
+
+interface NeonHttpQueryContext {
+  // `[queryData, opts]` for a single query, `[queryData[], opts[]]` for a `transaction()` batch.
+  arguments: unknown[];
+}
+
+interface NeonResolveConnectionContext {
+  result?: { resolvedURL?: URL };
+}
+
+// The HTTP query spans this integration started, so the connection-resolver subscriber only
+// enriches those and never a user's own active span.
+const httpQuerySpans = new WeakSet<Span>();
+
+const _neonIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      invokeOrchestrionInstrumentation(client, neonModuleNames, instrumentNeon, []);
+    },
+  };
+}) satisfies IntegrationFn;
+
+function instrumentNeon(): void {
+  // The WebSocket driver is pg's `Client`, bundled into the package, so its query channel gets
+  // the pg span shape.
+  bindPgQueryChannel(CHANNELS.NEON_QUERY, { origin: ORIGIN });
+
+  bindTracingChannelToSpan(
+    diagnosticsChannel.tracingChannel<NeonHttpQueryContext>(CHANNELS.NEON_HTTP_QUERY),
+    data => {
+      const span = startInactiveSpan(httpQuerySpanOptions(data.arguments));
+      httpQuerySpans.add(span);
+      return span;
+    },
+    { requiresParentSpan: true },
+  );
+
+  // The connection string is resolved inside the HTTP executor, so the query span is active
+  // when this settles. The executor's own context never sees the string.
+  diagnosticsChannel.tracingChannel<NeonResolveConnectionContext>(CHANNELS.NEON_RESOLVE_CONNECTION).subscribe({
+    start: NOOP,
+    end: NOOP,
+    asyncStart: NOOP,
+    error: NOOP,
+    asyncEnd(data) {
+      const span = getActiveSpan();
+      const url = data.result?.resolvedURL;
+      if (!span || !httpQuerySpans.has(span) || !url) {
+        return;
+      }
+      span.setAttributes(
+        getConnectionAttributes({
+          host: url.hostname,
+          port: Number(url.port) || DEFAULT_PORT,
+          database: url.pathname.slice(1),
+          user: url.username || undefined,
+        }),
+      );
+    },
+  });
+}
+
+function httpQuerySpanOptions(args: unknown[]): Parameters<typeof startInactiveSpan>[0] {
+  const queryData = args[0] as NeonQueryData | NeonQueryData[] | undefined;
+  const batchSize = Array.isArray(queryData) ? queryData.length : undefined;
+  // A batch gets one span whose text and summary list every statement, in order.
+  const statements = (Array.isArray(queryData) ? queryData : [queryData])
+    .map(getQueryText)
+    .filter((text): text is string => !!text)
+    .map(text => sanitizeSqlQueryWithSummary(text));
+  const queryText = joinDefined(statements.map(s => s.queryText));
+  const querySummary = joinDefined(statements.map(s => s.querySummary));
+  const name = querySummary || DB_SYSTEM_POSTGRESQL;
+
+  return {
+    name,
+    attributes: {
+      [SENTRY_OP]: DB,
+      [SENTRY_ORIGIN]: ORIGIN,
+      [SENTRY_KIND]: 'client',
+      [DB_SYSTEM_NAME]: DB_SYSTEM_POSTGRESQL,
+      [DB_QUERY_TEXT]: queryText || undefined,
+      [DB_QUERY_SUMMARY]: querySummary,
+      [DB_OPERATION_BATCH_SIZE]: batchSize,
+    },
+  };
+}
+
+function joinDefined(parts: (string | undefined)[]): string | undefined {
+  const defined = parts.filter((part): part is string => !!part);
+  return defined.length ? defined.join('; ') : undefined;
+}
+
+function getQueryText(data: NeonQueryData | undefined): string | undefined {
+  if (!data || typeof data !== 'object') {
+    return undefined;
+  }
+  if ('query' in data && typeof data.query === 'string') {
+    return data.query;
+  }
+  if (!('strings' in data) || !Array.isArray(data.strings)) {
+    return undefined;
+  }
+  if (typeof data.toParameterizedQuery === 'function') {
+    try {
+      // Neon's own rendering also inlines `sql.unsafe()` fragments and nested templates.
+      return data.toParameterizedQuery().query;
+    } catch {
+      // fall through to the plain placeholder rendering
+    }
+  }
+  return data.strings.reduce((text, part, i) => `${text}$${i}${part}`);
+}
+
+/**
+ * Diagnostics-channel-based `@neondatabase/serverless` integration.
+ *
+ * Subscribes to the channels Sentry's code transform injects into the package's bundled pg
+ * `Client.prototype.query` (WebSocket driver) and into the HTTP executor behind `neon()`, so both
+ * drivers emit `db` spans with the same shape as the `pg` integration. Requires the Sentry runtime
+ * hook or bundler plugin to be active.
+ */
+export const neonIntegration = defineIntegration(_neonIntegration);
diff --git a/packages/server-utils/src/orchestrion/channels.ts b/packages/server-utils/src/orchestrion/channels.ts
index 4211c8c88d5c..b5919b9eb071 100644
--- a/packages/server-utils/src/orchestrion/channels.ts
+++ b/packages/server-utils/src/orchestrion/channels.ts
@@ -24,6 +24,7 @@ import { mongodbChannels } from './config/mongodb';
 import { mongooseChannels } from './config/mongoose';
 import { mysql2Channels } from './config/mysql2';
 import { mysqlChannels } from './config/mysql';
+import { neonChannels } from './config/neon';
 import { nestjsChannels } from './config/nestjs';
 import { openaiChannels } from './config/openai';
 import { pgChannels } from './config/pg';
@@ -80,6 +81,7 @@ export const CHANNELS = {
   ...mongooseChannels,
   ...mysql2Channels,
   ...mysqlChannels,
+  ...neonChannels,
   ...nestjsChannels,
   ...openaiChannels,
   ...pgChannels,
diff --git a/packages/server-utils/src/orchestrion/config/channel-integration-definitions.ts b/packages/server-utils/src/orchestrion/config/channel-integration-definitions.ts
index 683370c0fe61..d3583a3977ec 100644
--- a/packages/server-utils/src/orchestrion/config/channel-integration-definitions.ts
+++ b/packages/server-utils/src/orchestrion/config/channel-integration-definitions.ts
@@ -18,6 +18,7 @@
 export const CHANNEL_INTEGRATION_DEFINITIONS = [
   { exportName: 'postgresIntegration', modules: ['pg', 'pg-pool'] },
   { exportName: 'postgresJsIntegration', modules: ['postgres'] },
+  { exportName: 'neonIntegration', modules: ['@neondatabase/serverless'] },
   { exportName: 'prismaIntegration', modules: ['@prisma/orm-family-sql'] },
   { exportName: 'mysqlIntegration', modules: ['mysql'] },
   { exportName: 'mysql2Integration', modules: ['mysql2'] },
diff --git a/packages/server-utils/src/orchestrion/config/index.ts b/packages/server-utils/src/orchestrion/config/index.ts
index 2c6a7835db1a..0cf0e363728f 100644
--- a/packages/server-utils/src/orchestrion/config/index.ts
+++ b/packages/server-utils/src/orchestrion/config/index.ts
@@ -30,6 +30,7 @@ import { mongodbConfig } from './mongodb';
 import { mongooseConfig } from './mongoose';
 import { mysql2Config } from './mysql2';
 import { mysqlConfig } from './mysql';
+import { neonConfig } from './neon';
 import { nestjsConfig } from './nestjs';
 import { openaiConfig } from './openai';
 import { pgConfig } from './pg';
@@ -86,6 +87,7 @@ export const SENTRY_INSTRUMENTATIONS: InstrumentationConfig[] = [
   ...mongooseConfig,
   ...mysql2Config,
   ...mysqlConfig,
+  ...neonConfig,
   ...nestjsConfig,
   ...openaiConfig,
   ...pgConfig,
diff --git a/packages/server-utils/test/integrations/neon.test.ts b/packages/server-utils/test/integrations/neon.test.ts
new file mode 100644
index 000000000000..661a65cc7389
--- /dev/null
+++ b/packages/server-utils/test/integrations/neon.test.ts
@@ -0,0 +1,286 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { tracingChannel } from 'node:diagnostics_channel';
+import {
+  DB_NAMESPACE,
+  DB_OPERATION_BATCH_SIZE,
+  DB_QUERY_SUMMARY,
+  DB_QUERY_TEXT,
+  DB_SYSTEM_NAME,
+  DB_USER,
+  SENTRY_KIND,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SERVER_ADDRESS,
+  SERVER_PORT,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
+import type { Client, Scope, Span } from '@sentry/core';
+import * as SentryCore from '@sentry/core';
+import {
+  _INTERNAL_setSpanForScope,
+  getDefaultCurrentScope,
+  getDefaultIsolationScope,
+  GLOBAL_OBJ,
+  setAsyncContextStrategy,
+} from '@sentry/core';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, type MockInstance, vi } from 'vitest';
+import { neonIntegration } from '../../src/integrations/neon';
+import { CHANNELS } from '../../src/orchestrion/channels';
+
+interface TestStore {
+  scope: Scope;
+  isolationScope: Scope;
+}
+
+// Same minimal async-context strategy as the pg tests: `bindTracingChannelToSpan` only binds
+// when a `getTracingChannelBinding` exists.
+function installTestAsyncContextStrategy(): void {
+  const asyncStorage = new AsyncLocalStorage<TestStore>();
+
+  function getScopes(): TestStore {
+    return asyncStorage.getStore() || { scope: getDefaultCurrentScope(), isolationScope: getDefaultIsolationScope() };
+  }
+
+  setAsyncContextStrategy({
+    withScope: callback => {
+      const scope = getScopes().scope.clone();
+      const isolationScope = getScopes().isolationScope;
+      return asyncStorage.run({ scope, isolationScope }, () => callback(scope));
+    },
+    withSetScope: (scope, callback) => {
+      const isolationScope = getScopes().isolationScope;
+      return asyncStorage.run({ scope, isolationScope }, () => callback(scope));
+    },
+    withIsolationScope: callback => {
+      const scope = getScopes().scope;
+      const isolationScope = getScopes().isolationScope.clone();
+      return asyncStorage.run({ scope, isolationScope }, () => callback(isolationScope));
+    },
+    withSetIsolationScope: (isolationScope, callback) => {
+      const scope = getScopes().scope;
+      return asyncStorage.run({ scope, isolationScope }, () => callback(isolationScope));
+    },
+    getCurrentScope: () => getScopes().scope,
+    getIsolationScope: () => getScopes().isolationScope,
+    getTracingChannelBinding: () => ({
+      asyncLocalStorage: asyncStorage,
+      getStoreWithActiveSpan: span => {
+        const scope = getScopes().scope.clone();
+        const isolationScope = getScopes().isolationScope;
+        _INTERNAL_setSpanForScope(scope, span);
+        return { scope, isolationScope };
+      },
+    }),
+  });
+}
+
+function makeSpan(): Span {
+  return { end: vi.fn(), setStatus: vi.fn(), setAttributes: vi.fn() } as unknown as Span;
+}
+
+interface ChannelContext {
+  arguments: unknown[];
+  self?: unknown;
+  result?: unknown;
+}
+
+const CONNECTION = { database: 'neondb', host: 'ep-x.aws.neon.tech', port: 5432, user: 'tim' };
+
+// Shape of `@neondatabase/serverless`'s `SqlTemplate`, the query data a tagged-template call builds.
+function sqlTemplate(strings: string[], values: unknown[]): unknown {
+  return {
+    strings,
+    values,
+    toParameterizedQuery() {
+      return { query: strings.reduce((acc, s, i) => `${acc}$${i}${s}`), params: values };
+    },
+  };
+}
+
+describe('neonIntegration', () => {
+  let startInactiveSpanSpy: MockInstance;
+  let getActiveSpanSpy: MockInstance;
+  let span: Span;
+
+  beforeAll(() => {
+    installTestAsyncContextStrategy();
+    GLOBAL_OBJ.__SENTRY_ORCHESTRION__ = { runtime: ['@neondatabase/serverless'] };
+    neonIntegration().setup?.({ on: () => () => undefined } as unknown as Client);
+  });
+
+  afterAll(() => {
+    setAsyncContextStrategy(undefined);
+    delete GLOBAL_OBJ.__SENTRY_ORCHESTRION__;
+  });
+
+  beforeEach(() => {
+    span = makeSpan();
+    startInactiveSpanSpy = vi.spyOn(SentryCore, 'startInactiveSpan').mockReturnValue(span);
+    getActiveSpanSpy = vi.spyOn(SentryCore, 'getActiveSpan').mockReturnValue({} as Span);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('websocket driver (`Client.prototype.query`)', () => {
+    it('builds a db span with the pg connection attributes and the neon origin', async () => {
+      const ctx: ChannelContext = { arguments: ['SELECT * FROM "User"'], self: { connectionParameters: CONNECTION } };
+
+      await tracingChannel(CHANNELS.NEON_QUERY).tracePromise(async () => ({ rows: [] }), ctx);
+
+      expect(startInactiveSpanSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'SELECT * FROM "User"',
+          attributes: expect.objectContaining({
+            [SENTRY_OP]: DB,
+            [SENTRY_KIND]: 'client',
+            [DB_SYSTEM_NAME]: 'postgresql',
+            [DB_NAMESPACE]: 'neondb',
+            [DB_USER]: 'tim',
+            [SERVER_ADDRESS]: 'ep-x.aws.neon.tech',
+            [SERVER_PORT]: 5432,
+            [DB_QUERY_TEXT]: 'SELECT * FROM "User"',
+            [SENTRY_ORIGIN]: 'auto.db.neon',
+          }),
+        }),
+      );
+      // The deprecated `db.connection_string` is left to the pg integration.
+      expect(startInactiveSpanSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          attributes: expect.not.objectContaining({ 'db.connection_string': expect.anything() }),
+        }),
+      );
+      expect(span.end).toHaveBeenCalledTimes(1);
+    });
+
+    it('does not start a span without a parent span', async () => {
+      getActiveSpanSpy.mockReturnValue(undefined);
+      const ctx: ChannelContext = { arguments: ['SELECT 1'], self: { connectionParameters: CONNECTION } };
+
+      await tracingChannel(CHANNELS.NEON_QUERY).tracePromise(async () => ({ rows: [] }), ctx);
+
+      expect(startInactiveSpanSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('http driver (`neon()`)', () => {
+    it('builds a db span for `sql.query(text, params)`', async () => {
+      const ctx: ChannelContext = {
+        arguments: [{ query: 'SELECT * FROM "User" WHERE id = $1', params: [1] }, undefined],
+      };
+
+      await tracingChannel(CHANNELS.NEON_HTTP_QUERY).tracePromise(async () => [], ctx);
+
+      expect(startInactiveSpanSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'SELECT "User"',
+          attributes: expect.objectContaining({
+            [SENTRY_OP]: DB,
+            [SENTRY_KIND]: 'client',
+            [DB_SYSTEM_NAME]: 'postgresql',
+            [DB_QUERY_TEXT]: 'SELECT * FROM "User" WHERE id = $1',
+            [DB_QUERY_SUMMARY]: 'SELECT "User"',
+            [SENTRY_ORIGIN]: 'auto.db.neon',
+            [DB_OPERATION_BATCH_SIZE]: undefined,
+          }),
+        }),
+      );
+      expect(span.end).toHaveBeenCalledTimes(1);
+    });
+
+    it('renders a tagged-template query with positional placeholders', async () => {
+      const ctx: ChannelContext = {
+        arguments: [sqlTemplate(['SELECT * FROM "User" WHERE id = ', ' AND name = ', ''], [1, 'tim'])],
+      };
+
+      await tracingChannel(CHANNELS.NEON_HTTP_QUERY).tracePromise(async () => [], ctx);
+
+      expect(startInactiveSpanSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'SELECT "User"',
+          attributes: expect.objectContaining({
+            [DB_QUERY_TEXT]: 'SELECT * FROM "User" WHERE id = $1 AND name = $2',
+          }),
+        }),
+      );
+    });
+
+    it('builds one span for a `transaction()` batch with the batch size', async () => {
+      const ctx: ChannelContext = {
+        arguments: [
+          [
+            { query: 'INSERT INTO "User" ("name") VALUES ($1)', params: ['tim'] },
+            sqlTemplate(['SELECT * FROM "User"'], []),
+          ],
+          [{}, {}],
+        ],
+      };
+
+      await tracingChannel(CHANNELS.NEON_HTTP_QUERY).tracePromise(async () => [[], []], ctx);
+
+      expect(startInactiveSpanSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'INSERT "User"; SELECT "User"',
+          attributes: expect.objectContaining({
+            [DB_QUERY_TEXT]: 'INSERT INTO "User" ("name") VALUES ($1); SELECT * FROM "User"',
+            [DB_QUERY_SUMMARY]: 'INSERT "User"; SELECT "User"',
+            [DB_OPERATION_BATCH_SIZE]: 2,
+            [SENTRY_ORIGIN]: 'auto.db.neon',
+          }),
+        }),
+      );
+      expect(span.end).toHaveBeenCalledTimes(1);
+    });
+
+    it('sets error status and ends the span when the request rejects', async () => {
+      const ctx: ChannelContext = { arguments: [{ query: 'SELECT 1', params: [] }] };
+
+      await expect(
+        tracingChannel(CHANNELS.NEON_HTTP_QUERY).tracePromise(async () => {
+          throw new Error('boom');
+        }, ctx),
+      ).rejects.toThrow('boom');
+
+      expect(span.setStatus).toHaveBeenCalledWith({ code: expect.anything(), message: 'boom' });
+      expect(span.end).toHaveBeenCalledTimes(1);
+    });
+
+    it('adds the connection attributes once the connection string resolves inside the query', async () => {
+      const ctx: ChannelContext = { arguments: [{ query: 'SELECT 1', params: [] }] };
+
+      await tracingChannel(CHANNELS.NEON_HTTP_QUERY).tracePromise(async () => {
+        // The resolver runs inside the query span's async context.
+        getActiveSpanSpy.mockReturnValue(span);
+        await tracingChannel(CHANNELS.NEON_RESOLVE_CONNECTION).tracePromise(
+          async () => ({
+            resolvedConnectionString: 'postgresql://tim:secret@ep-x.aws.neon.tech/neondb?application_name=x',
+            resolvedURL: new URL('postgresql://tim:secret@ep-x.aws.neon.tech/neondb?application_name=x'),
+          }),
+          { arguments: ['postgresql://tim:secret@ep-x.aws.neon.tech/neondb'] },
+        );
+      }, ctx);
+
+      // No port in the URL means the Postgres default, like pg's own connection parameters.
+      expect(span.setAttributes).toHaveBeenCalledWith({
+        [DB_SYSTEM_NAME]: 'postgresql',
+        [DB_NAMESPACE]: 'neondb',
+        [DB_USER]: 'tim',
+        [SERVER_ADDRESS]: 'ep-x.aws.neon.tech',
+        [SERVER_PORT]: 5432,
+      });
+    });
+
+    it('leaves spans it did not start alone when the connection string resolves', async () => {
+      const foreignSpan = makeSpan();
+      getActiveSpanSpy.mockReturnValue(foreignSpan);
+
+      await tracingChannel(CHANNELS.NEON_RESOLVE_CONNECTION).tracePromise(
+        async () => ({ resolvedURL: new URL('postgresql://tim:secret@ep-x.aws.neon.tech/neondb') }),
+        { arguments: [] },
+      );
+
+      expect(foreignSpan.setAttributes).not.toHaveBeenCalled();
+    });
+  });
+});
diff --git a/packages/server-utils/test/orchestrion/neon-bundle.test.ts b/packages/server-utils/test/orchestrion/neon-bundle.test.ts
index e84a1d35ebe9..79d9907467e2 100644
--- a/packages/server-utils/test/orchestrion/neon-bundle.test.ts
+++ b/packages/server-utils/test/orchestrion/neon-bundle.test.ts
@@ -6,7 +6,9 @@ import { dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { tracingChannel } from 'node:diagnostics_channel';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { neonChannels, neonConfig } from '../../src/orchestrion/config/neon';
+import { SENTRY_INSTRUMENTATIONS } from '../../src/orchestrion/config';
+import { neonChannels } from '../../src/orchestrion/config/neon';
+import { orchestrionTransformOptions } from '../../src/orchestrion/bundler/options';
 
 // The selectors key on internals of Neon's minified bundles, so this runs the bundler plugins'
 // code transformer over the real published files and executes the result: a release that
@@ -63,11 +65,21 @@ describe('neon orchestrion config on the published bundles', () => {
 
   afterAll(() => rmSync(outDir, { recursive: true, force: true }));
 
+  it('injects the subscriber snippet for the neon integration', () => {
+    const transformer = createCodeTransformer(orchestrionTransformOptions({}));
+    const result = transformer.transform(
+      readFileSync(join(packageDir, 'index.js'), 'utf8'),
+      join(packageDir, 'index.js'),
+    );
+
+    expect(result?.code).toContain('orchestrionModuleInjected("@neondatabase/serverless", () => neonIntegration())');
+  });
+
   it.each([
     ['index.js', 'cjs'],
     ['index.mjs', 'esm'],
   ])('instruments both drivers in %s', async (file, format) => {
-    const transformer = createCodeTransformer({ instrumentations: neonConfig });
+    const transformer = createCodeTransformer({ instrumentations: SENTRY_INSTRUMENTATIONS });
     const source = join(packageDir, file);
     const result = transformer.transform(readFileSync(source, 'utf8'), source);
     expect(result).not.toBeNull();
diff --git a/packages/solidstart/src/server/index.ts b/packages/solidstart/src/server/index.ts
index 8c8576aeb7ae..fc4f29d21181 100644
--- a/packages/solidstart/src/server/index.ts
+++ b/packages/solidstart/src/server/index.ts
@@ -82,6 +82,7 @@ export {
   parameterize,
   postgresIntegration,
   postgresJsIntegration,
+  neonIntegration,
   prismaIntegration,
   redisIntegration,
   requestDataIntegration,
diff --git a/packages/sveltekit/src/server/index.ts b/packages/sveltekit/src/server/index.ts
index cb0730b4c513..d01ea0d03fc2 100644
--- a/packages/sveltekit/src/server/index.ts
+++ b/packages/sveltekit/src/server/index.ts
@@ -81,6 +81,7 @@ export {
   parameterize,
   postgresIntegration,
   postgresJsIntegration,
+  neonIntegration,
   prismaIntegration,
   redisIntegration,
   requestDataIntegration,

From cb88771e9936caef5fd20ac390d12159605c17bd Mon Sep 17 00:00:00 2001
From: Charly Gomez <charly.gomez1310@gmail.com>
Date: Fri, 9 Oct 2026 12:41:01 +0200
Subject: [PATCH 22/84] test(node): Add integration tests for the Neon
 serverless driver (#25177)

Runs both Neon drivers end to end against Neon's own proxy
(`ghcr.io/timowilhelm/local-neon-http-proxy`) in front of a local
Postgres, so the HTTP `/sql` and WebSocket `/v2` wire protocols are the
real ones. Covers `sql.query()`, tagged templates, `transaction()`
batches, a failing statement and pool queries, in ESM and CJS under the
default span lifecycle.

The suite is excluded on Bun like the other database suites, since `bun
run` cannot inject the diagnostics channels; the Bun plugin build does
run it. The pool test is Node only, because on Bun and Deno the pool's
connect callback runs outside the segment's async context. `ws` is added
because Node 20 has no global `WebSocket`.

Stacked on #25164.

Refs #25144

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../node-suites/excludes.ts                   |   1 +
 .../node-integration-tests/package.json       |   2 +
 .../suites/tracing/neon/docker-compose.yml    |  43 +++++
 .../suites/tracing/neon/instrument.mjs        |   9 +
 .../suites/tracing/neon/scenario-http.mjs     |  33 ++++
 .../suites/tracing/neon/scenario-pool.mjs     |  35 ++++
 .../suites/tracing/neon/scenario-ws.mjs       |  44 +++++
 .../suites/tracing/neon/test.ts               | 165 ++++++++++++++++++
 .../node-integration-tests/utils/index.ts     |   8 +
 9 files changed, 340 insertions(+)
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/neon/docker-compose.yml
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/neon/instrument.mjs
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/neon/scenario-http.mjs
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/neon/scenario-pool.mjs
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/neon/scenario-ws.mjs
 create mode 100644 dev-packages/node-integration-tests/suites/tracing/neon/test.ts

diff --git a/dev-packages/bun-integration-tests/node-suites/excludes.ts b/dev-packages/bun-integration-tests/node-suites/excludes.ts
index 495ca29dec35..36e00ca5f35c 100644
--- a/dev-packages/bun-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/bun-integration-tests/node-suites/excludes.ts
@@ -120,6 +120,7 @@ export const NO_AUTO_INSTRUMENTATION = [
   'suites/tracing/mysql/test.ts',
   'suites/tracing/mysql2-tracing-channel/test.ts',
   'suites/tracing/mysql2/test.ts',
+  'suites/tracing/neon/test.ts',
   'suites/tracing/openai/test.ts',
   'suites/tracing/openai/v6/test.ts',
   'suites/tracing/openai/v7/test.ts',
diff --git a/dev-packages/node-integration-tests/package.json b/dev-packages/node-integration-tests/package.json
index fa0e94ba095d..d5d4dd9d8f83 100644
--- a/dev-packages/node-integration-tests/package.json
+++ b/dev-packages/node-integration-tests/package.json
@@ -104,9 +104,11 @@
     "rxjs": "^7.8.2",
     "tedious": "^19.2.1",
     "winston": "^3.17.0",
+    "ws": "^8.20.1",
     "yargs": "^16.2.0"
   },
   "devDependencies": {
+    "@neondatabase/serverless": "1.2.0",
     "@opentelemetry/instrumentation-http": "0.220.0",
     "@sentry/conventions": "0.26.0",
     "@sentry-internal/test-utils": "11.6.0",
diff --git a/dev-packages/node-integration-tests/suites/tracing/neon/docker-compose.yml b/dev-packages/node-integration-tests/suites/tracing/neon/docker-compose.yml
new file mode 100644
index 000000000000..49ce9976e3e2
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/neon/docker-compose.yml
@@ -0,0 +1,43 @@
+version: '3.9'
+
+services:
+  db:
+    image: postgres:16
+    restart: always
+    ports:
+      - '5496:5432'
+    environment:
+      POSTGRES_USER: test
+      POSTGRES_PASSWORD: test
+      POSTGRES_DB: tests
+    healthcheck:
+      test: ['CMD-SHELL', 'pg_isready -U test -d tests']
+      interval: 2s
+      timeout: 3s
+      retries: 30
+      start_period: 5s
+
+  # Neon's own proxy binary in front of the local Postgres. It serves the HTTP driver on `/sql`
+  # and the WebSocket driver on `/v2`, both on port 4444, so the scenarios run the real
+  # `@neondatabase/serverless` wire protocols against a throwaway database.
+  neon-proxy:
+    image: ghcr.io/timowilhelm/local-neon-http-proxy:main
+    restart: always
+    ports:
+      - '4494:4444'
+    environment:
+      PG_CONNECTION_STRING: postgres://test:test@db:5432/tests
+    depends_on:
+      db:
+        condition: service_healthy
+    healthcheck:
+      test:
+        [
+          'CMD-SHELL',
+          'curl -sf -X POST http://localhost:4444/sql -H "Neon-Connection-String:
+          postgres://test:test@db.localtest.me:5432/tests" -d ''{"query":"SELECT 1","params":[]}''',
+        ]
+      interval: 2s
+      timeout: 3s
+      retries: 30
+      start_period: 5s
diff --git a/dev-packages/node-integration-tests/suites/tracing/neon/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/neon/instrument.mjs
new file mode 100644
index 000000000000..46a27dd03b74
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/neon/instrument.mjs
@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
diff --git a/dev-packages/node-integration-tests/suites/tracing/neon/scenario-http.mjs b/dev-packages/node-integration-tests/suites/tracing/neon/scenario-http.mjs
new file mode 100644
index 000000000000..80469395a28e
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/neon/scenario-http.mjs
@@ -0,0 +1,33 @@
+import * as Sentry from '@sentry/node';
+import { waitForConnection } from '@sentry-internal/node-integration-tests';
+import { neon, neonConfig } from '@neondatabase/serverless';
+
+neonConfig.fetchEndpoint = 'http://localhost:4494/sql';
+
+// The connection string is never dialed by this process: the drivers only talk to the proxy, which
+// connects to Postgres itself. Host and port here are what the spans report as the server.
+const sql = neon('postgres://test:test@db.localtest.me:5432/tests');
+
+async function run() {
+  await waitForConnection(() => sql`SELECT 1`);
+
+  await Sentry.startSpan({ name: 'Test Span', op: 'test' }, async () => {
+    try {
+      await sql`CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))`;
+
+      await sql.query('INSERT INTO "User" ("email", "name") VALUES ($1, $2)', ['tim@domain.com', 'tim']);
+      await sql`SELECT * FROM "User" WHERE "name" = ${'tim'}`;
+
+      await sql.transaction([sql`SELECT "email" FROM "User"`, sql`SELECT "name" FROM "User"`]);
+
+      // A failing query should still produce an errored span
+      await sql`SELECT * FROM "does_not_exist_table"`.catch(() => {
+        // swallow: we only care about the span it produces
+      });
+    } finally {
+      await sql`DROP TABLE "User"`;
+    }
+  });
+}
+
+run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/neon/scenario-pool.mjs b/dev-packages/node-integration-tests/suites/tracing/neon/scenario-pool.mjs
new file mode 100644
index 000000000000..0562030fe3ce
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/neon/scenario-pool.mjs
@@ -0,0 +1,35 @@
+import * as Sentry from '@sentry/node';
+import { waitForConnection } from '@sentry-internal/node-integration-tests';
+import { Client, Pool, neonConfig } from '@neondatabase/serverless';
+import ws from 'ws';
+
+neonConfig.webSocketConstructor = ws;
+neonConfig.wsProxy = () => 'localhost:4494/v2';
+neonConfig.useSecureWebSocket = false;
+neonConfig.pipelineConnect = false;
+
+// The connection string is never dialed by this process: the drivers only talk to the proxy, which
+// connects to Postgres itself. Host and port here are what the spans report as the server.
+const connectionString = 'postgres://test:test@db.localtest.me:5432/tests';
+
+async function run() {
+  await waitForConnection(async () => {
+    const probe = new Client(connectionString);
+    await probe.connect();
+    await probe.end();
+  });
+
+  const pool = new Pool({ connectionString });
+  await Sentry.startSpan({ name: 'Test Span', op: 'test' }, async () => {
+    try {
+      await pool.query('SELECT "email", "name" FROM pg_catalog.pg_user LIMIT 1').catch(() => {
+        // swallow: pg_user has no "email" column, the span is what matters
+      });
+      await pool.query('SELECT "usename" FROM pg_catalog.pg_user');
+    } finally {
+      await pool.end();
+    }
+  });
+}
+
+run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/neon/scenario-ws.mjs b/dev-packages/node-integration-tests/suites/tracing/neon/scenario-ws.mjs
new file mode 100644
index 000000000000..d4f314de0bc8
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/neon/scenario-ws.mjs
@@ -0,0 +1,44 @@
+import * as Sentry from '@sentry/node';
+import { waitForConnection } from '@sentry-internal/node-integration-tests';
+import { Client, neonConfig } from '@neondatabase/serverless';
+import ws from 'ws';
+
+neonConfig.webSocketConstructor = ws;
+neonConfig.wsProxy = () => 'localhost:4494/v2';
+neonConfig.useSecureWebSocket = false;
+neonConfig.pipelineConnect = false;
+
+// The connection string is never dialed by this process: the drivers only talk to the proxy, which
+// connects to Postgres itself. Host and port here are what the spans report as the server.
+const connectionString = 'postgres://test:test@db.localtest.me:5432/tests';
+const client = new Client(connectionString);
+
+async function run() {
+  await waitForConnection(async () => {
+    const probe = new Client(connectionString);
+    await probe.connect();
+    await probe.end();
+  });
+
+  await Sentry.startSpan({ name: 'Test Span', op: 'test' }, async () => {
+    try {
+      await client.connect();
+
+      await client.query(
+        'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
+      );
+      await client.query('INSERT INTO "User" ("email", "name") VALUES ($1, $2)', ['tim@domain.com', 'tim']);
+      await client.query('SELECT * FROM "User"');
+
+      // A failing query should still produce an errored span
+      await client.query('SELECT * FROM "does_not_exist_table"').catch(() => {
+        // swallow: we only care about the span it produces
+      });
+    } finally {
+      await client.query('DROP TABLE "User"');
+      await client.end();
+    }
+  });
+}
+
+run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/neon/test.ts b/dev-packages/node-integration-tests/suites/tracing/neon/test.ts
new file mode 100644
index 000000000000..e1310a6ff703
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/tracing/neon/test.ts
@@ -0,0 +1,165 @@
+import type { SerializedStreamedSpan } from '@sentry/core';
+import {
+  DB_NAMESPACE,
+  DB_OPERATION_BATCH_SIZE,
+  DB_QUERY_SUMMARY,
+  DB_QUERY_TEXT,
+  DB_SYSTEM_NAME,
+  DB_USER,
+  SENTRY_KIND,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SERVER_ADDRESS,
+  SERVER_PORT,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
+import { afterAll, describe, expect } from 'vitest';
+import { RUNTIME, streamedAttribute as attr } from '../../../utils';
+import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
+
+const ORIGIN = 'auto.db.neon';
+
+const CREATE_USER_TABLE_STATEMENT =
+  'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))';
+
+// Both drivers report the same connection attributes: the WebSocket driver from pg's
+// `connectionParameters`, the HTTP driver from the resolved connection URL.
+const CONNECTION_ATTRIBUTES = {
+  [DB_SYSTEM_NAME]: attr('postgresql'),
+  [DB_NAMESPACE]: attr('tests'),
+  [DB_USER]: attr('test'),
+  [SERVER_ADDRESS]: attr('db.localtest.me'),
+  [SERVER_PORT]: attr(5432, 'integer'),
+};
+
+function expectedDbSpan({
+  name,
+  statement,
+  status = 'ok',
+  batchSize,
+}: {
+  name: string;
+  statement: string;
+  status?: 'ok' | 'error';
+  batchSize?: number;
+}): unknown {
+  return expect.objectContaining({
+    attributes: expect.objectContaining({
+      ...CONNECTION_ATTRIBUTES,
+      [SENTRY_OP]: attr(DB),
+      [SENTRY_KIND]: attr('client'),
+      [SENTRY_ORIGIN]: attr(ORIGIN),
+      [DB_QUERY_TEXT]: attr(statement),
+      [DB_QUERY_SUMMARY]: attr(name),
+      ...(batchSize ? { [DB_OPERATION_BATCH_SIZE]: attr(batchSize, 'integer') } : {}),
+    }),
+    is_segment: false,
+    name,
+    parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    status,
+  });
+}
+
+function getNeonSpans(spans: SerializedStreamedSpan[]): SerializedStreamedSpan[] {
+  const neonSpans = spans.filter(span => span.attributes[SENTRY_ORIGIN]?.value === ORIGIN);
+  // `server.address`/`server.port` describe the connection; the deprecated string is not emitted.
+  expect(neonSpans.some(span => 'db.connection_string' in span.attributes)).toBe(false);
+  return neonSpans;
+}
+
+describeWithDockerCompose('neon auto instrumentation', { workingDirectory: [__dirname] }, () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  describe('http driver', () => {
+    createEsmAndCjsTests(__dirname, 'scenario-http.mjs', 'instrument.mjs', (createTestRunner, test) => {
+      test('instruments `neon()` queries, templates and transactions', { timeout: 90_000 }, async () => {
+        const runner = createTestRunner();
+        const spansPromise = runner.collectStreamedSpansUntilSegment('Test Span');
+
+        await runner.start().completed();
+
+        const spans = await spansPromise;
+        const segment = spans.find(span => span.is_segment && span.name === 'Test Span');
+        expect(segment).toBeDefined();
+
+        const neonSpans = getNeonSpans(spans);
+        expect(neonSpans.every(span => span.parent_span_id === segment!.span_id)).toBe(true);
+        expect(neonSpans).toEqual([
+          expectedDbSpan({ name: 'CREATE TABLE "User"', statement: CREATE_USER_TABLE_STATEMENT }),
+          expectedDbSpan({ name: 'INSERT "User"', statement: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)' }),
+          expectedDbSpan({ name: 'SELECT "User"', statement: 'SELECT * FROM "User" WHERE "name" = $1' }),
+          expectedDbSpan({
+            name: 'SELECT "User"; SELECT "User"',
+            statement: 'SELECT "email" FROM "User"; SELECT "name" FROM "User"',
+            batchSize: 2,
+          }),
+          expectedDbSpan({
+            name: 'SELECT "does_not_exist_table"',
+            statement: 'SELECT * FROM "does_not_exist_table"',
+            status: 'error',
+          }),
+          expectedDbSpan({ name: 'DROP TABLE "User"', statement: 'DROP TABLE "User"' }),
+        ]);
+      });
+    });
+  });
+
+  describe('websocket driver', () => {
+    createEsmAndCjsTests(__dirname, 'scenario-ws.mjs', 'instrument.mjs', (createTestRunner, test) => {
+      test('instruments `Client` queries', { timeout: 90_000 }, async () => {
+        const runner = createTestRunner();
+        const spansPromise = runner.collectStreamedSpansUntilSegment('Test Span');
+
+        await runner.start().completed();
+
+        const spans = await spansPromise;
+        const segment = spans.find(span => span.is_segment && span.name === 'Test Span');
+        expect(segment).toBeDefined();
+
+        const neonSpans = getNeonSpans(spans);
+        expect(neonSpans.every(span => span.parent_span_id === segment!.span_id)).toBe(true);
+        expect(neonSpans).toEqual([
+          expectedDbSpan({ name: 'CREATE TABLE "User"', statement: CREATE_USER_TABLE_STATEMENT }),
+          expectedDbSpan({ name: 'INSERT "User"', statement: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)' }),
+          expectedDbSpan({ name: 'SELECT "User"', statement: 'SELECT * FROM "User"' }),
+          expectedDbSpan({
+            name: 'SELECT "does_not_exist_table"',
+            statement: 'SELECT * FROM "does_not_exist_table"',
+            status: 'error',
+          }),
+          expectedDbSpan({ name: 'DROP TABLE "User"', statement: 'DROP TABLE "User"' }),
+        ]);
+      });
+    });
+  });
+
+  describe('websocket pool', () => {
+    createEsmAndCjsTests(__dirname, 'scenario-pool.mjs', 'instrument.mjs', (createTestRunner, test) => {
+      // On Bun and Deno the pool's connect callback runs outside the segment's async context, so
+      // the queries it issues have no parent span.
+      test.skipIf(RUNTIME !== 'node')('instruments `Pool` queries', { timeout: 90_000 }, async () => {
+        const runner = createTestRunner();
+        const spansPromise = runner.collectStreamedSpansUntilSegment('Test Span');
+
+        await runner.start().completed();
+
+        const spans = await spansPromise;
+        const segment = spans.find(span => span.is_segment && span.name === 'Test Span');
+        expect(segment).toBeDefined();
+
+        const neonSpans = getNeonSpans(spans);
+        expect(neonSpans.every(span => span.parent_span_id === segment!.span_id)).toBe(true);
+        expect(neonSpans).toEqual([
+          expectedDbSpan({
+            name: 'SELECT pg_catalog.pg_user',
+            statement: 'SELECT "email", "name" FROM pg_catalog.pg_user LIMIT ?',
+            status: 'error',
+          }),
+          expectedDbSpan({ name: 'SELECT pg_catalog.pg_user', statement: 'SELECT "usename" FROM pg_catalog.pg_user' }),
+        ]);
+      });
+    });
+  });
+});
diff --git a/dev-packages/node-integration-tests/utils/index.ts b/dev-packages/node-integration-tests/utils/index.ts
index 21fdff8fe8a8..0849c4464bfc 100644
--- a/dev-packages/node-integration-tests/utils/index.ts
+++ b/dev-packages/node-integration-tests/utils/index.ts
@@ -98,3 +98,11 @@ export const parseEnvelope = (body: string): Array<Record<string, unknown>> => {
 export function getStringAttributeValue(value: unknown): string | undefined {
   return typeof value === 'string' ? value : undefined;
 }
+
+/**
+ * A serialized streamed-span attribute (`{ type, value }`), for strict `toEqual` assertions on
+ * `attributes` of a streamed span. Defaults to a string attribute.
+ */
+export function streamedAttribute(value: unknown, type = 'string'): { type: string; value: unknown } {
+  return { type, value };
+}

From 4132a3491ee9b40c13264458f42ccf24d4c0c410 Mon Sep 17 00:00:00 2001
From: Charly Gomez <charly.gomez1310@gmail.com>
Date: Fri, 9 Oct 2026 12:45:41 +0200
Subject: [PATCH 23/84] fix(nuxt): Remove @opentelemetry/resources dev alias
 (#25216)

In dev mode the Nuxt module aliased `@opentelemetry/resources` to
`@opentelemetry/resources/build/src/index.js`. Nuxt writes every alias
into the `paths` of the generated `.nuxt/tsconfig.*.json` files. Those
configs have no `baseUrl`, so with `typescript: { typeCheck: true }`
vue-tsc fails with TS5090 ("Non-relative paths are not allowed when
'baseUrl' is not set").

The alias was a workaround for incomplete ESM imports in
`@opentelemetry/resources` (#15204). In v11 nothing in the Nuxt SDK's
dependency tree uses that package anymore, so the alias can be removed
instead of rewritten.

Fixes #25188

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 packages/nuxt/src/module.ts           |  4 +-
 packages/nuxt/src/vite/utils.ts       | 24 ---------
 packages/nuxt/test/vite/utils.test.ts | 70 ---------------------------
 3 files changed, 1 insertion(+), 97 deletions(-)

diff --git a/packages/nuxt/src/module.ts b/packages/nuxt/src/module.ts
index f1cd456b84c6..10f22891ac2d 100644
--- a/packages/nuxt/src/module.ts
+++ b/packages/nuxt/src/module.ts
@@ -7,7 +7,7 @@ import type { SentryNuxtModuleOptions } from './common/types';
 import { setupNitroServer } from './vite/nitroServer';
 import { setupOrchestrion } from './vite/orchestrion';
 import { setupSourceMaps } from './vite/sourceMaps';
-import { addOTelCommonJSImportAlias, findDefaultSdkInitFile, resolveServerApi } from './vite/utils';
+import { findDefaultSdkInitFile, resolveServerApi } from './vite/utils';
 
 export type ModuleOptions = SentryNuxtModuleOptions;
 type NuxtPageSubset = { file?: string; path: string };
@@ -97,8 +97,6 @@ export default defineNuxtModule<ModuleOptions>({
       setupSourceMaps(moduleOptions, nuxt, addVitePlugin);
     }
 
-    addOTelCommonJSImportAlias(nuxt, serverApi === 'nitro3');
-
     let pagesData: NuxtPageSubset[] = [];
 
     nuxt.hooks.hook('pages:extend', pages => {
diff --git a/packages/nuxt/src/vite/utils.ts b/packages/nuxt/src/vite/utils.ts
index cab39bc95f19..fc393242b682 100644
--- a/packages/nuxt/src/vite/utils.ts
+++ b/packages/nuxt/src/vite/utils.ts
@@ -224,27 +224,3 @@ export function toResolvablePath(source: string): { path: string; wasFileUrl: bo
     return undefined;
   }
 }
-
-/**
- * Sets up alias to work around OpenTelemetry's incomplete ESM imports.
- * https://github.com/getsentry/sentry-javascript/issues/15204
- *
- * OpenTelemetry's @opentelemetry/resources package has incomplete imports missing
- * the .js file extensions (like execAsync for machine-id detection). This causes module resolution
- * errors in certain Nuxt configurations, particularly when local Nuxt modules in Nuxt 4 are present.
- *
- * @see https://nuxt.com/docs/guide/concepts/esm#aliasing-libraries
- */
-export function addOTelCommonJSImportAlias(nuxt: Nuxt, isNitroV3 = false): void {
-  if (!nuxt.options.dev || isNitroV3) {
-    return;
-  }
-
-  if (!nuxt.options.alias) {
-    nuxt.options.alias = {};
-  }
-
-  if (!nuxt.options.alias['@opentelemetry/resources']) {
-    nuxt.options.alias['@opentelemetry/resources'] = '@opentelemetry/resources/build/src/index.js';
-  }
-}
diff --git a/packages/nuxt/test/vite/utils.test.ts b/packages/nuxt/test/vite/utils.test.ts
index 605bf368ca9c..7d1213fdc959 100644
--- a/packages/nuxt/test/vite/utils.test.ts
+++ b/packages/nuxt/test/vite/utils.test.ts
@@ -3,7 +3,6 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import {
-  addOTelCommonJSImportAlias,
   constructFunctionReExport,
   constructWrappedFunctionExportQuery,
   extractFunctionReexportQueryParameters,
@@ -428,72 +427,3 @@ export { foo_sentryWrapped as foo };
     expect(result).toBe('');
   });
 });
-
-describe('addOTelCommonJSImportAlias', () => {
-  it('adds alias for @opentelemetry/resources when options.alias does not exist', () => {
-    const nuxtMock: Nuxt = {
-      options: { dev: true },
-    } as unknown as Nuxt;
-
-    addOTelCommonJSImportAlias(nuxtMock);
-
-    expect(nuxtMock.options.alias).toEqual({
-      '@opentelemetry/resources': '@opentelemetry/resources/build/src/index.js',
-    });
-  });
-
-  it('adds alias for @opentelemetry/resources when options.alias already exists', () => {
-    const nuxtMock: Nuxt = {
-      options: {
-        dev: true,
-        alias: {
-          'existing-alias': 'some-path',
-        },
-      },
-    } as unknown as Nuxt;
-
-    addOTelCommonJSImportAlias(nuxtMock);
-
-    expect(nuxtMock.options.alias).toEqual({
-      'existing-alias': 'some-path',
-      '@opentelemetry/resources': '@opentelemetry/resources/build/src/index.js',
-    });
-  });
-
-  it('does not override existing alias for @opentelemetry/resources', () => {
-    const nuxtMock: Nuxt = {
-      options: {
-        dev: true,
-        alias: {
-          '@opentelemetry/resources': 'some-other-path',
-        },
-      },
-    } as unknown as Nuxt;
-
-    addOTelCommonJSImportAlias(nuxtMock);
-
-    expect(nuxtMock.options.alias).toEqual({
-      '@opentelemetry/resources': 'some-other-path',
-    });
-  });
-
-  it('does not add alias when not development mode', () => {
-    const nuxtMock: Nuxt = {
-      options: {},
-    } as unknown as Nuxt;
-
-    addOTelCommonJSImportAlias(nuxtMock);
-
-    expect(nuxtMock.options.alias).toBeUndefined();
-  });
-
-  it('does not add alias when in Nitro v3+ (Rolldown incompatibility)', () => {
-    const nuxtMock: Nuxt = {
-      options: { dev: true },
-    } as unknown as Nuxt;
-
-    addOTelCommonJSImportAlias(nuxtMock, true);
-
-    expect(nuxtMock.options.alias).toBeUndefined();
-  });
-});

From 19185a133e35907178be26ee4a6be94fd961a1f4 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Fri, 9 Oct 2026 12:50:58 +0200
Subject: [PATCH 24/84] fix(core): Report actual item count in client reports
 of envelope send failures (#25185)

When sending an envelope fails (network error, 413, or a full buffer),
the transport recorded every item with quantity 1. This undercounts
span, log and metric discard quantities. Same for transactions that
[should
also](https://develop.sentry.dev/sdk/telemetry/client-reports/#span-outcomes)
report `span` counts. Containers now report their `item_count`, and
transactions also report `spans.length + 1` `span` outcomes, matching
how the client counts dropped transactions in `beforeSend`.

For transactions, we also record `span` outcomes on envelope send
failures, analogously to what
https://github.com/getsentry/sentry-javascript/pull/25006 adds to other
discard reasons

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 packages/core/src/transports/base.ts          | 21 ++++-
 .../core/test/lib/transports/base.test.ts     | 91 +++++++++++++++----
 2 files changed, 87 insertions(+), 25 deletions(-)

diff --git a/packages/core/src/transports/base.ts b/packages/core/src/transports/base.ts
index 45553115fa64..86c52037d6f7 100644
--- a/packages/core/src/transports/base.ts
+++ b/packages/core/src/transports/base.ts
@@ -1,6 +1,7 @@
 import { DEBUG_BUILD } from '../debug-build';
 import type { EventDropReason } from '../types/clientreport';
-import type { Envelope, EnvelopeItem } from '../types/envelope';
+import type { Envelope, EnvelopeItem, EnvelopeItemType } from '../types/envelope';
+import type { Event } from '../types/event';
 import type {
   InternalBaseTransportOptions,
   Transport,
@@ -36,14 +37,24 @@ export function createTransport(
   let rateLimits: RateLimits = {};
   const flush = (timeout?: number): PromiseLike<boolean> => buffer.drain(timeout);
 
+  function recordItemLoss(reason: EventDropReason, [headers, payload]: EnvelopeItem, type: EnvelopeItemType): void {
+    const dataCategory = envelopeItemTypeToDataCategory(type);
+    if (type === 'transaction') {
+      options.recordDroppedEvent(reason, dataCategory);
+      // The transaction itself counts as a span, too
+      options.recordDroppedEvent(reason, 'span', ((payload as Event).spans?.length ?? 0) + 1);
+    } else {
+      options.recordDroppedEvent(reason, dataCategory, typeof headers.item_count === 'number' ? headers.item_count : 1);
+    }
+  }
+
   function send(envelope: Envelope): PromiseLike<TransportMakeRequestResponse> {
     const filteredEnvelopeItems: EnvelopeItem[] = [];
 
     // Drop rate limited items from envelope
     forEachEnvelopeItem(envelope, (item, type) => {
-      const dataCategory = envelopeItemTypeToDataCategory(type);
-      if (isRateLimited(rateLimits, dataCategory)) {
-        options.recordDroppedEvent('ratelimit_backoff', dataCategory);
+      if (isRateLimited(rateLimits, envelopeItemTypeToDataCategory(type))) {
+        recordItemLoss('ratelimit_backoff', item, type);
       } else {
         filteredEnvelopeItems.push(item);
       }
@@ -64,7 +75,7 @@ export function createTransport(
         return;
       }
       forEachEnvelopeItem(filteredEnvelope, (item, type) => {
-        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));
+        recordItemLoss(reason, item, type);
       });
     };
 
diff --git a/packages/core/test/lib/transports/base.test.ts b/packages/core/test/lib/transports/base.test.ts
index 9a2d53582686..9a2a0ef6275b 100644
--- a/packages/core/test/lib/transports/base.test.ts
+++ b/packages/core/test/lib/transports/base.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 import { createTransport } from '../../../src/transports/base';
 import type { ClientReport } from '../../../src/types/clientreport';
-import type { AttachmentItem, EventEnvelope, EventItem } from '../../../src/types/envelope';
+import type { AttachmentItem, Envelope, EventEnvelope, EventItem } from '../../../src/types/envelope';
 import type { TransportMakeRequestResponse } from '../../../src/types/transport';
 import { createClientReportEnvelope } from '../../../src/utils/clientreport';
 import { createEnvelope, serializeEnvelope } from '../../../src/utils/envelope';
@@ -157,7 +157,7 @@ describe('createTransport', () => {
 
         await transport.send(ERROR_ENVELOPE);
         expect(requestExecutor).not.toHaveBeenCalled();
-        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'error');
+        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'error', 1);
         requestExecutor.mockClear();
         recordDroppedEventCallback.mockClear();
 
@@ -199,7 +199,7 @@ describe('createTransport', () => {
 
         await transport.send(ERROR_ENVELOPE); // Error envelope should not be sent because of pending rate limit
         expect(requestExecutor).not.toHaveBeenCalled();
-        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'error');
+        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'error', 1);
         requestExecutor.mockClear();
         recordDroppedEventCallback.mockClear();
 
@@ -242,18 +242,19 @@ describe('createTransport', () => {
         await transport.send(TRANSACTION_ENVELOPE); // Transaction envelope should not be sent because of pending rate limit
         expect(requestExecutor).not.toHaveBeenCalled();
         expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'transaction');
+        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'span', 1);
         requestExecutor.mockClear();
         recordDroppedEventCallback.mockClear();
 
         await transport.send(ERROR_ENVELOPE); // Error envelope should not be sent because of pending rate limit
         expect(requestExecutor).not.toHaveBeenCalled();
-        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'error');
+        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'error', 1);
         requestExecutor.mockClear();
         recordDroppedEventCallback.mockClear();
 
         await transport.send(ATTACHMENT_ENVELOPE); // Attachment envelope should not be sent because of pending rate limit
         expect(requestExecutor).not.toHaveBeenCalled();
-        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'attachment');
+        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'attachment', 1);
         requestExecutor.mockClear();
         recordDroppedEventCallback.mockClear();
 
@@ -302,12 +303,13 @@ describe('createTransport', () => {
         await transport.send(TRANSACTION_ENVELOPE); // Transaction envelope should not be sent because of pending rate limit
         expect(requestExecutor).not.toHaveBeenCalled();
         expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'transaction');
+        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'span', 1);
         requestExecutor.mockClear();
         recordDroppedEventCallback.mockClear();
 
         await transport.send(ERROR_ENVELOPE); // Error envelope should not be sent because of pending rate limit
         expect(requestExecutor).not.toHaveBeenCalled();
-        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'error');
+        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'error', 1);
         requestExecutor.mockClear();
         recordDroppedEventCallback.mockClear();
 
@@ -324,10 +326,35 @@ describe('createTransport', () => {
         expect(requestExecutor).toHaveBeenCalledTimes(1);
         expect(recordDroppedEventCallback).not.toHaveBeenCalled();
       });
+
+      it('records the item count of rate limited container items', async () => {
+        const { retryAfterSeconds, beforeLimit, withinLimit } = setRateLimitTimes();
+        const [transport, , requestExecutor, recordDroppedEventCallback] = createTestTransport({
+          headers: {
+            'x-sentry-rate-limits': `${retryAfterSeconds}:log_item:scope`,
+            'retry-after': null,
+          },
+        });
+
+        const dateNowSpy = vi.spyOn(Date, 'now').mockImplementation(() => beforeLimit);
+
+        await transport.send(ERROR_ENVELOPE);
+        requestExecutor.mockClear();
+
+        dateNowSpy.mockImplementation(() => withinLimit);
+
+        await transport.send(
+          createEnvelope<Envelope>({ sent_at: '123' }, [
+            [{ type: 'log', item_count: 3, content_type: 'application/vnd.sentry.items.log+json' }, { items: [] }],
+          ] as Envelope[1]),
+        );
+        expect(requestExecutor).not.toHaveBeenCalled();
+        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'log_item', 3);
+      });
     });
 
     describe('Client Reports', () => {
-      it('should not record outcomes when client reports fail to send', async () => {
+      it('does not record outcomes when client reports fail to send', async () => {
         expect.assertions(2);
 
         const mockRecordDroppedEventCallback = vi.fn();
@@ -347,7 +374,7 @@ describe('createTransport', () => {
         expect(mockRecordDroppedEventCallback).not.toHaveBeenCalled();
       });
 
-      it('should not record outcomes when client reports fail due to buffer overflow', async () => {
+      it('does not record outcomes when client reports fail due to buffer overflow', async () => {
         expect.assertions(2);
 
         const mockRecordDroppedEventCallback = vi.fn();
@@ -371,7 +398,7 @@ describe('createTransport', () => {
         expect(mockRecordDroppedEventCallback).not.toHaveBeenCalled();
       });
 
-      it('should record outcomes when regular events fail to send', async () => {
+      it('records outcomes when regular events fail to send', async () => {
         expect.assertions(2);
 
         const mockRecordDroppedEventCallback = vi.fn();
@@ -388,12 +415,12 @@ describe('createTransport', () => {
         }
 
         // recordDroppedEvent SHOULD be called for regular events
-        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('network_error', 'error');
+        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('network_error', 'error', 1);
       });
     });
 
     describe('HTTP 413 Content Too Large', () => {
-      it('should record send_error outcome when receiving 413 response', async () => {
+      it('records send_error outcome when receiving 413 response', async () => {
         const mockRecordDroppedEventCallback = vi.fn();
 
         const transport = createTransport({ recordDroppedEvent: mockRecordDroppedEventCallback }, () =>
@@ -405,17 +432,17 @@ describe('createTransport', () => {
         // Should resolve without throwing
         expect(result).toEqual({ statusCode: 413 });
         // recordDroppedEvent SHOULD be called with send_error reason
-        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'error');
+        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'error', 1);
       });
 
-      it('should record send_error for each item in envelope when receiving 413', async () => {
+      it('records send_error for each item in envelope when receiving 413', async () => {
         const mockRecordDroppedEventCallback = vi.fn();
 
         const multiItemEnvelope = createEnvelope<EventEnvelope>(
           { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2', sent_at: '123' },
           [
             [{ type: 'event' }, { event_id: 'aa3ff046696b4bc6b609ce6d28fde9e2' }] as EventItem,
-            [{ type: 'transaction' }, { event_id: 'bb3ff046696b4bc6b609ce6d28fde9e2' }] as EventItem,
+            [{ type: 'transaction' }, { event_id: 'bb3ff046696b4bc6b609ce6d28fde9e2', spans: [{}, {}] }] as EventItem,
           ],
         );
 
@@ -425,13 +452,37 @@ describe('createTransport', () => {
 
         await transport.send(multiItemEnvelope);
 
-        // recordDroppedEvent SHOULD be called for each item
-        expect(mockRecordDroppedEventCallback).toHaveBeenCalledTimes(2);
-        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'error');
+        expect(mockRecordDroppedEventCallback).toHaveBeenCalledTimes(3);
+        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'error', 1);
         expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'transaction');
+        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'span', 3);
+      });
+
+      it('records send_error with the item count of container items when receiving 413', async () => {
+        const mockRecordDroppedEventCallback = vi.fn();
+
+        const containerEnvelope = createEnvelope<Envelope>({ sent_at: '123' }, [
+          [{ type: 'span', item_count: 5, content_type: 'application/vnd.sentry.items.span.v2+json' }, { items: [] }],
+          [{ type: 'log', item_count: 3, content_type: 'application/vnd.sentry.items.log+json' }, { items: [] }],
+          [
+            { type: 'trace_metric', item_count: 2, content_type: 'application/vnd.sentry.items.trace-metric+json' },
+            { items: [] },
+          ],
+        ] as Envelope[1]);
+
+        const transport = createTransport({ recordDroppedEvent: mockRecordDroppedEventCallback }, () =>
+          resolvedSyncPromise({ statusCode: 413 }),
+        );
+
+        await transport.send(containerEnvelope);
+
+        expect(mockRecordDroppedEventCallback).toHaveBeenCalledTimes(3);
+        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'span', 5);
+        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'log_item', 3);
+        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'metric', 2);
       });
 
-      it('should not record outcomes for client reports when receiving 413', async () => {
+      it('does not record outcomes for client reports when receiving 413', async () => {
         const mockRecordDroppedEventCallback = vi.fn();
 
         const transport = createTransport({ recordDroppedEvent: mockRecordDroppedEventCallback }, () =>
@@ -446,7 +497,7 @@ describe('createTransport', () => {
         expect(mockRecordDroppedEventCallback).not.toHaveBeenCalled();
       });
 
-      it('should not apply rate limits after receiving 413', async () => {
+      it('does not apply rate limits after receiving 413', async () => {
         const mockRecordDroppedEventCallback = vi.fn();
         const mockRequestExecutor = vi.fn(() => resolvedSyncPromise({ statusCode: 413 }));
 
@@ -455,7 +506,7 @@ describe('createTransport', () => {
         // First request gets 413
         await transport.send(ERROR_ENVELOPE);
         expect(mockRequestExecutor).toHaveBeenCalledTimes(1);
-        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'error');
+        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'error', 1);
         mockRequestExecutor.mockClear();
         mockRecordDroppedEventCallback.mockClear();
 

From cae4c95f5beac502b38aab12435276195658d6f2 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 12:53:21 +0200
Subject: [PATCH 25/84] test(node): Use default streaming in scope and span
 suites (#25222)

Exercise scope and span suites with the default streaming lifecycle.

Part of #24140

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../node-suites/excludes.ts                      | 16 ++++++++--------
 .../node-suites/excludes.ts                      |  6 +++---
 .../{context-streamed => context}/scenario.ts    |  1 -
 .../scope-contexts/scenario.ts                   |  1 -
 .../scope-contexts/test.ts                       |  0
 .../suites/{context-streamed => context}/test.ts |  0
 .../scenario.ts                                  |  0
 .../test.ts                                      |  0
 .../public-api/scopes/initialScopes/scenario.ts  |  1 -
 .../public-api/scopes/isolationScope/scenario.ts |  1 -
 .../attributes/instrument.mjs                    |  1 -
 .../attributes/server.mjs                        |  0
 .../attributes/test.ts                           |  2 +-
 .../children/instrument.mjs                      |  1 -
 .../children/server.mjs                          |  0
 .../children/test.ts                             |  2 +-
 .../continued-trace-child/instrument.mjs         |  1 -
 .../continued-trace-child/server.mjs             |  0
 .../continued-trace-child/test.ts                |  2 +-
 .../continued-trace-http-client/instrument.mjs   |  1 -
 .../continued-trace-http-client/server.mjs       |  0
 .../continued-trace-http-client/test.ts          |  2 +-
 .../continued-trace-segment/instrument.mjs       |  1 -
 .../continued-trace-segment/server.mjs           |  0
 .../continued-trace-segment/test.ts              |  2 +-
 .../segments/instrument.mjs                      |  1 -
 .../segments/server.mjs                          |  0
 .../segments/test.ts                             |  2 +-
 .../instrument.mjs                               |  1 -
 .../{sampling-streamed => sampling}/server.mjs   |  0
 .../{sampling-streamed => sampling}/test.ts      |  2 +-
 31 files changed, 18 insertions(+), 29 deletions(-)
 rename dev-packages/node-integration-tests/suites/{context-streamed => context}/scenario.ts (92%)
 rename dev-packages/node-integration-tests/suites/{context-streamed => context}/scope-contexts/scenario.ts (96%)
 rename dev-packages/node-integration-tests/suites/{context-streamed => context}/scope-contexts/test.ts (100%)
 rename dev-packages/node-integration-tests/suites/{context-streamed => context}/test.ts (100%)
 rename dev-packages/node-integration-tests/suites/public-api/{beforeSendSpan-streamed => beforeSendSpan}/scenario.ts (100%)
 rename dev-packages/node-integration-tests/suites/public-api/{beforeSendSpan-streamed => beforeSendSpan}/test.ts (100%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/attributes/instrument.mjs (92%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/attributes/server.mjs (100%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/attributes/test.ts (94%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/children/instrument.mjs (92%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/children/server.mjs (100%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/children/test.ts (97%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-child/instrument.mjs (92%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-child/server.mjs (100%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-child/test.ts (96%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-http-client/instrument.mjs (93%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-http-client/server.mjs (100%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-http-client/test.ts (98%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-segment/instrument.mjs (92%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-segment/server.mjs (100%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-segment/test.ts (96%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/segments/instrument.mjs (92%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/segments/server.mjs (100%)
 rename dev-packages/node-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/segments/test.ts (95%)
 rename dev-packages/node-integration-tests/suites/tracing/{sampling-streamed => sampling}/instrument.mjs (95%)
 rename dev-packages/node-integration-tests/suites/tracing/{sampling-streamed => sampling}/server.mjs (100%)
 rename dev-packages/node-integration-tests/suites/tracing/{sampling-streamed => sampling}/test.ts (97%)

diff --git a/dev-packages/bun-integration-tests/node-suites/excludes.ts b/dev-packages/bun-integration-tests/node-suites/excludes.ts
index 36e00ca5f35c..7eea10e62c6f 100644
--- a/dev-packages/bun-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/bun-integration-tests/node-suites/excludes.ts
@@ -22,14 +22,14 @@ const NO_HTTP_SERVER_SPANS = [
   'suites/tracing/httpIntegration-streamed/test.ts',
   'suites/tracing/httpIntegration/test.ts',
   'suites/tracing/httpServerSpans-unrouted/test.ts',
-  'suites/tracing/ignoreSpans-streamed/**',
+  'suites/tracing/ignoreSpans/**',
   'suites/tracing/meta-tags-twp-errors/test.ts',
   'suites/tracing/meta-tags/test.ts',
   'suites/tracing/requestData/test.ts',
   'suites/tracing/sample-rand-propagation/test.ts',
   'suites/tracing/sample-rate-propagation/**',
   'suites/tracing/sampling-static/test.ts',
-  'suites/tracing/sampling-streamed/test.ts',
+  'suites/tracing/sampling/test.ts',
   'suites/tracing/traceid-recycling-with-spans/test.ts',
   'suites/tracing/traceid-recycling/test.ts',
 ];
@@ -171,7 +171,7 @@ const FETCH_INTEGRATION_DIFFERS = [
   'suites/tracing/http-client-spans/fetch-basic/test.ts',
   'suites/tracing/http-client-spans/fetch-error/test.ts',
   'suites/tracing/http-client-spans/fetch-strip-query/test.ts',
-  'suites/tracing/ignoreSpans-streamed/continued-trace-http-client/test.ts',
+  'suites/tracing/ignoreSpans/continued-trace-http-client/test.ts',
   'suites/tracing/requests/fetch-breadcrumbs/test.ts',
   'suites/tracing/requests/fetch-sampled-no-active-span/test.ts',
 ];
@@ -195,11 +195,11 @@ const NO_EXPRESS_INSTRUMENTATION = [
   'suites/sessions/crashed-session-aggregate/test.ts',
   'suites/sessions/errored-session-aggregate/test.ts',
   'suites/tracing/httpIntegration-streamed/test.ts',
-  'suites/tracing/ignoreSpans-streamed/attributes/test.ts',
-  'suites/tracing/ignoreSpans-streamed/children/test.ts',
-  'suites/tracing/ignoreSpans-streamed/continued-trace-child/test.ts',
-  'suites/tracing/ignoreSpans-streamed/segments/test.ts',
-  'suites/tracing/sampling-streamed/test.ts',
+  'suites/tracing/ignoreSpans/attributes/test.ts',
+  'suites/tracing/ignoreSpans/children/test.ts',
+  'suites/tracing/ignoreSpans/continued-trace-child/test.ts',
+  'suites/tracing/ignoreSpans/segments/test.ts',
+  'suites/tracing/sampling/test.ts',
   'suites/tracing/traceid-recycling-with-spans/test.ts',
 ];
 
diff --git a/dev-packages/deno-integration-tests/node-suites/excludes.ts b/dev-packages/deno-integration-tests/node-suites/excludes.ts
index e5ec281a7a52..14205893d332 100644
--- a/dev-packages/deno-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/deno-integration-tests/node-suites/excludes.ts
@@ -16,9 +16,9 @@ const NO_FETCH_INSTRUMENTATION = [
   'suites/tracing/http-client-spans/fetch-forward-request-hook/test.ts',
   'suites/tracing/http-client-spans/fetch-headers-to-span-attributes/test.ts',
   'suites/tracing/http-client-spans/fetch-strip-query/test.ts',
-  'suites/tracing/ignoreSpans-streamed/continued-trace-child/test.ts',
-  'suites/tracing/ignoreSpans-streamed/continued-trace-http-client/test.ts',
-  'suites/tracing/ignoreSpans-streamed/continued-trace-segment/test.ts',
+  'suites/tracing/ignoreSpans/continued-trace-child/test.ts',
+  'suites/tracing/ignoreSpans/continued-trace-http-client/test.ts',
+  'suites/tracing/ignoreSpans/continued-trace-segment/test.ts',
   'suites/tracing/no-parent-span-client-report/test.ts',
   'suites/tracing/requests/fetch-breadcrumbs/test.ts',
   'suites/tracing/requests/fetch-no-trace-propagation/test.ts',
diff --git a/dev-packages/node-integration-tests/suites/context-streamed/scenario.ts b/dev-packages/node-integration-tests/suites/context/scenario.ts
similarity index 92%
rename from dev-packages/node-integration-tests/suites/context-streamed/scenario.ts
rename to dev-packages/node-integration-tests/suites/context/scenario.ts
index 7f1b5ddd053f..4eb6adf001a0 100644
--- a/dev-packages/node-integration-tests/suites/context-streamed/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/context/scenario.ts
@@ -4,7 +4,6 @@ import { loggingTransport } from '@sentry-internal/node-integration-tests';
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1.0,
-  traceLifecycle: 'stream',
   transport: loggingTransport,
 });
 
diff --git a/dev-packages/node-integration-tests/suites/context-streamed/scope-contexts/scenario.ts b/dev-packages/node-integration-tests/suites/context/scope-contexts/scenario.ts
similarity index 96%
rename from dev-packages/node-integration-tests/suites/context-streamed/scope-contexts/scenario.ts
rename to dev-packages/node-integration-tests/suites/context/scope-contexts/scenario.ts
index f29857444e4d..6e2e0c7cd341 100644
--- a/dev-packages/node-integration-tests/suites/context-streamed/scope-contexts/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/context/scope-contexts/scenario.ts
@@ -4,7 +4,6 @@ import { loggingTransport } from '@sentry-internal/node-integration-tests';
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1.0,
-  traceLifecycle: 'stream',
   transport: loggingTransport,
 });
 
diff --git a/dev-packages/node-integration-tests/suites/context-streamed/scope-contexts/test.ts b/dev-packages/node-integration-tests/suites/context/scope-contexts/test.ts
similarity index 100%
rename from dev-packages/node-integration-tests/suites/context-streamed/scope-contexts/test.ts
rename to dev-packages/node-integration-tests/suites/context/scope-contexts/test.ts
diff --git a/dev-packages/node-integration-tests/suites/context-streamed/test.ts b/dev-packages/node-integration-tests/suites/context/test.ts
similarity index 100%
rename from dev-packages/node-integration-tests/suites/context-streamed/test.ts
rename to dev-packages/node-integration-tests/suites/context/test.ts
diff --git a/dev-packages/node-integration-tests/suites/public-api/beforeSendSpan-streamed/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/beforeSendSpan/scenario.ts
similarity index 100%
rename from dev-packages/node-integration-tests/suites/public-api/beforeSendSpan-streamed/scenario.ts
rename to dev-packages/node-integration-tests/suites/public-api/beforeSendSpan/scenario.ts
diff --git a/dev-packages/node-integration-tests/suites/public-api/beforeSendSpan-streamed/test.ts b/dev-packages/node-integration-tests/suites/public-api/beforeSendSpan/test.ts
similarity index 100%
rename from dev-packages/node-integration-tests/suites/public-api/beforeSendSpan-streamed/test.ts
rename to dev-packages/node-integration-tests/suites/public-api/beforeSendSpan/test.ts
diff --git a/dev-packages/node-integration-tests/suites/public-api/scopes/initialScopes/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/scopes/initialScopes/scenario.ts
index 4a4327c15b3a..f9245b584256 100644
--- a/dev-packages/node-integration-tests/suites/public-api/scopes/initialScopes/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/scopes/initialScopes/scenario.ts
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   transport: loggingTransport,
diff --git a/dev-packages/node-integration-tests/suites/public-api/scopes/isolationScope/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/scopes/isolationScope/scenario.ts
index 1e0e81cf58cb..b527d14699cc 100644
--- a/dev-packages/node-integration-tests/suites/public-api/scopes/isolationScope/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/scopes/isolationScope/scenario.ts
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   transport: loggingTransport,
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/attributes/instrument.mjs
similarity index 92%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/instrument.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/attributes/instrument.mjs
index 31da3f1dacfb..0db17515dbba 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/attributes/instrument.mjs
@@ -6,7 +6,6 @@ Sentry.init({
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
   ignoreSpans: [{ attributes: { 'http.request.method': 'POST' } }],
   clientReportFlushInterval: 1_000,
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/server.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/attributes/server.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/server.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/attributes/server.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/test.ts b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/attributes/test.ts
similarity index 94%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/test.ts
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/attributes/test.ts
index 22eac608d616..dbc23242a06b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/attributes/test.ts
@@ -1,7 +1,7 @@
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
 
-describe('filtering segment spans by attribute with ignoreSpans (streaming)', () => {
+describe('filtering segment spans by attribute with ignoreSpans', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/children/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/children/instrument.mjs
similarity index 92%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/children/instrument.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/children/instrument.mjs
index 266ffdc4f52c..4e6a4d0677c9 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/children/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/children/instrument.mjs
@@ -6,7 +6,6 @@ Sentry.init({
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
   ignoreSpans: ['expressInit', /custom-to-drop/, { op: 'ignored-op' }],
   clientReportFlushInterval: 1_000,
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/children/server.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/children/server.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/children/server.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/children/server.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/children/test.ts b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/children/test.ts
similarity index 97%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/children/test.ts
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/children/test.ts
index fefa45353102..03bac0660313 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/children/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/children/test.ts
@@ -2,7 +2,7 @@ import { SENTRY_OP } from '@sentry/conventions/attributes';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
 
-describe('filtering child spans with ignoreSpans (streaming)', () => {
+describe('filtering child spans with ignoreSpans', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/instrument.mjs
similarity index 92%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/instrument.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/instrument.mjs
index 75d3d12bc730..ca7f173be631 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/instrument.mjs
@@ -5,7 +5,6 @@ Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
   ignoreSpans: ['ignoredMiddleware'],
   tracePropagationTargets: [process.env.SERVER_URL],
   clientReportFlushInterval: 1_000,
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/server.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/server.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/server.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/server.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/test.ts b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/test.ts
similarity index 96%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/test.ts
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/test.ts
index a9c5574810d5..2f04092502b5 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/test.ts
@@ -3,7 +3,7 @@ import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
 import { SENTRY_OP } from '@sentry/conventions/attributes';
 
-describe('ignoring a child of a continued server segment (streaming)', () => {
+describe('ignoring a child of a continued server segment', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/instrument.mjs
similarity index 93%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/instrument.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/instrument.mjs
index 2d534bda43f2..8d6990f70f60 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/instrument.mjs
@@ -5,7 +5,6 @@ Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
   ignoreSpans: [{ attributes: { 'url.path': '/outgoing' } }],
   tracePropagationTargets: [process.env.SERVER_URL],
   clientReportFlushInterval: 1_000,
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/server.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/server.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/server.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/server.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/test.ts b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/test.ts
similarity index 98%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/test.ts
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/test.ts
index 79e727254710..da9f1e5a7d9f 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/test.ts
@@ -3,7 +3,7 @@ import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
 import { SENTRY_OP } from '@sentry/conventions/attributes';
 
-describe('ignoring an HTTP client child of a continued server segment (streaming)', () => {
+describe('ignoring an HTTP client child of a continued server segment', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/instrument.mjs
similarity index 92%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/instrument.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/instrument.mjs
index d6c2931b331f..950501539e15 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/instrument.mjs
@@ -5,7 +5,6 @@ Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
   ignoreSpans: [{ op: 'http.server' }],
   tracePropagationTargets: [process.env.SERVER_URL],
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/server.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/server.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/server.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/server.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/test.ts b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts
similarity index 96%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/test.ts
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts
index 5aa058ff4d7c..afc8eb2158ba 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts
@@ -3,7 +3,7 @@ import { afterAll, describe, expect } from 'vitest';
 import { RUNTIME } from '../../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
 
-describe('ignoring a continued server segment (streaming)', () => {
+describe('ignoring a continued server segment', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/segments/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/segments/instrument.mjs
similarity index 92%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/segments/instrument.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/segments/instrument.mjs
index 812ba9fb86a8..e86e9f19984b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/segments/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/segments/instrument.mjs
@@ -6,7 +6,6 @@ Sentry.init({
   release: '1.0',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
-  traceLifecycle: 'stream',
   ignoreSpans: [{ attributes: { 'url.path': '/health' } }],
   clientReportFlushInterval: 1_000,
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/segments/server.mjs b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/segments/server.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/segments/server.mjs
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/segments/server.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/segments/test.ts b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/segments/test.ts
similarity index 95%
rename from dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/segments/test.ts
rename to dev-packages/node-integration-tests/suites/tracing/ignoreSpans/segments/test.ts
index 538c9c77a532..ebbd956d8239 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/segments/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/segments/test.ts
@@ -1,7 +1,7 @@
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
 
-describe('filtering segment spans with ignoreSpans (streaming)', () => {
+describe('filtering segment spans with ignoreSpans', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/sampling-streamed/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/sampling/instrument.mjs
similarity index 95%
rename from dev-packages/node-integration-tests/suites/tracing/sampling-streamed/instrument.mjs
rename to dev-packages/node-integration-tests/suites/tracing/sampling/instrument.mjs
index 0ce3c59cf745..4fd072ae569a 100644
--- a/dev-packages/node-integration-tests/suites/tracing/sampling-streamed/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/sampling/instrument.mjs
@@ -12,6 +12,5 @@ Sentry.init({
     return inheritOrSampleWith(1);
   },
   transport: loggingTransport,
-  traceLifecycle: 'stream',
   clientReportFlushInterval: 1_000,
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/sampling-streamed/server.mjs b/dev-packages/node-integration-tests/suites/tracing/sampling/server.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/sampling-streamed/server.mjs
rename to dev-packages/node-integration-tests/suites/tracing/sampling/server.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/sampling-streamed/test.ts b/dev-packages/node-integration-tests/suites/tracing/sampling/test.ts
similarity index 97%
rename from dev-packages/node-integration-tests/suites/tracing/sampling-streamed/test.ts
rename to dev-packages/node-integration-tests/suites/tracing/sampling/test.ts
index aa28c3c7723b..fbcf06a52eec 100644
--- a/dev-packages/node-integration-tests/suites/tracing/sampling-streamed/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/sampling/test.ts
@@ -1,7 +1,7 @@
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
-describe('negative sampling (streaming)', () => {
+describe('negative sampling', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });

From 40e027529fc474b3195ccb56936b7704667762e3 Mon Sep 17 00:00:00 2001
From: Martin Sonnberger <martin.sonnberger@sentry.io>
Date: Fri, 9 Oct 2026 13:02:34 +0200
Subject: [PATCH 26/84] test(browser): migrate trace lifecycle and span API
 tests to streaming (#24881)

Run the browser trace lifecycle and public span API tests with default
span streaming, asserting across envelopes as roots and children are
sent independently. Retain the existing transaction counterparts as
explicitly pinned `*-static` suites so both lifecycles keep regression
coverage for sampling, propagation, linking, and span APIs.

Cover circular attributes in both lifecycles: streamed spans drop
unsupported objects while preserving primitive attributes, and static
transactions retain circular-reference normalization. Filter feedback
waits by envelope type so unrelated span envelopes cannot satisfy them.

Keep `public-api/startSpan/setMeasurement` on the static lifecycle
because the legacy measurement API has no span v2 representation.

Fixes #24144

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../integrations/httpclient/fetch/init.js     |   1 -
 .../fetch/withAbortController/init.js         |   1 -
 .../fetch/withAbortController/test.ts         |  13 +-
 .../fetch/withDataCollection/init.js          |   1 -
 .../fetch/withDisabledDataCollection/init.js  |   1 -
 .../withHeadersOnlyDataCollection/init.js     |   1 -
 .../suites/integrations/httpclient/init.js    |   1 -
 .../httpclient/xhr/withDataCollection/init.js |   1 -
 .../init.js                                   |   0
 .../test.ts                                   |   3 +-
 .../init.js                                   |   0
 .../test.ts                                   |   0
 .../simple_message_no_stacktrace/test.ts      |   5 +-
 .../public-api/startSpan/attributes/test.ts   |  20 +-
 .../public-api/startSpan/basic-static/init.js |  10 +
 .../startSpan/basic-static/subject.js         |  14 +
 .../public-api/startSpan/basic-static/test.ts |  52 ++
 .../startSpan/{streamed => basic}/init.js     |   1 -
 .../public-api/startSpan/basic/subject.js     |  25 +-
 .../suites/public-api/startSpan/basic/test.ts | 335 ++++++++++--
 .../startSpan/circular_data-static/init.js    |  10 +
 .../startSpan/circular_data-static/subject.js |   7 +
 .../startSpan/circular_data-static/test.ts    |  28 +
 .../startSpan/circular_data/subject.js        |   4 +-
 .../startSpan/circular_data/test.ts           |  44 +-
 .../startSpan/error-async-reject/test.ts      |  15 +-
 .../error-async-throw-not-awaited/test.ts     |  15 +-
 .../startSpan/error-async-throw/test.ts       |  15 +-
 .../public-api/startSpan/error-sync/test.ts   |  27 +-
 .../suites/public-api/startSpan/init.js       |   1 -
 .../parallel-root-spans-in-scope/test.ts      |  20 +-
 .../test.ts                                   |  20 +-
 .../startSpan/parallel-root-spans/test.ts     |  20 +-
 .../startSpan/setMeasurement/init.js          |  11 +
 .../startSpan/setMeasurement/test.ts          |  29 +-
 .../public-api/startSpan/streamed/subject.js  |  15 -
 .../public-api/startSpan/streamed/test.ts     | 295 -----------
 .../thenable-with-extra-methods/test.ts       |  11 +-
 .../suites/tracing/bindScopeToEmitter/init.js |   1 -
 .../suites/tracing/bindScopeToEmitter/test.ts |  18 +-
 .../browserTracingIntegrationShim/init.js     |   1 -
 .../continueTrace/full-tracing/init.js        |   1 -
 .../continueTrace/full-tracing/test.ts        |  67 ++-
 .../tracesSampleRate-zero/init.js             |   1 -
 .../tracesSampleRate-zero/test.ts             |  22 +-
 .../tracing-without-performance/init.js       |   1 -
 .../tracing-without-performance/test.ts       |   2 +-
 .../tracing/dsc-txn-name-update/init.js       |   1 -
 .../tracing/dsc-txn-name-update/test.ts       |  28 +-
 .../envelope-header-transaction-name/init.js  |   1 -
 .../envelope-header-transaction-name/test.ts  |  16 +-
 .../suites/tracing/envelope-header/init.js    |   1 -
 .../suites/tracing/envelope-header/test.ts    |  16 +-
 .../init.js                                   |   5 +-
 .../subject.js                                |   0
 .../test.ts                                   |  11 +-
 .../suites/tracing/ignoreSpans-static/init.js |  50 ++
 .../suites/tracing/ignoreSpans-static/test.ts |  29 ++
 .../attributes/init.js                        |   2 +-
 .../attributes/subject.js                     |   0
 .../attributes/test.ts                        |   0
 .../child/init.js                             |   2 +-
 .../child/subject.js                          |   0
 .../child/test.ts                             |   0
 .../continued-trace-child/init.js             |   2 +-
 .../continued-trace-child/subject.js          |   0
 .../continued-trace-child/template.html       |   0
 .../continued-trace-child/test.ts             |   0
 .../continued-trace-http-client/init.js       |   2 +-
 .../continued-trace-http-client/subject.js    |   0
 .../continued-trace-http-client/template.html |   0
 .../continued-trace-http-client/test.ts       |   0
 .../continued-trace-segment/init.js           |   2 +-
 .../continued-trace-segment/subject.js        |   0
 .../continued-trace-segment/template.html     |   0
 .../continued-trace-segment/test.ts           |   0
 .../suites/tracing/ignoreSpans/init.js        |   1 -
 .../segment/init.js                           |   2 +-
 .../segment/subject.js                        |   0
 .../segment/test.ts                           |   0
 .../suites/tracing/ignoreSpans/test.ts        |  16 +-
 .../nested => linking-addLink-static}/init.js |   2 +-
 .../subject.js                                |   0
 .../tracing/linking-addLink-static/test.ts    |  77 +++
 .../tracing/linking-addLink-streamed/test.ts  |  66 ---
 .../suites/tracing/linking-addLink/init.js    |   1 -
 .../suites/tracing/linking-addLink/test.ts    |  94 ++--
 .../suites/tracing/linking-addLinks/init.js   |   1 -
 .../suites/tracing/linking-addLinks/test.ts   |  74 +--
 .../tracing/linking-spanOptions/init.js       |   1 -
 .../tracing/linking-spanOptions/test.ts       |  43 +-
 .../suites/tracing/maxSpans-static/init.js    |  16 +
 .../suites/tracing/maxSpans-static/test.ts    |  16 +
 .../suites/tracing/maxSpans/init.js           |   1 -
 .../suites/tracing/maxSpans/test.ts           |  26 +-
 .../microfrontend-span-attribution/init.js    |   1 -
 .../microfrontend-span-attribution/test.ts    |  42 +-
 .../init.js                                   |   0
 .../subject.js                                |   0
 .../test.ts                                   |   0
 .../default}/init.js                          |   2 +-
 .../default/subject.js                        |   0
 .../default/test.ts                           |  22 +-
 .../nested-parentAlwaysRoot/init.js           |   2 +-
 .../nested-parentAlwaysRoot/subject.js        |   0
 .../nested-parentAlwaysRoot/test.ts           |  35 +-
 .../nested}/init.js                           |   2 +-
 .../nested/subject.js                         |   0
 .../setSpanActive-static/nested/test.ts       |  52 ++
 .../setSpanActive-streamed/nested/test.ts     |  53 --
 .../tracing/setSpanActive/default/init.js     |   2 +-
 .../tracing/setSpanActive/default/test.ts     |  24 +-
 .../nested-parentAlwaysRoot/init.js           |   2 +-
 .../nested-parentAlwaysRoot/test.ts           |  36 +-
 .../tracing/setSpanActive/nested/init.js      |   2 +-
 .../tracing/setSpanActive/nested/test.ts      |  36 +-
 .../suites/tracing/stringSampleRate/init.js   |   1 -
 .../suites/tracing/stringSampleRate/test.ts   |   9 +-
 .../suites/tracing/trace-lifetime/init.js     |   1 -
 .../init.js                                   |   3 +-
 .../navigation-static/subject.js              |  23 +
 .../navigation-static/template.html           |  12 +
 .../trace-lifetime/navigation-static/test.ts  | 363 +++++++++++++
 .../navigation-streamed/test.ts               | 317 ------------
 .../{pageload-streamed => navigation}/init.js |   2 +-
 .../tracing/trace-lifetime/navigation/test.ts | 288 +++++------
 .../trace-lifetime/pageload-headers/test.ts   |  44 +-
 .../trace-lifetime/pageload-meta/test.ts      | 127 +++--
 .../trace-lifetime/pageload-static/init.js    |  13 +
 .../trace-lifetime/pageload-static/subject.js |  23 +
 .../pageload-static/template.html             |  12 +
 .../trace-lifetime/pageload-static/test.ts    | 484 ++++++++++++++++++
 .../trace-lifetime/pageload-streamed/test.ts  | 237 ---------
 .../tracing/trace-lifetime/pageload/init.js   |  12 +
 .../tracing/trace-lifetime/pageload/test.ts   | 409 +++------------
 .../startNewTrace-multiple-spans/test.ts      |  42 +-
 .../startNewTrace-static/init.js              |  13 +
 .../subject.js                                |   0
 .../template.html                             |   0
 .../startNewTrace-static/test.ts              | 109 ++++
 .../startNewTrace-streamed/test.ts            |  44 --
 .../init.js                                   |   2 +-
 .../trace-lifetime/startNewTrace/test.ts      |  99 +---
 .../startNewTraceSampling/init.js             |   1 -
 .../startNewTraceSampling/test.ts             |  62 +--
 .../init.js                                   |   1 -
 .../test.ts                                   |   9 +-
 .../init.js                                   |   1 -
 .../tracing-without-performance/init.js       |   1 -
 .../tracing-without-performance/test.ts       |  13 +-
 .../tracesSampler/op-attribute/init.js        |   1 -
 .../tracesSampler/op-attribute/test.ts        |  16 +-
 .../utils/helpers.ts                          |   6 +-
 .../utils/spanUtils.ts                        |  41 +-
 154 files changed, 2596 insertions(+), 2349 deletions(-)
 rename dev-packages/browser-integration-tests/suites/public-api/{beforeSendSpan-streamed => beforeSendSpan}/init.js (100%)
 rename dev-packages/browser-integration-tests/suites/public-api/{beforeSendSpan-streamed => beforeSendSpan}/test.ts (89%)
 rename dev-packages/browser-integration-tests/suites/public-api/{beforeSendTransaction => beforeSendTransaction-static}/init.js (100%)
 rename dev-packages/browser-integration-tests/suites/public-api/{beforeSendTransaction => beforeSendTransaction-static}/test.ts (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/test.ts
 rename dev-packages/browser-integration-tests/suites/public-api/startSpan/{streamed => basic}/init.js (77%)
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/startSpan/setMeasurement/init.js
 delete mode 100644 dev-packages/browser-integration-tests/suites/public-api/startSpan/streamed/subject.js
 delete mode 100644 dev-packages/browser-integration-tests/suites/public-api/startSpan/streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/{http-client-span-streamed => http-client-span}/init.js (54%)
 rename dev-packages/browser-integration-tests/suites/tracing/{http-client-span-streamed => http-client-span}/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{http-client-span-streamed => http-client-span}/test.ts (63%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-static/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-static/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/attributes/init.js (82%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/attributes/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/attributes/test.ts (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/child/init.js (82%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/child/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/child/test.ts (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-child/init.js (76%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-child/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-child/template.html (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-child/test.ts (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-http-client/init.js (76%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-http-client/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-http-client/template.html (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-http-client/test.ts (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-segment/init.js (74%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-segment/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-segment/template.html (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/continued-trace-segment/test.ts (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/segment/init.js (79%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/segment/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{ignoreSpans-streamed => ignoreSpans}/segment/test.ts (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{setSpanActive-streamed/nested => linking-addLink-static}/init.js (75%)
 rename dev-packages/browser-integration-tests/suites/tracing/{linking-addLink-streamed => linking-addLink-static}/subject.js (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/linking-addLink-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/linking-addLink-streamed/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/maxSpans-static/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/maxSpans-static/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/{no-parent-span-client-report => no-parent-span-client-report-static}/init.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{no-parent-span-client-report => no-parent-span-client-report-static}/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{no-parent-span-client-report => no-parent-span-client-report-static}/test.ts (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{linking-addLink-streamed => setSpanActive-static/default}/init.js (75%)
 rename dev-packages/browser-integration-tests/suites/tracing/{setSpanActive-streamed => setSpanActive-static}/default/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{setSpanActive-streamed => setSpanActive-static}/default/test.ts (52%)
 rename dev-packages/browser-integration-tests/suites/tracing/{setSpanActive-streamed => setSpanActive-static}/nested-parentAlwaysRoot/init.js (78%)
 rename dev-packages/browser-integration-tests/suites/tracing/{setSpanActive-streamed => setSpanActive-static}/nested-parentAlwaysRoot/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/{setSpanActive-streamed => setSpanActive-static}/nested-parentAlwaysRoot/test.ts (53%)
 rename dev-packages/browser-integration-tests/suites/tracing/{setSpanActive-streamed/default => setSpanActive-static/nested}/init.js (75%)
 rename dev-packages/browser-integration-tests/suites/tracing/{setSpanActive-streamed => setSpanActive-static}/nested/subject.js (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/{navigation-streamed => navigation-static}/init.js (89%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/template.html
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/{pageload-streamed => navigation}/init.js (89%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/template.html
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-streamed/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/init.js
 rename dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/{startNewTrace-streamed => startNewTrace-static}/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/{startNewTrace-streamed => startNewTrace-static}/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/{startNewTrace-streamed => startNewTrace}/init.js (71%)

diff --git a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/init.js b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/init.js
index 43248f09b63d..f44669962912 100644
--- a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/init.js
+++ b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/init.js
@@ -4,7 +4,6 @@ import { httpClientIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [httpClientIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withAbortController/init.js b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withAbortController/init.js
index bd0421b32761..7c200c542c56 100644
--- a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withAbortController/init.js
+++ b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withAbortController/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withAbortController/test.ts b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withAbortController/test.ts
index fbd30098773a..85b7663dabc0 100644
--- a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withAbortController/test.ts
+++ b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withAbortController/test.ts
@@ -1,7 +1,7 @@
 import { expect } from '@playwright/test';
-import type { Event as SentryEvent } from '@sentry/core';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForErrorRequest } from '../../../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest('should handle aborted fetch calls', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
@@ -14,7 +14,7 @@ sentryTest('should handle aborted fetch calls', async ({ getLocalTestUrl, page }
     // never fulfil this route because we abort the request as part of the test
   });
 
-  const transactionEventPromise = getFirstSentryEnvelopeRequest<SentryEvent>(page);
+  const spanPromise = waitForStreamedSpan(page, span => span.name === 'with-abort-controller');
 
   const hasAbortedFetchPromise = new Promise<void>(resolve => {
     page.on('console', msg => {
@@ -29,10 +29,13 @@ sentryTest('should handle aborted fetch calls', async ({ getLocalTestUrl, page }
   await page.locator('[data-test-id=start-button]').click();
   await page.locator('[data-test-id=abort-button]').click();
 
-  const transactionEvent = await transactionEventPromise;
+  await spanPromise;
+  const eventPromise = waitForErrorRequest(page);
+  await page.evaluate(() => (window as any).Sentry.captureMessage('After aborted fetch'));
+  const event = envelopeRequestParser(await eventPromise);
 
   // assert that fetch calls do not return undefined
-  const fetchBreadcrumbs = transactionEvent.breadcrumbs?.filter(
+  const fetchBreadcrumbs = event.breadcrumbs?.filter(
     ({ category, data }) => category === 'fetch' && data === undefined,
   );
   expect(fetchBreadcrumbs).toHaveLength(0);
diff --git a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withDataCollection/init.js b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withDataCollection/init.js
index fd831d3f7c14..8584933da0fa 100644
--- a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withDataCollection/init.js
+++ b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withDataCollection/init.js
@@ -4,7 +4,6 @@ import { httpClientIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [httpClientIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withDisabledDataCollection/init.js b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withDisabledDataCollection/init.js
index 7d53e07a4c0c..a20cf0664d13 100644
--- a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withDisabledDataCollection/init.js
+++ b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withDisabledDataCollection/init.js
@@ -4,7 +4,6 @@ import { httpClientIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [httpClientIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withHeadersOnlyDataCollection/init.js b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withHeadersOnlyDataCollection/init.js
index 2739a4aeea64..5eafca47503b 100644
--- a/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withHeadersOnlyDataCollection/init.js
+++ b/dev-packages/browser-integration-tests/suites/integrations/httpclient/fetch/withHeadersOnlyDataCollection/init.js
@@ -4,7 +4,6 @@ import { httpClientIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [httpClientIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/integrations/httpclient/init.js b/dev-packages/browser-integration-tests/suites/integrations/httpclient/init.js
index 43248f09b63d..f44669962912 100644
--- a/dev-packages/browser-integration-tests/suites/integrations/httpclient/init.js
+++ b/dev-packages/browser-integration-tests/suites/integrations/httpclient/init.js
@@ -4,7 +4,6 @@ import { httpClientIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [httpClientIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/integrations/httpclient/xhr/withDataCollection/init.js b/dev-packages/browser-integration-tests/suites/integrations/httpclient/xhr/withDataCollection/init.js
index fd831d3f7c14..8584933da0fa 100644
--- a/dev-packages/browser-integration-tests/suites/integrations/httpclient/xhr/withDataCollection/init.js
+++ b/dev-packages/browser-integration-tests/suites/integrations/httpclient/xhr/withDataCollection/init.js
@@ -4,7 +4,6 @@ import { httpClientIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [httpClientIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan-streamed/init.js b/dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan/init.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan/init.js
diff --git a/dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan-streamed/test.ts b/dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan/test.ts
similarity index 89%
rename from dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan-streamed/test.ts
rename to dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan/test.ts
index c3218f27e98a..9491bc7feab6 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan-streamed/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/beforeSendSpan/test.ts
@@ -1,3 +1,4 @@
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../utils/fixtures';
 import { shouldSkipTracingTest } from '../../../utils/helpers';
@@ -22,7 +23,7 @@ sentryTest('beforeSendSpan applies changes to streamed span', async ({ getLocalT
         spanId: '456',
       },
       attributes: {
-        'sentry.link.type': { type: 'string', value: 'custom_link' },
+        [SENTRY_LINK_TYPE]: { type: 'string', value: 'custom_link' },
       },
     },
   ]);
diff --git a/dev-packages/browser-integration-tests/suites/public-api/beforeSendTransaction/init.js b/dev-packages/browser-integration-tests/suites/public-api/beforeSendTransaction-static/init.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/public-api/beforeSendTransaction/init.js
rename to dev-packages/browser-integration-tests/suites/public-api/beforeSendTransaction-static/init.js
diff --git a/dev-packages/browser-integration-tests/suites/public-api/beforeSendTransaction/test.ts b/dev-packages/browser-integration-tests/suites/public-api/beforeSendTransaction-static/test.ts
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/public-api/beforeSendTransaction/test.ts
rename to dev-packages/browser-integration-tests/suites/public-api/beforeSendTransaction-static/test.ts
diff --git a/dev-packages/browser-integration-tests/suites/public-api/captureMessage/simple_message_no_stacktrace/test.ts b/dev-packages/browser-integration-tests/suites/public-api/captureMessage/simple_message_no_stacktrace/test.ts
index ae9db5f3064d..2c42ced57737 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/captureMessage/simple_message_no_stacktrace/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/captureMessage/simple_message_no_stacktrace/test.ts
@@ -1,12 +1,11 @@
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest } from '../../../../utils/helpers';
+import { envelopeRequestParser, waitForErrorRequestOnUrl } from '../../../../utils/helpers';
 
 sentryTest('does not capture a stack trace if `attachStackTrace` is `false`', async ({ getLocalTestUrl, page }) => {
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  const eventData = envelopeRequestParser(await waitForErrorRequestOnUrl(page, url));
 
   expect(eventData.message).toBe('foo');
   expect(eventData.level).toBe('info');
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/attributes/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/attributes/test.ts
index 4d6d78f0eea1..7820d0108fc2 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/attributes/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/attributes/test.ts
@@ -1,20 +1,14 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  shouldSkipTracingTest,
-  waitForTransactionRequestOnUrl,
-} from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('sends an empty string attribute', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
-
+  sentryTest.skip(shouldSkipTracingTest());
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const req = await waitForTransactionRequestOnUrl(page, url);
-  const transaction = envelopeRequestParser(req);
+  const spanPromise = waitForStreamedSpan(page, span => span.name === 'child_span');
+  await page.goto(url);
 
-  const childSpan = transaction.spans?.[0];
-  expect(childSpan?.data?.someAttribute).toBe('');
+  const span = await spanPromise;
+  expect(span.attributes.someAttribute).toEqual({ type: 'string', value: '' });
 });
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/init.js b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/init.js
new file mode 100644
index 000000000000..527fad0d6f15
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracesSampleRate: 1.0,
+  normalizeDepth: 10,
+});
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/subject.js b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/subject.js
new file mode 100644
index 000000000000..35d41b55e69d
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/subject.js
@@ -0,0 +1,14 @@
+async function run() {
+  Sentry.startSpan({ name: 'parent_span' }, () => {
+    Sentry.startSpan({ name: 'child_span' }, () => {
+      // whatever a user would do here
+    });
+
+    // unfinished spans are filtered out
+    Sentry.startInactiveSpan({ name: 'span_4' });
+  });
+}
+
+(async () => {
+  await run();
+})();
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/test.ts
new file mode 100644
index 000000000000..d3819b797a11
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic-static/test.ts
@@ -0,0 +1,52 @@
+import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
+import { sentryTest } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  shouldSkipTracingTest,
+  waitForTransactionRequestOnUrl,
+} from '../../../../utils/helpers';
+
+sentryTest(
+  'sends a transaction in an envelope with manual origin and custom source',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    const req = await waitForTransactionRequestOnUrl(page, url);
+    const transaction = envelopeRequestParser(req);
+
+    const attributes = transaction.contexts?.trace?.data;
+    expect(attributes).toEqual({
+      [SENTRY_ORIGIN]: 'manual',
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
+      [SENTRY_SEGMENT_NAME_SOURCE]: 'custom',
+    });
+
+    expect(transaction.transaction_info?.source).toBe('custom');
+
+    expect(transaction.transaction).toBe('parent_span');
+    expect(transaction.spans).toBeDefined();
+  },
+);
+
+sentryTest('should report finished spans as children of the root transaction', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const req = await waitForTransactionRequestOnUrl(page, url);
+  const transaction = envelopeRequestParser(req);
+
+  expect(transaction.spans).toHaveLength(1);
+
+  const span_1 = transaction.spans?.[0];
+  expect(span_1?.description).toBe('child_span');
+  expect(span_1?.parent_span_id).toEqual(transaction?.contexts?.trace?.span_id);
+  expect(span_1?.origin).toEqual('manual');
+  expect(span_1?.data?.[SENTRY_ORIGIN]).toEqual('manual');
+});
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/streamed/init.js b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic/init.js
similarity index 77%
rename from dev-packages/browser-integration-tests/suites/public-api/startSpan/streamed/init.js
rename to dev-packages/browser-integration-tests/suites/public-api/startSpan/basic/init.js
index aaafd3396f14..e546c7cc6a94 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic/init.js
@@ -4,7 +4,6 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.spanStreamingIntegration()],
   tracesSampleRate: 1.0,
   debug: true,
 });
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic/subject.js b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic/subject.js
index 35d41b55e69d..afe2527d8c7e 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic/subject.js
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic/subject.js
@@ -1,14 +1,15 @@
-async function run() {
-  Sentry.startSpan({ name: 'parent_span' }, () => {
-    Sentry.startSpan({ name: 'child_span' }, () => {
-      // whatever a user would do here
-    });
-
-    // unfinished spans are filtered out
-    Sentry.startInactiveSpan({ name: 'span_4' });
+Sentry.startSpan({ name: 'test-span', op: 'test' }, () => {
+  Sentry.startSpan({ name: 'test-child-span', op: 'test-child' }, () => {
+    // noop
   });
-}
 
-(async () => {
-  await run();
-})();
+  const inactiveSpan = Sentry.startInactiveSpan({ name: 'test-inactive-span' });
+  inactiveSpan.end();
+
+  Sentry.startSpanManual({ name: 'test-manual-span' }, span => {
+    // 2 = SPAN_STATUS_ERROR. The message must be preserved as the `sentry.status.message`
+    // attribute on the streamed span, since v2 statuses are reduced to ok/error.
+    span.setStatus({ code: 2, message: 'Connection Refused' });
+    span.end();
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic/test.ts
index 824220e5133f..ba2404e747b5 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/basic/test.ts
@@ -1,52 +1,297 @@
-import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import {
+  SENTRY_IS_LOCALHOST,
+  CULTURE_CALENDAR,
+  CULTURE_LOCALE,
+  CULTURE_TIMEZONE,
+  URL_FULL,
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SEGMENT_NAME,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_TRACE_LIFECYCLE,
+  USER_AGENT_ORIGINAL,
+  SENTRY_ENVIRONMENT,
+  SENTRY_SDK_INTEGRATIONS,
+  SENTRY_STATUS_MESSAGE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
+import { SDK_VERSION, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  shouldSkipTracingTest,
-  waitForTransactionRequestOnUrl,
-} from '../../../../utils/helpers';
-
-sentryTest(
-  'sends a transaction in an envelope with manual origin and custom source',
-  async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-    const req = await waitForTransactionRequestOnUrl(page, url);
-    const transaction = envelopeRequestParser(req);
-
-    const attributes = transaction.contexts?.trace?.data;
-    expect(attributes).toEqual({
-      [SENTRY_ORIGIN]: 'manual',
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-      [SENTRY_SEGMENT_NAME_SOURCE]: 'custom',
-    });
-
-    expect(transaction.transaction_info?.source).toBe('custom');
-
-    expect(transaction.transaction).toBe('parent_span');
-    expect(transaction.spans).toBeDefined();
-  },
-);
-
-sentryTest('should report finished spans as children of the root transaction', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
+
+sentryTest('sends a streamed span envelope by default', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
+
+  const spanEnvelopePromise = waitForStreamedSpanEnvelope(page);
 
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const req = await waitForTransactionRequestOnUrl(page, url);
-  const transaction = envelopeRequestParser(req);
+  await page.goto(url);
+
+  const spanEnvelope = await spanEnvelopePromise;
+
+  const envelopeHeader = spanEnvelope[0];
+  const envelopeItem = spanEnvelope[1];
+  const spans = envelopeItem[0][1].items;
+
+  expect(envelopeHeader).toEqual({
+    sdk: {
+      name: 'sentry.javascript.browser',
+      version: SDK_VERSION,
+    },
+    sent_at: expect.any(String),
+    trace: {
+      environment: 'production',
+      public_key: 'public',
+      sample_rand: expect.any(String),
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      transaction: 'test-span',
+    },
+  });
+
+  const numericSampleRand = parseFloat(envelopeHeader.trace!.sample_rand!);
+  const traceId = envelopeHeader.trace!.trace_id;
+
+  expect(Number.isNaN(numericSampleRand)).toBe(false);
+
+  expect(envelopeItem).toEqual([
+    [
+      { content_type: 'application/vnd.sentry.items.span.v2+json', item_count: 4, type: 'span' },
+      {
+        version: 2,
+        ingest_settings: { infer_ip: 'auto', infer_user_agent: 'auto' },
+        items: expect.any(Array),
+      },
+    ],
+  ]);
 
-  expect(transaction.spans).toHaveLength(1);
+  const segmentSpanId = spans.find(s => !!s.is_segment)?.span_id;
+  expect(segmentSpanId).toBeDefined();
 
-  const span_1 = transaction.spans?.[0];
-  expect(span_1?.description).toBe('child_span');
-  expect(span_1?.parent_span_id).toEqual(transaction?.contexts?.trace?.span_id);
-  expect(span_1?.origin).toEqual('manual');
-  expect(span_1?.data?.['sentry.origin']).toEqual('manual');
+  expect(spans).toEqual([
+    {
+      attributes: {
+        [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
+        [SENTRY_OP]: {
+          type: 'string',
+          value: 'test-child',
+        },
+        [SENTRY_ORIGIN]: {
+          type: 'string',
+          value: 'manual',
+        },
+        [SENTRY_SDK_NAME]: {
+          type: 'string',
+          value: 'sentry.javascript.browser',
+        },
+        [SENTRY_SDK_VERSION]: {
+          type: 'string',
+          value: SDK_VERSION,
+        },
+        [SENTRY_SEGMENT_ID]: {
+          type: 'string',
+          value: segmentSpanId,
+        },
+        [SENTRY_SEGMENT_NAME]: {
+          type: 'string',
+          value: 'test-span',
+        },
+        [SENTRY_ENVIRONMENT]: {
+          type: 'string',
+          value: 'production',
+        },
+        [SENTRY_TRACE_LIFECYCLE]: {
+          type: 'string',
+          value: 'stream',
+        },
+        [USER_AGENT_ORIGINAL]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+      },
+      end_timestamp: expect.any(Number),
+      is_segment: false,
+      name: 'test-child-span',
+      parent_span_id: segmentSpanId,
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+      start_timestamp: expect.any(Number),
+      status: 'ok',
+      trace_id: traceId,
+    },
+    {
+      attributes: {
+        [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
+        [SENTRY_ORIGIN]: {
+          type: 'string',
+          value: 'manual',
+        },
+        [SENTRY_SDK_NAME]: {
+          type: 'string',
+          value: 'sentry.javascript.browser',
+        },
+        [SENTRY_SDK_VERSION]: {
+          type: 'string',
+          value: SDK_VERSION,
+        },
+        [SENTRY_SEGMENT_ID]: {
+          type: 'string',
+          value: segmentSpanId,
+        },
+        [SENTRY_SEGMENT_NAME]: {
+          type: 'string',
+          value: 'test-span',
+        },
+        [SENTRY_ENVIRONMENT]: {
+          type: 'string',
+          value: 'production',
+        },
+        [SENTRY_TRACE_LIFECYCLE]: {
+          type: 'string',
+          value: 'stream',
+        },
+        [USER_AGENT_ORIGINAL]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+      },
+      end_timestamp: expect.any(Number),
+      is_segment: false,
+      name: 'test-inactive-span',
+      parent_span_id: segmentSpanId,
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+      start_timestamp: expect.any(Number),
+      status: 'ok',
+      trace_id: traceId,
+    },
+    {
+      attributes: {
+        [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
+        [SENTRY_ORIGIN]: {
+          type: 'string',
+          value: 'manual',
+        },
+        [SENTRY_SDK_NAME]: {
+          type: 'string',
+          value: 'sentry.javascript.browser',
+        },
+        [SENTRY_SDK_VERSION]: {
+          type: 'string',
+          value: SDK_VERSION,
+        },
+        [SENTRY_SEGMENT_ID]: {
+          type: 'string',
+          value: segmentSpanId,
+        },
+        [SENTRY_SEGMENT_NAME]: {
+          type: 'string',
+          value: 'test-span',
+        },
+        [SENTRY_ENVIRONMENT]: {
+          type: 'string',
+          value: 'production',
+        },
+        [SENTRY_STATUS_MESSAGE]: {
+          type: 'string',
+          value: 'Connection Refused',
+        },
+        [SENTRY_TRACE_LIFECYCLE]: {
+          type: 'string',
+          value: 'stream',
+        },
+        [USER_AGENT_ORIGINAL]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+      },
+      end_timestamp: expect.any(Number),
+      is_segment: false,
+      name: 'test-manual-span',
+      parent_span_id: segmentSpanId,
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+      start_timestamp: expect.any(Number),
+      status: 'error',
+      trace_id: traceId,
+    },
+    {
+      attributes: {
+        [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
+        [CULTURE_CALENDAR]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+        [CULTURE_LOCALE]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+        [CULTURE_TIMEZONE]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+        [USER_AGENT_ORIGINAL]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+        [URL_FULL]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+        [SENTRY_OP]: {
+          type: 'string',
+          value: 'test',
+        },
+        [SENTRY_ORIGIN]: {
+          type: 'string',
+          value: 'manual',
+        },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: {
+          type: 'integer',
+          value: 1,
+        },
+        [SENTRY_SDK_NAME]: {
+          type: 'string',
+          value: 'sentry.javascript.browser',
+        },
+        [SENTRY_SDK_VERSION]: {
+          type: 'string',
+          value: SDK_VERSION,
+        },
+        [SENTRY_SDK_INTEGRATIONS]: {
+          type: 'array',
+          value: expect.arrayContaining(['SpanStreaming']),
+        },
+        [SENTRY_SEGMENT_ID]: {
+          type: 'string',
+          value: segmentSpanId,
+        },
+        [SENTRY_SEGMENT_NAME]: {
+          type: 'string',
+          value: 'test-span',
+        },
+        [SENTRY_SEGMENT_NAME_SOURCE]: {
+          type: 'string',
+          value: 'custom',
+        },
+        [SENTRY_ENVIRONMENT]: {
+          type: 'string',
+          value: 'production',
+        },
+        [SENTRY_TRACE_LIFECYCLE]: {
+          type: 'string',
+          value: 'stream',
+        },
+      },
+      end_timestamp: expect.any(Number),
+      is_segment: true,
+      name: 'test-span',
+      span_id: segmentSpanId,
+      start_timestamp: expect.any(Number),
+      status: 'ok',
+      trace_id: traceId,
+    },
+  ]);
 });
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/init.js b/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/init.js
new file mode 100644
index 000000000000..527fad0d6f15
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracesSampleRate: 1.0,
+  normalizeDepth: 10,
+});
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/subject.js b/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/subject.js
new file mode 100644
index 000000000000..c7aa1cd72dfe
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/subject.js
@@ -0,0 +1,7 @@
+const chicken = {};
+const egg = { contains: chicken };
+chicken.lays = egg;
+
+Sentry.startSpan({ name: 'circular_object_test_transaction', attributes: { chicken, count: 42 } }, () => {
+  Sentry.startSpan({ op: 'circular_object_test_span', attributes: { chicken, count: 42 } }, () => undefined);
+});
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/test.ts
new file mode 100644
index 000000000000..d794f101112d
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data-static/test.ts
@@ -0,0 +1,28 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  shouldSkipTracingTest,
+  waitForTransactionRequestOnUrl,
+} from '../../../../utils/helpers';
+
+sentryTest(
+  'normalizes circular attributes on root and child spans with static tracing',
+  async ({ getLocalTestUrl, page }) => {
+    sentryTest.skip(shouldSkipTracingTest());
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    const event = envelopeRequestParser(await waitForTransactionRequestOnUrl(page, url));
+
+    expect(event.transaction).toBe('circular_object_test_transaction');
+    expect(event.contexts?.trace?.data).toMatchObject({
+      chicken: { lays: { contains: '[Circular ~]' } },
+      count: 42,
+    });
+    expect(event.spans).toHaveLength(1);
+    expect(event.spans?.[0]).toMatchObject({
+      op: 'circular_object_test_span',
+      parent_span_id: event.contexts?.trace?.span_id,
+      data: { chicken: { lays: { contains: '[Circular ~]' } }, count: 42 },
+    });
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data/subject.js b/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data/subject.js
index b5ee8624b124..c7aa1cd72dfe 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data/subject.js
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data/subject.js
@@ -2,6 +2,6 @@ const chicken = {};
 const egg = { contains: chicken };
 chicken.lays = egg;
 
-Sentry.startSpan({ name: 'circular_object_test_transaction', attributes: { chicken } }, () => {
-  Sentry.startSpan({ op: 'circular_object_test_span', attributes: { chicken } }, () => undefined);
+Sentry.startSpan({ name: 'circular_object_test_transaction', attributes: { chicken, count: 42 } }, () => {
+  Sentry.startSpan({ op: 'circular_object_test_span', attributes: { chicken, count: 42 } }, () => undefined);
 });
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data/test.ts
index 41d49b6351ea..7860439b7707 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/circular_data/test.ts
@@ -1,29 +1,23 @@
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest('should be able to handle circular data', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+sentryTest(
+  'drops circular object attributes while preserving supported attributes on root and child spans',
+  async ({ getLocalTestUrl, page }) => {
+    sentryTest.skip(shouldSkipTracingTest());
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    const rootPromise = waitForStreamedSpan(page, span => span.name === 'circular_object_test_transaction');
+    const childPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'circular_object_test_span');
+    await page.goto(url);
 
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-
-  expect(eventData.type).toBe('transaction');
-  expect(eventData.transaction).toBe('circular_object_test_transaction');
-
-  expect(eventData.contexts).toMatchObject({
-    trace: {
-      data: { chicken: { lays: { contains: '[Circular ~]' } } },
-    },
-  });
-
-  expect(eventData?.spans?.[0]).toMatchObject({
-    data: { chicken: { lays: { contains: '[Circular ~]' } } },
-    op: 'circular_object_test_span',
-  });
-
-  await new Promise(resolve => setTimeout(resolve, 2000));
-});
+    const [rootSpan, childSpan] = await Promise.all([rootPromise, childPromise]);
+    expect(rootSpan.is_segment).toBe(true);
+    expect(childSpan.parent_span_id).toBe(rootSpan.span_id);
+    expect(rootSpan.attributes.count).toEqual({ type: 'integer', value: 42 });
+    expect(childSpan.attributes.count).toEqual({ type: 'integer', value: 42 });
+    expect(rootSpan.attributes.chicken).toBeUndefined();
+    expect(childSpan.attributes.chicken).toBeUndefined();
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-reject/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-reject/test.ts
index d8cecd5f09c7..c70b05e99fea 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-reject/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-reject/test.ts
@@ -1,7 +1,7 @@
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getMultipleSentryEnvelopeRequests, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { envelopeRequestParser, waitForErrorRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
   'should capture a promise rejection within an async startSpan callback',
@@ -11,17 +11,18 @@ sentryTest(
     }
 
     const url = await getLocalTestUrl({ testDir: __dirname });
-    const envelopePromise = getMultipleSentryEnvelopeRequests<Event>(page, 2);
+    const spanPromise = waitForStreamedSpan(page, span => span.name === 'parent_span');
+    const errorPromise = waitForErrorRequest(page);
 
     await page.goto(url);
 
     const clickPromise = page.getByText('Button 1').click();
 
-    const [, events] = await Promise.all([clickPromise, envelopePromise]);
-    const txn = events.find(event => event.type === 'transaction');
-    const err = events.find(event => !event.type);
+    const [, span, errorRequest] = await Promise.all([clickPromise, spanPromise, errorPromise]);
+    const err = envelopeRequestParser(errorRequest);
 
-    expect(txn).toMatchObject({ transaction: 'parent_span' });
+    expect(span.name).toBe('parent_span');
+    expect(span.status).toBe('ok');
 
     expect(err?.exception?.values?.[0]?.value).toBe(
       'Non-Error promise rejection captured with value: Async Promise Rejection',
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-throw-not-awaited/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-throw-not-awaited/test.ts
index 79ecf0f6e9e8..42c87027807f 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-throw-not-awaited/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-throw-not-awaited/test.ts
@@ -1,7 +1,7 @@
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getMultipleSentryEnvelopeRequests, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { envelopeRequestParser, waitForErrorRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
   "should capture a thrown error within an async startSpan callback that's not awaited properly",
@@ -9,7 +9,8 @@ sentryTest(
     if (shouldSkipTracingTest()) {
       sentryTest.skip();
     }
-    const envelopePromise = getMultipleSentryEnvelopeRequests<Event>(page, 2);
+    const spanPromise = waitForStreamedSpan(page, span => span.name === 'parent_span');
+    const errorPromise = waitForErrorRequest(page);
 
     const url = await getLocalTestUrl({ testDir: __dirname });
     await page.goto(url);
@@ -17,11 +18,11 @@ sentryTest(
     const clickPromise = page.getByText('Button 1').click();
 
     // awaiting both events simultaneously to avoid race conditions
-    const [, events] = await Promise.all([clickPromise, envelopePromise]);
-    const txn = events.find(event => event.type === 'transaction');
-    const err = events.find(event => !event.type);
+    const [, span, errorRequest] = await Promise.all([clickPromise, spanPromise, errorPromise]);
+    const err = envelopeRequestParser(errorRequest);
 
-    expect(txn).toMatchObject({ transaction: 'parent_span' });
+    expect(span.name).toBe('parent_span');
+    expect(span.status).toBe('error');
     expect(err?.exception?.values?.[0]?.value).toBe('Async Thrown Error');
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-throw/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-throw/test.ts
index 8f527b4e7238..ce66c78553bc 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-throw/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-async-throw/test.ts
@@ -1,13 +1,14 @@
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getMultipleSentryEnvelopeRequests, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { envelopeRequestParser, waitForErrorRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('should capture a thrown error within an async startSpan callback', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
     sentryTest.skip();
   }
-  const envelopePromise = getMultipleSentryEnvelopeRequests<Event>(page, 2);
+  const spanPromise = waitForStreamedSpan(page, span => span.name === 'parent_span');
+  const errorPromise = waitForErrorRequest(page);
 
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
@@ -15,10 +16,10 @@ sentryTest('should capture a thrown error within an async startSpan callback', a
   const clickPromise = page.getByText('Button 1').click();
 
   // awaiting both events simultaneously to avoid race conditions
-  const [, events] = await Promise.all([clickPromise, envelopePromise]);
-  const txn = events.find(event => event.type === 'transaction');
-  const err = events.find(event => !event.type);
+  const [, span, errorRequest] = await Promise.all([clickPromise, spanPromise, errorPromise]);
+  const err = envelopeRequestParser(errorRequest);
 
-  expect(txn).toMatchObject({ transaction: 'parent_span' });
+  expect(span.name).toBe('parent_span');
+  expect(span.status).toBe('error');
   expect(err?.exception?.values?.[0]?.value).toBe('Async Thrown Error');
 });
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-sync/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-sync/test.ts
index 9880598b9294..2a1dc368e98f 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-sync/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/error-sync/test.ts
@@ -1,11 +1,13 @@
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
+import type * as SentryBrowser from '@sentry/browser';
 import { sentryTest } from '../../../../utils/fixtures';
 import {
-  getMultipleSentryEnvelopeRequests,
+  envelopeRequestParser,
+  waitForErrorRequest,
   runScriptInSandbox,
   shouldSkipTracingTest,
 } from '../../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
   'should capture an error within a sync startSpan callback',
@@ -21,10 +23,20 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const errorEventsPromise = getMultipleSentryEnvelopeRequests<Event>(page, 2);
+    const spanPromise = waitForStreamedSpan(page, span => span.name === 'parent_span');
+    const errorPromise = waitForErrorRequest(page);
 
     await page.goto(url);
 
+    // Force a span envelope to arrive before the error so the error waiter must ignore it.
+    const precedingSpanPromise = waitForStreamedSpan(page, span => span.name === 'preceding_span');
+    await page.evaluate(async () => {
+      const Sentry = (window as typeof window & { Sentry: typeof SentryBrowser }).Sentry;
+      Sentry.startSpan({ name: 'preceding_span' }, () => undefined);
+      await Sentry.flush();
+    });
+    await precedingSpanPromise;
+
     await runScriptInSandbox(page, {
       content: `
       function run() {
@@ -37,12 +49,11 @@ sentryTest(
       `,
     });
 
-    const events = await errorEventsPromise;
-
-    const txn = events.find(event => event.type === 'transaction');
-    const err = events.find(event => !event.type);
+    const [span, errorRequest] = await Promise.all([spanPromise, errorPromise]);
+    const err = envelopeRequestParser(errorRequest);
 
-    expect(txn).toMatchObject({ transaction: 'parent_span' });
+    expect(span.name).toBe('parent_span');
+    expect(span.status).toBe('error');
     expect(err?.exception?.values?.[0]?.value).toBe('Sync Error');
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/init.js b/dev-packages/browser-integration-tests/suites/public-api/startSpan/init.js
index 527fad0d6f15..3364667c960c 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/init.js
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1.0,
   normalizeDepth: 10,
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans-in-scope/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans-in-scope/test.ts
index b3edbfac7dcf..b233cae07f97 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans-in-scope/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans-in-scope/test.ts
@@ -1,7 +1,7 @@
 import { expect } from '@playwright/test';
-import type { TransactionEvent } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
   'should send manually started parallel root spans outside of root context',
@@ -12,21 +12,21 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const transaction1ReqPromise = waitForTransactionRequest(page, event => event.transaction === 'test_span_1');
-    const transaction2ReqPromise = waitForTransactionRequest(page, event => event.transaction === 'test_span_2');
+    const transaction1ReqPromise = waitForStreamedSpan(page, event => event.name === 'test_span_1');
+    const transaction2ReqPromise = waitForStreamedSpan(page, event => event.name === 'test_span_2');
 
     await page.goto(url);
 
     const [transaction1Req, transaction2Req] = await Promise.all([transaction1ReqPromise, transaction2ReqPromise]);
 
-    const transaction1 = envelopeRequestParser<TransactionEvent>(transaction1Req);
-    const transaction2 = envelopeRequestParser<TransactionEvent>(transaction2Req);
+    const transaction1 = transaction1Req;
+    const transaction2 = transaction2Req;
 
     expect(transaction1).toBeDefined();
     expect(transaction2).toBeDefined();
 
-    const trace1Id = transaction1.contexts?.trace?.trace_id;
-    const trace2Id = transaction2.contexts?.trace?.trace_id;
+    const trace1Id = transaction1.trace_id;
+    const trace2Id = transaction2.trace_id;
 
     expect(trace1Id).toBeDefined();
     expect(trace2Id).toBeDefined();
@@ -34,7 +34,7 @@ sentryTest(
     // We use the same traceID from the root propagation context here
     expect(trace1Id).toBe(trace2Id);
 
-    expect(transaction1.contexts?.trace?.parent_span_id).toBeUndefined();
-    expect(transaction2.contexts?.trace?.parent_span_id).toBeUndefined();
+    expect(transaction1.parent_span_id).toBeUndefined();
+    expect(transaction2.parent_span_id).toBeUndefined();
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans-with-parentSpanId/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans-with-parentSpanId/test.ts
index 62cdeb9bf7c9..49d52dce3c61 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans-with-parentSpanId/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans-with-parentSpanId/test.ts
@@ -1,7 +1,7 @@
 import { expect } from '@playwright/test';
-import type { TransactionEvent } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
   'should send manually started parallel root spans in root context with parentSpanId',
@@ -12,26 +12,26 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const transaction1ReqPromise = waitForTransactionRequest(page, event => event.transaction === 'test_span_1');
-    const transaction2ReqPromise = waitForTransactionRequest(page, event => event.transaction === 'test_span_2');
+    const transaction1ReqPromise = waitForStreamedSpan(page, event => event.name === 'test_span_1');
+    const transaction2ReqPromise = waitForStreamedSpan(page, event => event.name === 'test_span_2');
 
     await page.goto(url);
 
     const [transaction1Req, transaction2Req] = await Promise.all([transaction1ReqPromise, transaction2ReqPromise]);
 
-    const transaction1 = envelopeRequestParser<TransactionEvent>(transaction1Req);
-    const transaction2 = envelopeRequestParser<TransactionEvent>(transaction2Req);
+    const transaction1 = transaction1Req;
+    const transaction2 = transaction2Req;
 
     expect(transaction1).toBeDefined();
     expect(transaction2).toBeDefined();
 
-    const trace1Id = transaction1.contexts?.trace?.trace_id;
-    const trace2Id = transaction2.contexts?.trace?.trace_id;
+    const trace1Id = transaction1.trace_id;
+    const trace2Id = transaction2.trace_id;
 
     expect(trace1Id).toBe('12345678901234567890123456789012');
     expect(trace2Id).toBe('12345678901234567890123456789012');
 
-    expect(transaction1.contexts?.trace?.parent_span_id).toBe('1234567890123456');
-    expect(transaction2.contexts?.trace?.parent_span_id).toBe('1234567890123456');
+    expect(transaction1.parent_span_id).toBe('1234567890123456');
+    expect(transaction2.parent_span_id).toBe('1234567890123456');
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans/test.ts
index 084b7100fa9b..1c1af189cc77 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/parallel-root-spans/test.ts
@@ -1,7 +1,7 @@
 import { expect } from '@playwright/test';
-import type { TransactionEvent } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('should send manually started parallel root spans in root context', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
@@ -10,21 +10,21 @@ sentryTest('should send manually started parallel root spans in root context', a
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const transaction1ReqPromise = waitForTransactionRequest(page, event => event.transaction === 'test_span_1');
-  const transaction2ReqPromise = waitForTransactionRequest(page, event => event.transaction === 'test_span_2');
+  const transaction1ReqPromise = waitForStreamedSpan(page, event => event.name === 'test_span_1');
+  const transaction2ReqPromise = waitForStreamedSpan(page, event => event.name === 'test_span_2');
 
   await page.goto(url);
 
   const [transaction1Req, transaction2Req] = await Promise.all([transaction1ReqPromise, transaction2ReqPromise]);
 
-  const transaction1 = envelopeRequestParser<TransactionEvent>(transaction1Req);
-  const transaction2 = envelopeRequestParser<TransactionEvent>(transaction2Req);
+  const transaction1 = transaction1Req;
+  const transaction2 = transaction2Req;
 
   expect(transaction1).toBeDefined();
   expect(transaction2).toBeDefined();
 
-  const trace1Id = transaction1.contexts?.trace?.trace_id;
-  const trace2Id = transaction2.contexts?.trace?.trace_id;
+  const trace1Id = transaction1.trace_id;
+  const trace2Id = transaction2.trace_id;
 
   expect(trace1Id).toBeDefined();
   expect(trace2Id).toBeDefined();
@@ -32,6 +32,6 @@ sentryTest('should send manually started parallel root spans in root context', a
   // We use the same traceID from the root propagation context here
   expect(trace1Id).toBe(trace2Id);
 
-  expect(transaction1.contexts?.trace?.parent_span_id).toBeUndefined();
-  expect(transaction2.contexts?.trace?.parent_span_id).toBeUndefined();
+  expect(transaction1.parent_span_id).toBeUndefined();
+  expect(transaction2.parent_span_id).toBeUndefined();
 });
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/setMeasurement/init.js b/dev-packages/browser-integration-tests/suites/public-api/startSpan/setMeasurement/init.js
new file mode 100644
index 000000000000..5f6b23836f8e
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/setMeasurement/init.js
@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  // setMeasurement is a legacy transaction API without a span v2 representation.
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracesSampleRate: 1.0,
+  normalizeDepth: 10,
+});
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/setMeasurement/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/setMeasurement/test.ts
index 2604470d0a50..8c257a2645cc 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/setMeasurement/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/setMeasurement/test.ts
@@ -3,19 +3,22 @@ import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
 import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
 
-sentryTest('should attach measurement to transaction', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+sentryTest(
+  'static tracing compatibility: should attach measurement to transaction',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
 
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  const event = await getFirstSentryEnvelopeRequest<Event>(page, url);
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    const event = await getFirstSentryEnvelopeRequest<Event>(page, url);
 
-  expect(event.measurements?.['metric.foo'].value).toBe(42);
-  expect(event.measurements?.['metric.bar'].value).toBe(1337);
-  expect(event.measurements?.['metric.baz'].value).toBe(1);
+    expect(event.measurements?.['metric.foo'].value).toBe(42);
+    expect(event.measurements?.['metric.bar'].value).toBe(1337);
+    expect(event.measurements?.['metric.baz'].value).toBe(1);
 
-  expect(event.measurements?.['metric.foo'].unit).toBe('ms');
-  expect(event.measurements?.['metric.bar'].unit).toBe('nanoseconds');
-  expect(event.measurements?.['metric.baz'].unit).toBe('');
-});
+    expect(event.measurements?.['metric.foo'].unit).toBe('ms');
+    expect(event.measurements?.['metric.bar'].unit).toBe('nanoseconds');
+    expect(event.measurements?.['metric.baz'].unit).toBe('');
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/streamed/subject.js b/dev-packages/browser-integration-tests/suites/public-api/startSpan/streamed/subject.js
deleted file mode 100644
index afe2527d8c7e..000000000000
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/streamed/subject.js
+++ /dev/null
@@ -1,15 +0,0 @@
-Sentry.startSpan({ name: 'test-span', op: 'test' }, () => {
-  Sentry.startSpan({ name: 'test-child-span', op: 'test-child' }, () => {
-    // noop
-  });
-
-  const inactiveSpan = Sentry.startInactiveSpan({ name: 'test-inactive-span' });
-  inactiveSpan.end();
-
-  Sentry.startSpanManual({ name: 'test-manual-span' }, span => {
-    // 2 = SPAN_STATUS_ERROR. The message must be preserved as the `sentry.status.message`
-    // attribute on the streamed span, since v2 statuses are reduced to ok/error.
-    span.setStatus({ code: 2, message: 'Connection Refused' });
-    span.end();
-  });
-});
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/streamed/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/streamed/test.ts
deleted file mode 100644
index 5cc3bd34f817..000000000000
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/streamed/test.ts
+++ /dev/null
@@ -1,295 +0,0 @@
-import { expect } from '@playwright/test';
-import { SDK_VERSION, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
-import {
-  SENTRY_SEGMENT_NAME_SOURCE,
-  SENTRY_SEGMENT_ID,
-  SENTRY_SEGMENT_NAME,
-  SENTRY_SDK_NAME,
-  SENTRY_SDK_VERSION,
-  SENTRY_TRACE_LIFECYCLE,
-  USER_AGENT_ORIGINAL,
-  SENTRY_STATUS_MESSAGE,
-  SENTRY_ENVIRONMENT,
-  SENTRY_SDK_INTEGRATIONS,
-  SENTRY_OP,
-  SENTRY_ORIGIN,
-} from '@sentry/conventions/attributes';
-
-sentryTest(
-  'sends a streamed span envelope if spanStreamingIntegration is enabled',
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const spanEnvelopePromise = waitForStreamedSpanEnvelope(page);
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-    await page.goto(url);
-
-    const spanEnvelope = await spanEnvelopePromise;
-
-    const envelopeHeader = spanEnvelope[0];
-    const envelopeItem = spanEnvelope[1];
-    const spans = envelopeItem[0][1].items;
-
-    expect(envelopeHeader).toEqual({
-      sdk: {
-        name: 'sentry.javascript.browser',
-        version: SDK_VERSION,
-      },
-      sent_at: expect.any(String),
-      trace: {
-        environment: 'production',
-        public_key: 'public',
-        sample_rand: expect.any(String),
-        sample_rate: '1',
-        sampled: 'true',
-        trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-        transaction: 'test-span',
-      },
-    });
-
-    const numericSampleRand = parseFloat(envelopeHeader.trace!.sample_rand!);
-    const traceId = envelopeHeader.trace!.trace_id;
-
-    expect(Number.isNaN(numericSampleRand)).toBe(false);
-
-    expect(envelopeItem).toEqual([
-      [
-        { content_type: 'application/vnd.sentry.items.span.v2+json', item_count: 4, type: 'span' },
-        {
-          version: 2,
-          ingest_settings: { infer_ip: 'auto', infer_user_agent: 'auto' },
-          items: expect.any(Array),
-        },
-      ],
-    ]);
-
-    const segmentSpanId = spans.find(s => !!s.is_segment)?.span_id;
-    expect(segmentSpanId).toBeDefined();
-
-    expect(spans).toEqual([
-      {
-        attributes: {
-          'sentry.is_localhost': { value: false, type: 'boolean' },
-          [SENTRY_OP]: {
-            type: 'string',
-            value: 'test-child',
-          },
-          [SENTRY_ORIGIN]: {
-            type: 'string',
-            value: 'manual',
-          },
-          [SENTRY_SDK_NAME]: {
-            type: 'string',
-            value: 'sentry.javascript.browser',
-          },
-          [SENTRY_SDK_VERSION]: {
-            type: 'string',
-            value: SDK_VERSION,
-          },
-          [SENTRY_SEGMENT_ID]: {
-            type: 'string',
-            value: segmentSpanId,
-          },
-          [SENTRY_SEGMENT_NAME]: {
-            type: 'string',
-            value: 'test-span',
-          },
-          [SENTRY_ENVIRONMENT]: {
-            type: 'string',
-            value: 'production',
-          },
-          [SENTRY_TRACE_LIFECYCLE]: {
-            type: 'string',
-            value: 'stream',
-          },
-          [USER_AGENT_ORIGINAL]: {
-            type: 'string',
-            value: expect.any(String),
-          },
-        },
-        end_timestamp: expect.any(Number),
-        is_segment: false,
-        name: 'test-child-span',
-        parent_span_id: segmentSpanId,
-        span_id: expect.stringMatching(/^[\da-f]{16}$/),
-        start_timestamp: expect.any(Number),
-        status: 'ok',
-        trace_id: traceId,
-      },
-      {
-        attributes: {
-          'sentry.is_localhost': { value: false, type: 'boolean' },
-          [SENTRY_ORIGIN]: {
-            type: 'string',
-            value: 'manual',
-          },
-          [SENTRY_SDK_NAME]: {
-            type: 'string',
-            value: 'sentry.javascript.browser',
-          },
-          [SENTRY_SDK_VERSION]: {
-            type: 'string',
-            value: SDK_VERSION,
-          },
-          [SENTRY_SEGMENT_ID]: {
-            type: 'string',
-            value: segmentSpanId,
-          },
-          [SENTRY_SEGMENT_NAME]: {
-            type: 'string',
-            value: 'test-span',
-          },
-          [SENTRY_ENVIRONMENT]: {
-            type: 'string',
-            value: 'production',
-          },
-          [SENTRY_TRACE_LIFECYCLE]: {
-            type: 'string',
-            value: 'stream',
-          },
-          [USER_AGENT_ORIGINAL]: {
-            type: 'string',
-            value: expect.any(String),
-          },
-        },
-        end_timestamp: expect.any(Number),
-        is_segment: false,
-        name: 'test-inactive-span',
-        parent_span_id: segmentSpanId,
-        span_id: expect.stringMatching(/^[\da-f]{16}$/),
-        start_timestamp: expect.any(Number),
-        status: 'ok',
-        trace_id: traceId,
-      },
-      {
-        attributes: {
-          'sentry.is_localhost': { value: false, type: 'boolean' },
-          [SENTRY_ORIGIN]: {
-            type: 'string',
-            value: 'manual',
-          },
-          [SENTRY_SDK_NAME]: {
-            type: 'string',
-            value: 'sentry.javascript.browser',
-          },
-          [SENTRY_SDK_VERSION]: {
-            type: 'string',
-            value: SDK_VERSION,
-          },
-          [SENTRY_SEGMENT_ID]: {
-            type: 'string',
-            value: segmentSpanId,
-          },
-          [SENTRY_SEGMENT_NAME]: {
-            type: 'string',
-            value: 'test-span',
-          },
-          [SENTRY_ENVIRONMENT]: {
-            type: 'string',
-            value: 'production',
-          },
-          [SENTRY_STATUS_MESSAGE]: {
-            type: 'string',
-            value: 'Connection Refused',
-          },
-          [SENTRY_TRACE_LIFECYCLE]: {
-            type: 'string',
-            value: 'stream',
-          },
-          [USER_AGENT_ORIGINAL]: {
-            type: 'string',
-            value: expect.any(String),
-          },
-        },
-        end_timestamp: expect.any(Number),
-        is_segment: false,
-        name: 'test-manual-span',
-        parent_span_id: segmentSpanId,
-        span_id: expect.stringMatching(/^[\da-f]{16}$/),
-        start_timestamp: expect.any(Number),
-        status: 'error',
-        trace_id: traceId,
-      },
-      {
-        attributes: {
-          'sentry.is_localhost': { value: false, type: 'boolean' },
-          'culture.calendar': {
-            type: 'string',
-            value: expect.any(String),
-          },
-          'culture.locale': {
-            type: 'string',
-            value: expect.any(String),
-          },
-          'culture.timezone': {
-            type: 'string',
-            value: expect.any(String),
-          },
-          [USER_AGENT_ORIGINAL]: {
-            type: 'string',
-            value: expect.any(String),
-          },
-          'url.full': {
-            type: 'string',
-            value: expect.any(String),
-          },
-          [SENTRY_OP]: {
-            type: 'string',
-            value: 'test',
-          },
-          [SENTRY_ORIGIN]: {
-            type: 'string',
-            value: 'manual',
-          },
-          [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: {
-            type: 'integer',
-            value: 1,
-          },
-          [SENTRY_SDK_NAME]: {
-            type: 'string',
-            value: 'sentry.javascript.browser',
-          },
-          [SENTRY_SDK_VERSION]: {
-            type: 'string',
-            value: SDK_VERSION,
-          },
-          [SENTRY_SDK_INTEGRATIONS]: {
-            type: 'array',
-            value: expect.arrayContaining(['SpanStreaming']),
-          },
-          [SENTRY_SEGMENT_ID]: {
-            type: 'string',
-            value: segmentSpanId,
-          },
-          [SENTRY_SEGMENT_NAME]: {
-            type: 'string',
-            value: 'test-span',
-          },
-          [SENTRY_SEGMENT_NAME_SOURCE]: {
-            type: 'string',
-            value: 'custom',
-          },
-          [SENTRY_ENVIRONMENT]: {
-            type: 'string',
-            value: 'production',
-          },
-          [SENTRY_TRACE_LIFECYCLE]: {
-            type: 'string',
-            value: 'stream',
-          },
-        },
-        end_timestamp: expect.any(Number),
-        is_segment: true,
-        name: 'test-span',
-        span_id: segmentSpanId,
-        start_timestamp: expect.any(Number),
-        status: 'ok',
-        trace_id: traceId,
-      },
-    ]);
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/public-api/startSpan/thenable-with-extra-methods/test.ts b/dev-packages/browser-integration-tests/suites/public-api/startSpan/thenable-with-extra-methods/test.ts
index 44008a93a3e9..ed6ab723310c 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/startSpan/thenable-with-extra-methods/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/startSpan/thenable-with-extra-methods/test.ts
@@ -1,6 +1,7 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('preserves extra methods on real jQuery jqXHR objects', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
@@ -8,7 +9,7 @@ sentryTest('preserves extra methods on real jQuery jqXHR objects', async ({ getL
   }
 
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const transactionPromise = waitForTransactionRequest(page);
+  const spanPromise = waitForStreamedSpan(page, span => span.name === 'test-jqxhr');
 
   await page.goto(url);
 
@@ -27,9 +28,9 @@ sentryTest('preserves extra methods on real jQuery jqXHR objects', async ({ getL
   const testError = await page.evaluate(() => (window as any).jqXHRTestError);
   expect(testError).toBeNull();
 
-  const transaction = envelopeRequestParser(await transactionPromise);
-  expect(transaction.transaction).toBe('test-jqxhr');
-  expect(transaction.spans).toBeDefined();
+  const span = await spanPromise;
+  expect(span.name).toBe('test-jqxhr');
+  expect(span.is_segment).toBe(true);
 });
 
 sentryTest('aborted request rejects promise correctly', async ({ getLocalTestUrl, page }) => {
diff --git a/dev-packages/browser-integration-tests/suites/tracing/bindScopeToEmitter/init.js b/dev-packages/browser-integration-tests/suites/tracing/bindScopeToEmitter/init.js
index bd0421b32761..7c200c542c56 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/bindScopeToEmitter/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/bindScopeToEmitter/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/bindScopeToEmitter/test.ts b/dev-packages/browser-integration-tests/suites/tracing/bindScopeToEmitter/test.ts
index f95829febe1d..3b269806fc84 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/bindScopeToEmitter/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/bindScopeToEmitter/test.ts
@@ -1,11 +1,7 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  shouldSkipCdnBundleTest,
-  shouldSkipTracingTest,
-  waitForTransactionRequest,
-} from '../../../utils/helpers';
+import { shouldSkipCdnBundleTest, shouldSkipTracingTest } from '../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../utils/spanUtils';
 
 sentryTest('bindScopeToEmitter runs listeners with the bound scope active', async ({ getLocalTestUrl, page }) => {
   // `bindScopeToEmitter` is not exported from the CDN bundles, only from npm.
@@ -13,19 +9,19 @@ sentryTest('bindScopeToEmitter runs listeners with the bound scope active', asyn
     sentryTest.skip();
   }
 
-  const req = waitForTransactionRequest(page, e => e.transaction === 'parent');
+  const rootSpanPromise = waitForStreamedSpan(page, span => span.name === 'parent');
+  const childSpanPromise = waitForStreamedSpan(page, span => span.name === 'child-bound');
 
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
 
-  const parentEvent = envelopeRequestParser(await req);
-  const parentSpanId = parentEvent.contexts?.trace?.span_id;
-  const parentTraceId = parentEvent.contexts?.trace?.trace_id;
+  const [parentEvent, childBound] = await Promise.all([rootSpanPromise, childSpanPromise]);
+  const parentSpanId = parentEvent.span_id;
+  const parentTraceId = parentEvent.trace_id;
   expect(parentSpanId).toMatch(/[a-f\d]{16}/);
 
   // The listener fired while no span was active, yet `child-bound` is nested under `parent`
   // because the parent scope was bound to the emitter.
-  const childBound = parentEvent.spans?.find(s => s.description === 'child-bound');
   expect(childBound).toBeDefined();
   expect(childBound?.parent_span_id).toBe(parentSpanId);
   expect(childBound?.trace_id).toBe(parentTraceId);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegrationShim/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegrationShim/init.js
index fdca84ba5c42..3595ea724749 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegrationShim/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegrationShim/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   sampleRate: 1,
   integrations: [Sentry.browserTracingIntegration()],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/full-tracing/init.js b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/full-tracing/init.js
index 65cfbab96ee2..b2280b70e307 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/full-tracing/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/full-tracing/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/full-tracing/test.ts b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/full-tracing/test.ts
index f53e4ef0615f..ecca9689b964 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/full-tracing/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/full-tracing/test.ts
@@ -1,13 +1,15 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import type { EventAndTraceHeader } from '../../../../utils/helpers';
 import {
   eventAndTraceHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
   shouldSkipTracingTest,
   waitForErrorRequest,
-  waitForTransactionRequest,
 } from '../../../../utils/helpers';
+import {
+  collectStreamedSpans,
+  waitForStreamedSpanAndTraceHeader,
+  waitForStreamedSpanAndTraceHeaderOnUrl,
+} from '../../../../utils/spanUtils';
 
 const SAMPLED_TRACE_ID = '12345678901234567890123456789012';
 const SAMPLED_SPAN_ID = '1234567890123456';
@@ -28,26 +30,24 @@ sentryTest(
       return route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({}) });
     });
 
-    // Discard the initial pageload transaction.
-    await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(page, url, eventAndTraceHeaderRequestParser);
+    await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
 
-    const transactionPromise = waitForTransactionRequest(
+    const spanPromise = waitForStreamedSpanAndTraceHeader(
       page,
-      event => event.contexts?.trace?.trace_id === SAMPLED_TRACE_ID,
+      span => span.is_segment && span.name === 'continued-sampled',
     );
 
     await page.locator('#sampled').click();
 
-    const req = await transactionPromise;
-    const transaction = eventAndTraceHeaderRequestParser(req);
-    const traceContext = transaction[0].contexts?.trace;
+    const span = await spanPromise;
+    const traceContext = span[0];
 
-    expect(traceContext?.trace_id).toBe(SAMPLED_TRACE_ID);
-    expect(traceContext?.parent_span_id).toBe(SAMPLED_SPAN_ID);
-    expect(transaction[0].transaction).toBe('continued-sampled');
+    expect(traceContext.trace_id).toBe(SAMPLED_TRACE_ID);
+    expect(traceContext.parent_span_id).toBe(SAMPLED_SPAN_ID);
+    expect(span[0].name).toBe('continued-sampled');
 
     // The incoming positive sampling decision is honored regardless of local config.
-    expect(transaction[1]?.sampled).toBe('true');
+    expect(span[1]?.sampled).toBe('true');
 
     // Outgoing request carries the continued trace.
     const outgoingRequest = await outgoingRequestPromise;
@@ -58,7 +58,7 @@ sentryTest(
 );
 
 sentryTest(
-  'continueTrace continues an unsampled incoming trace without emitting a transaction',
+  'continueTrace continues an unsampled incoming trace without emitting a span',
   async ({ getLocalTestUrl, page }) => {
     if (shouldSkipTracingTest()) {
       sentryTest.skip();
@@ -71,11 +71,11 @@ sentryTest(
       return route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({}) });
     });
 
-    await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(page, url, eventAndTraceHeaderRequestParser);
+    await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
 
-    // The captured error carries the continued (unsampled) trace even though no transaction is sent.
     const errorPromise = waitForErrorRequest(page);
 
+    const spans = collectStreamedSpans(page);
     await page.locator('#unsampled').click();
 
     const [errorEvent] = eventAndTraceHeaderRequestParser(await errorPromise);
@@ -85,6 +85,8 @@ sentryTest(
     const outgoingRequest = await outgoingRequestPromise;
     const headers = await outgoingRequest.allHeaders();
     expect(headers['sentry-trace']).toMatch(new RegExp(`^${UNSAMPLED_TRACE_ID}-[a-f0-9]{16}-0$`));
+    await page.evaluate(() => (window as any).Sentry.flush());
+    expect(spans.some(span => span.trace_id === UNSAMPLED_TRACE_ID)).toBe(false);
   },
 );
 
@@ -101,20 +103,18 @@ sentryTest(
       return route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({}) });
     });
 
-    await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(page, url, eventAndTraceHeaderRequestParser);
+    await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
 
-    // With tracesSampleRate=1 the deferred decision resolves to sampled, so a transaction is emitted
-    // on the continued trace id.
-    const transactionPromise = waitForTransactionRequest(
+    const spanPromise = waitForStreamedSpanAndTraceHeader(
       page,
-      event => event.contexts?.trace?.trace_id === DEFERRED_TRACE_ID,
+      span => span.is_segment && span.name === 'continued-deferred',
     );
 
     await page.locator('#deferred').click();
 
-    const transaction = eventAndTraceHeaderRequestParser(await transactionPromise);
-    expect(transaction[0].contexts?.trace?.trace_id).toBe(DEFERRED_TRACE_ID);
-    expect(transaction[0].transaction).toBe('continued-deferred');
+    const span = await spanPromise;
+    expect(span[0].trace_id).toBe(DEFERRED_TRACE_ID);
+    expect(span[0].name).toBe('continued-deferred');
   },
 );
 
@@ -129,21 +129,20 @@ sentryTest('continueTrace with no incoming trace starts a fresh trace', async ({
     return route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({}) });
   });
 
-  const [pageloadEvent] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+  const [pageloadEvent] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
+  const pageloadTraceId = pageloadEvent.trace_id;
+
+  const spanPromise = waitForStreamedSpanAndTraceHeader(
     page,
-    url,
-    eventAndTraceHeaderRequestParser,
+    span => span.is_segment && span.name === 'continued-noTrace',
   );
-  const pageloadTraceId = pageloadEvent.contexts?.trace?.trace_id;
-
-  const transactionPromise = waitForTransactionRequest(page, event => event.transaction === 'continued-noTrace');
 
   await page.locator('#noTrace').click();
 
-  const transaction = eventAndTraceHeaderRequestParser(await transactionPromise);
-  const traceId = transaction[0].contexts?.trace?.trace_id;
+  const span = await spanPromise;
+  const traceId = span[0].trace_id;
 
   expect(traceId).toMatch(/^[a-f0-9]{32}$/);
   expect(traceId).not.toBe(pageloadTraceId);
-  expect(transaction[0].contexts?.trace).not.toHaveProperty('parent_span_id');
+  expect(span[0]).not.toHaveProperty('parent_span_id');
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracesSampleRate-zero/init.js b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracesSampleRate-zero/init.js
index 06a40a8e55ec..5e9c86105ae7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracesSampleRate-zero/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracesSampleRate-zero/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracesSampleRate-zero/test.ts b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracesSampleRate-zero/test.ts
index 77956fb134bf..e7321abb38ee 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracesSampleRate-zero/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracesSampleRate-zero/test.ts
@@ -4,8 +4,8 @@ import {
   eventAndTraceHeaderRequestParser,
   shouldSkipTracingTest,
   waitForErrorRequest,
-  waitForTransactionRequest,
 } from '../../../../utils/helpers';
+import { collectStreamedSpans, waitForStreamedSpanAndTraceHeader } from '../../../../utils/spanUtils';
 
 const SAMPLED_TRACE_ID = '12345678901234567890123456789012';
 const SAMPLED_SPAN_ID = '1234567890123456';
@@ -26,18 +26,17 @@ sentryTest(
       return route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({}) });
     });
 
-    // With tracesSampleRate=0 there is no pageload transaction, so we only wait for the continued one.
-    const transactionPromise = waitForTransactionRequest(
+    const spanPromise = waitForStreamedSpanAndTraceHeader(
       page,
-      event => event.contexts?.trace?.trace_id === SAMPLED_TRACE_ID,
+      span => span.is_segment && span.name === 'continued-sampled',
     );
 
     await page.goto(url);
     await page.locator('#sampled').click();
 
-    const transaction = eventAndTraceHeaderRequestParser(await transactionPromise);
-    expect(transaction[0].contexts?.trace?.trace_id).toBe(SAMPLED_TRACE_ID);
-    expect(transaction[0].contexts?.trace?.parent_span_id).toBe(SAMPLED_SPAN_ID);
+    const span = await spanPromise;
+    expect(span[0].trace_id).toBe(SAMPLED_TRACE_ID);
+    expect(span[0].parent_span_id).toBe(SAMPLED_SPAN_ID);
 
     const outgoingRequest = await outgoingRequestPromise;
     const headers = await outgoingRequest.allHeaders();
@@ -46,7 +45,7 @@ sentryTest(
 );
 
 sentryTest(
-  'continueTrace does not emit a transaction for a deferred decision with tracesSampleRate=0',
+  'continueTrace does not emit a span for a deferred decision with tracesSampleRate=0',
   async ({ getLocalTestUrl, page }) => {
     if (shouldSkipTracingTest()) {
       sentryTest.skip();
@@ -61,9 +60,9 @@ sentryTest(
 
     await page.goto(url);
 
-    // The captured error carries the continued trace even though no transaction is sent.
     const errorPromise = waitForErrorRequest(page);
 
+    const spans = collectStreamedSpans(page);
     await page.locator('#deferred').click();
 
     const [errorEvent] = eventAndTraceHeaderRequestParser(await errorPromise);
@@ -73,6 +72,8 @@ sentryTest(
     const outgoingRequest = await outgoingRequestPromise;
     const headers = await outgoingRequest.allHeaders();
     expect(headers['sentry-trace']).toMatch(new RegExp(`^${DEFERRED_TRACE_ID}-[a-f0-9]{16}-0$`));
+    await page.evaluate(() => (window as any).Sentry.flush());
+    expect(spans.some(span => span.trace_id === DEFERRED_TRACE_ID)).toBe(false);
   },
 );
 
@@ -94,6 +95,7 @@ sentryTest(
 
     const errorPromise = waitForErrorRequest(page);
 
+    const spans = collectStreamedSpans(page);
     await page.locator('#unsampled').click();
 
     const [errorEvent] = eventAndTraceHeaderRequestParser(await errorPromise);
@@ -102,5 +104,7 @@ sentryTest(
     const outgoingRequest = await outgoingRequestPromise;
     const headers = await outgoingRequest.allHeaders();
     expect(headers['sentry-trace']).toMatch(new RegExp(`^${UNSAMPLED_TRACE_ID}-[a-f0-9]{16}-0$`));
+    await page.evaluate(() => (window as any).Sentry.flush());
+    expect(spans.some(span => span.trace_id === UNSAMPLED_TRACE_ID)).toBe(false);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracing-without-performance/init.js b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracing-without-performance/init.js
index 9eb615a288dd..79d41d4ce43c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracing-without-performance/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracing-without-performance/init.js
@@ -5,7 +5,6 @@ window.Sentry = Sentry;
 // In the browser, "tracing without performance" (TwP) means enabling `browserTracingIntegration`
 // but not setting `tracesSampleRate`.
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracing-without-performance/test.ts b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracing-without-performance/test.ts
index e9ebd9dcec57..bbf746fdc4df 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracing-without-performance/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/continueTrace/tracing-without-performance/test.ts
@@ -10,7 +10,7 @@ const SAMPLED_TRACE_ID = '12345678901234567890123456789012';
 const UNSAMPLED_TRACE_ID = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
 const DEFERRED_TRACE_ID = 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
 
-// In TwP mode no transactions are emitted, so each variant is observed via the captured error event
+// In TwP mode no spans are emitted, so each variant is observed via the captured error event
 // (which carries the continued trace on its `contexts.trace`) and the outgoing request headers.
 const VARIANTS = [
   { button: 'sampled', traceId: SAMPLED_TRACE_ID, sampledFlag: '-1' },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/dsc-txn-name-update/init.js b/dev-packages/browser-integration-tests/suites/tracing/dsc-txn-name-update/init.js
index 01c1dc121daf..b6c2bad12033 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/dsc-txn-name-update/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/dsc-txn-name-update/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration({ instrumentNavigation: false, instrumentPageLoad: false })],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/dsc-txn-name-update/test.ts b/dev-packages/browser-integration-tests/suites/tracing/dsc-txn-name-update/test.ts
index 7d33497a988b..23ec0ce9edda 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/dsc-txn-name-update/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/dsc-txn-name-update/test.ts
@@ -8,6 +8,7 @@ import {
   getMultipleSentryEnvelopeRequests,
   shouldSkipTracingTest,
 } from '../../../utils/helpers';
+import { waitForStreamedSpanAndTraceHeader } from '../../../utils/spanUtils';
 
 sentryTest('updates the DSC when the txn name is updated and high-quality', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
@@ -38,7 +39,7 @@ sentryTest('updates the DSC when the txn name is updated and high-quality', asyn
   8. Make request and check that baggage has updated HQ txn name
   9. Capture error and check that envelope trace header has updated HQ txn name
   10. End span and check that envelope trace header has updated HQ txn name
-  11. Make another request and check that there's no span information in baggage
+  11. Make another request and check that it starts its own segment in the same trace
   12. Capture an error and check that envelope trace header has no span information
   */
 
@@ -133,16 +134,9 @@ sentryTest('updates the DSC when the txn name is updated and high-quality', asyn
   });
 
   // 10
-  const txnEventPromise = getMultipleSentryEnvelopeRequests<EventAndTraceHeader>(
-    page,
-    1,
-    { envelopeType: 'transaction' },
-    eventAndTraceHeaderRequestParser,
-  );
-
+  const spanPromise = waitForStreamedSpanAndTraceHeader(page, span => span.name === 'updated-root-span-2');
   await page.locator('#btnEndSpan').click();
-
-  const [txnEvent, txnEnvelopeTraceHeader] = (await txnEventPromise)[0];
+  const [span, txnEnvelopeTraceHeader] = await spanPromise;
   expect(txnEnvelopeTraceHeader).toEqual({
     environment: 'production',
     public_key: 'public',
@@ -154,16 +148,28 @@ sentryTest('updates the DSC when the txn name is updated and high-quality', asyn
     sample_rand: expect.any(String),
   });
 
-  expect(txnEvent.transaction).toEqual('updated-root-span-2');
+  expect(span.name).toEqual('updated-root-span-2');
 
   // 11
+  const requestSpanPromise = waitForStreamedSpanAndTraceHeader(
+    page,
+    span => span.name === 'GET sentry-test-site.example',
+  );
   const baggageItemsAfterEnd = await makeRequestAndGetBaggageItems(page);
   expect(baggageItemsAfterEnd).toEqual([
     'sentry-environment=production',
     'sentry-public_key=public',
     'sentry-release=1.1.1',
+    expect.stringMatching(/sentry-sample_rand=0\.\d+/),
+    'sentry-sample_rate=1',
+    'sentry-sampled=true',
     `sentry-trace_id=${traceId}`,
+    'sentry-transaction=GET%20sentry-test-site.example',
   ]);
+  const [requestSpan] = await requestSpanPromise;
+  expect(requestSpan.is_segment).toBe(true);
+  expect(requestSpan.trace_id).toBe(traceId);
+  expect(requestSpan).not.toHaveProperty('parent_span_id');
 
   // 12
   const errorEnvelopeTraceHeaderAfterEnd = await captureErrorAndGetEnvelopeTraceHeader(page);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/envelope-header-transaction-name/init.js b/dev-packages/browser-integration-tests/suites/tracing/envelope-header-transaction-name/init.js
index 66fe57da4d6f..376c14f7b559 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/envelope-header-transaction-name/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/envelope-header-transaction-name/init.js
@@ -4,7 +4,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   environment: 'production',
diff --git a/dev-packages/browser-integration-tests/suites/tracing/envelope-header-transaction-name/test.ts b/dev-packages/browser-integration-tests/suites/tracing/envelope-header-transaction-name/test.ts
index 23043ebc770d..9e146d46bfac 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/envelope-header-transaction-name/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/envelope-header-transaction-name/test.ts
@@ -1,11 +1,7 @@
 import { expect } from '@playwright/test';
-import type { EventEnvelopeHeaders } from '@sentry/core';
 import { sentryTest } from '../../../utils/fixtures';
-import {
-  envelopeHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
-  shouldSkipTracingTest,
-} from '../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../utils/helpers';
+import { waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../utils/spanUtils';
 
 sentryTest(
   'should only include transaction name if source is better than an unparameterized URL',
@@ -16,13 +12,13 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const envHeader = await getFirstSentryEnvelopeRequest<EventEnvelopeHeaders>(page, url, envelopeHeaderRequestParser);
+    const [, traceHeader] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
 
-    expect(envHeader.trace).toBeDefined();
-    expect(envHeader.trace).toEqual({
+    expect(traceHeader).toBeDefined();
+    expect(traceHeader).toEqual({
       environment: 'production',
       sample_rate: '1',
-      transaction: expect.stringContaining('/index.html'),
+      transaction: 'Pageload',
       trace_id: expect.stringMatching(/[a-f\d]{32}/),
       public_key: 'public',
       sampled: 'true',
diff --git a/dev-packages/browser-integration-tests/suites/tracing/envelope-header/init.js b/dev-packages/browser-integration-tests/suites/tracing/envelope-header/init.js
index b90217ce3c39..79b4b0c89555 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/envelope-header/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/envelope-header/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: [/.*/],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/envelope-header/test.ts b/dev-packages/browser-integration-tests/suites/tracing/envelope-header/test.ts
index 7617b498efb2..242bf9ff462d 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/envelope-header/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/envelope-header/test.ts
@@ -1,14 +1,10 @@
 import { expect } from '@playwright/test';
-import type { EventEnvelopeHeaders } from '@sentry/core';
 import { sentryTest } from '../../../utils/fixtures';
-import {
-  envelopeHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
-  shouldSkipTracingTest,
-} from '../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../utils/helpers';
+import { waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../utils/spanUtils';
 
 sentryTest(
-  'should send dynamic sampling context data in trace envelope header of a transaction envelope',
+  'should send dynamic sampling context data in trace envelope header of a streamed span envelope',
   async ({ getLocalTestUrl, page }) => {
     if (shouldSkipTracingTest()) {
       sentryTest.skip();
@@ -16,14 +12,14 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const envHeader = await getFirstSentryEnvelopeRequest<EventEnvelopeHeaders>(page, url, envelopeHeaderRequestParser);
+    const [, traceHeader] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
 
     // In this test, we don't expect trace.transaction to be present because without a custom routing instrumentation
     // we for now don't have parameterization. This might change in the future but for now the only way of having
     // transaction in DSC with the default browserTracingIntegration is when the transaction name is set manually.
     // This scenario is covered in another integration test (envelope-header-transaction-name).
-    expect(envHeader.trace).toBeDefined();
-    expect(envHeader.trace).toEqual({
+    expect(traceHeader).toBeDefined();
+    expect(traceHeader).toEqual({
       environment: 'production',
       sample_rate: '1',
       trace_id: expect.stringMatching(/[a-f\d]{32}/),
diff --git a/dev-packages/browser-integration-tests/suites/tracing/http-client-span-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/http-client-span/init.js
similarity index 54%
rename from dev-packages/browser-integration-tests/suites/tracing/http-client-span-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/http-client-span/init.js
index 94db849f5fde..10e5ac1b84eb 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/http-client-span-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/http-client-span/init.js
@@ -4,10 +4,7 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [
-    Sentry.browserTracingIntegration({ instrumentPageLoad: false, instrumentNavigation: false }),
-    Sentry.spanStreamingIntegration(),
-  ],
+  integrations: [Sentry.browserTracingIntegration({ instrumentPageLoad: false, instrumentNavigation: false })],
   tracesSampleRate: 1,
   sendClientReports: true,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/http-client-span-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/http-client-span/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/http-client-span-streamed/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/http-client-span/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/http-client-span-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/http-client-span/test.ts
similarity index 63%
rename from dev-packages/browser-integration-tests/suites/tracing/http-client-span-streamed/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/http-client-span/test.ts
index 81d41ada7ccc..634068358415 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/http-client-span-streamed/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/http-client-span/test.ts
@@ -1,10 +1,11 @@
+import { SENTRY_ORIGIN, SENTRY_OP, URL_DOMAIN } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../utils/fixtures';
 import { shouldSkipTracingTest } from '../../../utils/helpers';
 import { getSpanOp, waitForStreamedSpan } from '../../../utils/spanUtils';
 
 sentryTest(
-  'sends http.client span for fetch requests without an active span when span streaming is enabled',
+  'sends http.client span for fetch requests without an active span with default span streaming',
   async ({ getLocalTestUrl, page }) => {
     sentryTest.skip(shouldSkipTracingTest());
 
@@ -24,9 +25,11 @@ sentryTest(
 
     const span = await spanPromise;
 
+    expect(span.is_segment).toBe(true);
+    expect(span).not.toHaveProperty('parent_span_id');
     expect(span.name).toBe('GET sentry-test-site.example');
-    expect(span.attributes['sentry.origin']).toEqual({ type: 'string', value: 'auto.http.browser' });
-    expect(span.attributes['sentry.op']).toEqual({ type: 'string', value: 'http.client' });
-    expect(span.attributes['url.domain']).toEqual({ type: 'string', value: 'sentry-test-site.example' });
+    expect(span.attributes[SENTRY_ORIGIN]).toEqual({ type: 'string', value: 'auto.http.browser' });
+    expect(span.attributes[SENTRY_OP]).toEqual({ type: 'string', value: 'http.client' });
+    expect(span.attributes[URL_DOMAIN]).toEqual({ type: 'string', value: 'sentry-test-site.example' });
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-static/init.js
new file mode 100644
index 000000000000..9e5c6fa2f2e9
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-static/init.js
@@ -0,0 +1,50 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [
+    Sentry.browserTracingIntegration({
+      idleTimeout: 3000,
+      finalTimeout: 3000,
+      childSpanTimeout: 3000,
+    }),
+  ],
+  ignoreSpans: [/ignore/],
+  tracesSampleRate: 1,
+  debug: true,
+});
+
+const waitFor = time => new Promise(resolve => setTimeout(resolve, time));
+
+Sentry.startSpanManual(
+  {
+    name: 'take-me',
+  },
+  async span => {
+    await waitFor(500);
+    span.end();
+  },
+);
+
+Sentry.startSpanManual(
+  {
+    name: 'ignore-me',
+  },
+  async span => {
+    await waitFor(1500);
+    span.end();
+  },
+);
+
+Sentry.startSpanManual(
+  {
+    name: 'ignore-me-too',
+  },
+  async span => {
+    await waitFor(2500);
+    span.end();
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-static/test.ts
new file mode 100644
index 000000000000..bc752c9cdf41
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-static/test.ts
@@ -0,0 +1,29 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../utils/helpers';
+
+sentryTest(
+  'adjusts the end timestamp of the root idle span if child spans are ignored',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    await page.goto(url);
+
+    const eventData = envelopeRequestParser(await pageloadRequestPromise);
+
+    const { start_timestamp: startTimestamp, timestamp: endTimestamp } = eventData;
+    const durationSeconds = endTimestamp! - startTimestamp!;
+
+    const spans = eventData.spans || [];
+
+    expect(durationSeconds).toBeGreaterThan(0);
+    expect(durationSeconds).toBeLessThan(1.5);
+
+    expect(spans.some(span => span.description === 'take-me')).toBe(true);
+    expect(spans.some(span => span.description?.includes('ignore-me'))).toBe(false);
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/init.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/attributes/init.js
similarity index 82%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/attributes/init.js
index f57cb5bfaa57..d4000b23ae24 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/attributes/init.js
@@ -4,7 +4,7 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.spanStreamingIntegration()],
+  integrations: [],
   ignoreSpans: [{ attributes: { 'http.response.status_code': 200 } }],
   tracesSampleRate: 1,
   debug: true,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/subject.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/attributes/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/attributes/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/test.ts b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/attributes/test.ts
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/attributes/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/attributes/test.ts
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/child/init.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/child/init.js
similarity index 82%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/child/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/child/init.js
index 086383ccdd54..4346f1d8f878 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/child/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/child/init.js
@@ -4,7 +4,7 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.spanStreamingIntegration()],
+  integrations: [],
   ignoreSpans: [/ignore/, { op: 'ignored-op' }],
   parentSpanIsAlwaysRootSpan: false,
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/child/subject.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/child/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/child/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/child/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/child/test.ts b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/child/test.ts
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/child/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/child/test.ts
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/init.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/init.js
similarity index 76%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/init.js
index 588769fbea94..df2361332e75 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/init.js
@@ -4,7 +4,7 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration()],
   ignoreSpans: [/ignored-click-listener/],
   parentSpanIsAlwaysRootSpan: false,
   tracePropagationTargets: ['sentry-test-external.io'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/subject.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/template.html b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/test.ts b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/test.ts
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-child/test.ts
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/init.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/init.js
similarity index 76%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/init.js
index 788e05781740..2bd0d43829a3 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/init.js
@@ -4,7 +4,7 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration()],
   ignoreSpans: [{ attributes: { 'sentry.op': 'http.client' } }],
   tracePropagationTargets: ['sentry-test-external.io'],
   tracesSampleRate: 0,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/subject.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/template.html b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/test.ts b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/test.ts
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-http-client/test.ts
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/init.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/init.js
similarity index 74%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/init.js
index 616ae3d942f6..8233baa577e3 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/init.js
@@ -4,7 +4,7 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration()],
   ignoreSpans: [{ op: 'pageload' }],
   tracePropagationTargets: ['sentry-test-external.io'],
   tracesSampleRate: 0,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/subject.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/template.html b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/test.ts b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/init.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/init.js
index 9e5c6fa2f2e9..385a1cdf1df5 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/segment/init.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/segment/init.js
similarity index 79%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/segment/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/segment/init.js
index 3a710324f0e1..6f5aa2608b79 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/segment/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/segment/init.js
@@ -4,7 +4,7 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.spanStreamingIntegration()],
+  integrations: [],
   ignoreSpans: [/ignore/],
   tracesSampleRate: 1,
   debug: true,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/segment/subject.js b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/segment/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/segment/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/segment/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/segment/test.ts b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/segment/test.ts
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/segment/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/segment/test.ts
diff --git a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/test.ts
index bc752c9cdf41..aca9af0055e6 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/ignoreSpans/test.ts
@@ -1,6 +1,7 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../utils/spanUtils';
 
 sentryTest(
   'adjusts the end timestamp of the root idle span if child spans are ignored',
@@ -9,21 +10,22 @@ sentryTest(
       sentryTest.skip();
     }
 
-    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
+    const spans = collectStreamedSpans(page);
+    const pageloadRequestPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
     const url = await getLocalTestUrl({ testDir: __dirname });
     await page.goto(url);
 
-    const eventData = envelopeRequestParser(await pageloadRequestPromise);
+    const eventData = await pageloadRequestPromise;
 
-    const { start_timestamp: startTimestamp, timestamp: endTimestamp } = eventData;
+    const { start_timestamp: startTimestamp, end_timestamp: endTimestamp } = eventData;
     const durationSeconds = endTimestamp! - startTimestamp!;
 
-    const spans = eventData.spans || [];
+    await page.evaluate(() => (window as any).Sentry.flush());
 
     expect(durationSeconds).toBeGreaterThan(0);
     expect(durationSeconds).toBeLessThan(1.5);
 
-    expect(spans.some(span => span.description === 'take-me')).toBe(true);
-    expect(spans.some(span => span.description?.includes('ignore-me'))).toBe(false);
+    expect(spans.some(span => span.name === 'take-me')).toBe(true);
+    expect(spans.some(span => span.name?.includes('ignore-me'))).toBe(false);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/init.js b/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-static/init.js
similarity index 75%
rename from dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/linking-addLink-static/init.js
index 9afcee48dc4a..bd0421b32761 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-static/init.js
@@ -3,7 +3,7 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.spanStreamingIntegration()],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-static/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/linking-addLink-streamed/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/linking-addLink-static/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-static/test.ts
new file mode 100644
index 000000000000..063569d95996
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-static/test.ts
@@ -0,0 +1,77 @@
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import type { SpanJSON, TransactionEvent } from '@sentry/core';
+import { sentryTest } from '../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../utils/helpers';
+
+sentryTest('should link spans with addLink() in trace context', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const rootSpan1Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan1');
+  const rootSpan2Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan2');
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
+
+  const rootSpan1 = envelopeRequestParser<TransactionEvent>(await rootSpan1Promise);
+  const rootSpan2 = envelopeRequestParser<TransactionEvent>(await rootSpan2Promise);
+
+  const rootSpan1_traceId = rootSpan1.contexts?.trace?.trace_id as string;
+  const rootSpan1_spanId = rootSpan1.contexts?.trace?.span_id as string;
+
+  expect(rootSpan1.transaction).toBe('rootSpan1');
+  expect(rootSpan1.spans).toEqual([]);
+
+  expect(rootSpan2.transaction).toBe('rootSpan2');
+  expect(rootSpan2.spans).toEqual([]);
+
+  expect(rootSpan2.contexts?.trace?.links?.length).toBe(1);
+  expect(rootSpan2.contexts?.trace?.links?.[0]).toMatchObject({
+    attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' },
+    sampled: true,
+    span_id: rootSpan1_spanId,
+    trace_id: rootSpan1_traceId,
+  });
+});
+
+sentryTest('should link spans with addLink() in nested startSpan() calls', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const rootSpan1Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan1');
+  const rootSpan3Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan3');
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
+
+  const rootSpan1 = envelopeRequestParser<TransactionEvent>(await rootSpan1Promise);
+  const rootSpan3 = envelopeRequestParser<TransactionEvent>(await rootSpan3Promise);
+
+  const rootSpan1_traceId = rootSpan1.contexts?.trace?.trace_id as string;
+  const rootSpan1_spanId = rootSpan1.contexts?.trace?.span_id as string;
+
+  const [childSpan_3_1, childSpan_3_2] = rootSpan3.spans as [SpanJSON, SpanJSON];
+  const rootSpan3_traceId = rootSpan3.contexts?.trace?.trace_id as string;
+  const rootSpan3_spanId = rootSpan3.contexts?.trace?.span_id as string;
+
+  expect(rootSpan3.transaction).toBe('rootSpan3');
+
+  expect(childSpan_3_1.description).toBe('childSpan3.1');
+  expect(childSpan_3_1.links?.length).toBe(1);
+  expect(childSpan_3_1.links?.[0]).toMatchObject({
+    attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' },
+    sampled: true,
+    span_id: rootSpan1_spanId,
+    trace_id: rootSpan1_traceId,
+  });
+
+  expect(childSpan_3_2.description).toBe('childSpan3.2');
+  expect(childSpan_3_2.links?.[0]).toMatchObject({
+    sampled: true,
+    span_id: rootSpan3_spanId,
+    trace_id: rootSpan3_traceId,
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-streamed/test.ts
deleted file mode 100644
index bafa95aee03f..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-streamed/test.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../utils/helpers';
-import { waitForStreamedSpan, waitForStreamedSpans } from '../../../utils/spanUtils';
-
-sentryTest('links spans with addLink() in trace context', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const rootSpan1Promise = waitForStreamedSpan(page, s => s.name === 'rootSpan1' && !!s.is_segment);
-  const rootSpan2Promise = waitForStreamedSpan(page, s => s.name === 'rootSpan2' && !!s.is_segment);
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  await page.goto(url);
-
-  const rootSpan1 = await rootSpan1Promise;
-  const rootSpan2 = await rootSpan2Promise;
-
-  expect(rootSpan1.name).toBe('rootSpan1');
-  expect(rootSpan1.links).toBeUndefined();
-
-  expect(rootSpan2.name).toBe('rootSpan2');
-  expect(rootSpan2.links).toHaveLength(1);
-  expect(rootSpan2.links?.[0]).toMatchObject({
-    attributes: { 'sentry.link.type': { type: 'string', value: 'previous_trace' } },
-    sampled: true,
-    span_id: rootSpan1.span_id,
-    trace_id: rootSpan1.trace_id,
-  });
-});
-
-sentryTest('links spans with addLink() in nested startSpan() calls', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const rootSpan1Promise = waitForStreamedSpan(page, s => s.name === 'rootSpan1' && !!s.is_segment);
-  const rootSpan3SpansPromise = waitForStreamedSpans(page, spans =>
-    spans.some(s => s.name === 'rootSpan3' && s.is_segment),
-  );
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  await page.goto(url);
-
-  const rootSpan1 = await rootSpan1Promise;
-  const rootSpan3Spans = await rootSpan3SpansPromise;
-
-  const rootSpan3 = rootSpan3Spans.find(s => s.name === 'rootSpan3')!;
-  const childSpan1 = rootSpan3Spans.find(s => s.name === 'childSpan3.1')!;
-  const childSpan2 = rootSpan3Spans.find(s => s.name === 'childSpan3.2')!;
-
-  expect(rootSpan3.name).toBe('rootSpan3');
-
-  expect(childSpan1.name).toBe('childSpan3.1');
-  expect(childSpan1.links).toHaveLength(1);
-  expect(childSpan1.links?.[0]).toMatchObject({
-    attributes: { 'sentry.link.type': { type: 'string', value: 'previous_trace' } },
-    sampled: true,
-    span_id: rootSpan1.span_id,
-    trace_id: rootSpan1.trace_id,
-  });
-
-  expect(childSpan2.name).toBe('childSpan3.2');
-  expect(childSpan2.links?.[0]).toMatchObject({
-    sampled: true,
-    span_id: rootSpan3.span_id,
-    trace_id: rootSpan3.trace_id,
-  });
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/linking-addLink/init.js b/dev-packages/browser-integration-tests/suites/tracing/linking-addLink/init.js
index 848d72e6bfdc..3ec6adbbdb75 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/linking-addLink/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/linking-addLink/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/linking-addLink/test.ts b/dev-packages/browser-integration-tests/suites/tracing/linking-addLink/test.ts
index 9c556335651e..e7f009c0e911 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/linking-addLink/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/linking-addLink/test.ts
@@ -1,76 +1,66 @@
-import { expect } from '@playwright/test';
-import type { SpanJSON, TransactionEvent } from '@sentry/core';
-import { sentryTest } from '../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../utils/helpers';
-
-sentryTest('should link spans with addLink() in trace context', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+sentryTest('links spans with addLink() in trace context', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
 
-  const rootSpan1Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan1');
-  const rootSpan2Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan2');
+  const rootSpan1Promise = waitForStreamedSpan(page, s => s.name === 'rootSpan1' && !!s.is_segment);
+  const rootSpan2Promise = waitForStreamedSpan(page, s => s.name === 'rootSpan2' && !!s.is_segment);
 
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
 
-  const rootSpan1 = envelopeRequestParser<TransactionEvent>(await rootSpan1Promise);
-  const rootSpan2 = envelopeRequestParser<TransactionEvent>(await rootSpan2Promise);
-
-  const rootSpan1_traceId = rootSpan1.contexts?.trace?.trace_id as string;
-  const rootSpan1_spanId = rootSpan1.contexts?.trace?.span_id as string;
-
-  expect(rootSpan1.transaction).toBe('rootSpan1');
-  expect(rootSpan1.spans).toEqual([]);
+  const rootSpan1 = await rootSpan1Promise;
+  const rootSpan2 = await rootSpan2Promise;
 
-  expect(rootSpan2.transaction).toBe('rootSpan2');
-  expect(rootSpan2.spans).toEqual([]);
+  expect(rootSpan1.name).toBe('rootSpan1');
+  expect(rootSpan1.links).toBeUndefined();
 
-  expect(rootSpan2.contexts?.trace?.links?.length).toBe(1);
-  expect(rootSpan2.contexts?.trace?.links?.[0]).toMatchObject({
-    attributes: { 'sentry.link.type': 'previous_trace' },
+  expect(rootSpan2.name).toBe('rootSpan2');
+  expect(rootSpan2.links).toHaveLength(1);
+  expect(rootSpan2.links?.[0]).toMatchObject({
+    attributes: { [SENTRY_LINK_TYPE]: { type: 'string', value: 'previous_trace' } },
     sampled: true,
-    span_id: rootSpan1_spanId,
-    trace_id: rootSpan1_traceId,
+    span_id: rootSpan1.span_id,
+    trace_id: rootSpan1.trace_id,
   });
 });
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../utils/fixtures';
+import { shouldSkipTracingTest } from '../../../utils/helpers';
+import { waitForStreamedSpan } from '../../../utils/spanUtils';
 
-sentryTest('should link spans with addLink() in nested startSpan() calls', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+sentryTest('links spans with addLink() in nested startSpan() calls', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
 
-  const rootSpan1Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan1');
-  const rootSpan3Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan3');
+  const rootSpan1Promise = waitForStreamedSpan(page, s => s.name === 'rootSpan1' && !!s.is_segment);
+  const rootSpan3Promise = waitForStreamedSpan(page, span => span.name === 'rootSpan3' && span.is_segment);
+  const childSpan1Promise = waitForStreamedSpan(page, span => span.name === 'childSpan3.1');
+  const childSpan2Promise = waitForStreamedSpan(page, span => span.name === 'childSpan3.2');
 
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
 
-  const rootSpan1 = envelopeRequestParser<TransactionEvent>(await rootSpan1Promise);
-  const rootSpan3 = envelopeRequestParser<TransactionEvent>(await rootSpan3Promise);
-
-  const rootSpan1_traceId = rootSpan1.contexts?.trace?.trace_id as string;
-  const rootSpan1_spanId = rootSpan1.contexts?.trace?.span_id as string;
-
-  const [childSpan_3_1, childSpan_3_2] = rootSpan3.spans as [SpanJSON, SpanJSON];
-  const rootSpan3_traceId = rootSpan3.contexts?.trace?.trace_id as string;
-  const rootSpan3_spanId = rootSpan3.contexts?.trace?.span_id as string;
+  const rootSpan1 = await rootSpan1Promise;
+  const [rootSpan3, childSpan1, childSpan2] = await Promise.all([
+    rootSpan3Promise,
+    childSpan1Promise,
+    childSpan2Promise,
+  ]);
 
-  expect(rootSpan3.transaction).toBe('rootSpan3');
+  expect(rootSpan3.name).toBe('rootSpan3');
 
-  expect(childSpan_3_1.description).toBe('childSpan3.1');
-  expect(childSpan_3_1.links?.length).toBe(1);
-  expect(childSpan_3_1.links?.[0]).toMatchObject({
-    attributes: { 'sentry.link.type': 'previous_trace' },
+  expect(childSpan1.name).toBe('childSpan3.1');
+  expect(childSpan1.links).toHaveLength(1);
+  expect(childSpan1.links?.[0]).toMatchObject({
+    attributes: { [SENTRY_LINK_TYPE]: { type: 'string', value: 'previous_trace' } },
     sampled: true,
-    span_id: rootSpan1_spanId,
-    trace_id: rootSpan1_traceId,
+    span_id: rootSpan1.span_id,
+    trace_id: rootSpan1.trace_id,
   });
 
-  expect(childSpan_3_2.description).toBe('childSpan3.2');
-  expect(childSpan_3_2.links?.[0]).toMatchObject({
+  expect(childSpan2.name).toBe('childSpan3.2');
+  expect(childSpan2.links?.[0]).toMatchObject({
     sampled: true,
-    span_id: rootSpan3_spanId,
-    trace_id: rootSpan3_traceId,
+    span_id: rootSpan3.span_id,
+    trace_id: rootSpan3.trace_id,
   });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/linking-addLinks/init.js b/dev-packages/browser-integration-tests/suites/tracing/linking-addLinks/init.js
index 848d72e6bfdc..3ec6adbbdb75 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/linking-addLinks/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/linking-addLinks/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/linking-addLinks/test.ts b/dev-packages/browser-integration-tests/suites/tracing/linking-addLinks/test.ts
index 529eae04ae03..56aaebf93cde 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/linking-addLinks/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/linking-addLinks/test.ts
@@ -1,47 +1,50 @@
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { SpanJSON, TransactionEvent } from '@sentry/core';
 import { sentryTest } from '../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../utils/helpers';
+import { collectStreamedSpans, waitForStreamedSpan } from '../../../utils/spanUtils';
 
 sentryTest('should link spans with addLinks() in trace context', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
     sentryTest.skip();
   }
 
-  const rootSpan1Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan1');
-  const rootSpan2Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan2');
-  const rootSpan3Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan3');
+  const rootSpan1Promise = waitForStreamedSpan(page, event => event.name === 'rootSpan1');
+  const rootSpan2Promise = waitForStreamedSpan(page, event => event.name === 'rootSpan2');
+  const rootSpan3Promise = waitForStreamedSpan(page, event => event.name === 'rootSpan3');
 
+  const allSpans = collectStreamedSpans(page);
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
 
-  const rootSpan1 = envelopeRequestParser<TransactionEvent>(await rootSpan1Promise);
-  const rootSpan2 = envelopeRequestParser<TransactionEvent>(await rootSpan2Promise);
-  const rootSpan3 = envelopeRequestParser<TransactionEvent>(await rootSpan3Promise);
+  const rootSpan1 = await rootSpan1Promise;
+  const rootSpan2 = await rootSpan2Promise;
+  const rootSpan3 = await rootSpan3Promise;
 
-  const rootSpan1_traceId = rootSpan1.contexts?.trace?.trace_id as string;
-  const rootSpan1_spanId = rootSpan1.contexts?.trace?.span_id as string;
+  const rootSpan1_traceId = rootSpan1.trace_id as string;
+  const rootSpan1_spanId = rootSpan1.span_id as string;
 
-  expect(rootSpan1.transaction).toBe('rootSpan1');
-  expect(rootSpan1.spans).toEqual([]);
+  expect(rootSpan1.name).toBe('rootSpan1');
+  expect(allSpans.filter(span => span.parent_span_id === rootSpan1.span_id)).toEqual([]);
 
-  const rootSpan2_traceId = rootSpan2.contexts?.trace?.trace_id as string;
-  const rootSpan2_spanId = rootSpan2.contexts?.trace?.span_id as string;
+  const rootSpan2_traceId = rootSpan2.trace_id as string;
+  const rootSpan2_spanId = rootSpan2.span_id as string;
 
-  expect(rootSpan2.transaction).toBe('rootSpan2');
-  expect(rootSpan2.spans).toEqual([]);
+  expect(rootSpan2.name).toBe('rootSpan2');
+  expect(allSpans.filter(span => span.parent_span_id === rootSpan2.span_id)).toEqual([]);
 
-  expect(rootSpan3.transaction).toBe('rootSpan3');
-  expect(rootSpan3.spans).toEqual([]);
-  expect(rootSpan3.contexts?.trace?.links?.length).toBe(2);
-  expect(rootSpan3.contexts?.trace?.links).toEqual([
+  expect(rootSpan3.name).toBe('rootSpan3');
+  expect(allSpans.filter(span => span.parent_span_id === rootSpan3.span_id)).toEqual([]);
+  expect(rootSpan3.links?.length).toBe(2);
+  expect(rootSpan3.links).toEqual([
     {
+      attributes: {},
       sampled: true,
       span_id: rootSpan1_spanId,
       trace_id: rootSpan1_traceId,
     },
     {
-      attributes: { 'sentry.link.type': 'previous_trace' },
+      attributes: { [SENTRY_LINK_TYPE]: { type: 'string', value: 'previous_trace' } },
       sampled: true,
       span_id: rootSpan2_spanId,
       trace_id: rootSpan2_traceId,
@@ -54,37 +57,40 @@ sentryTest('should link spans with addLinks() in nested startSpan() calls', asyn
     sentryTest.skip();
   }
 
-  const rootSpan2Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan2');
-  const rootSpan4Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan4');
+  const rootSpan2Promise = waitForStreamedSpan(page, event => event.name === 'rootSpan2');
+  const rootSpan4Promise = waitForStreamedSpan(page, event => event.name === 'rootSpan4');
 
+  const allSpans = collectStreamedSpans(page);
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
 
-  const rootSpan2 = envelopeRequestParser<TransactionEvent>(await rootSpan2Promise);
-  const rootSpan4 = envelopeRequestParser<TransactionEvent>(await rootSpan4Promise);
+  const rootSpan2 = await rootSpan2Promise;
+  const rootSpan4 = await rootSpan4Promise;
 
-  const rootSpan2_traceId = rootSpan2.contexts?.trace?.trace_id as string;
-  const rootSpan2_spanId = rootSpan2.contexts?.trace?.span_id as string;
+  const rootSpan2_traceId = rootSpan2.trace_id as string;
+  const rootSpan2_spanId = rootSpan2.span_id as string;
 
-  const [childSpan_4_1, childSpan_4_2] = rootSpan4.spans as [SpanJSON, SpanJSON];
-  const rootSpan4_traceId = rootSpan4.contexts?.trace?.trace_id as string;
-  const rootSpan4_spanId = rootSpan4.contexts?.trace?.span_id as string;
+  const childSpan_4_1 = allSpans.find(span => span.name === 'childSpan4.1')!;
+  const childSpan_4_2 = allSpans.find(span => span.name === 'childSpan4.2')!;
+  const rootSpan4_traceId = rootSpan4.trace_id as string;
+  const rootSpan4_spanId = rootSpan4.span_id as string;
 
-  expect(rootSpan4.transaction).toBe('rootSpan4');
+  expect(rootSpan4.name).toBe('rootSpan4');
 
-  expect(childSpan_4_1.description).toBe('childSpan4.1');
+  expect(childSpan_4_1.name).toBe('childSpan4.1');
   expect(childSpan_4_1.links).toBe(undefined);
 
-  expect(childSpan_4_2.description).toBe('childSpan4.2');
+  expect(childSpan_4_2.name).toBe('childSpan4.2');
   expect(childSpan_4_2.links?.length).toBe(2);
   expect(childSpan_4_2.links).toEqual([
     {
+      attributes: {},
       sampled: true,
       span_id: rootSpan4_spanId,
       trace_id: rootSpan4_traceId,
     },
     {
-      attributes: { 'sentry.link.type': 'previous_trace' },
+      attributes: { [SENTRY_LINK_TYPE]: { type: 'string', value: 'previous_trace' } },
       sampled: true,
       span_id: rootSpan2_spanId,
       trace_id: rootSpan2_traceId,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/linking-spanOptions/init.js b/dev-packages/browser-integration-tests/suites/tracing/linking-spanOptions/init.js
index 848d72e6bfdc..3ec6adbbdb75 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/linking-spanOptions/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/linking-spanOptions/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/linking-spanOptions/test.ts b/dev-packages/browser-integration-tests/suites/tracing/linking-spanOptions/test.ts
index c2a2ed02f0e6..c07214170d5c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/linking-spanOptions/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/linking-spanOptions/test.ts
@@ -1,45 +1,48 @@
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { TransactionEvent } from '@sentry/core';
 import { sentryTest } from '../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../utils/helpers';
+import { collectStreamedSpans, waitForStreamedSpan } from '../../../utils/spanUtils';
 
 sentryTest('should link spans by adding "links" to span options', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
     sentryTest.skip();
   }
 
-  const rootSpan1Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan1');
-  const rootSpan2Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan2');
-  const rootSpan3Promise = waitForTransactionRequest(page, event => event.transaction === 'rootSpan3');
+  const rootSpan1Promise = waitForStreamedSpan(page, event => event.name === 'rootSpan1');
+  const rootSpan2Promise = waitForStreamedSpan(page, event => event.name === 'rootSpan2');
+  const rootSpan3Promise = waitForStreamedSpan(page, event => event.name === 'rootSpan3');
 
+  const allSpans = collectStreamedSpans(page);
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
 
-  const rootSpan1 = envelopeRequestParser<TransactionEvent>(await rootSpan1Promise);
-  const rootSpan2 = envelopeRequestParser<TransactionEvent>(await rootSpan2Promise);
-  const rootSpan3 = envelopeRequestParser<TransactionEvent>(await rootSpan3Promise);
+  const rootSpan1 = await rootSpan1Promise;
+  const rootSpan2 = await rootSpan2Promise;
+  const rootSpan3 = await rootSpan3Promise;
 
-  const rootSpan1_traceId = rootSpan1.contexts?.trace?.trace_id as string;
-  const rootSpan1_spanId = rootSpan1.contexts?.trace?.span_id as string;
-  const rootSpan2_traceId = rootSpan2.contexts?.trace?.trace_id as string;
-  const rootSpan2_spanId = rootSpan2.contexts?.trace?.span_id as string;
+  const rootSpan1_traceId = rootSpan1.trace_id as string;
+  const rootSpan1_spanId = rootSpan1.span_id as string;
+  const rootSpan2_traceId = rootSpan2.trace_id as string;
+  const rootSpan2_spanId = rootSpan2.span_id as string;
 
-  expect(rootSpan1.transaction).toBe('rootSpan1');
-  expect(rootSpan1.spans).toEqual([]);
+  expect(rootSpan1.name).toBe('rootSpan1');
+  expect(allSpans.filter(span => span.parent_span_id === rootSpan1.span_id)).toEqual([]);
 
-  expect(rootSpan3.transaction).toBe('rootSpan3');
-  expect(rootSpan3.spans?.length).toBe(1);
-  expect(rootSpan3.spans?.[0].description).toBe('childSpan3.1');
+  expect(rootSpan3.name).toBe('rootSpan3');
+  expect(allSpans.filter(span => span.parent_span_id === rootSpan3.span_id)?.length).toBe(1);
+  expect(allSpans.find(span => span.name === 'childSpan3.1')?.name).toBe('childSpan3.1');
 
-  expect(rootSpan3.contexts?.trace?.links?.length).toBe(2);
-  expect(rootSpan3.contexts?.trace?.links).toEqual([
+  expect(rootSpan3.links?.length).toBe(2);
+  expect(rootSpan3.links).toEqual([
     {
+      attributes: {},
       sampled: true,
       span_id: rootSpan1_spanId,
       trace_id: rootSpan1_traceId,
     },
     {
-      attributes: { 'sentry.link.type': 'previous_trace' },
+      attributes: { [SENTRY_LINK_TYPE]: { type: 'string', value: 'previous_trace' } },
       sampled: true,
       span_id: rootSpan2_spanId,
       trace_id: rootSpan2_traceId,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/maxSpans-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/maxSpans-static/init.js
new file mode 100644
index 000000000000..d4062aa6eb8f
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/maxSpans-static/init.js
@@ -0,0 +1,16 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [],
+  tracesSampleRate: 1,
+});
+
+Sentry.startSpan({ name: 'parent' }, () => {
+  for (let i = 0; i < 5000; i++) {
+    Sentry.startInactiveSpan({ name: `child ${i}` }).end();
+  }
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/maxSpans-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/maxSpans-static/test.ts
new file mode 100644
index 000000000000..5a5c6f851c69
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/maxSpans-static/test.ts
@@ -0,0 +1,16 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequestOnUrl } from '../../../utils/helpers';
+
+sentryTest('limits static transactions to 1000 child spans', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const req = await waitForTransactionRequestOnUrl(page, url);
+  const transaction = envelopeRequestParser(req);
+
+  expect(transaction.spans).toHaveLength(1000);
+  expect(transaction.spans).toContainEqual(expect.objectContaining({ description: 'child 0' }));
+  expect(transaction.spans).toContainEqual(expect.objectContaining({ description: 'child 999' }));
+  expect(transaction.spans).not.toContainEqual(expect.objectContaining({ description: 'child 1000' }));
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/maxSpans/init.js b/dev-packages/browser-integration-tests/suites/tracing/maxSpans/init.js
index d4062aa6eb8f..162bc4a04cd9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/maxSpans/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/maxSpans/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/maxSpans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/maxSpans/test.ts
index 328c5c364c87..f5a05ad0854c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/maxSpans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/maxSpans/test.ts
@@ -1,20 +1,20 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequestOnUrl } from '../../../utils/helpers';
-
-sentryTest('it limits spans to 1000', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+import { shouldSkipTracingTest } from '../../../utils/helpers';
+import { collectStreamedSpans, waitForStreamedSpan } from '../../../utils/spanUtils';
 
+sentryTest('streams all children without the static 1000-span limit', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
+  const spans = collectStreamedSpans(page);
+  const rootPromise = waitForStreamedSpan(page, span => span.name === 'parent');
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
+  const root = await rootPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-  const req = await waitForTransactionRequestOnUrl(page, url);
-  const transaction = envelopeRequestParser(req);
-
-  expect(transaction.spans).toHaveLength(1000);
-  expect(transaction.spans).toContainEqual(expect.objectContaining({ description: 'child 0' }));
-  expect(transaction.spans).toContainEqual(expect.objectContaining({ description: 'child 999' }));
-  expect(transaction.spans).not.toContainEqual(expect.objectContaining({ description: 'child 1000' }));
+  const children = spans.filter(span => span.parent_span_id === root.span_id);
+  expect(children).toHaveLength(5000);
+  expect(children).toContainEqual(expect.objectContaining({ name: 'child 0' }));
+  expect(children).toContainEqual(expect.objectContaining({ name: 'child 999' }));
+  expect(children).toContainEqual(expect.objectContaining({ name: 'child 4999' }));
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/microfrontend-span-attribution/init.js b/dev-packages/browser-integration-tests/suites/tracing/microfrontend-span-attribution/init.js
index 19670513eef9..b8f186bc2896 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/microfrontend-span-attribution/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/microfrontend-span-attribution/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/microfrontend-span-attribution/test.ts b/dev-packages/browser-integration-tests/suites/tracing/microfrontend-span-attribution/test.ts
index e49b258b4ff2..d166f200ff28 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/microfrontend-span-attribution/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/microfrontend-span-attribution/test.ts
@@ -1,6 +1,8 @@
+import { URL_FULL } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../utils/spanUtils';
 
 sentryTest('should attribute spans to their originating microfrontend', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
@@ -11,27 +13,29 @@ sentryTest('should attribute spans to their originating microfrontend', async ({
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const reqPromise = waitForTransactionRequest(page, event => {
-    const spans = event.spans || [];
-    return (
-      spans.some(s => s.description?.includes('/api/todos/1')) &&
-      spans.some(s => s.description?.includes('/api/todos/2')) &&
-      spans.some(s => s.description?.includes('/api/todos/3')) &&
-      spans.some(s => s.description?.includes('/api/shell-config'))
-    );
-  });
-
+  const spans = collectStreamedSpans(page);
+  const rootSpanPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
   await page.goto(url);
-
-  const req = await reqPromise;
-  const event = envelopeRequestParser(req);
-  const httpSpans = event.spans?.filter(({ op }) => op === 'http.client') || [];
+  await rootSpanPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const httpSpans = spans.filter(span => getSpanOp(span) === 'http.client');
+  expect(httpSpans).toHaveLength(4);
 
   // Each MFE's fetch is attributed via withScope + spanStart hook
-  expect(httpSpans.find(s => s.description?.includes('/api/todos/1'))?.data?.['mfe.name']).toBe('mfe-header');
-  expect(httpSpans.find(s => s.description?.includes('/api/todos/2'))?.data?.['mfe.name']).toBe('mfe-one');
-  expect(httpSpans.find(s => s.description?.includes('/api/todos/3'))?.data?.['mfe.name']).toBe('mfe-two');
+  expect(
+    httpSpans.find(s => s.attributes[URL_FULL]?.value?.toString().includes('/api/todos/1'))?.attributes['mfe.name'],
+  ).toEqual({ type: 'string', value: 'mfe-header' });
+  expect(
+    httpSpans.find(s => s.attributes[URL_FULL]?.value?.toString().includes('/api/todos/2'))?.attributes['mfe.name'],
+  ).toEqual({ type: 'string', value: 'mfe-one' });
+  expect(
+    httpSpans.find(s => s.attributes[URL_FULL]?.value?.toString().includes('/api/todos/3'))?.attributes['mfe.name'],
+  ).toEqual({ type: 'string', value: 'mfe-two' });
 
   // Shell span has no MFE tag
-  expect(httpSpans.find(s => s.description?.includes('/api/shell-config'))?.data?.['mfe.name']).toBeUndefined();
+  expect(
+    httpSpans.find(s => s.attributes[URL_FULL]?.value?.toString().includes('/api/shell-config'))?.attributes[
+      'mfe.name'
+    ],
+  ).toBeUndefined();
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report/init.js b/dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report-static/init.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report-static/init.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report/subject.js b/dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report-static/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report-static/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report/test.ts b/dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report-static/test.ts
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/no-parent-span-client-report-static/test.ts
diff --git a/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/default/init.js
similarity index 75%
rename from dev-packages/browser-integration-tests/suites/tracing/linking-addLink-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/default/init.js
index 9afcee48dc4a..bd0421b32761 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/linking-addLink-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/default/init.js
@@ -3,7 +3,7 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.spanStreamingIntegration()],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/default/subject.js b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/default/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/default/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/default/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/default/test.ts b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/default/test.ts
similarity index 52%
rename from dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/default/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/default/test.ts
index c9f48a4ebefd..2019c78c837f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/default/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/default/test.ts
@@ -1,26 +1,26 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { waitForStreamedSpans } from '../../../../utils/spanUtils';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
 
 sentryTest('sets an inactive span active and adds child spans to it', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
 
-  const spansPromise = waitForStreamedSpans(page, spans => spans.some(s => s.name === 'checkout-flow' && s.is_segment));
+  const req = waitForTransactionRequest(page, e => e.transaction === 'checkout-flow');
 
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
 
-  const spans = await spansPromise;
-  const checkoutSpan = spans.find(s => s.name === 'checkout-flow');
-  const checkoutSpanId = checkoutSpan?.span_id;
+  const checkoutEvent = envelopeRequestParser(await req);
+  const checkoutSpanId = checkoutEvent.contexts?.trace?.span_id;
   expect(checkoutSpanId).toMatch(/[a-f\d]{16}/);
 
-  expect(spans.filter(s => !s.is_segment)).toHaveLength(3);
+  expect(checkoutEvent.spans).toHaveLength(3);
 
-  const checkoutStep1 = spans.find(s => s.name === 'checkout-step-1');
-  const checkoutStep11 = spans.find(s => s.name === 'checkout-step-1-1');
-  const checkoutStep2 = spans.find(s => s.name === 'checkout-step-2');
+  const checkoutStep1 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-1');
+  const checkoutStep11 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-1-1');
+  const checkoutStep2 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-2');
 
   expect(checkoutStep1).toBeDefined();
   expect(checkoutStep11).toBeDefined();
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/init.js b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested-parentAlwaysRoot/init.js
similarity index 78%
rename from dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested-parentAlwaysRoot/init.js
index 5b4cff73e95d..58be3b8dc82c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested-parentAlwaysRoot/init.js
@@ -3,8 +3,8 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.spanStreamingIntegration()],
   tracesSampleRate: 1,
   parentSpanIsAlwaysRootSpan: false,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/subject.js b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested-parentAlwaysRoot/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested-parentAlwaysRoot/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/test.ts b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested-parentAlwaysRoot/test.ts
similarity index 53%
rename from dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested-parentAlwaysRoot/test.ts
index f0ce77d4e00c..5132178d1981 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested-parentAlwaysRoot/test.ts
@@ -1,37 +1,36 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { waitForStreamedSpans } from '../../../../utils/spanUtils';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
 
 sentryTest(
   'nested calls to setActiveSpanInBrowser with parentSpanIsAlwaysRootSpan=false result in correct parenting',
   async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
 
-    const checkoutSpansPromise = waitForStreamedSpans(page, spans =>
-      spans.some(s => s.name === 'checkout-flow' && s.is_segment),
-    );
+    const req = waitForTransactionRequest(page, e => e.transaction === 'checkout-flow');
+    const postCheckoutReq = waitForTransactionRequest(page, e => e.transaction === 'post-checkout');
 
     const url = await getLocalTestUrl({ testDir: __dirname });
     await page.goto(url);
 
-    const checkoutSpans = await checkoutSpansPromise;
+    const checkoutEvent = envelopeRequestParser(await req);
+    const postCheckoutEvent = envelopeRequestParser(await postCheckoutReq);
 
-    const checkoutSpan = checkoutSpans.find(s => s.name === 'checkout-flow');
-    const postCheckoutSpan = checkoutSpans.find(s => s.name === 'post-checkout');
-
-    const checkoutSpanId = checkoutSpan?.span_id;
-    const postCheckoutSpanId = postCheckoutSpan?.span_id;
+    const checkoutSpanId = checkoutEvent.contexts?.trace?.span_id;
+    const postCheckoutSpanId = postCheckoutEvent.contexts?.trace?.span_id;
 
     expect(checkoutSpanId).toMatch(/[a-f\d]{16}/);
     expect(postCheckoutSpanId).toMatch(/[a-f\d]{16}/);
 
-    expect(checkoutSpans.filter(s => !s.is_segment)).toHaveLength(5);
+    expect(checkoutEvent.spans).toHaveLength(4);
+    expect(postCheckoutEvent.spans).toHaveLength(1);
 
-    const checkoutStep1 = checkoutSpans.find(s => s.name === 'checkout-step-1');
-    const checkoutStep2 = checkoutSpans.find(s => s.name === 'checkout-step-2');
-    const checkoutStep21 = checkoutSpans.find(s => s.name === 'checkout-step-2-1');
-    const checkoutStep3 = checkoutSpans.find(s => s.name === 'checkout-step-3');
+    const checkoutStep1 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-1');
+    const checkoutStep2 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-2');
+    const checkoutStep21 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-2-1');
+    const checkoutStep3 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-3');
 
     expect(checkoutStep1).toBeDefined();
     expect(checkoutStep2).toBeDefined();
@@ -51,7 +50,7 @@ sentryTest(
 
     // post-checkout trace is started as a new trace because ending checkoutSpan removes the active
     // span on the scope
-    const postCheckoutStep1 = checkoutSpans.find(s => s.name === 'post-checkout-1');
+    const postCheckoutStep1 = postCheckoutEvent.spans?.find(s => s.description === 'post-checkout-1');
     expect(postCheckoutStep1).toBeDefined();
     expect(postCheckoutStep1?.parent_span_id).toBe(postCheckoutSpanId);
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/default/init.js b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested/init.js
similarity index 75%
rename from dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/default/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested/init.js
index 9afcee48dc4a..bd0421b32761 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/default/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested/init.js
@@ -3,7 +3,7 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.spanStreamingIntegration()],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/subject.js b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested/test.ts b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested/test.ts
new file mode 100644
index 000000000000..cea01f304691
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-static/nested/test.ts
@@ -0,0 +1,52 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest(
+  'nested calls to setActiveSpanInBrowser still parent to root span by default',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const req = waitForTransactionRequest(page, e => e.transaction === 'checkout-flow');
+    const postCheckoutReq = waitForTransactionRequest(page, e => e.transaction === 'post-checkout');
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    await page.goto(url);
+
+    const checkoutEvent = envelopeRequestParser(await req);
+    const postCheckoutEvent = envelopeRequestParser(await postCheckoutReq);
+
+    const checkoutSpanId = checkoutEvent.contexts?.trace?.span_id;
+    const postCheckoutSpanId = postCheckoutEvent.contexts?.trace?.span_id;
+
+    expect(checkoutSpanId).toMatch(/[a-f\d]{16}/);
+    expect(postCheckoutSpanId).toMatch(/[a-f\d]{16}/);
+
+    expect(checkoutEvent.spans).toHaveLength(4);
+    expect(postCheckoutEvent.spans).toHaveLength(1);
+
+    const checkoutStep1 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-1');
+    const checkoutStep2 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-2');
+    const checkoutStep21 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-2-1');
+    const checkoutStep3 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-3');
+
+    expect(checkoutStep1).toBeDefined();
+    expect(checkoutStep2).toBeDefined();
+    expect(checkoutStep21).toBeDefined();
+    expect(checkoutStep3).toBeDefined();
+
+    expect(checkoutStep1?.parent_span_id).toBe(checkoutSpanId);
+    expect(checkoutStep2?.parent_span_id).toBe(checkoutSpanId);
+    expect(checkoutStep3?.parent_span_id).toBe(checkoutSpanId);
+
+    // despite 2-1 being called within 2 AND setting 2 as active span, it's still parented to the
+    // root span due to this being default behaviour in browser environments
+    expect(checkoutStep21?.parent_span_id).toBe(checkoutSpanId);
+
+    const postCheckoutStep1 = postCheckoutEvent.spans?.find(s => s.description === 'post-checkout-1');
+    expect(postCheckoutStep1).toBeDefined();
+    expect(postCheckoutStep1?.parent_span_id).toBe(postCheckoutSpanId);
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/test.ts b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/test.ts
deleted file mode 100644
index 37a76f81152d..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/test.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest(
-  'nested calls to setActiveSpanInBrowser still parent to root span by default',
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const checkoutSpansPromise = waitForStreamedSpans(page, spans =>
-      spans.some(s => s.name === 'checkout-flow' && s.is_segment),
-    );
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-    await page.goto(url);
-
-    const checkoutSpans = await checkoutSpansPromise;
-
-    const checkoutSpan = checkoutSpans.find(s => s.name === 'checkout-flow');
-    const postCheckoutSpan = checkoutSpans.find(s => s.name === 'post-checkout');
-
-    const checkoutSpanId = checkoutSpan?.span_id;
-    const postCheckoutSpanId = postCheckoutSpan?.span_id;
-
-    expect(checkoutSpanId).toMatch(/[a-f\d]{16}/);
-    expect(postCheckoutSpanId).toMatch(/[a-f\d]{16}/);
-
-    expect(checkoutSpans.filter(s => !s.is_segment)).toHaveLength(5);
-
-    const checkoutStep1 = checkoutSpans.find(s => s.name === 'checkout-step-1');
-    const checkoutStep2 = checkoutSpans.find(s => s.name === 'checkout-step-2');
-    const checkoutStep21 = checkoutSpans.find(s => s.name === 'checkout-step-2-1');
-    const checkoutStep3 = checkoutSpans.find(s => s.name === 'checkout-step-3');
-
-    expect(checkoutStep1).toBeDefined();
-    expect(checkoutStep2).toBeDefined();
-    expect(checkoutStep21).toBeDefined();
-    expect(checkoutStep3).toBeDefined();
-
-    expect(checkoutStep1?.parent_span_id).toBe(checkoutSpanId);
-    expect(checkoutStep2?.parent_span_id).toBe(checkoutSpanId);
-    expect(checkoutStep3?.parent_span_id).toBe(checkoutSpanId);
-
-    // despite 2-1 being called within 2 AND setting 2 as active span, it's still parented to the
-    // root span due to this being default behaviour in browser environments
-    expect(checkoutStep21?.parent_span_id).toBe(checkoutSpanId);
-
-    const postCheckoutStep1 = checkoutSpans.find(s => s.name === 'post-checkout-1');
-    expect(postCheckoutStep1).toBeDefined();
-    expect(postCheckoutStep1?.parent_span_id).toBe(postCheckoutSpanId);
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/default/init.js b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/default/init.js
index bd0421b32761..3ec6adbbdb75 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/default/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/default/init.js
@@ -3,7 +3,7 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/default/test.ts b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/default/test.ts
index 2019c78c837f..ab996fc17d4c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/default/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/default/test.ts
@@ -1,26 +1,28 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('sets an inactive span active and adds child spans to it', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest());
 
-  const req = waitForTransactionRequest(page, e => e.transaction === 'checkout-flow');
+  const spans = collectStreamedSpans(page);
+  const rootPromise = waitForStreamedSpan(page, span => span.name === 'checkout-flow' && span.is_segment);
 
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
 
-  const checkoutEvent = envelopeRequestParser(await req);
-  const checkoutSpanId = checkoutEvent.contexts?.trace?.span_id;
+  await rootPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const checkoutSpan = spans.find(s => s.name === 'checkout-flow');
+  const checkoutSpanId = checkoutSpan?.span_id;
   expect(checkoutSpanId).toMatch(/[a-f\d]{16}/);
 
-  expect(checkoutEvent.spans).toHaveLength(3);
+  expect(spans.filter(s => !s.is_segment)).toHaveLength(3);
 
-  const checkoutStep1 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-1');
-  const checkoutStep11 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-1-1');
-  const checkoutStep2 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-2');
+  const checkoutStep1 = spans.find(s => s.name === 'checkout-step-1');
+  const checkoutStep11 = spans.find(s => s.name === 'checkout-step-1-1');
+  const checkoutStep2 = spans.find(s => s.name === 'checkout-step-2');
 
   expect(checkoutStep1).toBeDefined();
   expect(checkoutStep11).toBeDefined();
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested-parentAlwaysRoot/init.js b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested-parentAlwaysRoot/init.js
index 58be3b8dc82c..27b13c52906f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested-parentAlwaysRoot/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested-parentAlwaysRoot/init.js
@@ -3,8 +3,8 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [],
   tracesSampleRate: 1,
   parentSpanIsAlwaysRootSpan: false,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested-parentAlwaysRoot/test.ts b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested-parentAlwaysRoot/test.ts
index 5132178d1981..12baff69f5f8 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested-parentAlwaysRoot/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested-parentAlwaysRoot/test.ts
@@ -1,36 +1,38 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
   'nested calls to setActiveSpanInBrowser with parentSpanIsAlwaysRootSpan=false result in correct parenting',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
-    const req = waitForTransactionRequest(page, e => e.transaction === 'checkout-flow');
-    const postCheckoutReq = waitForTransactionRequest(page, e => e.transaction === 'post-checkout');
+    const checkoutSpans = collectStreamedSpans(page);
+    const checkoutPromise = waitForStreamedSpan(page, span => span.name === 'checkout-flow' && span.is_segment);
+    const postCheckoutPromise = waitForStreamedSpan(page, span => span.name === 'post-checkout' && span.is_segment);
 
     const url = await getLocalTestUrl({ testDir: __dirname });
     await page.goto(url);
 
-    const checkoutEvent = envelopeRequestParser(await req);
-    const postCheckoutEvent = envelopeRequestParser(await postCheckoutReq);
+    await Promise.all([checkoutPromise, postCheckoutPromise]);
+    await page.evaluate(() => (window as any).Sentry.flush());
 
-    const checkoutSpanId = checkoutEvent.contexts?.trace?.span_id;
-    const postCheckoutSpanId = postCheckoutEvent.contexts?.trace?.span_id;
+    const checkoutSpan = checkoutSpans.find(s => s.name === 'checkout-flow');
+    const postCheckoutSpan = checkoutSpans.find(s => s.name === 'post-checkout');
+
+    const checkoutSpanId = checkoutSpan?.span_id;
+    const postCheckoutSpanId = postCheckoutSpan?.span_id;
 
     expect(checkoutSpanId).toMatch(/[a-f\d]{16}/);
     expect(postCheckoutSpanId).toMatch(/[a-f\d]{16}/);
 
-    expect(checkoutEvent.spans).toHaveLength(4);
-    expect(postCheckoutEvent.spans).toHaveLength(1);
+    expect(checkoutSpans.filter(s => !s.is_segment)).toHaveLength(5);
 
-    const checkoutStep1 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-1');
-    const checkoutStep2 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-2');
-    const checkoutStep21 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-2-1');
-    const checkoutStep3 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-3');
+    const checkoutStep1 = checkoutSpans.find(s => s.name === 'checkout-step-1');
+    const checkoutStep2 = checkoutSpans.find(s => s.name === 'checkout-step-2');
+    const checkoutStep21 = checkoutSpans.find(s => s.name === 'checkout-step-2-1');
+    const checkoutStep3 = checkoutSpans.find(s => s.name === 'checkout-step-3');
 
     expect(checkoutStep1).toBeDefined();
     expect(checkoutStep2).toBeDefined();
@@ -50,7 +52,7 @@ sentryTest(
 
     // post-checkout trace is started as a new trace because ending checkoutSpan removes the active
     // span on the scope
-    const postCheckoutStep1 = postCheckoutEvent.spans?.find(s => s.description === 'post-checkout-1');
+    const postCheckoutStep1 = checkoutSpans.find(s => s.name === 'post-checkout-1');
     expect(postCheckoutStep1).toBeDefined();
     expect(postCheckoutStep1?.parent_span_id).toBe(postCheckoutSpanId);
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested/init.js b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested/init.js
index bd0421b32761..3ec6adbbdb75 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested/init.js
@@ -3,7 +3,7 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested/test.ts b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested/test.ts
index cea01f304691..686a64079db9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive/nested/test.ts
@@ -1,36 +1,38 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
   'nested calls to setActiveSpanInBrowser still parent to root span by default',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
-    const req = waitForTransactionRequest(page, e => e.transaction === 'checkout-flow');
-    const postCheckoutReq = waitForTransactionRequest(page, e => e.transaction === 'post-checkout');
+    const checkoutSpans = collectStreamedSpans(page);
+    const checkoutPromise = waitForStreamedSpan(page, span => span.name === 'checkout-flow' && span.is_segment);
+    const postCheckoutPromise = waitForStreamedSpan(page, span => span.name === 'post-checkout' && span.is_segment);
 
     const url = await getLocalTestUrl({ testDir: __dirname });
     await page.goto(url);
 
-    const checkoutEvent = envelopeRequestParser(await req);
-    const postCheckoutEvent = envelopeRequestParser(await postCheckoutReq);
+    await Promise.all([checkoutPromise, postCheckoutPromise]);
+    await page.evaluate(() => (window as any).Sentry.flush());
 
-    const checkoutSpanId = checkoutEvent.contexts?.trace?.span_id;
-    const postCheckoutSpanId = postCheckoutEvent.contexts?.trace?.span_id;
+    const checkoutSpan = checkoutSpans.find(s => s.name === 'checkout-flow');
+    const postCheckoutSpan = checkoutSpans.find(s => s.name === 'post-checkout');
+
+    const checkoutSpanId = checkoutSpan?.span_id;
+    const postCheckoutSpanId = postCheckoutSpan?.span_id;
 
     expect(checkoutSpanId).toMatch(/[a-f\d]{16}/);
     expect(postCheckoutSpanId).toMatch(/[a-f\d]{16}/);
 
-    expect(checkoutEvent.spans).toHaveLength(4);
-    expect(postCheckoutEvent.spans).toHaveLength(1);
+    expect(checkoutSpans.filter(s => !s.is_segment)).toHaveLength(5);
 
-    const checkoutStep1 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-1');
-    const checkoutStep2 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-2');
-    const checkoutStep21 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-2-1');
-    const checkoutStep3 = checkoutEvent.spans?.find(s => s.description === 'checkout-step-3');
+    const checkoutStep1 = checkoutSpans.find(s => s.name === 'checkout-step-1');
+    const checkoutStep2 = checkoutSpans.find(s => s.name === 'checkout-step-2');
+    const checkoutStep21 = checkoutSpans.find(s => s.name === 'checkout-step-2-1');
+    const checkoutStep3 = checkoutSpans.find(s => s.name === 'checkout-step-3');
 
     expect(checkoutStep1).toBeDefined();
     expect(checkoutStep2).toBeDefined();
@@ -45,7 +47,7 @@ sentryTest(
     // root span due to this being default behaviour in browser environments
     expect(checkoutStep21?.parent_span_id).toBe(checkoutSpanId);
 
-    const postCheckoutStep1 = postCheckoutEvent.spans?.find(s => s.description === 'post-checkout-1');
+    const postCheckoutStep1 = checkoutSpans.find(s => s.name === 'post-checkout-1');
     expect(postCheckoutStep1).toBeDefined();
     expect(postCheckoutStep1?.parent_span_id).toBe(postCheckoutSpanId);
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/stringSampleRate/init.js b/dev-packages/browser-integration-tests/suites/tracing/stringSampleRate/init.js
index cbf6c3a35415..dbefdbdfcda5 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/stringSampleRate/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/stringSampleRate/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: '1',
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/stringSampleRate/test.ts b/dev-packages/browser-integration-tests/suites/tracing/stringSampleRate/test.ts
index 207aa7517ac7..e078da24e465 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/stringSampleRate/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/stringSampleRate/test.ts
@@ -1,6 +1,8 @@
+import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequestOnUrl } from '../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../utils/helpers';
+import { waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../utils/spanUtils';
 
 sentryTest('parses a string sample rate', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
@@ -9,8 +11,7 @@ sentryTest('parses a string sample rate', async ({ getLocalTestUrl, page }) => {
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const req = await waitForTransactionRequestOnUrl(page, url);
-  const eventData = envelopeRequestParser(req);
+  const [span] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
 
-  expect(eventData.contexts?.trace?.data?.['sentry.sample_rate']).toStrictEqual(1);
+  expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toEqual({ type: 'integer', value: 1 });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/init.js
index 8718d9d354eb..30317eda63ef 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/init.js
@@ -5,7 +5,6 @@ import { feedbackIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration(), feedbackIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/init.js
similarity index 89%
rename from dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/init.js
index 3dd77207e103..8718d9d354eb 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/init.js
@@ -5,8 +5,9 @@ import { feedbackIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), feedbackIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration(), feedbackIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/subject.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/subject.js
new file mode 100644
index 000000000000..eead800a75a5
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/subject.js
@@ -0,0 +1,23 @@
+const errorBtn = document.getElementById('errorBtn');
+errorBtn.addEventListener('click', () => {
+  throw new Error(`Sentry Test Error ${Math.random()}`);
+});
+
+const fetchBtn = document.getElementById('fetchBtn');
+fetchBtn.addEventListener('click', async () => {
+  await fetch('http://sentry-test-site.example');
+});
+
+const xhrBtn = document.getElementById('xhrBtn');
+xhrBtn.addEventListener('click', () => {
+  const xhr = new XMLHttpRequest();
+  xhr.open('GET', 'http://sentry-test-site.example');
+  xhr.send();
+});
+
+const spanAndFetchBtn = document.getElementById('spanAndFetchBtn');
+spanAndFetchBtn.addEventListener('click', () => {
+  Sentry.startSpan({ name: 'custom-root-span' }, async () => {
+    await fetch('http://sentry-test-site.example');
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/template.html b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/template.html
new file mode 100644
index 000000000000..87e7bf5efbea
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/template.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <button id="errorBtn">Throw Error</button>
+    <button id="fetchBtn">Fetch Request</button>
+    <button id="xhrBtn">XHR Request</button>
+    <button id="spanAndFetchBtn">Start Span and Fetch Request</button>
+  </body>
+</html>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/test.ts
new file mode 100644
index 000000000000..2f7749685ba8
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-static/test.ts
@@ -0,0 +1,363 @@
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import type { EventAndTraceHeader } from '../../../../utils/helpers';
+import {
+  eventAndTraceHeaderRequestParser,
+  getFirstSentryEnvelopeRequest,
+  getMultipleSentryEnvelopeRequests,
+  shouldSkipFeedbackTest,
+  shouldSkipTracingTest,
+} from '../../../../utils/helpers';
+
+sentryTest('creates a new trace and sample_rand on each navigation', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await getFirstSentryEnvelopeRequest(page, url);
+
+  const [navigation1Event, navigation1TraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    page,
+    `${url}#foo`,
+    eventAndTraceHeaderRequestParser,
+  );
+  const [navigation2Event, navigation2TraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    page,
+    `${url}#bar`,
+    eventAndTraceHeaderRequestParser,
+  );
+
+  const navigation1TraceContext = navigation1Event.contexts?.trace;
+  const navigation2TraceContext = navigation2Event.contexts?.trace;
+
+  expect(navigation1Event.type).toEqual('transaction');
+  expect(navigation2Event.type).toEqual('transaction');
+
+  expect(navigation1TraceContext).toMatchObject({
+    op: 'navigation',
+    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+  expect(navigation1TraceContext).not.toHaveProperty('parent_span_id');
+
+  expect(navigation1TraceHeader).toEqual({
+    environment: 'production',
+    public_key: 'public',
+    sample_rate: '1',
+    sampled: 'true',
+    trace_id: navigation1TraceContext?.trace_id,
+    sample_rand: expect.any(String),
+  });
+
+  expect(navigation2TraceContext).toMatchObject({
+    op: 'navigation',
+    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+  expect(navigation2TraceContext).not.toHaveProperty('parent_span_id');
+
+  expect(navigation2TraceHeader).toEqual({
+    environment: 'production',
+    public_key: 'public',
+    sample_rate: '1',
+    sampled: 'true',
+    trace_id: navigation2TraceContext?.trace_id,
+    sample_rand: expect.any(String),
+  });
+
+  expect(navigation1TraceContext?.trace_id).not.toEqual(navigation2TraceContext?.trace_id);
+  expect(navigation1TraceHeader?.sample_rand).not.toEqual(navigation2TraceHeader?.sample_rand);
+});
+
+sentryTest('error after navigation has navigation traceId', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  // ensure pageload transaction is finished
+  await getFirstSentryEnvelopeRequest<Event>(page, url);
+
+  const [navigationEvent, navigationTraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    page,
+    `${url}#foo`,
+    eventAndTraceHeaderRequestParser,
+  );
+  const navigationTraceContext = navigationEvent.contexts?.trace;
+
+  expect(navigationEvent.type).toEqual('transaction');
+
+  expect(navigationTraceContext).toMatchObject({
+    op: 'navigation',
+    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+  expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
+
+  expect(navigationTraceHeader).toEqual({
+    environment: 'production',
+    public_key: 'public',
+    sample_rate: '1',
+    sampled: 'true',
+    trace_id: navigationTraceContext?.trace_id,
+    sample_rand: expect.any(String),
+  });
+
+  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    page,
+    undefined,
+    eventAndTraceHeaderRequestParser,
+  );
+  await page.locator('#errorBtn').click();
+  const [errorEvent, errorTraceHeader] = await errorEventPromise;
+
+  expect(errorEvent.type).toEqual(undefined);
+
+  const errorTraceContext = errorEvent.contexts?.trace;
+  expect(errorTraceContext).toEqual({
+    trace_id: navigationTraceContext?.trace_id,
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+  expect(errorTraceHeader).toEqual({
+    environment: 'production',
+    public_key: 'public',
+    sample_rate: '1',
+    sampled: 'true',
+    trace_id: navigationTraceContext?.trace_id,
+    sample_rand: expect.any(String),
+  });
+});
+
+sentryTest('error during navigation has new navigation traceId', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  // ensure pageload transaction is finished
+  await getFirstSentryEnvelopeRequest<Event>(page, url);
+
+  const envelopeRequestsPromise = getMultipleSentryEnvelopeRequests<EventAndTraceHeader>(
+    page,
+    2,
+    undefined,
+    eventAndTraceHeaderRequestParser,
+  );
+
+  await page.goto(`${url}#foo`);
+  await page.locator('#errorBtn').click();
+  const envelopes = await envelopeRequestsPromise;
+
+  const [navigationEvent, navigationTraceHeader] = envelopes.find(envelope => envelope[0].type === 'transaction')!;
+  const [errorEvent, errorTraceHeader] = envelopes.find(envelope => !envelope[0].type)!;
+
+  expect(navigationEvent.type).toEqual('transaction');
+  expect(errorEvent.type).toEqual(undefined);
+
+  const navigationTraceContext = navigationEvent?.contexts?.trace;
+  expect(navigationTraceContext).toMatchObject({
+    op: 'navigation',
+    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+  expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
+
+  expect(navigationTraceHeader).toEqual({
+    environment: 'production',
+    public_key: 'public',
+    sample_rate: '1',
+    sampled: 'true',
+    trace_id: navigationTraceContext?.trace_id,
+    sample_rand: expect.any(String),
+  });
+
+  const errorTraceContext = errorEvent?.contexts?.trace;
+  expect(errorTraceContext).toEqual({
+    trace_id: navigationTraceContext?.trace_id,
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+
+  expect(errorTraceHeader).toEqual({
+    environment: 'production',
+    public_key: 'public',
+    sample_rate: '1',
+    sampled: 'true',
+    trace_id: navigationTraceContext?.trace_id,
+    sample_rand: expect.any(String),
+  });
+});
+
+sentryTest(
+  'outgoing fetch request during navigation has navigation traceId in headers',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await page.route('http://sentry-test-site.example/**', route => {
+      return route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({}),
+      });
+    });
+
+    // ensure pageload transaction is finished
+    await getFirstSentryEnvelopeRequest<Event>(page, url);
+
+    const navigationEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+      page,
+      undefined,
+      eventAndTraceHeaderRequestParser,
+    );
+    const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
+    await page.goto(`${url}#foo`);
+    await page.locator('#fetchBtn').click();
+    const [[navigationEvent, navigationTraceHeader], request] = await Promise.all([
+      navigationEventPromise,
+      requestPromise,
+    ]);
+
+    const navigationTraceContext = navigationEvent.contexts?.trace;
+
+    expect(navigationEvent.type).toEqual('transaction');
+    expect(navigationTraceContext).toMatchObject({
+      op: 'navigation',
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    });
+    expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
+
+    expect(navigationTraceHeader).toEqual({
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: navigationTraceContext?.trace_id,
+      sample_rand: expect.any(String),
+    });
+
+    const headers = request.headers();
+
+    // sampling decision is propagated from active span sampling decision
+    const navigationTraceId = navigationTraceContext?.trace_id;
+    expect(headers['sentry-trace']).toMatch(new RegExp(`^${navigationTraceId}-[0-9a-f]{16}-1$`));
+    expect(headers['baggage']).toEqual(
+      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${navigationTraceId},sentry-sampled=true,sentry-sample_rand=${navigationTraceHeader?.sample_rand},sentry-sample_rate=1`,
+    );
+  },
+);
+
+sentryTest(
+  'outgoing XHR request during navigation has navigation traceId in headers',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await page.route('http://sentry-test-site.example/**', route => {
+      return route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({}),
+      });
+    });
+
+    // ensure navigation transaction is finished
+    await getFirstSentryEnvelopeRequest(page, url);
+
+    const navigationEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+      page,
+      undefined,
+      eventAndTraceHeaderRequestParser,
+    );
+    const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
+    await page.goto(`${url}#foo`);
+    await page.locator('#xhrBtn').click();
+    const [[navigationEvent, navigationTraceHeader], request] = await Promise.all([
+      navigationEventPromise,
+      requestPromise,
+    ]);
+
+    const navigationTraceContext = navigationEvent.contexts?.trace;
+
+    expect(navigationEvent.type).toEqual('transaction');
+    expect(navigationTraceContext).toMatchObject({
+      op: 'navigation',
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    });
+    expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
+
+    expect(navigationTraceHeader).toEqual({
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: navigationTraceContext?.trace_id,
+      sample_rand: expect.any(String),
+    });
+
+    const headers = request.headers();
+
+    // sampling decision is propagated from active span sampling decision
+    const navigationTraceId = navigationTraceContext?.trace_id;
+    expect(headers['sentry-trace']).toMatch(new RegExp(`^${navigationTraceId}-[0-9a-f]{16}-1$`));
+    expect(headers['baggage']).toEqual(
+      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${navigationTraceId},sentry-sampled=true,sentry-sample_rand=${navigationTraceHeader?.sample_rand},sentry-sample_rate=1`,
+    );
+  },
+);
+
+sentryTest(
+  'user feedback event after navigation has navigation traceId in headers',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest() || shouldSkipFeedbackTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname, handleLazyLoadedFeedback: true });
+
+    // ensure pageload transaction is finished
+    await getFirstSentryEnvelopeRequest<Event>(page, url);
+
+    const navigationEvent = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#foo`);
+
+    const navigationTraceContext = navigationEvent.contexts?.trace;
+    expect(navigationTraceContext).toMatchObject({
+      op: 'navigation',
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    });
+    expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
+
+    const feedbackEventsPromise = getMultipleSentryEnvelopeRequests<Event>(page, 1, { envelopeType: 'feedback' });
+
+    await page.getByText('Report a Bug').click();
+    expect(await page.locator(':visible:text-is("Report a Bug")').count()).toEqual(1);
+    await page.locator('[name="name"]').fill('Jane Doe');
+    await page.locator('[name="email"]').fill('janedoe@example.org');
+    await page.locator('[name="message"]').fill('my example feedback');
+    await page.locator('[data-sentry-feedback] .btn--primary').click();
+
+    const [feedbackEvent] = await feedbackEventsPromise;
+
+    expect(feedbackEvent.type).toEqual('feedback');
+
+    const feedbackTraceContext = feedbackEvent.contexts?.trace;
+
+    expect(feedbackTraceContext).toMatchObject({
+      trace_id: navigationTraceContext?.trace_id,
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    });
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-streamed/test.ts
deleted file mode 100644
index 3c2cafaa0430..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation-streamed/test.ts
+++ /dev/null
@@ -1,317 +0,0 @@
-import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
-import { sentryTest } from '../../../../utils/fixtures';
-import type { EventAndTraceHeader } from '../../../../utils/helpers';
-import {
-  eventAndTraceHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
-  shouldSkipFeedbackTest,
-  shouldSkipTracingTest,
-} from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
-
-sentryTest('creates a new trace and sample_rand on each navigation', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  // Wait for and skip the initial pageload span
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-  await page.goto(url);
-  await pageloadSpanPromise;
-
-  const navigation1SpanEnvelopePromise = waitForStreamedSpanEnvelope(
-    page,
-    env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
-  );
-  await page.goto(`${url}#foo`);
-  const navigation1SpanEnvelope = await navigation1SpanEnvelopePromise;
-
-  const navigation2SpanEnvelopePromise = waitForStreamedSpanEnvelope(
-    page,
-    env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
-  );
-  await page.goto(`${url}#bar`);
-  const navigation2SpanEnvelope = await navigation2SpanEnvelopePromise;
-
-  const navigation1TraceId = navigation1SpanEnvelope[0].trace?.trace_id;
-  const navigation1SampleRand = navigation1SpanEnvelope[0].trace?.sample_rand;
-  const navigation2TraceId = navigation2SpanEnvelope[0].trace?.trace_id;
-  const navigation2SampleRand = navigation2SpanEnvelope[0].trace?.sample_rand;
-
-  const navigation1Span = navigation1SpanEnvelope[1][0][1].items.find(s => getSpanOp(s) === 'navigation')!;
-  const navigation2Span = navigation2SpanEnvelope[1][0][1].items.find(s => getSpanOp(s) === 'navigation')!;
-
-  expect(getSpanOp(navigation1Span)).toEqual('navigation');
-  expect(navigation1TraceId).toMatch(/^[\da-f]{32}$/);
-  expect(navigation1Span.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(navigation1Span.parent_span_id).toBeUndefined();
-
-  expect(navigation1SpanEnvelope[0].trace).toEqual({
-    environment: 'production',
-    public_key: 'public',
-    sample_rate: '1',
-    sampled: 'true',
-    trace_id: navigation1TraceId,
-    sample_rand: expect.any(String),
-  });
-
-  expect(getSpanOp(navigation2Span)).toEqual('navigation');
-  expect(navigation2TraceId).toMatch(/^[\da-f]{32}$/);
-  expect(navigation2Span.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(navigation2Span.parent_span_id).toBeUndefined();
-
-  expect(navigation2SpanEnvelope[0].trace).toEqual({
-    environment: 'production',
-    public_key: 'public',
-    sample_rate: '1',
-    sampled: 'true',
-    trace_id: navigation2TraceId,
-    sample_rand: expect.any(String),
-  });
-
-  expect(navigation1TraceId).not.toEqual(navigation2TraceId);
-  expect(navigation1SampleRand).not.toEqual(navigation2SampleRand);
-});
-
-sentryTest('error after navigation has navigation traceId', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  // ensure pageload span is finished
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-  await page.goto(url);
-  await pageloadSpanPromise;
-
-  const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
-  const navigationSpanEnvelopePromise = waitForStreamedSpanEnvelope(
-    page,
-    env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
-  );
-  await page.goto(`${url}#foo`);
-  const [navigationSpan, navigationSpanEnvelope] = await Promise.all([
-    navigationSpanPromise,
-    navigationSpanEnvelopePromise,
-  ]);
-
-  const navigationTraceId = navigationSpan.trace_id;
-
-  expect(getSpanOp(navigationSpan)).toEqual('navigation');
-  expect(navigationTraceId).toMatch(/^[\da-f]{32}$/);
-  expect(navigationSpan.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(navigationSpan.parent_span_id).toBeUndefined();
-
-  expect(navigationSpanEnvelope[0].trace).toEqual({
-    environment: 'production',
-    public_key: 'public',
-    sample_rate: '1',
-    sampled: 'true',
-    trace_id: navigationTraceId,
-    sample_rand: expect.any(String),
-  });
-
-  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
-  await page.locator('#errorBtn').click();
-  const [errorEvent, errorTraceHeader] = await errorEventPromise;
-
-  expect(errorEvent.type).toEqual(undefined);
-
-  const errorTraceContext = errorEvent.contexts?.trace;
-  expect(errorTraceContext).toEqual({
-    trace_id: navigationTraceId,
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-  expect(errorTraceHeader).toEqual({
-    environment: 'production',
-    public_key: 'public',
-    sample_rate: '1',
-    sampled: 'true',
-    trace_id: navigationTraceId,
-    sample_rand: expect.any(String),
-  });
-});
-
-sentryTest('error during navigation has new navigation traceId', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  // ensure pageload span is finished
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-  await page.goto(url);
-  await pageloadSpanPromise;
-
-  const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
-  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
-
-  await page.goto(`${url}#foo`);
-  await page.locator('#errorBtn').click();
-  const [navigationSpan, [errorEvent, errorTraceHeader]] = await Promise.all([
-    navigationSpanPromise,
-    errorEventPromise,
-  ]);
-
-  expect(getSpanOp(navigationSpan)).toEqual('navigation');
-  expect(errorEvent.type).toEqual(undefined);
-
-  const navigationTraceId = navigationSpan.trace_id;
-  expect(navigationTraceId).toMatch(/^[\da-f]{32}$/);
-  expect(navigationSpan.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(navigationSpan.parent_span_id).toBeUndefined();
-
-  const errorTraceContext = errorEvent?.contexts?.trace;
-  expect(errorTraceContext).toEqual({
-    trace_id: navigationTraceId,
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-
-  expect(errorTraceHeader).toEqual({
-    environment: 'production',
-    public_key: 'public',
-    sample_rate: '1',
-    sampled: 'true',
-    trace_id: navigationTraceId,
-    sample_rand: expect.any(String),
-  });
-});
-
-sentryTest(
-  'outgoing fetch request during navigation has navigation traceId in headers',
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    await page.route('http://sentry-test-site.example/**', route => {
-      return route.fulfill({
-        status: 200,
-        contentType: 'application/json',
-        body: JSON.stringify({}),
-      });
-    });
-
-    // ensure pageload span is finished
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-    await page.goto(url);
-    await pageloadSpanPromise;
-
-    const navigationSpanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
-    );
-    const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
-    await page.goto(`${url}#foo`);
-    await page.locator('#fetchBtn').click();
-    const [navigationSpanEnvelope, request] = await Promise.all([navigationSpanEnvelopePromise, requestPromise]);
-
-    const navigationTraceId = navigationSpanEnvelope[0].trace?.trace_id;
-    const sampleRand = navigationSpanEnvelope[0].trace?.sample_rand;
-
-    expect(navigationTraceId).toMatch(/^[\da-f]{32}$/);
-
-    const headers = request.headers();
-
-    // sampling decision is propagated from active span sampling decision
-    expect(headers['sentry-trace']).toMatch(new RegExp(`^${navigationTraceId}-[0-9a-f]{16}-1$`));
-    expect(headers['baggage']).toEqual(
-      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${navigationTraceId},sentry-sampled=true,sentry-sample_rand=${sampleRand},sentry-sample_rate=1`,
-    );
-  },
-);
-
-sentryTest(
-  'outgoing XHR request during navigation has navigation traceId in headers',
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    await page.route('http://sentry-test-site.example/**', route => {
-      return route.fulfill({
-        status: 200,
-        contentType: 'application/json',
-        body: JSON.stringify({}),
-      });
-    });
-
-    // ensure navigation span is finished
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-    await page.goto(url);
-    await pageloadSpanPromise;
-
-    const navigationSpanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
-    );
-    const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
-    await page.goto(`${url}#foo`);
-    await page.locator('#xhrBtn').click();
-    const [navigationSpanEnvelope, request] = await Promise.all([navigationSpanEnvelopePromise, requestPromise]);
-
-    const navigationTraceId = navigationSpanEnvelope[0].trace?.trace_id;
-    const sampleRand = navigationSpanEnvelope[0].trace?.sample_rand;
-
-    expect(navigationTraceId).toMatch(/^[\da-f]{32}$/);
-
-    const headers = request.headers();
-
-    // sampling decision is propagated from active span sampling decision
-    expect(headers['sentry-trace']).toMatch(new RegExp(`^${navigationTraceId}-[0-9a-f]{16}-1$`));
-    expect(headers['baggage']).toEqual(
-      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${navigationTraceId},sentry-sampled=true,sentry-sample_rand=${sampleRand},sentry-sample_rate=1`,
-    );
-  },
-);
-
-sentryTest(
-  'user feedback event after navigation has navigation traceId in headers',
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest() || shouldSkipFeedbackTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname, handleLazyLoadedFeedback: true });
-
-    // ensure pageload span is finished
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-    await page.goto(url);
-    await pageloadSpanPromise;
-
-    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
-    await page.goto(`${url}#foo`);
-    const navigationSpan = await navigationSpanPromise;
-
-    const navigationTraceId = navigationSpan.trace_id;
-    expect(getSpanOp(navigationSpan)).toEqual('navigation');
-    expect(navigationTraceId).toMatch(/^[\da-f]{32}$/);
-    expect(navigationSpan.span_id).toMatch(/^[\da-f]{16}$/);
-    expect(navigationSpan.parent_span_id).toBeUndefined();
-
-    const feedbackEventPromise = getFirstSentryEnvelopeRequest<Event>(page);
-
-    await page.getByText('Report a Bug').click();
-    expect(await page.locator(':visible:text-is("Report a Bug")').count()).toEqual(1);
-    await page.locator('[name="name"]').fill('Jane Doe');
-    await page.locator('[name="email"]').fill('janedoe@example.org');
-    await page.locator('[name="message"]').fill('my example feedback');
-    await page.locator('[data-sentry-feedback] .btn--primary').click();
-
-    const feedbackEvent = await feedbackEventPromise;
-
-    expect(feedbackEvent.type).toEqual('feedback');
-
-    const feedbackTraceContext = feedbackEvent.contexts?.trace;
-
-    expect(feedbackTraceContext).toMatchObject({
-      trace_id: navigationTraceId,
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    });
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation/init.js
similarity index 89%
rename from dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation/init.js
index 3dd77207e103..30317eda63ef 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation/init.js
@@ -6,7 +6,7 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), feedbackIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration(), feedbackIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation/test.ts
index 0255507287d3..37bb7cb62f8c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/navigation/test.ts
@@ -1,117 +1,117 @@
 import { expect } from '@playwright/test';
 import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import type { EventAndTraceHeader } from '../../../../utils/helpers';
 import {
   eventAndTraceHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
   getMultipleSentryEnvelopeRequests,
   shouldSkipFeedbackTest,
   shouldSkipTracingTest,
+  waitForErrorRequest,
 } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
 
 sentryTest('creates a new trace and sample_rand on each navigation', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  await getFirstSentryEnvelopeRequest(page, url);
+  // Wait for and skip the initial pageload span
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+  await page.goto(url);
+  await pageloadSpanPromise;
 
-  const [navigation1Event, navigation1TraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+  const navigation1SpanEnvelopePromise = waitForStreamedSpanEnvelope(
     page,
-    `${url}#foo`,
-    eventAndTraceHeaderRequestParser,
+    env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
   );
-  const [navigation2Event, navigation2TraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+  await page.goto(`${url}#foo`);
+  const navigation1SpanEnvelope = await navigation1SpanEnvelopePromise;
+
+  const navigation2SpanEnvelopePromise = waitForStreamedSpanEnvelope(
     page,
-    `${url}#bar`,
-    eventAndTraceHeaderRequestParser,
+    env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
   );
+  await page.goto(`${url}#bar`);
+  const navigation2SpanEnvelope = await navigation2SpanEnvelopePromise;
 
-  const navigation1TraceContext = navigation1Event.contexts?.trace;
-  const navigation2TraceContext = navigation2Event.contexts?.trace;
+  const navigation1TraceId = navigation1SpanEnvelope[0].trace?.trace_id;
+  const navigation1SampleRand = navigation1SpanEnvelope[0].trace?.sample_rand;
+  const navigation2TraceId = navigation2SpanEnvelope[0].trace?.trace_id;
+  const navigation2SampleRand = navigation2SpanEnvelope[0].trace?.sample_rand;
 
-  expect(navigation1Event.type).toEqual('transaction');
-  expect(navigation2Event.type).toEqual('transaction');
+  const navigation1Span = navigation1SpanEnvelope[1][0][1].items.find(s => getSpanOp(s) === 'navigation')!;
+  const navigation2Span = navigation2SpanEnvelope[1][0][1].items.find(s => getSpanOp(s) === 'navigation')!;
 
-  expect(navigation1TraceContext).toMatchObject({
-    op: 'navigation',
-    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-  expect(navigation1TraceContext).not.toHaveProperty('parent_span_id');
+  expect(getSpanOp(navigation1Span)).toEqual('navigation');
+  expect(navigation1TraceId).toMatch(/^[\da-f]{32}$/);
+  expect(navigation1Span.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(navigation1Span.parent_span_id).toBeUndefined();
 
-  expect(navigation1TraceHeader).toEqual({
+  expect(navigation1SpanEnvelope[0].trace).toEqual({
     environment: 'production',
     public_key: 'public',
     sample_rate: '1',
     sampled: 'true',
-    trace_id: navigation1TraceContext?.trace_id,
+    trace_id: navigation1TraceId,
     sample_rand: expect.any(String),
   });
 
-  expect(navigation2TraceContext).toMatchObject({
-    op: 'navigation',
-    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-  expect(navigation2TraceContext).not.toHaveProperty('parent_span_id');
+  expect(getSpanOp(navigation2Span)).toEqual('navigation');
+  expect(navigation2TraceId).toMatch(/^[\da-f]{32}$/);
+  expect(navigation2Span.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(navigation2Span.parent_span_id).toBeUndefined();
 
-  expect(navigation2TraceHeader).toEqual({
+  expect(navigation2SpanEnvelope[0].trace).toEqual({
     environment: 'production',
     public_key: 'public',
     sample_rate: '1',
     sampled: 'true',
-    trace_id: navigation2TraceContext?.trace_id,
+    trace_id: navigation2TraceId,
     sample_rand: expect.any(String),
   });
 
-  expect(navigation1TraceContext?.trace_id).not.toEqual(navigation2TraceContext?.trace_id);
-  expect(navigation1TraceHeader?.sample_rand).not.toEqual(navigation2TraceHeader?.sample_rand);
+  expect(navigation1TraceId).not.toEqual(navigation2TraceId);
+  expect(navigation1SampleRand).not.toEqual(navigation2SampleRand);
 });
 
 sentryTest('error after navigation has navigation traceId', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  // ensure pageload transaction is finished
-  await getFirstSentryEnvelopeRequest<Event>(page, url);
+  // ensure pageload span is finished
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+  await page.goto(url);
+  await pageloadSpanPromise;
 
-  const [navigationEvent, navigationTraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+  const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
+  const navigationSpanEnvelopePromise = waitForStreamedSpanEnvelope(
     page,
-    `${url}#foo`,
-    eventAndTraceHeaderRequestParser,
+    env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
   );
-  const navigationTraceContext = navigationEvent.contexts?.trace;
+  await page.goto(`${url}#foo`);
+  const [navigationSpan, navigationSpanEnvelope] = await Promise.all([
+    navigationSpanPromise,
+    navigationSpanEnvelopePromise,
+  ]);
 
-  expect(navigationEvent.type).toEqual('transaction');
+  const navigationTraceId = navigationSpan.trace_id;
 
-  expect(navigationTraceContext).toMatchObject({
-    op: 'navigation',
-    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-  expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
+  expect(getSpanOp(navigationSpan)).toEqual('navigation');
+  expect(navigationTraceId).toMatch(/^[\da-f]{32}$/);
+  expect(navigationSpan.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(navigationSpan.parent_span_id).toBeUndefined();
 
-  expect(navigationTraceHeader).toEqual({
+  expect(navigationSpanEnvelope[0].trace).toEqual({
     environment: 'production',
     public_key: 'public',
     sample_rate: '1',
     sampled: 'true',
-    trace_id: navigationTraceContext?.trace_id,
+    trace_id: navigationTraceId,
     sample_rand: expect.any(String),
   });
 
-  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
+  const errorEventPromise = waitForErrorRequest(page).then(eventAndTraceHeaderRequestParser);
   await page.locator('#errorBtn').click();
   const [errorEvent, errorTraceHeader] = await errorEventPromise;
 
@@ -119,7 +119,7 @@ sentryTest('error after navigation has navigation traceId', async ({ getLocalTes
 
   const errorTraceContext = errorEvent.contexts?.trace;
   expect(errorTraceContext).toEqual({
-    trace_id: navigationTraceContext?.trace_id,
+    trace_id: navigationTraceId,
     span_id: expect.stringMatching(/^[\da-f]{16}$/),
   });
   expect(errorTraceHeader).toEqual({
@@ -127,58 +127,42 @@ sentryTest('error after navigation has navigation traceId', async ({ getLocalTes
     public_key: 'public',
     sample_rate: '1',
     sampled: 'true',
-    trace_id: navigationTraceContext?.trace_id,
+    trace_id: navigationTraceId,
     sample_rand: expect.any(String),
   });
 });
 
 sentryTest('error during navigation has new navigation traceId', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  // ensure pageload transaction is finished
-  await getFirstSentryEnvelopeRequest<Event>(page, url);
+  // ensure pageload span is finished
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+  await page.goto(url);
+  await pageloadSpanPromise;
 
-  const envelopeRequestsPromise = getMultipleSentryEnvelopeRequests<EventAndTraceHeader>(
-    page,
-    2,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
+  const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
+  const errorEventPromise = waitForErrorRequest(page).then(eventAndTraceHeaderRequestParser);
 
   await page.goto(`${url}#foo`);
   await page.locator('#errorBtn').click();
-  const envelopes = await envelopeRequestsPromise;
-
-  const [navigationEvent, navigationTraceHeader] = envelopes.find(envelope => envelope[0].type === 'transaction')!;
-  const [errorEvent, errorTraceHeader] = envelopes.find(envelope => !envelope[0].type)!;
+  const [navigationSpan, [errorEvent, errorTraceHeader]] = await Promise.all([
+    navigationSpanPromise,
+    errorEventPromise,
+  ]);
 
-  expect(navigationEvent.type).toEqual('transaction');
+  expect(getSpanOp(navigationSpan)).toEqual('navigation');
   expect(errorEvent.type).toEqual(undefined);
 
-  const navigationTraceContext = navigationEvent?.contexts?.trace;
-  expect(navigationTraceContext).toMatchObject({
-    op: 'navigation',
-    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-  expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
-
-  expect(navigationTraceHeader).toEqual({
-    environment: 'production',
-    public_key: 'public',
-    sample_rate: '1',
-    sampled: 'true',
-    trace_id: navigationTraceContext?.trace_id,
-    sample_rand: expect.any(String),
-  });
+  const navigationTraceId = navigationSpan.trace_id;
+  expect(navigationTraceId).toMatch(/^[\da-f]{32}$/);
+  expect(navigationSpan.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(navigationSpan.parent_span_id).toBeUndefined();
 
   const errorTraceContext = errorEvent?.contexts?.trace;
   expect(errorTraceContext).toEqual({
-    trace_id: navigationTraceContext?.trace_id,
+    trace_id: navigationTraceId,
     span_id: expect.stringMatching(/^[\da-f]{16}$/),
   });
 
@@ -187,7 +171,7 @@ sentryTest('error during navigation has new navigation traceId', async ({ getLoc
     public_key: 'public',
     sample_rate: '1',
     sampled: 'true',
-    trace_id: navigationTraceContext?.trace_id,
+    trace_id: navigationTraceId,
     sample_rand: expect.any(String),
   });
 });
@@ -195,9 +179,7 @@ sentryTest('error during navigation has new navigation traceId', async ({ getLoc
 sentryTest(
   'outgoing fetch request during navigation has navigation traceId in headers',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
@@ -209,48 +191,31 @@ sentryTest(
       });
     });
 
-    // ensure pageload transaction is finished
-    await getFirstSentryEnvelopeRequest<Event>(page, url);
+    // ensure pageload span is finished
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    await page.goto(url);
+    await pageloadSpanPromise;
 
-    const navigationEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    const navigationSpanEnvelopePromise = waitForStreamedSpanEnvelope(
       page,
-      undefined,
-      eventAndTraceHeaderRequestParser,
+      env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
     );
     const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
     await page.goto(`${url}#foo`);
     await page.locator('#fetchBtn').click();
-    const [[navigationEvent, navigationTraceHeader], request] = await Promise.all([
-      navigationEventPromise,
-      requestPromise,
-    ]);
+    const [navigationSpanEnvelope, request] = await Promise.all([navigationSpanEnvelopePromise, requestPromise]);
 
-    const navigationTraceContext = navigationEvent.contexts?.trace;
+    const navigationTraceId = navigationSpanEnvelope[0].trace?.trace_id;
+    const sampleRand = navigationSpanEnvelope[0].trace?.sample_rand;
 
-    expect(navigationEvent.type).toEqual('transaction');
-    expect(navigationTraceContext).toMatchObject({
-      op: 'navigation',
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    });
-    expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
-
-    expect(navigationTraceHeader).toEqual({
-      environment: 'production',
-      public_key: 'public',
-      sample_rate: '1',
-      sampled: 'true',
-      trace_id: navigationTraceContext?.trace_id,
-      sample_rand: expect.any(String),
-    });
+    expect(navigationTraceId).toMatch(/^[\da-f]{32}$/);
 
     const headers = request.headers();
 
     // sampling decision is propagated from active span sampling decision
-    const navigationTraceId = navigationTraceContext?.trace_id;
     expect(headers['sentry-trace']).toMatch(new RegExp(`^${navigationTraceId}-[0-9a-f]{16}-1$`));
     expect(headers['baggage']).toEqual(
-      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${navigationTraceId},sentry-sampled=true,sentry-sample_rand=${navigationTraceHeader?.sample_rand},sentry-sample_rate=1`,
+      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${navigationTraceId},sentry-sampled=true,sentry-sample_rand=${sampleRand},sentry-sample_rate=1`,
     );
   },
 );
@@ -258,9 +223,7 @@ sentryTest(
 sentryTest(
   'outgoing XHR request during navigation has navigation traceId in headers',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
@@ -272,48 +235,31 @@ sentryTest(
       });
     });
 
-    // ensure navigation transaction is finished
-    await getFirstSentryEnvelopeRequest(page, url);
+    // ensure navigation span is finished
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    await page.goto(url);
+    await pageloadSpanPromise;
 
-    const navigationEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    const navigationSpanEnvelopePromise = waitForStreamedSpanEnvelope(
       page,
-      undefined,
-      eventAndTraceHeaderRequestParser,
+      env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
     );
     const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
     await page.goto(`${url}#foo`);
     await page.locator('#xhrBtn').click();
-    const [[navigationEvent, navigationTraceHeader], request] = await Promise.all([
-      navigationEventPromise,
-      requestPromise,
-    ]);
+    const [navigationSpanEnvelope, request] = await Promise.all([navigationSpanEnvelopePromise, requestPromise]);
 
-    const navigationTraceContext = navigationEvent.contexts?.trace;
+    const navigationTraceId = navigationSpanEnvelope[0].trace?.trace_id;
+    const sampleRand = navigationSpanEnvelope[0].trace?.sample_rand;
 
-    expect(navigationEvent.type).toEqual('transaction');
-    expect(navigationTraceContext).toMatchObject({
-      op: 'navigation',
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    });
-    expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
-
-    expect(navigationTraceHeader).toEqual({
-      environment: 'production',
-      public_key: 'public',
-      sample_rate: '1',
-      sampled: 'true',
-      trace_id: navigationTraceContext?.trace_id,
-      sample_rand: expect.any(String),
-    });
+    expect(navigationTraceId).toMatch(/^[\da-f]{32}$/);
 
     const headers = request.headers();
 
     // sampling decision is propagated from active span sampling decision
-    const navigationTraceId = navigationTraceContext?.trace_id;
     expect(headers['sentry-trace']).toMatch(new RegExp(`^${navigationTraceId}-[0-9a-f]{16}-1$`));
     expect(headers['baggage']).toEqual(
-      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${navigationTraceId},sentry-sampled=true,sentry-sample_rand=${navigationTraceHeader?.sample_rand},sentry-sample_rate=1`,
+      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${navigationTraceId},sentry-sampled=true,sentry-sample_rand=${sampleRand},sentry-sample_rate=1`,
     );
   },
 );
@@ -321,26 +267,26 @@ sentryTest(
 sentryTest(
   'user feedback event after navigation has navigation traceId in headers',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest() || shouldSkipFeedbackTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest() || shouldSkipFeedbackTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname, handleLazyLoadedFeedback: true });
 
-    // ensure pageload transaction is finished
-    await getFirstSentryEnvelopeRequest<Event>(page, url);
+    // ensure pageload span is finished
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    await page.goto(url);
+    await pageloadSpanPromise;
 
-    const navigationEvent = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#foo`);
+    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
+    await page.goto(`${url}#foo`);
+    const navigationSpan = await navigationSpanPromise;
 
-    const navigationTraceContext = navigationEvent.contexts?.trace;
-    expect(navigationTraceContext).toMatchObject({
-      op: 'navigation',
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    });
-    expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
+    const navigationTraceId = navigationSpan.trace_id;
+    expect(getSpanOp(navigationSpan)).toEqual('navigation');
+    expect(navigationTraceId).toMatch(/^[\da-f]{32}$/);
+    expect(navigationSpan.span_id).toMatch(/^[\da-f]{16}$/);
+    expect(navigationSpan.parent_span_id).toBeUndefined();
 
-    const feedbackEventPromise = getFirstSentryEnvelopeRequest<Event>(page);
+    const feedbackEventsPromise = getMultipleSentryEnvelopeRequests<Event>(page, 1, { envelopeType: 'feedback' });
 
     await page.getByText('Report a Bug').click();
     expect(await page.locator(':visible:text-is("Report a Bug")').count()).toEqual(1);
@@ -349,14 +295,14 @@ sentryTest(
     await page.locator('[name="message"]').fill('my example feedback');
     await page.locator('[data-sentry-feedback] .btn--primary').click();
 
-    const feedbackEvent = await feedbackEventPromise;
+    const [feedbackEvent] = await feedbackEventsPromise;
 
     expect(feedbackEvent.type).toEqual('feedback');
 
     const feedbackTraceContext = feedbackEvent.contexts?.trace;
 
     expect(feedbackTraceContext).toMatchObject({
-      trace_id: navigationTraceContext?.trace_id,
+      trace_id: navigationTraceId,
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
     });
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-headers/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-headers/test.ts
index 76e015dcb07a..efe6897d497e 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-headers/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-headers/test.ts
@@ -1,11 +1,8 @@
+import { SENTRY_OP } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import type { EventAndTraceHeader } from '../../../../utils/helpers';
-import {
-  eventAndTraceHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
-  shouldSkipTracingTest,
-} from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
 const META_TAG_TRACE_ID = '12345678901234567890123456789012';
 const META_TAG_PARENT_SPAN_ID = '1234567890123456';
@@ -28,23 +25,13 @@ sentryTest(
       },
     });
 
-    const [pageloadEvent, pageloadTraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-      page,
-      url,
-      eventAndTraceHeaderRequestParser,
-    );
-    const [navigationEvent, navigationTraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-      page,
-      `${url}#foo`,
-      eventAndTraceHeaderRequestParser,
-    );
+    const [pageloadSpan, pageloadTraceHeader] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
+    const [navigationSpan, navigationTraceHeader] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, `${url}#foo`);
 
-    const pageloadTraceContext = pageloadEvent.contexts?.trace;
-    const navigationTraceContext = navigationEvent.contexts?.trace;
-
-    expect(pageloadEvent.type).toEqual('transaction');
-    expect(pageloadTraceContext).toMatchObject({
-      op: 'pageload',
+    expect(pageloadSpan.is_segment).toBe(true);
+    expect(pageloadSpan).toMatchObject({
+      is_segment: true,
+      attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'pageload' } }),
       trace_id: META_TAG_TRACE_ID,
       parent_span_id: META_TAG_PARENT_SPAN_ID,
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
@@ -61,25 +48,26 @@ sentryTest(
       sample_rand: '0.42',
     });
 
-    expect(navigationEvent.type).toEqual('transaction');
-    expect(navigationTraceContext).toMatchObject({
-      op: 'navigation',
+    expect(navigationSpan.is_segment).toBe(true);
+    expect(navigationSpan).toMatchObject({
+      is_segment: true,
+      attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'navigation' } }),
       trace_id: expect.stringMatching(/^[\da-f]{32}$/),
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
     });
     // navigation span is head of trace, so there's no parent span:
-    expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
+    expect(navigationSpan).not.toHaveProperty('parent_span_id');
 
     expect(navigationTraceHeader).toEqual({
       environment: 'production',
       public_key: 'public',
       sample_rate: '1',
       sampled: 'true',
-      trace_id: navigationTraceContext?.trace_id,
+      trace_id: navigationSpan?.trace_id,
       sample_rand: expect.any(String),
     });
 
-    expect(pageloadTraceContext?.trace_id).not.toEqual(navigationTraceContext?.trace_id);
+    expect(pageloadSpan?.trace_id).not.toEqual(navigationSpan?.trace_id);
     expect(pageloadTraceHeader?.sample_rand).not.toEqual(navigationTraceHeader?.sample_rand);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-meta/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-meta/test.ts
index c66d8793e610..5d81177d2515 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-meta/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-meta/test.ts
@@ -1,14 +1,19 @@
+import { SENTRY_OP } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import type { EventAndTraceHeader } from '../../../../utils/helpers';
 import {
   eventAndTraceHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
   getMultipleSentryEnvelopeRequests,
   shouldSkipFeedbackTest,
   shouldSkipTracingTest,
+  waitForErrorRequest,
 } from '../../../../utils/helpers';
+import {
+  getSpanOp,
+  waitForStreamedSpanAndTraceHeader,
+  waitForStreamedSpanAndTraceHeaderOnUrl,
+} from '../../../../utils/spanUtils';
 
 const META_TAG_TRACE_ID = '12345678901234567890123456789012';
 const META_TAG_PARENT_SPAN_ID = '1234567890123456';
@@ -24,23 +29,13 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const [pageloadEvent, pageloadTraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-      page,
-      url,
-      eventAndTraceHeaderRequestParser,
-    );
-    const [navigationEvent, navigationTraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-      page,
-      `${url}#foo`,
-      eventAndTraceHeaderRequestParser,
-    );
-
-    const pageloadTraceContext = pageloadEvent.contexts?.trace;
-    const navigationTraceContext = navigationEvent.contexts?.trace;
+    const [pageloadSpan, pageloadTraceHeader] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
+    const [navigationSpan, navigationTraceHeader] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, `${url}#foo`);
 
-    expect(pageloadEvent.type).toEqual('transaction');
-    expect(pageloadTraceContext).toMatchObject({
-      op: 'pageload',
+    expect(pageloadSpan.is_segment).toBe(true);
+    expect(pageloadSpan).toMatchObject({
+      is_segment: true,
+      attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'pageload' } }),
       trace_id: META_TAG_TRACE_ID,
       parent_span_id: META_TAG_PARENT_SPAN_ID,
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
@@ -57,25 +52,26 @@ sentryTest(
       sample_rand: '0.42',
     });
 
-    expect(navigationEvent.type).toEqual('transaction');
-    expect(navigationTraceContext).toMatchObject({
-      op: 'navigation',
+    expect(navigationSpan.is_segment).toBe(true);
+    expect(navigationSpan).toMatchObject({
+      is_segment: true,
+      attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'navigation' } }),
       trace_id: expect.stringMatching(/^[\da-f]{32}$/),
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
     });
     // navigation span is head of trace, so there's no parent span:
-    expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
+    expect(navigationSpan).not.toHaveProperty('parent_span_id');
 
     expect(navigationTraceHeader).toEqual({
       environment: 'production',
       public_key: 'public',
       sample_rate: '1',
       sampled: 'true',
-      trace_id: navigationTraceContext?.trace_id,
+      trace_id: navigationSpan?.trace_id,
       sample_rand: expect.any(String),
     });
 
-    expect(pageloadTraceContext?.trace_id).not.toEqual(navigationTraceContext?.trace_id);
+    expect(pageloadSpan?.trace_id).not.toEqual(navigationSpan?.trace_id);
     expect(pageloadTraceHeader?.sample_rand).not.toEqual(navigationTraceHeader?.sample_rand);
   },
 );
@@ -87,14 +83,11 @@ sentryTest('error after <meta> tag pageload has pageload traceId', async ({ getL
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const [pageloadEvent, pageloadTraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    url,
-    eventAndTraceHeaderRequestParser,
-  );
+  const [pageloadSpan, pageloadTraceHeader] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
 
-  expect(pageloadEvent.contexts?.trace).toMatchObject({
-    op: 'pageload',
+  expect(pageloadSpan).toMatchObject({
+    is_segment: true,
+    attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'pageload' } }),
     trace_id: META_TAG_TRACE_ID,
     parent_span_id: META_TAG_PARENT_SPAN_ID,
     span_id: expect.stringMatching(/^[\da-f]{16}$/),
@@ -111,11 +104,7 @@ sentryTest('error after <meta> tag pageload has pageload traceId', async ({ getL
     sample_rand: '0.42',
   });
 
-  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
+  const errorEventPromise = waitForErrorRequest(page).then(eventAndTraceHeaderRequestParser);
   await page.locator('#errorBtn').click();
   const [errorEvent, errorTraceHeader] = await errorEventPromise;
 
@@ -145,24 +134,22 @@ sentryTest('error during <meta> tag pageload has pageload traceId', async ({ get
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const envelopeRequestsPromise = getMultipleSentryEnvelopeRequests<EventAndTraceHeader>(
+  const pageloadPromise = waitForStreamedSpanAndTraceHeader(
     page,
-    2,
-    undefined,
-    eventAndTraceHeaderRequestParser,
+    span => span.is_segment && getSpanOp(span) === 'pageload',
   );
+  const errorPromise = waitForErrorRequest(page).then(eventAndTraceHeaderRequestParser);
   await page.goto(url);
   await page.locator('#errorBtn').click();
-  const envelopes = await envelopeRequestsPromise;
-
-  const [pageloadEvent, pageloadTraceHeader] = envelopes.find(
-    eventAndHeader => eventAndHeader[0].type === 'transaction',
-  )!;
-  const [errorEvent, errorTraceHeader] = envelopes.find(eventAndHeader => !eventAndHeader[0].type)!;
-
-  expect(pageloadEvent.type).toEqual('transaction');
-  expect(pageloadEvent?.contexts?.trace).toMatchObject({
-    op: 'pageload',
+  const [[pageloadSpan, pageloadTraceHeader], [errorEvent, errorTraceHeader]] = await Promise.all([
+    pageloadPromise,
+    errorPromise,
+  ]);
+
+  expect(pageloadSpan.is_segment).toBe(true);
+  expect(pageloadSpan).toMatchObject({
+    is_segment: true,
+    attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'pageload' } }),
     trace_id: META_TAG_TRACE_ID,
     parent_span_id: META_TAG_PARENT_SPAN_ID,
     span_id: expect.stringMatching(/^[\da-f]{16}$/),
@@ -215,19 +202,19 @@ sentryTest(
       });
     });
 
-    const pageloadEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    const pageloadSpanPromise = waitForStreamedSpanAndTraceHeader(
       page,
-      undefined,
-      eventAndTraceHeaderRequestParser,
+      span => span.is_segment && getSpanOp(span) === 'pageload',
     );
     const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
     await page.goto(url);
     await page.locator('#fetchBtn').click();
-    const [[pageloadEvent, pageloadTraceHeader], request] = await Promise.all([pageloadEventPromise, requestPromise]);
+    const [[pageloadSpan, pageloadTraceHeader], request] = await Promise.all([pageloadSpanPromise, requestPromise]);
 
-    expect(pageloadEvent.type).toEqual('transaction');
-    expect(pageloadEvent?.contexts?.trace).toMatchObject({
-      op: 'pageload',
+    expect(pageloadSpan.is_segment).toBe(true);
+    expect(pageloadSpan).toMatchObject({
+      is_segment: true,
+      attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'pageload' } }),
       trace_id: META_TAG_TRACE_ID,
       parent_span_id: META_TAG_PARENT_SPAN_ID,
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
@@ -270,19 +257,19 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    const pageloadSpanPromise = waitForStreamedSpanAndTraceHeader(
       page,
-      undefined,
-      eventAndTraceHeaderRequestParser,
+      span => span.is_segment && getSpanOp(span) === 'pageload',
     );
     const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
     await page.goto(url);
     await page.locator('#xhrBtn').click();
-    const [[pageloadEvent, pageloadTraceHeader], request] = await Promise.all([pageloadEventPromise, requestPromise]);
+    const [[pageloadSpan, pageloadTraceHeader], request] = await Promise.all([pageloadSpanPromise, requestPromise]);
 
-    expect(pageloadEvent.type).toEqual('transaction');
-    expect(pageloadEvent?.contexts?.trace).toMatchObject({
-      op: 'pageload',
+    expect(pageloadSpan.is_segment).toBe(true);
+    expect(pageloadSpan).toMatchObject({
+      is_segment: true,
+      attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'pageload' } }),
       trace_id: META_TAG_TRACE_ID,
       parent_span_id: META_TAG_PARENT_SPAN_ID,
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
@@ -315,17 +302,17 @@ sentryTest('user feedback event after pageload has pageload traceId in headers',
 
   const url = await getLocalTestUrl({ testDir: __dirname, handleLazyLoadedFeedback: true });
 
-  const pageloadEvent = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const pageloadTraceContext = pageloadEvent.contexts?.trace;
+  const [pageloadSpan] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
 
-  expect(pageloadTraceContext).toMatchObject({
-    op: 'pageload',
+  expect(pageloadSpan).toMatchObject({
+    is_segment: true,
+    attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'pageload' } }),
     trace_id: META_TAG_TRACE_ID,
     parent_span_id: META_TAG_PARENT_SPAN_ID,
     span_id: expect.stringMatching(/^[\da-f]{16}$/),
   });
 
-  const feedbackEventPromise = getFirstSentryEnvelopeRequest<Event>(page);
+  const feedbackEventsPromise = getMultipleSentryEnvelopeRequests<Event>(page, 1, { envelopeType: 'feedback' });
 
   await page.getByText('Report a Bug').click();
   expect(await page.locator(':visible:text-is("Report a Bug")').count()).toEqual(1);
@@ -334,7 +321,7 @@ sentryTest('user feedback event after pageload has pageload traceId in headers',
   await page.locator('[name="message"]').fill('my example feedback');
   await page.locator('[data-sentry-feedback] .btn--primary').click();
 
-  const feedbackEvent = await feedbackEventPromise;
+  const [feedbackEvent] = await feedbackEventsPromise;
   const feedbackTraceContext = feedbackEvent.contexts?.trace;
 
   expect(feedbackEvent.type).toEqual('feedback');
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/init.js
new file mode 100644
index 000000000000..8718d9d354eb
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/init.js
@@ -0,0 +1,13 @@
+import * as Sentry from '@sentry/browser';
+// Import this separately so that generatePlugin can handle it for CDN scenarios
+import { feedbackIntegration } from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration(), feedbackIntegration()],
+  tracePropagationTargets: ['http://sentry-test-site.example'],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/subject.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/subject.js
new file mode 100644
index 000000000000..eead800a75a5
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/subject.js
@@ -0,0 +1,23 @@
+const errorBtn = document.getElementById('errorBtn');
+errorBtn.addEventListener('click', () => {
+  throw new Error(`Sentry Test Error ${Math.random()}`);
+});
+
+const fetchBtn = document.getElementById('fetchBtn');
+fetchBtn.addEventListener('click', async () => {
+  await fetch('http://sentry-test-site.example');
+});
+
+const xhrBtn = document.getElementById('xhrBtn');
+xhrBtn.addEventListener('click', () => {
+  const xhr = new XMLHttpRequest();
+  xhr.open('GET', 'http://sentry-test-site.example');
+  xhr.send();
+});
+
+const spanAndFetchBtn = document.getElementById('spanAndFetchBtn');
+spanAndFetchBtn.addEventListener('click', () => {
+  Sentry.startSpan({ name: 'custom-root-span' }, async () => {
+    await fetch('http://sentry-test-site.example');
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/template.html b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/template.html
new file mode 100644
index 000000000000..87e7bf5efbea
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/template.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <button id="errorBtn">Throw Error</button>
+    <button id="fetchBtn">Fetch Request</button>
+    <button id="xhrBtn">XHR Request</button>
+    <button id="spanAndFetchBtn">Start Span and Fetch Request</button>
+  </body>
+</html>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/test.ts
new file mode 100644
index 000000000000..f65ed9c13e3a
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-static/test.ts
@@ -0,0 +1,484 @@
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import type { EventAndTraceHeader } from '../../../../utils/helpers';
+import {
+  eventAndTraceHeaderRequestParser,
+  getFirstSentryEnvelopeRequest,
+  getMultipleSentryEnvelopeRequests,
+  shouldSkipFeedbackTest,
+  shouldSkipTracingTest,
+} from '../../../../utils/helpers';
+
+sentryTest(
+  'should create a new trace for a navigation after the initial pageload',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const [pageloadEvent, pageloadTraceHeaders] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+      page,
+      url,
+      eventAndTraceHeaderRequestParser,
+    );
+    const [navigationEvent, navigationTraceHeaders] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+      page,
+      `${url}#foo`,
+      eventAndTraceHeaderRequestParser,
+    );
+
+    const pageloadTraceContext = pageloadEvent.contexts?.trace;
+    const navigationTraceContext = navigationEvent.contexts?.trace;
+
+    expect(pageloadEvent.type).toEqual('transaction');
+    expect(navigationEvent.type).toEqual('transaction');
+
+    expect(pageloadTraceContext).toMatchObject({
+      op: 'pageload',
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    });
+    expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+
+    expect(pageloadTraceHeaders).toEqual({
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: pageloadTraceContext?.trace_id,
+      sample_rand: expect.any(String),
+    });
+
+    expect(navigationTraceContext).toMatchObject({
+      op: 'navigation',
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    });
+    expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
+
+    expect(navigationTraceHeaders).toEqual({
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: navigationTraceContext?.trace_id,
+      sample_rand: expect.any(String),
+    });
+
+    expect(pageloadTraceContext?.span_id).not.toEqual(navigationTraceContext?.span_id);
+  },
+);
+
+sentryTest('error after pageload has pageload traceId', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const [pageloadEvent, pageloadTraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    page,
+    url,
+    eventAndTraceHeaderRequestParser,
+  );
+  const pageloadTraceContext = pageloadEvent.contexts?.trace;
+
+  expect(pageloadEvent.type).toEqual('transaction');
+  expect(pageloadTraceContext).toMatchObject({
+    op: 'pageload',
+    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+  expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+
+  expect(pageloadTraceHeader).toEqual({
+    environment: 'production',
+    public_key: 'public',
+    sample_rate: '1',
+    sampled: 'true',
+    trace_id: pageloadTraceContext?.trace_id,
+    sample_rand: expect.any(String),
+  });
+
+  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    page,
+    undefined,
+    eventAndTraceHeaderRequestParser,
+  );
+  await page.locator('#errorBtn').click();
+  const [errorEvent, errorTraceHeader] = await errorEventPromise;
+
+  const errorTraceContext = errorEvent.contexts?.trace;
+  expect(errorEvent.type).toEqual(undefined);
+
+  expect(errorTraceContext).toEqual({
+    trace_id: pageloadTraceContext?.trace_id,
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+
+  expect(errorTraceHeader).toEqual({
+    environment: 'production',
+    public_key: 'public',
+    sample_rate: '1',
+    sampled: 'true',
+    trace_id: pageloadTraceContext?.trace_id,
+    sample_rand: expect.any(String),
+  });
+});
+
+sentryTest('error during pageload has pageload traceId', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const envelopeRequestsPromise = getMultipleSentryEnvelopeRequests<EventAndTraceHeader>(
+    page,
+    2,
+    undefined,
+    eventAndTraceHeaderRequestParser,
+  );
+  await page.goto(url);
+  await page.locator('#errorBtn').click();
+  const envelopes = await envelopeRequestsPromise;
+
+  const [pageloadEvent, pageloadTraceHeader] = envelopes.find(
+    eventAndHeader => eventAndHeader[0].type === 'transaction',
+  )!;
+  const [errorEvent, errorTraceHeader] = envelopes.find(eventAndHeader => !eventAndHeader[0].type)!;
+
+  const pageloadTraceContext = pageloadEvent?.contexts?.trace;
+
+  expect(pageloadEvent.type).toEqual('transaction');
+  expect(pageloadTraceContext).toMatchObject({
+    op: 'pageload',
+    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+  expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+
+  expect(pageloadTraceHeader).toEqual({
+    environment: 'production',
+    public_key: 'public',
+    sample_rate: '1',
+    sampled: 'true',
+    trace_id: pageloadTraceContext?.trace_id,
+    sample_rand: expect.any(String),
+  });
+
+  const errorTraceContext = errorEvent?.contexts?.trace;
+
+  expect(errorEvent.type).toEqual(undefined);
+  expect(errorTraceContext).toEqual({
+    trace_id: pageloadTraceContext?.trace_id,
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+
+  expect(errorTraceHeader).toEqual({
+    environment: 'production',
+    public_key: 'public',
+    sample_rate: '1',
+    sampled: 'true',
+    trace_id: pageloadTraceContext?.trace_id,
+    sample_rand: expect.any(String),
+  });
+});
+
+sentryTest(
+  'outgoing fetch request during pageload has pageload traceId in headers',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await page.route('http://sentry-test-site.example/**', route => {
+      return route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({}),
+      });
+    });
+
+    const pageloadEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+      page,
+      undefined,
+      eventAndTraceHeaderRequestParser,
+    );
+    const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
+    await page.goto(url);
+    await page.locator('#fetchBtn').click();
+    const [[pageloadEvent, pageloadTraceHeader], request] = await Promise.all([pageloadEventPromise, requestPromise]);
+
+    const pageloadTraceContext = pageloadEvent.contexts?.trace;
+    const pageloadTraceId = pageloadTraceContext?.trace_id;
+
+    expect(pageloadEvent.type).toEqual('transaction');
+    expect(pageloadTraceContext).toMatchObject({
+      op: 'pageload',
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    });
+    expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+
+    expect(pageloadTraceHeader).toEqual({
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: pageloadTraceId,
+      sample_rand: expect.any(String),
+    });
+
+    const headers = request.headers();
+
+    // sampling decision is propagated from active span sampling decision
+    expect(headers['sentry-trace']).toMatch(new RegExp(`^${pageloadTraceId}-[0-9a-f]{16}-1$`));
+    expect(headers['baggage']).toBe(
+      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sampled=true,sentry-sample_rand=${pageloadTraceHeader?.sample_rand},sentry-sample_rate=1`,
+    );
+  },
+);
+
+sentryTest(
+  'outgoing XHR request during pageload has pageload traceId in headers',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await page.route('http://sentry-test-site.example/**', route => {
+      return route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({}),
+      });
+    });
+
+    const pageloadEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+      page,
+      undefined,
+      eventAndTraceHeaderRequestParser,
+    );
+    const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
+    await page.goto(url);
+    await page.locator('#xhrBtn').click();
+    const [[pageloadEvent, pageloadTraceHeader], request] = await Promise.all([pageloadEventPromise, requestPromise]);
+
+    const pageloadTraceContext = pageloadEvent.contexts?.trace;
+    const pageloadTraceId = pageloadTraceContext?.trace_id;
+
+    expect(pageloadEvent.type).toEqual('transaction');
+    expect(pageloadTraceContext).toMatchObject({
+      op: 'pageload',
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    });
+    expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+
+    expect(pageloadTraceHeader).toEqual({
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: pageloadTraceId,
+      sample_rand: expect.any(String),
+    });
+
+    const headers = request.headers();
+
+    // sampling decision is propagated from active span sampling decision
+    expect(headers['sentry-trace']).toMatch(new RegExp(`^${pageloadTraceId}-[0-9a-f]{16}-1$`));
+    expect(headers['baggage']).toBe(
+      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sampled=true,sentry-sample_rand=${pageloadTraceHeader?.sample_rand},sentry-sample_rate=1`,
+    );
+  },
+);
+
+// sentryTest(
+//   'outgoing fetch request after pageload has pageload traceId in headers',
+//   async ({ getLocalTestUrl, page }) => {
+//     if (shouldSkipTracingTest()) {
+//       sentryTest.skip();
+//     }
+
+//     const url = await getLocalTestUrl({ testDir: __dirname });
+
+//     await page.route('http://sentry-test-site.example/**', route => {
+//       return route.fulfill({
+//         status: 200,
+//         contentType: 'application/json',
+//         body: JSON.stringify({}),
+//       });
+//     });
+
+//     const pageloadEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+//       page,
+//       undefined,
+//       eventAndTraceHeaderRequestParser,
+//     );
+//     await page.goto(url);
+//     const [pageloadEvent, pageloadTraceHeader] = await pageloadEventPromise;
+
+//     const pageloadTraceContext = pageloadEvent.contexts?.trace;
+//     const pageloadTraceId = pageloadTraceContext?.trace_id;
+
+//     expect(pageloadEvent.type).toEqual('transaction');
+//     expect(pageloadTraceContext).toMatchObject({
+//       op: 'pageload',
+//       trace_id: expect.stringMatching(/^[0-9a-f]{32}$/),
+//       span_id: expect.stringMatching(/^[0-9a-f]{16}$/),
+//     });
+//     expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+
+//     expect(pageloadTraceHeader).toEqual({
+//       environment: 'production',
+//       public_key: 'public',
+//       sample_rate: '1',
+//       sampled: 'true',
+//       trace_id: pageloadTraceId,
+//     });
+
+//     const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
+//     await page.locator('#xhrBtn').click();
+//     const request = await requestPromise;
+
+//     const headers = request.headers();
+
+//     // sampling decision is propagated from active span sampling decision
+//     expect(headers['sentry-trace']).toMatch(new RegExp(`^${pageloadTraceId}-[0-9a-f]{16}-1$`));
+//     expect(headers['baggage']).toEqual(
+//       `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sample_rate=1,sentry-sampled=true`,
+//     );
+//   },
+// )
+
+// sentryTest(
+//   'custom span and request headers after pageload have pageload traceId ',
+//   async ({ getLocalTestUrl, page }) => {
+//     if (shouldSkipTracingTest()) {
+//       sentryTest.skip();
+//     }
+
+//     const url = await getLocalTestUrl({ testDir: __dirname });
+
+//     await page.route('http://sentry-test-site.example/**', route => {
+//       return route.fulfill({
+//         status: 200,
+//         contentType: 'application/json',
+//         body: JSON.stringify({}),
+//       });
+//     });
+
+//     const pageloadEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+//       page,
+//       undefined,
+//       eventAndTraceHeaderRequestParser,
+//     );
+
+//     await page.goto(url);
+
+//     const [pageloadEvent, pageloadTraceHeader] = await pageloadEventPromise;
+
+//     const pageloadTraceContext = pageloadEvent.contexts?.trace;
+//     const pageloadTraceId = pageloadTraceContext?.trace_id;
+
+//     expect(pageloadEvent.type).toEqual('transaction');
+//     expect(pageloadTraceContext).toMatchObject({
+//       op: 'pageload',
+//       trace_id: expect.stringMatching(/^[0-9a-f]{32}$/),
+//       span_id: expect.stringMatching(/^[0-9a-f]{16}$/),
+//     });
+//     expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+
+//     expect(pageloadTraceHeader).toEqual({
+//       environment: 'production',
+//       public_key: 'public',
+//       sample_rate: '1',
+//       sampled: 'true',
+//       trace_id: pageloadTraceId,
+//     });
+
+//     const requestPromise = page.waitForRequest('http://sentry-test-site.example/**');
+//     const customTransactionEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+//       page,
+//       undefined,
+//       eventAndTraceHeaderRequestParser,
+//     );
+
+//     await page.locator('#spanAndFetchBtn').click();
+
+//     const [[customTransactionEvent, customTransactionTraceHeader], request] = await Promise.all([
+//       customTransactionEventPromise,
+//       requestPromise,
+//     ]);
+
+//     const customTransactionTraceContext = customTransactionEvent.contexts?.trace;
+
+//     expect(customTransactionEvent.type).toEqual('transaction');
+//     expect(customTransactionTraceContext).toMatchObject({
+//       trace_id: pageloadTraceId,
+//     });
+
+//     expect(customTransactionTraceHeader).toEqual({
+//       environment: 'production',
+//       public_key: 'public',
+//       sample_rate: '1',
+//       sampled: 'true',
+//       trace_id: pageloadTraceId,
+//     });
+
+//     const headers = request.headers();
+
+//     // sampling decision is propagated from active span sampling decision
+//     expect(headers['sentry-trace']).toMatch(new RegExp(`^${pageloadTraceId}-[0-9a-f]{16}-1$`));
+//     expect(headers['baggage']).toEqual(
+//       `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sample_rate=1,sentry-sampled=true`,
+//     );
+//   },
+// );
+
+sentryTest('user feedback event after pageload has pageload traceId in headers', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest() || shouldSkipFeedbackTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname, handleLazyLoadedFeedback: true });
+
+  const pageloadEvent = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  const pageloadTraceContext = pageloadEvent.contexts?.trace;
+
+  expect(pageloadTraceContext).toMatchObject({
+    op: 'pageload',
+    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+  expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+
+  const feedbackEventsPromise = getMultipleSentryEnvelopeRequests<Event>(page, 1, { envelopeType: 'feedback' });
+
+  await page.getByText('Report a Bug').click();
+  expect(await page.locator(':visible:text-is("Report a Bug")').count()).toEqual(1);
+  await page.locator('[name="name"]').fill('Jane Doe');
+  await page.locator('[name="email"]').fill('janedoe@example.org');
+  await page.locator('[name="message"]').fill('my example feedback');
+  await page.locator('[data-sentry-feedback] .btn--primary').click();
+
+  const [feedbackEvent] = await feedbackEventsPromise;
+
+  expect(feedbackEvent.type).toEqual('feedback');
+
+  const feedbackTraceContext = feedbackEvent.contexts?.trace;
+
+  expect(feedbackTraceContext).toMatchObject({
+    trace_id: pageloadTraceContext?.trace_id,
+    span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-streamed/test.ts
deleted file mode 100644
index 646d4be6fa56..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload-streamed/test.ts
+++ /dev/null
@@ -1,237 +0,0 @@
-import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
-import { sentryTest } from '../../../../utils/fixtures';
-import type { EventAndTraceHeader } from '../../../../utils/helpers';
-import {
-  eventAndTraceHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
-  shouldSkipFeedbackTest,
-  shouldSkipTracingTest,
-} from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
-
-sentryTest('creates a new trace for a navigation after the initial pageload', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-  const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  await page.goto(url);
-
-  const pageloadSpan = await pageloadSpanPromise;
-
-  page.goto(`${url}#foo`);
-
-  const navigationSpan = await navigationSpanPromise;
-
-  expect(getSpanOp(pageloadSpan)).toEqual('pageload');
-  expect(pageloadSpan.trace_id).toMatch(/^[\da-f]{32}$/);
-  expect(pageloadSpan.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(pageloadSpan.parent_span_id).toBeUndefined();
-
-  expect(getSpanOp(navigationSpan)).toEqual('navigation');
-  expect(navigationSpan.trace_id).toMatch(/^[\da-f]{32}$/);
-  expect(navigationSpan.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(navigationSpan.parent_span_id).toBeUndefined();
-
-  expect(pageloadSpan.span_id).not.toEqual(navigationSpan.span_id);
-  expect(pageloadSpan.trace_id).not.toEqual(navigationSpan.trace_id);
-});
-
-sentryTest('error after pageload has pageload traceId', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  await page.goto(url);
-
-  const pageloadSpan = await pageloadSpanPromise;
-  const pageloadTraceId = pageloadSpan.trace_id;
-
-  expect(getSpanOp(pageloadSpan)).toEqual('pageload');
-  expect(pageloadTraceId).toMatch(/^[\da-f]{32}$/);
-  expect(pageloadSpan.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(pageloadSpan.parent_span_id).toBeUndefined();
-
-  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
-  await page.locator('#errorBtn').click();
-  const [errorEvent, errorTraceHeader] = await errorEventPromise;
-
-  const errorTraceContext = errorEvent.contexts?.trace;
-  expect(errorEvent.type).toEqual(undefined);
-
-  expect(errorTraceContext).toEqual({
-    trace_id: pageloadTraceId,
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-
-  expect(errorTraceHeader).toEqual({
-    environment: 'production',
-    public_key: 'public',
-    sample_rate: '1',
-    sampled: 'true',
-    trace_id: pageloadTraceId,
-    sample_rand: expect.any(String),
-  });
-});
-
-sentryTest('error during pageload has pageload traceId', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
-
-  await page.goto(url);
-  await page.locator('#errorBtn').click();
-  const [pageloadSpan, [errorEvent, errorTraceHeader]] = await Promise.all([pageloadSpanPromise, errorEventPromise]);
-
-  const pageloadTraceId = pageloadSpan.trace_id;
-
-  expect(getSpanOp(pageloadSpan)).toEqual('pageload');
-  expect(pageloadTraceId).toMatch(/^[\da-f]{32}$/);
-  expect(pageloadSpan.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(pageloadSpan.parent_span_id).toBeUndefined();
-
-  const errorTraceContext = errorEvent?.contexts?.trace;
-  expect(errorEvent.type).toEqual(undefined);
-
-  expect(errorTraceContext).toEqual({
-    trace_id: pageloadTraceId,
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-
-  expect(errorTraceHeader).toEqual({
-    environment: 'production',
-    public_key: 'public',
-    sample_rate: '1',
-    sampled: 'true',
-    trace_id: pageloadTraceId,
-    sample_rand: expect.any(String),
-  });
-});
-
-sentryTest(
-  'outgoing fetch request during pageload has pageload traceId in headers',
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    await page.route('http://sentry-test-site.example/**', route => {
-      return route.fulfill({
-        status: 200,
-        contentType: 'application/json',
-        body: JSON.stringify({}),
-      });
-    });
-
-    const pageloadSpanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
-    );
-    const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
-    await page.goto(url);
-    await page.locator('#fetchBtn').click();
-    const [pageloadSpanEnvelope, request] = await Promise.all([pageloadSpanEnvelopePromise, requestPromise]);
-
-    const pageloadTraceId = pageloadSpanEnvelope[0].trace?.trace_id;
-    const sampleRand = pageloadSpanEnvelope[0].trace?.sample_rand;
-
-    expect(pageloadTraceId).toMatch(/^[\da-f]{32}$/);
-
-    const headers = request.headers();
-
-    // sampling decision is propagated from active span sampling decision
-    expect(headers['sentry-trace']).toMatch(new RegExp(`^${pageloadTraceId}-[0-9a-f]{16}-1$`));
-    expect(headers['baggage']).toBe(
-      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sampled=true,sentry-sample_rand=${sampleRand},sentry-sample_rate=1`,
-    );
-  },
-);
-
-sentryTest(
-  'outgoing XHR request during pageload has pageload traceId in headers',
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    await page.route('http://sentry-test-site.example/**', route => {
-      return route.fulfill({
-        status: 200,
-        contentType: 'application/json',
-        body: JSON.stringify({}),
-      });
-    });
-
-    const pageloadSpanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
-    );
-    const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
-    await page.goto(url);
-    await page.locator('#xhrBtn').click();
-    const [pageloadSpanEnvelope, request] = await Promise.all([pageloadSpanEnvelopePromise, requestPromise]);
-
-    const pageloadTraceId = pageloadSpanEnvelope[0].trace?.trace_id;
-    const sampleRand = pageloadSpanEnvelope[0].trace?.sample_rand;
-
-    expect(pageloadTraceId).toMatch(/^[\da-f]{32}$/);
-
-    const headers = request.headers();
-
-    // sampling decision is propagated from active span sampling decision
-    expect(headers['sentry-trace']).toMatch(new RegExp(`^${pageloadTraceId}-[0-9a-f]{16}-1$`));
-    expect(headers['baggage']).toBe(
-      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sampled=true,sentry-sample_rand=${sampleRand},sentry-sample_rate=1`,
-    );
-  },
-);
-
-sentryTest('user feedback event after pageload has pageload traceId in headers', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest() || shouldSkipFeedbackTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname, handleLazyLoadedFeedback: true });
-
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-  await page.goto(url);
-  const pageloadSpan = await pageloadSpanPromise;
-  const pageloadTraceId = pageloadSpan.trace_id;
-
-  expect(getSpanOp(pageloadSpan)).toEqual('pageload');
-  expect(pageloadTraceId).toMatch(/^[\da-f]{32}$/);
-  expect(pageloadSpan.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(pageloadSpan.parent_span_id).toBeUndefined();
-
-  const feedbackEventPromise = getFirstSentryEnvelopeRequest<Event>(page);
-
-  await page.getByText('Report a Bug').click();
-  expect(await page.locator(':visible:text-is("Report a Bug")').count()).toEqual(1);
-  await page.locator('[name="name"]').fill('Jane Doe');
-  await page.locator('[name="email"]').fill('janedoe@example.org');
-  await page.locator('[name="message"]').fill('my example feedback');
-  await page.locator('[data-sentry-feedback] .btn--primary').click();
-
-  const feedbackEvent = await feedbackEventPromise;
-
-  expect(feedbackEvent.type).toEqual('feedback');
-
-  const feedbackTraceContext = feedbackEvent.contexts?.trace;
-
-  expect(feedbackTraceContext).toMatchObject({
-    trace_id: pageloadTraceId,
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/init.js
new file mode 100644
index 000000000000..30317eda63ef
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/init.js
@@ -0,0 +1,12 @@
+import * as Sentry from '@sentry/browser';
+// Import this separately so that generatePlugin can handle it for CDN scenarios
+import { feedbackIntegration } from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration(), feedbackIntegration()],
+  tracePropagationTargets: ['http://sentry-test-site.example'],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/test.ts
index e6edd02cf360..c6038e48826b 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/pageload/test.ts
@@ -1,113 +1,61 @@
 import { expect } from '@playwright/test';
 import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import type { EventAndTraceHeader } from '../../../../utils/helpers';
 import {
   eventAndTraceHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
   getMultipleSentryEnvelopeRequests,
   shouldSkipFeedbackTest,
   shouldSkipTracingTest,
+  waitForErrorRequest,
 } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
 
-sentryTest(
-  'should create a new trace for a navigation after the initial pageload',
-  async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+sentryTest('creates a new trace for a navigation after the initial pageload', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
 
-    const url = await getLocalTestUrl({ testDir: __dirname });
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+  const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
 
-    const [pageloadEvent, pageloadTraceHeaders] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-      page,
-      url,
-      eventAndTraceHeaderRequestParser,
-    );
-    const [navigationEvent, navigationTraceHeaders] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-      page,
-      `${url}#foo`,
-      eventAndTraceHeaderRequestParser,
-    );
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
 
-    const pageloadTraceContext = pageloadEvent.contexts?.trace;
-    const navigationTraceContext = navigationEvent.contexts?.trace;
+  const pageloadSpan = await pageloadSpanPromise;
 
-    expect(pageloadEvent.type).toEqual('transaction');
-    expect(navigationEvent.type).toEqual('transaction');
+  await page.goto(`${url}#foo`);
 
-    expect(pageloadTraceContext).toMatchObject({
-      op: 'pageload',
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    });
-    expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
-
-    expect(pageloadTraceHeaders).toEqual({
-      environment: 'production',
-      public_key: 'public',
-      sample_rate: '1',
-      sampled: 'true',
-      trace_id: pageloadTraceContext?.trace_id,
-      sample_rand: expect.any(String),
-    });
+  const navigationSpan = await navigationSpanPromise;
 
-    expect(navigationTraceContext).toMatchObject({
-      op: 'navigation',
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    });
-    expect(navigationTraceContext).not.toHaveProperty('parent_span_id');
-
-    expect(navigationTraceHeaders).toEqual({
-      environment: 'production',
-      public_key: 'public',
-      sample_rate: '1',
-      sampled: 'true',
-      trace_id: navigationTraceContext?.trace_id,
-      sample_rand: expect.any(String),
-    });
+  expect(getSpanOp(pageloadSpan)).toEqual('pageload');
+  expect(pageloadSpan.trace_id).toMatch(/^[\da-f]{32}$/);
+  expect(pageloadSpan.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(pageloadSpan.parent_span_id).toBeUndefined();
 
-    expect(pageloadTraceContext?.span_id).not.toEqual(navigationTraceContext?.span_id);
-  },
-);
+  expect(getSpanOp(navigationSpan)).toEqual('navigation');
+  expect(navigationSpan.trace_id).toMatch(/^[\da-f]{32}$/);
+  expect(navigationSpan.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(navigationSpan.parent_span_id).toBeUndefined();
+
+  expect(pageloadSpan.span_id).not.toEqual(navigationSpan.span_id);
+  expect(pageloadSpan.trace_id).not.toEqual(navigationSpan.trace_id);
+});
 
 sentryTest('error after pageload has pageload traceId', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest());
+
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
 
   const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
 
-  const [pageloadEvent, pageloadTraceHeader] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    url,
-    eventAndTraceHeaderRequestParser,
-  );
-  const pageloadTraceContext = pageloadEvent.contexts?.trace;
-
-  expect(pageloadEvent.type).toEqual('transaction');
-  expect(pageloadTraceContext).toMatchObject({
-    op: 'pageload',
-    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-  expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+  const pageloadSpan = await pageloadSpanPromise;
+  const pageloadTraceId = pageloadSpan.trace_id;
 
-  expect(pageloadTraceHeader).toEqual({
-    environment: 'production',
-    public_key: 'public',
-    sample_rate: '1',
-    sampled: 'true',
-    trace_id: pageloadTraceContext?.trace_id,
-    sample_rand: expect.any(String),
-  });
+  expect(getSpanOp(pageloadSpan)).toEqual('pageload');
+  expect(pageloadTraceId).toMatch(/^[\da-f]{32}$/);
+  expect(pageloadSpan.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(pageloadSpan.parent_span_id).toBeUndefined();
 
-  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
+  const errorEventPromise = waitForErrorRequest(page).then(eventAndTraceHeaderRequestParser);
   await page.locator('#errorBtn').click();
   const [errorEvent, errorTraceHeader] = await errorEventPromise;
 
@@ -115,7 +63,7 @@ sentryTest('error after pageload has pageload traceId', async ({ getLocalTestUrl
   expect(errorEvent.type).toEqual(undefined);
 
   expect(errorTraceContext).toEqual({
-    trace_id: pageloadTraceContext?.trace_id,
+    trace_id: pageloadTraceId,
     span_id: expect.stringMatching(/^[\da-f]{16}$/),
   });
 
@@ -124,57 +72,35 @@ sentryTest('error after pageload has pageload traceId', async ({ getLocalTestUrl
     public_key: 'public',
     sample_rate: '1',
     sampled: 'true',
-    trace_id: pageloadTraceContext?.trace_id,
+    trace_id: pageloadTraceId,
     sample_rand: expect.any(String),
   });
 });
 
 sentryTest('error during pageload has pageload traceId', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const envelopeRequestsPromise = getMultipleSentryEnvelopeRequests<EventAndTraceHeader>(
-    page,
-    2,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+  const errorEventPromise = waitForErrorRequest(page).then(eventAndTraceHeaderRequestParser);
+
   await page.goto(url);
   await page.locator('#errorBtn').click();
-  const envelopes = await envelopeRequestsPromise;
-
-  const [pageloadEvent, pageloadTraceHeader] = envelopes.find(
-    eventAndHeader => eventAndHeader[0].type === 'transaction',
-  )!;
-  const [errorEvent, errorTraceHeader] = envelopes.find(eventAndHeader => !eventAndHeader[0].type)!;
-
-  const pageloadTraceContext = pageloadEvent?.contexts?.trace;
+  const [pageloadSpan, [errorEvent, errorTraceHeader]] = await Promise.all([pageloadSpanPromise, errorEventPromise]);
 
-  expect(pageloadEvent.type).toEqual('transaction');
-  expect(pageloadTraceContext).toMatchObject({
-    op: 'pageload',
-    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-  expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+  const pageloadTraceId = pageloadSpan.trace_id;
 
-  expect(pageloadTraceHeader).toEqual({
-    environment: 'production',
-    public_key: 'public',
-    sample_rate: '1',
-    sampled: 'true',
-    trace_id: pageloadTraceContext?.trace_id,
-    sample_rand: expect.any(String),
-  });
+  expect(getSpanOp(pageloadSpan)).toEqual('pageload');
+  expect(pageloadTraceId).toMatch(/^[\da-f]{32}$/);
+  expect(pageloadSpan.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(pageloadSpan.parent_span_id).toBeUndefined();
 
   const errorTraceContext = errorEvent?.contexts?.trace;
-
   expect(errorEvent.type).toEqual(undefined);
+
   expect(errorTraceContext).toEqual({
-    trace_id: pageloadTraceContext?.trace_id,
+    trace_id: pageloadTraceId,
     span_id: expect.stringMatching(/^[\da-f]{16}$/),
   });
 
@@ -183,7 +109,7 @@ sentryTest('error during pageload has pageload traceId', async ({ getLocalTestUr
     public_key: 'public',
     sample_rate: '1',
     sampled: 'true',
-    trace_id: pageloadTraceContext?.trace_id,
+    trace_id: pageloadTraceId,
     sample_rand: expect.any(String),
   });
 });
@@ -191,9 +117,7 @@ sentryTest('error during pageload has pageload traceId', async ({ getLocalTestUr
 sentryTest(
   'outgoing fetch request during pageload has pageload traceId in headers',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
@@ -205,42 +129,26 @@ sentryTest(
       });
     });
 
-    const pageloadEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    const pageloadSpanEnvelopePromise = waitForStreamedSpanEnvelope(
       page,
-      undefined,
-      eventAndTraceHeaderRequestParser,
+      env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
     );
     const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
     await page.goto(url);
     await page.locator('#fetchBtn').click();
-    const [[pageloadEvent, pageloadTraceHeader], request] = await Promise.all([pageloadEventPromise, requestPromise]);
+    const [pageloadSpanEnvelope, request] = await Promise.all([pageloadSpanEnvelopePromise, requestPromise]);
 
-    const pageloadTraceContext = pageloadEvent.contexts?.trace;
-    const pageloadTraceId = pageloadTraceContext?.trace_id;
+    const pageloadTraceId = pageloadSpanEnvelope[0].trace?.trace_id;
+    const sampleRand = pageloadSpanEnvelope[0].trace?.sample_rand;
 
-    expect(pageloadEvent.type).toEqual('transaction');
-    expect(pageloadTraceContext).toMatchObject({
-      op: 'pageload',
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    });
-    expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
-
-    expect(pageloadTraceHeader).toEqual({
-      environment: 'production',
-      public_key: 'public',
-      sample_rate: '1',
-      sampled: 'true',
-      trace_id: pageloadTraceId,
-      sample_rand: expect.any(String),
-    });
+    expect(pageloadTraceId).toMatch(/^[\da-f]{32}$/);
 
     const headers = request.headers();
 
     // sampling decision is propagated from active span sampling decision
     expect(headers['sentry-trace']).toMatch(new RegExp(`^${pageloadTraceId}-[0-9a-f]{16}-1$`));
     expect(headers['baggage']).toBe(
-      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sampled=true,sentry-sample_rand=${pageloadTraceHeader?.sample_rand},sentry-sample_rate=1`,
+      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sampled=true,sentry-sample_rand=${sampleRand},sentry-sample_rate=1`,
     );
   },
 );
@@ -248,9 +156,7 @@ sentryTest(
 sentryTest(
   'outgoing XHR request during pageload has pageload traceId in headers',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
@@ -262,207 +168,46 @@ sentryTest(
       });
     });
 
-    const pageloadEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+    const pageloadSpanEnvelopePromise = waitForStreamedSpanEnvelope(
       page,
-      undefined,
-      eventAndTraceHeaderRequestParser,
+      env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
     );
     const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
     await page.goto(url);
     await page.locator('#xhrBtn').click();
-    const [[pageloadEvent, pageloadTraceHeader], request] = await Promise.all([pageloadEventPromise, requestPromise]);
+    const [pageloadSpanEnvelope, request] = await Promise.all([pageloadSpanEnvelopePromise, requestPromise]);
 
-    const pageloadTraceContext = pageloadEvent.contexts?.trace;
-    const pageloadTraceId = pageloadTraceContext?.trace_id;
+    const pageloadTraceId = pageloadSpanEnvelope[0].trace?.trace_id;
+    const sampleRand = pageloadSpanEnvelope[0].trace?.sample_rand;
 
-    expect(pageloadEvent.type).toEqual('transaction');
-    expect(pageloadTraceContext).toMatchObject({
-      op: 'pageload',
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    });
-    expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
-
-    expect(pageloadTraceHeader).toEqual({
-      environment: 'production',
-      public_key: 'public',
-      sample_rate: '1',
-      sampled: 'true',
-      trace_id: pageloadTraceId,
-      sample_rand: expect.any(String),
-    });
+    expect(pageloadTraceId).toMatch(/^[\da-f]{32}$/);
 
     const headers = request.headers();
 
     // sampling decision is propagated from active span sampling decision
     expect(headers['sentry-trace']).toMatch(new RegExp(`^${pageloadTraceId}-[0-9a-f]{16}-1$`));
     expect(headers['baggage']).toBe(
-      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sampled=true,sentry-sample_rand=${pageloadTraceHeader?.sample_rand},sentry-sample_rate=1`,
+      `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sampled=true,sentry-sample_rand=${sampleRand},sentry-sample_rate=1`,
     );
   },
 );
 
-// sentryTest(
-//   'outgoing fetch request after pageload has pageload traceId in headers',
-//   async ({ getLocalTestUrl, page }) => {
-//     if (shouldSkipTracingTest()) {
-//       sentryTest.skip();
-//     }
-
-//     const url = await getLocalTestUrl({ testDir: __dirname });
-
-//     await page.route('http://sentry-test-site.example/**', route => {
-//       return route.fulfill({
-//         status: 200,
-//         contentType: 'application/json',
-//         body: JSON.stringify({}),
-//       });
-//     });
-
-//     const pageloadEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-//       page,
-//       undefined,
-//       eventAndTraceHeaderRequestParser,
-//     );
-//     await page.goto(url);
-//     const [pageloadEvent, pageloadTraceHeader] = await pageloadEventPromise;
-
-//     const pageloadTraceContext = pageloadEvent.contexts?.trace;
-//     const pageloadTraceId = pageloadTraceContext?.trace_id;
-
-//     expect(pageloadEvent.type).toEqual('transaction');
-//     expect(pageloadTraceContext).toMatchObject({
-//       op: 'pageload',
-//       trace_id: expect.stringMatching(/^[0-9a-f]{32}$/),
-//       span_id: expect.stringMatching(/^[0-9a-f]{16}$/),
-//     });
-//     expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
-
-//     expect(pageloadTraceHeader).toEqual({
-//       environment: 'production',
-//       public_key: 'public',
-//       sample_rate: '1',
-//       sampled: 'true',
-//       trace_id: pageloadTraceId,
-//     });
-
-//     const requestPromise = page.waitForRequest('http://sentry-test-site.example/*');
-//     await page.locator('#xhrBtn').click();
-//     const request = await requestPromise;
-
-//     const headers = request.headers();
-
-//     // sampling decision is propagated from active span sampling decision
-//     expect(headers['sentry-trace']).toMatch(new RegExp(`^${pageloadTraceId}-[0-9a-f]{16}-1$`));
-//     expect(headers['baggage']).toEqual(
-//       `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sample_rate=1,sentry-sampled=true`,
-//     );
-//   },
-// )
-
-// sentryTest(
-//   'custom span and request headers after pageload have pageload traceId ',
-//   async ({ getLocalTestUrl, page }) => {
-//     if (shouldSkipTracingTest()) {
-//       sentryTest.skip();
-//     }
-
-//     const url = await getLocalTestUrl({ testDir: __dirname });
-
-//     await page.route('http://sentry-test-site.example/**', route => {
-//       return route.fulfill({
-//         status: 200,
-//         contentType: 'application/json',
-//         body: JSON.stringify({}),
-//       });
-//     });
-
-//     const pageloadEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-//       page,
-//       undefined,
-//       eventAndTraceHeaderRequestParser,
-//     );
-
-//     await page.goto(url);
-
-//     const [pageloadEvent, pageloadTraceHeader] = await pageloadEventPromise;
-
-//     const pageloadTraceContext = pageloadEvent.contexts?.trace;
-//     const pageloadTraceId = pageloadTraceContext?.trace_id;
-
-//     expect(pageloadEvent.type).toEqual('transaction');
-//     expect(pageloadTraceContext).toMatchObject({
-//       op: 'pageload',
-//       trace_id: expect.stringMatching(/^[0-9a-f]{32}$/),
-//       span_id: expect.stringMatching(/^[0-9a-f]{16}$/),
-//     });
-//     expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
-
-//     expect(pageloadTraceHeader).toEqual({
-//       environment: 'production',
-//       public_key: 'public',
-//       sample_rate: '1',
-//       sampled: 'true',
-//       trace_id: pageloadTraceId,
-//     });
-
-//     const requestPromise = page.waitForRequest('http://sentry-test-site.example/**');
-//     const customTransactionEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-//       page,
-//       undefined,
-//       eventAndTraceHeaderRequestParser,
-//     );
-
-//     await page.locator('#spanAndFetchBtn').click();
-
-//     const [[customTransactionEvent, customTransactionTraceHeader], request] = await Promise.all([
-//       customTransactionEventPromise,
-//       requestPromise,
-//     ]);
-
-//     const customTransactionTraceContext = customTransactionEvent.contexts?.trace;
-
-//     expect(customTransactionEvent.type).toEqual('transaction');
-//     expect(customTransactionTraceContext).toMatchObject({
-//       trace_id: pageloadTraceId,
-//     });
-
-//     expect(customTransactionTraceHeader).toEqual({
-//       environment: 'production',
-//       public_key: 'public',
-//       sample_rate: '1',
-//       sampled: 'true',
-//       trace_id: pageloadTraceId,
-//     });
-
-//     const headers = request.headers();
-
-//     // sampling decision is propagated from active span sampling decision
-//     expect(headers['sentry-trace']).toMatch(new RegExp(`^${pageloadTraceId}-[0-9a-f]{16}-1$`));
-//     expect(headers['baggage']).toEqual(
-//       `sentry-environment=production,sentry-public_key=public,sentry-trace_id=${pageloadTraceId},sentry-sample_rate=1,sentry-sampled=true`,
-//     );
-//   },
-// );
-
 sentryTest('user feedback event after pageload has pageload traceId in headers', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest() || shouldSkipFeedbackTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest() || shouldSkipFeedbackTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname, handleLazyLoadedFeedback: true });
 
-  const pageloadEvent = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const pageloadTraceContext = pageloadEvent.contexts?.trace;
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+  await page.goto(url);
+  const pageloadSpan = await pageloadSpanPromise;
+  const pageloadTraceId = pageloadSpan.trace_id;
 
-  expect(pageloadTraceContext).toMatchObject({
-    op: 'pageload',
-    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-  });
-  expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+  expect(getSpanOp(pageloadSpan)).toEqual('pageload');
+  expect(pageloadTraceId).toMatch(/^[\da-f]{32}$/);
+  expect(pageloadSpan.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(pageloadSpan.parent_span_id).toBeUndefined();
 
-  const feedbackEventPromise = getFirstSentryEnvelopeRequest<Event>(page);
+  const feedbackEventsPromise = getMultipleSentryEnvelopeRequests<Event>(page, 1, { envelopeType: 'feedback' });
 
   await page.getByText('Report a Bug').click();
   expect(await page.locator(':visible:text-is("Report a Bug")').count()).toEqual(1);
@@ -471,14 +216,14 @@ sentryTest('user feedback event after pageload has pageload traceId in headers',
   await page.locator('[name="message"]').fill('my example feedback');
   await page.locator('[data-sentry-feedback] .btn--primary').click();
 
-  const feedbackEvent = await feedbackEventPromise;
+  const [feedbackEvent] = await feedbackEventsPromise;
 
   expect(feedbackEvent.type).toEqual('feedback');
 
   const feedbackTraceContext = feedbackEvent.contexts?.trace;
 
   expect(feedbackTraceContext).toMatchObject({
-    trace_id: pageloadTraceContext?.trace_id,
+    trace_id: pageloadTraceId,
     span_id: expect.stringMatching(/^[\da-f]{16}$/),
   });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-multiple-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-multiple-spans/test.ts
index cf17b26aee87..f9c3d5deca85 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-multiple-spans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-multiple-spans/test.ts
@@ -1,12 +1,11 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import type { EventAndTraceHeader } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
 import {
-  eventAndTraceHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
-  getMultipleSentryEnvelopeRequests,
-  shouldSkipTracingTest,
-} from '../../../../utils/helpers';
+  type StreamedSpanAndTraceHeader,
+  waitForStreamedSpanAndTraceHeader,
+  waitForStreamedSpanAndTraceHeaderOnUrl,
+} from '../../../../utils/spanUtils';
 
 sentryTest(
   'every root span created within a single `startNewTrace` callback shares the one new trace',
@@ -17,44 +16,37 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const [pageloadEvent] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-      page,
-      url,
-      eventAndTraceHeaderRequestParser,
-    );
-    const pageloadTraceId = pageloadEvent.contexts?.trace?.trace_id;
+    const [pageloadSpan] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
+    const pageloadTraceId = pageloadSpan?.trace_id;
     expect(pageloadTraceId).toMatch(/^[\da-f]{32}$/);
 
-    const transactionPromises = getMultipleSentryEnvelopeRequests<EventAndTraceHeader>(
-      page,
-      3,
-      { envelopeType: 'transaction' },
-      eventAndTraceHeaderRequestParser,
+    const spanPromises = Promise.all(
+      [1, 2, 3].map(index => waitForStreamedSpanAndTraceHeader(page, span => span.name === `new-trace-span-${index}`)),
     );
 
     await page.locator('#newTrace').click();
 
-    const transactions = await transactionPromises;
+    const spans = await spanPromises;
 
-    const byName = (name: string): EventAndTraceHeader => transactions.find(([event]) => event.transaction === name)!;
+    const byName = (name: string): StreamedSpanAndTraceHeader => spans.find(([span]) => span.name === name)!;
 
     const [span1] = byName('new-trace-span-1');
     const [span2] = byName('new-trace-span-2');
     const [span3] = byName('new-trace-span-3');
 
-    const newTraceId = span1.contexts?.trace?.trace_id;
+    const newTraceId = span1.trace_id;
     expect(newTraceId).toMatch(/^[\da-f]{32}$/);
 
     // All three root spans share the one new trace id ...
-    expect(span2.contexts?.trace?.trace_id).toBe(newTraceId);
-    expect(span3.contexts?.trace?.trace_id).toBe(newTraceId);
+    expect(span2.trace_id).toBe(newTraceId);
+    expect(span3.trace_id).toBe(newTraceId);
 
     // ... which is a fresh trace, not the pageload trace.
     expect(newTraceId).not.toBe(pageloadTraceId);
 
     // They are independent root spans, not parented to one another.
-    expect(span1.contexts?.trace).not.toHaveProperty('parent_span_id');
-    expect(span2.contexts?.trace).not.toHaveProperty('parent_span_id');
-    expect(span3.contexts?.trace).not.toHaveProperty('parent_span_id');
+    expect(span1).not.toHaveProperty('parent_span_id');
+    expect(span2).not.toHaveProperty('parent_span_id');
+    expect(span3).not.toHaveProperty('parent_span_id');
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/init.js
new file mode 100644
index 000000000000..8718d9d354eb
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/init.js
@@ -0,0 +1,13 @@
+import * as Sentry from '@sentry/browser';
+// Import this separately so that generatePlugin can handle it for CDN scenarios
+import { feedbackIntegration } from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration(), feedbackIntegration()],
+  tracePropagationTargets: ['http://sentry-test-site.example'],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-streamed/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-streamed/template.html b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-streamed/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/test.ts
new file mode 100644
index 000000000000..40cc8a64d75f
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-static/test.ts
@@ -0,0 +1,109 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import type { EventAndTraceHeader } from '../../../../utils/helpers';
+import {
+  eventAndTraceHeaderRequestParser,
+  getFirstSentryEnvelopeRequest,
+  getMultipleSentryEnvelopeRequests,
+  shouldSkipTracingTest,
+} from '../../../../utils/helpers';
+
+sentryTest(
+  'creates a new trace if `startNewTrace` is called and leaves old trace valid outside the callback',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await page.route('http://sentry-test-site.example/**', route => {
+      return route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({}),
+      });
+    });
+
+    const [pageloadEvent, pageloadTraceHeaders] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
+      page,
+      url,
+      eventAndTraceHeaderRequestParser,
+    );
+
+    const pageloadTraceContext = pageloadEvent.contexts?.trace;
+
+    expect(pageloadEvent.type).toEqual('transaction');
+
+    expect(pageloadTraceContext).toMatchObject({
+      op: 'pageload',
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    });
+    expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+
+    expect(pageloadTraceHeaders).toEqual({
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: pageloadTraceContext?.trace_id,
+      sample_rand: expect.any(String),
+    });
+
+    const transactionPromises = getMultipleSentryEnvelopeRequests<EventAndTraceHeader>(
+      page,
+      2,
+      { envelopeType: 'transaction' },
+      eventAndTraceHeaderRequestParser,
+    );
+
+    await page.locator('#newTrace').click();
+    await page.locator('#oldTrace').click();
+
+    const [txnEvent1, txnEvent2] = await transactionPromises;
+
+    const [newTraceTransactionEvent, newTraceTransactionTraceHeaders] =
+      txnEvent1[0].transaction === 'new-trace' ? txnEvent1 : txnEvent2;
+    const [oldTraceTransactionEvent, oldTraceTransactionTraceHeaders] =
+      txnEvent1[0].transaction === 'old-trace' ? txnEvent1 : txnEvent2;
+
+    const newTraceTransactionTraceContext = newTraceTransactionEvent.contexts?.trace;
+    expect(newTraceTransactionTraceContext).toMatchObject({
+      op: 'ui.interaction.click',
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    });
+
+    expect(newTraceTransactionTraceHeaders).toEqual({
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: newTraceTransactionTraceContext?.trace_id,
+      transaction: 'new-trace',
+      sample_rand: expect.any(String),
+    });
+
+    const oldTraceTransactionEventTraceContext = oldTraceTransactionEvent.contexts?.trace;
+    expect(oldTraceTransactionEventTraceContext).toMatchObject({
+      op: 'ui.interaction.click',
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+    });
+
+    expect(oldTraceTransactionTraceHeaders).toEqual({
+      environment: 'production',
+      public_key: 'public',
+      sample_rate: '1',
+      sampled: 'true',
+      trace_id: oldTraceTransactionTraceHeaders?.trace_id,
+      sample_rand: expect.any(String),
+      // transaction: 'old-trace', <-- this is not in the DSC because the DSC is continued from the pageload transaction
+      // which does not have a `transaction` field because its source is URL.
+    });
+
+    expect(oldTraceTransactionEventTraceContext?.trace_id).toEqual(pageloadTraceContext?.trace_id);
+    expect(newTraceTransactionTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-streamed/test.ts
deleted file mode 100644
index 07ac4b0c8cd3..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-streamed/test.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
-
-sentryTest(
-  'creates a new trace if `startNewTrace` is called and leaves old trace valid outside the callback',
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    await page.route('http://sentry-test-site.example/**', route => {
-      return route.fulfill({
-        status: 200,
-        contentType: 'application/json',
-        body: JSON.stringify({}),
-      });
-    });
-
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-    await page.goto(url);
-    const pageloadSpan = await pageloadSpanPromise;
-
-    const newTraceSpanPromise = waitForStreamedSpan(page, span => span.name === 'new-trace');
-    const oldTraceSpanPromise = waitForStreamedSpan(page, span => span.name === 'old-trace');
-
-    await page.locator('#newTrace').click();
-    await page.locator('#oldTrace').click();
-
-    const [newTraceSpan, oldTraceSpan] = await Promise.all([newTraceSpanPromise, oldTraceSpanPromise]);
-
-    expect(getSpanOp(newTraceSpan)).toEqual('ui.interaction.click');
-    expect(newTraceSpan.trace_id).toMatch(/^[\da-f]{32}$/);
-    expect(newTraceSpan.span_id).toMatch(/^[\da-f]{16}$/);
-
-    expect(getSpanOp(oldTraceSpan)).toEqual('ui.interaction.click');
-    expect(oldTraceSpan.trace_id).toMatch(/^[\da-f]{32}$/);
-    expect(oldTraceSpan.span_id).toMatch(/^[\da-f]{16}$/);
-
-    expect(oldTraceSpan.trace_id).toEqual(pageloadSpan.trace_id);
-    expect(newTraceSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace/init.js
similarity index 71%
rename from dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace/init.js
index 187e07624fdf..b2280b70e307 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace/init.js
@@ -4,7 +4,7 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace/test.ts
index 40cc8a64d75f..07ac4b0c8cd3 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTrace/test.ts
@@ -1,19 +1,12 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import type { EventAndTraceHeader } from '../../../../utils/helpers';
-import {
-  eventAndTraceHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
-  getMultipleSentryEnvelopeRequests,
-  shouldSkipTracingTest,
-} from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
   'creates a new trace if `startNewTrace` is called and leaves old trace valid outside the callback',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
@@ -25,85 +18,27 @@ sentryTest(
       });
     });
 
-    const [pageloadEvent, pageloadTraceHeaders] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-      page,
-      url,
-      eventAndTraceHeaderRequestParser,
-    );
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    await page.goto(url);
+    const pageloadSpan = await pageloadSpanPromise;
 
-    const pageloadTraceContext = pageloadEvent.contexts?.trace;
-
-    expect(pageloadEvent.type).toEqual('transaction');
-
-    expect(pageloadTraceContext).toMatchObject({
-      op: 'pageload',
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    });
-    expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
-
-    expect(pageloadTraceHeaders).toEqual({
-      environment: 'production',
-      public_key: 'public',
-      sample_rate: '1',
-      sampled: 'true',
-      trace_id: pageloadTraceContext?.trace_id,
-      sample_rand: expect.any(String),
-    });
-
-    const transactionPromises = getMultipleSentryEnvelopeRequests<EventAndTraceHeader>(
-      page,
-      2,
-      { envelopeType: 'transaction' },
-      eventAndTraceHeaderRequestParser,
-    );
+    const newTraceSpanPromise = waitForStreamedSpan(page, span => span.name === 'new-trace');
+    const oldTraceSpanPromise = waitForStreamedSpan(page, span => span.name === 'old-trace');
 
     await page.locator('#newTrace').click();
     await page.locator('#oldTrace').click();
 
-    const [txnEvent1, txnEvent2] = await transactionPromises;
+    const [newTraceSpan, oldTraceSpan] = await Promise.all([newTraceSpanPromise, oldTraceSpanPromise]);
 
-    const [newTraceTransactionEvent, newTraceTransactionTraceHeaders] =
-      txnEvent1[0].transaction === 'new-trace' ? txnEvent1 : txnEvent2;
-    const [oldTraceTransactionEvent, oldTraceTransactionTraceHeaders] =
-      txnEvent1[0].transaction === 'old-trace' ? txnEvent1 : txnEvent2;
+    expect(getSpanOp(newTraceSpan)).toEqual('ui.interaction.click');
+    expect(newTraceSpan.trace_id).toMatch(/^[\da-f]{32}$/);
+    expect(newTraceSpan.span_id).toMatch(/^[\da-f]{16}$/);
 
-    const newTraceTransactionTraceContext = newTraceTransactionEvent.contexts?.trace;
-    expect(newTraceTransactionTraceContext).toMatchObject({
-      op: 'ui.interaction.click',
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    });
-
-    expect(newTraceTransactionTraceHeaders).toEqual({
-      environment: 'production',
-      public_key: 'public',
-      sample_rate: '1',
-      sampled: 'true',
-      trace_id: newTraceTransactionTraceContext?.trace_id,
-      transaction: 'new-trace',
-      sample_rand: expect.any(String),
-    });
-
-    const oldTraceTransactionEventTraceContext = oldTraceTransactionEvent.contexts?.trace;
-    expect(oldTraceTransactionEventTraceContext).toMatchObject({
-      op: 'ui.interaction.click',
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    });
-
-    expect(oldTraceTransactionTraceHeaders).toEqual({
-      environment: 'production',
-      public_key: 'public',
-      sample_rate: '1',
-      sampled: 'true',
-      trace_id: oldTraceTransactionTraceHeaders?.trace_id,
-      sample_rand: expect.any(String),
-      // transaction: 'old-trace', <-- this is not in the DSC because the DSC is continued from the pageload transaction
-      // which does not have a `transaction` field because its source is URL.
-    });
+    expect(getSpanOp(oldTraceSpan)).toEqual('ui.interaction.click');
+    expect(oldTraceSpan.trace_id).toMatch(/^[\da-f]{32}$/);
+    expect(oldTraceSpan.span_id).toMatch(/^[\da-f]{16}$/);
 
-    expect(oldTraceTransactionEventTraceContext?.trace_id).toEqual(pageloadTraceContext?.trace_id);
-    expect(newTraceTransactionTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+    expect(oldTraceSpan.trace_id).toEqual(pageloadSpan.trace_id);
+    expect(newTraceSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTraceSampling/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTraceSampling/init.js
index 9e1a8762f0b1..d32f77f4cb6b 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTraceSampling/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTraceSampling/init.js
@@ -15,7 +15,6 @@ crypto.randomUUID = function randomUUID() {
 };
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTraceSampling/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTraceSampling/test.ts
index dc3d75f54799..17f822e26a2a 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTraceSampling/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/startNewTraceSampling/test.ts
@@ -1,12 +1,9 @@
+import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
+import { SENTRY_OP } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import type { EventAndTraceHeader } from '../../../../utils/helpers';
-import {
-  eventAndTraceHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
-  shouldSkipTracingTest,
-  waitForTransactionRequest,
-} from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpanAndTraceHeader, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
 sentryTest(
   'new trace started with `startNewTrace` is sampled according to the `tracesSampler`',
@@ -25,65 +22,56 @@ sentryTest(
       });
     });
 
-    const [pageloadEvent, pageloadTraceHeaders] = await getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-      page,
-      url,
-      eventAndTraceHeaderRequestParser,
-    );
+    const [pageloadSpan, pageloadTraceHeaders] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
 
-    const pageloadTraceContext = pageloadEvent.contexts?.trace;
+    expect(pageloadSpan.is_segment).toBe(true);
 
-    expect(pageloadEvent.type).toEqual('transaction');
-
-    expect(pageloadTraceContext).toMatchObject({
-      op: 'pageload',
+    expect(pageloadSpan).toMatchObject({
+      is_segment: true,
+      attributes: expect.objectContaining({
+        [SENTRY_OP]: { type: 'string', value: 'pageload' },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: { type: 'double', value: 0.5 },
+      }),
       trace_id: expect.stringMatching(/^[\da-f]{32}$/),
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
-      data: {
-        'sentry.sample_rate': 0.5,
-      },
     });
-    expect(pageloadTraceContext).not.toHaveProperty('parent_span_id');
+    expect(pageloadSpan).not.toHaveProperty('parent_span_id');
 
     expect(pageloadTraceHeaders).toEqual({
       environment: 'production',
       public_key: 'public',
       sample_rate: '0.5',
       sampled: 'true',
-      trace_id: pageloadTraceContext?.trace_id,
+      trace_id: pageloadSpan?.trace_id,
       sample_rand: '0.45',
     });
 
-    const transactionPromise = waitForTransactionRequest(page, event => {
-      return event.transaction === 'new-trace';
-    });
+    const spanPromise = waitForStreamedSpanAndTraceHeader(page, span => span.name === 'new-trace');
 
     await page.locator('#newTrace').click();
 
-    const [newTraceTransactionEvent, newTraceTransactionTraceHeaders] = eventAndTraceHeaderRequestParser(
-      await transactionPromise,
-    );
+    const [newTraceSpan, newTraceHeaders] = await spanPromise;
 
-    const newTraceTransactionTraceContext = newTraceTransactionEvent.contexts?.trace;
-    expect(newTraceTransactionTraceContext).toMatchObject({
-      op: 'ui.interaction.click',
+    expect(newTraceSpan).toMatchObject({
+      is_segment: true,
+      attributes: expect.objectContaining({
+        [SENTRY_OP]: { type: 'string', value: 'ui.interaction.click' },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: { type: 'double', value: 0.9 },
+      }),
       trace_id: expect.stringMatching(/^[\da-f]{32}$/),
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
-      data: {
-        'sentry.sample_rate': 0.9,
-      },
     });
 
-    expect(newTraceTransactionTraceHeaders).toEqual({
+    expect(newTraceHeaders).toEqual({
       environment: 'production',
       public_key: 'public',
       sample_rate: '0.9',
       sampled: 'true',
-      trace_id: newTraceTransactionTraceContext?.trace_id,
+      trace_id: newTraceSpan?.trace_id,
       transaction: 'new-trace',
       sample_rand: '0.85',
     });
 
-    expect(newTraceTransactionTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+    expect(newTraceSpan?.trace_id).not.toEqual(pageloadSpan?.trace_id);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-headers/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-headers/init.js
index f6aa87028094..94222159056c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-headers/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-headers/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   // in browser TwP means not setting tracesSampleRate but adding browserTracingIntegration,
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-headers/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-headers/test.ts
index 3d0262b717d9..b0737b5c9fe7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-headers/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-headers/test.ts
@@ -1,10 +1,9 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import type { EventAndTraceHeader } from '../../../../utils/helpers';
 import {
   eventAndTraceHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
   shouldSkipTracingTest,
+  waitForErrorRequest,
 } from '../../../../utils/helpers';
 
 const META_TAG_TRACE_ID = '12345678901234567890123456789012';
@@ -25,11 +24,7 @@ sentryTest('error on initial page has traceId from server timing headers', async
   });
   await page.goto(url);
 
-  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
+  const errorEventPromise = waitForErrorRequest(page).then(eventAndTraceHeaderRequestParser);
 
   await page.locator('#errorBtn').click();
   const [errorEvent, errorTraceHeader] = await errorEventPromise;
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-propagateTraceparent/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-propagateTraceparent/init.js
index 59e00870be1d..b5b7d0354f77 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-propagateTraceparent/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance-propagateTraceparent/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   // in browser TwP means not setting tracesSampleRate but adding browserTracingIntegration,
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance/init.js b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance/init.js
index f6aa87028094..94222159056c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   // in browser TwP means not setting tracesSampleRate but adding browserTracingIntegration,
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance/test.ts b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance/test.ts
index 51cc61e0de0c..126f1eb99bff 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/tracing-without-performance/test.ts
@@ -5,6 +5,7 @@ import {
   eventAndTraceHeaderRequestParser,
   getFirstSentryEnvelopeRequest,
   shouldSkipTracingTest,
+  waitForErrorRequest,
 } from '../../../../utils/helpers';
 
 const META_TAG_TRACE_ID = '12345678901234567890123456789012';
@@ -20,11 +21,7 @@ sentryTest('error on initial page has traceId from meta tag', async ({ getLocalT
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
 
-  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
+  const errorEventPromise = waitForErrorRequest(page).then(eventAndTraceHeaderRequestParser);
 
   await page.locator('#errorBtn').click();
   const [errorEvent, errorTraceHeader] = await errorEventPromise;
@@ -53,11 +50,7 @@ sentryTest('error has new traceId after navigation', async ({ getLocalTestUrl, p
   const url = await getLocalTestUrl({ testDir: __dirname });
   await page.goto(url);
 
-  const errorEventPromise = getFirstSentryEnvelopeRequest<EventAndTraceHeader>(
-    page,
-    undefined,
-    eventAndTraceHeaderRequestParser,
-  );
+  const errorEventPromise = waitForErrorRequest(page).then(eventAndTraceHeaderRequestParser);
   await page.locator('#errorBtn').click();
   const [errorEvent, errorTraceHeader] = await errorEventPromise;
 
diff --git a/dev-packages/browser-integration-tests/suites/tracing/tracesSampler/op-attribute/init.js b/dev-packages/browser-integration-tests/suites/tracing/tracesSampler/op-attribute/init.js
index 1c46615de295..9eeaf599e7c2 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/tracesSampler/op-attribute/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/tracesSampler/op-attribute/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampler: ({ attributes }) => {
     return attributes?.['sentry.op'] === 'custom.op' ? 1 : 0;
diff --git a/dev-packages/browser-integration-tests/suites/tracing/tracesSampler/op-attribute/test.ts b/dev-packages/browser-integration-tests/suites/tracing/tracesSampler/op-attribute/test.ts
index 9d5bc57bc5c2..4828dcd58af7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/tracesSampler/op-attribute/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/tracesSampler/op-attribute/test.ts
@@ -1,10 +1,7 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  shouldSkipTracingTest,
-  waitForTransactionRequestOnUrl,
-} from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
 sentryTest('tracesSampler can sample based on the `sentry.op` attribute', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
@@ -15,10 +12,9 @@ sentryTest('tracesSampler can sample based on the `sentry.op` attribute', async
 
   // The sampler drops `other.op` and keeps `custom.op`, so the only transaction
   // that arrives is the one whose op the sampler saw in the attributes.
-  const req = await waitForTransactionRequestOnUrl(page, url);
-  const transactionEvent = envelopeRequestParser(req);
+  const [span] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
 
-  expect(transactionEvent.type).toBe('transaction');
-  expect(transactionEvent.transaction).toBe('span-with-sampled-op');
-  expect(transactionEvent.contexts?.trace?.op).toBe('custom.op');
+  expect(span.is_segment).toBe(true);
+  expect(span.name).toBe('span-with-sampled-op');
+  expect(getSpanOp(span)).toBe('custom.op');
 });
diff --git a/dev-packages/browser-integration-tests/utils/helpers.ts b/dev-packages/browser-integration-tests/utils/helpers.ts
index 97c40002e305..05b5aebcf5f4 100644
--- a/dev-packages/browser-integration-tests/utils/helpers.ts
+++ b/dev-packages/browser-integration-tests/utils/helpers.ts
@@ -215,12 +215,12 @@ export function waitForErrorRequest(page: Page, callback?: (event: SentryEvent)
     }
 
     try {
-      const event = envelopeRequestParser(req);
-
-      if (event.type) {
+      if (getEnvelopeType(req) !== 'event') {
         return false;
       }
 
+      const event = envelopeRequestParser(req);
+
       if (callback) {
         return callback(event);
       }
diff --git a/dev-packages/browser-integration-tests/utils/spanUtils.ts b/dev-packages/browser-integration-tests/utils/spanUtils.ts
index 532f2ce5c526..4a10f9069e8c 100644
--- a/dev-packages/browser-integration-tests/utils/spanUtils.ts
+++ b/dev-packages/browser-integration-tests/utils/spanUtils.ts
@@ -1,5 +1,5 @@
 import type { Page } from '@playwright/test';
-import type { SerializedStreamedSpan, StreamedSpanEnvelope } from '@sentry/core';
+import type { DynamicSamplingContext, SerializedStreamedSpan, StreamedSpanEnvelope } from '@sentry/core';
 import { properFullEnvelopeParser } from './helpers';
 
 /**
@@ -131,3 +131,42 @@ export function getSpanOp(span: SerializedStreamedSpan): string | undefined {
 export function getSpansFromEnvelope(envelope: StreamedSpanEnvelope): SerializedStreamedSpan[] {
   return envelope[1][0][1].items;
 }
+
+export type StreamedSpanAndTraceHeader = [SerializedStreamedSpan, Partial<DynamicSamplingContext> | undefined];
+
+export async function waitForStreamedSpanAndTraceHeader(
+  page: Page,
+  callback: (span: SerializedStreamedSpan) => boolean = span => span.is_segment,
+): Promise<StreamedSpanAndTraceHeader> {
+  const envelope = await waitForStreamedSpanEnvelope(page, envelope => envelope[1][0][1].items.some(callback));
+  const span = envelope[1][0][1].items.find(callback)!;
+  return [span, envelope[0].trace];
+}
+
+export async function waitForStreamedSpanAndTraceHeaderOnUrl(
+  page: Page,
+  url: string,
+  callback?: (span: SerializedStreamedSpan) => boolean,
+): Promise<StreamedSpanAndTraceHeader> {
+  const [spanAndTraceHeader] = await Promise.all([waitForStreamedSpanAndTraceHeader(page, callback), page.goto(url)]);
+  return spanAndTraceHeader;
+}
+
+export function collectStreamedSpans(page: Page): SerializedStreamedSpan[] {
+  const spans: SerializedStreamedSpan[] = [];
+  page.on('request', request => {
+    if (!request.postData()) {
+      return;
+    }
+    try {
+      const envelope = properFullEnvelopeParser<StreamedSpanEnvelope>(request);
+      const header = envelope[1][0][0];
+      if (header.type === 'span' && header.content_type === 'application/vnd.sentry.items.span.v2+json') {
+        spans.push(...envelope[1][0][1].items);
+      }
+    } catch {
+      // Other requests may contain bodies which are not envelopes.
+    }
+  });
+  return spans;
+}

From 8a92d0d2d4d8ff72c31756d2bc77980fef4bf439 Mon Sep 17 00:00:00 2001
From: Martin Sonnberger <martin.sonnberger@sentry.io>
Date: Fri, 9 Oct 2026 13:02:34 +0200
Subject: [PATCH 27/84] test(browser): port browser tracing suites to span
 streaming (#24888)

Exercise browserTracingIntegration with default span streaming,
including low-cardinality names and children sent across envelopes.
Retain the existing transaction counterparts as explicitly pinned
`*-static` suites to preserve compatibility coverage for navigation,
pageloads, linked traces, timing, and sampling.

Stacked on #24881 for the shared span collector and dynamic sampling
context helpers.

Fixes #24142

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../async-spans/init.js                       |   1 -
 .../async-spans/test.ts                       |   6 +-
 .../backgroundtab-custom/init.js              |   1 -
 .../backgroundtab-custom/test.ts              |   7 +-
 .../init.js                                   |   3 +-
 .../subject.js                                |   0
 .../template.html                             |   0
 .../backgroundtab-pageload-static/test.ts     |  23 ++
 .../backgroundtab-pageload-streamed/test.ts   |  18 -
 .../init.js                                   |   5 +-
 .../backgroundtab-pageload/test.ts            |  22 +-
 .../browserTracingIntegration/error/test.ts   |  54 +--
 .../init.js                                   |   4 +-
 .../subject.js                                |   0
 .../http-timings-static/test.ts               |  75 ++++
 .../http-timings-streamed/test.ts             |  64 ---
 .../http-timings/init.js                      |   1 -
 .../http-timings/test.ts                      | 164 +++++---
 .../tracing/browserTracingIntegration/init.js |   1 -
 .../consistent-sampling/default/init.js       |   2 +-
 .../consistent-sampling/default/subject.js    |   0
 .../consistent-sampling/default/template.html |   0
 .../consistent-sampling/default/test.ts       | 149 +++++++
 .../consistent-sampling/meta-negative/init.js |   3 +-
 .../meta-negative/subject.js                  |   0
 .../meta-negative/template.html               |   0
 .../consistent-sampling/meta-negative/test.ts |  43 +-
 .../meta-precedence/init.js                   |   2 +-
 .../meta-precedence/page-1.html               |   0
 .../meta-precedence/page-2.html               |   0
 .../meta-precedence/subject.js                |   0
 .../meta-precedence/template.html             |   0
 .../meta-precedence/test.ts                   |  51 +--
 .../consistent-sampling/meta/init.js          |   2 +-
 .../consistent-sampling/meta/subject.js       |   0
 .../consistent-sampling/meta/template.html    |   0
 .../consistent-sampling/meta/test.ts          | 176 +++++++++
 .../tracesSampler-precedence/init.js          |   2 +-
 .../tracesSampler-precedence/subject.js       |   0
 .../tracesSampler-precedence/template.html    |   0
 .../tracesSampler-precedence/test.ts          |  93 ++---
 .../custom-trace}/init.js                     |   3 +-
 .../custom-trace/subject.js                   |   0
 .../custom-trace/template.html                |   0
 .../linked-traces-static/custom-trace/test.ts |  62 +++
 .../default}/init.js                          |   3 +-
 .../linked-traces-static/default/test.ts      |  99 +++++
 .../interaction-spans/init.js                 |   3 +-
 .../interaction-spans/template.html           |   0
 .../interaction-spans/test.ts                 |  89 +++++
 .../linked-traces-static/meta/init.js         |  11 +
 .../meta/template.html                        |   0
 .../linked-traces-static/meta/test.ts         |  54 +++
 .../negatively-sampled/init.js                |   3 +-
 .../negatively-sampled/test.ts                |  42 ++
 .../session-storage/init.js                   |  10 +
 .../session-storage/test.ts                   |  39 ++
 .../consistent-sampling/default/test.ts       | 154 --------
 .../consistent-sampling/meta/test.ts          | 171 --------
 .../custom-trace/test.ts                      |  63 ---
 .../linked-traces-streamed/default/test.ts    |  95 -----
 .../interaction-spans/test.ts                 |  79 ----
 .../linked-traces-streamed/meta/test.ts       |  50 ---
 .../negatively-sampled/test.ts                |  44 ---
 .../session-storage/test.ts                   |  42 --
 .../consistent-sampling/default/init.js       |   1 -
 .../consistent-sampling/default/test.ts       | 138 +++----
 .../consistent-sampling/meta-negative/init.js |   1 -
 .../consistent-sampling/meta-negative/test.ts |  38 +-
 .../meta-precedence/init.js                   |   1 -
 .../meta-precedence/test.ts                   |  51 ++-
 .../consistent-sampling/meta/init.js          |   1 -
 .../consistent-sampling/meta/test.ts          | 144 ++++---
 .../tracesSampler-precedence/init.js          |   1 -
 .../tracesSampler-precedence/test.ts          | 101 ++---
 .../linked-traces/custom-trace/test.ts        |  60 +--
 .../linked-traces/default/test.ts             |  93 +++--
 .../linked-traces/init.js                     |   1 -
 .../linked-traces/interaction-spans/init.js   |   1 -
 .../linked-traces/interaction-spans/test.ts   |  73 ++--
 .../linked-traces/meta/test.ts                |  45 +--
 .../linked-traces/negatively-sampled/init.js  |   1 -
 .../linked-traces/negatively-sampled/test.ts  |  33 +-
 .../linked-traces/session-storage/init.js     |   1 -
 .../linked-traces/session-storage/test.ts     |  44 ++-
 .../init.js                                   |   2 +-
 .../subject.js                                |   0
 .../template.html                             |   0
 .../test.ts                                   |  34 ++
 .../test.ts                                   |  25 --
 .../init.js                                   |   1 -
 .../test.ts                                   |  26 +-
 .../assets/script.js                          |   0
 .../init.js                                   |   2 +-
 .../template.html                             |   0
 .../test.ts                                   |  26 ++
 .../test.ts                                   |  28 --
 .../long-animation-frame-disabled/init.js     |   1 -
 .../long-animation-frame-disabled/test.ts     |  22 +-
 .../assets/script.js                          |   0
 .../init.js                                   |   2 +-
 .../template.html                             |   0
 .../test.ts                                   | 116 ++++++
 .../test.ts                                   | 108 -----
 .../long-animation-frame-enabled/init.js      |   1 -
 .../long-animation-frame-enabled/test.ts      | 141 +++----
 .../long-animation-frame-non-chromium/init.js |   1 -
 .../long-animation-frame-non-chromium/test.ts |  10 +-
 .../assets/script.js                          |   0
 .../init.js                                   |   2 +-
 .../template.html                             |   0
 .../test.ts                                   | 118 ++++++
 .../test.ts                                   | 110 ------
 .../init.js                                   |   1 -
 .../test.ts                                   | 141 +++----
 .../init.js                                   |   2 +-
 .../subject.js                                |   0
 .../template.html                             |   0
 .../test.ts                                   |  19 +-
 .../long-tasks-before-navigation/init.js      |   1 -
 .../long-tasks-before-navigation/test.ts      |  25 +-
 .../assets/script.js                          |   0
 .../init.js                                   |   2 +-
 .../template.html                             |   0
 .../long-tasks-disabled-static/test.ts        |  21 +
 .../long-tasks-disabled-streamed/test.ts      |  23 --
 .../long-tasks-disabled/init.js               |   1 -
 .../long-tasks-disabled/test.ts               |  22 +-
 .../assets/script.js                          |   0
 .../init.js                                   |   2 +-
 .../template.html                             |   0
 .../long-tasks-enabled-static/test.ts         |  36 ++
 .../long-tasks-enabled-streamed/test.ts       |  42 --
 .../long-tasks-enabled/init.js                |   1 -
 .../long-tasks-enabled/test.ts                |  36 +-
 .../long-tasks-no-animation-frame/init.js     |   1 -
 .../long-tasks-no-animation-frame/test.ts     |  27 +-
 .../browserTracingIntegration/meta/init.js    |   1 -
 .../browserTracingIntegration/meta/test.ts    | 116 +++---
 .../navigation-aborting-pageload/init.js      |   1 -
 .../navigation-aborting-pageload/test.ts      | 112 +++---
 .../multiple-redirects/init.js                |   1 -
 .../multiple-redirects/test.ts                |  81 ++--
 .../navigation-navigation-click/init.js       |   1 -
 .../navigation-navigation-click/test.ts       |  40 +-
 .../navigation-navigation-keypress/init.js    |   1 -
 .../navigation-navigation-keypress/test.ts    |  43 +-
 .../navigation-redirect/init.js               |   1 -
 .../navigation-redirect/test.ts               |  31 +-
 .../navigation-redirect/opt-out/init.js       |   1 -
 .../navigation-redirect/opt-out/test.ts       |  21 +-
 .../pageload-navigation-click/init.js         |   1 -
 .../pageload-navigation-click/test.ts         |  23 +-
 .../pageload-navigation-keypress/init.js      |   1 -
 .../pageload-navigation-keypress/test.ts      |  21 +-
 .../pageload-navigation-time/init.js          |   1 -
 .../pageload-navigation-time/test.ts          |  21 +-
 .../pageload-redirect/init.js                 |   1 -
 .../pageload-redirect/test.ts                 |  66 ++--
 .../navigation-static/init.js                 |  10 +
 .../navigation-static/test.ts                 | 156 ++++++++
 .../navigation-streamed/test.ts               | 274 -------------
 .../navigation/init.js                        |   9 +
 .../navigation/test.ts                        | 370 +++++++++++++-----
 .../on-request-span-end/init.js               |   1 -
 .../on-request-span-end/test.ts               |  31 +-
 .../on-request-span-start/init.js             |   1 -
 .../on-request-span-start/test.ts             |  27 +-
 .../init.js                                   |   4 +-
 .../pageload-static/test.ts                   |  43 ++
 .../pageload-streamed/test.ts                 | 192 ---------
 .../pageload-update-txn-name/init.js          |   1 -
 .../pageload-update-txn-name/test.ts          |  39 +-
 .../pageload-updateSpanName-static/init.js    |  11 +
 .../pageload-updateSpanName-static/subject.js |   4 +
 .../pageload-updateSpanName-static/test.ts    |  38 ++
 .../pageload-updateSpanName/init.js           |   1 -
 .../pageload-updateSpanName/test.ts           |  39 +-
 .../pageload/init.js                          |   1 -
 .../pageload/test.ts                          | 223 +++++++++--
 .../pageloadDelayed/init.js                   |   1 -
 .../pageloadDelayed/test.ts                   |  23 +-
 .../pageloadWithChildSpanTimeout/init.js      |   1 -
 .../pageloadWithChildSpanTimeout/test.ts      |  37 +-
 .../default/init.js                           |   3 +-
 .../default/test.ts                           |  28 +-
 .../finalTimeout/init.js                      |   6 +-
 .../finalTimeout/test.ts                      |  43 ++
 .../navigation/init.js                        |   6 +-
 .../navigation/test.ts                        |  41 ++
 .../finalTimeout/test.ts                      |  36 --
 .../navigation/test.ts                        |  34 --
 .../reportPageLoaded/default/init.js          |   1 -
 .../reportPageLoaded/default/test.ts          |  36 +-
 .../reportPageLoaded/finalTimeout/init.js     |   1 -
 .../reportPageLoaded/finalTimeout/test.ts     |  35 +-
 .../reportPageLoaded/navigation/init.js       |   1 -
 .../reportPageLoaded/navigation/test.ts       |  35 +-
 .../resource-spans-ignored/init.js            |   1 -
 .../resource-spans-ignored/test.ts            |  10 +-
 .../init.js                                   |   2 +-
 .../subject.js                                |   0
 .../template.html                             |   0
 .../test.ts                                   |  54 +++
 .../test.ts                                   |  65 ---
 .../spotlight-interaction-filter/init.js      |   1 -
 .../spotlight-interaction-filter/test.ts      | 103 +++--
 .../customTargets/init.js                     |   1 -
 .../defaultTargetsMatch/init.js               |   1 -
 .../defaultTargetsNoMatch/init.js             |   1 -
 .../twp-errors-meta/init.js                   |   1 -
 .../twp-errors/init.js                        |   1 -
 212 files changed, 3526 insertions(+), 3240 deletions(-)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{navigation-streamed => backgroundtab-pageload-static}/init.js (64%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{backgroundtab-pageload-streamed => backgroundtab-pageload-static}/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{backgroundtab-pageload-streamed => backgroundtab-pageload-static}/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed/session-storage => backgroundtab-pageload}/init.js (53%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{http-timings-streamed => http-timings-static}/init.js (78%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{http-timings-streamed => http-timings-static}/subject.js (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/default/init.js (93%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/default/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/default/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/default/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta-negative/init.js (85%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta-negative/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta-negative/template.html (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta-negative/test.ts (73%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta-precedence/init.js (92%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta-precedence/page-1.html (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta-precedence/page-2.html (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta-precedence/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta-precedence/template.html (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta-precedence/test.ts (63%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta/init.js (92%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/meta/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/tracesSampler-precedence/init.js (94%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/tracesSampler-precedence/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/tracesSampler-precedence/template.html (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/consistent-sampling/tracesSampler-precedence/test.ts (50%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{backgroundtab-pageload-streamed => linked-traces-static/custom-trace}/init.js (66%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/custom-trace/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/custom-trace/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/custom-trace/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static/default}/init.js (66%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/default/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/interaction-spans/init.js (84%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/interaction-spans/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/interaction-spans/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/meta/init.js
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/meta/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/meta/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{linked-traces-streamed => linked-traces-static}/negatively-sampled/init.js (88%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/negatively-sampled/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/session-storage/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/session-storage/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/default/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/custom-trace/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/default/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/interaction-spans/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/meta/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/negatively-sampled/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/session-storage/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-animation-frame-before-navigation-streamed => long-animation-frame-before-navigation-static}/init.js (90%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-animation-frame-before-navigation-streamed => long-animation-frame-before-navigation-static}/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-animation-frame-before-navigation-streamed => long-animation-frame-before-navigation-static}/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-animation-frame-disabled-streamed => long-animation-frame-disabled-static}/assets/script.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-disabled-streamed => long-animation-frame-disabled-static}/init.js (88%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-animation-frame-disabled-streamed => long-animation-frame-disabled-static}/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-animation-frame-enabled-streamed => long-animation-frame-enabled-static}/assets/script.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-animation-frame-enabled-streamed => long-animation-frame-enabled-static}/init.js (88%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-animation-frame-enabled-streamed => long-animation-frame-enabled-static}/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-and-animation-frame-enabled-streamed => long-tasks-and-animation-frame-enabled-static}/assets/script.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-and-animation-frame-enabled-streamed => long-tasks-and-animation-frame-enabled-static}/init.js (88%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-and-animation-frame-enabled-streamed => long-tasks-and-animation-frame-enabled-static}/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-before-navigation-streamed => long-tasks-before-navigation-static}/init.js (90%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-before-navigation-streamed => long-tasks-before-navigation-static}/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-before-navigation-streamed => long-tasks-before-navigation-static}/template.html (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-before-navigation-streamed => long-tasks-before-navigation-static}/test.ts (50%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-disabled-streamed => long-tasks-disabled-static}/assets/script.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-animation-frame-disabled-streamed => long-tasks-disabled-static}/init.js (88%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-disabled-streamed => long-tasks-disabled-static}/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-enabled-streamed => long-tasks-enabled-static}/assets/script.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-enabled-streamed => long-tasks-enabled-static}/init.js (87%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{long-tasks-enabled-streamed => long-tasks-enabled-static}/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-streamed/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-static/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-streamed/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/init.js
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{pageload-streamed => pageload-static}/init.js (65%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-streamed/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{reportPageLoaded-streamed => reportPageLoaded-static}/default/init.js (86%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{reportPageLoaded-streamed => reportPageLoaded-static}/default/test.ts (50%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{reportPageLoaded-streamed => reportPageLoaded-static}/finalTimeout/init.js (65%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/finalTimeout/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{reportPageLoaded-streamed => reportPageLoaded-static}/navigation/init.js (71%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/navigation/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/finalTimeout/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/navigation/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{spotlight-interaction-filter-streamed => spotlight-interaction-filter-static}/init.js (90%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{spotlight-interaction-filter-streamed => spotlight-interaction-filter-static}/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/{spotlight-interaction-filter-streamed => spotlight-interaction-filter-static}/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-streamed/test.ts

diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/async-spans/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/async-spans/init.js
index bb6d4918d1bf..83076460599f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/async-spans/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/async-spans/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/async-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/async-spans/test.ts
index 5a2f34abecba..24516c270dba 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/async-spans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/async-spans/test.ts
@@ -1,7 +1,6 @@
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
 
 type WindowWithSpan = Window & {
   firstWaitingSpan: any;
@@ -19,8 +18,7 @@ sentryTest(
     const url = await getLocalTestUrl({ testDir: __dirname });
     await page.goto(url);
 
-    const envelope = await getFirstSentryEnvelopeRequest<Event>(page);
-    expect(envelope).toBeDefined();
+    await page.waitForFunction(() => !!(window as unknown as WindowWithSpan).secondWaitingSpan);
 
     const firstWaitingSpanValue = await page.evaluate(
       () => (window as unknown as WindowWithSpan).firstWaitingSpan.name,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-custom/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-custom/init.js
index 1c1791241ab7..9a11fe3682bb 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-custom/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-custom/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-custom/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-custom/test.ts
index b6661c2638e2..944ed474f19e 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-custom/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-custom/test.ts
@@ -1,9 +1,10 @@
+import { SENTRY_STATUS_MESSAGE, SENTRY_CANCELLATION_REASON } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import type { StreamedSpanJSON } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
 import { shouldSkipTracingTest } from '../../../../utils/helpers';
 
-sentryTest('should finish a custom transaction when the page goes background', async ({ getLocalTestUrl, page }) => {
+sentryTest('should finish a custom span when the page goes background', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
     sentryTest.skip();
   }
@@ -32,6 +33,6 @@ sentryTest('should finish a custom transaction when the page goes background', a
   expect(name_after).toBe(name_before);
   // a cancelled span is reported as `ok`, with the raw status kept as an attribute
   expect(spanJsonAfter.status).toBe('ok');
-  expect(attributes_after['sentry.status.message']).toBeUndefined();
-  expect(attributes_after['sentry.cancellation_reason']).toBe('document.hidden');
+  expect(attributes_after[SENTRY_STATUS_MESSAGE]).toBeUndefined();
+  expect(attributes_after[SENTRY_CANCELLATION_REASON]).toBe('document.hidden');
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-static/init.js
similarity index 64%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-static/init.js
index a93fc742bafb..bb6d4918d1bf 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-static/init.js
@@ -3,7 +3,8 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-static/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-streamed/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-static/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-streamed/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-streamed/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-static/test.ts
new file mode 100644
index 000000000000..626c7cbdcdbf
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-static/test.ts
@@ -0,0 +1,23 @@
+import { PAGELOAD } from '@sentry/conventions/op';
+import { SENTRY_CANCELLATION_REASON } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest('should finish pageload transaction when the page goes background', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const pageloadPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+
+  await page.goto(url);
+  await page.locator('#go-background').click();
+
+  const pageloadTransaction = envelopeRequestParser(await pageloadPromise);
+
+  expect(pageloadTransaction.contexts?.trace?.op).toBe(PAGELOAD);
+  expect(pageloadTransaction.contexts?.trace?.status).toBe('cancelled');
+  expect(pageloadTransaction.contexts?.trace?.data?.[SENTRY_CANCELLATION_REASON]).toBe('document.hidden');
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-streamed/test.ts
deleted file mode 100644
index f33f988be946..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-streamed/test.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
-
-sentryTest('finishes streamed pageload span when the page goes background', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-
-  await page.goto(url);
-  await page.locator('#go-background').click();
-  const pageloadSpan = await pageloadSpanPromise;
-
-  // TODO: Is this what we want?
-  expect(pageloadSpan.status).toBe('ok');
-  expect(pageloadSpan.attributes['sentry.cancellation_reason']?.value).toBe('document.hidden');
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/session-storage/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload/init.js
similarity index 53%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/session-storage/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload/init.js
index e51af56c2a9d..83076460599f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/session-storage/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload/init.js
@@ -4,9 +4,6 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [
-    Sentry.browserTracingIntegration({ linkPreviousTrace: 'session-storage' }),
-    Sentry.spanStreamingIntegration(),
-  ],
+  integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload/test.ts
index 80ea1f5fa09c..10380d5b0e1b 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload/test.ts
@@ -1,20 +1,20 @@
+import { PAGELOAD } from '@sentry/conventions/op';
+import { SENTRY_CANCELLATION_REASON } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest('should finish pageload transaction when the page goes background', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+sentryTest('finishes streamed pageload span when the page goes background', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
   const url = await getLocalTestUrl({ testDir: __dirname });
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === PAGELOAD);
 
   await page.goto(url);
   await page.locator('#go-background').click();
+  const pageloadSpan = await pageloadSpanPromise;
 
-  const pageloadTransaction = await getFirstSentryEnvelopeRequest<Event>(page);
-
-  expect(pageloadTransaction.contexts?.trace?.op).toBe('pageload');
-  expect(pageloadTransaction.contexts?.trace?.status).toBe('cancelled');
-  expect(pageloadTransaction.contexts?.trace?.data?.['sentry.cancellation_reason']).toBe('document.hidden');
+  expect(getSpanOp(pageloadSpan)).toBe(PAGELOAD);
+  expect(pageloadSpan.status).toBe('ok');
+  expect(pageloadSpan.attributes[SENTRY_CANCELLATION_REASON]?.value).toBe('document.hidden');
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/error/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/error/test.ts
index bf54209f053a..07a56ecdc184 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/error/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/error/test.ts
@@ -1,47 +1,35 @@
+import { PAGELOAD } from '@sentry/conventions/op';
+import { URL_PATH } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
 import {
-  getMultipleSentryEnvelopeRequests,
+  envelopeRequestParser,
+  waitForErrorRequest,
   runScriptInSandbox,
   shouldSkipTracingTest,
 } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
-  'should put the pageload transaction name onto an error event caught during pageload',
+  'puts the page path onto an error caught during pageload',
   async ({ getLocalTestUrl, page, browserName }) => {
-    if (browserName === 'webkit') {
-      // This test fails on Webkit as errors thrown from `runScriptInSandbox` are Script Errors and skipped by Sentry
-      sentryTest.skip();
-    }
-
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
-
+    // WebKit treats errors from runScriptInSandbox as Script Errors, which Sentry skips.
+    sentryTest.skip(shouldSkipTracingTest() || browserName === 'webkit');
     const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const errorEventsPromise = getMultipleSentryEnvelopeRequests<Event>(page, 2);
-
+    const spans = collectStreamedSpans(page);
+    const pageloadPromise = waitForStreamedSpan(page, span => getSpanOp(span) === PAGELOAD);
+    const errorPromise = waitForErrorRequest(page);
     await page.goto(url);
-
-    await runScriptInSandbox(page, {
-      content: `
-          throw new Error('Error during pageload');
-        `,
-    });
-
-    const [e1, e2] = await errorEventsPromise;
-
-    const pageloadTxnEvent = e1.type === 'transaction' ? e1 : e2;
-    const errorEvent = e1.type === 'transaction' ? e2 : e1;
-
-    expect(pageloadTxnEvent.contexts?.trace?.op).toEqual('pageload');
-    expect(pageloadTxnEvent.spans?.length).toBeGreaterThan(0);
-    expect(errorEvent.exception?.values?.[0]).toBeDefined();
-
-    expect(pageloadTxnEvent.transaction?.endsWith('index.html')).toBe(true);
-
-    expect(errorEvent.transaction).toEqual(pageloadTxnEvent.transaction);
+    await runScriptInSandbox(page, { content: "throw new Error('Error during pageload');" });
+    const [pageload, errorRequest] = await Promise.all([pageloadPromise, errorPromise]);
+    await page.evaluate(() => (window as any).Sentry.flush());
+    expect(getSpanOp(pageload)).toBe(PAGELOAD);
+    expect(spans.filter(span => !span.is_segment)).not.toHaveLength(0);
+    const error = envelopeRequestParser<Event>(errorRequest);
+    expect(error.exception?.values?.[0]).toBeDefined();
+    expect(pageload.name).toBe('Pageload');
+    expect(error.transaction).toBe('/index.html');
+    expect(error.transaction).toBe(pageload.attributes[URL_PATH]?.value);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-static/init.js
similarity index 78%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-static/init.js
index 8ec045483e0c..5e521633ad12 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-static/init.js
@@ -3,6 +3,7 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
@@ -10,9 +11,6 @@ Sentry.init({
         enableHTTPTimings: true,
       },
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracesSampleRate: 1,
-  traceLifecycle: 'stream',
-  debug: true,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-static/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-static/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-static/test.ts
new file mode 100644
index 000000000000..bc64d2630c9b
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-static/test.ts
@@ -0,0 +1,75 @@
+import { PAGELOAD, HTTP_CLIENT } from '@sentry/conventions/op';
+import {
+  HTTP_REQUEST_REDIRECT_START,
+  HTTP_REQUEST_REDIRECT_END,
+  HTTP_REQUEST_WORKER_START,
+  HTTP_REQUEST_FETCH_START,
+  HTTP_REQUEST_DOMAIN_LOOKUP_START,
+  HTTP_REQUEST_DOMAIN_LOOKUP_END,
+  HTTP_REQUEST_CONNECT_START,
+  HTTP_REQUEST_SECURE_CONNECTION_START,
+  HTTP_REQUEST_CONNECTION_END,
+  HTTP_REQUEST_REQUEST_START,
+  HTTP_REQUEST_RESPONSE_START,
+  HTTP_REQUEST_RESPONSE_END,
+  HTTP_REQUEST_TIME_TO_FIRST_BYTE,
+  NETWORK_PROTOCOL_VERSION,
+} from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest('creates fetch spans with http timing', async ({ browserName, getLocalTestUrl, page }) => {
+  const supportedBrowsers = ['chromium', 'firefox'];
+
+  if (shouldSkipTracingTest() || !supportedBrowsers.includes(browserName)) {
+    sentryTest.skip();
+  }
+  await page.route('http://sentry-test-site.example/*', async route => {
+    const request = route.request();
+    const postData = await request.postDataJSON();
+
+    await route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify(Object.assign({ id: 1 }, postData)),
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const pageloadPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+  await page.goto(url);
+  const tracingEvent = envelopeRequestParser(await pageloadPromise);
+
+  const requestSpans = tracingEvent.spans?.filter(({ op }) => op === HTTP_CLIENT);
+
+  expect(requestSpans).toHaveLength(3);
+
+  requestSpans?.forEach((span, index) =>
+    expect(span).toMatchObject({
+      description: `GET http://sentry-test-site.example/${index}`,
+      parent_span_id: tracingEvent.contexts?.trace?.span_id,
+      span_id: expect.stringMatching(/[a-f\d]{16}/),
+      start_timestamp: expect.any(Number),
+      timestamp: expect.any(Number),
+      trace_id: tracingEvent.contexts?.trace?.trace_id,
+      data: expect.objectContaining({
+        [HTTP_REQUEST_REDIRECT_START]: expect.any(Number),
+        [HTTP_REQUEST_REDIRECT_END]: expect.any(Number),
+        [HTTP_REQUEST_WORKER_START]: expect.any(Number),
+        [HTTP_REQUEST_FETCH_START]: expect.any(Number),
+        [HTTP_REQUEST_DOMAIN_LOOKUP_START]: expect.any(Number),
+        [HTTP_REQUEST_DOMAIN_LOOKUP_END]: expect.any(Number),
+        [HTTP_REQUEST_CONNECT_START]: expect.any(Number),
+        [HTTP_REQUEST_SECURE_CONNECTION_START]: expect.any(Number),
+        [HTTP_REQUEST_CONNECTION_END]: expect.any(Number),
+        [HTTP_REQUEST_REQUEST_START]: expect.any(Number),
+        [HTTP_REQUEST_RESPONSE_START]: expect.any(Number),
+        [HTTP_REQUEST_RESPONSE_END]: expect.any(Number),
+        [HTTP_REQUEST_TIME_TO_FIRST_BYTE]: expect.any(Number),
+        [NETWORK_PROTOCOL_VERSION]: expect.any(String),
+      }),
+    }),
+  );
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/test.ts
deleted file mode 100644
index 7c02a63fc41c..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/test.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest(
-  'adds http timing to http.client spans in span streaming mode',
-  async ({ browserName, getLocalTestUrl, page }) => {
-    const supportedBrowsers = ['chromium', 'firefox'];
-
-    sentryTest.skip(shouldSkipTracingTest() || !supportedBrowsers.includes(browserName));
-
-    await page.route('http://sentry-test-site.example/*', async route => {
-      const request = route.request();
-      const postData = await request.postDataJSON();
-
-      await route.fulfill({
-        status: 200,
-        contentType: 'application/json',
-        body: JSON.stringify(Object.assign({ id: 1 }, postData)),
-      });
-    });
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const spansPromise = waitForStreamedSpans(page, spans => spans.some(s => getSpanOp(s) === 'http.client'));
-    await page.goto(url);
-
-    const requestSpans = (await spansPromise).filter(s => getSpanOp(s) === 'http.client');
-    const pageloadSpan = (await spansPromise).find(s => getSpanOp(s) === 'pageload');
-
-    expect(pageloadSpan).toBeDefined();
-    expect(requestSpans).toHaveLength(3);
-
-    requestSpans?.forEach(span =>
-      expect(span).toMatchObject({
-        // Streamed span names drop the high-cardinality URL path.
-        name: 'GET sentry-test-site.example',
-        parent_span_id: pageloadSpan?.span_id,
-        span_id: expect.stringMatching(/[a-f\d]{16}/),
-        start_timestamp: expect.any(Number),
-        end_timestamp: expect.any(Number),
-        trace_id: pageloadSpan?.trace_id,
-        status: 'ok',
-        attributes: expect.objectContaining({
-          'http.request.redirect_start': expect.any(Object),
-          'http.request.redirect_end': expect.any(Object),
-          'http.request.worker_start': expect.any(Object),
-          'http.request.fetch_start': expect.any(Object),
-          'http.request.domain_lookup_start': expect.any(Object),
-          'http.request.domain_lookup_end': expect.any(Object),
-          'http.request.connect_start': expect.any(Object),
-          'http.request.secure_connection_start': expect.any(Object),
-          'http.request.connection_end': expect.any(Object),
-          'http.request.request_start': expect.any(Object),
-          'http.request.response_start': expect.any(Object),
-          'http.request.response_end': expect.any(Object),
-          'http.request.time_to_first_byte': expect.any(Object),
-          'network.protocol.version': expect.any(Object),
-        }),
-      }),
-    );
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings/init.js
index 5e521633ad12..575e3fa65693 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings/test.ts
index 6894d7407349..bb80bf6b8efb 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings/test.ts
@@ -1,59 +1,113 @@
+import { PAGELOAD, HTTP_CLIENT } from '@sentry/conventions/op';
+import {
+  URL_FULL,
+  HTTP_REQUEST_REDIRECT_START,
+  HTTP_REQUEST_REDIRECT_END,
+  HTTP_REQUEST_WORKER_START,
+  HTTP_REQUEST_FETCH_START,
+  HTTP_REQUEST_DOMAIN_LOOKUP_START,
+  HTTP_REQUEST_DOMAIN_LOOKUP_END,
+  HTTP_REQUEST_CONNECT_START,
+  HTTP_REQUEST_SECURE_CONNECTION_START,
+  HTTP_REQUEST_CONNECTION_END,
+  HTTP_REQUEST_REQUEST_START,
+  HTTP_REQUEST_RESPONSE_START,
+  HTTP_REQUEST_RESPONSE_END,
+  HTTP_REQUEST_TIME_TO_FIRST_BYTE,
+  NETWORK_PROTOCOL_VERSION,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getMultipleSentryEnvelopeRequests, shouldSkipTracingTest } from '../../../../utils/helpers';
-
-sentryTest('creates fetch spans with http timing', async ({ browserName, getLocalTestUrl, page }) => {
-  const supportedBrowsers = ['chromium', 'firefox'];
-
-  if (shouldSkipTracingTest() || !supportedBrowsers.includes(browserName)) {
-    sentryTest.skip();
-  }
-  await page.route('http://sentry-test-site.example/*', async route => {
-    const request = route.request();
-    const postData = await request.postDataJSON();
-
-    await route.fulfill({
-      status: 200,
-      contentType: 'application/json',
-      body: JSON.stringify(Object.assign({ id: 1 }, postData)),
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
+
+sentryTest(
+  'adds http timing to http.client spans in span streaming mode',
+  async ({ browserName, getLocalTestUrl, page }) => {
+    const supportedBrowsers = ['chromium', 'firefox'];
+
+    sentryTest.skip(shouldSkipTracingTest() || !supportedBrowsers.includes(browserName));
+
+    await page.route('http://sentry-test-site.example/*', async route => {
+      const request = route.request();
+      const postData = await request.postDataJSON();
+
+      await route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify(Object.assign({ id: 1 }, postData)),
+      });
     });
-  });
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const envelopes = await getMultipleSentryEnvelopeRequests<Event>(page, 2, { url, timeout: 10000 });
-  const tracingEvent = envelopes[envelopes.length - 1]; // last envelope contains tracing data on all browsers
-
-  const requestSpans = tracingEvent.spans?.filter(({ op }) => op === 'http.client');
-
-  expect(requestSpans).toHaveLength(3);
-
-  await page.pause();
-  requestSpans?.forEach((span, index) =>
-    expect(span).toMatchObject({
-      description: `GET http://sentry-test-site.example/${index}`,
-      parent_span_id: tracingEvent.contexts?.trace?.span_id,
-      span_id: expect.stringMatching(/[a-f\d]{16}/),
-      start_timestamp: expect.any(Number),
-      timestamp: expect.any(Number),
-      trace_id: tracingEvent.contexts?.trace?.trace_id,
-      data: expect.objectContaining({
-        'http.request.redirect_start': expect.any(Number),
-        'http.request.redirect_end': expect.any(Number),
-        'http.request.worker_start': expect.any(Number),
-        'http.request.fetch_start': expect.any(Number),
-        'http.request.domain_lookup_start': expect.any(Number),
-        'http.request.domain_lookup_end': expect.any(Number),
-        'http.request.connect_start': expect.any(Number),
-        'http.request.secure_connection_start': expect.any(Number),
-        'http.request.connection_end': expect.any(Number),
-        'http.request.request_start': expect.any(Number),
-        'http.request.response_start': expect.any(Number),
-        'http.request.response_end': expect.any(Number),
-        'http.request.time_to_first_byte': expect.any(Number),
-        'network.protocol.version': expect.any(String),
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const spans = collectStreamedSpans(page);
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === PAGELOAD);
+    await page.goto(url);
+
+    const pageloadSpan = await pageloadSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const requestSpans = spans
+      .filter(s => getSpanOp(s) === HTTP_CLIENT)
+      .sort((a, b) => String(a.attributes[URL_FULL]?.value).localeCompare(String(b.attributes[URL_FULL]?.value)));
+
+    expect(pageloadSpan).toBeDefined();
+    expect(requestSpans).toHaveLength(3);
+
+    requestSpans?.forEach((span, index) =>
+      expect(span).toMatchObject({
+        name: 'GET sentry-test-site.example',
+        parent_span_id: pageloadSpan?.span_id,
+        span_id: expect.stringMatching(/[a-f\d]{16}/),
+        start_timestamp: expect.any(Number),
+        end_timestamp: expect.any(Number),
+        trace_id: pageloadSpan?.trace_id,
+        status: 'ok',
+        attributes: expect.objectContaining({
+          [URL_FULL]: { type: 'string', value: `http://sentry-test-site.example/${index}` },
+          [HTTP_REQUEST_REDIRECT_START]: {
+            type: expect.stringMatching(/^(integer|double)$/),
+            value: expect.any(Number),
+          },
+          [HTTP_REQUEST_REDIRECT_END]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+          [HTTP_REQUEST_WORKER_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+          [HTTP_REQUEST_FETCH_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+          [HTTP_REQUEST_DOMAIN_LOOKUP_START]: {
+            type: expect.stringMatching(/^(integer|double)$/),
+            value: expect.any(Number),
+          },
+          [HTTP_REQUEST_DOMAIN_LOOKUP_END]: {
+            type: expect.stringMatching(/^(integer|double)$/),
+            value: expect.any(Number),
+          },
+          [HTTP_REQUEST_CONNECT_START]: {
+            type: expect.stringMatching(/^(integer|double)$/),
+            value: expect.any(Number),
+          },
+          [HTTP_REQUEST_SECURE_CONNECTION_START]: {
+            type: expect.stringMatching(/^(integer|double)$/),
+            value: expect.any(Number),
+          },
+          [HTTP_REQUEST_CONNECTION_END]: {
+            type: expect.stringMatching(/^(integer|double)$/),
+            value: expect.any(Number),
+          },
+          [HTTP_REQUEST_REQUEST_START]: {
+            type: expect.stringMatching(/^(integer|double)$/),
+            value: expect.any(Number),
+          },
+          [HTTP_REQUEST_RESPONSE_START]: {
+            type: expect.stringMatching(/^(integer|double)$/),
+            value: expect.any(Number),
+          },
+          [HTTP_REQUEST_RESPONSE_END]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+          [HTTP_REQUEST_TIME_TO_FIRST_BYTE]: {
+            type: expect.stringMatching(/^(integer|double)$/),
+            value: expect.any(Number),
+          },
+          [NETWORK_PROTOCOL_VERSION]: { type: 'string', value: expect.any(String) },
+        }),
       }),
-    }),
-  );
-});
+    );
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/init.js
index bb6d4918d1bf..83076460599f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/default/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/default/init.js
similarity index 93%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/default/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/default/init.js
index 63afee65329a..04a299421004 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/default/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/default/init.js
@@ -3,13 +3,13 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
       linkPreviousTrace: 'in-memory',
       consistentTraceSampling: true,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracePropagationTargets: ['sentry-test-external.io'],
   tracesSampler: ctx => {
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/default/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/default/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/default/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/default/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/default/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/default/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/default/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/default/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/default/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/default/test.ts
new file mode 100644
index 000000000000..4d13371bc693
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/default/test.ts
@@ -0,0 +1,149 @@
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { extractTraceparentData, parseBaggageHeader, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
+import { sentryTest } from '../../../../../../utils/fixtures';
+import {
+  eventAndTraceHeaderRequestParser,
+  shouldSkipTracingTest,
+  waitForTracingHeadersOnUrl,
+  waitForTransactionRequest,
+} from '../../../../../../utils/helpers';
+
+sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
+  sentryTest('Continues sampling decision from initial pageload', async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const { pageloadTraceContext, pageloadSampleRand } = await sentryTest.step('Initial pageload', async () => {
+      const pageloadRequestPromise = waitForTransactionRequest(page, evt => {
+        return evt.contexts?.trace?.op === 'pageload';
+      });
+      await page.goto(url);
+
+      const res = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
+      const pageloadSampleRand = Number(res[1]?.sample_rand);
+      const pageloadTraceContext = res[0].contexts?.trace;
+
+      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
+      expect(pageloadSampleRand).toBeGreaterThanOrEqual(0);
+
+      return { pageloadTraceContext: res[0].contexts?.trace, pageloadSampleRand };
+    });
+
+    const customTraceContext = await sentryTest.step('Custom trace', async () => {
+      const customTrace1RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+      await page.locator('#btn1').click();
+      const [customTrace1Event, customTraceTraceHeader] = eventAndTraceHeaderRequestParser(
+        await customTrace1RequestPromise,
+      );
+
+      const customTraceContext = customTrace1Event.contexts?.trace;
+
+      expect(customTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+      // although we "continue the trace" from pageload, this is actually a root span,
+      // so there must not be a parent span id
+      expect(customTraceContext?.parent_span_id).toBeUndefined();
+
+      expect(pageloadSampleRand).toEqual(Number(customTraceTraceHeader?.sample_rand));
+
+      return customTraceContext;
+    });
+
+    await sentryTest.step('Navigation', async () => {
+      const navigation1RequestPromise = waitForTransactionRequest(
+        page,
+        evt => evt.contexts?.trace?.op === 'navigation',
+      );
+      await page.goto(`${url}#foo`);
+      const [navigationEvent, navigationTraceHeader] = eventAndTraceHeaderRequestParser(
+        await navigation1RequestPromise,
+      );
+      const navTraceContext = navigationEvent.contexts?.trace;
+
+      expect(navTraceContext?.trace_id).not.toEqual(customTraceContext?.trace_id);
+      expect(navTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+
+      expect(navTraceContext?.links).toEqual([
+        {
+          trace_id: customTraceContext?.trace_id,
+          span_id: customTraceContext?.span_id,
+          sampled: true,
+          attributes: {
+            [SENTRY_LINK_TYPE]: 'previous_trace',
+          },
+        },
+      ]);
+      expect(navTraceContext?.parent_span_id).toBeUndefined();
+
+      expect(pageloadSampleRand).toEqual(Number(navigationTraceHeader?.sample_rand));
+    });
+  });
+
+  sentryTest('Propagates continued sampling decision to outgoing requests', async ({ page, getLocalTestUrl }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const { pageloadTraceContext, pageloadSampleRand } = await sentryTest.step('Initial pageload', async () => {
+      const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+      await page.goto(url);
+
+      const res = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
+      const pageloadSampleRand = Number(res[1]?.sample_rand);
+
+      expect(pageloadSampleRand).toBeGreaterThanOrEqual(0);
+
+      const pageloadTraceContext = res[0].contexts?.trace;
+
+      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
+
+      return { pageloadTraceContext: pageloadTraceContext, pageloadSampleRand };
+    });
+
+    await sentryTest.step('Make fetch request', async () => {
+      const fetchTracePromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+      const tracingHeadersPromise = waitForTracingHeadersOnUrl(page, 'http://sentry-test-external.io');
+
+      await page.locator('#btn2').click();
+
+      const { baggage, sentryTrace } = await tracingHeadersPromise;
+
+      const [fetchTraceEvent, fetchTraceTraceHeader] = eventAndTraceHeaderRequestParser(await fetchTracePromise);
+
+      const fetchTraceSampleRand = Number(fetchTraceTraceHeader?.sample_rand);
+      const fetchTraceTraceContext = fetchTraceEvent.contexts?.trace;
+      const httpClientSpan = fetchTraceEvent.spans?.find(span => span.op === 'http.client');
+
+      expect(fetchTraceSampleRand).toEqual(pageloadSampleRand);
+
+      expect(fetchTraceTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toEqual(
+        pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE],
+      );
+      expect(fetchTraceTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+
+      expect(sentryTrace).toBeDefined();
+      expect(baggage).toBeDefined();
+
+      expect(extractTraceparentData(sentryTrace)).toEqual({
+        traceId: fetchTraceTraceContext?.trace_id,
+        parentSpanId: httpClientSpan?.span_id,
+        parentSampled: true,
+      });
+
+      expect(parseBaggageHeader(baggage)).toEqual({
+        'sentry-environment': 'production',
+        'sentry-public_key': 'public',
+        'sentry-sample_rand': `${pageloadSampleRand}`,
+        'sentry-sample_rate': '1',
+        'sentry-sampled': 'true',
+        'sentry-trace_id': fetchTraceTraceContext?.trace_id,
+        'sentry-transaction': 'custom root span 2',
+      });
+    });
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-negative/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/init.js
similarity index 85%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-negative/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/init.js
index d570ac45144c..05c4ec8db85a 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-negative/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/init.js
@@ -3,15 +3,14 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
       linkPreviousTrace: 'in-memory',
       consistentTraceSampling: true,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
-  traceLifecycle: 'stream',
   tracePropagationTargets: ['sentry-test-external.io'],
   tracesSampleRate: 1,
   debug: true,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-negative/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-negative/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-negative/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-negative/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-negative/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/test.ts
similarity index 73%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-negative/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/test.ts
index efd4ccce4e37..c4eae38fbd89 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-negative/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/test.ts
@@ -1,15 +1,16 @@
 import { expect } from '@playwright/test';
-import type { ClientReport, SerializedStreamedSpan } from '@sentry/core';
+import type { ClientReport } from '@sentry/core';
 import { extractTraceparentData, parseBaggageHeader } from '@sentry/core';
 import { sentryTest } from '../../../../../../utils/fixtures';
 import {
   envelopeRequestParser,
+  envelopeUrlRegex,
+  getEnvelopeType,
   hidePage,
   shouldSkipTracingTest,
   waitForClientReportRequest,
   waitForTracingHeadersOnUrl,
 } from '../../../../../../utils/helpers';
-import { observeStreamedSpan } from '../../../../../../utils/spanUtils';
 
 const metaTagSampleRand = 0.9;
 const metaTagSampleRate = 0.2;
@@ -19,31 +20,38 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
   sentryTest(
     'Continues negative sampling decision from meta tag across all traces and downstream propagations',
     async ({ getLocalTestUrl, page }) => {
-      sentryTest.skip(shouldSkipTracingTest());
+      if (shouldSkipTracingTest()) {
+        sentryTest.skip();
+      }
 
       const url = await getLocalTestUrl({ testDir: __dirname });
 
-      const spansReceived: SerializedStreamedSpan[] = [];
-      observeStreamedSpan(page, span => {
-        spansReceived.push(span);
-        return false;
+      let txnsReceived = 0;
+      page.on('request', request => {
+        if (envelopeUrlRegex.test(request.url()) && getEnvelopeType(request) === 'transaction') {
+          ++txnsReceived;
+        }
       });
 
-      const clientReportPromise = waitForClientReportRequest(page);
+      const clientReportPromise = waitForClientReportRequest(page, report =>
+        report.discarded_events.some(
+          event => event.category === 'transaction' && event.reason === 'sample_rate' && event.quantity === 4,
+        ),
+      );
 
       await sentryTest.step('Initial pageload', async () => {
         await page.goto(url);
-        expect(spansReceived).toHaveLength(0);
+        expect(txnsReceived).toEqual(0);
       });
 
       await sentryTest.step('Custom instrumented button click', async () => {
         await page.locator('#btn1').click();
-        expect(spansReceived).toHaveLength(0);
+        expect(txnsReceived).toEqual(0);
       });
 
       await sentryTest.step('Navigation', async () => {
         await page.goto(`${url}#foo`);
-        expect(spansReceived).toHaveLength(0);
+        expect(txnsReceived).toEqual(0);
       });
 
       await sentryTest.step('Make fetch request', async () => {
@@ -70,8 +78,6 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
           'sentry-trace_id': expect.not.stringContaining(metaTagTraceId),
           'sentry-transaction': 'custom root span 2',
         });
-
-        expect(spansReceived).toHaveLength(0);
       });
 
       await sentryTest.step('Client report', async () => {
@@ -81,17 +87,18 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
           timestamp: expect.any(Number),
           discarded_events: [
             {
-              category: 'span',
-              quantity: expect.any(Number),
+              category: 'transaction',
+              quantity: 4,
               reason: 'sample_rate',
             },
           ],
         });
-        // exact number depends on performance observer emissions
-        expect(clientReport.discarded_events[0].quantity).toBeGreaterThanOrEqual(10);
       });
 
-      expect(spansReceived).toHaveLength(0);
+      await sentryTest.step('No transactions sent after processing completes', async () => {
+        expect(await page.evaluate(() => (window as any).Sentry.flush())).toBe(true);
+        expect(txnsReceived).toEqual(0);
+      });
     },
   );
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/init.js
similarity index 92%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/init.js
index 177fe4c4aeaf..fbf897d47eab 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/init.js
@@ -3,13 +3,13 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
       linkPreviousTrace: 'session-storage',
       consistentTraceSampling: true,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracePropagationTargets: ['sentry-test-external.io'],
   tracesSampler: ({ inheritOrSampleWith }) => {
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/page-1.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/page-1.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/page-1.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/page-1.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/page-2.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/page-2.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/page-2.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/page-2.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/test.ts
similarity index 63%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/test.ts
index cd64596f9bfd..3dab9594ba7c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/test.ts
@@ -4,12 +4,13 @@ import { extractTraceparentData, parseBaggageHeader } from '@sentry/core';
 import { sentryTest } from '../../../../../../utils/fixtures';
 import {
   envelopeRequestParser,
+  eventAndTraceHeaderRequestParser,
   hidePage,
   shouldSkipTracingTest,
   waitForClientReportRequest,
   waitForTracingHeadersOnUrl,
+  waitForTransactionRequest,
 } from '../../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpanEnvelope } from '../../../../../../utils/spanUtils';
 
 const metaTagSampleRand = 0.9;
 const metaTagSampleRate = 0.2;
@@ -20,14 +21,16 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
   sentryTest(
     'meta tag decision has precedence over sampling decision from previous trace in session storage',
     async ({ getLocalTestUrl, page }) => {
-      sentryTest.skip(shouldSkipTracingTest());
+      if (shouldSkipTracingTest()) {
+        sentryTest.skip();
+      }
 
       const url = await getLocalTestUrl({ testDir: __dirname });
 
       const clientReportPromise = waitForClientReportRequest(page);
 
       await sentryTest.step('Initial pageload', async () => {
-        // negative sampling decision -> no pageload span
+        // negative sampling decision -> no pageload txn
         await page.goto(url);
       });
 
@@ -68,49 +71,37 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
           timestamp: expect.any(Number),
           discarded_events: [
             {
-              category: 'span',
-              quantity: expect.any(Number),
+              category: 'transaction',
+              quantity: 2,
               reason: 'sample_rate',
             },
           ],
         });
-        // exact number depends on performance observer emissions
-        expect(clientReport.discarded_events[0].quantity).toBeGreaterThanOrEqual(3);
       });
 
       await sentryTest.step('Navigate to another page with meta tags', async () => {
-        const page1PageloadEnvelopePromise = waitForStreamedSpanEnvelope(
-          page,
-          env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload' && s.trace_id === metaTagTraceIdPage1),
-        );
+        const page1Pageload = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
         await page.locator('a').click();
 
-        const envelope = await page1PageloadEnvelopePromise;
-        const pageloadSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
+        const [pageloadEvent, pageloadTraceHeader] = eventAndTraceHeaderRequestParser(await page1Pageload);
+        const pageloadTraceContext = pageloadEvent.contexts?.trace;
 
-        expect(Number(envelope[0].trace?.sample_rand)).toBe(0.12);
-        expect(Number(envelope[0].trace?.sample_rate)).toBe(0.2);
-        expect(pageloadSpan.trace_id).toEqual(metaTagTraceIdPage1);
+        expect(Number(pageloadTraceHeader?.sample_rand)).toBe(0.12);
+        expect(Number(pageloadTraceHeader?.sample_rate)).toBe(0.2);
+        expect(pageloadTraceContext?.trace_id).toEqual(metaTagTraceIdPage1);
       });
 
       await sentryTest.step('Navigate to another page without meta tags', async () => {
-        const page2PageloadEnvelopePromise = waitForStreamedSpanEnvelope(
-          page,
-          env =>
-            !!env[1][0][1].items.find(
-              s =>
-                getSpanOp(s) === 'pageload' && s.trace_id !== metaTagTraceIdPage1 && s.trace_id !== metaTagTraceIdIndex,
-            ),
-        );
+        const page2Pageload = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
         await page.locator('a').click();
 
-        const envelope = await page2PageloadEnvelopePromise;
-        const pageloadSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
+        const [pageloadEvent, pageloadTraceHeader] = eventAndTraceHeaderRequestParser(await page2Pageload);
+        const pageloadTraceContext = pageloadEvent.contexts?.trace;
 
-        expect(Number(envelope[0].trace?.sample_rand)).toBe(0.12);
-        expect(Number(envelope[0].trace?.sample_rate)).toBe(0.2);
-        expect(pageloadSpan.trace_id).not.toEqual(metaTagTraceIdPage1);
-        expect(pageloadSpan.trace_id).not.toEqual(metaTagTraceIdIndex);
+        expect(Number(pageloadTraceHeader?.sample_rand)).toBe(0.12);
+        expect(Number(pageloadTraceHeader?.sample_rate)).toBe(0.2);
+        expect(pageloadTraceContext?.trace_id).not.toEqual(metaTagTraceIdPage1);
+        expect(pageloadTraceContext?.trace_id).not.toEqual(metaTagTraceIdIndex);
       });
     },
   );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta/init.js
similarity index 92%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta/init.js
index a1ddc5465950..61e2b2daa9ba 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta/init.js
@@ -3,13 +3,13 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
       linkPreviousTrace: 'in-memory',
       consistentTraceSampling: true,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracePropagationTargets: ['sentry-test-external.io'],
   // only take into account sampling from meta tag; otherwise sample negatively
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta/test.ts
new file mode 100644
index 000000000000..ac2a865fb181
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta/test.ts
@@ -0,0 +1,176 @@
+import { expect } from '@playwright/test';
+import {
+  extractTraceparentData,
+  parseBaggageHeader,
+  SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE,
+  SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
+} from '@sentry/core';
+import { sentryTest } from '../../../../../../utils/fixtures';
+import {
+  eventAndTraceHeaderRequestParser,
+  shouldSkipTracingTest,
+  waitForTracingHeadersOnUrl,
+  waitForTransactionRequest,
+} from '../../../../../../utils/helpers';
+
+const metaTagSampleRand = 0.051121;
+const metaTagSampleRate = 0.2;
+
+sentryTest.describe('When `consistentTraceSampling` is `true` and page contains <meta> tags', () => {
+  sentryTest('Continues sampling decision across all traces from meta tag', async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
+      const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+
+      await page.goto(url);
+
+      const [pageloadEvent, pageloadTraceHeader] = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
+      const pageloadTraceContext = pageloadEvent.contexts?.trace;
+
+      expect(Number(pageloadTraceHeader?.sample_rand)).toBe(metaTagSampleRand);
+      expect(Number(pageloadTraceHeader?.sample_rate)).toBe(metaTagSampleRate);
+
+      // since the local sample rate was not applied, the sample rate attribute shouldn't be set
+      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
+      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBeUndefined();
+
+      return pageloadTraceContext;
+    });
+
+    const customTraceContext = await sentryTest.step('Custom trace', async () => {
+      const customTrace1RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+
+      await page.locator('#btn1').click();
+
+      const [customTrace1Event, customTraceTraceHeader] = eventAndTraceHeaderRequestParser(
+        await customTrace1RequestPromise,
+      );
+
+      const customTraceContext = customTrace1Event.contexts?.trace;
+
+      expect(customTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+      expect(customTraceContext?.parent_span_id).toBeUndefined();
+
+      expect(Number(customTraceTraceHeader?.sample_rand)).toBe(metaTagSampleRand);
+      expect(Number(customTraceTraceHeader?.sample_rate)).toBe(metaTagSampleRate);
+      expect(Boolean(customTraceTraceHeader?.sampled)).toBe(true);
+
+      // since the local sample rate was not applied, the sample rate attribute shouldn't be set
+      expect(customTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
+
+      // but we need to set this attribute to still be able to correctly add the sample rate to the DSC (checked above in trace header)
+      expect(customTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBe(metaTagSampleRate);
+
+      return customTraceContext;
+    });
+
+    await sentryTest.step('Navigation', async () => {
+      const navigation1RequestPromise = waitForTransactionRequest(
+        page,
+        evt => evt.contexts?.trace?.op === 'navigation',
+      );
+
+      await page.goto(`${url}#foo`);
+
+      const [navigationEvent, navigationTraceHeader] = eventAndTraceHeaderRequestParser(
+        await navigation1RequestPromise,
+      );
+
+      const navigationTraceContext = navigationEvent.contexts?.trace;
+
+      expect(navigationTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+      expect(navigationTraceContext?.trace_id).not.toEqual(customTraceContext?.trace_id);
+
+      expect(navigationTraceContext?.parent_span_id).toBeUndefined();
+
+      expect(Number(navigationTraceHeader?.sample_rand)).toEqual(metaTagSampleRand);
+      expect(Number(navigationTraceHeader?.sample_rate)).toEqual(metaTagSampleRate);
+      expect(Boolean(navigationTraceHeader?.sampled)).toEqual(true);
+
+      // since the local sample rate was not applied, the sample rate attribute shouldn't be set
+      expect(navigationTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
+
+      // but we need to set this attribute to still be able to correctly add the sample rate to the DSC (checked above in trace header)
+      expect(navigationTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBe(
+        metaTagSampleRate,
+      );
+    });
+  });
+
+  sentryTest(
+    'Propagates continued <meta> tag sampling decision to outgoing requests',
+    async ({ page, getLocalTestUrl }) => {
+      if (shouldSkipTracingTest()) {
+        sentryTest.skip();
+      }
+
+      const url = await getLocalTestUrl({ testDir: __dirname });
+
+      const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
+        const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+
+        await page.goto(url);
+
+        const [pageloadEvent, pageloadTraceHeader] = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
+        const pageloadTraceContext = pageloadEvent.contexts?.trace;
+
+        expect(Number(pageloadTraceHeader?.sample_rand)).toBe(metaTagSampleRand);
+        expect(Number(pageloadTraceHeader?.sample_rate)).toBe(metaTagSampleRate);
+
+        // since the local sample rate was not applied, the sample rate attribute shouldn't be set
+        expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
+        expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBeUndefined();
+
+        return pageloadTraceContext;
+      });
+
+      await sentryTest.step('Make fetch request', async () => {
+        const fetchTracePromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+        const tracingHeadersPromise = waitForTracingHeadersOnUrl(page, 'http://sentry-test-external.io');
+
+        await page.locator('#btn2').click();
+
+        const { baggage, sentryTrace } = await tracingHeadersPromise;
+
+        const [fetchTraceEvent, fetchTraceTraceHeader] = eventAndTraceHeaderRequestParser(await fetchTracePromise);
+
+        const fetchTraceSampleRand = Number(fetchTraceTraceHeader?.sample_rand);
+        const fetchTraceTraceContext = fetchTraceEvent.contexts?.trace;
+        const httpClientSpan = fetchTraceEvent.spans?.find(span => span.op === 'http.client');
+
+        expect(fetchTraceSampleRand).toEqual(metaTagSampleRand);
+
+        expect(fetchTraceTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
+        expect(fetchTraceTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBe(
+          metaTagSampleRate,
+        );
+
+        expect(fetchTraceTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+
+        expect(sentryTrace).toBeDefined();
+        expect(baggage).toBeDefined();
+
+        expect(extractTraceparentData(sentryTrace)).toEqual({
+          traceId: fetchTraceTraceContext?.trace_id,
+          parentSpanId: httpClientSpan?.span_id,
+          parentSampled: true,
+        });
+
+        expect(parseBaggageHeader(baggage)).toEqual({
+          'sentry-environment': 'production',
+          'sentry-public_key': 'public',
+          'sentry-sample_rand': `${metaTagSampleRand}`,
+          'sentry-sample_rate': `${metaTagSampleRate}`,
+          'sentry-sampled': 'true',
+          'sentry-trace_id': fetchTraceTraceContext?.trace_id,
+          'sentry-transaction': 'custom root span 2',
+        });
+      });
+    },
+  );
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/tracesSampler-precedence/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/init.js
similarity index 94%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/tracesSampler-precedence/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/init.js
index 623db0ecc028..e2efc43e50f2 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/tracesSampler-precedence/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/init.js
@@ -3,6 +3,7 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
@@ -10,7 +11,6 @@ Sentry.init({
       consistentTraceSampling: true,
       enableInp: false,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracePropagationTargets: ['sentry-test-external.io'],
   tracesSampler: ctx => {
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/tracesSampler-precedence/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/tracesSampler-precedence/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/tracesSampler-precedence/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/tracesSampler-precedence/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/tracesSampler-precedence/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/test.ts
similarity index 50%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/tracesSampler-precedence/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/test.ts
index 37e3b204fe88..a61043dfc109 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/tracesSampler-precedence/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/test.ts
@@ -1,3 +1,4 @@
+import { PAGELOAD, NAVIGATION } from '@sentry/conventions/op';
 import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
@@ -5,11 +6,12 @@ import type { ClientReport } from '@sentry/core';
 import { sentryTest } from '../../../../../../utils/fixtures';
 import {
   envelopeRequestParser,
+  eventAndTraceHeaderRequestParser,
   hidePage,
   shouldSkipTracingTest,
   waitForClientReportRequest,
+  waitForTransactionRequest,
 } from '../../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpanEnvelope } from '../../../../../../utils/spanUtils';
 
 /**
  * This test demonstrates that:
@@ -18,24 +20,26 @@ import { getSpanOp, waitForStreamedSpanEnvelope } from '../../../../../../utils/
  */
 sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
   sentryTest('explicit sampling decisions in `tracesSampler` have precedence', async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const { pageloadSpan } = await sentryTest.step('Initial pageload', async () => {
-      const pageloadEnvelopePromise = waitForStreamedSpanEnvelope(
-        page,
-        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
-      );
+    const { pageloadTraceContext } = await sentryTest.step('Initial pageload', async () => {
+      const pageloadRequestPromise = waitForTransactionRequest(page, evt => {
+        return evt.contexts?.trace?.op === PAGELOAD;
+      });
       await page.goto(url);
 
-      const envelope = await pageloadEnvelopePromise;
-      const pageloadSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
+      const res = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
+      const pageloadSampleRand = Number(res[1]?.sample_rand);
+      const pageloadTraceContext = res[0].contexts?.trace;
 
-      expect(pageloadSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]?.value).toBe(1);
-      expect(Number(envelope[0].trace?.sample_rand)).toBeGreaterThanOrEqual(0);
+      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
+      expect(pageloadSampleRand).toBeGreaterThanOrEqual(0);
 
-      return { pageloadSpan };
+      return { pageloadTraceContext: res[0].contexts?.trace, pageloadSampleRand };
     });
 
     await sentryTest.step('Custom trace is sampled negatively (explicitly in tracesSampler)', async () => {
@@ -43,7 +47,6 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
 
       await page.locator('#btn1').click();
 
-      await page.waitForTimeout(500);
       await hidePage(page);
 
       const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
@@ -52,7 +55,7 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
         timestamp: expect.any(Number),
         discarded_events: [
           {
-            category: 'span',
+            category: 'transaction',
             quantity: 1,
             reason: 'sample_rate',
           },
@@ -65,8 +68,6 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
 
       await page.goto(`${url}#foo`);
 
-      await page.waitForTimeout(500);
-
       await hidePage(page);
 
       const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
@@ -75,7 +76,7 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
         timestamp: expect.any(Number),
         discarded_events: [
           {
-            category: 'span',
+            category: 'transaction',
             quantity: 1,
             reason: 'sample_rate',
           },
@@ -83,67 +84,53 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
       });
     });
 
-    const { customTrace2Span } = await sentryTest.step(
+    const { customTrace2Context } = await sentryTest.step(
       'Custom trace 2 is sampled positively (explicitly in tracesSampler)',
       async () => {
-        const customEnvelopePromise = waitForStreamedSpanEnvelope(
-          page,
-          env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'custom'),
-        );
+        const customTrace2RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
 
         await page.locator('#btn2').click();
 
-        const envelope = await customEnvelopePromise;
-        const customTrace2Span = envelope[1][0][1].items.find(s => getSpanOp(s) === 'custom')!;
+        const [customTrace2Event] = eventAndTraceHeaderRequestParser(await customTrace2RequestPromise);
+
+        const customTrace2Context = customTrace2Event.contexts?.trace;
 
-        expect(customTrace2Span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]?.value).toBe(1);
-        expect(customTrace2Span.trace_id).not.toEqual(pageloadSpan.trace_id);
-        expect(customTrace2Span.parent_span_id).toBeUndefined();
+        expect(customTrace2Context?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
+        expect(customTrace2Context?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+        expect(customTrace2Context?.parent_span_id).toBeUndefined();
 
-        expect(customTrace2Span.links).toEqual([
+        expect(customTrace2Context?.links).toEqual([
           {
-            attributes: {
-              [SENTRY_LINK_TYPE]: {
-                type: 'string',
-                value: 'previous_trace',
-              },
-            },
+            attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' },
             sampled: false,
             span_id: expect.stringMatching(/^[\da-f]{16}$/),
             trace_id: expect.stringMatching(/^[\da-f]{32}$/),
           },
         ]);
 
-        return { customTrace2Span };
+        return { customTrace2Context };
       },
     );
 
     await sentryTest.step('Navigation trace is sampled positively (inherited from previous trace)', async () => {
-      const navigationEnvelopePromise = waitForStreamedSpanEnvelope(
-        page,
-        env => env[0].trace?.sampled === 'true' && !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
-      );
+      const navigationRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === NAVIGATION);
 
       await page.goto(`${url}#bar`);
 
-      const envelope = await navigationEnvelopePromise;
-      const navigationSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'navigation')!;
+      const [navigationEvent] = eventAndTraceHeaderRequestParser(await navigationRequestPromise);
 
-      expect(navigationSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]?.value).toBe(1);
-      expect(navigationSpan.trace_id).not.toEqual(customTrace2Span.trace_id);
-      expect(navigationSpan.parent_span_id).toBeUndefined();
+      const navigationTraceContext = navigationEvent.contexts?.trace;
 
-      expect(navigationSpan.links).toEqual([
+      expect(navigationTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
+      expect(navigationTraceContext?.trace_id).not.toEqual(customTrace2Context?.trace_id);
+      expect(navigationTraceContext?.parent_span_id).toBeUndefined();
+
+      expect(navigationTraceContext?.links).toEqual([
         {
-          attributes: {
-            [SENTRY_LINK_TYPE]: {
-              type: 'string',
-              value: 'previous_trace',
-            },
-          },
+          attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' },
           sampled: true,
-          span_id: customTrace2Span.span_id,
-          trace_id: customTrace2Span.trace_id,
+          span_id: customTrace2Context?.span_id,
+          trace_id: customTrace2Context?.trace_id,
         },
       ]);
     });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/custom-trace/init.js
similarity index 66%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/custom-trace/init.js
index 749560a5c459..bdd43f5ac757 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/backgroundtab-pageload-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/custom-trace/init.js
@@ -3,8 +3,9 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
   debug: true,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/custom-trace/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/custom-trace/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/custom-trace/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/custom-trace/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/custom-trace/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/custom-trace/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/custom-trace/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/custom-trace/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/custom-trace/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/custom-trace/test.ts
new file mode 100644
index 000000000000..c4637dc25018
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/custom-trace/test.ts
@@ -0,0 +1,62 @@
+import { expect } from '@playwright/test';
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { sentryTest } from '../../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+
+sentryTest('manually started custom traces are linked correctly in the chain', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
+    const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    await page.goto(url);
+    const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
+    return pageloadRequest.contexts?.trace;
+  });
+
+  const customTrace1Context = await sentryTest.step('Custom trace', async () => {
+    const customTrace1RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+    await page.locator('#btn1').click();
+    const customTrace1Event = envelopeRequestParser(await customTrace1RequestPromise);
+
+    const customTraceCtx = customTrace1Event.contexts?.trace;
+
+    expect(customTraceCtx?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+    expect(customTraceCtx?.links).toEqual([
+      {
+        trace_id: pageloadTraceContext?.trace_id,
+        span_id: pageloadTraceContext?.span_id,
+        sampled: true,
+        attributes: {
+          [SENTRY_LINK_TYPE]: 'previous_trace',
+        },
+      },
+    ]);
+
+    return customTraceCtx;
+  });
+
+  await sentryTest.step('Navigation', async () => {
+    const navigation1RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
+    await page.goto(`${url}#foo`);
+    const navigationEvent = envelopeRequestParser(await navigation1RequestPromise);
+    const navTraceContext = navigationEvent.contexts?.trace;
+
+    expect(navTraceContext?.trace_id).not.toEqual(customTrace1Context?.trace_id);
+    expect(navTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+
+    expect(navTraceContext?.links).toEqual([
+      {
+        trace_id: customTrace1Context?.trace_id,
+        span_id: customTrace1Context?.span_id,
+        sampled: true,
+        attributes: {
+          [SENTRY_LINK_TYPE]: 'previous_trace',
+        },
+      },
+    ]);
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/default/init.js
similarity index 66%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/default/init.js
index 749560a5c459..bdd43f5ac757 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/default/init.js
@@ -3,8 +3,9 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
   debug: true,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/default/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/default/test.ts
new file mode 100644
index 000000000000..7399c2bb26c3
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/default/test.ts
@@ -0,0 +1,99 @@
+import { expect } from '@playwright/test';
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { sentryTest } from '../../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+
+sentryTest("navigation spans link back to previous trace's root span", async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
+    const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    await page.goto(url);
+    const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
+    return pageloadRequest.contexts?.trace;
+  });
+
+  const navigation1TraceContext = await sentryTest.step('First navigation', async () => {
+    const navigation1RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
+    await page.goto(`${url}#foo`);
+    const navigation1Request = envelopeRequestParser(await navigation1RequestPromise);
+    return navigation1Request.contexts?.trace;
+  });
+
+  const navigation2TraceContext = await sentryTest.step('Second navigation', async () => {
+    const navigation2RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
+    await page.goto(`${url}#bar`);
+    const navigation2Request = envelopeRequestParser(await navigation2RequestPromise);
+    return navigation2Request.contexts?.trace;
+  });
+
+  const pageloadTraceId = pageloadTraceContext?.trace_id;
+  const navigation1TraceId = navigation1TraceContext?.trace_id;
+  const navigation2TraceId = navigation2TraceContext?.trace_id;
+
+  expect(pageloadTraceContext?.links).toBeUndefined();
+
+  expect(navigation1TraceContext?.links).toEqual([
+    {
+      trace_id: pageloadTraceId,
+      span_id: pageloadTraceContext?.span_id,
+      sampled: true,
+      attributes: {
+        [SENTRY_LINK_TYPE]: 'previous_trace',
+      },
+    },
+  ]);
+
+  expect(navigation1TraceContext?.data).toMatchObject({
+    'sentry.previous_trace': `${pageloadTraceId}-${pageloadTraceContext?.span_id}-1`,
+  });
+
+  expect(navigation2TraceContext?.links).toEqual([
+    {
+      trace_id: navigation1TraceId,
+      span_id: navigation1TraceContext?.span_id,
+      sampled: true,
+      attributes: {
+        [SENTRY_LINK_TYPE]: 'previous_trace',
+      },
+    },
+  ]);
+
+  expect(navigation2TraceContext?.data).toMatchObject({
+    'sentry.previous_trace': `${navigation1TraceId}-${navigation1TraceContext?.span_id}-1`,
+  });
+
+  expect(pageloadTraceId).not.toEqual(navigation1TraceId);
+  expect(navigation1TraceId).not.toEqual(navigation2TraceId);
+  expect(pageloadTraceId).not.toEqual(navigation2TraceId);
+});
+
+sentryTest("doesn't link between hard page reloads by default", async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await sentryTest.step('First pageload', async () => {
+    const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    await page.goto(url);
+    const pageload1Event = envelopeRequestParser(await pageloadRequestPromise);
+
+    expect(pageload1Event.contexts?.trace).toBeDefined();
+    expect(pageload1Event.contexts?.trace?.links).toBeUndefined();
+  });
+
+  await sentryTest.step('Second pageload', async () => {
+    const pageload2RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    await page.reload();
+    const pageload2Event = envelopeRequestParser(await pageload2RequestPromise);
+
+    expect(pageload2Event.contexts?.trace).toBeDefined();
+    expect(pageload2Event.contexts?.trace?.links).toBeUndefined();
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/interaction-spans/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/interaction-spans/init.js
similarity index 84%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/interaction-spans/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/interaction-spans/init.js
index 812e8cb92dc2..2c3e9264d882 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/interaction-spans/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/interaction-spans/init.js
@@ -4,7 +4,8 @@ import { interactionsIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1,
-  integrations: [Sentry.browserTracingIntegration(), interactionsIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration(), interactionsIntegration()],
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/interaction-spans/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/interaction-spans/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/interaction-spans/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/interaction-spans/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/interaction-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/interaction-spans/test.ts
new file mode 100644
index 000000000000..24a1e2c59072
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/interaction-spans/test.ts
@@ -0,0 +1,89 @@
+import { expect } from '@playwright/test';
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { sentryTest } from '../../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+
+/*
+  This is quite peculiar behavior but it's a result of the route-based trace lifetime.
+  Once we shortened trace lifetime, this whole scenario will change as the interaction
+  spans will be their own trace. So most likely, we can replace this test with a new one
+  that covers the new default behavior.
+*/
+sentryTest(
+  'only the first root spans in the trace link back to the previous trace',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
+      const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+      await page.goto(url);
+
+      const pageloadEvent = envelopeRequestParser(await pageloadRequestPromise);
+      const traceContext = pageloadEvent.contexts?.trace;
+
+      expect(traceContext).toBeDefined();
+      expect(traceContext?.links).toBeUndefined();
+
+      return traceContext;
+    });
+
+    await sentryTest.step('Click Before navigation', async () => {
+      const interactionRequestPromise = waitForTransactionRequest(page, evt => {
+        return evt.contexts?.trace?.op === 'ui.action.click';
+      });
+      await page.click('#btn');
+
+      const interactionEvent = envelopeRequestParser(await interactionRequestPromise);
+      const interactionTraceContext = interactionEvent.contexts?.trace;
+
+      // sanity check: route-based trace lifetime means the trace_id should be the same
+      expect(interactionTraceContext?.trace_id).toBe(pageloadTraceContext?.trace_id);
+
+      // no links yet as previous root span belonged to same trace
+      expect(interactionTraceContext?.links).toBeUndefined();
+    });
+
+    const navigationTraceContext = await sentryTest.step('Navigation', async () => {
+      const navigationRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
+      await page.goto(`${url}#foo`);
+      const navigationEvent = envelopeRequestParser(await navigationRequestPromise);
+
+      const traceContext = navigationEvent.contexts?.trace;
+
+      expect(traceContext?.op).toBe('navigation');
+      expect(traceContext?.links).toEqual([
+        {
+          trace_id: pageloadTraceContext?.trace_id,
+          span_id: pageloadTraceContext?.span_id,
+          sampled: true,
+          attributes: {
+            [SENTRY_LINK_TYPE]: 'previous_trace',
+          },
+        },
+      ]);
+
+      expect(traceContext?.trace_id).not.toEqual(traceContext?.links![0].trace_id);
+      return traceContext;
+    });
+
+    await sentryTest.step('Click After navigation', async () => {
+      const interactionRequestPromise = waitForTransactionRequest(page, evt => {
+        return evt.contexts?.trace?.op === 'ui.action.click';
+      });
+      await page.click('#btn');
+      const interactionEvent = envelopeRequestParser(await interactionRequestPromise);
+
+      const interactionTraceContext = interactionEvent.contexts?.trace;
+
+      // sanity check: route-based trace lifetime means the trace_id should be the same
+      expect(interactionTraceContext?.trace_id).toBe(navigationTraceContext?.trace_id);
+
+      // since this is the second root span in the trace, it doesn't link back to the previous trace
+      expect(interactionTraceContext?.links).toBeUndefined();
+    });
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/meta/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/meta/init.js
new file mode 100644
index 000000000000..bdd43f5ac757
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/meta/init.js
@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracesSampleRate: 1,
+  debug: true,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/meta/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/meta/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/meta/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/meta/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/meta/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/meta/test.ts
new file mode 100644
index 000000000000..a232a5a0f6e7
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/meta/test.ts
@@ -0,0 +1,54 @@
+import { expect } from '@playwright/test';
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { sentryTest } from '../../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+
+sentryTest(
+  "links back to previous trace's local root span if continued from meta tags",
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const metaTagTraceId = '12345678901234567890123456789012';
+
+    const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
+      const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+      await page.goto(url);
+      const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
+
+      const traceContext = pageloadRequest.contexts?.trace;
+
+      // sanity check
+      expect(traceContext?.trace_id).toBe(metaTagTraceId);
+
+      expect(traceContext?.links).toBeUndefined();
+
+      return traceContext;
+    });
+
+    const navigationTraceContext = await sentryTest.step('Navigation', async () => {
+      const navigationRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
+      await page.goto(`${url}#foo`);
+      const navigationRequest = envelopeRequestParser(await navigationRequestPromise);
+      return navigationRequest.contexts?.trace;
+    });
+
+    const navigationTraceId = navigationTraceContext?.trace_id;
+
+    expect(navigationTraceContext?.links).toEqual([
+      {
+        trace_id: metaTagTraceId,
+        span_id: pageloadTraceContext?.span_id,
+        sampled: true,
+        attributes: {
+          [SENTRY_LINK_TYPE]: 'previous_trace',
+        },
+      },
+    ]);
+
+    expect(navigationTraceId).not.toEqual(metaTagTraceId);
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/negatively-sampled/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/negatively-sampled/init.js
similarity index 88%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/negatively-sampled/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/negatively-sampled/init.js
index 778092cf026b..79ca4d68e8ba 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/negatively-sampled/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/negatively-sampled/init.js
@@ -3,9 +3,10 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   // We want to ignore redirects for this test
-  integrations: [Sentry.browserTracingIntegration({ detectRedirects: false }), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration({ detectRedirects: false })],
   tracesSampler: ctx => {
     if (ctx.attributes['sentry.origin'] === 'auto.pageload.browser') {
       return 0;
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/negatively-sampled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/negatively-sampled/test.ts
new file mode 100644
index 000000000000..894fe0d5929a
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/negatively-sampled/test.ts
@@ -0,0 +1,42 @@
+import { expect } from '@playwright/test';
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { sentryTest } from '../../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+
+sentryTest('includes a span link to a previously negatively sampled span', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await sentryTest.step('Initial pageload', async () => {
+    // No event to check for an event here because this pageload span is sampled negatively!
+    await page.goto(url);
+  });
+
+  await sentryTest.step('Navigation', async () => {
+    const navigationRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
+    await page.goto(`${url}#foo`);
+    const navigationEvent = envelopeRequestParser(await navigationRequestPromise);
+    const navigationTraceContext = navigationEvent.contexts?.trace;
+
+    expect(navigationTraceContext?.op).toBe('navigation');
+    expect(navigationTraceContext?.links).toEqual([
+      {
+        trace_id: expect.stringMatching(/[a-f\d]{32}/),
+        span_id: expect.stringMatching(/[a-f\d]{16}/),
+        sampled: false,
+        attributes: {
+          [SENTRY_LINK_TYPE]: 'previous_trace',
+        },
+      },
+    ]);
+
+    expect(navigationTraceContext?.data).toMatchObject({
+      'sentry.previous_trace': expect.stringMatching(/[a-f\d]{32}-[a-f\d]{16}-0/),
+    });
+
+    expect(navigationTraceContext?.trace_id).not.toEqual(navigationTraceContext?.links![0].trace_id);
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/session-storage/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/session-storage/init.js
new file mode 100644
index 000000000000..9b88e489ae07
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/session-storage/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration({ linkPreviousTrace: 'session-storage' })],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/session-storage/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/session-storage/test.ts
new file mode 100644
index 000000000000..f7e0d288de5b
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/session-storage/test.ts
@@ -0,0 +1,39 @@
+import { expect } from '@playwright/test';
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { sentryTest } from '../../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+
+sentryTest('adds link between hard page reloads when opting into sessionStorage', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const pageload1TraceContext = await sentryTest.step('First pageload', async () => {
+    const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    await page.goto(url);
+    const pageload1Event = envelopeRequestParser(await pageloadRequestPromise);
+    const pageload1TraceContext = pageload1Event.contexts?.trace;
+    expect(pageload1TraceContext).toBeDefined();
+    expect(pageload1TraceContext?.links).toBeUndefined();
+    return pageload1TraceContext;
+  });
+
+  const pageload2Event = await sentryTest.step('Hard page reload', async () => {
+    const pageload2RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    await page.reload();
+    return envelopeRequestParser(await pageload2RequestPromise);
+  });
+
+  expect(pageload2Event.contexts?.trace?.links).toEqual([
+    {
+      trace_id: pageload1TraceContext?.trace_id,
+      span_id: pageload1TraceContext?.span_id,
+      sampled: true,
+      attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' },
+    },
+  ]);
+
+  expect(pageload1TraceContext?.trace_id).not.toEqual(pageload2Event.contexts?.trace?.trace_id);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/default/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/default/test.ts
deleted file mode 100644
index 3ef7ddefca6d..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/default/test.ts
+++ /dev/null
@@ -1,154 +0,0 @@
-import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
-import { expect } from '@playwright/test';
-import { extractTraceparentData, parseBaggageHeader } from '@sentry/core';
-import { sentryTest } from '../../../../../../utils/fixtures';
-import { shouldSkipTracingTest, waitForTracingHeadersOnUrl } from '../../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpanEnvelope } from '../../../../../../utils/spanUtils';
-
-sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
-  sentryTest('continues sampling decision from initial pageload span', async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const { pageloadSpan, pageloadSampleRand } = await sentryTest.step('Initial pageload', async () => {
-      const pageloadEnvelopePromise = waitForStreamedSpanEnvelope(
-        page,
-        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
-      );
-      await page.goto(url);
-
-      const envelope = await pageloadEnvelopePromise;
-      const pageloadSampleRand = Number(envelope[0].trace?.sample_rand);
-      const pageloadSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
-
-      expect(pageloadSpan.attributes['sentry.sample_rate']?.value).toBe(1);
-      expect(Number.isNaN(pageloadSampleRand)).toBe(false);
-      expect(pageloadSampleRand).toBeGreaterThanOrEqual(0);
-      expect(pageloadSampleRand).toBeLessThanOrEqual(1);
-
-      return { pageloadSpan, pageloadSampleRand };
-    });
-
-    const customTraceSpan = await sentryTest.step('Custom trace', async () => {
-      const customEnvelopePromise = waitForStreamedSpanEnvelope(
-        page,
-        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'custom'),
-      );
-      await page.locator('#btn1').click();
-      const envelope = await customEnvelopePromise;
-      const span = envelope[1][0][1].items.find(s => getSpanOp(s) === 'custom')!;
-
-      expect(span.trace_id).not.toEqual(pageloadSpan.trace_id);
-      // although we "continue the trace" from pageload, this is actually a root span,
-      // so there must not be a parent span id
-      expect(span.parent_span_id).toBeUndefined();
-
-      expect(Number(envelope[0].trace?.sample_rand)).toBe(pageloadSampleRand);
-
-      return span;
-    });
-
-    await sentryTest.step('Navigation', async () => {
-      const navigationEnvelopePromise = waitForStreamedSpanEnvelope(
-        page,
-        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
-      );
-      await page.goto(`${url}#foo`);
-      const envelope = await navigationEnvelopePromise;
-      const navSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'navigation')!;
-
-      expect(navSpan.trace_id).not.toEqual(customTraceSpan.trace_id);
-      expect(navSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
-
-      expect(navSpan.links).toEqual([
-        {
-          trace_id: customTraceSpan.trace_id,
-          span_id: customTraceSpan.span_id,
-          sampled: true,
-          attributes: {
-            [SENTRY_LINK_TYPE]: {
-              type: 'string',
-              value: 'previous_trace',
-            },
-          },
-        },
-      ]);
-      expect(navSpan.parent_span_id).toBeUndefined();
-
-      expect(Number(envelope[0].trace?.sample_rand)).toBe(pageloadSampleRand);
-    });
-  });
-
-  sentryTest('Propagates continued sampling decision to outgoing requests', async ({ page, getLocalTestUrl }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const { pageloadSpan, pageloadSampleRand } = await sentryTest.step('Initial pageload', async () => {
-      const pageloadEnvelopePromise = waitForStreamedSpanEnvelope(
-        page,
-        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
-      );
-      await page.goto(url);
-
-      const envelope = await pageloadEnvelopePromise;
-      const pageloadSampleRand = Number(envelope[0].trace?.sample_rand);
-
-      expect(Number(envelope[0].trace?.sample_rand)).toBe(pageloadSampleRand);
-      expect(pageloadSampleRand).toBeGreaterThanOrEqual(0);
-      expect(pageloadSampleRand).toBeLessThanOrEqual(1);
-      expect(Number.isNaN(pageloadSampleRand)).toBe(false);
-
-      const pageloadSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
-
-      expect(pageloadSpan.attributes['sentry.sample_rate']?.value).toBe(1);
-
-      return { pageloadSpan, pageloadSampleRand };
-    });
-
-    await sentryTest.step('Make fetch request', async () => {
-      const fetchEnvelopePromise = waitForStreamedSpanEnvelope(
-        page,
-        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'custom'),
-      );
-      const tracingHeadersPromise = waitForTracingHeadersOnUrl(page, 'http://sentry-test-external.io');
-
-      await page.locator('#btn2').click();
-
-      const { baggage, sentryTrace } = await tracingHeadersPromise;
-      const fetchEnvelope = await fetchEnvelopePromise;
-
-      const fetchTraceSampleRand = Number(fetchEnvelope[0].trace?.sample_rand);
-      const fetchTraceSpans = fetchEnvelope[1][0][1].items;
-      const fetchTraceSpan = fetchTraceSpans.find(s => getSpanOp(s) === 'custom')!;
-      const httpClientSpan = fetchTraceSpans.find(s => getSpanOp(s) === 'http.client');
-
-      expect(fetchTraceSampleRand).toBe(pageloadSampleRand);
-
-      expect(fetchTraceSpan.attributes['sentry.sample_rate']?.value).toEqual(
-        pageloadSpan.attributes['sentry.sample_rate']?.value,
-      );
-      expect(fetchTraceSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
-
-      expect(sentryTrace).toBeDefined();
-      expect(baggage).toBeDefined();
-
-      expect(extractTraceparentData(sentryTrace)).toEqual({
-        traceId: fetchTraceSpan.trace_id,
-        parentSpanId: httpClientSpan?.span_id,
-        parentSampled: true,
-      });
-
-      expect(parseBaggageHeader(baggage)).toEqual({
-        'sentry-environment': 'production',
-        'sentry-public_key': 'public',
-        'sentry-sample_rand': `${pageloadSampleRand}`,
-        'sentry-sample_rate': '1',
-        'sentry-sampled': 'true',
-        'sentry-trace_id': fetchTraceSpan.trace_id,
-        'sentry-transaction': 'custom root span 2',
-      });
-    });
-  });
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta/test.ts
deleted file mode 100644
index 2657bed50d61..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta/test.ts
+++ /dev/null
@@ -1,171 +0,0 @@
-import { expect } from '@playwright/test';
-import {
-  extractTraceparentData,
-  parseBaggageHeader,
-  SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE,
-} from '@sentry/core';
-import { sentryTest } from '../../../../../../utils/fixtures';
-import { shouldSkipTracingTest, waitForTracingHeadersOnUrl } from '../../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpanEnvelope } from '../../../../../../utils/spanUtils';
-
-const metaTagSampleRand = 0.051121;
-const metaTagSampleRate = 0.2;
-
-sentryTest.describe('When `consistentTraceSampling` is `true` and page contains <meta> tags', () => {
-  sentryTest('Continues sampling decision across all traces from meta tag', async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const pageloadSpan = await sentryTest.step('Initial pageload', async () => {
-      const pageloadEnvelopePromise = waitForStreamedSpanEnvelope(
-        page,
-        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
-      );
-
-      await page.goto(url);
-
-      const envelope = await pageloadEnvelopePromise;
-      const span = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
-
-      expect(Number(envelope[0].trace?.sample_rand)).toBe(metaTagSampleRand);
-      expect(Number(envelope[0].trace?.sample_rate)).toBe(metaTagSampleRate);
-
-      // since the local sample rate was not applied, the sample rate attribute shouldn't be set
-      expect(span.attributes['sentry.sample_rate']).toBeUndefined();
-      expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBeUndefined();
-
-      return span;
-    });
-
-    const customTraceSpan = await sentryTest.step('Custom trace', async () => {
-      const customEnvelopePromise = waitForStreamedSpanEnvelope(
-        page,
-        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'custom'),
-      );
-
-      await page.locator('#btn1').click();
-
-      const envelope = await customEnvelopePromise;
-      const span = envelope[1][0][1].items.find(s => getSpanOp(s) === 'custom')!;
-
-      expect(span.trace_id).not.toEqual(pageloadSpan.trace_id);
-      expect(span.parent_span_id).toBeUndefined();
-
-      expect(Number(envelope[0].trace?.sample_rand)).toBe(metaTagSampleRand);
-      expect(Number(envelope[0].trace?.sample_rate)).toBe(metaTagSampleRate);
-      expect(envelope[0].trace?.sampled).toBe('true');
-
-      // since the local sample rate was not applied, the sample rate attribute shouldn't be set
-      expect(span.attributes['sentry.sample_rate']).toBeUndefined();
-
-      // but we need to set this attribute to still be able to correctly add the sample rate to the DSC (checked above in trace header)
-      expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]?.value).toBe(metaTagSampleRate);
-
-      return span;
-    });
-
-    await sentryTest.step('Navigation', async () => {
-      const navigationEnvelopePromise = waitForStreamedSpanEnvelope(
-        page,
-        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
-      );
-
-      await page.goto(`${url}#foo`);
-
-      const envelope = await navigationEnvelopePromise;
-      const navSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'navigation')!;
-
-      expect(navSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
-      expect(navSpan.trace_id).not.toEqual(customTraceSpan.trace_id);
-
-      expect(navSpan.parent_span_id).toBeUndefined();
-
-      expect(Number(envelope[0].trace?.sample_rand)).toEqual(metaTagSampleRand);
-      expect(Number(envelope[0].trace?.sample_rate)).toEqual(metaTagSampleRate);
-      expect(envelope[0].trace?.sampled).toEqual('true');
-
-      // since the local sample rate was not applied, the sample rate attribute shouldn't be set
-      expect(navSpan.attributes['sentry.sample_rate']).toBeUndefined();
-
-      // but we need to set this attribute to still be able to correctly add the sample rate to the DSC (checked above in trace header)
-      expect(navSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]?.value).toBe(metaTagSampleRate);
-    });
-  });
-
-  sentryTest(
-    'Propagates continued <meta> tag sampling decision to outgoing requests',
-    async ({ page, getLocalTestUrl }) => {
-      sentryTest.skip(shouldSkipTracingTest());
-
-      const url = await getLocalTestUrl({ testDir: __dirname });
-
-      const pageloadSpan = await sentryTest.step('Initial pageload', async () => {
-        const pageloadEnvelopePromise = waitForStreamedSpanEnvelope(
-          page,
-          env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
-        );
-
-        await page.goto(url);
-
-        const envelope = await pageloadEnvelopePromise;
-        const span = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
-
-        expect(Number(envelope[0].trace?.sample_rand)).toBe(metaTagSampleRand);
-        expect(Number(envelope[0].trace?.sample_rate)).toBe(metaTagSampleRate);
-
-        // since the local sample rate was not applied, the sample rate attribute shouldn't be set
-        expect(span.attributes['sentry.sample_rate']).toBeUndefined();
-        expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBeUndefined();
-
-        return span;
-      });
-
-      await sentryTest.step('Make fetch request', async () => {
-        const fetchEnvelopePromise = waitForStreamedSpanEnvelope(
-          page,
-          env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'custom'),
-        );
-        const tracingHeadersPromise = waitForTracingHeadersOnUrl(page, 'http://sentry-test-external.io');
-
-        await page.locator('#btn2').click();
-
-        const { baggage, sentryTrace } = await tracingHeadersPromise;
-        const fetchEnvelope = await fetchEnvelopePromise;
-
-        const fetchTraceSampleRand = Number(fetchEnvelope[0].trace?.sample_rand);
-        const fetchTraceSpans = fetchEnvelope[1][0][1].items;
-        const fetchTraceSpan = fetchTraceSpans.find(s => getSpanOp(s) === 'custom')!;
-        const httpClientSpan = fetchTraceSpans.find(s => getSpanOp(s) === 'http.client');
-
-        expect(fetchTraceSampleRand).toEqual(metaTagSampleRand);
-
-        expect(fetchTraceSpan.attributes['sentry.sample_rate']).toBeUndefined();
-        expect(fetchTraceSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]?.value).toBe(
-          metaTagSampleRate,
-        );
-
-        expect(fetchTraceSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
-
-        expect(sentryTrace).toBeDefined();
-        expect(baggage).toBeDefined();
-
-        expect(extractTraceparentData(sentryTrace)).toEqual({
-          traceId: fetchTraceSpan.trace_id,
-          parentSpanId: httpClientSpan?.span_id,
-          parentSampled: true,
-        });
-
-        expect(parseBaggageHeader(baggage)).toEqual({
-          'sentry-environment': 'production',
-          'sentry-public_key': 'public',
-          'sentry-sample_rand': `${metaTagSampleRand}`,
-          'sentry-sample_rate': `${metaTagSampleRate}`,
-          'sentry-sampled': 'true',
-          'sentry-trace_id': fetchTraceSpan.trace_id,
-          'sentry-transaction': 'custom root span 2',
-        });
-      });
-    },
-  );
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/custom-trace/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/custom-trace/test.ts
deleted file mode 100644
index 7bb7a5546910..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/custom-trace/test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { expect } from '@playwright/test';
-import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
-import { sentryTest } from '../../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
-
-sentryTest('manually started custom traces are linked correctly in the chain', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const pageloadSpan = await sentryTest.step('Initial pageload', async () => {
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-    await page.goto(url);
-    return pageloadSpanPromise;
-  });
-
-  const customTraceSpan = await sentryTest.step('Custom trace', async () => {
-    const customSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'custom');
-    await page.locator('#btn1').click();
-    const span = await customSpanPromise;
-
-    expect(span.trace_id).not.toEqual(pageloadSpan.trace_id);
-    expect(span.links).toEqual([
-      {
-        trace_id: pageloadSpan.trace_id,
-        span_id: pageloadSpan.span_id,
-        sampled: true,
-        attributes: {
-          [SENTRY_LINK_TYPE]: {
-            type: 'string',
-            value: 'previous_trace',
-          },
-        },
-      },
-    ]);
-
-    return span;
-  });
-
-  await sentryTest.step('Navigation', async () => {
-    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
-    await page.goto(`${url}#foo`);
-    const navSpan = await navigationSpanPromise;
-
-    expect(navSpan.trace_id).not.toEqual(customTraceSpan.trace_id);
-    expect(navSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
-
-    expect(navSpan.links).toEqual([
-      {
-        trace_id: customTraceSpan.trace_id,
-        span_id: customTraceSpan.span_id,
-        sampled: true,
-        attributes: {
-          [SENTRY_LINK_TYPE]: {
-            type: 'string',
-            value: 'previous_trace',
-          },
-        },
-      },
-    ]);
-  });
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/default/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/default/test.ts
deleted file mode 100644
index 5fb19844a3ce..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/default/test.ts
+++ /dev/null
@@ -1,95 +0,0 @@
-import { expect } from '@playwright/test';
-import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
-import { sentryTest } from '../../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
-
-sentryTest("navigation spans link back to previous trace's root span", async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-  await page.goto(url);
-  const pageloadSpan = await pageloadSpanPromise;
-
-  const navigation1SpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
-  await page.goto(`${url}#foo`);
-  const navigation1Span = await navigation1SpanPromise;
-
-  const navigation2SpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
-  await page.goto(`${url}#bar`);
-  const navigation2Span = await navigation2SpanPromise;
-
-  const pageloadTraceId = pageloadSpan.trace_id;
-  const navigation1TraceId = navigation1Span.trace_id;
-  const navigation2TraceId = navigation2Span.trace_id;
-
-  expect(pageloadSpan.links).toBeUndefined();
-
-  expect(navigation1Span.links).toEqual([
-    {
-      trace_id: pageloadTraceId,
-      span_id: pageloadSpan.span_id,
-      sampled: true,
-      attributes: {
-        [SENTRY_LINK_TYPE]: {
-          type: 'string',
-          value: 'previous_trace',
-        },
-      },
-    },
-  ]);
-
-  expect(navigation1Span.attributes['sentry.previous_trace']).toEqual({
-    type: 'string',
-    value: `${pageloadTraceId}-${pageloadSpan.span_id}-1`,
-  });
-
-  expect(navigation2Span.links).toEqual([
-    {
-      trace_id: navigation1TraceId,
-      span_id: navigation1Span.span_id,
-      sampled: true,
-      attributes: {
-        [SENTRY_LINK_TYPE]: {
-          type: 'string',
-          value: 'previous_trace',
-        },
-      },
-    },
-  ]);
-
-  expect(navigation2Span.attributes['sentry.previous_trace']).toEqual({
-    type: 'string',
-    value: `${navigation1TraceId}-${navigation1Span.span_id}-1`,
-  });
-
-  expect(pageloadTraceId).not.toEqual(navigation1TraceId);
-  expect(navigation1TraceId).not.toEqual(navigation2TraceId);
-  expect(pageloadTraceId).not.toEqual(navigation2TraceId);
-});
-
-sentryTest("doesn't link between hard page reloads by default", async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  await sentryTest.step('First pageload', async () => {
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-    await page.goto(url);
-    const pageload1Span = await pageloadSpanPromise;
-
-    expect(pageload1Span).toBeDefined();
-    expect(pageload1Span.links).toBeUndefined();
-  });
-
-  await sentryTest.step('Second pageload', async () => {
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-    await page.reload();
-    const pageload2Span = await pageloadSpanPromise;
-
-    expect(pageload2Span).toBeDefined();
-    expect(pageload2Span.links).toBeUndefined();
-  });
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/interaction-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/interaction-spans/test.ts
deleted file mode 100644
index bfc974fc953a..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/interaction-spans/test.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import { expect } from '@playwright/test';
-import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
-import { sentryTest } from '../../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
-
-/*
-  This is quite peculiar behavior but it's a result of the route-based trace lifetime.
-  Once we shortened trace lifetime, this whole scenario will change as the interaction
-  spans will be their own trace. So most likely, we can replace this test with a new one
-  that covers the new default behavior.
-*/
-sentryTest(
-  'only the first root spans in the trace link back to the previous trace',
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const pageloadSpan = await sentryTest.step('Initial pageload', async () => {
-      const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-      await page.goto(url);
-      const span = await pageloadSpanPromise;
-
-      expect(span).toBeDefined();
-      expect(span.links).toBeUndefined();
-
-      return span;
-    });
-
-    await sentryTest.step('Click Before navigation', async () => {
-      const interactionSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.action.click');
-      await page.click('#btn');
-      const interactionSpan = await interactionSpanPromise;
-
-      // sanity check: route-based trace lifetime means the trace_id should be the same
-      expect(interactionSpan.trace_id).toBe(pageloadSpan.trace_id);
-
-      // no links yet as previous root span belonged to same trace
-      expect(interactionSpan.links).toBeUndefined();
-    });
-
-    const navigationSpan = await sentryTest.step('Navigation', async () => {
-      const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
-      await page.goto(`${url}#foo`);
-      const span = await navigationSpanPromise;
-
-      expect(getSpanOp(span)).toBe('navigation');
-      expect(span.links).toEqual([
-        {
-          trace_id: pageloadSpan.trace_id,
-          span_id: pageloadSpan.span_id,
-          sampled: true,
-          attributes: {
-            [SENTRY_LINK_TYPE]: {
-              type: 'string',
-              value: 'previous_trace',
-            },
-          },
-        },
-      ]);
-
-      expect(span.trace_id).not.toEqual(span.links![0].trace_id);
-      return span;
-    });
-
-    await sentryTest.step('Click After navigation', async () => {
-      const interactionSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.action.click');
-      await page.click('#btn');
-      const interactionSpan = await interactionSpanPromise;
-
-      // sanity check: route-based trace lifetime means the trace_id should be the same
-      expect(interactionSpan.trace_id).toBe(navigationSpan.trace_id);
-
-      // since this is the second root span in the trace, it doesn't link back to the previous trace
-      expect(interactionSpan.links).toBeUndefined();
-    });
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/meta/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/meta/test.ts
deleted file mode 100644
index 732547954091..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/meta/test.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { expect } from '@playwright/test';
-import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
-import { sentryTest } from '../../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
-
-sentryTest(
-  "links back to previous trace's local root span if continued from meta tags",
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const metaTagTraceId = '12345678901234567890123456789012';
-
-    const pageloadSpan = await sentryTest.step('Initial pageload', async () => {
-      const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-      await page.goto(url);
-      const span = await pageloadSpanPromise;
-
-      // sanity check
-      expect(span.trace_id).toBe(metaTagTraceId);
-      expect(span.links).toBeUndefined();
-
-      return span;
-    });
-
-    const navigationSpan = await sentryTest.step('Navigation', async () => {
-      const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
-      await page.goto(`${url}#foo`);
-      return navigationSpanPromise;
-    });
-
-    expect(navigationSpan.links).toEqual([
-      {
-        trace_id: metaTagTraceId,
-        span_id: pageloadSpan.span_id,
-        sampled: true,
-        attributes: {
-          [SENTRY_LINK_TYPE]: {
-            type: 'string',
-            value: 'previous_trace',
-          },
-        },
-      },
-    ]);
-
-    expect(navigationSpan.trace_id).not.toEqual(metaTagTraceId);
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/negatively-sampled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/negatively-sampled/test.ts
deleted file mode 100644
index 4bc05cb95737..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/negatively-sampled/test.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { expect } from '@playwright/test';
-import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
-import { sentryTest } from '../../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
-
-sentryTest('includes a span link to a previously negatively sampled span', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  await sentryTest.step('Initial pageload', async () => {
-    // No span envelope expected here because this pageload span is sampled negatively!
-    await page.goto(url);
-  });
-
-  await sentryTest.step('Navigation', async () => {
-    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
-    await page.goto(`${url}#foo`);
-    const navigationSpan = await navigationSpanPromise;
-
-    expect(getSpanOp(navigationSpan)).toBe('navigation');
-    expect(navigationSpan.links).toEqual([
-      {
-        trace_id: expect.stringMatching(/[a-f\d]{32}/),
-        span_id: expect.stringMatching(/[a-f\d]{16}/),
-        sampled: false,
-        attributes: {
-          [SENTRY_LINK_TYPE]: {
-            type: 'string',
-            value: 'previous_trace',
-          },
-        },
-      },
-    ]);
-
-    expect(navigationSpan.attributes['sentry.previous_trace']).toEqual({
-      type: 'string',
-      value: expect.stringMatching(/[a-f\d]{32}-[a-f\d]{16}-0/),
-    });
-
-    expect(navigationSpan.trace_id).not.toEqual(navigationSpan.links![0].trace_id);
-  });
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/session-storage/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/session-storage/test.ts
deleted file mode 100644
index 81d1d31e10e3..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/session-storage/test.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { expect } from '@playwright/test';
-import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
-import { sentryTest } from '../../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
-
-sentryTest('adds link between hard page reloads when opting into sessionStorage', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const pageload1Span = await sentryTest.step('First pageload', async () => {
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-    await page.goto(url);
-    const span = await pageloadSpanPromise;
-    expect(span).toBeDefined();
-    expect(span.links).toBeUndefined();
-    return span;
-  });
-
-  const pageload2Span = await sentryTest.step('Hard page reload', async () => {
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-    await page.reload();
-    return pageloadSpanPromise;
-  });
-
-  expect(pageload2Span.links).toEqual([
-    {
-      trace_id: pageload1Span.trace_id,
-      span_id: pageload1Span.span_id,
-      sampled: true,
-      attributes: {
-        [SENTRY_LINK_TYPE]: {
-          type: 'string',
-          value: 'previous_trace',
-        },
-      },
-    },
-  ]);
-
-  expect(pageload1Span.trace_id).not.toEqual(pageload2Span.trace_id);
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/init.js
index 04a299421004..2497d6da6b84 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/test.ts
index 4d13371bc693..28c0b0ea1796 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/test.ts
@@ -1,136 +1,140 @@
 import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import { extractTraceparentData, parseBaggageHeader, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, extractTraceparentData, parseBaggageHeader } from '@sentry/core';
 import { sentryTest } from '../../../../../../utils/fixtures';
-import {
-  eventAndTraceHeaderRequestParser,
-  shouldSkipTracingTest,
-  waitForTracingHeadersOnUrl,
-  waitForTransactionRequest,
-} from '../../../../../../utils/helpers';
+import { shouldSkipTracingTest, waitForTracingHeadersOnUrl } from '../../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpanEnvelope } from '../../../../../../utils/spanUtils';
 
 sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
-  sentryTest('Continues sampling decision from initial pageload', async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+  sentryTest('continues sampling decision from initial pageload span', async ({ getLocalTestUrl, page }) => {
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const { pageloadTraceContext, pageloadSampleRand } = await sentryTest.step('Initial pageload', async () => {
-      const pageloadRequestPromise = waitForTransactionRequest(page, evt => {
-        return evt.contexts?.trace?.op === 'pageload';
-      });
+    const { pageloadSpan, pageloadSampleRand } = await sentryTest.step('Initial pageload', async () => {
+      const pageloadEnvelopePromise = waitForStreamedSpanEnvelope(
+        page,
+        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
+      );
       await page.goto(url);
 
-      const res = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
-      const pageloadSampleRand = Number(res[1]?.sample_rand);
-      const pageloadTraceContext = res[0].contexts?.trace;
+      const envelope = await pageloadEnvelopePromise;
+      const pageloadSampleRand = Number(envelope[0].trace?.sample_rand);
+      const pageloadSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
 
-      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
+      expect(pageloadSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]?.value).toBe(1);
+      expect(Number.isNaN(pageloadSampleRand)).toBe(false);
       expect(pageloadSampleRand).toBeGreaterThanOrEqual(0);
+      expect(pageloadSampleRand).toBeLessThanOrEqual(1);
 
-      return { pageloadTraceContext: res[0].contexts?.trace, pageloadSampleRand };
+      return { pageloadSpan, pageloadSampleRand };
     });
 
-    const customTraceContext = await sentryTest.step('Custom trace', async () => {
-      const customTrace1RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
-      await page.locator('#btn1').click();
-      const [customTrace1Event, customTraceTraceHeader] = eventAndTraceHeaderRequestParser(
-        await customTrace1RequestPromise,
+    const customTraceSpan = await sentryTest.step('Custom trace', async () => {
+      const customEnvelopePromise = waitForStreamedSpanEnvelope(
+        page,
+        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'custom'),
       );
+      await page.locator('#btn1').click();
+      const envelope = await customEnvelopePromise;
+      const span = envelope[1][0][1].items.find(s => getSpanOp(s) === 'custom')!;
 
-      const customTraceContext = customTrace1Event.contexts?.trace;
-
-      expect(customTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+      expect(span.trace_id).not.toEqual(pageloadSpan.trace_id);
       // although we "continue the trace" from pageload, this is actually a root span,
       // so there must not be a parent span id
-      expect(customTraceContext?.parent_span_id).toBeUndefined();
+      expect(span.parent_span_id).toBeUndefined();
 
-      expect(pageloadSampleRand).toEqual(Number(customTraceTraceHeader?.sample_rand));
+      expect(Number(envelope[0].trace?.sample_rand)).toBe(pageloadSampleRand);
 
-      return customTraceContext;
+      return span;
     });
 
     await sentryTest.step('Navigation', async () => {
-      const navigation1RequestPromise = waitForTransactionRequest(
+      const navigationEnvelopePromise = waitForStreamedSpanEnvelope(
         page,
-        evt => evt.contexts?.trace?.op === 'navigation',
+        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
       );
       await page.goto(`${url}#foo`);
-      const [navigationEvent, navigationTraceHeader] = eventAndTraceHeaderRequestParser(
-        await navigation1RequestPromise,
-      );
-      const navTraceContext = navigationEvent.contexts?.trace;
+      const envelope = await navigationEnvelopePromise;
+      const navSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'navigation')!;
 
-      expect(navTraceContext?.trace_id).not.toEqual(customTraceContext?.trace_id);
-      expect(navTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+      expect(navSpan.trace_id).not.toEqual(customTraceSpan.trace_id);
+      expect(navSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
 
-      expect(navTraceContext?.links).toEqual([
+      expect(navSpan.links).toEqual([
         {
-          trace_id: customTraceContext?.trace_id,
-          span_id: customTraceContext?.span_id,
+          trace_id: customTraceSpan.trace_id,
+          span_id: customTraceSpan.span_id,
           sampled: true,
           attributes: {
-            [SENTRY_LINK_TYPE]: 'previous_trace',
+            [SENTRY_LINK_TYPE]: {
+              type: 'string',
+              value: 'previous_trace',
+            },
           },
         },
       ]);
-      expect(navTraceContext?.parent_span_id).toBeUndefined();
+      expect(navSpan.parent_span_id).toBeUndefined();
 
-      expect(pageloadSampleRand).toEqual(Number(navigationTraceHeader?.sample_rand));
+      expect(Number(envelope[0].trace?.sample_rand)).toBe(pageloadSampleRand);
     });
   });
 
   sentryTest('Propagates continued sampling decision to outgoing requests', async ({ page, getLocalTestUrl }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const { pageloadTraceContext, pageloadSampleRand } = await sentryTest.step('Initial pageload', async () => {
-      const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    const { pageloadSpan, pageloadSampleRand } = await sentryTest.step('Initial pageload', async () => {
+      const pageloadEnvelopePromise = waitForStreamedSpanEnvelope(
+        page,
+        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
+      );
       await page.goto(url);
 
-      const res = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
-      const pageloadSampleRand = Number(res[1]?.sample_rand);
+      const envelope = await pageloadEnvelopePromise;
+      const pageloadSampleRand = Number(envelope[0].trace?.sample_rand);
 
       expect(pageloadSampleRand).toBeGreaterThanOrEqual(0);
+      expect(pageloadSampleRand).toBeLessThanOrEqual(1);
+      expect(Number.isNaN(pageloadSampleRand)).toBe(false);
 
-      const pageloadTraceContext = res[0].contexts?.trace;
+      const pageloadSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
 
-      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
+      expect(pageloadSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]?.value).toBe(1);
 
-      return { pageloadTraceContext: pageloadTraceContext, pageloadSampleRand };
+      return { pageloadSpan, pageloadSampleRand };
     });
 
     await sentryTest.step('Make fetch request', async () => {
-      const fetchTracePromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+      const fetchEnvelopePromise = waitForStreamedSpanEnvelope(
+        page,
+        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'custom'),
+      );
       const tracingHeadersPromise = waitForTracingHeadersOnUrl(page, 'http://sentry-test-external.io');
 
       await page.locator('#btn2').click();
 
       const { baggage, sentryTrace } = await tracingHeadersPromise;
+      const fetchEnvelope = await fetchEnvelopePromise;
 
-      const [fetchTraceEvent, fetchTraceTraceHeader] = eventAndTraceHeaderRequestParser(await fetchTracePromise);
-
-      const fetchTraceSampleRand = Number(fetchTraceTraceHeader?.sample_rand);
-      const fetchTraceTraceContext = fetchTraceEvent.contexts?.trace;
-      const httpClientSpan = fetchTraceEvent.spans?.find(span => span.op === 'http.client');
+      const fetchTraceSampleRand = Number(fetchEnvelope[0].trace?.sample_rand);
+      const fetchTraceSpans = fetchEnvelope[1][0][1].items;
+      const fetchTraceSpan = fetchTraceSpans.find(s => getSpanOp(s) === 'custom')!;
+      const httpClientSpan = fetchTraceSpans.find(s => getSpanOp(s) === 'http.client');
 
-      expect(fetchTraceSampleRand).toEqual(pageloadSampleRand);
+      expect(fetchTraceSampleRand).toBe(pageloadSampleRand);
 
-      expect(fetchTraceTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toEqual(
-        pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE],
+      expect(fetchTraceSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]?.value).toEqual(
+        pageloadSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]?.value,
       );
-      expect(fetchTraceTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+      expect(fetchTraceSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
 
       expect(sentryTrace).toBeDefined();
       expect(baggage).toBeDefined();
 
       expect(extractTraceparentData(sentryTrace)).toEqual({
-        traceId: fetchTraceTraceContext?.trace_id,
+        traceId: fetchTraceSpan.trace_id,
         parentSpanId: httpClientSpan?.span_id,
         parentSampled: true,
       });
@@ -141,7 +145,7 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
         'sentry-sample_rand': `${pageloadSampleRand}`,
         'sentry-sample_rate': '1',
         'sentry-sampled': 'true',
-        'sentry-trace_id': fetchTraceTraceContext?.trace_id,
+        'sentry-trace_id': fetchTraceSpan.trace_id,
         'sentry-transaction': 'custom root span 2',
       });
     });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/init.js
index 05c4ec8db85a..4cb0d3389fc2 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/test.ts
index c8faee2f5feb..34401725079c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/test.ts
@@ -1,15 +1,15 @@
 import { expect } from '@playwright/test';
-import type { ClientReport } from '@sentry/core';
+import type { ClientReport, SerializedStreamedSpan } from '@sentry/core';
 import { extractTraceparentData, parseBaggageHeader } from '@sentry/core';
 import { sentryTest } from '../../../../../../utils/fixtures';
 import {
   envelopeRequestParser,
-  getMultipleSentryEnvelopeRequests,
   hidePage,
   shouldSkipTracingTest,
   waitForClientReportRequest,
   waitForTracingHeadersOnUrl,
 } from '../../../../../../utils/helpers';
+import { observeStreamedSpan } from '../../../../../../utils/spanUtils';
 
 const metaTagSampleRand = 0.9;
 const metaTagSampleRate = 0.2;
@@ -19,34 +19,31 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
   sentryTest(
     'Continues negative sampling decision from meta tag across all traces and downstream propagations',
     async ({ getLocalTestUrl, page }) => {
-      if (shouldSkipTracingTest()) {
-        sentryTest.skip();
-      }
+      sentryTest.skip(shouldSkipTracingTest());
 
       const url = await getLocalTestUrl({ testDir: __dirname });
 
-      let txnsReceived = 0;
-      // @ts-expect-error - no need to return something valid here
-      getMultipleSentryEnvelopeRequests<Event>(page, 1, { envelopeType: 'transaction' }, () => {
-        ++txnsReceived;
-        return {};
+      const spansReceived: SerializedStreamedSpan[] = [];
+      observeStreamedSpan(page, span => {
+        spansReceived.push(span);
+        return false;
       });
 
       const clientReportPromise = waitForClientReportRequest(page);
 
       await sentryTest.step('Initial pageload', async () => {
         await page.goto(url);
-        expect(txnsReceived).toEqual(0);
+        expect(spansReceived).toHaveLength(0);
       });
 
       await sentryTest.step('Custom instrumented button click', async () => {
         await page.locator('#btn1').click();
-        expect(txnsReceived).toEqual(0);
+        expect(spansReceived).toHaveLength(0);
       });
 
       await sentryTest.step('Navigation', async () => {
         await page.goto(`${url}#foo`);
-        expect(txnsReceived).toEqual(0);
+        expect(spansReceived).toHaveLength(0);
       });
 
       await sentryTest.step('Make fetch request', async () => {
@@ -73,6 +70,8 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
           'sentry-trace_id': expect.not.stringContaining(metaTagTraceId),
           'sentry-transaction': 'custom root span 2',
         });
+
+        expect(spansReceived).toHaveLength(0);
       });
 
       await sentryTest.step('Client report', async () => {
@@ -82,19 +81,18 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
           timestamp: expect.any(Number),
           discarded_events: [
             {
-              category: 'transaction',
-              quantity: 4,
+              category: 'span',
+              quantity: expect.any(Number),
               reason: 'sample_rate',
             },
           ],
         });
+        // exact number depends on performance observer emissions
+        expect(clientReport.discarded_events[0].quantity).toBeGreaterThanOrEqual(10);
       });
 
-      await sentryTest.step('Wait for transactions to be discarded', async () => {
-        // give it a little longer just in case a txn is pending to be sent
-        await page.waitForTimeout(1000);
-        expect(txnsReceived).toEqual(0);
-      });
+      await page.evaluate(() => (window as any).Sentry.flush());
+      expect(spansReceived).toHaveLength(0);
     },
   );
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-precedence/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-precedence/init.js
index fbf897d47eab..c758d9875be1 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-precedence/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-precedence/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-precedence/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-precedence/test.ts
index 3dab9594ba7c..cd64596f9bfd 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-precedence/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-precedence/test.ts
@@ -4,13 +4,12 @@ import { extractTraceparentData, parseBaggageHeader } from '@sentry/core';
 import { sentryTest } from '../../../../../../utils/fixtures';
 import {
   envelopeRequestParser,
-  eventAndTraceHeaderRequestParser,
   hidePage,
   shouldSkipTracingTest,
   waitForClientReportRequest,
   waitForTracingHeadersOnUrl,
-  waitForTransactionRequest,
 } from '../../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpanEnvelope } from '../../../../../../utils/spanUtils';
 
 const metaTagSampleRand = 0.9;
 const metaTagSampleRate = 0.2;
@@ -21,16 +20,14 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
   sentryTest(
     'meta tag decision has precedence over sampling decision from previous trace in session storage',
     async ({ getLocalTestUrl, page }) => {
-      if (shouldSkipTracingTest()) {
-        sentryTest.skip();
-      }
+      sentryTest.skip(shouldSkipTracingTest());
 
       const url = await getLocalTestUrl({ testDir: __dirname });
 
       const clientReportPromise = waitForClientReportRequest(page);
 
       await sentryTest.step('Initial pageload', async () => {
-        // negative sampling decision -> no pageload txn
+        // negative sampling decision -> no pageload span
         await page.goto(url);
       });
 
@@ -71,37 +68,49 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
           timestamp: expect.any(Number),
           discarded_events: [
             {
-              category: 'transaction',
-              quantity: 2,
+              category: 'span',
+              quantity: expect.any(Number),
               reason: 'sample_rate',
             },
           ],
         });
+        // exact number depends on performance observer emissions
+        expect(clientReport.discarded_events[0].quantity).toBeGreaterThanOrEqual(3);
       });
 
       await sentryTest.step('Navigate to another page with meta tags', async () => {
-        const page1Pageload = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+        const page1PageloadEnvelopePromise = waitForStreamedSpanEnvelope(
+          page,
+          env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload' && s.trace_id === metaTagTraceIdPage1),
+        );
         await page.locator('a').click();
 
-        const [pageloadEvent, pageloadTraceHeader] = eventAndTraceHeaderRequestParser(await page1Pageload);
-        const pageloadTraceContext = pageloadEvent.contexts?.trace;
+        const envelope = await page1PageloadEnvelopePromise;
+        const pageloadSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
 
-        expect(Number(pageloadTraceHeader?.sample_rand)).toBe(0.12);
-        expect(Number(pageloadTraceHeader?.sample_rate)).toBe(0.2);
-        expect(pageloadTraceContext?.trace_id).toEqual(metaTagTraceIdPage1);
+        expect(Number(envelope[0].trace?.sample_rand)).toBe(0.12);
+        expect(Number(envelope[0].trace?.sample_rate)).toBe(0.2);
+        expect(pageloadSpan.trace_id).toEqual(metaTagTraceIdPage1);
       });
 
       await sentryTest.step('Navigate to another page without meta tags', async () => {
-        const page2Pageload = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+        const page2PageloadEnvelopePromise = waitForStreamedSpanEnvelope(
+          page,
+          env =>
+            !!env[1][0][1].items.find(
+              s =>
+                getSpanOp(s) === 'pageload' && s.trace_id !== metaTagTraceIdPage1 && s.trace_id !== metaTagTraceIdIndex,
+            ),
+        );
         await page.locator('a').click();
 
-        const [pageloadEvent, pageloadTraceHeader] = eventAndTraceHeaderRequestParser(await page2Pageload);
-        const pageloadTraceContext = pageloadEvent.contexts?.trace;
+        const envelope = await page2PageloadEnvelopePromise;
+        const pageloadSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
 
-        expect(Number(pageloadTraceHeader?.sample_rand)).toBe(0.12);
-        expect(Number(pageloadTraceHeader?.sample_rate)).toBe(0.2);
-        expect(pageloadTraceContext?.trace_id).not.toEqual(metaTagTraceIdPage1);
-        expect(pageloadTraceContext?.trace_id).not.toEqual(metaTagTraceIdIndex);
+        expect(Number(envelope[0].trace?.sample_rand)).toBe(0.12);
+        expect(Number(envelope[0].trace?.sample_rate)).toBe(0.2);
+        expect(pageloadSpan.trace_id).not.toEqual(metaTagTraceIdPage1);
+        expect(pageloadSpan.trace_id).not.toEqual(metaTagTraceIdIndex);
       });
     },
   );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta/init.js
index 61e2b2daa9ba..9aa63000ef2e 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta/test.ts
index ac2a865fb181..bc2eb2118a09 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta/test.ts
@@ -1,162 +1,158 @@
 import { expect } from '@playwright/test';
 import {
+  SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
   extractTraceparentData,
   parseBaggageHeader,
   SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE,
-  SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
 } from '@sentry/core';
 import { sentryTest } from '../../../../../../utils/fixtures';
-import {
-  eventAndTraceHeaderRequestParser,
-  shouldSkipTracingTest,
-  waitForTracingHeadersOnUrl,
-  waitForTransactionRequest,
-} from '../../../../../../utils/helpers';
+import { shouldSkipTracingTest, waitForTracingHeadersOnUrl } from '../../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpanEnvelope } from '../../../../../../utils/spanUtils';
 
 const metaTagSampleRand = 0.051121;
 const metaTagSampleRate = 0.2;
 
 sentryTest.describe('When `consistentTraceSampling` is `true` and page contains <meta> tags', () => {
   sentryTest('Continues sampling decision across all traces from meta tag', async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
-      const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    const pageloadSpan = await sentryTest.step('Initial pageload', async () => {
+      const pageloadEnvelopePromise = waitForStreamedSpanEnvelope(
+        page,
+        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
+      );
 
       await page.goto(url);
 
-      const [pageloadEvent, pageloadTraceHeader] = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
-      const pageloadTraceContext = pageloadEvent.contexts?.trace;
+      const envelope = await pageloadEnvelopePromise;
+      const span = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
 
-      expect(Number(pageloadTraceHeader?.sample_rand)).toBe(metaTagSampleRand);
-      expect(Number(pageloadTraceHeader?.sample_rate)).toBe(metaTagSampleRate);
+      expect(Number(envelope[0].trace?.sample_rand)).toBe(metaTagSampleRand);
+      expect(Number(envelope[0].trace?.sample_rate)).toBe(metaTagSampleRate);
 
       // since the local sample rate was not applied, the sample rate attribute shouldn't be set
-      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
-      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBeUndefined();
+      expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
+      expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBeUndefined();
 
-      return pageloadTraceContext;
+      return span;
     });
 
-    const customTraceContext = await sentryTest.step('Custom trace', async () => {
-      const customTrace1RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+    const customTraceSpan = await sentryTest.step('Custom trace', async () => {
+      const customEnvelopePromise = waitForStreamedSpanEnvelope(
+        page,
+        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'custom'),
+      );
 
       await page.locator('#btn1').click();
 
-      const [customTrace1Event, customTraceTraceHeader] = eventAndTraceHeaderRequestParser(
-        await customTrace1RequestPromise,
-      );
+      const envelope = await customEnvelopePromise;
+      const span = envelope[1][0][1].items.find(s => getSpanOp(s) === 'custom')!;
 
-      const customTraceContext = customTrace1Event.contexts?.trace;
+      expect(span.trace_id).not.toEqual(pageloadSpan.trace_id);
+      expect(span.parent_span_id).toBeUndefined();
 
-      expect(customTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
-      expect(customTraceContext?.parent_span_id).toBeUndefined();
-
-      expect(Number(customTraceTraceHeader?.sample_rand)).toBe(metaTagSampleRand);
-      expect(Number(customTraceTraceHeader?.sample_rate)).toBe(metaTagSampleRate);
-      expect(Boolean(customTraceTraceHeader?.sampled)).toBe(true);
+      expect(Number(envelope[0].trace?.sample_rand)).toBe(metaTagSampleRand);
+      expect(Number(envelope[0].trace?.sample_rate)).toBe(metaTagSampleRate);
+      expect(envelope[0].trace?.sampled).toBe('true');
 
       // since the local sample rate was not applied, the sample rate attribute shouldn't be set
-      expect(customTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
+      expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
 
       // but we need to set this attribute to still be able to correctly add the sample rate to the DSC (checked above in trace header)
-      expect(customTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBe(metaTagSampleRate);
+      expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]?.value).toBe(metaTagSampleRate);
 
-      return customTraceContext;
+      return span;
     });
 
     await sentryTest.step('Navigation', async () => {
-      const navigation1RequestPromise = waitForTransactionRequest(
+      const navigationEnvelopePromise = waitForStreamedSpanEnvelope(
         page,
-        evt => evt.contexts?.trace?.op === 'navigation',
+        env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'navigation'),
       );
 
       await page.goto(`${url}#foo`);
 
-      const [navigationEvent, navigationTraceHeader] = eventAndTraceHeaderRequestParser(
-        await navigation1RequestPromise,
-      );
-
-      const navigationTraceContext = navigationEvent.contexts?.trace;
+      const envelope = await navigationEnvelopePromise;
+      const navSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === 'navigation')!;
 
-      expect(navigationTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
-      expect(navigationTraceContext?.trace_id).not.toEqual(customTraceContext?.trace_id);
+      expect(navSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
+      expect(navSpan.trace_id).not.toEqual(customTraceSpan.trace_id);
 
-      expect(navigationTraceContext?.parent_span_id).toBeUndefined();
+      expect(navSpan.parent_span_id).toBeUndefined();
 
-      expect(Number(navigationTraceHeader?.sample_rand)).toEqual(metaTagSampleRand);
-      expect(Number(navigationTraceHeader?.sample_rate)).toEqual(metaTagSampleRate);
-      expect(Boolean(navigationTraceHeader?.sampled)).toEqual(true);
+      expect(Number(envelope[0].trace?.sample_rand)).toEqual(metaTagSampleRand);
+      expect(Number(envelope[0].trace?.sample_rate)).toEqual(metaTagSampleRate);
+      expect(envelope[0].trace?.sampled).toEqual('true');
 
       // since the local sample rate was not applied, the sample rate attribute shouldn't be set
-      expect(navigationTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
+      expect(navSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
 
       // but we need to set this attribute to still be able to correctly add the sample rate to the DSC (checked above in trace header)
-      expect(navigationTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBe(
-        metaTagSampleRate,
-      );
+      expect(navSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]?.value).toBe(metaTagSampleRate);
     });
   });
 
   sentryTest(
     'Propagates continued <meta> tag sampling decision to outgoing requests',
     async ({ page, getLocalTestUrl }) => {
-      if (shouldSkipTracingTest()) {
-        sentryTest.skip();
-      }
+      sentryTest.skip(shouldSkipTracingTest());
 
       const url = await getLocalTestUrl({ testDir: __dirname });
 
-      const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
-        const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+      const pageloadSpan = await sentryTest.step('Initial pageload', async () => {
+        const pageloadEnvelopePromise = waitForStreamedSpanEnvelope(
+          page,
+          env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'pageload'),
+        );
 
         await page.goto(url);
 
-        const [pageloadEvent, pageloadTraceHeader] = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
-        const pageloadTraceContext = pageloadEvent.contexts?.trace;
+        const envelope = await pageloadEnvelopePromise;
+        const span = envelope[1][0][1].items.find(s => getSpanOp(s) === 'pageload')!;
 
-        expect(Number(pageloadTraceHeader?.sample_rand)).toBe(metaTagSampleRand);
-        expect(Number(pageloadTraceHeader?.sample_rate)).toBe(metaTagSampleRate);
+        expect(Number(envelope[0].trace?.sample_rand)).toBe(metaTagSampleRand);
+        expect(Number(envelope[0].trace?.sample_rate)).toBe(metaTagSampleRate);
 
         // since the local sample rate was not applied, the sample rate attribute shouldn't be set
-        expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
-        expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBeUndefined();
+        expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
+        expect(span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBeUndefined();
 
-        return pageloadTraceContext;
+        return span;
       });
 
       await sentryTest.step('Make fetch request', async () => {
-        const fetchTracePromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+        const fetchEnvelopePromise = waitForStreamedSpanEnvelope(
+          page,
+          env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'custom'),
+        );
         const tracingHeadersPromise = waitForTracingHeadersOnUrl(page, 'http://sentry-test-external.io');
 
         await page.locator('#btn2').click();
 
         const { baggage, sentryTrace } = await tracingHeadersPromise;
+        const fetchEnvelope = await fetchEnvelopePromise;
 
-        const [fetchTraceEvent, fetchTraceTraceHeader] = eventAndTraceHeaderRequestParser(await fetchTracePromise);
-
-        const fetchTraceSampleRand = Number(fetchTraceTraceHeader?.sample_rand);
-        const fetchTraceTraceContext = fetchTraceEvent.contexts?.trace;
-        const httpClientSpan = fetchTraceEvent.spans?.find(span => span.op === 'http.client');
+        const fetchTraceSampleRand = Number(fetchEnvelope[0].trace?.sample_rand);
+        const fetchTraceSpans = fetchEnvelope[1][0][1].items;
+        const fetchTraceSpan = fetchTraceSpans.find(s => getSpanOp(s) === 'custom')!;
+        const httpClientSpan = fetchTraceSpans.find(s => getSpanOp(s) === 'http.client');
 
         expect(fetchTraceSampleRand).toEqual(metaTagSampleRand);
 
-        expect(fetchTraceTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
-        expect(fetchTraceTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]).toBe(
+        expect(fetchTraceSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBeUndefined();
+        expect(fetchTraceSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_PREVIOUS_TRACE_SAMPLE_RATE]?.value).toBe(
           metaTagSampleRate,
         );
 
-        expect(fetchTraceTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+        expect(fetchTraceSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
 
         expect(sentryTrace).toBeDefined();
         expect(baggage).toBeDefined();
 
         expect(extractTraceparentData(sentryTrace)).toEqual({
-          traceId: fetchTraceTraceContext?.trace_id,
+          traceId: fetchTraceSpan.trace_id,
           parentSpanId: httpClientSpan?.span_id,
           parentSampled: true,
         });
@@ -167,7 +163,7 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
           'sentry-sample_rand': `${metaTagSampleRand}`,
           'sentry-sample_rate': `${metaTagSampleRate}`,
           'sentry-sampled': 'true',
-          'sentry-trace_id': fetchTraceTraceContext?.trace_id,
+          'sentry-trace_id': fetchTraceSpan.trace_id,
           'sentry-transaction': 'custom root span 2',
         });
       });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/tracesSampler-precedence/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/tracesSampler-precedence/init.js
index e2efc43e50f2..e99cf357559a 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/tracesSampler-precedence/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/tracesSampler-precedence/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/tracesSampler-precedence/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/tracesSampler-precedence/test.ts
index 2bb196c898fd..801f0a51d3bf 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/tracesSampler-precedence/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/tracesSampler-precedence/test.ts
@@ -1,15 +1,17 @@
+import { PAGELOAD, NAVIGATION } from '@sentry/conventions/op';
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
 import type { ClientReport } from '@sentry/core';
+
 import { sentryTest } from '../../../../../../utils/fixtures';
 import {
   envelopeRequestParser,
-  eventAndTraceHeaderRequestParser,
   hidePage,
   shouldSkipTracingTest,
   waitForClientReportRequest,
-  waitForTransactionRequest,
 } from '../../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpanEnvelope } from '../../../../../../utils/spanUtils';
 
 /**
  * This test demonstrates that:
@@ -18,26 +20,24 @@ import {
  */
 sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
   sentryTest('explicit sampling decisions in `tracesSampler` have precedence', async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const { pageloadTraceContext } = await sentryTest.step('Initial pageload', async () => {
-      const pageloadRequestPromise = waitForTransactionRequest(page, evt => {
-        return evt.contexts?.trace?.op === 'pageload';
-      });
+    const { pageloadSpan } = await sentryTest.step('Initial pageload', async () => {
+      const pageloadEnvelopePromise = waitForStreamedSpanEnvelope(
+        page,
+        env => !!env[1][0][1].items.find(s => getSpanOp(s) === PAGELOAD),
+      );
       await page.goto(url);
 
-      const res = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
-      const pageloadSampleRand = Number(res[1]?.sample_rand);
-      const pageloadTraceContext = res[0].contexts?.trace;
+      const envelope = await pageloadEnvelopePromise;
+      const pageloadSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === PAGELOAD)!;
 
-      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
-      expect(pageloadSampleRand).toBeGreaterThanOrEqual(0);
+      expect(pageloadSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]?.value).toBe(1);
+      expect(Number(envelope[0].trace?.sample_rand)).toBeGreaterThanOrEqual(0);
 
-      return { pageloadTraceContext: res[0].contexts?.trace, pageloadSampleRand };
+      return { pageloadSpan };
     });
 
     await sentryTest.step('Custom trace is sampled negatively (explicitly in tracesSampler)', async () => {
@@ -45,7 +45,6 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
 
       await page.locator('#btn1').click();
 
-      await page.waitForTimeout(500);
       await hidePage(page);
 
       const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
@@ -54,12 +53,13 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
         timestamp: expect.any(Number),
         discarded_events: [
           {
-            category: 'transaction',
-            quantity: 1,
+            category: 'span',
+            quantity: expect.any(Number),
             reason: 'sample_rate',
           },
         ],
       });
+      expect(clientReport.discarded_events[0].quantity).toBeGreaterThanOrEqual(1);
     });
 
     await sentryTest.step('Subsequent navigation trace is also sampled negatively', async () => {
@@ -67,8 +67,6 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
 
       await page.goto(`${url}#foo`);
 
-      await page.waitForTimeout(500);
-
       await hidePage(page);
 
       const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
@@ -77,61 +75,76 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
         timestamp: expect.any(Number),
         discarded_events: [
           {
-            category: 'transaction',
-            quantity: 1,
+            category: 'span',
+            quantity: expect.any(Number),
             reason: 'sample_rate',
           },
         ],
       });
+      expect(clientReport.discarded_events[0].quantity).toBeGreaterThanOrEqual(1);
     });
 
-    const { customTrace2Context } = await sentryTest.step(
+    const { customTrace2Span } = await sentryTest.step(
       'Custom trace 2 is sampled positively (explicitly in tracesSampler)',
       async () => {
-        const customTrace2RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+        const customEnvelopePromise = waitForStreamedSpanEnvelope(
+          page,
+          env => !!env[1][0][1].items.find(s => getSpanOp(s) === 'custom'),
+        );
 
         await page.locator('#btn2').click();
 
-        const [customTrace2Event] = eventAndTraceHeaderRequestParser(await customTrace2RequestPromise);
+        const envelope = await customEnvelopePromise;
+        const customTrace2Span = envelope[1][0][1].items.find(s => getSpanOp(s) === 'custom')!;
 
-        const customTrace2Context = customTrace2Event.contexts?.trace;
+        expect(customTrace2Span.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]?.value).toBe(1);
+        expect(customTrace2Span.trace_id).not.toEqual(pageloadSpan.trace_id);
+        expect(customTrace2Span.parent_span_id).toBeUndefined();
 
-        expect(customTrace2Context?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
-        expect(customTrace2Context?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
-        expect(customTrace2Context?.parent_span_id).toBeUndefined();
-
-        expect(customTrace2Context?.links).toEqual([
+        expect(customTrace2Span.links).toEqual([
           {
-            attributes: { 'sentry.link.type': 'previous_trace' },
+            attributes: {
+              [SENTRY_LINK_TYPE]: {
+                type: 'string',
+                value: 'previous_trace',
+              },
+            },
             sampled: false,
             span_id: expect.stringMatching(/^[\da-f]{16}$/),
             trace_id: expect.stringMatching(/^[\da-f]{32}$/),
           },
         ]);
 
-        return { customTrace2Context };
+        return { customTrace2Span };
       },
     );
 
     await sentryTest.step('Navigation trace is sampled positively (inherited from previous trace)', async () => {
-      const navigationRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
+      const navigationEnvelopePromise = waitForStreamedSpanEnvelope(
+        page,
+        env => env[0].trace?.sampled === 'true' && !!env[1][0][1].items.find(s => getSpanOp(s) === NAVIGATION),
+      );
 
       await page.goto(`${url}#bar`);
 
-      const [navigationEvent] = eventAndTraceHeaderRequestParser(await navigationRequestPromise);
-
-      const navigationTraceContext = navigationEvent.contexts?.trace;
+      const envelope = await navigationEnvelopePromise;
+      const navigationSpan = envelope[1][0][1].items.find(s => getSpanOp(s) === NAVIGATION)!;
 
-      expect(navigationTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
-      expect(navigationTraceContext?.trace_id).not.toEqual(customTrace2Context?.trace_id);
-      expect(navigationTraceContext?.parent_span_id).toBeUndefined();
+      expect(navigationSpan.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]?.value).toBe(1);
+      expect(navigationSpan.trace_id).not.toEqual(customTrace2Span.trace_id);
+      expect(navigationSpan.parent_span_id).toBeUndefined();
 
-      expect(navigationTraceContext?.links).toEqual([
+      expect(navigationSpan.links).toEqual([
         {
-          attributes: { 'sentry.link.type': 'previous_trace' },
+          attributes: {
+            [SENTRY_LINK_TYPE]: {
+              type: 'string',
+              value: 'previous_trace',
+            },
+          },
           sampled: true,
-          span_id: customTrace2Context?.span_id,
-          trace_id: customTrace2Context?.trace_id,
+          span_id: customTrace2Span.span_id,
+          trace_id: customTrace2Span.trace_id,
         },
       ]);
     });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/custom-trace/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/custom-trace/test.ts
index c4637dc25018..bdbdd1c78a90 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/custom-trace/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/custom-trace/test.ts
@@ -1,60 +1,62 @@
-import { expect } from '@playwright/test';
 import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest('manually started custom traces are linked correctly in the chain', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
-    const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+  const pageloadSpan = await sentryTest.step('Initial pageload', async () => {
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
     await page.goto(url);
-    const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
-    return pageloadRequest.contexts?.trace;
+    return pageloadSpanPromise;
   });
 
-  const customTrace1Context = await sentryTest.step('Custom trace', async () => {
-    const customTrace1RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+  const customTraceSpan = await sentryTest.step('Custom trace', async () => {
+    const customSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'custom');
     await page.locator('#btn1').click();
-    const customTrace1Event = envelopeRequestParser(await customTrace1RequestPromise);
-
-    const customTraceCtx = customTrace1Event.contexts?.trace;
+    const span = await customSpanPromise;
 
-    expect(customTraceCtx?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
-    expect(customTraceCtx?.links).toEqual([
+    expect(span.trace_id).not.toEqual(pageloadSpan.trace_id);
+    expect(span.links).toEqual([
       {
-        trace_id: pageloadTraceContext?.trace_id,
-        span_id: pageloadTraceContext?.span_id,
+        trace_id: pageloadSpan.trace_id,
+        span_id: pageloadSpan.span_id,
         sampled: true,
         attributes: {
-          [SENTRY_LINK_TYPE]: 'previous_trace',
+          [SENTRY_LINK_TYPE]: {
+            type: 'string',
+            value: 'previous_trace',
+          },
         },
       },
     ]);
 
-    return customTraceCtx;
+    return span;
   });
 
   await sentryTest.step('Navigation', async () => {
-    const navigation1RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
+    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
     await page.goto(`${url}#foo`);
-    const navigationEvent = envelopeRequestParser(await navigation1RequestPromise);
-    const navTraceContext = navigationEvent.contexts?.trace;
+    const navSpan = await navigationSpanPromise;
 
-    expect(navTraceContext?.trace_id).not.toEqual(customTrace1Context?.trace_id);
-    expect(navTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+    expect(navSpan.trace_id).not.toEqual(customTraceSpan.trace_id);
+    expect(navSpan.trace_id).not.toEqual(pageloadSpan.trace_id);
 
-    expect(navTraceContext?.links).toEqual([
+    expect(navSpan.links).toEqual([
       {
-        trace_id: customTrace1Context?.trace_id,
-        span_id: customTrace1Context?.span_id,
+        trace_id: customTraceSpan.trace_id,
+        span_id: customTraceSpan.span_id,
         sampled: true,
         attributes: {
-          [SENTRY_LINK_TYPE]: 'previous_trace',
+          [SENTRY_LINK_TYPE]: {
+            type: 'string',
+            value: 'previous_trace',
+          },
         },
       },
     ]);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/default/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/default/test.ts
index 7399c2bb26c3..ca42ae5e32a0 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/default/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/default/test.ts
@@ -1,70 +1,69 @@
-import { expect } from '@playwright/test';
 import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest("navigation spans link back to previous trace's root span", async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
-    const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
-    await page.goto(url);
-    const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
-    return pageloadRequest.contexts?.trace;
-  });
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+  await page.goto(url);
+  const pageloadSpan = await pageloadSpanPromise;
 
-  const navigation1TraceContext = await sentryTest.step('First navigation', async () => {
-    const navigation1RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
-    await page.goto(`${url}#foo`);
-    const navigation1Request = envelopeRequestParser(await navigation1RequestPromise);
-    return navigation1Request.contexts?.trace;
-  });
+  const navigation1SpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
+  await page.goto(`${url}#foo`);
+  const navigation1Span = await navigation1SpanPromise;
 
-  const navigation2TraceContext = await sentryTest.step('Second navigation', async () => {
-    const navigation2RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
-    await page.goto(`${url}#bar`);
-    const navigation2Request = envelopeRequestParser(await navigation2RequestPromise);
-    return navigation2Request.contexts?.trace;
-  });
+  const navigation2SpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
+  await page.goto(`${url}#bar`);
+  const navigation2Span = await navigation2SpanPromise;
 
-  const pageloadTraceId = pageloadTraceContext?.trace_id;
-  const navigation1TraceId = navigation1TraceContext?.trace_id;
-  const navigation2TraceId = navigation2TraceContext?.trace_id;
+  const pageloadTraceId = pageloadSpan.trace_id;
+  const navigation1TraceId = navigation1Span.trace_id;
+  const navigation2TraceId = navigation2Span.trace_id;
 
-  expect(pageloadTraceContext?.links).toBeUndefined();
+  expect(pageloadSpan.links).toBeUndefined();
 
-  expect(navigation1TraceContext?.links).toEqual([
+  expect(navigation1Span.links).toEqual([
     {
       trace_id: pageloadTraceId,
-      span_id: pageloadTraceContext?.span_id,
+      span_id: pageloadSpan.span_id,
       sampled: true,
       attributes: {
-        [SENTRY_LINK_TYPE]: 'previous_trace',
+        [SENTRY_LINK_TYPE]: {
+          type: 'string',
+          value: 'previous_trace',
+        },
       },
     },
   ]);
 
-  expect(navigation1TraceContext?.data).toMatchObject({
-    'sentry.previous_trace': `${pageloadTraceId}-${pageloadTraceContext?.span_id}-1`,
+  expect(navigation1Span.attributes['sentry.previous_trace']).toEqual({
+    type: 'string',
+    value: `${pageloadTraceId}-${pageloadSpan.span_id}-1`,
   });
 
-  expect(navigation2TraceContext?.links).toEqual([
+  expect(navigation2Span.links).toEqual([
     {
       trace_id: navigation1TraceId,
-      span_id: navigation1TraceContext?.span_id,
+      span_id: navigation1Span.span_id,
       sampled: true,
       attributes: {
-        [SENTRY_LINK_TYPE]: 'previous_trace',
+        [SENTRY_LINK_TYPE]: {
+          type: 'string',
+          value: 'previous_trace',
+        },
       },
     },
   ]);
 
-  expect(navigation2TraceContext?.data).toMatchObject({
-    'sentry.previous_trace': `${navigation1TraceId}-${navigation1TraceContext?.span_id}-1`,
+  expect(navigation2Span.attributes['sentry.previous_trace']).toEqual({
+    type: 'string',
+    value: `${navigation1TraceId}-${navigation1Span.span_id}-1`,
   });
 
   expect(pageloadTraceId).not.toEqual(navigation1TraceId);
@@ -73,27 +72,25 @@ sentryTest("navigation spans link back to previous trace's root span", async ({
 });
 
 sentryTest("doesn't link between hard page reloads by default", async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
   await sentryTest.step('First pageload', async () => {
-    const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
     await page.goto(url);
-    const pageload1Event = envelopeRequestParser(await pageloadRequestPromise);
+    const pageload1Span = await pageloadSpanPromise;
 
-    expect(pageload1Event.contexts?.trace).toBeDefined();
-    expect(pageload1Event.contexts?.trace?.links).toBeUndefined();
+    expect(pageload1Span).toBeDefined();
+    expect(pageload1Span.links).toBeUndefined();
   });
 
   await sentryTest.step('Second pageload', async () => {
-    const pageload2RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
     await page.reload();
-    const pageload2Event = envelopeRequestParser(await pageload2RequestPromise);
+    const pageload2Span = await pageloadSpanPromise;
 
-    expect(pageload2Event.contexts?.trace).toBeDefined();
-    expect(pageload2Event.contexts?.trace?.links).toBeUndefined();
+    expect(pageload2Span).toBeDefined();
+    expect(pageload2Span.links).toBeUndefined();
   });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/init.js
index bdd43f5ac757..1ce4125ee422 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/interaction-spans/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/interaction-spans/init.js
index 2c3e9264d882..96386e1d38d5 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/interaction-spans/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/interaction-spans/init.js
@@ -4,7 +4,6 @@ import { interactionsIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1,
   integrations: [Sentry.browserTracingIntegration(), interactionsIntegration()],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/interaction-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/interaction-spans/test.ts
index 24a1e2c59072..67e216567856 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/interaction-spans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/interaction-spans/test.ts
@@ -1,7 +1,9 @@
-import { expect } from '@playwright/test';
 import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 /*
   This is quite peculiar behavior but it's a result of the route-based trace lifetime.
@@ -12,78 +14,67 @@ import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest
 sentryTest(
   'only the first root spans in the trace link back to the previous trace',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
-      const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    const pageloadSpan = await sentryTest.step('Initial pageload', async () => {
+      const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
       await page.goto(url);
+      const span = await pageloadSpanPromise;
 
-      const pageloadEvent = envelopeRequestParser(await pageloadRequestPromise);
-      const traceContext = pageloadEvent.contexts?.trace;
-
-      expect(traceContext).toBeDefined();
-      expect(traceContext?.links).toBeUndefined();
+      expect(span).toBeDefined();
+      expect(span.links).toBeUndefined();
 
-      return traceContext;
+      return span;
     });
 
     await sentryTest.step('Click Before navigation', async () => {
-      const interactionRequestPromise = waitForTransactionRequest(page, evt => {
-        return evt.contexts?.trace?.op === 'ui.action.click';
-      });
+      const interactionSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.action.click');
       await page.click('#btn');
-
-      const interactionEvent = envelopeRequestParser(await interactionRequestPromise);
-      const interactionTraceContext = interactionEvent.contexts?.trace;
+      const interactionSpan = await interactionSpanPromise;
 
       // sanity check: route-based trace lifetime means the trace_id should be the same
-      expect(interactionTraceContext?.trace_id).toBe(pageloadTraceContext?.trace_id);
+      expect(interactionSpan.trace_id).toBe(pageloadSpan.trace_id);
 
       // no links yet as previous root span belonged to same trace
-      expect(interactionTraceContext?.links).toBeUndefined();
+      expect(interactionSpan.links).toBeUndefined();
     });
 
-    const navigationTraceContext = await sentryTest.step('Navigation', async () => {
-      const navigationRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
+    const navigationSpan = await sentryTest.step('Navigation', async () => {
+      const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
       await page.goto(`${url}#foo`);
-      const navigationEvent = envelopeRequestParser(await navigationRequestPromise);
-
-      const traceContext = navigationEvent.contexts?.trace;
+      const span = await navigationSpanPromise;
 
-      expect(traceContext?.op).toBe('navigation');
-      expect(traceContext?.links).toEqual([
+      expect(getSpanOp(span)).toBe('navigation');
+      expect(span.links).toEqual([
         {
-          trace_id: pageloadTraceContext?.trace_id,
-          span_id: pageloadTraceContext?.span_id,
+          trace_id: pageloadSpan.trace_id,
+          span_id: pageloadSpan.span_id,
           sampled: true,
           attributes: {
-            [SENTRY_LINK_TYPE]: 'previous_trace',
+            [SENTRY_LINK_TYPE]: {
+              type: 'string',
+              value: 'previous_trace',
+            },
           },
         },
       ]);
 
-      expect(traceContext?.trace_id).not.toEqual(traceContext?.links![0].trace_id);
-      return traceContext;
+      expect(span.trace_id).not.toEqual(span.links![0].trace_id);
+      return span;
     });
 
     await sentryTest.step('Click After navigation', async () => {
-      const interactionRequestPromise = waitForTransactionRequest(page, evt => {
-        return evt.contexts?.trace?.op === 'ui.action.click';
-      });
+      const interactionSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.action.click');
       await page.click('#btn');
-      const interactionEvent = envelopeRequestParser(await interactionRequestPromise);
-
-      const interactionTraceContext = interactionEvent.contexts?.trace;
+      const interactionSpan = await interactionSpanPromise;
 
       // sanity check: route-based trace lifetime means the trace_id should be the same
-      expect(interactionTraceContext?.trace_id).toBe(navigationTraceContext?.trace_id);
+      expect(interactionSpan.trace_id).toBe(navigationSpan.trace_id);
 
       // since this is the second root span in the trace, it doesn't link back to the previous trace
-      expect(interactionTraceContext?.links).toBeUndefined();
+      expect(interactionSpan.links).toBeUndefined();
     });
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/meta/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/meta/test.ts
index a232a5a0f6e7..3f8688a0bf4d 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/meta/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/meta/test.ts
@@ -1,54 +1,51 @@
-import { expect } from '@playwright/test';
 import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest(
   "links back to previous trace's local root span if continued from meta tags",
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
     const metaTagTraceId = '12345678901234567890123456789012';
 
-    const pageloadTraceContext = await sentryTest.step('Initial pageload', async () => {
-      const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+    const pageloadSpan = await sentryTest.step('Initial pageload', async () => {
+      const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
       await page.goto(url);
-      const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
-
-      const traceContext = pageloadRequest.contexts?.trace;
+      const span = await pageloadSpanPromise;
 
       // sanity check
-      expect(traceContext?.trace_id).toBe(metaTagTraceId);
-
-      expect(traceContext?.links).toBeUndefined();
+      expect(span.trace_id).toBe(metaTagTraceId);
+      expect(span.links).toBeUndefined();
 
-      return traceContext;
+      return span;
     });
 
-    const navigationTraceContext = await sentryTest.step('Navigation', async () => {
-      const navigationRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
+    const navigationSpan = await sentryTest.step('Navigation', async () => {
+      const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
       await page.goto(`${url}#foo`);
-      const navigationRequest = envelopeRequestParser(await navigationRequestPromise);
-      return navigationRequest.contexts?.trace;
+      return navigationSpanPromise;
     });
 
-    const navigationTraceId = navigationTraceContext?.trace_id;
-
-    expect(navigationTraceContext?.links).toEqual([
+    expect(navigationSpan.links).toEqual([
       {
         trace_id: metaTagTraceId,
-        span_id: pageloadTraceContext?.span_id,
+        span_id: pageloadSpan.span_id,
         sampled: true,
         attributes: {
-          [SENTRY_LINK_TYPE]: 'previous_trace',
+          [SENTRY_LINK_TYPE]: {
+            type: 'string',
+            value: 'previous_trace',
+          },
         },
       },
     ]);
 
-    expect(navigationTraceId).not.toEqual(metaTagTraceId);
+    expect(navigationSpan.trace_id).not.toEqual(metaTagTraceId);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/negatively-sampled/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/negatively-sampled/init.js
index 79ca4d68e8ba..a3b99e2e1dc3 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/negatively-sampled/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/negatively-sampled/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   // We want to ignore redirects for this test
   integrations: [Sentry.browserTracingIntegration({ detectRedirects: false })],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/negatively-sampled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/negatively-sampled/test.ts
index 894fe0d5929a..9fd3c0d2dd7d 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/negatively-sampled/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/negatively-sampled/test.ts
@@ -1,42 +1,45 @@
-import { expect } from '@playwright/test';
 import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest('includes a span link to a previously negatively sampled span', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
   await sentryTest.step('Initial pageload', async () => {
-    // No event to check for an event here because this pageload span is sampled negatively!
+    // No span envelope expected here because this pageload span is sampled negatively!
     await page.goto(url);
   });
 
   await sentryTest.step('Navigation', async () => {
-    const navigationRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
+    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
     await page.goto(`${url}#foo`);
-    const navigationEvent = envelopeRequestParser(await navigationRequestPromise);
-    const navigationTraceContext = navigationEvent.contexts?.trace;
+    const navigationSpan = await navigationSpanPromise;
 
-    expect(navigationTraceContext?.op).toBe('navigation');
-    expect(navigationTraceContext?.links).toEqual([
+    expect(getSpanOp(navigationSpan)).toBe('navigation');
+    expect(navigationSpan.links).toEqual([
       {
         trace_id: expect.stringMatching(/[a-f\d]{32}/),
         span_id: expect.stringMatching(/[a-f\d]{16}/),
         sampled: false,
         attributes: {
-          [SENTRY_LINK_TYPE]: 'previous_trace',
+          [SENTRY_LINK_TYPE]: {
+            type: 'string',
+            value: 'previous_trace',
+          },
         },
       },
     ]);
 
-    expect(navigationTraceContext?.data).toMatchObject({
-      'sentry.previous_trace': expect.stringMatching(/[a-f\d]{32}-[a-f\d]{16}-0/),
+    expect(navigationSpan.attributes['sentry.previous_trace']).toEqual({
+      type: 'string',
+      value: expect.stringMatching(/[a-f\d]{32}-[a-f\d]{16}-0/),
     });
 
-    expect(navigationTraceContext?.trace_id).not.toEqual(navigationTraceContext?.links![0].trace_id);
+    expect(navigationSpan.trace_id).not.toEqual(navigationSpan.links![0].trace_id);
   });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/session-storage/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/session-storage/init.js
index 9b88e489ae07..fc053206d9ed 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/session-storage/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/session-storage/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration({ linkPreviousTrace: 'session-storage' })],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/session-storage/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/session-storage/test.ts
index f7e0d288de5b..57121c395b53 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/session-storage/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces/session-storage/test.ts
@@ -1,39 +1,43 @@
-import { expect } from '@playwright/test';
 import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest('adds link between hard page reloads when opting into sessionStorage', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const pageload1TraceContext = await sentryTest.step('First pageload', async () => {
-    const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+  const pageload1Span = await sentryTest.step('First pageload', async () => {
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
     await page.goto(url);
-    const pageload1Event = envelopeRequestParser(await pageloadRequestPromise);
-    const pageload1TraceContext = pageload1Event.contexts?.trace;
-    expect(pageload1TraceContext).toBeDefined();
-    expect(pageload1TraceContext?.links).toBeUndefined();
-    return pageload1TraceContext;
+    const span = await pageloadSpanPromise;
+    expect(span).toBeDefined();
+    expect(span.links).toBeUndefined();
+    return span;
   });
 
-  const pageload2Event = await sentryTest.step('Hard page reload', async () => {
-    const pageload2RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+  const pageload2Span = await sentryTest.step('Hard page reload', async () => {
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
     await page.reload();
-    return envelopeRequestParser(await pageload2RequestPromise);
+    return pageloadSpanPromise;
   });
 
-  expect(pageload2Event.contexts?.trace?.links).toEqual([
+  expect(pageload2Span.links).toEqual([
     {
-      trace_id: pageload1TraceContext?.trace_id,
-      span_id: pageload1TraceContext?.span_id,
+      trace_id: pageload1Span.trace_id,
+      span_id: pageload1Span.span_id,
       sampled: true,
-      attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' },
+      attributes: {
+        [SENTRY_LINK_TYPE]: {
+          type: 'string',
+          value: 'previous_trace',
+        },
+      },
     },
   ]);
 
-  expect(pageload1TraceContext?.trace_id).not.toEqual(pageload2Event.contexts?.trace?.trace_id);
+  expect(pageload1Span.trace_id).not.toEqual(pageload2Span.trace_id);
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-static/init.js
similarity index 90%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-static/init.js
index d3c861a8ae26..a8a7fc20c7f9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-static/init.js
@@ -3,6 +3,7 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
@@ -11,7 +12,6 @@ Sentry.init({
       instrumentPageLoad: false,
       enableInp: false,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-static/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-streamed/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-static/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-streamed/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-streamed/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-static/test.ts
new file mode 100644
index 000000000000..ca072e14b342
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-static/test.ts
@@ -0,0 +1,34 @@
+import { NAVIGATION } from '@sentry/conventions/op';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest(
+  "doesn't capture long animation frame that starts before a navigation.",
+  async ({ browserName, getLocalTestUrl, page }) => {
+    // Long animation frames only work on chrome
+    if (shouldSkipTracingTest() || browserName !== 'chromium') {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await page.goto(url);
+
+    const navigationTransactionEventPromise = waitForTransactionRequest(
+      page,
+      event => event.contexts?.trace?.op === NAVIGATION,
+    );
+
+    await page.locator('#clickme').click();
+
+    const navigationTransactionEvent = envelopeRequestParser<Event>(await navigationTransactionEventPromise);
+
+    expect(navigationTransactionEvent.contexts?.trace?.op).toBe(NAVIGATION);
+
+    const loafSpans = navigationTransactionEvent.spans?.filter(s => s.op?.startsWith('ui.long_animation_frame'));
+
+    expect(loafSpans?.length).toEqual(0);
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-streamed/test.ts
deleted file mode 100644
index bfda616223b4..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation-streamed/test.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest(
-  "doesn't capture long animation frame that starts before a navigation.",
-  async ({ browserName, getLocalTestUrl, page }) => {
-    // Long animation frames only work on chrome
-    sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const navigationSpansPromise = waitForStreamedSpans(page, spans => spans.some(s => getSpanOp(s) === 'navigation'));
-
-    await page.goto(url);
-
-    await page.locator('#clickme').click();
-
-    const spans = await navigationSpansPromise;
-
-    const loafSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui.long_animation_frame'));
-    expect(loafSpans).toHaveLength(0);
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation/init.js
index a8a7fc20c7f9..019eece018f6 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation/test.ts
index b7215249910f..031da81f9d78 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-before-navigation/test.ts
@@ -1,30 +1,30 @@
+import { SENTRY_SEGMENT_ID } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
   "doesn't capture long animation frame that starts before a navigation.",
   async ({ browserName, getLocalTestUrl, page }) => {
     // Long animation frames only work on chrome
-    if (shouldSkipTracingTest() || browserName !== 'chromium') {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    await page.goto(url);
+    const allSpans = collectStreamedSpans(page);
+    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
 
-    const navigationTransactionEventPromise = getFirstSentryEnvelopeRequest<Event>(page);
+    await page.goto(url);
 
     await page.locator('#clickme').click();
 
-    const navigationTransactionEvent = await navigationTransactionEventPromise;
-
-    expect(navigationTransactionEvent.contexts?.trace?.op).toBe('navigation');
-
-    const loafSpans = navigationTransactionEvent.spans?.filter(s => s.op?.startsWith('ui.long_animation_frame'));
+    const navigationRoot = await navigationSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    expect(getSpanOp(navigationRoot)).toBe('navigation');
+    const spans = allSpans.filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === navigationRoot.span_id);
 
-    expect(loafSpans?.length).toEqual(0);
+    const loafSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui.long_animation_frame'));
+    expect(loafSpans).toHaveLength(0);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-streamed/assets/script.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-static/assets/script.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-streamed/assets/script.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-static/assets/script.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-static/init.js
similarity index 88%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-static/init.js
index 3c004b952f80..250f2a72311b 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-static/init.js
@@ -3,13 +3,13 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
       enableLongTask: false,
       enableLongAnimationFrame: false,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-streamed/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-streamed/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-static/test.ts
new file mode 100644
index 000000000000..3d4ca79877b1
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-static/test.ts
@@ -0,0 +1,26 @@
+import type { Route } from '@playwright/test';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest(
+  'should not capture long animation frame when flag is disabled.',
+  async ({ browserName, getLocalTestUrl, page }) => {
+    // Long animation frames only work on chrome
+    if (shouldSkipTracingTest() || browserName !== 'chromium') {
+      sentryTest.skip();
+    }
+
+    await page.route('**/path/to/script.js', (route: Route) =>
+      route.fulfill({ path: `${__dirname}/assets/script.js` }),
+    );
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+    const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui'));
+
+    expect(uiSpans?.length).toBe(0);
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-streamed/test.ts
deleted file mode 100644
index e03474070bb0..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-streamed/test.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import type { Route } from '@playwright/test';
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest(
-  'does not capture long animation frame when flag is disabled.',
-  async ({ browserName, getLocalTestUrl, page }) => {
-    // Long animation frames only work on chrome
-    sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
-
-    await page.route('**/path/to/script.js', (route: Route) =>
-      route.fulfill({ path: `${__dirname}/assets/script.js` }),
-    );
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const spansPromise = waitForStreamedSpans(page, spans => spans.some(s => getSpanOp(s) === 'pageload'));
-
-    await page.goto(url);
-
-    const spans = await spansPromise;
-    const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui'));
-
-    expect(uiSpans.length).toBe(0);
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled/init.js
index 250f2a72311b..0339c3fa3dbf 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled/test.ts
index 3d4ca79877b1..7ea2ac55bb53 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled/test.ts
@@ -1,16 +1,14 @@
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
-  'should not capture long animation frame when flag is disabled.',
+  'does not capture long animation frame when flag is disabled.',
   async ({ browserName, getLocalTestUrl, page }) => {
     // Long animation frames only work on chrome
-    if (shouldSkipTracingTest() || browserName !== 'chromium') {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
 
     await page.route('**/path/to/script.js', (route: Route) =>
       route.fulfill({ path: `${__dirname}/assets/script.js` }),
@@ -18,9 +16,15 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-    const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui'));
+    const spans = collectStreamedSpans(page);
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
 
-    expect(uiSpans?.length).toBe(0);
+    await page.goto(url);
+
+    await pageloadSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui'));
+
+    expect(uiSpans.length).toBe(0);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-streamed/assets/script.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-static/assets/script.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-streamed/assets/script.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-static/assets/script.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-static/init.js
similarity index 88%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-static/init.js
index 2be5f32985d7..cfa9cb5faa3f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-static/init.js
@@ -3,13 +3,13 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
       enableLongTask: false,
       enableLongAnimationFrame: true,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-streamed/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-streamed/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-static/test.ts
new file mode 100644
index 000000000000..0a3f97f6a786
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-static/test.ts
@@ -0,0 +1,116 @@
+import { PAGELOAD, UI_LONG_ANIMATION_FRAME } from '@sentry/conventions/op';
+import {
+  BROWSER_SCRIPT_INVOKER,
+  CODE_FILE_PATH,
+  BROWSER_SCRIPT_SOURCE_CHAR_POSITION,
+  BROWSER_SCRIPT_INVOKER_TYPE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import type { Route } from '@playwright/test';
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest(
+  'should capture long animation frame for top-level script.',
+  async ({ browserName, getLocalTestUrl, page }) => {
+    // Long animation frames only work on chrome
+    if (shouldSkipTracingTest() || browserName !== 'chromium') {
+      sentryTest.skip();
+    }
+
+    await page.route('**/path/to/script.js', (route: Route) =>
+      route.fulfill({ path: `${__dirname}/assets/script.js` }),
+    );
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const promise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+
+    await page.goto(url);
+
+    const eventData = envelopeRequestParser(await promise);
+
+    const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith(UI_LONG_ANIMATION_FRAME));
+
+    expect(uiSpans?.length).toBeGreaterThanOrEqual(1);
+
+    const topLevelUISpan = (uiSpans || []).find(
+      span => span.data?.[BROWSER_SCRIPT_INVOKER] === 'https://sentry-test-site.example/path/to/script.js',
+    )!;
+    expect(topLevelUISpan).toEqual(
+      expect.objectContaining({
+        op: UI_LONG_ANIMATION_FRAME,
+        description: 'Main UI thread blocked',
+        parent_span_id: eventData.contexts?.trace?.span_id,
+        data: {
+          [CODE_FILE_PATH]: 'https://sentry-test-site.example/path/to/script.js',
+          [BROWSER_SCRIPT_SOURCE_CHAR_POSITION]: 0,
+          [BROWSER_SCRIPT_INVOKER]: 'https://sentry-test-site.example/path/to/script.js',
+          [BROWSER_SCRIPT_INVOKER_TYPE]: 'classic-script',
+          [SENTRY_OP]: UI_LONG_ANIMATION_FRAME,
+          [SENTRY_ORIGIN]: 'auto.ui.browser.metrics',
+        },
+      }),
+    );
+    const start = topLevelUISpan.start_timestamp ?? 0;
+    const end = topLevelUISpan.timestamp ?? 0;
+    const duration = end - start;
+
+    expect(duration).toBeGreaterThanOrEqual(0.1);
+    expect(duration).toBeLessThanOrEqual(0.15);
+  },
+);
+
+sentryTest(
+  'should capture long animation frame for event listener.',
+  async ({ browserName, getLocalTestUrl, page }) => {
+    // Long animation frames only work on chrome
+    if (shouldSkipTracingTest() || browserName !== 'chromium') {
+      sentryTest.skip();
+    }
+
+    await page.route('**/path/to/script.js', (route: Route) =>
+      route.fulfill({ path: `${__dirname}/assets/script.js` }),
+    );
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const promise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+
+    await page.goto(url);
+
+    // trigger long animation frame function
+    await page.getByRole('button').click();
+
+    const eventData = envelopeRequestParser(await promise);
+
+    const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith(UI_LONG_ANIMATION_FRAME)) || [];
+
+    expect(uiSpans.length).toBeGreaterThanOrEqual(2);
+
+    const eventListenerUISpan = uiSpans.find(span => span.data[BROWSER_SCRIPT_INVOKER] === 'BUTTON#clickme.onclick')!;
+
+    expect(eventListenerUISpan).toEqual(
+      expect.objectContaining({
+        op: UI_LONG_ANIMATION_FRAME,
+        description: 'Main UI thread blocked',
+        parent_span_id: eventData.contexts?.trace?.span_id,
+        data: {
+          [BROWSER_SCRIPT_INVOKER]: 'BUTTON#clickme.onclick',
+          [BROWSER_SCRIPT_INVOKER_TYPE]: 'event-listener',
+          [CODE_FILE_PATH]: 'https://sentry-test-site.example/path/to/script.js',
+          [SENTRY_OP]: UI_LONG_ANIMATION_FRAME,
+          [SENTRY_ORIGIN]: 'auto.ui.browser.metrics',
+        },
+      }),
+    );
+    const start = eventListenerUISpan.start_timestamp ?? 0;
+    const end = eventListenerUISpan.timestamp ?? 0;
+    const duration = end - start;
+
+    expect(duration).toBeGreaterThanOrEqual(0.1);
+    expect(duration).toBeLessThanOrEqual(0.15);
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-streamed/test.ts
deleted file mode 100644
index f885fc4c3bde..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled-streamed/test.ts
+++ /dev/null
@@ -1,108 +0,0 @@
-import { SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
-import type { Route } from '@playwright/test';
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest(
-  'captures long animation frame span for top-level script.',
-  async ({ browserName, getLocalTestUrl, page }) => {
-    // Long animation frames only work on chrome
-    sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
-
-    await page.route('**/path/to/script.js', (route: Route) =>
-      route.fulfill({ path: `${__dirname}/assets/script.js` }),
-    );
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const spansPromise = waitForStreamedSpans(page, spans => spans.some(s => getSpanOp(s) === 'pageload'));
-
-    await page.goto(url);
-
-    const spans = await spansPromise;
-    const pageloadSpan = spans.find(s => getSpanOp(s) === 'pageload')!;
-
-    const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui.long_animation_frame'));
-
-    expect(uiSpans.length).toBeGreaterThanOrEqual(1);
-
-    const topLevelUISpan = uiSpans.find(
-      s => s.attributes['browser.script.invoker']?.value === 'https://sentry-test-site.example/path/to/script.js',
-    )!;
-
-    expect(topLevelUISpan).toEqual(
-      expect.objectContaining({
-        name: 'Main UI thread blocked',
-        parent_span_id: pageloadSpan.span_id,
-        attributes: expect.objectContaining({
-          'code.file.path': { type: 'string', value: 'https://sentry-test-site.example/path/to/script.js' },
-          'browser.script.source_char_position': expect.objectContaining({ value: 0 }),
-          'browser.script.invoker': {
-            type: 'string',
-            value: 'https://sentry-test-site.example/path/to/script.js',
-          },
-          'browser.script.invoker_type': { type: 'string', value: 'classic-script' },
-          [SENTRY_OP]: { type: 'string', value: 'ui.long_animation_frame' },
-          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.ui.browser.metrics' },
-        }),
-      }),
-    );
-
-    const start = topLevelUISpan.start_timestamp ?? 0;
-    const end = topLevelUISpan.end_timestamp ?? 0;
-    const duration = end - start;
-
-    expect(duration).toBeGreaterThanOrEqual(0.1);
-    expect(duration).toBeLessThanOrEqual(0.15);
-  },
-);
-
-sentryTest('captures long animation frame span for event listener.', async ({ browserName, getLocalTestUrl, page }) => {
-  // Long animation frames only work on chrome
-  sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
-
-  await page.route('**/path/to/script.js', (route: Route) => route.fulfill({ path: `${__dirname}/assets/script.js` }));
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const spansPromise = waitForStreamedSpans(page, spans => spans.some(s => getSpanOp(s) === 'pageload'));
-
-  await page.goto(url);
-
-  // trigger long animation frame function
-  await page.getByRole('button').click();
-
-  const spans = await spansPromise;
-  const pageloadSpan = spans.find(s => getSpanOp(s) === 'pageload')!;
-
-  const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui.long_animation_frame'));
-
-  expect(uiSpans.length).toBeGreaterThanOrEqual(2);
-
-  const eventListenerUISpan = uiSpans.find(
-    s => s.attributes['browser.script.invoker']?.value === 'BUTTON#clickme.onclick',
-  )!;
-
-  expect(eventListenerUISpan).toEqual(
-    expect.objectContaining({
-      name: 'Main UI thread blocked',
-      parent_span_id: pageloadSpan.span_id,
-      attributes: expect.objectContaining({
-        'browser.script.invoker': { type: 'string', value: 'BUTTON#clickme.onclick' },
-        'browser.script.invoker_type': { type: 'string', value: 'event-listener' },
-        'code.file.path': { type: 'string', value: 'https://sentry-test-site.example/path/to/script.js' },
-        [SENTRY_OP]: { type: 'string', value: 'ui.long_animation_frame' },
-        [SENTRY_ORIGIN]: { type: 'string', value: 'auto.ui.browser.metrics' },
-      }),
-    }),
-  );
-
-  const start = eventListenerUISpan.start_timestamp ?? 0;
-  const end = eventListenerUISpan.end_timestamp ?? 0;
-  const duration = end - start;
-
-  expect(duration).toBeGreaterThanOrEqual(0.1);
-  expect(duration).toBeLessThanOrEqual(0.15);
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled/init.js
index cfa9cb5faa3f..f16f7af33b5c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled/test.ts
index 937662e117a4..8a1cc8026aaa 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-enabled/test.ts
@@ -1,17 +1,22 @@
-import { SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import {
+  BROWSER_SCRIPT_INVOKER,
+  CODE_FILE_PATH,
+  BROWSER_SCRIPT_SOURCE_CHAR_POSITION,
+  BROWSER_SCRIPT_INVOKER_TYPE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
-  'should capture long animation frame for top-level script.',
+  'captures long animation frame span for top-level script.',
   async ({ browserName, getLocalTestUrl, page }) => {
     // Long animation frames only work on chrome
-    if (shouldSkipTracingTest() || browserName !== 'chromium') {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
 
     await page.route('**/path/to/script.js', (route: Route) =>
       route.fulfill({ path: `${__dirname}/assets/script.js` }),
@@ -19,38 +24,43 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const promise = getFirstSentryEnvelopeRequest<Event>(page);
+    const spans = collectStreamedSpans(page);
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
 
     await page.goto(url);
 
-    await new Promise(resolve => setTimeout(resolve, 1000));
+    await pageloadSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const pageloadSpan = spans.find(s => getSpanOp(s) === 'pageload')!;
 
-    const eventData = await promise;
+    const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui.long_animation_frame'));
 
-    const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui.long_animation_frame'));
+    expect(uiSpans.length).toBeGreaterThanOrEqual(1);
 
-    expect(uiSpans?.length).toBeGreaterThanOrEqual(1);
-
-    const topLevelUISpan = (uiSpans || []).find(
-      span => span.data?.['browser.script.invoker'] === 'https://sentry-test-site.example/path/to/script.js',
+    const topLevelUISpan = uiSpans.find(
+      s => s.attributes[BROWSER_SCRIPT_INVOKER]?.value === 'https://sentry-test-site.example/path/to/script.js',
     )!;
+
     expect(topLevelUISpan).toEqual(
       expect.objectContaining({
-        op: 'ui.long_animation_frame',
-        description: 'Main UI thread blocked',
-        parent_span_id: eventData.contexts?.trace?.span_id,
-        data: {
-          'code.file.path': 'https://sentry-test-site.example/path/to/script.js',
-          'browser.script.source_char_position': 0,
-          'browser.script.invoker': 'https://sentry-test-site.example/path/to/script.js',
-          'browser.script.invoker_type': 'classic-script',
-          [SENTRY_OP]: 'ui.long_animation_frame',
-          [SENTRY_ORIGIN]: 'auto.ui.browser.metrics',
-        },
+        name: 'Main UI thread blocked',
+        parent_span_id: pageloadSpan.span_id,
+        attributes: expect.objectContaining({
+          [CODE_FILE_PATH]: { type: 'string', value: 'https://sentry-test-site.example/path/to/script.js' },
+          [BROWSER_SCRIPT_SOURCE_CHAR_POSITION]: expect.objectContaining({ value: 0 }),
+          [BROWSER_SCRIPT_INVOKER]: {
+            type: 'string',
+            value: 'https://sentry-test-site.example/path/to/script.js',
+          },
+          [BROWSER_SCRIPT_INVOKER_TYPE]: { type: 'string', value: 'classic-script' },
+          [SENTRY_OP]: { type: 'string', value: 'ui.long_animation_frame' },
+          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.ui.browser.metrics' },
+        }),
       }),
     );
+
     const start = topLevelUISpan.start_timestamp ?? 0;
-    const end = topLevelUISpan.timestamp ?? 0;
+    const end = topLevelUISpan.end_timestamp ?? 0;
     const duration = end - start;
 
     expect(duration).toBeGreaterThanOrEqual(0.1);
@@ -58,56 +68,51 @@ sentryTest(
   },
 );
 
-sentryTest(
-  'should capture long animation frame for event listener.',
-  async ({ browserName, getLocalTestUrl, page }) => {
-    // Long animation frames only work on chrome
-    if (shouldSkipTracingTest() || browserName !== 'chromium') {
-      sentryTest.skip();
-    }
-
-    await page.route('**/path/to/script.js', (route: Route) =>
-      route.fulfill({ path: `${__dirname}/assets/script.js` }),
-    );
+sentryTest('captures long animation frame span for event listener.', async ({ browserName, getLocalTestUrl, page }) => {
+  // Long animation frames only work on chrome
+  sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
 
-    const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.route('**/path/to/script.js', (route: Route) => route.fulfill({ path: `${__dirname}/assets/script.js` }));
 
-    const promise = getFirstSentryEnvelopeRequest<Event>(page);
+  const url = await getLocalTestUrl({ testDir: __dirname });
 
-    await page.goto(url);
+  const spans = collectStreamedSpans(page);
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
 
-    // trigger long animation frame function
-    await page.getByRole('button').click();
+  await page.goto(url);
 
-    await new Promise(resolve => setTimeout(resolve, 1000));
+  // trigger long animation frame function
+  await page.getByRole('button').click();
 
-    const eventData = await promise;
+  const pageloadSpan = await pageloadSpanPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-    const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui.long_animation_frame')) || [];
+  const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui.long_animation_frame'));
 
-    expect(uiSpans.length).toBeGreaterThanOrEqual(2);
+  expect(uiSpans.length).toBeGreaterThanOrEqual(2);
 
-    const eventListenerUISpan = uiSpans.find(span => span.data['browser.script.invoker'] === 'BUTTON#clickme.onclick')!;
+  const eventListenerUISpan = uiSpans.find(
+    s => s.attributes[BROWSER_SCRIPT_INVOKER]?.value === 'BUTTON#clickme.onclick',
+  )!;
 
-    expect(eventListenerUISpan).toEqual(
-      expect.objectContaining({
-        op: 'ui.long_animation_frame',
-        description: 'Main UI thread blocked',
-        parent_span_id: eventData.contexts?.trace?.span_id,
-        data: {
-          'browser.script.invoker': 'BUTTON#clickme.onclick',
-          'browser.script.invoker_type': 'event-listener',
-          'code.file.path': 'https://sentry-test-site.example/path/to/script.js',
-          [SENTRY_OP]: 'ui.long_animation_frame',
-          [SENTRY_ORIGIN]: 'auto.ui.browser.metrics',
-        },
+  expect(eventListenerUISpan).toEqual(
+    expect.objectContaining({
+      name: 'Main UI thread blocked',
+      parent_span_id: pageloadSpan.span_id,
+      attributes: expect.objectContaining({
+        [BROWSER_SCRIPT_INVOKER]: { type: 'string', value: 'BUTTON#clickme.onclick' },
+        [BROWSER_SCRIPT_INVOKER_TYPE]: { type: 'string', value: 'event-listener' },
+        [CODE_FILE_PATH]: { type: 'string', value: 'https://sentry-test-site.example/path/to/script.js' },
+        [SENTRY_OP]: { type: 'string', value: 'ui.long_animation_frame' },
+        [SENTRY_ORIGIN]: { type: 'string', value: 'auto.ui.browser.metrics' },
       }),
-    );
-    const start = eventListenerUISpan.start_timestamp ?? 0;
-    const end = eventListenerUISpan.timestamp ?? 0;
-    const duration = end - start;
+    }),
+  );
 
-    expect(duration).toBeGreaterThanOrEqual(0.1);
-    expect(duration).toBeLessThanOrEqual(0.15);
-  },
-);
+  const start = eventListenerUISpan.start_timestamp ?? 0;
+  const end = eventListenerUISpan.end_timestamp ?? 0;
+  const duration = end - start;
+
+  expect(duration).toBeGreaterThanOrEqual(0.1);
+  expect(duration).toBeLessThanOrEqual(0.15);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-non-chromium/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-non-chromium/init.js
index 37df798364a8..382115cbc8b9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-non-chromium/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-non-chromium/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-non-chromium/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-non-chromium/test.ts
index 2c8f5427cc05..07d3a6cd313a 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-non-chromium/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-non-chromium/test.ts
@@ -1,8 +1,8 @@
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
 sentryTest(
   'should not capture long animation frame or long task when browser is non-chromium',
@@ -18,8 +18,10 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-    const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui'));
+    const spans = collectStreamedSpans(page);
+    await waitForStreamedSpanAndTraceHeaderOnUrl(page, url, span => getSpanOp(span) === 'pageload');
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const uiSpans = spans?.filter(span => getSpanOp(span)?.startsWith('ui'));
 
     expect(uiSpans?.length).toBe(0);
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-streamed/assets/script.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-static/assets/script.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-streamed/assets/script.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-static/assets/script.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-static/init.js
similarity index 88%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-static/init.js
index b0dc0a8d7ff5..37df798364a8 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-static/init.js
@@ -3,13 +3,13 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
       enableLongTask: true,
       enableLongAnimationFrame: true,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-streamed/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-streamed/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-static/test.ts
new file mode 100644
index 000000000000..fb252c80fa30
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-static/test.ts
@@ -0,0 +1,118 @@
+import { PAGELOAD, UI_LONG_ANIMATION_FRAME } from '@sentry/conventions/op';
+import {
+  BROWSER_SCRIPT_INVOKER,
+  CODE_FILE_PATH,
+  BROWSER_SCRIPT_SOURCE_CHAR_POSITION,
+  BROWSER_SCRIPT_INVOKER_TYPE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import type { Route } from '@playwright/test';
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest(
+  'should capture long animation frame for top-level script.',
+  async ({ browserName, getLocalTestUrl, page }) => {
+    // Long animation frames only work on chrome
+    if (shouldSkipTracingTest() || browserName !== 'chromium') {
+      sentryTest.skip();
+    }
+
+    // Long animation frame should take priority over long tasks
+
+    await page.route('**/path/to/script.js', (route: Route) =>
+      route.fulfill({ path: `${__dirname}/assets/script.js` }),
+    );
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const promise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+
+    await page.goto(url);
+
+    const eventData = envelopeRequestParser(await promise);
+
+    const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith(UI_LONG_ANIMATION_FRAME));
+
+    expect(uiSpans?.length).toBeGreaterThanOrEqual(1);
+
+    const topLevelUISpan = (uiSpans || []).find(
+      span => span.data?.[BROWSER_SCRIPT_INVOKER] === 'https://sentry-test-site.example/path/to/script.js',
+    )!;
+    expect(topLevelUISpan).toEqual(
+      expect.objectContaining({
+        op: UI_LONG_ANIMATION_FRAME,
+        description: 'Main UI thread blocked',
+        parent_span_id: eventData.contexts?.trace?.span_id,
+        data: {
+          [CODE_FILE_PATH]: 'https://sentry-test-site.example/path/to/script.js',
+          [BROWSER_SCRIPT_SOURCE_CHAR_POSITION]: 0,
+          [BROWSER_SCRIPT_INVOKER]: 'https://sentry-test-site.example/path/to/script.js',
+          [BROWSER_SCRIPT_INVOKER_TYPE]: 'classic-script',
+          [SENTRY_OP]: UI_LONG_ANIMATION_FRAME,
+          [SENTRY_ORIGIN]: 'auto.ui.browser.metrics',
+        },
+      }),
+    );
+    const start = topLevelUISpan.start_timestamp ?? 0;
+    const end = topLevelUISpan.timestamp ?? 0;
+    const duration = end - start;
+
+    expect(duration).toBeGreaterThanOrEqual(0.1);
+    expect(duration).toBeLessThanOrEqual(0.15);
+  },
+);
+
+sentryTest(
+  'should capture long animation frame for event listener.',
+  async ({ browserName, getLocalTestUrl, page }) => {
+    // Long animation frames only work on chrome
+    if (shouldSkipTracingTest() || browserName !== 'chromium') {
+      sentryTest.skip();
+    }
+
+    await page.route('**/path/to/script.js', (route: Route) =>
+      route.fulfill({ path: `${__dirname}/assets/script.js` }),
+    );
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const promise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+
+    await page.goto(url);
+
+    // trigger long animation frame function
+    await page.getByRole('button').click();
+
+    const eventData = envelopeRequestParser(await promise);
+
+    const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith(UI_LONG_ANIMATION_FRAME)) || [];
+
+    expect(uiSpans.length).toBeGreaterThanOrEqual(2);
+
+    const eventListenerUISpan = uiSpans.find(span => span.data[BROWSER_SCRIPT_INVOKER] === 'BUTTON#clickme.onclick')!;
+
+    expect(eventListenerUISpan).toEqual(
+      expect.objectContaining({
+        op: UI_LONG_ANIMATION_FRAME,
+        description: 'Main UI thread blocked',
+        parent_span_id: eventData.contexts?.trace?.span_id,
+        data: {
+          [BROWSER_SCRIPT_INVOKER]: 'BUTTON#clickme.onclick',
+          [BROWSER_SCRIPT_INVOKER_TYPE]: 'event-listener',
+          [CODE_FILE_PATH]: 'https://sentry-test-site.example/path/to/script.js',
+          [SENTRY_OP]: UI_LONG_ANIMATION_FRAME,
+          [SENTRY_ORIGIN]: 'auto.ui.browser.metrics',
+        },
+      }),
+    );
+    const start = eventListenerUISpan.start_timestamp ?? 0;
+    const end = eventListenerUISpan.timestamp ?? 0;
+    const duration = end - start;
+
+    expect(duration).toBeGreaterThanOrEqual(0.1);
+    expect(duration).toBeLessThanOrEqual(0.15);
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-streamed/test.ts
deleted file mode 100644
index 94ece2b74e6f..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled-streamed/test.ts
+++ /dev/null
@@ -1,110 +0,0 @@
-import { SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
-import type { Route } from '@playwright/test';
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest(
-  'captures long animation frame span for top-level script.',
-  async ({ browserName, getLocalTestUrl, page }) => {
-    // Long animation frames only work on chrome
-    sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
-
-    // Long animation frame should take priority over long tasks
-
-    await page.route('**/path/to/script.js', (route: Route) =>
-      route.fulfill({ path: `${__dirname}/assets/script.js` }),
-    );
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const spansPromise = waitForStreamedSpans(page, spans => spans.some(s => getSpanOp(s) === 'pageload'));
-
-    await page.goto(url);
-
-    const spans = await spansPromise;
-    const pageloadSpan = spans.find(s => getSpanOp(s) === 'pageload')!;
-
-    const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui.long_animation_frame'));
-
-    expect(uiSpans.length).toBeGreaterThanOrEqual(1);
-
-    const topLevelUISpan = uiSpans.find(
-      s => s.attributes['browser.script.invoker']?.value === 'https://sentry-test-site.example/path/to/script.js',
-    )!;
-
-    expect(topLevelUISpan).toEqual(
-      expect.objectContaining({
-        name: 'Main UI thread blocked',
-        parent_span_id: pageloadSpan.span_id,
-        attributes: expect.objectContaining({
-          'code.file.path': { type: 'string', value: 'https://sentry-test-site.example/path/to/script.js' },
-          'browser.script.source_char_position': expect.objectContaining({ value: 0 }),
-          'browser.script.invoker': {
-            type: 'string',
-            value: 'https://sentry-test-site.example/path/to/script.js',
-          },
-          'browser.script.invoker_type': { type: 'string', value: 'classic-script' },
-          [SENTRY_OP]: { type: 'string', value: 'ui.long_animation_frame' },
-          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.ui.browser.metrics' },
-        }),
-      }),
-    );
-
-    const start = topLevelUISpan.start_timestamp ?? 0;
-    const end = topLevelUISpan.end_timestamp ?? 0;
-    const duration = end - start;
-
-    expect(duration).toBeGreaterThanOrEqual(0.1);
-    expect(duration).toBeLessThanOrEqual(0.15);
-  },
-);
-
-sentryTest('captures long animation frame span for event listener.', async ({ browserName, getLocalTestUrl, page }) => {
-  // Long animation frames only work on chrome
-  sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
-
-  await page.route('**/path/to/script.js', (route: Route) => route.fulfill({ path: `${__dirname}/assets/script.js` }));
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const spansPromise = waitForStreamedSpans(page, spans => spans.some(s => getSpanOp(s) === 'pageload'));
-
-  await page.goto(url);
-
-  // trigger long animation frame function
-  await page.getByRole('button').click();
-
-  const spans = await spansPromise;
-  const pageloadSpan = spans.find(s => getSpanOp(s) === 'pageload')!;
-
-  const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui.long_animation_frame'));
-
-  expect(uiSpans.length).toBeGreaterThanOrEqual(2);
-
-  const eventListenerUISpan = uiSpans.find(
-    s => s.attributes['browser.script.invoker']?.value === 'BUTTON#clickme.onclick',
-  )!;
-
-  expect(eventListenerUISpan).toEqual(
-    expect.objectContaining({
-      name: 'Main UI thread blocked',
-      parent_span_id: pageloadSpan.span_id,
-      attributes: expect.objectContaining({
-        'browser.script.invoker': { type: 'string', value: 'BUTTON#clickme.onclick' },
-        'browser.script.invoker_type': { type: 'string', value: 'event-listener' },
-        'code.file.path': { type: 'string', value: 'https://sentry-test-site.example/path/to/script.js' },
-        [SENTRY_OP]: { type: 'string', value: 'ui.long_animation_frame' },
-        [SENTRY_ORIGIN]: { type: 'string', value: 'auto.ui.browser.metrics' },
-      }),
-    }),
-  );
-
-  const start = eventListenerUISpan.start_timestamp ?? 0;
-  const end = eventListenerUISpan.end_timestamp ?? 0;
-  const duration = end - start;
-
-  expect(duration).toBeGreaterThanOrEqual(0.1);
-  expect(duration).toBeLessThanOrEqual(0.15);
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled/init.js
index 37df798364a8..382115cbc8b9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled/test.ts
index b571a7d6a306..192956b477d9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-and-animation-frame-enabled/test.ts
@@ -1,17 +1,22 @@
-import { SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import {
+  BROWSER_SCRIPT_INVOKER,
+  CODE_FILE_PATH,
+  BROWSER_SCRIPT_SOURCE_CHAR_POSITION,
+  BROWSER_SCRIPT_INVOKER_TYPE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
-  'should capture long animation frame for top-level script.',
+  'captures long animation frame span for top-level script.',
   async ({ browserName, getLocalTestUrl, page }) => {
     // Long animation frames only work on chrome
-    if (shouldSkipTracingTest() || browserName !== 'chromium') {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
 
     // Long animation frame should take priority over long tasks
 
@@ -21,38 +26,43 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const promise = getFirstSentryEnvelopeRequest<Event>(page);
+    const spans = collectStreamedSpans(page);
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
 
     await page.goto(url);
 
-    await new Promise(resolve => setTimeout(resolve, 1000));
+    await pageloadSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const pageloadSpan = spans.find(s => getSpanOp(s) === 'pageload')!;
 
-    const eventData = await promise;
+    const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui.long_animation_frame'));
 
-    const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui.long_animation_frame'));
+    expect(uiSpans.length).toBeGreaterThanOrEqual(1);
 
-    expect(uiSpans?.length).toBeGreaterThanOrEqual(1);
-
-    const topLevelUISpan = (uiSpans || []).find(
-      span => span.data?.['browser.script.invoker'] === 'https://sentry-test-site.example/path/to/script.js',
+    const topLevelUISpan = uiSpans.find(
+      s => s.attributes[BROWSER_SCRIPT_INVOKER]?.value === 'https://sentry-test-site.example/path/to/script.js',
     )!;
+
     expect(topLevelUISpan).toEqual(
       expect.objectContaining({
-        op: 'ui.long_animation_frame',
-        description: 'Main UI thread blocked',
-        parent_span_id: eventData.contexts?.trace?.span_id,
-        data: {
-          'code.file.path': 'https://sentry-test-site.example/path/to/script.js',
-          'browser.script.source_char_position': 0,
-          'browser.script.invoker': 'https://sentry-test-site.example/path/to/script.js',
-          'browser.script.invoker_type': 'classic-script',
-          [SENTRY_OP]: 'ui.long_animation_frame',
-          [SENTRY_ORIGIN]: 'auto.ui.browser.metrics',
-        },
+        name: 'Main UI thread blocked',
+        parent_span_id: pageloadSpan.span_id,
+        attributes: expect.objectContaining({
+          [CODE_FILE_PATH]: { type: 'string', value: 'https://sentry-test-site.example/path/to/script.js' },
+          [BROWSER_SCRIPT_SOURCE_CHAR_POSITION]: expect.objectContaining({ value: 0 }),
+          [BROWSER_SCRIPT_INVOKER]: {
+            type: 'string',
+            value: 'https://sentry-test-site.example/path/to/script.js',
+          },
+          [BROWSER_SCRIPT_INVOKER_TYPE]: { type: 'string', value: 'classic-script' },
+          [SENTRY_OP]: { type: 'string', value: 'ui.long_animation_frame' },
+          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.ui.browser.metrics' },
+        }),
       }),
     );
+
     const start = topLevelUISpan.start_timestamp ?? 0;
-    const end = topLevelUISpan.timestamp ?? 0;
+    const end = topLevelUISpan.end_timestamp ?? 0;
     const duration = end - start;
 
     expect(duration).toBeGreaterThanOrEqual(0.1);
@@ -60,56 +70,51 @@ sentryTest(
   },
 );
 
-sentryTest(
-  'should capture long animation frame for event listener.',
-  async ({ browserName, getLocalTestUrl, page }) => {
-    // Long animation frames only work on chrome
-    if (shouldSkipTracingTest() || browserName !== 'chromium') {
-      sentryTest.skip();
-    }
-
-    await page.route('**/path/to/script.js', (route: Route) =>
-      route.fulfill({ path: `${__dirname}/assets/script.js` }),
-    );
+sentryTest('captures long animation frame span for event listener.', async ({ browserName, getLocalTestUrl, page }) => {
+  // Long animation frames only work on chrome
+  sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
 
-    const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.route('**/path/to/script.js', (route: Route) => route.fulfill({ path: `${__dirname}/assets/script.js` }));
 
-    const promise = getFirstSentryEnvelopeRequest<Event>(page);
+  const url = await getLocalTestUrl({ testDir: __dirname });
 
-    await page.goto(url);
+  const spans = collectStreamedSpans(page);
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
 
-    // trigger long animation frame function
-    await page.getByRole('button').click();
+  await page.goto(url);
 
-    await new Promise(resolve => setTimeout(resolve, 1000));
+  // trigger long animation frame function
+  await page.getByRole('button').click();
 
-    const eventData = await promise;
+  const pageloadSpan = await pageloadSpanPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-    const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui.long_animation_frame')) || [];
+  const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui.long_animation_frame'));
 
-    expect(uiSpans.length).toBeGreaterThanOrEqual(2);
+  expect(uiSpans.length).toBeGreaterThanOrEqual(2);
 
-    const eventListenerUISpan = uiSpans.find(span => span.data['browser.script.invoker'] === 'BUTTON#clickme.onclick')!;
+  const eventListenerUISpan = uiSpans.find(
+    s => s.attributes[BROWSER_SCRIPT_INVOKER]?.value === 'BUTTON#clickme.onclick',
+  )!;
 
-    expect(eventListenerUISpan).toEqual(
-      expect.objectContaining({
-        op: 'ui.long_animation_frame',
-        description: 'Main UI thread blocked',
-        parent_span_id: eventData.contexts?.trace?.span_id,
-        data: {
-          'browser.script.invoker': 'BUTTON#clickme.onclick',
-          'browser.script.invoker_type': 'event-listener',
-          'code.file.path': 'https://sentry-test-site.example/path/to/script.js',
-          [SENTRY_OP]: 'ui.long_animation_frame',
-          [SENTRY_ORIGIN]: 'auto.ui.browser.metrics',
-        },
+  expect(eventListenerUISpan).toEqual(
+    expect.objectContaining({
+      name: 'Main UI thread blocked',
+      parent_span_id: pageloadSpan.span_id,
+      attributes: expect.objectContaining({
+        [BROWSER_SCRIPT_INVOKER]: { type: 'string', value: 'BUTTON#clickme.onclick' },
+        [BROWSER_SCRIPT_INVOKER_TYPE]: { type: 'string', value: 'event-listener' },
+        [CODE_FILE_PATH]: { type: 'string', value: 'https://sentry-test-site.example/path/to/script.js' },
+        [SENTRY_OP]: { type: 'string', value: 'ui.long_animation_frame' },
+        [SENTRY_ORIGIN]: { type: 'string', value: 'auto.ui.browser.metrics' },
       }),
-    );
-    const start = eventListenerUISpan.start_timestamp ?? 0;
-    const end = eventListenerUISpan.timestamp ?? 0;
-    const duration = end - start;
+    }),
+  );
 
-    expect(duration).toBeGreaterThanOrEqual(0.1);
-    expect(duration).toBeLessThanOrEqual(0.15);
-  },
-);
+  const start = eventListenerUISpan.start_timestamp ?? 0;
+  const end = eventListenerUISpan.end_timestamp ?? 0;
+  const duration = end - start;
+
+  expect(duration).toBeGreaterThanOrEqual(0.1);
+  expect(duration).toBeLessThanOrEqual(0.15);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-static/init.js
similarity index 90%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-static/init.js
index 9f36511d8ff5..63abc00dea38 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-static/init.js
@@ -3,6 +3,7 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
@@ -12,7 +13,6 @@ Sentry.init({
       enableInp: false,
       enableLongTask: true,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-static/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-streamed/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-static/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-streamed/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-streamed/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-static/test.ts
similarity index 50%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-streamed/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-static/test.ts
index 7e544f27a107..5236717091f1 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-streamed/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation-static/test.ts
@@ -1,29 +1,30 @@
 import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
+import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
 
 sentryTest(
   "doesn't capture long task spans starting before a navigation in the navigation transaction",
   async ({ browserName, getLocalTestUrl, page }) => {
     // Long tasks only work on chrome
-    sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
+    if (shouldSkipTracingTest() || browserName !== 'chromium') {
+      sentryTest.skip();
+    }
     const url = await getLocalTestUrl({ testDir: __dirname });
 
     await page.route('**/path/to/script.js', route => route.fulfill({ path: `${__dirname}/assets/script.js` }));
 
-    const navigationSpansPromise = waitForStreamedSpans(page, spans => spans.some(s => getSpanOp(s) === 'navigation'));
-
     await page.goto(url);
 
+    const navigationTransactionEventPromise = getFirstSentryEnvelopeRequest<Event>(page);
+
     await page.locator('#myButton').click();
 
-    const spans = await navigationSpansPromise;
+    const navigationTransactionEvent = await navigationTransactionEventPromise;
 
-    const navigationSpan = spans.find(s => getSpanOp(s) === 'navigation');
-    expect(navigationSpan).toBeDefined();
+    expect(navigationTransactionEvent.contexts?.trace?.op).toBe('navigation');
 
-    const longTaskSpans = spans.filter(s => getSpanOp(s) === 'ui.long_task');
+    const longTaskSpans = navigationTransactionEvent?.spans?.filter(span => span.op === 'ui.long_task');
     expect(longTaskSpans).toHaveLength(0);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation/init.js
index 63abc00dea38..ccf669361e37 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation/test.ts
index 5236717091f1..fb458438ed43 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-before-navigation/test.ts
@@ -1,30 +1,33 @@
+import { SENTRY_SEGMENT_ID } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
-  "doesn't capture long task spans starting before a navigation in the navigation transaction",
+  "doesn't capture long task spans starting before a navigation in the navigation span",
   async ({ browserName, getLocalTestUrl, page }) => {
     // Long tasks only work on chrome
-    if (shouldSkipTracingTest() || browserName !== 'chromium') {
-      sentryTest.skip();
-    }
+    sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
     const url = await getLocalTestUrl({ testDir: __dirname });
 
     await page.route('**/path/to/script.js', route => route.fulfill({ path: `${__dirname}/assets/script.js` }));
 
-    await page.goto(url);
+    const allSpans = collectStreamedSpans(page);
+    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
 
-    const navigationTransactionEventPromise = getFirstSentryEnvelopeRequest<Event>(page);
+    await page.goto(url);
 
     await page.locator('#myButton').click();
 
-    const navigationTransactionEvent = await navigationTransactionEventPromise;
+    const navigationRoot = await navigationSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const spans = allSpans.filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === navigationRoot.span_id);
 
-    expect(navigationTransactionEvent.contexts?.trace?.op).toBe('navigation');
+    const navigationSpan = spans.find(s => getSpanOp(s) === 'navigation');
+    expect(navigationSpan).toBeDefined();
 
-    const longTaskSpans = navigationTransactionEvent?.spans?.filter(span => span.op === 'ui.long_task');
+    const longTaskSpans = spans.filter(s => getSpanOp(s) === 'ui.long_task');
     expect(longTaskSpans).toHaveLength(0);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-streamed/assets/script.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-static/assets/script.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-streamed/assets/script.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-static/assets/script.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-static/init.js
similarity index 88%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-static/init.js
index 3c004b952f80..250f2a72311b 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-animation-frame-disabled-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-static/init.js
@@ -3,13 +3,13 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
       enableLongTask: false,
       enableLongAnimationFrame: false,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-streamed/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-streamed/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-static/test.ts
new file mode 100644
index 000000000000..bb32e21ee1d5
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-static/test.ts
@@ -0,0 +1,21 @@
+import type { Route } from '@playwright/test';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest('should not capture long task when flag is disabled.', async ({ browserName, getLocalTestUrl, page }) => {
+  // Long tasks only work on chrome
+  if (shouldSkipTracingTest() || browserName !== 'chromium') {
+    sentryTest.skip();
+  }
+
+  await page.route('**/path/to/script.js', (route: Route) => route.fulfill({ path: `${__dirname}/assets/script.js` }));
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui'));
+
+  expect(uiSpans?.length).toBe(0);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-streamed/test.ts
deleted file mode 100644
index da7f44f05df7..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled-streamed/test.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import type { Route } from '@playwright/test';
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest("doesn't capture long task spans when flag is disabled.", async ({ browserName, getLocalTestUrl, page }) => {
-  // Long tasks only work on chrome
-  sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
-
-  await page.route('**/path/to/script.js', (route: Route) => route.fulfill({ path: `${__dirname}/assets/script.js` }));
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const spansPromise = waitForStreamedSpans(page, spans => spans.some(s => getSpanOp(s) === 'pageload'));
-
-  await page.goto(url);
-
-  const spans = await spansPromise;
-  const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui'));
-
-  expect(uiSpans.length).toBe(0);
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled/init.js
index 250f2a72311b..0339c3fa3dbf 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled/test.ts
index bb32e21ee1d5..6ebf0c018e6f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-disabled/test.ts
@@ -1,21 +1,25 @@
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest('should not capture long task when flag is disabled.', async ({ browserName, getLocalTestUrl, page }) => {
+sentryTest("doesn't capture long task spans when flag is disabled.", async ({ browserName, getLocalTestUrl, page }) => {
   // Long tasks only work on chrome
-  if (shouldSkipTracingTest() || browserName !== 'chromium') {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
 
   await page.route('**/path/to/script.js', (route: Route) => route.fulfill({ path: `${__dirname}/assets/script.js` }));
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui'));
+  const spans = collectStreamedSpans(page);
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
 
-  expect(uiSpans?.length).toBe(0);
+  await page.goto(url);
+
+  await pageloadSpanPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui'));
+
+  expect(uiSpans.length).toBe(0);
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-streamed/assets/script.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-static/assets/script.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-streamed/assets/script.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-static/assets/script.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-static/init.js
similarity index 87%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-static/init.js
index 977ff9c6425e..73d20634b532 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-static/init.js
@@ -3,12 +3,12 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
       enableLongAnimationFrame: false,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-streamed/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-streamed/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-static/test.ts
new file mode 100644
index 000000000000..e34b0d779f7e
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-static/test.ts
@@ -0,0 +1,36 @@
+import type { Route } from '@playwright/test';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest('should capture long task.', async ({ browserName, getLocalTestUrl, page }) => {
+  // Long tasks only work on chrome
+  if (shouldSkipTracingTest() || browserName !== 'chromium') {
+    sentryTest.skip();
+  }
+
+  await page.route('**/path/to/script.js', (route: Route) => route.fulfill({ path: `${__dirname}/assets/script.js` }));
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui'));
+
+  expect(uiSpans?.length).toBeGreaterThan(0);
+
+  const [firstUISpan] = uiSpans || [];
+  expect(firstUISpan).toEqual(
+    expect.objectContaining({
+      op: 'ui.long_task',
+      description: 'Main UI thread blocked',
+      parent_span_id: eventData.contexts?.trace?.span_id,
+    }),
+  );
+  const start = firstUISpan.start_timestamp ?? 0;
+  const end = firstUISpan.timestamp ?? 0;
+  const duration = end - start;
+
+  expect(duration).toBeGreaterThanOrEqual(0.1);
+  expect(duration).toBeLessThanOrEqual(0.15);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-streamed/test.ts
deleted file mode 100644
index 1eeb65579b39..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled-streamed/test.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import type { Route } from '@playwright/test';
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest('captures long task.', async ({ browserName, getLocalTestUrl, page }) => {
-  // Long tasks only work on chrome
-  sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
-
-  await page.route('**/path/to/script.js', (route: Route) => route.fulfill({ path: `${__dirname}/assets/script.js` }));
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const spansPromise = waitForStreamedSpans(page, spans => spans.some(s => getSpanOp(s) === 'pageload'));
-
-  await page.goto(url);
-
-  const spans = await spansPromise;
-  const pageloadSpan = spans.find(s => getSpanOp(s) === 'pageload')!;
-
-  const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui'));
-  expect(uiSpans.length).toBeGreaterThan(0);
-
-  const [firstUISpan] = uiSpans;
-  expect(firstUISpan).toEqual(
-    expect.objectContaining({
-      name: 'Main UI thread blocked',
-      parent_span_id: pageloadSpan.span_id,
-      attributes: expect.objectContaining({
-        'sentry.op': { type: 'string', value: 'ui.long_task' },
-      }),
-    }),
-  );
-
-  const start = firstUISpan.start_timestamp ?? 0;
-  const end = firstUISpan.end_timestamp ?? 0;
-  const duration = end - start;
-
-  expect(duration).toBeGreaterThanOrEqual(0.1);
-  expect(duration).toBeLessThanOrEqual(0.15);
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled/init.js
index 73d20634b532..47e9fd0b92d8 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled/test.ts
index e34b0d779f7e..add1a8130425 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-enabled/test.ts
@@ -1,34 +1,42 @@
+import { SENTRY_OP } from '@sentry/conventions/attributes';
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest('should capture long task.', async ({ browserName, getLocalTestUrl, page }) => {
+sentryTest('captures long task.', async ({ browserName, getLocalTestUrl, page }) => {
   // Long tasks only work on chrome
-  if (shouldSkipTracingTest() || browserName !== 'chromium') {
-    sentryTest.skip();
-  }
+  sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
 
   await page.route('**/path/to/script.js', (route: Route) => route.fulfill({ path: `${__dirname}/assets/script.js` }));
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui'));
+  const spans = collectStreamedSpans(page);
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
 
-  expect(uiSpans?.length).toBeGreaterThan(0);
+  await page.goto(url);
 
-  const [firstUISpan] = uiSpans || [];
+  const pageloadSpan = await pageloadSpanPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+
+  const uiSpans = spans.filter(s => getSpanOp(s)?.startsWith('ui'));
+  expect(uiSpans.length).toBeGreaterThan(0);
+
+  const [firstUISpan] = uiSpans;
   expect(firstUISpan).toEqual(
     expect.objectContaining({
-      op: 'ui.long_task',
-      description: 'Main UI thread blocked',
-      parent_span_id: eventData.contexts?.trace?.span_id,
+      name: 'Main UI thread blocked',
+      parent_span_id: pageloadSpan.span_id,
+      attributes: expect.objectContaining({
+        [SENTRY_OP]: { type: 'string', value: 'ui.long_task' },
+      }),
     }),
   );
+
   const start = firstUISpan.start_timestamp ?? 0;
-  const end = firstUISpan.timestamp ?? 0;
+  const end = firstUISpan.end_timestamp ?? 0;
   const duration = end - start;
 
   expect(duration).toBeGreaterThanOrEqual(0.1);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-no-animation-frame/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-no-animation-frame/init.js
index a7797f5dce06..723707736f2e 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-no-animation-frame/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-no-animation-frame/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-no-animation-frame/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-no-animation-frame/test.ts
index e34b0d779f7e..707a336d3df1 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-no-animation-frame/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/long-tasks-no-animation-frame/test.ts
@@ -1,8 +1,9 @@
+import { SENTRY_OP } from '@sentry/conventions/attributes';
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
 sentryTest('should capture long task.', async ({ browserName, getLocalTestUrl, page }) => {
   // Long tasks only work on chrome
@@ -14,21 +15,27 @@ sentryTest('should capture long task.', async ({ browserName, getLocalTestUrl, p
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const uiSpans = eventData.spans?.filter(({ op }) => op?.startsWith('ui'));
+  const spans = collectStreamedSpans(page);
+  const [pageloadSpan] = await waitForStreamedSpanAndTraceHeaderOnUrl(
+    page,
+    url,
+    span => getSpanOp(span) === 'pageload',
+  );
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const uiSpans = spans.filter(span => getSpanOp(span)?.startsWith('ui'));
 
-  expect(uiSpans?.length).toBeGreaterThan(0);
+  expect(uiSpans.length).toBeGreaterThan(0);
 
-  const [firstUISpan] = uiSpans || [];
+  const [firstUISpan] = uiSpans;
   expect(firstUISpan).toEqual(
     expect.objectContaining({
-      op: 'ui.long_task',
-      description: 'Main UI thread blocked',
-      parent_span_id: eventData.contexts?.trace?.span_id,
+      attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'ui.long_task' } }),
+      name: 'Main UI thread blocked',
+      parent_span_id: pageloadSpan.span_id,
     }),
   );
   const start = firstUISpan.start_timestamp ?? 0;
-  const end = firstUISpan.timestamp ?? 0;
+  const end = firstUISpan.end_timestamp ?? 0;
   const duration = end - start;
 
   expect(duration).toBeGreaterThanOrEqual(0.1);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/meta/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/meta/init.js
index 52fc529d095a..d4c7810ef518 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/meta/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/meta/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/meta/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/meta/test.ts
index 1d7a14a46055..86b7d100bb37 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/meta/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/meta/test.ts
@@ -1,43 +1,31 @@
+import { SENTRY_SEGMENT_ID } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event, EventEnvelopeHeaders } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import {
-  envelopeHeaderRequestParser,
-  getFirstSentryEnvelopeRequest,
-  shouldSkipTracingTest,
-} from '../../../../utils/helpers';
-
-sentryTest('should create a pageload transaction based on `sentry-trace` <meta>', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
+sentryTest('creates a pageload span based on `sentry-trace` <meta>', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
   const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-
-  expect(eventData.contexts?.trace).toMatchObject({
-    op: 'pageload',
+  const spans = collectStreamedSpans(page);
+  const [pageload] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
+  await page.evaluate(() => (window as any).Sentry.flush());
+  expect(getSpanOp(pageload)).toBe('pageload');
+  expect(pageload).toMatchObject({
+    is_segment: true,
     parent_span_id: '1121201211212012',
     trace_id: '12312012123120121231201212312012',
   });
-
-  expect(eventData.spans?.length).toBeGreaterThan(0);
+  expect(spans.filter(span => !span.is_segment)).not.toHaveLength(0);
 });
 
 sentryTest(
-  'should pick up `baggage` <meta> tag, propagate the content in transaction and not add own data',
+  'propagates `baggage` <meta> in the span envelope without adding own data',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
-
+    sentryTest.skip(shouldSkipTracingTest());
     const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const envHeader = await getFirstSentryEnvelopeRequest<EventEnvelopeHeaders>(page, url, envelopeHeaderRequestParser);
-
-    expect(envHeader.trace).toBeDefined();
-    expect(envHeader.trace).toEqual({
+    const [, trace] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
+    expect(trace).toEqual({
       release: '2.1.12',
       sample_rate: '0.3232',
       trace_id: '123',
@@ -47,47 +35,31 @@ sentryTest(
   },
 );
 
-sentryTest(
-  "should create a navigation that's not influenced by `sentry-trace` <meta>",
-  async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const pageloadRequest = await getFirstSentryEnvelopeRequest<Event>(page, url);
-    const navigationRequest = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#foo`);
-
-    expect(pageloadRequest.contexts?.trace).toMatchObject({
-      op: 'pageload',
-      parent_span_id: '1121201211212012',
-      trace_id: '12312012123120121231201212312012',
-    });
-
-    expect(navigationRequest.contexts?.trace?.op).toBe('navigation');
-    expect(navigationRequest.contexts?.trace?.trace_id).toBeDefined();
-    expect(navigationRequest.contexts?.trace?.trace_id).not.toBe(pageloadRequest.contexts?.trace?.trace_id);
-
-    const pageloadSpans = pageloadRequest.spans;
-    const navigationSpans = navigationRequest.spans;
-
-    const pageloadSpanId = pageloadRequest.contexts?.trace?.span_id;
-    const navigationSpanId = navigationRequest.contexts?.trace?.span_id;
-
-    expect(pageloadSpanId).toBeDefined();
-    expect(navigationSpanId).toBeDefined();
-
-    pageloadSpans?.forEach(span =>
-      expect(span).toMatchObject({
-        parent_span_id: pageloadSpanId,
-      }),
-    );
-
-    navigationSpans?.forEach(span =>
-      expect(span).toMatchObject({
-        parent_span_id: navigationSpanId,
-      }),
-    );
-  },
-);
+sentryTest("creates a navigation that's not influenced by `sentry-trace` <meta>", async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const spans = collectStreamedSpans(page);
+  const [pageload] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
+  const [navigation] = await waitForStreamedSpanAndTraceHeaderOnUrl(
+    page,
+    `${url}#foo`,
+    span => getSpanOp(span) === 'navigation',
+  );
+  await page.evaluate(() => (window as any).Sentry.flush());
+
+  expect(getSpanOp(pageload)).toBe('pageload');
+  expect(pageload).toMatchObject({
+    parent_span_id: '1121201211212012',
+    trace_id: '12312012123120121231201212312012',
+  });
+  expect(getSpanOp(navigation)).toBe('navigation');
+  expect(navigation.trace_id).toBeDefined();
+  expect(navigation.trace_id).not.toBe(pageload.trace_id);
+  expect(pageload.span_id).toBeDefined();
+  expect(navigation.span_id).toBeDefined();
+  for (const root of [pageload, navigation]) {
+    spans
+      .filter(span => !span.is_segment && span.attributes[SENTRY_SEGMENT_ID]?.value === root.span_id)
+      .forEach(span => expect(span.parent_span_id).toBe(root.span_id));
+  }
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-aborting-pageload/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-aborting-pageload/init.js
index f1e482cc6950..fcce12c3dca2 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-aborting-pageload/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-aborting-pageload/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-aborting-pageload/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-aborting-pageload/test.ts
index 829710ce5011..c62d4a2a7b3f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-aborting-pageload/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-aborting-pageload/test.ts
@@ -1,69 +1,71 @@
-import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import {
+  URL_PATH,
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  USER_AGENT_ORIGINAL,
+  URL_FULL,
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest(
-  'should create a navigation transaction that aborts an ongoing pageload',
-  async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
+sentryTest('should create a navigation span that aborts an ongoing pageload', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
 
-    const url = await getLocalTestUrl({ testDir: __dirname });
+  const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
-    const navigationRequestPromise = waitForTransactionRequest(
-      page,
-      event => event.contexts?.trace?.op === 'navigation',
-    );
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+  const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
 
-    await page.goto(url);
+  await page.goto(url);
 
-    const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
-    const navigationRequest = envelopeRequestParser(await navigationRequestPromise);
+  const pageloadSpan = await pageloadSpanPromise;
+  const navigationSpan = await navigationSpanPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-    expect(pageloadRequest.contexts?.trace?.op).toBe('pageload');
-    expect(navigationRequest.contexts?.trace?.op).toBe('navigation');
+  expect(getSpanOp(pageloadSpan)).toBe('pageload');
+  expect(getSpanOp(navigationSpan)).toBe('navigation');
 
-    expect(navigationRequest.transaction_info?.source).toEqual('url');
+  expect(navigationSpan.attributes[SENTRY_SEGMENT_NAME_SOURCE]?.value).toEqual('url');
 
-    const pageloadTraceId = pageloadRequest.contexts?.trace?.trace_id;
-    const navigationTraceId = navigationRequest.contexts?.trace?.trace_id;
+  const pageloadTraceId = pageloadSpan.trace_id;
+  const navigationTraceId = navigationSpan.trace_id;
 
-    expect(pageloadTraceId).toBeDefined();
-    expect(navigationTraceId).toBeDefined();
-    expect(pageloadTraceId).not.toEqual(navigationTraceId);
+  expect(pageloadTraceId).toBeDefined();
+  expect(navigationTraceId).toBeDefined();
+  expect(pageloadTraceId).not.toEqual(navigationTraceId);
 
-    expect(pageloadRequest.transaction).toEqual('/index.html');
-    expect(navigationRequest.transaction).toEqual('/sub-page');
+  expect(pageloadSpan.name).toEqual('Pageload');
+  expect(pageloadSpan.attributes[URL_PATH]?.value).toEqual('/index.html');
+  expect(navigationSpan.name).toEqual('Navigation');
+  expect(navigationSpan.attributes[URL_PATH]?.value).toEqual('/sub-page');
 
-    expect(pageloadRequest.contexts?.trace?.data).toMatchObject({
-      [SENTRY_ORIGIN]: 'auto.pageload.browser',
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-      [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-      [SENTRY_OP]: 'pageload',
-      ['sentry.idle_span_finish_reason']: 'cancelled',
-    });
-    expect(navigationRequest.contexts?.trace?.data).toMatchObject({
-      [SENTRY_ORIGIN]: 'auto.navigation.browser',
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-      [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-      [SENTRY_OP]: 'navigation',
-      ['sentry.idle_span_finish_reason']: 'idleTimeout',
-    });
-    expect(pageloadRequest.request).toEqual({
-      headers: {
-        'User-Agent': expect.any(String),
-      },
-      url: 'http://sentry-test.io/index.html',
-    });
-    expect(navigationRequest.request).toEqual({
-      headers: {
-        'User-Agent': expect.any(String),
-      },
-      url: 'http://sentry-test.io/sub-page',
-    });
-  },
-);
+  expect(pageloadSpan.attributes).toMatchObject({
+    [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
+    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: { type: 'integer', value: 1 },
+    [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'url' },
+    [SENTRY_OP]: { type: 'string', value: 'pageload' },
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: { type: 'string', value: 'cancelled' },
+  });
+  expect(navigationSpan.attributes).toMatchObject({
+    [SENTRY_ORIGIN]: { type: 'string', value: 'auto.navigation.browser' },
+    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: { type: 'integer', value: 1 },
+    [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'url' },
+    [SENTRY_OP]: { type: 'string', value: 'navigation' },
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: { type: 'string', value: 'idleTimeout' },
+  });
+  expect(pageloadSpan.attributes).toMatchObject({
+    [USER_AGENT_ORIGINAL]: { type: 'string', value: expect.any(String) },
+    [URL_FULL]: { type: 'string', value: 'http://sentry-test.io/index.html' },
+  });
+  expect(navigationSpan.attributes).toMatchObject({
+    [USER_AGENT_ORIGINAL]: { type: 'string', value: expect.any(String) },
+    [URL_FULL]: { type: 'string', value: 'http://sentry-test.io/sub-page' },
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/multiple-redirects/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/multiple-redirects/init.js
index b538f322b360..484a12682a2d 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/multiple-redirects/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/multiple-redirects/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/multiple-redirects/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/multiple-redirects/test.ts
index caa2b6afb328..75f306ef5078 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/multiple-redirects/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/multiple-redirects/test.ts
@@ -1,8 +1,13 @@
 import { expect } from '@playwright/test';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 import {
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  USER_AGENT_ORIGINAL,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SEGMENT_NAME,
   SENTRY_SEGMENT_NAME_SOURCE,
   URL_FULL,
   URL_PATH,
@@ -17,66 +22,72 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const allSpans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
-    const navigationRequestPromise = waitForTransactionRequest(
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    const navigationSpanPromise = waitForStreamedSpan(
       page,
-      event => event.contexts?.trace?.op === 'navigation' && event.transaction === '/next-page',
+      span => getSpanOp(span) === 'navigation' && span.attributes[URL_PATH]?.value === '/next-page',
     );
 
     await page.goto(url);
 
-    const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
-    const navigationRequest = envelopeRequestParser(await navigationRequestPromise);
+    const pageloadSpan = await pageloadSpanPromise;
+    const navigationSpan = await navigationSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
 
-    expect(pageloadRequest.contexts?.trace?.op).toBe('pageload');
+    expect(getSpanOp(pageloadSpan)).toBe('pageload');
 
-    expect(pageloadRequest.contexts?.trace?.data).toMatchObject({
-      [SENTRY_ORIGIN]: 'auto.pageload.browser',
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-      [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-      [SENTRY_OP]: 'pageload',
-      ['sentry.idle_span_finish_reason']: 'cancelled',
+    expect(pageloadSpan.attributes).toMatchObject({
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: { type: 'integer', value: 1 },
+      [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'url' },
+      [SENTRY_OP]: { type: 'string', value: 'pageload' },
+      [SENTRY_IDLE_SPAN_FINISH_REASON]: { type: 'string', value: 'cancelled' },
     });
 
-    expect(pageloadRequest.request).toEqual({
-      headers: {
-        'User-Agent': expect.any(String),
-      },
-      url: 'http://sentry-test.io/index.html',
+    expect(pageloadSpan.attributes).toMatchObject({
+      [USER_AGENT_ORIGINAL]: { type: 'string', value: expect.any(String) },
+      [URL_FULL]: { type: 'string', value: 'http://sentry-test.io/index.html' },
     });
 
-    const spans = pageloadRequest.spans || [];
+    const spans = allSpans.filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === pageloadSpan.span_id);
 
-    const redirectSpans = spans.filter(span => span.op === 'navigation.redirect');
+    const redirectSpans = spans.filter(span => getSpanOp(span) === 'navigation.redirect');
     expect(redirectSpans).toHaveLength(3);
 
     redirectSpans.forEach(redirectSpan => {
-      expect(redirectSpan?.timestamp).toEqual(redirectSpan?.start_timestamp);
-      expect(redirectSpan).toEqual({
-        data: {
-          'sentry.op': 'navigation.redirect',
-          'sentry.origin': 'auto.navigation.browser',
-          [URL_FULL]: expect.any(String),
-          [URL_PATH]: expect.any(String),
+      expect(redirectSpan?.end_timestamp).toEqual(redirectSpan?.start_timestamp);
+      expect(redirectSpan).toMatchObject({
+        attributes: {
+          [SENTRY_OP]: { type: 'string', value: 'navigation.redirect' },
+          [SENTRY_ORIGIN]: { type: 'string', value: 'auto.navigation.browser' },
+          [SENTRY_SEGMENT_ID]: { type: 'string', value: pageloadSpan.span_id },
+          [SENTRY_SEGMENT_NAME]: { type: 'string', value: 'Pageload' },
+          [URL_FULL]: { type: 'string', value: expect.any(String) },
+          [URL_PATH]: { type: 'string', value: expect.any(String) },
         },
-        description: expect.stringContaining('/sub-page-redirect-'),
-        op: 'navigation.redirect',
-        origin: 'auto.navigation.browser',
+        name: 'Navigation',
+        is_segment: false,
         status: 'ok',
-        parent_span_id: pageloadRequest.contexts!.trace!.span_id,
+        parent_span_id: pageloadSpan.span_id,
         span_id: expect.any(String),
         start_timestamp: expect.any(Number),
-        timestamp: expect.any(Number),
+        end_timestamp: expect.any(Number),
         trace_id: expect.any(String),
       });
     });
 
-    expect(navigationRequest.contexts?.trace?.op).toBe('navigation');
-    expect(navigationRequest.transaction).toEqual('/next-page');
+    expect(getSpanOp(navigationSpan)).toBe('navigation');
+    expect(navigationSpan.name).toEqual('Navigation');
+    expect(navigationSpan.attributes[URL_PATH]?.value).toEqual('/next-page');
 
     // 2 subsequent redirects belonging to the navigation root span
-    expect(navigationRequest.spans?.filter(span => span.op === 'navigation.redirect')).toHaveLength(2);
+    expect(
+      allSpans
+        .filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === navigationSpan.span_id)
+        .filter(span => getSpanOp(span) === 'navigation.redirect'),
+    ).toHaveLength(2);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-click/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-click/init.js
index b85590114a76..c3e90ce95430 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-click/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-click/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-click/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-click/test.ts
index a88987209bcd..93e77f615917 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-click/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-click/test.ts
@@ -1,6 +1,8 @@
+import { URL_PATH, SENTRY_SEGMENT_ID } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest(
   'creates navigation root span if click happened within 1.5s of the last navigation',
@@ -9,39 +11,47 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const allSpans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
-    const navigationRequestPromise = waitForTransactionRequest(
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    const navigationSpanPromise = waitForStreamedSpan(
       page,
-      event => event.contexts?.trace?.op === 'navigation' && event.transaction === '/sub-page',
+      span => getSpanOp(span) === 'navigation' && span.attributes[URL_PATH]?.value === '/sub-page',
     );
-    const navigation2RequestPromise = waitForTransactionRequest(
+    const navigation2SpanPromise = waitForStreamedSpan(
       page,
-      event => event.contexts?.trace?.op === 'navigation' && event.transaction === '/sub-page-2',
+      span => getSpanOp(span) === 'navigation' && span.attributes[URL_PATH]?.value === '/sub-page-2',
     );
 
     await page.goto(url);
 
-    await pageloadRequestPromise;
+    await pageloadSpanPromise;
 
     // Now trigger navigation (since no span is active), and then a redirect in the navigation, with
     await page.click('#btn1');
 
-    const navigationRequest = envelopeRequestParser(await navigationRequestPromise);
-    const navigation2Request = envelopeRequestParser(await navigation2RequestPromise);
+    const navigationSpan = await navigationSpanPromise;
+    const navigation2Span = await navigation2SpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
 
-    expect(navigationRequest.contexts?.trace?.op).toBe('navigation');
-    expect(navigationRequest.transaction).toEqual('/sub-page');
+    expect(getSpanOp(navigationSpan)).toBe('navigation');
+    expect(navigationSpan.name).toEqual('Navigation');
+    expect(navigationSpan.attributes[URL_PATH]?.value).toEqual('/sub-page');
 
-    const spans = (navigationRequest.spans || []).filter(s => s.op === 'navigation.redirect');
+    const spans = allSpans
+      .filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === navigationSpan.span_id)
+      .filter(s => getSpanOp(s) === 'navigation.redirect');
 
     expect(spans).toHaveLength(0);
 
-    expect(navigation2Request.contexts?.trace?.op).toBe('navigation');
-    expect(navigation2Request.transaction).toEqual('/sub-page-2');
+    expect(getSpanOp(navigation2Span)).toBe('navigation');
+    expect(navigation2Span.name).toEqual('Navigation');
+    expect(navigation2Span.attributes[URL_PATH]?.value).toEqual('/sub-page-2');
 
-    const spans2 = (navigation2Request.spans || []).filter(s => s.op === 'navigation.redirect');
+    const spans2 = allSpans
+      .filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === navigation2Span.span_id)
+      .filter(s => getSpanOp(s) === 'navigation.redirect');
     expect(spans2).toHaveLength(0);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-keypress/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-keypress/init.js
index b53ef315b481..f9d8db46d3d9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-keypress/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-keypress/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-keypress/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-keypress/test.ts
index fe152feda462..fe01834e77cb 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-keypress/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-navigation-keypress/test.ts
@@ -1,6 +1,8 @@
+import { URL_PATH, SENTRY_SEGMENT_ID } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest(
   'creates a navigation root span if a keypress happened within the last 1.5s',
@@ -9,22 +11,23 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const allSpans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
-    const navigationRequestPromise = waitForTransactionRequest(
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    const navigationSpanPromise = waitForStreamedSpan(
       page,
-      event => event.contexts?.trace?.op === 'navigation' && event.transaction === '/sub-page',
+      span => getSpanOp(span) === 'navigation' && span.attributes[URL_PATH]?.value === '/sub-page',
     );
 
-    const navigationRequest2Promise = waitForTransactionRequest(
+    const navigationSpan2Promise = waitForStreamedSpan(
       page,
-      event => event.contexts?.trace?.op === 'navigation' && event.transaction === '/sub-page-2',
+      span => getSpanOp(span) === 'navigation' && span.attributes[URL_PATH]?.value === '/sub-page-2',
     );
 
     await page.goto(url);
 
-    await pageloadRequestPromise;
+    await pageloadSpanPromise;
 
     await page.focus('#btn1');
     await page.keyboard.press('Enter');
@@ -34,21 +37,29 @@ sentryTest(
     await page.focus('#btn2');
     await page.keyboard.press('Enter');
 
-    const navigationRequest = envelopeRequestParser(await navigationRequestPromise);
-    const navigationRequest2 = envelopeRequestParser(await navigationRequest2Promise);
+    const navigationSpan = await navigationSpanPromise;
+    const navigationSpan2 = await navigationSpan2Promise;
+    await page.evaluate(() => (window as any).Sentry.flush());
 
-    expect(navigationRequest.contexts?.trace?.op).toBe('navigation');
-    expect(navigationRequest.transaction).toEqual('/sub-page');
+    expect(getSpanOp(navigationSpan)).toBe('navigation');
+    expect(navigationSpan.name).toEqual('Navigation');
+    expect(navigationSpan.attributes[URL_PATH]?.value).toEqual('/sub-page');
 
-    const redirectSpans = navigationRequest.spans?.filter(span => span.op === 'navigation.redirect') || [];
+    const redirectSpans = allSpans
+      .filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === navigationSpan.span_id)
+      .filter(span => getSpanOp(span) === 'navigation.redirect');
     expect(redirectSpans).toHaveLength(1);
 
-    expect(redirectSpans[0].description).toEqual('/sub-page-redirect');
+    expect(redirectSpans[0].name).toBe('Navigation');
+    expect(redirectSpans[0].attributes[URL_PATH]?.value).toBe('/sub-page-redirect');
 
-    expect(navigationRequest2.contexts?.trace?.op).toBe('navigation');
-    expect(navigationRequest2.transaction).toEqual('/sub-page-2');
+    expect(getSpanOp(navigationSpan2)).toBe('navigation');
+    expect(navigationSpan2.name).toEqual('Navigation');
+    expect(navigationSpan2.attributes[URL_PATH]?.value).toEqual('/sub-page-2');
 
-    const redirectSpans2 = navigationRequest2.spans?.filter(span => span.op === 'navigation.redirect') || [];
+    const redirectSpans2 = allSpans
+      .filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === navigationSpan2.span_id)
+      .filter(span => getSpanOp(span) === 'navigation.redirect');
     expect(redirectSpans2).toHaveLength(0);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-redirect/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-redirect/init.js
index 1545e68dd89c..5cf45a1f0b06 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-redirect/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-redirect/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-redirect/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-redirect/test.ts
index 71fe35c8bcc9..bab505425ba5 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-redirect/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/navigation-redirect/test.ts
@@ -1,6 +1,8 @@
+import { URL_PATH, SENTRY_SEGMENT_ID, SENTRY_OP } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest(
   'creates a navigation root span and redirect child span if no click happened within the last 1.5s',
@@ -9,32 +11,35 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const allSpans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
-    const navigationRequestPromise = waitForTransactionRequest(
-      page,
-      event => event.contexts?.trace?.op === 'navigation',
-    );
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
 
     await page.goto(url);
 
-    await pageloadRequestPromise;
+    await pageloadSpanPromise;
 
     // Now trigger navigation (since no span is active), and then a redirect in the navigation, with
     await page.click('#btn1');
 
-    const navigationRequest = envelopeRequestParser(await navigationRequestPromise);
+    const navigationSpan = await navigationSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
 
-    expect(navigationRequest.contexts?.trace?.op).toBe('navigation');
-    expect(navigationRequest.transaction).toEqual('/sub-page');
+    expect(getSpanOp(navigationSpan)).toBe('navigation');
+    expect(navigationSpan.name).toEqual('Navigation');
+    expect(navigationSpan.attributes[URL_PATH]?.value).toEqual('/sub-page');
 
-    const spans = navigationRequest.spans || [];
+    const spans = allSpans.filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === navigationSpan.span_id);
 
     expect(spans).toContainEqual(
       expect.objectContaining({
-        op: 'navigation.redirect',
-        description: '/sub-page-redirect',
+        name: 'Navigation',
+        attributes: expect.objectContaining({
+          [SENTRY_OP]: { type: 'string', value: 'navigation.redirect' },
+          [URL_PATH]: { type: 'string', value: '/sub-page-redirect' },
+        }),
       }),
     );
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/opt-out/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/opt-out/init.js
index bfefd3b54534..331024032a6f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/opt-out/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/opt-out/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/opt-out/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/opt-out/test.ts
index a25cc01f086f..ba2c70c2b924 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/opt-out/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/opt-out/test.ts
@@ -1,6 +1,8 @@
+import { SENTRY_SEGMENT_ID, SENTRY_OP } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest(
   "doesn't create a navigation.redirect span if `detectRedirects` is set to false",
@@ -9,25 +11,24 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const allSpans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
-    const navigationRequestPromise = waitForTransactionRequest(
-      page,
-      event => event.contexts?.trace?.op === 'navigation',
-    );
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
 
     await page.goto(url);
 
-    const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
+    const pageloadSpan = await pageloadSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
     // Ensure a navigation span is sent, too
-    await navigationRequestPromise;
+    await navigationSpanPromise;
 
-    const spans = pageloadRequest.spans || [];
+    const spans = allSpans.filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === pageloadSpan.span_id);
 
     expect(spans).not.toContainEqual(
       expect.objectContaining({
-        op: 'navigation.redirect',
+        attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'navigation.redirect' } }),
       }),
     );
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-click/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-click/init.js
index bdd43f5ac757..1ce4125ee422 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-click/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-click/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-click/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-click/test.ts
index 771b07afaba6..a7e18331a79d 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-click/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-click/test.ts
@@ -1,6 +1,8 @@
+import { SENTRY_SEGMENT_ID, SENTRY_OP } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest(
   "doesn't create a navigation.redirect span if a click happened before navigation",
@@ -9,25 +11,24 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const allSpans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
-    const navigationRequestPromise = waitForTransactionRequest(
-      page,
-      event => event.contexts?.trace?.op === 'navigation',
-    );
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
 
     await page.goto(url);
 
-    const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
+    const pageloadSpan = await pageloadSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
     // Ensure a navigation span is sent, too
-    await navigationRequestPromise;
+    await navigationSpanPromise;
 
-    const pageloadTxnSpans = pageloadRequest.spans || [];
+    const pageloadSpans = allSpans.filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === pageloadSpan.span_id);
 
-    expect(pageloadTxnSpans).not.toContainEqual(
+    expect(pageloadSpans).not.toContainEqual(
       expect.objectContaining({
-        op: 'navigation.redirect',
+        attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'navigation.redirect' } }),
       }),
     );
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-keypress/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-keypress/init.js
index bdd43f5ac757..1ce4125ee422 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-keypress/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-keypress/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-keypress/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-keypress/test.ts
index e77e08936466..e82f4f565293 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-keypress/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-keypress/test.ts
@@ -1,6 +1,8 @@
+import { SENTRY_SEGMENT_ID, SENTRY_OP } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest(
   "doesn't create a navigation.redirect span if a keypress happened before navigation",
@@ -9,27 +11,26 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const allSpans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
-    const navigationRequestPromise = waitForTransactionRequest(
-      page,
-      event => event.contexts?.trace?.op === 'navigation',
-    );
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
 
     await page.goto(url);
     await page.focus('#btn1');
     await page.keyboard.press('Enter');
 
-    const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
+    const pageloadSpan = await pageloadSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
     // Ensure a navigation span is sent, too
-    await navigationRequestPromise;
+    await navigationSpanPromise;
 
-    const spans = pageloadRequest.spans || [];
+    const spans = allSpans.filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === pageloadSpan.span_id);
 
     expect(spans).not.toContainEqual(
       expect.objectContaining({
-        op: 'navigation.redirect',
+        attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'navigation.redirect' } }),
       }),
     );
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-time/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-time/init.js
index 4aecc7f5ef40..f317a550e2a7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-time/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-time/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-time/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-time/test.ts
index 6b5925f52cd1..535bc77adaae 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-time/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-navigation-time/test.ts
@@ -1,6 +1,8 @@
+import { SENTRY_SEGMENT_ID, SENTRY_OP } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest(
   "doesn't create a navigation.redirect span if redirect happened more than 1.5s after pageload",
@@ -9,25 +11,24 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const allSpans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
-    const navigationRequestPromise = waitForTransactionRequest(
-      page,
-      event => event.contexts?.trace?.op === 'navigation',
-    );
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    const navigationSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'navigation');
 
     await page.goto(url);
 
-    const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
+    const pageloadSpan = await pageloadSpanPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
     // Ensure a navigation span is sent, too
-    await navigationRequestPromise;
+    await navigationSpanPromise;
 
-    const spans = pageloadRequest.spans || [];
+    const spans = allSpans.filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === pageloadSpan.span_id);
 
     expect(spans).not.toContainEqual(
       expect.objectContaining({
-        op: 'navigation.redirect',
+        attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'navigation.redirect' } }),
       }),
     );
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-redirect/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-redirect/init.js
index bb91be7762dc..cba0015b22c8 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-redirect/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-redirect/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-redirect/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-redirect/test.ts
index fc126da536f3..866e09aa6551 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-redirect/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-redirect/pageload-redirect/test.ts
@@ -1,8 +1,13 @@
 import { expect } from '@playwright/test';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 import {
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  USER_AGENT_ORIGINAL,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SEGMENT_NAME,
   SENTRY_SEGMENT_NAME_SOURCE,
   URL_FULL,
   URL_PATH,
@@ -15,56 +20,57 @@ sentryTest('creates a pageload root span with navigation.redirect childspan', as
     sentryTest.skip();
   }
 
+  const allSpans = collectStreamedSpans(page);
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
 
   await page.goto(url);
 
-  const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise);
+  const pageloadSpan = await pageloadSpanPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-  expect(pageloadRequest.contexts?.trace?.op).toBe('pageload');
+  expect(getSpanOp(pageloadSpan)).toBe('pageload');
 
-  expect(pageloadRequest.contexts?.trace?.data).toMatchObject({
-    [SENTRY_ORIGIN]: 'auto.pageload.browser',
-    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-    [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-    [SENTRY_OP]: 'pageload',
-    ['sentry.idle_span_finish_reason']: 'idleTimeout',
+  expect(pageloadSpan.attributes).toMatchObject({
+    [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
+    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: { type: 'integer', value: 1 },
+    [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'url' },
+    [SENTRY_OP]: { type: 'string', value: 'pageload' },
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: { type: 'string', value: 'idleTimeout' },
   });
 
-  expect(pageloadRequest.request).toEqual({
-    headers: {
-      'User-Agent': expect.any(String),
-    },
-    url: 'http://sentry-test.io/index.html',
+  expect(pageloadSpan.attributes).toMatchObject({
+    [USER_AGENT_ORIGINAL]: { type: 'string', value: expect.any(String) },
+    [URL_FULL]: { type: 'string', value: 'http://sentry-test.io/index.html' },
   });
 
-  const spans = pageloadRequest.spans || [];
+  const spans = allSpans.filter(span => span.attributes[SENTRY_SEGMENT_ID]?.value === pageloadSpan.span_id);
 
   expect(spans).toContainEqual(
     expect.objectContaining({
-      op: 'navigation.redirect',
+      attributes: expect.objectContaining({ [SENTRY_OP]: { type: 'string', value: 'navigation.redirect' } }),
     }),
   );
 
-  const redirectSpan = spans.find(span => span.op === 'navigation.redirect');
-  expect(redirectSpan?.timestamp).toEqual(redirectSpan?.start_timestamp);
-  expect(redirectSpan).toEqual({
-    data: {
-      'sentry.op': 'navigation.redirect',
-      'sentry.origin': 'auto.navigation.browser',
-      [URL_FULL]: 'http://sentry-test.io/sub-page',
-      [URL_PATH]: '/sub-page',
+  const redirectSpan = spans.find(span => getSpanOp(span) === 'navigation.redirect');
+  expect(redirectSpan?.end_timestamp).toEqual(redirectSpan?.start_timestamp);
+  expect(redirectSpan).toMatchObject({
+    attributes: {
+      [SENTRY_OP]: { type: 'string', value: 'navigation.redirect' },
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.navigation.browser' },
+      [SENTRY_SEGMENT_ID]: { type: 'string', value: pageloadSpan.span_id },
+      [SENTRY_SEGMENT_NAME]: { type: 'string', value: 'Pageload' },
+      [URL_FULL]: { type: 'string', value: 'http://sentry-test.io/sub-page' },
+      [URL_PATH]: { type: 'string', value: '/sub-page' },
     },
-    description: '/sub-page',
-    op: 'navigation.redirect',
-    origin: 'auto.navigation.browser',
+    name: 'Navigation',
+    is_segment: false,
     status: 'ok',
-    parent_span_id: pageloadRequest.contexts!.trace!.span_id,
+    parent_span_id: pageloadSpan.span_id,
     span_id: expect.any(String),
     start_timestamp: expect.any(Number),
-    timestamp: expect.any(Number),
+    end_timestamp: expect.any(Number),
     trace_id: expect.any(String),
   });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-static/init.js
new file mode 100644
index 000000000000..bb6d4918d1bf
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-static/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-static/test.ts
new file mode 100644
index 000000000000..bf3324b9809b
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-static/test.ts
@@ -0,0 +1,156 @@
+import { PAGELOAD, NAVIGATION } from '@sentry/conventions/op';
+import {
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest('should create a navigation transaction on page navigation', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+  await page.goto(url);
+  const pageloadRequest = envelopeRequestParser<Event>(await pageloadRequestPromise);
+
+  const navigationRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === NAVIGATION);
+  await page.goto(`${url}#foo`);
+  const navigationRequest = envelopeRequestParser<Event>(await navigationRequestPromise);
+
+  expect(pageloadRequest.contexts?.trace?.op).toBe(PAGELOAD);
+  expect(navigationRequest.contexts?.trace?.op).toBe(NAVIGATION);
+
+  expect(navigationRequest.transaction_info?.source).toEqual('url');
+
+  const pageloadTraceId = pageloadRequest.contexts?.trace?.trace_id;
+  const navigationTraceId = navigationRequest.contexts?.trace?.trace_id;
+
+  expect(pageloadTraceId).toBeDefined();
+  expect(navigationTraceId).toBeDefined();
+  expect(pageloadTraceId).not.toEqual(navigationTraceId);
+
+  expect(pageloadRequest.transaction).toEqual('/index.html');
+  // Fragment is not in transaction name
+  expect(navigationRequest.transaction).toEqual('/index.html');
+
+  expect(pageloadRequest.contexts?.trace?.data).toMatchObject({
+    [SENTRY_ORIGIN]: 'auto.pageload.browser',
+    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
+    [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
+    [SENTRY_OP]: PAGELOAD,
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: 'idleTimeout',
+  });
+  expect(navigationRequest.contexts?.trace?.data).toMatchObject({
+    [SENTRY_ORIGIN]: 'auto.navigation.browser',
+    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
+    [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
+    [SENTRY_OP]: NAVIGATION,
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: 'idleTimeout',
+  });
+  expect(pageloadRequest.request).toEqual({
+    headers: {
+      'User-Agent': expect.any(String),
+    },
+    url: 'http://sentry-test.io/index.html',
+  });
+  expect(navigationRequest.request).toEqual({
+    headers: {
+      'User-Agent': expect.any(String),
+    },
+    url: 'http://sentry-test.io/index.html#foo',
+  });
+
+  const pageloadSpans = pageloadRequest.spans;
+  const navigationSpans = navigationRequest.spans;
+
+  const pageloadSpanId = pageloadRequest.contexts?.trace?.span_id;
+  const navigationSpanId = navigationRequest.contexts?.trace?.span_id;
+
+  expect(pageloadSpanId).toBeDefined();
+  expect(navigationSpanId).toBeDefined();
+
+  pageloadSpans?.forEach(span =>
+    expect(span).toMatchObject({
+      parent_span_id: pageloadSpanId,
+    }),
+  );
+
+  navigationSpans?.forEach(span =>
+    expect(span).toMatchObject({
+      parent_span_id: navigationSpanId,
+    }),
+  );
+
+  expect(pageloadSpanId).not.toEqual(navigationSpanId);
+});
+
+//
+sentryTest('should handle pushState with full URL', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+  const navigationRequestPromise = waitForTransactionRequest(
+    page,
+    event => event.contexts?.trace?.op === NAVIGATION && event.transaction === '/sub-page',
+  );
+  const navigationRequestPromise2 = waitForTransactionRequest(
+    page,
+    event => event.contexts?.trace?.op === NAVIGATION && event.transaction === '/sub-page-2',
+  );
+
+  await page.goto(url);
+  await pageloadRequestPromise;
+
+  await page.evaluate("window.history.pushState({}, '', `${window.location.origin}/sub-page`);");
+
+  const navigationRequest = envelopeRequestParser(await navigationRequestPromise);
+
+  expect(navigationRequest.transaction).toEqual('/sub-page');
+
+  expect(navigationRequest.contexts?.trace?.data).toMatchObject({
+    [SENTRY_ORIGIN]: 'auto.navigation.browser',
+    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
+    [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
+    [SENTRY_OP]: NAVIGATION,
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: 'idleTimeout',
+  });
+  expect(navigationRequest.request).toEqual({
+    headers: {
+      'User-Agent': expect.any(String),
+    },
+    url: 'http://sentry-test.io/sub-page',
+  });
+
+  await page.evaluate("window.history.pushState({}, '', `${window.location.origin}/sub-page-2`);");
+
+  const navigationRequest2 = envelopeRequestParser(await navigationRequestPromise2);
+
+  expect(navigationRequest2.transaction).toEqual('/sub-page-2');
+
+  expect(navigationRequest2.contexts?.trace?.data).toMatchObject({
+    [SENTRY_ORIGIN]: 'auto.navigation.browser',
+    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
+    [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
+    [SENTRY_OP]: NAVIGATION,
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: 'idleTimeout',
+  });
+  expect(navigationRequest2.request).toEqual({
+    headers: {
+      'User-Agent': expect.any(String),
+    },
+    url: 'http://sentry-test.io/sub-page-2',
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-streamed/test.ts
deleted file mode 100644
index 62fcd88c337f..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation-streamed/test.ts
+++ /dev/null
@@ -1,274 +0,0 @@
-import { expect } from '@playwright/test';
-import { SDK_VERSION, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
-import {
-  SENTRY_SEGMENT_NAME_SOURCE,
-  SENTRY_TRACE_LIFECYCLE,
-  URL_FULL,
-  URL_PATH,
-  USER_AGENT_ORIGINAL,
-  SENTRY_ENVIRONMENT,
-  SENTRY_SDK_INTEGRATIONS,
-  SENTRY_OP,
-  SENTRY_ORIGIN,
-} from '@sentry/conventions/attributes';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import {
-  getSpanOp,
-  getSpansFromEnvelope,
-  waitForStreamedSpan,
-  waitForStreamedSpanEnvelope,
-} from '../../../../utils/spanUtils';
-
-sentryTest('starts a streamed navigation span on page navigation', async ({ browserName, getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-  const navigationSpanEnvelopePromise = waitForStreamedSpanEnvelope(
-    page,
-    env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'navigation'),
-  );
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  await page.goto(url);
-
-  const pageloadSpan = await pageloadSpanPromise;
-
-  // simulate navigation
-  page.goto(`${url}#foo`);
-
-  const navigationSpanEnvelope = await navigationSpanEnvelopePromise;
-
-  const navigationSpanEnvelopeHeader = navigationSpanEnvelope[0];
-  const navigationSpanEnvelopeItem = navigationSpanEnvelope[1];
-  const navigationSpans = navigationSpanEnvelopeItem[0][1].items;
-  const navigationSpan = navigationSpans.find(s => getSpanOp(s) === 'navigation')!;
-
-  expect(navigationSpanEnvelopeHeader).toEqual({
-    sent_at: expect.any(String),
-    trace: {
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      environment: 'production',
-      public_key: 'public',
-      sample_rand: expect.any(String),
-      sample_rate: '1',
-      sampled: 'true',
-    },
-    sdk: {
-      name: 'sentry.javascript.browser',
-      version: SDK_VERSION,
-    },
-  });
-
-  const numericSampleRand = parseFloat(navigationSpanEnvelopeHeader.trace!.sample_rand!);
-  expect(Number.isNaN(numericSampleRand)).toBe(false);
-
-  const pageloadTraceId = pageloadSpan.trace_id;
-  const navigationTraceId = navigationSpan.trace_id;
-
-  expect(pageloadTraceId).toBeDefined();
-  expect(navigationTraceId).toBeDefined();
-  expect(pageloadTraceId).not.toEqual(navigationTraceId);
-
-  expect(pageloadSpan.name).toEqual('Pageload');
-
-  expect(navigationSpan).toEqual({
-    attributes: {
-      'sentry.is_localhost': { value: false, type: 'boolean' },
-      [SENTRY_TRACE_LIFECYCLE]: {
-        type: 'string',
-        value: 'stream',
-      },
-      'culture.calendar': {
-        type: 'string',
-        value: expect.any(String),
-      },
-      'culture.locale': {
-        type: 'string',
-        value: expect.any(String),
-      },
-      'culture.timezone': {
-        type: 'string',
-        value: expect.any(String),
-      },
-      [USER_AGENT_ORIGINAL]: {
-        type: 'string',
-        value: expect.any(String),
-      },
-      [URL_FULL]: {
-        type: 'string',
-        value: expect.any(String),
-      },
-      [URL_PATH]: {
-        type: 'string',
-        value: expect.any(String),
-      },
-      'device.processor_count': {
-        type: expect.stringMatching(/^(integer)|(double)$/),
-        value: expect.any(Number),
-      },
-      ...(browserName !== 'webkit' && {
-        'network.connection.effective_type': {
-          type: 'string',
-          value: expect.any(String),
-        },
-        'network.connection.rtt': {
-          type: expect.stringMatching(/^(integer)|(double)$/),
-          value: expect.any(Number),
-        },
-      }),
-      'sentry.idle_span_finish_reason': {
-        type: 'string',
-        value: 'idleTimeout',
-      },
-      [SENTRY_OP]: {
-        type: 'string',
-        value: 'navigation',
-      },
-      [SENTRY_ORIGIN]: {
-        type: 'string',
-        value: 'auto.navigation.browser',
-      },
-      'sentry.previous_trace': {
-        type: 'string',
-        value: `${pageloadTraceId}-${pageloadSpan.span_id}-1`,
-      },
-      'sentry.sample_rate': {
-        type: 'integer',
-        value: 1,
-      },
-      'sentry.sdk.name': {
-        type: 'string',
-        value: 'sentry.javascript.browser',
-      },
-      'sentry.sdk.version': {
-        type: 'string',
-        value: SDK_VERSION,
-      },
-      [SENTRY_SDK_INTEGRATIONS]: {
-        type: 'array',
-        value: expect.arrayContaining(['BrowserTracing', 'SpanStreaming']),
-      },
-      'sentry.segment.id': {
-        type: 'string',
-        value: navigationSpan.span_id,
-      },
-      'sentry.segment.name': {
-        type: 'string',
-        value: 'Navigation',
-      },
-      'sentry.segment.name.source': {
-        type: 'string',
-        value: 'url',
-      },
-      [SENTRY_ENVIRONMENT]: {
-        type: 'string',
-        value: 'production',
-      },
-    },
-    end_timestamp: expect.any(Number),
-    is_segment: true,
-    links: [
-      {
-        attributes: {
-          'sentry.link.type': {
-            type: 'string',
-            value: 'previous_trace',
-          },
-        },
-        sampled: true,
-        span_id: pageloadSpan.span_id,
-        trace_id: pageloadTraceId,
-      },
-    ],
-    // The raw URL stays in `url.path`/`url.full`: with span streaming, a navigation span name is
-    // low cardinality and falls back to 'Navigation' when there is no parameterized route.
-    name: 'Navigation',
-    span_id: navigationSpan.span_id,
-    start_timestamp: expect.any(Number),
-    status: 'ok',
-    trace_id: navigationTraceId,
-  });
-});
-
-sentryTest('handles pushState with full URL', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-  const navigationSpan1Promise = waitForStreamedSpan(
-    page,
-    // Matched on `url.path` rather than the span name, which is low cardinality.
-    span => getSpanOp(span) === 'navigation' && span.attributes?.[URL_PATH]?.value === '/sub-page',
-  );
-  const navigationSpan2Promise = waitForStreamedSpan(
-    page,
-    span => getSpanOp(span) === 'navigation' && span.attributes?.[URL_PATH]?.value === '/sub-page-2',
-  );
-
-  await page.goto(url);
-  await pageloadSpanPromise;
-
-  await page.evaluate("window.history.pushState({}, '', `${window.location.origin}/sub-page`);");
-
-  const navigationSpan1 = await navigationSpan1Promise;
-
-  expect(navigationSpan1.name).toEqual('Navigation');
-
-  expect(navigationSpan1.attributes).toMatchObject({
-    [URL_PATH]: {
-      type: 'string',
-      value: '/sub-page',
-    },
-    [SENTRY_ORIGIN]: {
-      type: 'string',
-      value: 'auto.navigation.browser',
-    },
-    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: {
-      type: 'integer',
-      value: 1,
-    },
-    [SENTRY_SEGMENT_NAME_SOURCE]: {
-      type: 'string',
-      value: 'url',
-    },
-    [SENTRY_OP]: {
-      type: 'string',
-      value: 'navigation',
-    },
-  });
-
-  await page.evaluate("window.history.pushState({}, '', `${window.location.origin}/sub-page-2`);");
-
-  const navigationSpan2 = await navigationSpan2Promise;
-
-  expect(navigationSpan2.name).toEqual('Navigation');
-
-  expect(navigationSpan2.attributes).toMatchObject({
-    [URL_PATH]: {
-      type: 'string',
-      value: '/sub-page-2',
-    },
-    [SENTRY_ORIGIN]: {
-      type: 'string',
-      value: 'auto.navigation.browser',
-    },
-    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: {
-      type: 'integer',
-      value: 1,
-    },
-    [SENTRY_SEGMENT_NAME_SOURCE]: {
-      type: 'string',
-      value: 'url',
-    },
-    [SENTRY_OP]: {
-      type: 'string',
-      value: 'navigation',
-    },
-    ['sentry.idle_span_finish_reason']: {
-      type: 'string',
-      value: 'idleTimeout',
-    },
-  });
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/init.js
new file mode 100644
index 000000000000..83076460599f
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/init.js
@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/test.ts
index ab8a3931e132..84eaf5b4943a 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/navigation/test.ts
@@ -1,150 +1,310 @@
-import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
-import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
+import { SDK_VERSION, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
+import {
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  SENTRY_SEGMENT_ID,
+  SENTRY_IS_LOCALHOST,
+  CULTURE_CALENDAR,
+  CULTURE_LOCALE,
+  CULTURE_TIMEZONE,
+  DEVICE_PROCESSOR_COUNT,
+  NETWORK_CONNECTION_EFFECTIVE_TYPE,
+  NETWORK_CONNECTION_RTT,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_SEGMENT_NAME,
+  SENTRY_LINK_TYPE,
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_TRACE_LIFECYCLE,
+  URL_FULL,
+  URL_PATH,
+  USER_AGENT_ORIGINAL,
+  SENTRY_ENVIRONMENT,
+  SENTRY_SDK_INTEGRATIONS,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
 import { sentryTest } from '../../../../utils/fixtures';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
 import {
-  envelopeRequestParser,
-  getFirstSentryEnvelopeRequest,
-  shouldSkipTracingTest,
-  waitForTransactionRequest,
-} from '../../../../utils/helpers';
-
-sentryTest('should create a navigation transaction on page navigation', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+  collectStreamedSpans,
+  getSpanOp,
+  getSpansFromEnvelope,
+  waitForStreamedSpan,
+  waitForStreamedSpanEnvelope,
+} from '../../../../utils/spanUtils';
 
-  const url = await getLocalTestUrl({ testDir: __dirname });
+sentryTest('starts a streamed navigation span on page navigation', async ({ browserName, getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
 
-  const pageloadRequest = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const navigationRequest = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#foo`);
+  const collectedSpans = collectStreamedSpans(page);
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+  const navigationSpanEnvelopePromise = waitForStreamedSpanEnvelope(
+    page,
+    env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'navigation'),
+  );
 
-  expect(pageloadRequest.contexts?.trace?.op).toBe('pageload');
-  expect(navigationRequest.contexts?.trace?.op).toBe('navigation');
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
 
-  expect(navigationRequest.transaction_info?.source).toEqual('url');
+  const pageloadSpan = await pageloadSpanPromise;
 
-  const pageloadTraceId = pageloadRequest.contexts?.trace?.trace_id;
-  const navigationTraceId = navigationRequest.contexts?.trace?.trace_id;
+  await page.goto(`${url}#foo`);
 
-  expect(pageloadTraceId).toBeDefined();
-  expect(navigationTraceId).toBeDefined();
-  expect(pageloadTraceId).not.toEqual(navigationTraceId);
+  const navigationSpanEnvelope = await navigationSpanEnvelopePromise;
 
-  expect(pageloadRequest.transaction).toEqual('/index.html');
-  // Fragment is not in transaction name
-  expect(navigationRequest.transaction).toEqual('/index.html');
+  const navigationSpanEnvelopeHeader = navigationSpanEnvelope[0];
+  const navigationSpanEnvelopeItem = navigationSpanEnvelope[1];
+  const navigationSpans = navigationSpanEnvelopeItem[0][1].items;
+  const navigationSpan = navigationSpans.find(s => getSpanOp(s) === 'navigation')!;
 
-  expect(pageloadRequest.contexts?.trace?.data).toMatchObject({
-    [SENTRY_ORIGIN]: 'auto.pageload.browser',
-    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-    [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-    [SENTRY_OP]: 'pageload',
-    ['sentry.idle_span_finish_reason']: 'idleTimeout',
-  });
-  expect(navigationRequest.contexts?.trace?.data).toMatchObject({
-    [SENTRY_ORIGIN]: 'auto.navigation.browser',
-    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-    [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-    [SENTRY_OP]: 'navigation',
-    ['sentry.idle_span_finish_reason']: 'idleTimeout',
-  });
-  expect(pageloadRequest.request).toEqual({
-    headers: {
-      'User-Agent': expect.any(String),
+  expect(navigationSpanEnvelopeHeader).toEqual({
+    sent_at: expect.any(String),
+    trace: {
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      environment: 'production',
+      public_key: 'public',
+      sample_rand: expect.any(String),
+      sample_rate: '1',
+      sampled: 'true',
     },
-    url: 'http://sentry-test.io/index.html',
-  });
-  expect(navigationRequest.request).toEqual({
-    headers: {
-      'User-Agent': expect.any(String),
+    sdk: {
+      name: 'sentry.javascript.browser',
+      version: SDK_VERSION,
     },
-    url: 'http://sentry-test.io/index.html#foo',
   });
 
-  const pageloadSpans = pageloadRequest.spans;
-  const navigationSpans = navigationRequest.spans;
+  const numericSampleRand = parseFloat(navigationSpanEnvelopeHeader.trace!.sample_rand!);
+  expect(Number.isNaN(numericSampleRand)).toBe(false);
 
-  const pageloadSpanId = pageloadRequest.contexts?.trace?.span_id;
-  const navigationSpanId = navigationRequest.contexts?.trace?.span_id;
+  const pageloadTraceId = pageloadSpan.trace_id;
+  const navigationTraceId = navigationSpan.trace_id;
 
-  expect(pageloadSpanId).toBeDefined();
-  expect(navigationSpanId).toBeDefined();
-
-  pageloadSpans?.forEach(span =>
-    expect(span).toMatchObject({
-      parent_span_id: pageloadSpanId,
-    }),
-  );
+  expect(pageloadTraceId).toBeDefined();
+  expect(navigationTraceId).toBeDefined();
+  expect(pageloadTraceId).not.toEqual(navigationTraceId);
 
-  navigationSpans?.forEach(span =>
-    expect(span).toMatchObject({
-      parent_span_id: navigationSpanId,
-    }),
-  );
+  expect(pageloadSpan.name).toEqual('Pageload');
+  expect(pageloadSpan.attributes).toMatchObject({
+    [URL_PATH]: { type: 'string', value: '/index.html' },
+    [URL_FULL]: { type: 'string', value: 'http://sentry-test.io/index.html' },
+    [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
+    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: { type: 'integer', value: 1 },
+    [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'url' },
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: { type: 'string', value: 'idleTimeout' },
+  });
+  expect(pageloadSpan.span_id).not.toBe(navigationSpan.span_id);
+  await page.evaluate(() => (window as any).Sentry.flush());
+  for (const root of [pageloadSpan, navigationSpan]) {
+    collectedSpans
+      .filter(span => !span.is_segment && span.attributes[SENTRY_SEGMENT_ID]?.value === root.span_id)
+      .forEach(span => expect(span.parent_span_id).toBe(root.span_id));
+  }
 
-  expect(pageloadSpanId).not.toEqual(navigationSpanId);
+  expect(navigationSpan).toEqual({
+    attributes: {
+      [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
+      [SENTRY_TRACE_LIFECYCLE]: {
+        type: 'string',
+        value: 'stream',
+      },
+      [CULTURE_CALENDAR]: {
+        type: 'string',
+        value: expect.any(String),
+      },
+      [CULTURE_LOCALE]: {
+        type: 'string',
+        value: expect.any(String),
+      },
+      [CULTURE_TIMEZONE]: {
+        type: 'string',
+        value: expect.any(String),
+      },
+      [USER_AGENT_ORIGINAL]: {
+        type: 'string',
+        value: expect.any(String),
+      },
+      [URL_FULL]: {
+        type: 'string',
+        value: 'http://sentry-test.io/index.html#foo',
+      },
+      [URL_PATH]: {
+        type: 'string',
+        value: '/index.html',
+      },
+      [DEVICE_PROCESSOR_COUNT]: {
+        type: expect.stringMatching(/^(integer)|(double)$/),
+        value: expect.any(Number),
+      },
+      ...(browserName !== 'webkit' && {
+        [NETWORK_CONNECTION_EFFECTIVE_TYPE]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+        [NETWORK_CONNECTION_RTT]: {
+          type: expect.stringMatching(/^(integer)|(double)$/),
+          value: expect.any(Number),
+        },
+      }),
+      [SENTRY_IDLE_SPAN_FINISH_REASON]: {
+        type: 'string',
+        value: 'idleTimeout',
+      },
+      [SENTRY_OP]: {
+        type: 'string',
+        value: 'navigation',
+      },
+      [SENTRY_ORIGIN]: {
+        type: 'string',
+        value: 'auto.navigation.browser',
+      },
+      'sentry.previous_trace': {
+        type: 'string',
+        value: `${pageloadTraceId}-${pageloadSpan.span_id}-1`,
+      },
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: {
+        type: 'integer',
+        value: 1,
+      },
+      [SENTRY_SDK_NAME]: {
+        type: 'string',
+        value: 'sentry.javascript.browser',
+      },
+      [SENTRY_SDK_VERSION]: {
+        type: 'string',
+        value: SDK_VERSION,
+      },
+      [SENTRY_SDK_INTEGRATIONS]: {
+        type: 'array',
+        value: expect.arrayContaining(['BrowserTracing', 'SpanStreaming']),
+      },
+      [SENTRY_SEGMENT_ID]: {
+        type: 'string',
+        value: navigationSpan.span_id,
+      },
+      [SENTRY_SEGMENT_NAME]: {
+        type: 'string',
+        value: 'Navigation',
+      },
+      [SENTRY_SEGMENT_NAME_SOURCE]: {
+        type: 'string',
+        value: 'url',
+      },
+      [SENTRY_ENVIRONMENT]: {
+        type: 'string',
+        value: 'production',
+      },
+    },
+    end_timestamp: expect.any(Number),
+    is_segment: true,
+    links: [
+      {
+        attributes: {
+          [SENTRY_LINK_TYPE]: {
+            type: 'string',
+            value: 'previous_trace',
+          },
+        },
+        sampled: true,
+        span_id: pageloadSpan.span_id,
+        trace_id: pageloadTraceId,
+      },
+    ],
+    name: 'Navigation',
+    span_id: navigationSpan.span_id,
+    start_timestamp: expect.any(Number),
+    status: 'ok',
+    trace_id: navigationTraceId,
+  });
 });
 
-//
-sentryTest('should handle pushState with full URL', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+sentryTest('handles pushState with full URL', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
-  const navigationRequestPromise = waitForTransactionRequest(
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+  const navigationSpan1Promise = waitForStreamedSpan(
     page,
-    event => event.contexts?.trace?.op === 'navigation' && event.transaction === '/sub-page',
+    span => getSpanOp(span) === 'navigation' && span.attributes?.[URL_PATH]?.value === '/sub-page',
   );
-  const navigationRequestPromise2 = waitForTransactionRequest(
+  const navigationSpan2Promise = waitForStreamedSpan(
     page,
-    event => event.contexts?.trace?.op === 'navigation' && event.transaction === '/sub-page-2',
+    span => getSpanOp(span) === 'navigation' && span.attributes?.[URL_PATH]?.value === '/sub-page-2',
   );
 
   await page.goto(url);
-  await pageloadRequestPromise;
+  await pageloadSpanPromise;
 
   await page.evaluate("window.history.pushState({}, '', `${window.location.origin}/sub-page`);");
 
-  const navigationRequest = envelopeRequestParser(await navigationRequestPromise);
+  const navigationSpan1 = await navigationSpan1Promise;
 
-  expect(navigationRequest.transaction).toEqual('/sub-page');
-
-  expect(navigationRequest.contexts?.trace?.data).toMatchObject({
-    [SENTRY_ORIGIN]: 'auto.navigation.browser',
-    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-    [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-    [SENTRY_OP]: 'navigation',
-    ['sentry.idle_span_finish_reason']: 'idleTimeout',
+  expect(navigationSpan1.name).toEqual('Navigation');
+  expect(navigationSpan1.attributes).toMatchObject({
+    [URL_FULL]: { type: 'string', value: 'http://sentry-test.io/sub-page' },
+    [USER_AGENT_ORIGINAL]: { type: 'string', value: expect.any(String) },
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: { type: 'string', value: 'idleTimeout' },
   });
-  expect(navigationRequest.request).toEqual({
-    headers: {
-      'User-Agent': expect.any(String),
+
+  expect(navigationSpan1.attributes).toMatchObject({
+    [URL_PATH]: {
+      type: 'string',
+      value: '/sub-page',
+    },
+    [SENTRY_ORIGIN]: {
+      type: 'string',
+      value: 'auto.navigation.browser',
+    },
+    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: {
+      type: 'integer',
+      value: 1,
+    },
+    [SENTRY_SEGMENT_NAME_SOURCE]: {
+      type: 'string',
+      value: 'url',
+    },
+    [SENTRY_OP]: {
+      type: 'string',
+      value: 'navigation',
     },
-    url: 'http://sentry-test.io/sub-page',
   });
 
   await page.evaluate("window.history.pushState({}, '', `${window.location.origin}/sub-page-2`);");
 
-  const navigationRequest2 = envelopeRequestParser(await navigationRequestPromise2);
-
-  expect(navigationRequest2.transaction).toEqual('/sub-page-2');
+  const navigationSpan2 = await navigationSpan2Promise;
 
-  expect(navigationRequest2.contexts?.trace?.data).toMatchObject({
-    [SENTRY_ORIGIN]: 'auto.navigation.browser',
-    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-    [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-    [SENTRY_OP]: 'navigation',
-    ['sentry.idle_span_finish_reason']: 'idleTimeout',
+  expect(navigationSpan2.name).toEqual('Navigation');
+  expect(navigationSpan2.attributes).toMatchObject({
+    [URL_FULL]: { type: 'string', value: 'http://sentry-test.io/sub-page-2' },
+    [USER_AGENT_ORIGINAL]: { type: 'string', value: expect.any(String) },
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: { type: 'string', value: 'idleTimeout' },
   });
-  expect(navigationRequest2.request).toEqual({
-    headers: {
-      'User-Agent': expect.any(String),
+
+  expect(navigationSpan2.attributes).toMatchObject({
+    [URL_PATH]: {
+      type: 'string',
+      value: '/sub-page-2',
+    },
+    [SENTRY_ORIGIN]: {
+      type: 'string',
+      value: 'auto.navigation.browser',
+    },
+    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: {
+      type: 'integer',
+      value: 1,
+    },
+    [SENTRY_SEGMENT_NAME_SOURCE]: {
+      type: 'string',
+      value: 'url',
+    },
+    [SENTRY_OP]: {
+      type: 'string',
+      value: 'navigation',
+    },
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: {
+      type: 'string',
+      value: 'idleTimeout',
     },
-    url: 'http://sentry-test.io/sub-page-2',
   });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-end/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-end/init.js
index 25e1637ea608..207473572df5 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-end/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-end/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-end/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-end/test.ts
index 03bfc13814af..8fd42411f5a9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-end/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-end/test.ts
@@ -1,7 +1,8 @@
+import { SENTRY_OP } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getMultipleSentryEnvelopeRequests, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
 sentryTest('should call onRequestSpanEnd hook', async ({ browserName, getLocalTestUrl, page }) => {
   const supportedBrowsers = ['chromium', 'firefox'];
@@ -35,26 +36,26 @@ sentryTest('should call onRequestSpanEnd hook', async ({ browserName, getLocalTe
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const envelopes = await getMultipleSentryEnvelopeRequests<Event>(page, 2, { url, timeout: 10000 });
+  const spans = collectStreamedSpans(page);
+  await waitForStreamedSpanAndTraceHeaderOnUrl(page, url, span => getSpanOp(span) === 'pageload');
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-  const tracingEvent = envelopes[envelopes.length - 1]; // last envelope contains tracing data on all browsers
-
-  expect(tracingEvent.spans).toContainEqual(
+  expect(spans).toContainEqual(
     expect.objectContaining({
-      op: 'http.client',
-      data: expect.objectContaining({
-        type: 'xhr',
-        'hook.called.response-type': 'xhr',
+      attributes: expect.objectContaining({
+        [SENTRY_OP]: { type: 'string', value: 'http.client' },
+        type: { type: 'string', value: 'xhr' },
+        'hook.called.response-type': { type: 'string', value: 'xhr' },
       }),
     }),
   );
 
-  expect(tracingEvent.spans).toContainEqual(
+  expect(spans).toContainEqual(
     expect.objectContaining({
-      op: 'http.client',
-      data: expect.objectContaining({
-        type: 'fetch',
-        'hook.called.response-type': 'fetch',
+      attributes: expect.objectContaining({
+        [SENTRY_OP]: { type: 'string', value: 'http.client' },
+        type: { type: 'string', value: 'fetch' },
+        'hook.called.response-type': { type: 'string', value: 'fetch' },
       }),
     }),
   );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/init.js
index a24444de55b1..680dfd7304df 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/test.ts
index d1d90a698a77..c21fa92e97a3 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/on-request-span-start/test.ts
@@ -1,7 +1,8 @@
+import { SENTRY_OP } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getMultipleSentryEnvelopeRequests, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
 sentryTest('should call onRequestSpanStart hook', async ({ browserName, getLocalTestUrl, page }) => {
   const supportedBrowsers = ['chromium', 'firefox'];
@@ -27,24 +28,24 @@ sentryTest('should call onRequestSpanStart hook', async ({ browserName, getLocal
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const envelopes = await getMultipleSentryEnvelopeRequests<Event>(page, 2, { url, timeout: 10000 });
+  const spans = collectStreamedSpans(page);
+  await waitForStreamedSpanAndTraceHeaderOnUrl(page, url, span => getSpanOp(span) === 'pageload');
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-  const tracingEvent = envelopes[envelopes.length - 1]; // last envelope contains tracing data on all browsers
-
-  expect(tracingEvent.spans).toContainEqual(
+  expect(spans).toContainEqual(
     expect.objectContaining({
-      op: 'http.client',
-      data: expect.objectContaining({
-        'hook.called.headers': 'xhr',
+      attributes: expect.objectContaining({
+        [SENTRY_OP]: { type: 'string', value: 'http.client' },
+        'hook.called.headers': { type: 'string', value: 'xhr' },
       }),
     }),
   );
 
-  expect(tracingEvent.spans).toContainEqual(
+  expect(spans).toContainEqual(
     expect.objectContaining({
-      op: 'http.client',
-      data: expect.objectContaining({
-        'hook.called.headers': 'fetch',
+      attributes: expect.objectContaining({
+        [SENTRY_OP]: { type: 'string', value: 'http.client' },
+        'hook.called.headers': { type: 'string', value: 'fetch' },
       }),
     }),
   );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-static/init.js
similarity index 65%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-static/init.js
index bd3b6ed17872..b74e6633eadb 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-static/init.js
@@ -4,8 +4,8 @@ window.Sentry = Sentry;
 window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
-  traceLifecycle: 'stream',
+  integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-static/test.ts
new file mode 100644
index 000000000000..2f89771057f7
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-static/test.ts
@@ -0,0 +1,43 @@
+import { PAGELOAD } from '@sentry/conventions/op';
+import {
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest('creates a pageload transaction with url as source', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+  await page.goto(url);
+  const eventData = envelopeRequestParser<Event>(await pageloadRequestPromise);
+  const timeOrigin = await page.evaluate<number>('window._testBaseTimestamp');
+
+  const { start_timestamp: startTimestamp } = eventData;
+
+  const traceContextData = eventData.contexts?.trace?.data;
+
+  expect(startTimestamp).toBeCloseTo(timeOrigin, 1);
+
+  expect(traceContextData).toMatchObject({
+    [SENTRY_ORIGIN]: 'auto.pageload.browser',
+    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
+    [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
+    [SENTRY_OP]: PAGELOAD,
+    [SENTRY_IDLE_SPAN_FINISH_REASON]: 'idleTimeout',
+  });
+
+  expect(eventData.contexts?.trace?.op).toBe(PAGELOAD);
+  expect(eventData.spans?.length).toBeGreaterThan(0);
+  expect(eventData.transaction_info?.source).toEqual('url');
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-streamed/test.ts
deleted file mode 100644
index 717011ffb9c3..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-streamed/test.ts
+++ /dev/null
@@ -1,192 +0,0 @@
-import { expect } from '@playwright/test';
-import { SDK_VERSION, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
-import {
-  BROWSER_NAVIGATION_TYPE,
-  SENTRY_SEGMENT_NAME_SOURCE,
-  SENTRY_SEGMENT_ID,
-  SENTRY_SEGMENT_NAME,
-  SENTRY_SDK_NAME,
-  SENTRY_SDK_VERSION,
-  SENTRY_TRACE_LIFECYCLE,
-  URL_FULL,
-  URL_PATH,
-  USER_AGENT_ORIGINAL,
-  SENTRY_ENVIRONMENT,
-  SENTRY_SDK_INTEGRATIONS,
-  SENTRY_OP,
-  SENTRY_ORIGIN,
-} from '@sentry/conventions/attributes';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, getSpansFromEnvelope, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
-
-sentryTest(
-  'creates a pageload streamed span envelope with url as pageload span name source',
-  async ({ browserName, getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const spanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'pageload'),
-    );
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-    await page.goto(url);
-
-    const spanEnvelope = await spanEnvelopePromise;
-    const envelopeHeader = spanEnvelope[0];
-    const envelopeItem = spanEnvelope[1];
-    const spans = envelopeItem[0][1].items;
-    const pageloadSpan = spans.find(s => getSpanOp(s) === 'pageload');
-
-    const timeOrigin = await page.evaluate<number>('window._testBaseTimestamp');
-
-    expect(envelopeHeader).toEqual({
-      sdk: {
-        name: 'sentry.javascript.browser',
-        version: SDK_VERSION,
-      },
-      sent_at: expect.any(String),
-      trace: {
-        environment: 'production',
-        public_key: 'public',
-        sample_rand: expect.any(String),
-        sample_rate: '1',
-        sampled: 'true',
-        trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      },
-    });
-
-    const numericSampleRand = parseFloat(envelopeHeader.trace!.sample_rand!);
-    const traceId = envelopeHeader.trace!.trace_id;
-
-    expect(Number.isNaN(numericSampleRand)).toBe(false);
-
-    expect(envelopeItem[0][0].item_count).toBeGreaterThan(1);
-
-    expect(pageloadSpan?.start_timestamp).toBeCloseTo(timeOrigin, 1);
-
-    expect(pageloadSpan).toEqual({
-      attributes: {
-        'sentry.is_localhost': { value: false, type: 'boolean' },
-        'culture.calendar': {
-          type: 'string',
-          value: expect.any(String),
-        },
-        'culture.locale': {
-          type: 'string',
-          value: expect.any(String),
-        },
-        'culture.timezone': {
-          type: 'string',
-          value: expect.any(String),
-        },
-        [USER_AGENT_ORIGINAL]: {
-          type: 'string',
-          value: expect.any(String),
-        },
-        [URL_FULL]: {
-          type: 'string',
-          value: expect.any(String),
-        },
-        [URL_PATH]: {
-          type: 'string',
-          value: expect.any(String),
-        },
-        // formerly known as 'hardwareConcurrency'
-        'device.processor_count': {
-          type: expect.stringMatching(/^(integer)|(double)$/),
-          value: expect.any(Number),
-        },
-        'browser.performance.navigation.activation_start': {
-          type: expect.stringMatching(/^(integer)|(double)$/),
-          value: expect.any(Number),
-        },
-        'browser.performance.time_origin': {
-          type: expect.stringMatching(/^(integer)|(double)$/),
-          value: expect.any(Number),
-        },
-        'browser.web_vital.ttfb.request_time': {
-          type: expect.stringMatching(/^(integer)|(double)$/),
-          value: expect.any(Number),
-        },
-        ...(browserName !== 'webkit' && {
-          // formerly known as 'effectiveConnectionType'
-          'network.connection.effective_type': {
-            type: 'string',
-            value: expect.any(String),
-          },
-          'network.connection.rtt': {
-            type: expect.stringMatching(/^(integer)|(double)$/),
-            value: expect.any(Number),
-          },
-          'browser.web_vital.ttfb.value': {
-            type: expect.stringMatching(/^(integer)|(double)$/),
-            value: expect.any(Number),
-          },
-          [BROWSER_NAVIGATION_TYPE]: {
-            type: 'string',
-            value: 'navigate',
-          },
-        }),
-        'sentry.idle_span_finish_reason': {
-          type: 'string',
-          value: 'idleTimeout',
-        },
-        [SENTRY_OP]: {
-          type: 'string',
-          value: 'pageload',
-        },
-        [SENTRY_ORIGIN]: {
-          type: 'string',
-          value: 'auto.pageload.browser',
-        },
-        [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: {
-          type: 'integer',
-          value: 1,
-        },
-        [SENTRY_SDK_NAME]: {
-          type: 'string',
-          value: 'sentry.javascript.browser',
-        },
-        [SENTRY_SDK_VERSION]: {
-          type: 'string',
-          value: SDK_VERSION,
-        },
-        [SENTRY_SDK_INTEGRATIONS]: {
-          type: 'array',
-          value: expect.arrayContaining(['BrowserTracing', 'SpanStreaming']),
-        },
-        [SENTRY_SEGMENT_ID]: {
-          type: 'string',
-          value: pageloadSpan?.span_id,
-        },
-        [SENTRY_SEGMENT_NAME]: {
-          type: 'string',
-          value: 'Pageload',
-        },
-        [SENTRY_SEGMENT_NAME_SOURCE]: {
-          type: 'string',
-          value: 'url',
-        },
-        [SENTRY_ENVIRONMENT]: {
-          type: 'string',
-          value: 'production',
-        },
-        [SENTRY_TRACE_LIFECYCLE]: {
-          type: 'string',
-          value: 'stream',
-        },
-      },
-      end_timestamp: expect.any(Number),
-      is_segment: true,
-      // The raw URL stays in `url.path`/`url.full`: with span streaming, a pageload span name is
-      // low cardinality and falls back to 'Pageload' when there is no parameterized route.
-      name: 'Pageload',
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-      start_timestamp: expect.any(Number),
-      status: 'ok',
-      trace_id: traceId,
-    });
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-update-txn-name/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-update-txn-name/init.js
index b74e6633eadb..1f0b64911a75 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-update-txn-name/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-update-txn-name/init.js
@@ -4,7 +4,6 @@ window.Sentry = Sentry;
 window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-update-txn-name/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-update-txn-name/test.ts
index 0776668fb9e8..232565e32f9f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-update-txn-name/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-update-txn-name/test.ts
@@ -1,12 +1,13 @@
 import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
-import { type Event, SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME } from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
 sentryTest(
-  'sets the source to custom when updating the transaction name with `span.updateName`',
+  'sets the source to custom when updating the span name with `span.updateName`',
   async ({ getLocalTestUrl, page }) => {
     if (shouldSkipTracingTest()) {
       sentryTest.skip();
@@ -14,25 +15,31 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+    const spans = collectStreamedSpans(page);
+    const [pageloadSpan] = await waitForStreamedSpanAndTraceHeaderOnUrl(
+      page,
+      url,
+      span => getSpanOp(span) === 'pageload',
+    );
+    await page.evaluate(() => (window as any).Sentry.flush());
 
-    const traceContextData = eventData.contexts?.trace?.data;
+    const attributes = pageloadSpan.attributes;
 
-    expect(traceContextData).toBeDefined();
+    expect(attributes).toBeDefined();
 
-    expect(eventData.transaction).toBe('new name');
+    expect(pageloadSpan.name).toBe('new name');
 
-    expect(traceContextData).toMatchObject({
-      [SENTRY_ORIGIN]: 'auto.pageload.browser',
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-      [SENTRY_SEGMENT_NAME_SOURCE]: 'custom',
-      [SENTRY_OP]: 'pageload',
+    expect(pageloadSpan.attributes).toMatchObject({
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: { type: 'integer', value: 1 },
+      [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'custom' },
+      [SENTRY_OP]: { type: 'string', value: 'pageload' },
     });
 
-    expect(traceContextData![SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]).toBeUndefined();
+    expect(attributes[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]).toBeUndefined();
 
-    expect(eventData.contexts?.trace?.op).toBe('pageload');
-    expect(eventData.spans?.length).toBeGreaterThan(0);
-    expect(eventData.transaction_info?.source).toEqual('custom');
+    expect(getSpanOp(pageloadSpan)).toBe('pageload');
+    expect(spans.filter(span => !span.is_segment).length).toBeGreaterThan(0);
+    expect(pageloadSpan.attributes[SENTRY_SEGMENT_NAME_SOURCE]?.value).toEqual('custom');
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/init.js
new file mode 100644
index 000000000000..b74e6633eadb
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/init.js
@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+window._testBaseTimestamp = performance.timeOrigin / 1000;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/subject.js
new file mode 100644
index 000000000000..7f0ad0fea340
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/subject.js
@@ -0,0 +1,4 @@
+const activeSpan = Sentry.getActiveSpan();
+const rootSpan = activeSpan && Sentry.getRootSpan(activeSpan);
+
+Sentry.updateSpanName(rootSpan, 'new name');
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/test.ts
new file mode 100644
index 000000000000..ab1b1ed20c46
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName-static/test.ts
@@ -0,0 +1,38 @@
+import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
+import { type Event, SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest(
+  'sets the source to custom when updating the transaction name with Sentry.updateSpanName',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+
+    const traceContextData = eventData.contexts?.trace?.data;
+
+    expect(traceContextData).toBeDefined();
+
+    expect(traceContextData).toMatchObject({
+      [SENTRY_ORIGIN]: 'auto.pageload.browser',
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
+      [SENTRY_SEGMENT_NAME_SOURCE]: 'custom',
+      [SENTRY_OP]: 'pageload',
+    });
+
+    expect(traceContextData![SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]).toBeUndefined();
+
+    expect(eventData.transaction).toBe('new name');
+
+    expect(eventData.contexts?.trace?.op).toBe('pageload');
+    expect(eventData.spans?.length).toBeGreaterThan(0);
+    expect(eventData.transaction_info?.source).toEqual('custom');
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/init.js
index b74e6633eadb..1f0b64911a75 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/init.js
@@ -4,7 +4,6 @@ window.Sentry = Sentry;
 window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/test.ts
index ab1b1ed20c46..0ee7a634717f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/test.ts
@@ -1,12 +1,13 @@
 import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
-import { type Event, SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME } from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
 sentryTest(
-  'sets the source to custom when updating the transaction name with Sentry.updateSpanName',
+  'sets the source to custom when updating the span name with Sentry.updateSpanName',
   async ({ getLocalTestUrl, page }) => {
     if (shouldSkipTracingTest()) {
       sentryTest.skip();
@@ -14,25 +15,31 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+    const spans = collectStreamedSpans(page);
+    const [pageloadSpan] = await waitForStreamedSpanAndTraceHeaderOnUrl(
+      page,
+      url,
+      span => getSpanOp(span) === 'pageload',
+    );
+    await page.evaluate(() => (window as any).Sentry.flush());
 
-    const traceContextData = eventData.contexts?.trace?.data;
+    const attributes = pageloadSpan.attributes;
 
-    expect(traceContextData).toBeDefined();
+    expect(attributes).toBeDefined();
 
-    expect(traceContextData).toMatchObject({
-      [SENTRY_ORIGIN]: 'auto.pageload.browser',
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-      [SENTRY_SEGMENT_NAME_SOURCE]: 'custom',
-      [SENTRY_OP]: 'pageload',
+    expect(pageloadSpan.attributes).toMatchObject({
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: { type: 'integer', value: 1 },
+      [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'custom' },
+      [SENTRY_OP]: { type: 'string', value: 'pageload' },
     });
 
-    expect(traceContextData![SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]).toBeUndefined();
+    expect(attributes[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]).toEqual({ type: 'string', value: 'new name' });
 
-    expect(eventData.transaction).toBe('new name');
+    expect(pageloadSpan.name).toBe('new name');
 
-    expect(eventData.contexts?.trace?.op).toBe('pageload');
-    expect(eventData.spans?.length).toBeGreaterThan(0);
-    expect(eventData.transaction_info?.source).toEqual('custom');
+    expect(getSpanOp(pageloadSpan)).toBe('pageload');
+    expect(spans.filter(span => !span.is_segment).length).toBeGreaterThan(0);
+    expect(pageloadSpan.attributes[SENTRY_SEGMENT_NAME_SOURCE]?.value).toEqual('custom');
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload/init.js
index b74e6633eadb..1f0b64911a75 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload/init.js
@@ -4,7 +4,6 @@ window.Sentry = Sentry;
 window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload/test.ts
index 8e7c3a4b2480..83e6991b114c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload/test.ts
@@ -1,35 +1,208 @@
-import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
-import type { Event } from '@sentry/core';
+import { SDK_VERSION, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
+import {
+  SENTRY_IS_LOCALHOST,
+  CULTURE_CALENDAR,
+  CULTURE_LOCALE,
+  CULTURE_TIMEZONE,
+  DEVICE_PROCESSOR_COUNT,
+  BROWSER_PERFORMANCE_NAVIGATION_ACTIVATION_START,
+  BROWSER_PERFORMANCE_TIME_ORIGIN,
+  BROWSER_WEB_VITAL_TTFB_REQUEST_TIME,
+  NETWORK_CONNECTION_EFFECTIVE_TYPE,
+  NETWORK_CONNECTION_RTT,
+  BROWSER_WEB_VITAL_TTFB_VALUE,
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  BROWSER_NAVIGATION_TYPE,
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SEGMENT_NAME,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_TRACE_LIFECYCLE,
+  URL_FULL,
+  URL_PATH,
+  USER_AGENT_ORIGINAL,
+  SENTRY_ENVIRONMENT,
+  SENTRY_SDK_INTEGRATIONS,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import {
+  collectStreamedSpans,
+  getSpanOp,
+  getSpansFromEnvelope,
+  waitForStreamedSpanEnvelope,
+} from '../../../../utils/spanUtils';
 
-sentryTest('creates a pageload transaction with url as source', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+sentryTest(
+  'creates a pageload streamed span envelope with url as pageload span name source',
+  async ({ browserName, getLocalTestUrl, page }) => {
+    sentryTest.skip(shouldSkipTracingTest());
 
-  const url = await getLocalTestUrl({ testDir: __dirname });
+    const collectedSpans = collectStreamedSpans(page);
+    const spanEnvelopePromise = waitForStreamedSpanEnvelope(
+      page,
+      env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'pageload'),
+    );
 
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const timeOrigin = await page.evaluate<number>('window._testBaseTimestamp');
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    await page.goto(url);
 
-  const { start_timestamp: startTimestamp } = eventData;
+    const spanEnvelope = await spanEnvelopePromise;
+    const envelopeHeader = spanEnvelope[0];
+    const envelopeItem = spanEnvelope[1];
+    const spans = envelopeItem[0][1].items;
+    const pageloadSpan = spans.find(s => getSpanOp(s) === 'pageload');
 
-  const traceContextData = eventData.contexts?.trace?.data;
+    const timeOrigin = await page.evaluate<number>('window._testBaseTimestamp');
 
-  expect(startTimestamp).toBeCloseTo(timeOrigin, 1);
+    expect(envelopeHeader).toEqual({
+      sdk: {
+        name: 'sentry.javascript.browser',
+        version: SDK_VERSION,
+      },
+      sent_at: expect.any(String),
+      trace: {
+        environment: 'production',
+        public_key: 'public',
+        sample_rand: expect.any(String),
+        sample_rate: '1',
+        sampled: 'true',
+        trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      },
+    });
 
-  expect(traceContextData).toMatchObject({
-    [SENTRY_ORIGIN]: 'auto.pageload.browser',
-    [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-    [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-    [SENTRY_OP]: 'pageload',
-    ['sentry.idle_span_finish_reason']: 'idleTimeout',
-  });
+    const numericSampleRand = parseFloat(envelopeHeader.trace!.sample_rand!);
+    const traceId = envelopeHeader.trace!.trace_id;
 
-  expect(eventData.contexts?.trace?.op).toBe('pageload');
-  expect(eventData.spans?.length).toBeGreaterThan(0);
-  expect(eventData.transaction_info?.source).toEqual('url');
-});
+    expect(Number.isNaN(numericSampleRand)).toBe(false);
+
+    expect(envelopeItem[0][0].item_count).toBe(spans.length);
+    await page.evaluate(() => (window as any).Sentry.flush());
+    expect(collectedSpans.filter(span => !span.is_segment)).not.toHaveLength(0);
+
+    expect(pageloadSpan?.start_timestamp).toBeCloseTo(timeOrigin, 1);
+
+    expect(pageloadSpan).toEqual({
+      attributes: {
+        [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
+        [CULTURE_CALENDAR]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+        [CULTURE_LOCALE]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+        [CULTURE_TIMEZONE]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+        [USER_AGENT_ORIGINAL]: {
+          type: 'string',
+          value: expect.any(String),
+        },
+        [URL_FULL]: {
+          type: 'string',
+          value: 'http://sentry-test.io/index.html',
+        },
+        [URL_PATH]: {
+          type: 'string',
+          value: '/index.html',
+        },
+        [DEVICE_PROCESSOR_COUNT]: {
+          type: expect.stringMatching(/^(integer)|(double)$/),
+          value: expect.any(Number),
+        },
+        [BROWSER_PERFORMANCE_NAVIGATION_ACTIVATION_START]: {
+          type: expect.stringMatching(/^(integer)|(double)$/),
+          value: expect.any(Number),
+        },
+        [BROWSER_PERFORMANCE_TIME_ORIGIN]: {
+          type: expect.stringMatching(/^(integer)|(double)$/),
+          value: expect.any(Number),
+        },
+        [BROWSER_WEB_VITAL_TTFB_REQUEST_TIME]: {
+          type: expect.stringMatching(/^(integer)|(double)$/),
+          value: expect.any(Number),
+        },
+        ...(browserName !== 'webkit' && {
+          [NETWORK_CONNECTION_EFFECTIVE_TYPE]: {
+            type: 'string',
+            value: expect.any(String),
+          },
+          [NETWORK_CONNECTION_RTT]: {
+            type: expect.stringMatching(/^(integer)|(double)$/),
+            value: expect.any(Number),
+          },
+          [BROWSER_WEB_VITAL_TTFB_VALUE]: {
+            type: expect.stringMatching(/^(integer)|(double)$/),
+            value: expect.any(Number),
+          },
+          [BROWSER_NAVIGATION_TYPE]: {
+            type: 'string',
+            value: 'navigate',
+          },
+        }),
+        [SENTRY_IDLE_SPAN_FINISH_REASON]: {
+          type: 'string',
+          value: 'idleTimeout',
+        },
+        [SENTRY_OP]: {
+          type: 'string',
+          value: 'pageload',
+        },
+        [SENTRY_ORIGIN]: {
+          type: 'string',
+          value: 'auto.pageload.browser',
+        },
+        [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: {
+          type: 'integer',
+          value: 1,
+        },
+        [SENTRY_SDK_NAME]: {
+          type: 'string',
+          value: 'sentry.javascript.browser',
+        },
+        [SENTRY_SDK_VERSION]: {
+          type: 'string',
+          value: SDK_VERSION,
+        },
+        [SENTRY_SDK_INTEGRATIONS]: {
+          type: 'array',
+          value: expect.arrayContaining(['BrowserTracing', 'SpanStreaming']),
+        },
+        [SENTRY_SEGMENT_ID]: {
+          type: 'string',
+          value: pageloadSpan?.span_id,
+        },
+        [SENTRY_SEGMENT_NAME]: {
+          type: 'string',
+          value: 'Pageload',
+        },
+        [SENTRY_SEGMENT_NAME_SOURCE]: {
+          type: 'string',
+          value: 'url',
+        },
+        [SENTRY_ENVIRONMENT]: {
+          type: 'string',
+          value: 'production',
+        },
+        [SENTRY_TRACE_LIFECYCLE]: {
+          type: 'string',
+          value: 'stream',
+        },
+      },
+      end_timestamp: expect.any(Number),
+      is_segment: true,
+      name: 'Pageload',
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+      start_timestamp: expect.any(Number),
+      status: 'ok',
+      trace_id: traceId,
+    });
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadDelayed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadDelayed/init.js
index ba739b4b8cc5..2c5a44a7f76d 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadDelayed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadDelayed/init.js
@@ -6,7 +6,6 @@ window._testBaseTimestamp = performance.timeOrigin / 1000;
 setTimeout(() => {
   window._testTimeoutTimestamp = (performance.timeOrigin + performance.now()) / 1000;
   Sentry.init({
-    traceLifecycle: 'static',
     dsn: 'https://public@dsn.ingest.sentry.io/1337',
     integrations: [Sentry.browserTracingIntegration()],
     tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadDelayed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadDelayed/test.ts
index 0d608a782314..2b09200481b7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadDelayed/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadDelayed/test.ts
@@ -1,25 +1,32 @@
+import { SENTRY_SEGMENT_NAME_SOURCE } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
-sentryTest('should create a pageload transaction when initialized delayed', async ({ getLocalTestUrl, page }) => {
+sentryTest('should create a pageload span when initialized delayed', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
     sentryTest.skip();
   }
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  const spans = collectStreamedSpans(page);
+  const [pageloadSpan] = await waitForStreamedSpanAndTraceHeaderOnUrl(
+    page,
+    url,
+    span => getSpanOp(span) === 'pageload',
+  );
+  await page.evaluate(() => (window as any).Sentry.flush());
   const timeOrigin = await page.evaluate<number>('window._testBaseTimestamp');
   const timeoutTimestamp = await page.evaluate<number>('window._testTimeoutTimestamp');
 
-  const { start_timestamp: startTimestamp } = eventData;
+  const { start_timestamp: startTimestamp } = pageloadSpan;
 
   expect(startTimestamp).toBeCloseTo(timeOrigin, 1);
   expect(startTimestamp).toBeLessThan(timeoutTimestamp);
 
-  expect(eventData.contexts?.trace?.op).toBe('pageload');
-  expect(eventData.spans?.length).toBeGreaterThan(0);
-  expect(eventData.transaction_info?.source).toEqual('url');
+  expect(getSpanOp(pageloadSpan)).toBe('pageload');
+  expect(spans.filter(span => !span.is_segment).length).toBeGreaterThan(0);
+  expect(pageloadSpan.attributes[SENTRY_SEGMENT_NAME_SOURCE]?.value).toEqual('url');
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadWithChildSpanTimeout/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadWithChildSpanTimeout/init.js
index b2820c740c2b..229372e215c7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadWithChildSpanTimeout/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadWithChildSpanTimeout/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadWithChildSpanTimeout/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadWithChildSpanTimeout/test.ts
index 16f5a2f7f539..daf8048d6622 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadWithChildSpanTimeout/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageloadWithChildSpanTimeout/test.ts
@@ -1,28 +1,33 @@
+import { SENTRY_IDLE_SPAN_FINISH_REASON } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  shouldSkipTracingTest,
-  waitForTransactionRequestOnUrl,
-} from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
-// This tests asserts that the pageload span will finish itself after the child span timeout if it
-// has a child span without adding any additional ones or finishing any of them finishing. All of the child spans that
-// are still running should have the status "cancelled".
 sentryTest('should send a pageload span terminated via child span timeout', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
     sentryTest.skip();
   }
 
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const req = await waitForTransactionRequestOnUrl(page, url);
+  const spans = collectStreamedSpans(page);
+  const [pageloadSpan] = await waitForStreamedSpanAndTraceHeaderOnUrl(
+    page,
+    url,
+    span => getSpanOp(span) === 'pageload',
+  );
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-  const eventData = envelopeRequestParser(req);
-
-  expect(eventData.contexts?.trace?.op).toBe('pageload');
-  expect(eventData.contexts?.trace?.data?.['sentry.idle_span_discarded_spans']).toBeUndefined();
-  expect(eventData.spans?.length).toBeGreaterThanOrEqual(1);
-  const testSpan = eventData.spans?.find(span => span.description === 'pageload-child-span');
+  expect(getSpanOp(pageloadSpan)).toBe('pageload');
+  expect(pageloadSpan.attributes['sentry.idle_span_discarded_spans']).toBeUndefined();
+  expect(spans.length).toBeGreaterThanOrEqual(2);
+  const testSpan = spans.find(span => span.name === 'pageload-child-span');
   expect(testSpan).toBeDefined();
-  expect(testSpan?.status).toBe('cancelled');
+  expect(testSpan?.status).toBe('ok');
+  expect(pageloadSpan.attributes[SENTRY_IDLE_SPAN_FINISH_REASON]?.value).toBe('heartbeatFailed');
+  expect(testSpan).toMatchObject({
+    parent_span_id: pageloadSpan.span_id,
+    trace_id: pageloadSpan.trace_id,
+    end_timestamp: pageloadSpan.end_timestamp,
+  });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/default/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/default/init.js
similarity index 86%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/default/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/default/init.js
index ded3ca204b6b..054a40d79664 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/default/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/default/init.js
@@ -4,8 +4,9 @@ window.Sentry = Sentry;
 window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration({ enableReportPageLoaded: true }), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration({ enableReportPageLoaded: true })],
   tracesSampleRate: 1,
   debug: true,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/default/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/default/test.ts
similarity index 50%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/default/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/default/test.ts
index 3c4a37bc9de3..a20d10297c4b 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/default/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/default/test.ts
@@ -7,30 +7,32 @@ import {
 import { expect } from '@playwright/test';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
 
 sentryTest(
   'waits for Sentry.reportPageLoaded() to be called when `enableReportPageLoaded` is true',
   async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
 
-    const url = await getLocalTestUrl({ testDir: __dirname });
+    const pageloadEventPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
 
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+    const url = await getLocalTestUrl({ testDir: __dirname });
 
     await page.goto(url);
 
-    const pageloadSpan = await pageloadSpanPromise;
+    const eventData = envelopeRequestParser(await pageloadEventPromise);
 
-    const spanDurationSeconds = pageloadSpan.end_timestamp - pageloadSpan.start_timestamp;
+    const traceContextData = eventData.contexts?.trace?.data;
+    const spanDurationSeconds = eventData.timestamp! - eventData.start_timestamp!;
 
-    expect(pageloadSpan.attributes).toMatchObject({
-      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: expect.objectContaining({ value: 1 }),
-      [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'url' },
-      [SENTRY_OP]: { type: 'string', value: 'pageload' },
-      [SENTRY_IDLE_SPAN_FINISH_REASON]: { type: 'string', value: 'reportPageLoaded' },
+    expect(traceContextData).toMatchObject({
+      [SENTRY_ORIGIN]: 'auto.pageload.browser',
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
+      [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
+      [SENTRY_OP]: 'pageload',
+      [SENTRY_IDLE_SPAN_FINISH_REASON]: 'reportPageLoaded',
     });
 
     // We wait for 2.5 seconds before calling Sentry.reportPageLoaded(). The span starts at navigation start,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/finalTimeout/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/finalTimeout/init.js
similarity index 65%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/finalTimeout/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/finalTimeout/init.js
index b1c19f779713..2f633a9c6f1e 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/finalTimeout/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/finalTimeout/init.js
@@ -4,11 +4,9 @@ window.Sentry = Sentry;
 window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [
-    Sentry.browserTracingIntegration({ enableReportPageLoaded: true, finalTimeout: 3000 }),
-    Sentry.spanStreamingIntegration(),
-  ],
+  integrations: [Sentry.browserTracingIntegration({ enableReportPageLoaded: true, finalTimeout: 3000 })],
   tracesSampleRate: 1,
   debug: true,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/finalTimeout/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/finalTimeout/test.ts
new file mode 100644
index 000000000000..8244b6f83c7a
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/finalTimeout/test.ts
@@ -0,0 +1,43 @@
+import {
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
+import { sentryTest } from '../../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+
+sentryTest(
+  'final timeout cancels the pageload span even if `enableReportPageLoaded` is true',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const pageloadEventPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await page.goto(url);
+
+    const eventData = envelopeRequestParser(await pageloadEventPromise);
+
+    const traceContextData = eventData.contexts?.trace?.data;
+    const spanDurationSeconds = eventData.timestamp! - eventData.start_timestamp!;
+
+    expect(traceContextData).toMatchObject({
+      [SENTRY_ORIGIN]: 'auto.pageload.browser',
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
+      [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
+      [SENTRY_OP]: 'pageload',
+      [SENTRY_IDLE_SPAN_FINISH_REASON]: 'finalTimeout',
+    });
+
+    // We wait for 3 seconds before calling Sentry.reportPageLoaded()
+    // the margins are to account for timing weirdness in CI to avoid flakes
+    expect(spanDurationSeconds).toBeGreaterThan(2.5);
+    expect(spanDurationSeconds).toBeLessThan(3.5);
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/navigation/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/navigation/init.js
similarity index 71%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/navigation/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/navigation/init.js
index ac42880742a3..3e937c873954 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/navigation/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/navigation/init.js
@@ -4,11 +4,9 @@ window.Sentry = Sentry;
 window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [
-    Sentry.browserTracingIntegration({ enableReportPageLoaded: true, instrumentNavigation: false }),
-    Sentry.spanStreamingIntegration(),
-  ],
+  integrations: [Sentry.browserTracingIntegration({ enableReportPageLoaded: true, instrumentNavigation: false })],
   tracesSampleRate: 1,
   debug: true,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/navigation/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/navigation/test.ts
new file mode 100644
index 000000000000..376c35d25a7f
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-static/navigation/test.ts
@@ -0,0 +1,41 @@
+import {
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
+import { sentryTest } from '../../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+
+sentryTest(
+  'starting a navigation span cancels the pageload span even if `enableReportPageLoaded` is true',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const pageloadEventPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await page.goto(url);
+
+    const eventData = envelopeRequestParser(await pageloadEventPromise);
+
+    const traceContextData = eventData.contexts?.trace?.data;
+    const spanDurationSeconds = eventData.timestamp! - eventData.start_timestamp!;
+
+    expect(traceContextData).toMatchObject({
+      [SENTRY_ORIGIN]: 'auto.pageload.browser',
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
+      [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
+      [SENTRY_OP]: 'pageload',
+      [SENTRY_IDLE_SPAN_FINISH_REASON]: 'cancelled',
+    });
+
+    // ending span after 1s but adding a margin of 0.5s to account for timing weirdness in CI to avoid flakes
+    expect(spanDurationSeconds).toBeLessThan(1.5);
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/finalTimeout/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/finalTimeout/test.ts
deleted file mode 100644
index 8ea2ea1ca842..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/finalTimeout/test.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
-import { expect } from '@playwright/test';
-import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
-import { sentryTest } from '../../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
-
-sentryTest(
-  'final timeout cancels the pageload span even if `enableReportPageLoaded` is true',
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-
-    await page.goto(url);
-
-    const pageloadSpan = await pageloadSpanPromise;
-
-    const spanDurationSeconds = pageloadSpan.end_timestamp - pageloadSpan.start_timestamp;
-
-    expect(pageloadSpan.attributes).toMatchObject({
-      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: expect.objectContaining({ value: 1 }),
-      [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'url' },
-      [SENTRY_OP]: { type: 'string', value: 'pageload' },
-      'sentry.idle_span_finish_reason': { type: 'string', value: 'finalTimeout' },
-    });
-
-    // We wait for 3 seconds before calling Sentry.reportPageLoaded()
-    // the margins are to account for timing weirdness in CI to avoid flakes
-    expect(spanDurationSeconds).toBeGreaterThan(2.5);
-    expect(spanDurationSeconds).toBeLessThan(3.5);
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/navigation/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/navigation/test.ts
deleted file mode 100644
index db6f6737ccd6..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded-streamed/navigation/test.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
-import { expect } from '@playwright/test';
-import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
-import { sentryTest } from '../../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
-
-sentryTest(
-  'starting a navigation span cancels the pageload span even if `enableReportPageLoaded` is true',
-  async ({ getLocalTestUrl, page }) => {
-    sentryTest.skip(shouldSkipTracingTest());
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-
-    await page.goto(url);
-
-    const pageloadSpan = await pageloadSpanPromise;
-
-    const spanDurationSeconds = pageloadSpan.end_timestamp - pageloadSpan.start_timestamp;
-
-    expect(pageloadSpan.attributes).toMatchObject({
-      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: expect.objectContaining({ value: 1 }),
-      [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'url' },
-      [SENTRY_OP]: { type: 'string', value: 'pageload' },
-      'sentry.idle_span_finish_reason': { type: 'string', value: 'cancelled' },
-    });
-
-    // ending span after 1s but adding a margin of 0.5s to account for timing weirdness in CI to avoid flakes
-    expect(spanDurationSeconds).toBeLessThan(1.5);
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/default/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/default/init.js
index 054a40d79664..39a212ae5fa5 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/default/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/default/init.js
@@ -4,7 +4,6 @@ window.Sentry = Sentry;
 window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration({ enableReportPageLoaded: true })],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/default/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/default/test.ts
index bca0d6052b95..52fb62fbec10 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/default/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/default/test.ts
@@ -1,33 +1,37 @@
-import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import {
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
+
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest(
   'waits for Sentry.reportPageLoaded() to be called when `enableReportPageLoaded` is true',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
-
-    const pageloadEventPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+
     await page.goto(url);
 
-    const eventData = envelopeRequestParser(await pageloadEventPromise);
+    const pageloadSpan = await pageloadSpanPromise;
 
-    const traceContextData = eventData.contexts?.trace?.data;
-    const spanDurationSeconds = eventData.timestamp! - eventData.start_timestamp!;
+    const spanDurationSeconds = pageloadSpan.end_timestamp - pageloadSpan.start_timestamp;
 
-    expect(traceContextData).toMatchObject({
-      [SENTRY_ORIGIN]: 'auto.pageload.browser',
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-      [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-      [SENTRY_OP]: 'pageload',
-      ['sentry.idle_span_finish_reason']: 'reportPageLoaded',
+    expect(pageloadSpan.attributes).toMatchObject({
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: expect.objectContaining({ value: 1 }),
+      [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'url' },
+      [SENTRY_OP]: { type: 'string', value: 'pageload' },
+      [SENTRY_IDLE_SPAN_FINISH_REASON]: { type: 'string', value: 'reportPageLoaded' },
     });
 
     // We wait for 2.5 seconds before calling Sentry.reportPageLoaded(). The span starts at navigation start,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/finalTimeout/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/finalTimeout/init.js
index 2f633a9c6f1e..7ec015be44dd 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/finalTimeout/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/finalTimeout/init.js
@@ -4,7 +4,6 @@ window.Sentry = Sentry;
 window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration({ enableReportPageLoaded: true, finalTimeout: 3000 })],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/finalTimeout/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/finalTimeout/test.ts
index ae6ffdec21b3..aaef5b809ed7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/finalTimeout/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/finalTimeout/test.ts
@@ -1,33 +1,36 @@
-import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import {
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest(
   'final timeout cancels the pageload span even if `enableReportPageLoaded` is true',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
-
-    const pageloadEventPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+
     await page.goto(url);
 
-    const eventData = envelopeRequestParser(await pageloadEventPromise);
+    const pageloadSpan = await pageloadSpanPromise;
 
-    const traceContextData = eventData.contexts?.trace?.data;
-    const spanDurationSeconds = eventData.timestamp! - eventData.start_timestamp!;
+    const spanDurationSeconds = pageloadSpan.end_timestamp - pageloadSpan.start_timestamp;
 
-    expect(traceContextData).toMatchObject({
-      [SENTRY_ORIGIN]: 'auto.pageload.browser',
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-      [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-      [SENTRY_OP]: 'pageload',
-      ['sentry.idle_span_finish_reason']: 'finalTimeout',
+    expect(pageloadSpan.attributes).toMatchObject({
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: expect.objectContaining({ value: 1 }),
+      [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'url' },
+      [SENTRY_OP]: { type: 'string', value: 'pageload' },
+      [SENTRY_IDLE_SPAN_FINISH_REASON]: { type: 'string', value: 'finalTimeout' },
     });
 
     // We wait for 3 seconds before calling Sentry.reportPageLoaded()
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/navigation/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/navigation/init.js
index 3e937c873954..65e9938f7985 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/navigation/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/navigation/init.js
@@ -4,7 +4,6 @@ window.Sentry = Sentry;
 window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration({ enableReportPageLoaded: true, instrumentNavigation: false })],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/navigation/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/navigation/test.ts
index 9e947592a576..b67276f0bcd0 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/navigation/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/reportPageLoaded/navigation/test.ts
@@ -1,33 +1,36 @@
-import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import {
+  SENTRY_IDLE_SPAN_FINISH_REASON,
+  SENTRY_SEGMENT_NAME_SOURCE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/browser';
 import { sentryTest } from '../../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../../utils/spanUtils';
 
 sentryTest(
   'starting a navigation span cancels the pageload span even if `enableReportPageLoaded` is true',
   async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
-
-    const pageloadEventPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
+    sentryTest.skip(shouldSkipTracingTest());
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+
     await page.goto(url);
 
-    const eventData = envelopeRequestParser(await pageloadEventPromise);
+    const pageloadSpan = await pageloadSpanPromise;
 
-    const traceContextData = eventData.contexts?.trace?.data;
-    const spanDurationSeconds = eventData.timestamp! - eventData.start_timestamp!;
+    const spanDurationSeconds = pageloadSpan.end_timestamp - pageloadSpan.start_timestamp;
 
-    expect(traceContextData).toMatchObject({
-      [SENTRY_ORIGIN]: 'auto.pageload.browser',
-      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
-      [SENTRY_SEGMENT_NAME_SOURCE]: 'url',
-      [SENTRY_OP]: 'pageload',
-      ['sentry.idle_span_finish_reason']: 'cancelled',
+    expect(pageloadSpan.attributes).toMatchObject({
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.pageload.browser' },
+      [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: expect.objectContaining({ value: 1 }),
+      [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'url' },
+      [SENTRY_OP]: { type: 'string', value: 'pageload' },
+      [SENTRY_IDLE_SPAN_FINISH_REASON]: { type: 'string', value: 'cancelled' },
     });
 
     // ending span after 1s but adding a margin of 0.5s to account for timing weirdness in CI to avoid flakes
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/resource-spans-ignored/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/resource-spans-ignored/init.js
index 0eb1efc7a5a4..3a4c2cb1cdf4 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/resource-spans-ignored/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/resource-spans-ignored/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/resource-spans-ignored/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/resource-spans-ignored/test.ts
index 4bc9621f8395..282625e0d8b7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/resource-spans-ignored/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/resource-spans-ignored/test.ts
@@ -1,8 +1,8 @@
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
 
 sentryTest('should allow specific types of resource spans to be ignored.', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
@@ -13,8 +13,10 @@ sentryTest('should allow specific types of resource spans to be ignored.', async
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const allSpans = eventData.spans?.filter(({ op }) => op?.startsWith('resource.script'));
+  const spans = collectStreamedSpans(page);
+  await waitForStreamedSpanAndTraceHeaderOnUrl(page, url, span => getSpanOp(span) === 'pageload');
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const allSpans = spans?.filter(span => getSpanOp(span)?.startsWith('resource.script'));
 
   expect(allSpans?.length).toBe(0);
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-static/init.js
similarity index 90%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-static/init.js
index 53029a40b668..f2b876b3bf7d 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-static/init.js
@@ -4,13 +4,13 @@ import { interactionsIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
       enableLongTask: false,
     }),
     interactionsIntegration(),
-    Sentry.spanStreamingIntegration(),
     Sentry.spotlightBrowserIntegration(),
   ],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-static/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-streamed/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-static/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-streamed/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-streamed/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-static/test.ts
new file mode 100644
index 000000000000..ae6640054caa
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-static/test.ts
@@ -0,0 +1,54 @@
+import { PAGELOAD, UI_ACTION_CLICK, UI_INTERACTION_CLICK } from '@sentry/conventions/op';
+import { expect } from '@playwright/test';
+import type { TransactionEvent } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  shouldSkipCdnBundleTest,
+  shouldSkipTracingTest,
+  waitForTransactionRequest,
+} from '../../../../utils/helpers';
+
+sentryTest(
+  'filters ui.interaction.click spans for spotlight elements via ignoreSpans',
+  async ({ getLocalTestUrl, page }) => {
+    // spotlightBrowserIntegration is not available in CDN bundles
+    if (shouldSkipTracingTest() || shouldSkipCdnBundleTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    const pageloadPromise = waitForTransactionRequest(page, txn => txn.contexts?.trace?.op === PAGELOAD);
+    await page.goto(url);
+    await pageloadPromise;
+
+    // Click on the spotlight element — interaction span should be filtered
+    const spotlightTxnPromise = waitForTransactionRequest(page, txn => txn.contexts?.trace?.op === UI_ACTION_CLICK);
+    await page.locator('[data-test-id=spotlight-button]').click();
+    await page.locator('.clicked[data-test-id=spotlight-button]').isVisible();
+    const spotlightTransaction = envelopeRequestParser<TransactionEvent>(await spotlightTxnPromise);
+
+    expect(spotlightTransaction.contexts?.trace?.op).toBe(UI_ACTION_CLICK);
+
+    const spotlightInteractionSpans = spotlightTransaction.spans?.filter(span => span.op === UI_INTERACTION_CLICK);
+    expect(spotlightInteractionSpans).toHaveLength(0);
+
+    // Click on the regular button — wait specifically for a transaction that contains
+    // a ui.interaction.click child span, since the PerformanceObserver may deliver
+    // the event entry asynchronously
+    const regularTxnPromise = waitForTransactionRequest(
+      page,
+      txn =>
+        txn.contexts?.trace?.op === UI_ACTION_CLICK &&
+        (txn.spans?.some(span => span.op === UI_INTERACTION_CLICK) ?? false),
+    );
+    await page.locator('[data-test-id=regular-button]').click();
+    await page.locator('.clicked[data-test-id=regular-button]').isVisible();
+    const regularTransaction = envelopeRequestParser<TransactionEvent>(await regularTxnPromise);
+
+    const regularInteractionSpans = regularTransaction.spans?.filter(span => span.op === UI_INTERACTION_CLICK);
+    expect(regularInteractionSpans?.length).toBeGreaterThanOrEqual(1);
+    expect(regularInteractionSpans![0]!.description).toContain('button');
+    expect(regularInteractionSpans![0]!.description).not.toContain('#sentry-spotlight');
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-streamed/test.ts
deleted file mode 100644
index 0a646701fde8..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter-streamed/test.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipCdnBundleTest, shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, observeStreamedSpan, waitForStreamedSpan, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-// Interaction spans are named after the component, so the element is on `browser.web_vital.inp.target`.
-// The click handler adds the `clicked` class before the event timing entry is recorded.
-const SPOTLIGHT_BUTTON = 'body > div#sentry-spotlight > button.clicked';
-const REGULAR_BUTTON = 'body > button.clicked';
-
-sentryTest(
-  'filters ui.interaction.click spans for spotlight elements via ignoreSpans in streaming mode',
-  async ({ getLocalTestUrl, page }) => {
-    // spotlightBrowserIntegration is not available in CDN bundles
-    if (shouldSkipTracingTest() || shouldSkipCdnBundleTest()) {
-      sentryTest.skip();
-    }
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    // Set up an observer that fails if a spotlight interaction span is ever sent
-    let sawSpotlightInteractionSpan = false;
-    await observeStreamedSpan(page, span => {
-      if (
-        getSpanOp(span) === 'ui.interaction.click' &&
-        span.attributes['browser.web_vital.inp.target']?.value === SPOTLIGHT_BUTTON
-      ) {
-        sawSpotlightInteractionSpan = true;
-        return true;
-      }
-      return false;
-    });
-
-    await page.goto(url);
-
-    // Wait for pageload to finish before clicking
-    await waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-
-    // Click on the spotlight element — its ui.interaction.click child should be filtered
-    await page.locator('[data-test-id=spotlight-button]').click();
-    await page.locator('.clicked[data-test-id=spotlight-button]').isVisible();
-
-    // Wait for the spotlight click's segment span to arrive
-    await waitForStreamedSpans(page, spans =>
-      spans.some(span => span.is_segment && getSpanOp(span) === 'ui.action.click'),
-    );
-
-    // Click on the regular button — its ui.interaction.click child should be kept
-    const regularInteractionSpansPromise = waitForStreamedSpans(page, spans =>
-      spans.some(span => span.attributes['browser.web_vital.inp.target']?.value === REGULAR_BUTTON),
-    );
-
-    await page.locator('[data-test-id=regular-button]').click();
-    await page.locator('.clicked[data-test-id=regular-button]').isVisible();
-
-    const regularSpans = await regularInteractionSpansPromise;
-    const regularInteractionSpan = regularSpans.find(
-      span => span.attributes['browser.web_vital.inp.target']?.value === REGULAR_BUTTON,
-    );
-    expect(getSpanOp(regularInteractionSpan!)).toBe('ui.interaction.click');
-
-    // Verify no spotlight interaction span was ever sent
-    expect(sawSpotlightInteractionSpan).toBe(false);
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter/init.js
index f2b876b3bf7d..652e289ca5f7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter/init.js
@@ -4,7 +4,6 @@ import { interactionsIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter/test.ts
index d0480062c10a..26d8b21cc6b3 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/spotlight-interaction-filter/test.ts
@@ -1,57 +1,50 @@
+import { BROWSER_WEB_VITAL_INP_TARGET } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { TransactionEvent } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  shouldSkipCdnBundleTest,
-  shouldSkipTracingTest,
-  waitForTransactionRequest,
-} from '../../../../utils/helpers';
-
-sentryTest(
-  'filters ui.interaction.click spans for spotlight elements via ignoreSpans',
-  async ({ getLocalTestUrl, page }) => {
-    // spotlightBrowserIntegration is not available in CDN bundles
-    if (shouldSkipTracingTest() || shouldSkipCdnBundleTest()) {
-      sentryTest.skip();
-    }
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-    await page.goto(url);
-
-    // Wait for the pageload transaction to complete
-    await waitForTransactionRequest(page);
-
-    // Click on the spotlight element — interaction span should be filtered
-    const spotlightTxnPromise = waitForTransactionRequest(page, txn => txn.contexts?.trace?.op === 'ui.action.click');
-    await page.locator('[data-test-id=spotlight-button]').click();
-    await page.locator('.clicked[data-test-id=spotlight-button]').isVisible();
-    const spotlightTransaction = envelopeRequestParser<TransactionEvent>(await spotlightTxnPromise);
-
-    expect(spotlightTransaction.contexts?.trace?.op).toBe('ui.action.click');
-
-    const spotlightInteractionSpans = spotlightTransaction.spans?.filter(span => span.op === 'ui.interaction.click');
-    expect(spotlightInteractionSpans).toHaveLength(0);
-
-    // Let the first idle span fully settle before clicking again
-    await page.waitForTimeout(1000);
-
-    // Click on the regular button — wait specifically for a transaction that contains
-    // a ui.interaction.click child span, since the PerformanceObserver may deliver
-    // the event entry asynchronously
-    const regularTxnPromise = waitForTransactionRequest(
-      page,
-      txn =>
-        txn.contexts?.trace?.op === 'ui.action.click' &&
-        (txn.spans?.some(span => span.op === 'ui.interaction.click') ?? false),
-    );
-    await page.locator('[data-test-id=regular-button]').click();
-    await page.locator('.clicked[data-test-id=regular-button]').isVisible();
-    const regularTransaction = envelopeRequestParser<TransactionEvent>(await regularTxnPromise);
-
-    const regularInteractionSpans = regularTransaction.spans?.filter(span => span.op === 'ui.interaction.click');
-    expect(regularInteractionSpans?.length).toBeGreaterThanOrEqual(1);
-    expect(regularInteractionSpans![0]!.description).toContain('button');
-    expect(regularInteractionSpans![0]!.description).not.toContain('#sentry-spotlight');
-  },
-);
+import { shouldSkipCdnBundleTest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
+
+// The click handler adds the class before the event timing entry records the target.
+const SPOTLIGHT_BUTTON = 'body > div#sentry-spotlight > button.clicked';
+const REGULAR_BUTTON = 'body > button.clicked';
+
+sentryTest('filters spotlight interaction spans via ignoreSpans', async ({ getLocalTestUrl, page }) => {
+  // spotlightBrowserIntegration is not available in CDN bundles.
+  sentryTest.skip(shouldSkipTracingTest() || shouldSkipCdnBundleTest());
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+  await page.goto(url);
+  await pageloadPromise;
+
+  const spotlightPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'ui.action.click');
+  await page.locator('[data-test-id=spotlight-button]').click();
+  await expect(page.locator('.clicked[data-test-id=spotlight-button]')).toBeVisible();
+  const spotlight = await spotlightPromise;
+  expect(getSpanOp(spotlight)).toBe('ui.action.click');
+
+  const regularPromise = waitForStreamedSpan(
+    page,
+    span => span.is_segment && getSpanOp(span) === 'ui.action.click' && span.span_id !== spotlight.span_id,
+  );
+  const regularInteractionPromise = waitForStreamedSpan(
+    page,
+    span => span.attributes[BROWSER_WEB_VITAL_INP_TARGET]?.value === REGULAR_BUTTON,
+  );
+  await page.locator('[data-test-id=regular-button]').click();
+  await expect(page.locator('.clicked[data-test-id=regular-button]')).toBeVisible();
+  const [regular, interaction] = await Promise.all([regularPromise, regularInteractionPromise]);
+  await page.evaluate(() => (window as any).Sentry.flush());
+
+  expect(getSpanOp(interaction)).toBe('ui.interaction.click');
+  expect(interaction.parent_span_id).toBe(regular.span_id);
+  expect(interaction.trace_id).toBe(regular.trace_id);
+  expect(interaction.attributes[BROWSER_WEB_VITAL_INP_TARGET]?.value).not.toContain('#sentry-spotlight');
+  expect(
+    spans.filter(
+      span =>
+        getSpanOp(span) === 'ui.interaction.click' &&
+        span.attributes[BROWSER_WEB_VITAL_INP_TARGET]?.value === SPOTLIGHT_BUTTON,
+    ),
+  ).toHaveLength(0);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/customTargets/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/customTargets/init.js
index 65cfbab96ee2..b2280b70e307 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/customTargets/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/customTargets/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/defaultTargetsMatch/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/defaultTargetsMatch/init.js
index bb6d4918d1bf..83076460599f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/defaultTargetsMatch/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/defaultTargetsMatch/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/defaultTargetsNoMatch/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/defaultTargetsNoMatch/init.js
index 238d85509b25..d7b0a648a2de 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/defaultTargetsNoMatch/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/tracePropagationTargets/defaultTargetsNoMatch/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/twp-errors-meta/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/twp-errors-meta/init.js
index 17b2b0a13c6b..c026daa1eed9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/twp-errors-meta/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/twp-errors-meta/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: integrations => {
     integrations.push(Sentry.browserTracingIntegration());
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/twp-errors/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/twp-errors/init.js
index 17b2b0a13c6b..c026daa1eed9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/twp-errors/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/twp-errors/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: integrations => {
     integrations.push(Sentry.browserTracingIntegration());

From 061f62c0b8261a3bb6935de70d93f6a5dc77361e Mon Sep 17 00:00:00 2001
From: Martin Sonnberger <martin.sonnberger@sentry.io>
Date: Fri, 9 Oct 2026 13:02:35 +0200
Subject: [PATCH 28/84] test(browser): port requests and web vitals to span
 streaming (#24886)

Exercise request instrumentation, web vitals, interactions, and user
timing with default span streaming. Retain the existing transaction
counterparts for fetch, XHR, resource timing, and TTFB as explicitly
pinned `*-static` suites so the migration preserves coverage of both
lifecycles. Check RTT as a span attribute on pageload and navigation.

Fixes #24143

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../tracing/interactions/disabled/init.js     |   1 -
 .../tracing/interactions/disabled/test.ts     |  18 +-
 .../interactions/navigation-click/init.js     |   1 -
 .../interactions/navigation-click/test.ts     |  63 +--
 .../suites/tracing/interactions/spans/init.js |   2 +-
 .../suites/tracing/interactions/spans/test.ts |  38 +-
 .../metrics/connection-rtt-navigation/init.js |   1 -
 .../metrics/connection-rtt-navigation/test.ts |  45 +-
 .../tracing/metrics/connection-rtt/test.ts    |  66 +--
 .../tracing/metrics/element-timing/init.js    |   1 -
 .../metrics/handlers-lcp/template.html        |   2 +-
 .../tracing/metrics/handlers-lcp/test.ts      |  58 +--
 .../suites/tracing/metrics/init.js            |   1 -
 .../metrics/pageload-browser-spans/test.ts    |  48 +-
 .../assets/image.svg                          |   1 +
 .../assets/script.js                          |   1 +
 .../assets/style.css                          |   4 +
 .../pageload-resource-spans-static}/init.js   |   2 +-
 .../template.html                             |   0
 .../pageload-resource-spans-static/test.ts    | 254 +++++++++
 .../pageload-resource-spans-streamed/test.ts  |  68 ---
 .../pageload-resource-spans}/init.js          |   1 -
 .../metrics/pageload-resource-spans/test.ts   | 490 ++++++++++--------
 .../init.js                                   |   3 +-
 .../metrics/web-vitals-cls-static/subject.js  |   9 +
 .../template.html                             |   1 -
 .../metrics/web-vitals-cls-static/test.ts     |  29 ++
 .../web-vitals-cls-streamed-spans/subject.js  |  17 -
 .../web-vitals-cls-streamed-spans/test.ts     |  79 ---
 .../tracing/metrics/web-vitals-cls/init.js    |   8 +-
 .../tracing/metrics/web-vitals-cls/subject.js |  18 +-
 .../metrics/web-vitals-cls/template.html      |   1 +
 .../tracing/metrics/web-vitals-cls/test.ts    |  97 ++--
 .../init.js                                   |   4 +-
 .../web-vitals-fp-fcp-static/template.html    |   9 +
 .../metrics/web-vitals-fp-fcp-static/test.ts  |  46 ++
 .../tracing/metrics/web-vitals-fp-fcp/test.ts |  63 +--
 .../init.js                                   |  39 ++
 .../subject.js                                |   5 +-
 .../template.html                             |   2 +
 .../test.ts                                   |  48 ++
 .../web-vitals-inp-before-send-span/init.js   |  13 +-
 .../web-vitals-inp-before-send-span/test.ts   |  36 +-
 .../metrics/web-vitals-inp-late/init.js       |   1 -
 .../metrics/web-vitals-inp-late/test.ts       |  85 +--
 .../metrics/web-vitals-inp-navigate/init.js   |   1 -
 .../metrics/web-vitals-inp-navigate/test.ts   | 140 +++--
 .../web-vitals-inp-parametrized-late/init.js  |   1 -
 .../web-vitals-inp-parametrized-late/test.ts  |  85 +--
 .../web-vitals-inp-parametrized/init.js       |   1 -
 .../web-vitals-inp-parametrized/test.ts       |  85 +--
 .../web-vitals-inp-streamed-spans/test.ts     |  87 ----
 .../tracing/metrics/web-vitals-inp/init.js    |  19 +-
 .../tracing/metrics/web-vitals-inp/subject.js |   5 +-
 .../metrics/web-vitals-inp/template.html      |   2 -
 .../tracing/metrics/web-vitals-inp/test.ts    | 266 ++++------
 .../assets/sentry-logo-600x179.png            | Bin
 .../metrics/web-vitals-lcp-static/init.js     |  10 +
 .../template.html                             |   0
 .../metrics/web-vitals-lcp-static/test.ts     |  42 ++
 .../web-vitals-lcp-streamed-spans/init.js     |  11 -
 .../web-vitals-lcp-streamed-spans/test.ts     |  69 ---
 .../init.js                                   |   3 +-
 .../tracing/metrics/web-vitals-lcp/test.ts    |  79 ++-
 .../metrics/web-vitals-ttfb-static/init.js    |  10 +
 .../web-vitals-ttfb-static/template.html      |   9 +
 .../metrics/web-vitals-ttfb-static/test.ts    |  28 +
 .../metrics/web-vitals-ttfb-streamed/test.ts  |  36 --
 .../init.js                                   |   3 +-
 .../tracing/metrics/web-vitals-ttfb/test.ts   |  41 +-
 .../suites/tracing/metrics/web-vitals/test.ts |  48 +-
 .../tracing/request/fetch-data-url/init.js    |   1 -
 .../tracing/request/fetch-data-url/test.ts    |  48 +-
 .../tracing/request/fetch-immediate/init.js   |   1 -
 .../tracing/request/fetch-immediate/test.ts   |  37 +-
 .../tracing/request/fetch-no-tracing/init.js  |   1 -
 .../fetch-propagateTraceparent/init.js        |   1 -
 .../request/fetch-relative-url-static/init.js |  10 +
 .../fetch-relative-url-static/subject.js      |   3 +
 .../request/fetch-relative-url-static/test.ts |  78 +++
 .../fetch-relative-url-streamed/subject.js    |   1 -
 .../fetch-relative-url-streamed/test.ts       |  39 --
 .../request/fetch-relative-url/init.js        |   2 +-
 .../request/fetch-relative-url/test.ts        |  52 +-
 .../{xhr-streamed => fetch-static}/init.js    |   3 +-
 .../subject.js                                |   0
 .../tracing/request/fetch-static/test.ts      |  87 ++++
 .../tracing/request/fetch-streamed/test.ts    |  48 --
 .../fetch-strip-query-and-fragment/init.js    |   1 -
 .../fetch-strip-query-and-fragment/test.ts    | 171 +++---
 .../fetch-trace-header-merging/init.js        |   1 -
 .../init.js                                   |   1 -
 .../request/fetch-tracing-unsampled/init.js   |   1 -
 .../init.js                                   |   1 -
 .../fetch-tracing-without-performance/init.js |   1 -
 .../init.js                                   |   6 +-
 .../subject.js                                |   0
 .../test.ts                                   |   9 +-
 .../init.js                                   |   1 -
 .../fetch-with-custom-sentry-headers/init.js  |   1 -
 .../request/fetch-with-request/init.js        |   1 -
 .../request/{fetch-streamed => fetch}/init.js |   2 +-
 .../suites/tracing/request/fetch/test.ts      |  51 +-
 .../suites/tracing/request/init.js            |   1 -
 .../tracing/request/xhr-data-url/init.js      |   1 -
 .../tracing/request/xhr-data-url/test.ts      |  45 +-
 .../tracing/request/xhr-no-tracing/init.js    |   1 -
 .../request/xhr-propagateTraceparent/init.js  |   1 -
 .../request/xhr-relative-url-static/init.js   |  10 +
 .../subject.js                                |   1 +
 .../request/xhr-relative-url-static/test.ts   |  78 +++
 .../request/xhr-relative-url-streamed/test.ts |  39 --
 .../tracing/request/xhr-relative-url/init.js  |   2 +-
 .../tracing/request/xhr-relative-url/test.ts  |  52 +-
 .../suites/tracing/request/xhr-static/init.js |  12 +
 .../{xhr-streamed => xhr-static}/subject.js   |   0
 .../suites/tracing/request/xhr-static/test.ts |  76 +++
 .../tracing/request/xhr-streamed/test.ts      |  48 --
 .../xhr-strip-query-and-fragment/init.js      |   1 -
 .../xhr-strip-query-and-fragment/test.ts      | 161 +++---
 .../init.js                                   |   1 -
 .../request/xhr-tracing-unsampled/init.js     |   1 -
 .../init.js                                   |   1 -
 .../xhr-tracing-without-performance/init.js   |   1 -
 .../init.js                                   |   1 -
 .../suites/tracing/request/xhr/init.js        |  11 +
 .../suites/tracing/request/xhr/test.ts        |  48 +-
 .../tracing/user-timing/disabled/test.ts      |   8 +-
 .../init.js                                   |   1 -
 .../test.ts                                   |  79 +--
 .../pageload-measure-spans/init.js            |   1 -
 .../pageload-measure-spans/test.ts            |  56 +-
 .../suites/tracing/user-timing/spans/test.ts  |  11 +-
 .../utils/helpers.ts                          |  49 +-
 .../nuxt-4-static/tests/middleware.test.ts    |   8 +-
 135 files changed, 2427 insertions(+), 1899 deletions(-)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/image.svg
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/script.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/style.css
 rename dev-packages/browser-integration-tests/suites/tracing/{request/fetch-relative-url-streamed => metrics/pageload-resource-spans-static}/init.js (87%)
 rename dev-packages/browser-integration-tests/suites/tracing/metrics/{pageload-resource-spans-streamed => pageload-resource-spans-static}/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/{request/xhr-relative-url-streamed => metrics/pageload-resource-spans}/init.js (87%)
 rename dev-packages/browser-integration-tests/suites/tracing/metrics/{web-vitals-inp-streamed-spans => web-vitals-cls-static}/init.js (72%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/subject.js
 rename dev-packages/browser-integration-tests/suites/tracing/metrics/{web-vitals-cls-streamed-spans => web-vitals-cls-static}/template.html (84%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/subject.js
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/metrics/{pageload-resource-spans-streamed => web-vitals-fp-fcp-static}/init.js (57%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp-static/template.html
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp-static/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/init.js
 rename dev-packages/browser-integration-tests/suites/tracing/metrics/{web-vitals-inp-streamed-spans => web-vitals-inp-before-send-span-static}/subject.js (70%)
 rename dev-packages/browser-integration-tests/suites/tracing/metrics/{web-vitals-inp-streamed-spans => web-vitals-inp-before-send-span-static}/template.html (65%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/metrics/{web-vitals-lcp-streamed-spans => web-vitals-lcp-static}/assets/sentry-logo-600x179.png (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/init.js
 rename dev-packages/browser-integration-tests/suites/tracing/metrics/{web-vitals-lcp-streamed-spans => web-vitals-lcp-static}/template.html (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/init.js
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/metrics/{web-vitals-cls-streamed-spans => web-vitals-lcp}/init.js (65%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/template.html
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/metrics/{web-vitals-ttfb-streamed => web-vitals-ttfb}/init.js (66%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-streamed/subject.js
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/request/{xhr-streamed => fetch-static}/init.js (74%)
 rename dev-packages/browser-integration-tests/suites/tracing/request/{fetch-streamed => fetch-static}/subject.js (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed/test.ts
 rename dev-packages/browser-integration-tests/suites/tracing/request/{fetch-streamed-track-stream-performance => fetch-track-stream-performance}/init.js (62%)
 rename dev-packages/browser-integration-tests/suites/tracing/request/{fetch-streamed-track-stream-performance => fetch-track-stream-performance}/subject.js (100%)
 rename dev-packages/browser-integration-tests/suites/tracing/request/{fetch-streamed-track-stream-performance => fetch-track-stream-performance}/test.ts (85%)
 rename dev-packages/browser-integration-tests/suites/tracing/request/{fetch-streamed => fetch}/init.js (74%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-static/init.js
 rename dev-packages/browser-integration-tests/suites/tracing/request/{xhr-relative-url-streamed => xhr-relative-url-static}/subject.js (80%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-streamed/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-static/init.js
 rename dev-packages/browser-integration-tests/suites/tracing/request/{xhr-streamed => xhr-static}/subject.js (100%)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-static/test.ts
 delete mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr-streamed/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/request/xhr/init.js

diff --git a/dev-packages/browser-integration-tests/suites/tracing/interactions/disabled/init.js b/dev-packages/browser-integration-tests/suites/tracing/interactions/disabled/init.js
index bb6d4918d1bf..83076460599f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/interactions/disabled/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/interactions/disabled/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/interactions/disabled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/interactions/disabled/test.ts
index 5a163c067969..400a19d98011 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/interactions/disabled/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/interactions/disabled/test.ts
@@ -1,19 +1,19 @@
+import { SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event as SentryEvent } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { countEnvelopes, getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('does not capture interaction spans without the integration', async ({ getLocalTestUrl, page }) => {
   sentryTest.skip(shouldSkipTracingTest());
-
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
   const url = await getLocalTestUrl({ testDir: __dirname });
-
   await page.goto(url);
-  await getFirstSentryEnvelopeRequest<SentryEvent>(page);
-
-  const countPromise = countEnvelopes(page, { envelopeType: 'transaction', timeout: 2000 });
-
+  await pageloadPromise;
   await page.locator('[data-test-id=interaction-button]').click();
+  await hidePage(page);
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-  expect(await countPromise).toBe(0);
+  expect(spans.filter(span => span.attributes[SENTRY_ORIGIN]?.value === 'auto.browser.interactions')).toHaveLength(0);
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/interactions/navigation-click/init.js b/dev-packages/browser-integration-tests/suites/tracing/interactions/navigation-click/init.js
index 2c3e9264d882..96386e1d38d5 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/interactions/navigation-click/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/interactions/navigation-click/init.js
@@ -4,7 +4,6 @@ import { interactionsIntegration } from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1,
   integrations: [Sentry.browserTracingIntegration(), interactionsIntegration()],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/interactions/navigation-click/test.ts b/dev-packages/browser-integration-tests/suites/tracing/interactions/navigation-click/test.ts
index 4931aaa4b172..b9913d3a5739 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/interactions/navigation-click/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/interactions/navigation-click/test.ts
@@ -1,39 +1,28 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
-
-sentryTest(
-  'click-triggered navigation should produce a root navigation transaction',
-  async ({ getLocalTestUrl, page }) => {
-    if (shouldSkipTracingTest()) {
-      sentryTest.skip();
-    }
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    await page.goto(url);
-    await waitForTransactionRequest(page); // "pageload" root span
-
-    const interactionRequestPromise = waitForTransactionRequest(
-      page,
-      evt => evt.contexts?.trace?.op === 'ui.action.click',
-    );
-    const navigationRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'navigation');
-
-    await page.locator('[data-test-id=navigate-button]').click();
-
-    const interactionEvent = envelopeRequestParser(await interactionRequestPromise);
-    const navigationEvent = envelopeRequestParser(await navigationRequestPromise);
-
-    // Navigation is root span, not a child span on the interaction
-    expect(interactionEvent.contexts?.trace?.op).toBe('ui.action.click');
-    expect(navigationEvent.contexts?.trace?.op).toBe('navigation');
-
-    expect(interactionEvent.contexts?.trace?.trace_id).not.toEqual(navigationEvent.contexts?.trace?.trace_id);
-
-    // does not contain a child navigation span
-    const interactionSpans = interactionEvent.spans || [];
-    const hasNavigationChild = interactionSpans.some(span => span.op === 'navigation' || span.op === 'http.server');
-    expect(hasNavigationChild).toBeFalsy();
-  },
-);
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
+
+sentryTest('starts a root navigation segment when a click triggers navigation', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
+  await pageloadPromise;
+
+  const interactionPromise = waitForStreamedSpan(
+    page,
+    span => span.is_segment && getSpanOp(span) === 'ui.action.click',
+  );
+  const navigationPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'navigation');
+  await page.locator('[data-test-id=navigate-button]').click();
+  const [interaction, navigation] = await Promise.all([interactionPromise, navigationPromise]);
+  await page.evaluate(() => (window as any).Sentry.flush());
+
+  expect(navigation.is_segment).toBe(true);
+  expect(navigation).not.toHaveProperty('parent_span_id');
+  expect(navigation.trace_id).not.toBe(interaction.trace_id);
+  const children = spans.filter(span => span.parent_span_id === interaction.span_id);
+  expect(children.filter(span => ['navigation', 'http.server'].includes(getSpanOp(span) ?? ''))).toHaveLength(0);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/interactions/spans/init.js b/dev-packages/browser-integration-tests/suites/tracing/interactions/spans/init.js
index af4b7b3e3483..c2d6aa640c21 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/interactions/spans/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/interactions/spans/init.js
@@ -5,6 +5,6 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), interactionsIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration(), interactionsIntegration()],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/interactions/spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/interactions/spans/test.ts
index 0870974ba825..2a83365805f8 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/interactions/spans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/interactions/spans/test.ts
@@ -1,6 +1,12 @@
 import { expect } from '@playwright/test';
 import { SDK_VERSION } from '@sentry/core';
 import {
+  SENTRY_IS_LOCALHOST,
+  CULTURE_CALENDAR,
+  CULTURE_LOCALE,
+  CULTURE_TIMEZONE,
+  URL_FULL,
+  BROWSER_WEB_VITAL_INP_TARGET,
   SENTRY_IDLE_SPAN_FINISH_REASON,
   SENTRY_SEGMENT_ID,
   SENTRY_SEGMENT_NAME,
@@ -17,7 +23,7 @@ import {
 } from '@sentry/conventions/attributes';
 import { sentryTest } from '../../../../utils/fixtures';
 import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan, waitForStreamedSpans } from '../../../../utils/spanUtils';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('captures streamed interaction span tree. @firefox', async ({ browserName, getLocalTestUrl, page }) => {
   const supportedBrowsers = ['chromium', 'firefox'];
@@ -25,8 +31,10 @@ sentryTest('captures streamed interaction span tree. @firefox', async ({ browser
   sentryTest.skip(shouldSkipTracingTest() || !supportedBrowsers.includes(browserName));
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const interactionSpansPromise = waitForStreamedSpans(page, spans =>
-    spans.some(span => getSpanOp(span) === 'ui.action.click'),
+  const spans = collectStreamedSpans(page);
+  const interactionPromise = waitForStreamedSpan(
+    page,
+    span => span.is_segment && getSpanOp(span) === 'ui.action.click',
   );
 
   const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
@@ -39,26 +47,30 @@ sentryTest('captures streamed interaction span tree. @firefox', async ({ browser
   await page.locator('[data-test-id=interaction-button]').click();
   await page.locator('.clicked[data-test-id=interaction-button]').isVisible();
 
-  const interactionSpanTree = await interactionSpansPromise;
-
-  const interactionSegmentSpan = interactionSpanTree.find(span => !!span.is_segment);
+  const interactionSegmentSpan = await interactionPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const interactionSpanTree = spans.filter(
+    span =>
+      span.span_id === interactionSegmentSpan.span_id ||
+      span.attributes[SENTRY_SEGMENT_ID]?.value === interactionSegmentSpan.span_id,
+  );
 
   expect(interactionSegmentSpan).toEqual({
     attributes: {
-      'sentry.is_localhost': { value: false, type: 'boolean' },
+      [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
       [SENTRY_TRACE_LIFECYCLE]: {
         type: 'string',
         value: 'stream',
       },
-      'culture.calendar': {
+      [CULTURE_CALENDAR]: {
         type: 'string',
         value: expect.any(String),
       },
-      'culture.locale': {
+      [CULTURE_LOCALE]: {
         type: 'string',
         value: expect.any(String),
       },
-      'culture.timezone': {
+      [CULTURE_TIMEZONE]: {
         type: 'string',
         value: expect.any(String),
       },
@@ -66,7 +78,7 @@ sentryTest('captures streamed interaction span tree. @firefox', async ({ browser
         type: 'string',
         value: expect.any(String),
       },
-      'url.full': {
+      [URL_FULL]: {
         type: 'string',
         value: expect.any(String),
       },
@@ -130,7 +142,7 @@ sentryTest('captures streamed interaction span tree. @firefox', async ({ browser
   const interactionSpan = interactionSpanTree.find(span => getSpanOp(span) === 'ui.interaction.click');
   expect(interactionSpan).toEqual({
     attributes: {
-      'sentry.is_localhost': { value: false, type: 'boolean' },
+      [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
       [SENTRY_TRACE_LIFECYCLE]: {
         type: 'string',
         value: 'stream',
@@ -167,7 +179,7 @@ sentryTest('captures streamed interaction span tree. @firefox', async ({ browser
         type: 'string',
         value: 'production',
       },
-      'browser.web_vital.inp.target': {
+      [BROWSER_WEB_VITAL_INP_TARGET]: {
         type: 'string',
         value: 'body > button.clicked',
       },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt-navigation/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt-navigation/init.js
index 7ebcfe76faab..3e7a3d67bff0 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt-navigation/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt-navigation/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt-navigation/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt-navigation/test.ts
index c071cf089d71..ef019fa0dc56 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt-navigation/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt-navigation/test.ts
@@ -1,37 +1,24 @@
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
+import {
+  BROWSER_WEB_VITAL_FCP_VALUE,
+  BROWSER_WEB_VITAL_TTFB_VALUE,
+  NETWORK_CONNECTION_RTT,
+} from '@sentry/conventions/attributes';
 
-sentryTest.beforeEach(({ browserName }) => {
-  if (shouldSkipTracingTest() || browserName !== 'chromium') {
-    sentryTest.skip();
-  }
-});
-
-// `connection.rtt` is recorded as a measurement, which is only flushed on the pageload
-// transaction. It must not leak onto navigation transactions.
 sentryTest(
-  'records `connection.rtt` as a measurement on pageload but not on navigation transactions',
-  async ({ getLocalTestUrl, page }) => {
-    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === 'pageload');
+  'records connection RTT on pageload and navigation spans',
+  async ({ getLocalTestUrl, page, browserName }) => {
+    sentryTest.skip(shouldSkipTracingTest() || browserName !== 'chromium');
     const url = await getLocalTestUrl({ testDir: __dirname });
-    await page.goto(url);
-
-    const pageloadRequest = envelopeRequestParser(await pageloadRequestPromise) as Event;
-
-    const navigationRequestPromise = waitForTransactionRequest(
-      page,
-      event => event.contexts?.trace?.op === 'navigation',
-    );
-    await page.goto(`${url}#foo`);
-
-    const navigationRequest = envelopeRequestParser(await navigationRequestPromise) as Event;
-
-    expect(pageloadRequest.contexts?.trace?.op).toBe('pageload');
-    expect(navigationRequest.contexts?.trace?.op).toBe('navigation');
+    const [pageload] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url);
+    const [navigation] = await waitForStreamedSpanAndTraceHeaderOnUrl(page, `${url}#foo`);
 
-    expect(pageloadRequest.measurements?.['connection.rtt']?.value).toBeDefined();
-    expect(navigationRequest.measurements?.['connection.rtt']).toBeUndefined();
+    expect(pageload.attributes[NETWORK_CONNECTION_RTT]).toEqual({ type: 'integer', value: 0 });
+    expect(navigation.attributes[NETWORK_CONNECTION_RTT]).toEqual(pageload.attributes[NETWORK_CONNECTION_RTT]);
+    expect(navigation.attributes[BROWSER_WEB_VITAL_FCP_VALUE]).toBeUndefined();
+    expect(navigation.attributes[BROWSER_WEB_VITAL_TTFB_VALUE]).toBeUndefined();
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt/test.ts
index 6f4b885e71d1..492027a2fead 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/connection-rtt/test.ts
@@ -1,8 +1,9 @@
 import type { Page } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { waitForStreamedSpanAndTraceHeaderOnUrl } from '../../../../utils/spanUtils';
+import { NETWORK_CONNECTION_RTT } from '@sentry/conventions/attributes';
 
 sentryTest.beforeEach(({ browserName }) => {
   if (shouldSkipTracingTest() || browserName !== 'chromium') {
@@ -22,55 +23,42 @@ async function createSessionWithLatency(page: Page, latency: number) {
   return session;
 }
 
-sentryTest('should capture a `connection.rtt` metric. xxx', async ({ getLocalTestUrl, page }) => {
+sentryTest('captures connection RTT without emulation', async ({ getLocalTestUrl, page }) => {
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  const eventData = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url).then(([span]) => span);
 
-  expect(eventData.measurements).toBeDefined();
-  expect(eventData.measurements?.['connection.rtt']?.value).toBe(0);
+  expect(eventData.attributes[NETWORK_CONNECTION_RTT]?.value).toBe(0);
 });
 
-sentryTest(
-  'should capture a `connection.rtt` metric with emulated value 200ms on Chromium.',
-  async ({ getLocalTestUrl, page }) => {
-    const session = await createSessionWithLatency(page, 200);
+sentryTest('captures connection RTT with emulated value 200ms on Chromium.', async ({ getLocalTestUrl, page }) => {
+  const session = await createSessionWithLatency(page, 200);
 
-    const url = await getLocalTestUrl({ testDir: __dirname });
-    const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const eventData = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url).then(([span]) => span);
 
-    await session.detach();
+  await session.detach();
 
-    expect(eventData.measurements).toBeDefined();
-    expect(eventData.measurements?.['connection.rtt']?.value).toBe(200);
-  },
-);
+  expect(eventData.attributes[NETWORK_CONNECTION_RTT]?.value).toBe(200);
+});
 
-sentryTest(
-  'should capture a `connection.rtt` metric with emulated value 100ms on Chromium.',
-  async ({ getLocalTestUrl, page }) => {
-    const session = await createSessionWithLatency(page, 100);
+sentryTest('captures connection RTT with emulated value 100ms on Chromium.', async ({ getLocalTestUrl, page }) => {
+  const session = await createSessionWithLatency(page, 100);
 
-    const url = await getLocalTestUrl({ testDir: __dirname });
-    const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const eventData = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url).then(([span]) => span);
 
-    await session.detach();
+  await session.detach();
 
-    expect(eventData.measurements).toBeDefined();
-    expect(eventData.measurements?.['connection.rtt']?.value).toBe(100);
-  },
-);
+  expect(eventData.attributes[NETWORK_CONNECTION_RTT]?.value).toBe(100);
+});
 
-sentryTest(
-  'should capture a `connection.rtt` metric with emulated value 50ms on Chromium.',
-  async ({ getLocalTestUrl, page }) => {
-    const session = await createSessionWithLatency(page, 50);
+sentryTest('captures connection RTT with emulated value 50ms on Chromium.', async ({ getLocalTestUrl, page }) => {
+  const session = await createSessionWithLatency(page, 50);
 
-    const url = await getLocalTestUrl({ testDir: __dirname });
-    const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const eventData = await waitForStreamedSpanAndTraceHeaderOnUrl(page, url).then(([span]) => span);
 
-    await session.detach();
+  await session.detach();
 
-    expect(eventData.measurements).toBeDefined();
-    expect(eventData.measurements?.['connection.rtt']?.value).toBe(50);
-  },
-);
+  expect(eventData.attributes[NETWORK_CONNECTION_RTT]?.value).toBe(50);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/element-timing/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/element-timing/init.js
index 8c8e5e033d47..40253c296af1 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/element-timing/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/element-timing/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   debug: true,
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration(), Sentry.elementTimingIntegration()],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/template.html b/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/template.html
index a8ba98c05ad2..ff4754b3ebb6 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/template.html
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/template.html
@@ -6,6 +6,6 @@
   <body>
     <div id="content"></div>
     <img src="https://sentry-test-site.example/path/to/image.png" />
-    <button type="button">Test button</button>
+    <button type="button" aria-label="Finalize LCP"></button>
   </body>
 </html>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/test.ts
index b40899e37521..be7a0585ffcf 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/test.ts
@@ -1,8 +1,13 @@
+import {
+  BROWSER_WEB_VITAL_LCP_VALUE,
+  BROWSER_WEB_VITAL_LCP_ELEMENT,
+  BROWSER_WEB_VITAL_LCP_SIZE,
+} from '@sentry/conventions/attributes';
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest, waitForLcpCandidate } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 const bundle = process.env.PW_BUNDLE || '';
 
@@ -20,38 +25,21 @@ sentryTest(
 
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const [eventData] = await Promise.all([
-      getFirstSentryEnvelopeRequest<Event>(page),
-      page.goto(url),
-      page.locator('button').click(),
-    ]);
-
-    expect(eventData.measurements).toBeDefined();
-    expect(eventData.measurements?.lcp?.value).toBeDefined();
-
-    // This should be body > img, but it can be flakey as sometimes it will report
-    // the button as LCP.
-    expect(eventData.contexts?.trace?.data?.['lcp.element'].startsWith('body >')).toBe(true);
-
-    // Working around flakiness
-    // Only testing this when the LCP element is an image, not a button
-    if (eventData.contexts?.trace?.data?.['lcp.element'] === 'body > img') {
-      expect(eventData.contexts?.trace?.data?.['lcp.size']).toBe(107400);
-
-      const lcp = await (await page.waitForFunction('window._LCP')).jsonValue();
-      const lcp2 = await (await page.waitForFunction('window._LCP2')).jsonValue();
-      const lcp3 = await page.evaluate('window._LCP3');
-
-      expect(lcp).toEqual(107400);
-      expect(lcp2).toEqual(107400);
-      // this has not been triggered yet
-      expect(lcp3).toEqual(undefined);
-
-      // Adding a handler after LCP is completed still triggers the handler
-      await page.evaluate('window.ADD_HANDLER()');
-      const lcp3_2 = await (await page.waitForFunction('window._LCP3')).jsonValue();
-
-      expect(lcp3_2).toEqual(107400);
-    }
+    const lcpPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.webvital.lcp');
+    await page.goto(url);
+    await waitForLcpCandidate(page, 'img');
+    await page.locator('button').click();
+    const lcpSpan = await lcpPromise;
+
+    expect(lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_VALUE]?.value).toBeGreaterThan(0);
+    expect(lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_ELEMENT]).toEqual({ type: 'string', value: 'body > img' });
+    expect(lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_SIZE]).toEqual({ type: 'integer', value: 107400 });
+    expect(await page.evaluate('window._LCP')).toBe(107400);
+    expect(await page.evaluate('window._LCP2')).toBe(107400);
+    expect(await page.evaluate('window._LCP3')).toBeUndefined();
+
+    await page.evaluate('window.ADD_HANDLER()');
+    await page.waitForFunction('window._LCP3 === 107400');
+    expect(await page.evaluate('window._LCP3')).toBe(107400);
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/init.js
index bb6d4918d1bf..83076460599f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-browser-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-browser-spans/test.ts
index 5e85698e709d..8be9de6373d1 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-browser-spans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-browser-spans/test.ts
@@ -1,29 +1,31 @@
+import { PAGELOAD, BROWSER, BROWSER_LOAD_EVENT, BROWSER_REQUEST, BROWSER_RESPONSE } from '@sentry/conventions/op';
+import { URL_FULL } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
-
-sentryTest('should add browser-related spans to pageload transaction', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
+sentryTest('adds browser performance spans to the pageload segment', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === PAGELOAD);
   const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
+  const pageload = await pageloadPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const browserSpans = eventData.spans?.filter(({ op }) => op?.startsWith('browser'));
-
-  // Spans `dom_content_loaded_event`, `connect`, `cache` and `dns` are not
-  // always inside `pageload` transaction.
-  expect(browserSpans?.length).toBeGreaterThanOrEqual(4);
-
-  ['load_event', 'request', 'response'].forEach(eventDesc =>
-    expect(browserSpans).toContainEqual(
-      expect.objectContaining({
-        op: `browser.${eventDesc}`,
-        description: page.url(),
-        parent_span_id: eventData.contexts?.trace?.span_id,
-      }),
-    ),
-  );
+  const browserSpans = spans.filter(span => getSpanOp(span)?.startsWith(BROWSER));
+  expect(browserSpans.length).toBeGreaterThanOrEqual(4);
+  [
+    { op: BROWSER_LOAD_EVENT, name: 'Load event' },
+    { op: BROWSER_REQUEST, name: 'Request' },
+    { op: BROWSER_RESPONSE, name: 'Response' },
+  ].forEach(({ op, name }) => {
+    const matches = browserSpans.filter(span => getSpanOp(span) === op);
+    expect(matches).toHaveLength(1);
+    expect(matches[0].name).toBe(name);
+    expect(matches[0].attributes[URL_FULL]).toEqual({ type: 'string', value: page.url() });
+    expect(matches[0].parent_span_id).toBe(pageload.span_id);
+    expect(matches[0].trace_id).toBe(pageload.trace_id);
+  });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/image.svg b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/image.svg
new file mode 100644
index 000000000000..3e8fcacea683
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/image.svg
@@ -0,0 +1 @@
+<svg></svg>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/script.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/script.js
new file mode 100644
index 000000000000..1ebec8919f7f
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/script.js
@@ -0,0 +1 @@
+(() => {})();
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/style.css b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/style.css
new file mode 100644
index 000000000000..3e9fdb9de409
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/assets/style.css
@@ -0,0 +1,4 @@
+p {
+  color: red;
+  text-align: center;
+}
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/init.js
similarity index 87%
rename from dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/init.js
index 5ab240338c8c..bb6d4918d1bf 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/init.js
@@ -3,8 +3,8 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
-  autoSessionTracking: false,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-streamed/template.html b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-streamed/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/test.ts
new file mode 100644
index 000000000000..c15ef574991a
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-static/test.ts
@@ -0,0 +1,254 @@
+import { PAGELOAD, RESOURCE, RESOURCE_SCRIPT, RESOURCE_LINK, RESOURCE_IMG } from '@sentry/conventions/op';
+import {
+  HTTP_REQUEST_SAME_ORIGIN,
+  URL_FULL,
+  HTTP_RESPONSE_BODY_DECODED_SIZE,
+  HTTP_RESPONSE_BODY_SIZE,
+  HTTP_RESPONSE_SIZE,
+  HTTP_REQUEST_CONNECT_START,
+  HTTP_REQUEST_CONNECTION_END,
+  HTTP_REQUEST_DOMAIN_LOOKUP_END,
+  HTTP_REQUEST_DOMAIN_LOOKUP_START,
+  HTTP_REQUEST_FETCH_START,
+  HTTP_REQUEST_REDIRECT_END,
+  HTTP_REQUEST_REDIRECT_START,
+  HTTP_REQUEST_REQUEST_START,
+  HTTP_REQUEST_SECURE_CONNECTION_START,
+  HTTP_REQUEST_WORKER_START,
+  HTTP_REQUEST_RESPONSE_END,
+  HTTP_REQUEST_RESPONSE_START,
+  HTTP_REQUEST_TIME_TO_FIRST_BYTE,
+  NETWORK_PROTOCOL_NAME,
+  NETWORK_PROTOCOL_VERSION,
+  SERVER_ADDRESS,
+  URL_DOMAIN,
+  URL_SCHEME,
+  HTTP_RESPONSE_STATUS_CODE,
+  RESOURCE_RENDER_BLOCKING_STATUS,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import type { Route } from '@playwright/test';
+import { expect } from '@playwright/test';
+import { type Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest('adds resource spans to pageload transaction', async ({ getLocalTestUrl, page, browserName }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const isWebkitRun = browserName === 'webkit';
+
+  // Intercepting asset requests to avoid network-related flakiness and random retries (on Firefox).
+  await page.route('https://sentry-test-site.example/path/to/image.svg', (route: Route) =>
+    route.fulfill({
+      path: `${__dirname}/assets/image.svg`,
+      headers: {
+        'Timing-Allow-Origin': '*',
+        'Content-Type': 'image/svg+xml',
+      },
+    }),
+  );
+  await page.route('https://sentry-test-site.example/path/to/script.js', (route: Route) =>
+    route.fulfill({
+      path: `${__dirname}/assets/script.js`,
+      headers: {
+        'Timing-Allow-Origin': '*',
+        'Content-Type': 'application/javascript',
+      },
+    }),
+  );
+  await page.route('https://sentry-test-site.example/path/to/style.css', (route: Route) =>
+    route.fulfill({
+      path: `${__dirname}/assets/style.css`,
+      headers: {
+        'Timing-Allow-Origin': '*',
+        'Content-Type': 'text/css',
+      },
+    }),
+  );
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const pageloadPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+  await page.goto(url);
+  const eventData = envelopeRequestParser<Event>(await pageloadPromise);
+  const resourceSpans = eventData.spans?.filter(({ op }) => op?.startsWith(RESOURCE));
+
+  const scriptSpans = resourceSpans?.filter(({ op }) => op === RESOURCE_SCRIPT);
+  const linkSpan = resourceSpans?.filter(({ op }) => op === RESOURCE_LINK)[0];
+  const imgSpan = resourceSpans?.filter(({ op }) => op === RESOURCE_IMG)[0];
+
+  const spanId = eventData.contexts?.trace?.span_id;
+  const traceId = eventData.contexts?.trace?.trace_id;
+
+  expect(spanId).toBeDefined();
+  expect(traceId).toBeDefined();
+
+  const hasCdnBundle = (process.env.PW_BUNDLE || '').startsWith('bundle');
+
+  const expectedScripts = ['/init.bundle.js', 'https://sentry-test-site.example/path/to/script.js'];
+  if (hasCdnBundle) {
+    expectedScripts.unshift('/cdn.bundle.js');
+  }
+
+  expect(scriptSpans?.map(({ description }) => description).sort()).toEqual(expectedScripts);
+  expect(scriptSpans?.map(({ parent_span_id }) => parent_span_id)).toEqual(expectedScripts.map(() => spanId));
+
+  // The init bundle script is served from the test origin: its description is origin-relative,
+  // but `url.full` retains the full absolute URL (needed for span description inference).
+  const sameOriginScriptSpan = scriptSpans?.find(({ description }) => description === '/init.bundle.js');
+  expect(sameOriginScriptSpan?.data?.[HTTP_REQUEST_SAME_ORIGIN]).toBe(true);
+  expect(sameOriginScriptSpan?.data?.[URL_FULL]).toMatch(/^https?:\/\/.+\/init\.bundle\.js$/);
+
+  const customScriptSpan = scriptSpans?.find(
+    ({ description }) => description === 'https://sentry-test-site.example/path/to/script.js',
+  );
+
+  expect(imgSpan).toEqual({
+    data: {
+      [HTTP_RESPONSE_BODY_DECODED_SIZE]: expect.any(Number),
+      [HTTP_RESPONSE_BODY_SIZE]: expect.any(Number),
+      [HTTP_RESPONSE_SIZE]: expect.any(Number),
+      [HTTP_REQUEST_CONNECT_START]: expect.any(Number),
+      [HTTP_REQUEST_CONNECTION_END]: expect.any(Number),
+      [HTTP_REQUEST_DOMAIN_LOOKUP_END]: expect.any(Number),
+      [HTTP_REQUEST_DOMAIN_LOOKUP_START]: expect.any(Number),
+      [HTTP_REQUEST_FETCH_START]: expect.any(Number),
+      [HTTP_REQUEST_REDIRECT_END]: expect.any(Number),
+      [HTTP_REQUEST_REDIRECT_START]: expect.any(Number),
+      [HTTP_REQUEST_REQUEST_START]: expect.any(Number),
+      [HTTP_REQUEST_SECURE_CONNECTION_START]: expect.any(Number),
+      [HTTP_REQUEST_WORKER_START]: expect.any(Number),
+      [HTTP_REQUEST_RESPONSE_END]: expect.any(Number),
+      [HTTP_REQUEST_RESPONSE_START]: expect.any(Number),
+      [HTTP_REQUEST_TIME_TO_FIRST_BYTE]: expect.any(Number),
+      [NETWORK_PROTOCOL_NAME]: '',
+      [NETWORK_PROTOCOL_VERSION]: 'unknown',
+      [SENTRY_OP]: RESOURCE_IMG,
+      [SENTRY_ORIGIN]: 'auto.resource.browser.metrics',
+      [SERVER_ADDRESS]: 'sentry-test-site.example',
+      [URL_DOMAIN]: 'sentry-test-site.example',
+      [HTTP_REQUEST_SAME_ORIGIN]: false,
+      [URL_SCHEME]: 'https',
+      [URL_FULL]: 'https://sentry-test-site.example/path/to/image.svg',
+      // WebKit reports `deliveryType` as of Playwright 1.63's build, but still no response status
+      // or render blocking status.
+      'http.response_delivery_type': '',
+      ...(!isWebkitRun && {
+        [HTTP_RESPONSE_STATUS_CODE]: expect.any(Number),
+        [RESOURCE_RENDER_BLOCKING_STATUS]: 'non-blocking',
+      }),
+    },
+    description: 'https://sentry-test-site.example/path/to/image.svg',
+    op: RESOURCE_IMG,
+    origin: 'auto.resource.browser.metrics',
+    status: 'ok',
+    parent_span_id: spanId,
+    span_id: expect.stringMatching(/^[a-f\d]{16}$/),
+    start_timestamp: expect.any(Number),
+    timestamp: expect.any(Number),
+    trace_id: traceId,
+  });
+
+  // range check: TTFB is reasonably <10 seconds, which is really a check that we report it in
+  // seconds rather than milliseconds. WebKit resolves these intercepted routes without measurable
+  // delay, so only the other engines are held to a non-zero value.
+  const imgSpanTtfb = imgSpan?.data[HTTP_REQUEST_TIME_TO_FIRST_BYTE];
+  expect(imgSpanTtfb).toBeGreaterThan(isWebkitRun ? -1 : 0);
+  expect(imgSpanTtfb).toBeLessThan(10);
+
+  expect(linkSpan).toEqual({
+    data: {
+      [HTTP_RESPONSE_BODY_DECODED_SIZE]: expect.any(Number),
+      [HTTP_RESPONSE_BODY_SIZE]: expect.any(Number),
+      [HTTP_RESPONSE_SIZE]: expect.any(Number),
+      [HTTP_REQUEST_CONNECT_START]: expect.any(Number),
+      [HTTP_REQUEST_CONNECTION_END]: expect.any(Number),
+      [HTTP_REQUEST_DOMAIN_LOOKUP_END]: expect.any(Number),
+      [HTTP_REQUEST_DOMAIN_LOOKUP_START]: expect.any(Number),
+      [HTTP_REQUEST_FETCH_START]: expect.any(Number),
+      [HTTP_REQUEST_REDIRECT_END]: expect.any(Number),
+      [HTTP_REQUEST_REDIRECT_START]: expect.any(Number),
+      [HTTP_REQUEST_REQUEST_START]: expect.any(Number),
+      [HTTP_REQUEST_SECURE_CONNECTION_START]: expect.any(Number),
+      [HTTP_REQUEST_WORKER_START]: expect.any(Number),
+      [HTTP_REQUEST_RESPONSE_END]: expect.any(Number),
+      [HTTP_REQUEST_RESPONSE_START]: expect.any(Number),
+      [HTTP_REQUEST_TIME_TO_FIRST_BYTE]: expect.any(Number),
+      [NETWORK_PROTOCOL_NAME]: '',
+      [NETWORK_PROTOCOL_VERSION]: 'unknown',
+      [SENTRY_OP]: RESOURCE_LINK,
+      [SENTRY_ORIGIN]: 'auto.resource.browser.metrics',
+      [SERVER_ADDRESS]: 'sentry-test-site.example',
+      [URL_DOMAIN]: 'sentry-test-site.example',
+      [HTTP_REQUEST_SAME_ORIGIN]: false,
+      [URL_SCHEME]: 'https',
+      [URL_FULL]: 'https://sentry-test-site.example/path/to/style.css',
+      // WebKit reports `deliveryType` as of Playwright 1.63's build, but still no response status
+      // or render blocking status.
+      'http.response_delivery_type': '',
+      ...(!isWebkitRun && {
+        [HTTP_RESPONSE_STATUS_CODE]: expect.any(Number),
+        [RESOURCE_RENDER_BLOCKING_STATUS]: 'non-blocking',
+      }),
+    },
+    description: 'https://sentry-test-site.example/path/to/style.css',
+    op: RESOURCE_LINK,
+    origin: 'auto.resource.browser.metrics',
+    status: 'ok',
+    parent_span_id: spanId,
+    span_id: expect.stringMatching(/^[a-f\d]{16}$/),
+    start_timestamp: expect.any(Number),
+    timestamp: expect.any(Number),
+    trace_id: traceId,
+  });
+
+  expect(customScriptSpan).toEqual({
+    data: {
+      [HTTP_RESPONSE_BODY_DECODED_SIZE]: expect.any(Number),
+      [HTTP_RESPONSE_BODY_SIZE]: expect.any(Number),
+      [HTTP_RESPONSE_SIZE]: expect.any(Number),
+      [HTTP_REQUEST_CONNECTION_END]: expect.any(Number),
+      [HTTP_REQUEST_CONNECT_START]: expect.any(Number),
+      [HTTP_REQUEST_DOMAIN_LOOKUP_END]: expect.any(Number),
+      [HTTP_REQUEST_DOMAIN_LOOKUP_START]: expect.any(Number),
+      [HTTP_REQUEST_FETCH_START]: expect.any(Number),
+      [HTTP_REQUEST_REDIRECT_END]: expect.any(Number),
+      [HTTP_REQUEST_REDIRECT_START]: expect.any(Number),
+      [HTTP_REQUEST_REQUEST_START]: expect.any(Number),
+      [HTTP_REQUEST_SECURE_CONNECTION_START]: expect.any(Number),
+      [HTTP_REQUEST_WORKER_START]: expect.any(Number),
+      [HTTP_REQUEST_RESPONSE_END]: expect.any(Number),
+      [HTTP_REQUEST_RESPONSE_START]: expect.any(Number),
+      [HTTP_REQUEST_TIME_TO_FIRST_BYTE]: expect.any(Number),
+      [NETWORK_PROTOCOL_NAME]: '',
+      [NETWORK_PROTOCOL_VERSION]: 'unknown',
+      [SENTRY_OP]: RESOURCE_SCRIPT,
+      [SENTRY_ORIGIN]: 'auto.resource.browser.metrics',
+      [SERVER_ADDRESS]: 'sentry-test-site.example',
+      [URL_DOMAIN]: 'sentry-test-site.example',
+      [HTTP_REQUEST_SAME_ORIGIN]: false,
+      [URL_SCHEME]: 'https',
+      [URL_FULL]: 'https://sentry-test-site.example/path/to/script.js',
+      // WebKit reports `deliveryType` as of Playwright 1.63's build, but still no response status
+      // or render blocking status.
+      'http.response_delivery_type': '',
+      ...(!isWebkitRun && {
+        [HTTP_RESPONSE_STATUS_CODE]: expect.any(Number),
+        [RESOURCE_RENDER_BLOCKING_STATUS]: 'non-blocking',
+      }),
+    },
+    description: 'https://sentry-test-site.example/path/to/script.js',
+    op: RESOURCE_SCRIPT,
+    origin: 'auto.resource.browser.metrics',
+    status: 'ok',
+    parent_span_id: spanId,
+    span_id: expect.stringMatching(/^[a-f\d]{16}$/),
+    start_timestamp: expect.any(Number),
+    timestamp: expect.any(Number),
+    trace_id: traceId,
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-streamed/test.ts
deleted file mode 100644
index a0a1e863137c..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-streamed/test.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import type { Route } from '@playwright/test';
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, getSpansFromEnvelope, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
-
-const assetsDir = `${__dirname}/../pageload-resource-spans/assets`;
-
-sentryTest('names streamed resource spans after the resource domain', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  // Intercepting asset requests to avoid network-related flakiness and random retries (on Firefox).
-  await page.route('https://sentry-test-site.example/path/to/image.svg', (route: Route) =>
-    route.fulfill({
-      path: `${assetsDir}/image.svg`,
-      headers: {
-        'Timing-Allow-Origin': '*',
-        'Content-Type': 'image/svg+xml',
-      },
-    }),
-  );
-  await page.route('https://sentry-test-site.example/path/to/script.js', (route: Route) =>
-    route.fulfill({
-      path: `${assetsDir}/script.js`,
-      headers: {
-        'Timing-Allow-Origin': '*',
-        'Content-Type': 'application/javascript',
-      },
-    }),
-  );
-  await page.route('https://sentry-test-site.example/path/to/style.css', (route: Route) =>
-    route.fulfill({
-      path: `${assetsDir}/style.css`,
-      headers: {
-        'Timing-Allow-Origin': '*',
-        'Content-Type': 'text/css',
-      },
-    }),
-  );
-
-  const spanEnvelopePromise = waitForStreamedSpanEnvelope(
-    page,
-    env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'resource.img'),
-  );
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  await page.goto(url);
-
-  const spans = getSpansFromEnvelope(await spanEnvelopePromise);
-
-  const imgSpan = spans.find(s => getSpanOp(s) === 'resource.img');
-  const linkSpan = spans.find(s => getSpanOp(s) === 'resource.link');
-
-  expect(imgSpan?.name).toBe('sentry-test-site.example');
-  expect(imgSpan?.attributes['url.domain']).toEqual({ type: 'string', value: 'sentry-test-site.example' });
-  expect(imgSpan?.attributes['url.full']).toEqual({
-    type: 'string',
-    value: 'https://sentry-test-site.example/path/to/image.svg',
-  });
-
-  expect(linkSpan?.name).toBe('sentry-test-site.example');
-
-  // Same-origin resources used to be named by their origin-relative path, they now carry the test host.
-  const sameOriginScriptSpan = spans.find(
-    s => getSpanOp(s) === 'resource.script' && s.name !== 'sentry-test-site.example',
-  );
-  expect(sameOriginScriptSpan?.name).toBe('sentry-test.io');
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans/init.js
similarity index 87%
rename from dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans/init.js
index 5ab240338c8c..83076460599f 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans/init.js
@@ -6,5 +6,4 @@ Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
-  autoSessionTracking: false,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans/test.ts
index 276234385fae..f9b35fa67c6a 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans/test.ts
@@ -1,223 +1,291 @@
-import { SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import {
+  URL_DOMAIN,
+  URL_FULL,
+  HTTP_REQUEST_SAME_ORIGIN,
+  HTTP_RESPONSE_BODY_DECODED_SIZE,
+  HTTP_RESPONSE_BODY_SIZE,
+  HTTP_RESPONSE_SIZE,
+  HTTP_REQUEST_CONNECT_START,
+  HTTP_REQUEST_CONNECTION_END,
+  HTTP_REQUEST_DOMAIN_LOOKUP_END,
+  HTTP_REQUEST_DOMAIN_LOOKUP_START,
+  HTTP_REQUEST_FETCH_START,
+  HTTP_REQUEST_REDIRECT_END,
+  HTTP_REQUEST_REDIRECT_START,
+  HTTP_REQUEST_REQUEST_START,
+  HTTP_REQUEST_SECURE_CONNECTION_START,
+  HTTP_REQUEST_WORKER_START,
+  HTTP_REQUEST_RESPONSE_END,
+  HTTP_REQUEST_RESPONSE_START,
+  HTTP_REQUEST_TIME_TO_FIRST_BYTE,
+  NETWORK_PROTOCOL_NAME,
+  NETWORK_PROTOCOL_VERSION,
+  SERVER_ADDRESS,
+  URL_SCHEME,
+  HTTP_RESPONSE_STATUS_CODE,
+  RESOURCE_RENDER_BLOCKING_STATUS,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import { type Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest('adds resource spans to pageload transaction', async ({ getLocalTestUrl, page, browserName }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+const assetsDir = `${__dirname}/assets`;
 
-  const isWebkitRun = browserName === 'webkit';
+sentryTest(
+  'names streamed resource spans after the resource domain',
+  async ({ getLocalTestUrl, page, browserName }) => {
+    sentryTest.skip(shouldSkipTracingTest());
 
-  // Intercepting asset requests to avoid network-related flakiness and random retries (on Firefox).
-  await page.route('https://sentry-test-site.example/path/to/image.svg', (route: Route) =>
-    route.fulfill({
-      path: `${__dirname}/assets/image.svg`,
-      headers: {
-        'Timing-Allow-Origin': '*',
-        'Content-Type': 'image/svg+xml',
-      },
-    }),
-  );
-  await page.route('https://sentry-test-site.example/path/to/script.js', (route: Route) =>
-    route.fulfill({
-      path: `${__dirname}/assets/script.js`,
-      headers: {
-        'Timing-Allow-Origin': '*',
-        'Content-Type': 'application/javascript',
-      },
-    }),
-  );
-  await page.route('https://sentry-test-site.example/path/to/style.css', (route: Route) =>
-    route.fulfill({
-      path: `${__dirname}/assets/style.css`,
-      headers: {
-        'Timing-Allow-Origin': '*',
-        'Content-Type': 'text/css',
-      },
-    }),
-  );
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const resourceSpans = eventData.spans?.filter(({ op }) => op?.startsWith('resource'));
-
-  const scriptSpans = resourceSpans?.filter(({ op }) => op === 'resource.script');
-  const linkSpan = resourceSpans?.filter(({ op }) => op === 'resource.link')[0];
-  const imgSpan = resourceSpans?.filter(({ op }) => op === 'resource.img')[0];
-
-  const spanId = eventData.contexts?.trace?.span_id;
-  const traceId = eventData.contexts?.trace?.trace_id;
-
-  expect(spanId).toBeDefined();
-  expect(traceId).toBeDefined();
-
-  const hasCdnBundle = (process.env.PW_BUNDLE || '').startsWith('bundle');
-
-  const expectedScripts = ['/init.bundle.js', 'https://sentry-test-site.example/path/to/script.js'];
-  if (hasCdnBundle) {
-    expectedScripts.unshift('/cdn.bundle.js');
-  }
-
-  expect(scriptSpans?.map(({ description }) => description).sort()).toEqual(expectedScripts);
-  expect(scriptSpans?.map(({ parent_span_id }) => parent_span_id)).toEqual(expectedScripts.map(() => spanId));
+    // Intercepting asset requests to avoid network-related flakiness and random retries (on Firefox).
+    await page.route('https://sentry-test-site.example/path/to/image.svg', (route: Route) =>
+      route.fulfill({
+        path: `${assetsDir}/image.svg`,
+        headers: {
+          'Timing-Allow-Origin': '*',
+          'Content-Type': 'image/svg+xml',
+        },
+      }),
+    );
+    await page.route('https://sentry-test-site.example/path/to/script.js', (route: Route) =>
+      route.fulfill({
+        path: `${assetsDir}/script.js`,
+        headers: {
+          'Timing-Allow-Origin': '*',
+          'Content-Type': 'application/javascript',
+        },
+      }),
+    );
+    await page.route('https://sentry-test-site.example/path/to/style.css', (route: Route) =>
+      route.fulfill({
+        path: `${assetsDir}/style.css`,
+        headers: {
+          'Timing-Allow-Origin': '*',
+          'Content-Type': 'text/css',
+        },
+      }),
+    );
 
-  // The init bundle script is served from the test origin: its description is origin-relative,
-  // but `url.full` retains the full absolute URL (needed for span description inference).
-  const sameOriginScriptSpan = scriptSpans?.find(({ description }) => description === '/init.bundle.js');
-  expect(sameOriginScriptSpan?.data?.['http.request.same_origin']).toBe(true);
-  expect(sameOriginScriptSpan?.data?.['url.full']).toMatch(/^https?:\/\/.+\/init\.bundle\.js$/);
+    const spans = collectStreamedSpans(page);
+    const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    await page.goto(url);
+    const pageload = await pageloadPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const externalResources = spans.filter(span => span.attributes[URL_DOMAIN]?.value === 'sentry-test-site.example');
+    expect(externalResources).toHaveLength(3);
+    externalResources.forEach(span => {
+      expect(span.parent_span_id).toBe(pageload.span_id);
+      expect(span.trace_id).toBe(pageload.trace_id);
+    });
 
-  const customScriptSpan = scriptSpans?.find(
-    ({ description }) => description === 'https://sentry-test-site.example/path/to/script.js',
-  );
+    const isWebkitRun = browserName === 'webkit';
+    const resourceSpans = spans.filter(span => getSpanOp(span)?.startsWith('resource'));
+    const scriptSpans = resourceSpans.filter(span => getSpanOp(span) === 'resource.script');
+    const imgSpan = resourceSpans.find(span => getSpanOp(span) === 'resource.img');
+    const linkSpan = resourceSpans.find(span => getSpanOp(span) === 'resource.link');
+    const customScriptSpan = scriptSpans.find(
+      span => span.attributes[URL_DOMAIN]?.value === 'sentry-test-site.example',
+    );
+    const sameOriginScriptSpan = scriptSpans.find(
+      span => span.attributes[URL_FULL]?.value === new URL('init.bundle.js', url).href,
+    );
+    const spanId = pageload.span_id;
+    const traceId = pageload.trace_id;
+    const expectedScripts = [new URL('init.bundle.js', url).href, 'https://sentry-test-site.example/path/to/script.js'];
+    if ((process.env.PW_BUNDLE || '').startsWith('bundle')) {
+      expectedScripts.push(new URL('cdn.bundle.js', url).href);
+    }
+    expect(scriptSpans.map(span => span.attributes[URL_FULL]?.value).sort()).toEqual(expectedScripts.sort());
+    expect(scriptSpans.map(span => span.parent_span_id)).toEqual(expectedScripts.map(() => spanId));
+    expect(sameOriginScriptSpan?.name).toBe('sentry-test.io');
+    expect(sameOriginScriptSpan?.attributes[HTTP_REQUEST_SAME_ORIGIN]).toEqual({ type: 'boolean', value: true });
 
-  expect(imgSpan).toEqual({
-    data: {
-      'http.response.body.decoded_size': expect.any(Number),
-      'http.response.body.size': expect.any(Number),
-      'http.response.size': expect.any(Number),
-      'http.request.connect_start': expect.any(Number),
-      'http.request.connection_end': expect.any(Number),
-      'http.request.domain_lookup_end': expect.any(Number),
-      'http.request.domain_lookup_start': expect.any(Number),
-      'http.request.fetch_start': expect.any(Number),
-      'http.request.redirect_end': expect.any(Number),
-      'http.request.redirect_start': expect.any(Number),
-      'http.request.request_start': expect.any(Number),
-      'http.request.secure_connection_start': expect.any(Number),
-      'http.request.worker_start': expect.any(Number),
-      'http.request.response_end': expect.any(Number),
-      'http.request.response_start': expect.any(Number),
-      'http.request.time_to_first_byte': expect.any(Number),
-      'network.protocol.name': '',
-      'network.protocol.version': 'unknown',
-      [SENTRY_OP]: 'resource.img',
-      [SENTRY_ORIGIN]: 'auto.resource.browser.metrics',
-      'server.address': 'sentry-test-site.example',
-      'url.domain': 'sentry-test-site.example',
-      'http.request.same_origin': false,
-      'url.scheme': 'https',
-      'url.full': 'https://sentry-test-site.example/path/to/image.svg',
-      // WebKit reports `deliveryType` as of Playwright 1.63's build, but still no response status
-      // or render blocking status.
-      'http.response_delivery_type': '',
-      ...(!isWebkitRun && {
-        'http.response.status_code': expect.any(Number),
-        'resource.render_blocking_status': 'non-blocking',
-      }),
-    },
-    description: 'https://sentry-test-site.example/path/to/image.svg',
-    op: 'resource.img',
-    origin: 'auto.resource.browser.metrics',
-    status: 'ok',
-    parent_span_id: spanId,
-    span_id: expect.stringMatching(/^[a-f\d]{16}$/),
-    start_timestamp: expect.any(Number),
-    timestamp: expect.any(Number),
-    trace_id: traceId,
-  });
+    expect(imgSpan).toMatchObject({
+      attributes: {
+        [HTTP_RESPONSE_BODY_DECODED_SIZE]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_RESPONSE_BODY_SIZE]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_RESPONSE_SIZE]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_CONNECT_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_CONNECTION_END]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_DOMAIN_LOOKUP_END]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_REQUEST_DOMAIN_LOOKUP_START]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_REQUEST_FETCH_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_REDIRECT_END]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_REDIRECT_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_REQUEST_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_SECURE_CONNECTION_START]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_REQUEST_WORKER_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_RESPONSE_END]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_RESPONSE_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_TIME_TO_FIRST_BYTE]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [NETWORK_PROTOCOL_NAME]: { type: 'string', value: '' },
+        [NETWORK_PROTOCOL_VERSION]: { type: 'string', value: 'unknown' },
+        [SENTRY_OP]: { type: 'string', value: 'resource.img' },
+        [SENTRY_ORIGIN]: { type: 'string', value: 'auto.resource.browser.metrics' },
+        [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
+        [URL_DOMAIN]: { type: 'string', value: 'sentry-test-site.example' },
+        [HTTP_REQUEST_SAME_ORIGIN]: { type: 'boolean', value: false },
+        [URL_SCHEME]: { type: 'string', value: 'https' },
+        [URL_FULL]: { type: 'string', value: 'https://sentry-test-site.example/path/to/image.svg' },
+        // WebKit reports `deliveryType` as of Playwright 1.63's build, but still no response status
+        // or render blocking status.
+        'http.response_delivery_type': { type: 'string', value: '' },
+        ...(!isWebkitRun && {
+          [HTTP_RESPONSE_STATUS_CODE]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+          [RESOURCE_RENDER_BLOCKING_STATUS]: { type: 'string', value: 'non-blocking' },
+        }),
+      },
+      name: 'sentry-test-site.example',
+      status: 'ok',
+      parent_span_id: spanId,
+      span_id: expect.stringMatching(/^[a-f\d]{16}$/),
+      start_timestamp: expect.any(Number),
+      end_timestamp: expect.any(Number),
+      trace_id: traceId,
+    });
 
-  // range check: TTFB is reasonably <10 seconds, which is really a check that we report it in
-  // seconds rather than milliseconds. WebKit resolves these intercepted routes without measurable
-  // delay, so only the other engines are held to a non-zero value.
-  const imgSpanTtfb = imgSpan?.data['http.request.time_to_first_byte'];
-  expect(imgSpanTtfb).toBeGreaterThan(isWebkitRun ? -1 : 0);
-  expect(imgSpanTtfb).toBeLessThan(10);
+    // range check: TTFB is reasonably <10 seconds, which is really a check that we report it in
+    // seconds rather than milliseconds. WebKit resolves these intercepted routes without measurable
+    // delay, so only the other engines are held to a non-zero value.
+    const imgSpanTtfb = imgSpan?.attributes[HTTP_REQUEST_TIME_TO_FIRST_BYTE]?.value;
+    expect(imgSpanTtfb).toBeGreaterThan(isWebkitRun ? -1 : 0);
+    expect(imgSpanTtfb).toBeLessThan(10);
 
-  expect(linkSpan).toEqual({
-    data: {
-      'http.response.body.decoded_size': expect.any(Number),
-      'http.response.body.size': expect.any(Number),
-      'http.response.size': expect.any(Number),
-      'http.request.connect_start': expect.any(Number),
-      'http.request.connection_end': expect.any(Number),
-      'http.request.domain_lookup_end': expect.any(Number),
-      'http.request.domain_lookup_start': expect.any(Number),
-      'http.request.fetch_start': expect.any(Number),
-      'http.request.redirect_end': expect.any(Number),
-      'http.request.redirect_start': expect.any(Number),
-      'http.request.request_start': expect.any(Number),
-      'http.request.secure_connection_start': expect.any(Number),
-      'http.request.worker_start': expect.any(Number),
-      'http.request.response_end': expect.any(Number),
-      'http.request.response_start': expect.any(Number),
-      'http.request.time_to_first_byte': expect.any(Number),
-      'network.protocol.name': '',
-      'network.protocol.version': 'unknown',
-      [SENTRY_OP]: 'resource.link',
-      [SENTRY_ORIGIN]: 'auto.resource.browser.metrics',
-      'server.address': 'sentry-test-site.example',
-      'url.domain': 'sentry-test-site.example',
-      'http.request.same_origin': false,
-      'url.scheme': 'https',
-      'url.full': 'https://sentry-test-site.example/path/to/style.css',
-      // WebKit reports `deliveryType` as of Playwright 1.63's build, but still no response status
-      // or render blocking status.
-      'http.response_delivery_type': '',
-      ...(!isWebkitRun && {
-        'http.response.status_code': expect.any(Number),
-        'resource.render_blocking_status': 'non-blocking',
-      }),
-    },
-    description: 'https://sentry-test-site.example/path/to/style.css',
-    op: 'resource.link',
-    origin: 'auto.resource.browser.metrics',
-    status: 'ok',
-    parent_span_id: spanId,
-    span_id: expect.stringMatching(/^[a-f\d]{16}$/),
-    start_timestamp: expect.any(Number),
-    timestamp: expect.any(Number),
-    trace_id: traceId,
-  });
+    expect(linkSpan).toMatchObject({
+      attributes: {
+        [HTTP_RESPONSE_BODY_DECODED_SIZE]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_RESPONSE_BODY_SIZE]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_RESPONSE_SIZE]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_CONNECT_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_CONNECTION_END]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_DOMAIN_LOOKUP_END]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_REQUEST_DOMAIN_LOOKUP_START]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_REQUEST_FETCH_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_REDIRECT_END]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_REDIRECT_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_REQUEST_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_SECURE_CONNECTION_START]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_REQUEST_WORKER_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_RESPONSE_END]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_RESPONSE_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_TIME_TO_FIRST_BYTE]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [NETWORK_PROTOCOL_NAME]: { type: 'string', value: '' },
+        [NETWORK_PROTOCOL_VERSION]: { type: 'string', value: 'unknown' },
+        [SENTRY_OP]: { type: 'string', value: 'resource.link' },
+        [SENTRY_ORIGIN]: { type: 'string', value: 'auto.resource.browser.metrics' },
+        [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
+        [URL_DOMAIN]: { type: 'string', value: 'sentry-test-site.example' },
+        [HTTP_REQUEST_SAME_ORIGIN]: { type: 'boolean', value: false },
+        [URL_SCHEME]: { type: 'string', value: 'https' },
+        [URL_FULL]: { type: 'string', value: 'https://sentry-test-site.example/path/to/style.css' },
+        // WebKit reports `deliveryType` as of Playwright 1.63's build, but still no response status
+        // or render blocking status.
+        'http.response_delivery_type': { type: 'string', value: '' },
+        ...(!isWebkitRun && {
+          [HTTP_RESPONSE_STATUS_CODE]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+          [RESOURCE_RENDER_BLOCKING_STATUS]: { type: 'string', value: 'non-blocking' },
+        }),
+      },
+      name: 'sentry-test-site.example',
+      status: 'ok',
+      parent_span_id: spanId,
+      span_id: expect.stringMatching(/^[a-f\d]{16}$/),
+      start_timestamp: expect.any(Number),
+      end_timestamp: expect.any(Number),
+      trace_id: traceId,
+    });
 
-  expect(customScriptSpan).toEqual({
-    data: {
-      'http.response.body.decoded_size': expect.any(Number),
-      'http.response.body.size': expect.any(Number),
-      'http.response.size': expect.any(Number),
-      'http.request.connection_end': expect.any(Number),
-      'http.request.connect_start': expect.any(Number),
-      'http.request.domain_lookup_end': expect.any(Number),
-      'http.request.domain_lookup_start': expect.any(Number),
-      'http.request.fetch_start': expect.any(Number),
-      'http.request.redirect_end': expect.any(Number),
-      'http.request.redirect_start': expect.any(Number),
-      'http.request.request_start': expect.any(Number),
-      'http.request.secure_connection_start': expect.any(Number),
-      'http.request.worker_start': expect.any(Number),
-      'http.request.response_end': expect.any(Number),
-      'http.request.response_start': expect.any(Number),
-      'http.request.time_to_first_byte': expect.any(Number),
-      'network.protocol.name': '',
-      'network.protocol.version': 'unknown',
-      'sentry.op': 'resource.script',
-      'sentry.origin': 'auto.resource.browser.metrics',
-      'server.address': 'sentry-test-site.example',
-      'url.domain': 'sentry-test-site.example',
-      'http.request.same_origin': false,
-      'url.scheme': 'https',
-      'url.full': 'https://sentry-test-site.example/path/to/script.js',
-      // WebKit reports `deliveryType` as of Playwright 1.63's build, but still no response status
-      // or render blocking status.
-      'http.response_delivery_type': '',
-      ...(!isWebkitRun && {
-        'http.response.status_code': expect.any(Number),
-        'resource.render_blocking_status': 'non-blocking',
-      }),
-    },
-    description: 'https://sentry-test-site.example/path/to/script.js',
-    op: 'resource.script',
-    origin: 'auto.resource.browser.metrics',
-    status: 'ok',
-    parent_span_id: spanId,
-    span_id: expect.stringMatching(/^[a-f\d]{16}$/),
-    start_timestamp: expect.any(Number),
-    timestamp: expect.any(Number),
-    trace_id: traceId,
-  });
-});
+    expect(customScriptSpan).toMatchObject({
+      attributes: {
+        [HTTP_RESPONSE_BODY_DECODED_SIZE]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_RESPONSE_BODY_SIZE]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_RESPONSE_SIZE]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_CONNECTION_END]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_CONNECT_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_DOMAIN_LOOKUP_END]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_REQUEST_DOMAIN_LOOKUP_START]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_REQUEST_FETCH_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_REDIRECT_END]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_REDIRECT_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_REQUEST_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_SECURE_CONNECTION_START]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [HTTP_REQUEST_WORKER_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_RESPONSE_END]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_RESPONSE_START]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+        [HTTP_REQUEST_TIME_TO_FIRST_BYTE]: {
+          type: expect.stringMatching(/^(integer|double)$/),
+          value: expect.any(Number),
+        },
+        [NETWORK_PROTOCOL_NAME]: { type: 'string', value: '' },
+        [NETWORK_PROTOCOL_VERSION]: { type: 'string', value: 'unknown' },
+        [SENTRY_OP]: { type: 'string', value: 'resource.script' },
+        [SENTRY_ORIGIN]: { type: 'string', value: 'auto.resource.browser.metrics' },
+        [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
+        [URL_DOMAIN]: { type: 'string', value: 'sentry-test-site.example' },
+        [HTTP_REQUEST_SAME_ORIGIN]: { type: 'boolean', value: false },
+        [URL_SCHEME]: { type: 'string', value: 'https' },
+        [URL_FULL]: { type: 'string', value: 'https://sentry-test-site.example/path/to/script.js' },
+        // WebKit reports `deliveryType` as of Playwright 1.63's build, but still no response status
+        // or render blocking status.
+        'http.response_delivery_type': { type: 'string', value: '' },
+        ...(!isWebkitRun && {
+          [HTTP_RESPONSE_STATUS_CODE]: { type: expect.stringMatching(/^(integer|double)$/), value: expect.any(Number) },
+          [RESOURCE_RENDER_BLOCKING_STATUS]: { type: 'string', value: 'non-blocking' },
+        }),
+      },
+      name: 'sentry-test-site.example',
+      status: 'ok',
+      parent_span_id: spanId,
+      span_id: expect.stringMatching(/^[a-f\d]{16}$/),
+      start_timestamp: expect.any(Number),
+      end_timestamp: expect.any(Number),
+      trace_id: traceId,
+    });
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/init.js
similarity index 72%
rename from dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/init.js
index 8be8d8420f85..38429010914d 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/init.js
@@ -1,15 +1,14 @@
 import * as Sentry from '@sentry/browser';
 
 window.Sentry = Sentry;
-window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
       idleTimeout: 5000,
     }),
-    Sentry.spanStreamingIntegration(),
   ],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/subject.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/subject.js
new file mode 100644
index 000000000000..b33aea72d7c9
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/subject.js
@@ -0,0 +1,9 @@
+import { simulateCLS } from '../../../../utils/web-vitals/cls.ts';
+
+// Getting expected CLS parameter from URL hash
+const expectedCLS = Number(location.hash.slice(1));
+
+// CLS lands on the pageload span when it ends on the idle timeout, so nothing has to force the
+// page away to finalize it. Reloading here used to do that, but it raced the envelope: on a fast
+// browser the reload cancelled the in-flight send before it left the page.
+simulateCLS(expectedCLS);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/template.html b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/template.html
similarity index 84%
rename from dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/template.html
index 10e2e22f7d6a..72c22be8e49a 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/template.html
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/template.html
@@ -5,6 +5,5 @@
   </head>
   <body>
     <div id="content"></div>
-    <p>Some content</p>
   </body>
 </html>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/test.ts
new file mode 100644
index 000000000000..c51b0c98687c
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-static/test.ts
@@ -0,0 +1,29 @@
+import { PAGELOAD } from '@sentry/conventions/op';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest.beforeEach(async ({ browserName, page }) => {
+  if (shouldSkipTracingTest() || browserName !== 'chromium') {
+    sentryTest.skip();
+  }
+
+  await page.setViewportSize({ width: 800, height: 1200 });
+});
+
+sentryTest('records CLS as a pageload measurement with its source', async ({ getLocalTestUrl, page }) => {
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const pageloadPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+  await page.goto(`${url}#0.05`);
+  const eventData = envelopeRequestParser<Event>(await pageloadPromise);
+
+  expect(eventData.measurements).toBeDefined();
+  expect(eventData.measurements?.cls?.value).toBeDefined();
+
+  // Flakey value dependent on timings -> we check for a range
+  expect(eventData.measurements?.cls?.value).toBeGreaterThan(0.03);
+  expect(eventData.measurements?.cls?.value).toBeLessThan(0.07);
+
+  expect(eventData.contexts?.trace?.data?.['cls.source.1']).toBe('body > div#content > p#partial');
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/subject.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/subject.js
deleted file mode 100644
index 9742a4a5cc29..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/subject.js
+++ /dev/null
@@ -1,17 +0,0 @@
-import { simulateCLS } from '../../../../utils/web-vitals/cls.ts';
-
-// Simulate Layout shift right at the beginning of the page load, depending on the URL hash
-// don't run if expected CLS is NaN
-const expectedCLS = Number(location.hash.slice(1));
-if (expectedCLS && expectedCLS >= 0) {
-  simulateCLS(expectedCLS).then(() => window.dispatchEvent(new Event('cls-done')));
-}
-
-// Simulate layout shift whenever the trigger-cls event is dispatched
-// Cannot trigger via a button click because expected layout shift after
-// an interaction doesn't contribute to CLS.
-window.addEventListener('trigger-cls', () => {
-  simulateCLS(0.1).then(() => {
-    window.dispatchEvent(new Event('cls-done'));
-  });
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/test.ts
deleted file mode 100644
index 02ce7b981ed9..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/test.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-import type { Page } from '@playwright/test';
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
-
-sentryTest.beforeEach(async ({ browserName, page }) => {
-  if (shouldSkipTracingTest() || browserName !== 'chromium') {
-    sentryTest.skip();
-  }
-
-  await page.setViewportSize({ width: 800, height: 1200 });
-});
-
-function waitForLayoutShift(page: Page): Promise<void> {
-  return page.evaluate(() => {
-    return new Promise(resolve => {
-      window.addEventListener('cls-done', () => resolve());
-    });
-  });
-}
-
-sentryTest('captures CLS as a streamed span with source attributes', async ({ getLocalTestUrl, page }) => {
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const clsSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.webvital.cls');
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-
-  await page.goto(`${url}#0.15`);
-  await waitForLayoutShift(page);
-  await hidePage(page);
-
-  const clsSpan = await clsSpanPromise;
-  const pageloadSpan = await pageloadSpanPromise;
-
-  expect(clsSpan.attributes['sentry.op']).toEqual({ type: 'string', value: 'ui.webvital.cls' });
-  expect(clsSpan.attributes['sentry.origin']).toEqual({ type: 'string', value: 'auto.http.browser.cls' });
-  expect(clsSpan.attributes['sentry.exclusive_time']).toEqual({ type: 'integer', value: 0 });
-  expect(clsSpan.attributes['user_agent.original']?.value).toEqual(expect.stringContaining('Chrome'));
-
-  // Check the CLS span carries the segment name it belongs to
-  expect(clsSpan.attributes['sentry.segment.name']).toEqual({ type: 'string', value: 'Pageload' });
-
-  // Check browser.web_vital.cls.source attributes
-  expect(clsSpan.attributes['browser.web_vital.cls.source.1']?.value).toEqual(
-    expect.stringContaining('body > div#content > p'),
-  );
-
-  // Check pageload span id is present
-  expect(clsSpan.attributes['sentry.pageload.span_id']?.value).toBe(pageloadSpan.span_id);
-
-  // CLS is a point-in-time metric
-  expect(clsSpan.start_timestamp).toEqual(clsSpan.end_timestamp);
-
-  expect(clsSpan.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(clsSpan.trace_id).toMatch(/^[\da-f]{32}$/);
-
-  expect(clsSpan.parent_span_id).toBe(pageloadSpan.span_id);
-  expect(clsSpan.trace_id).toBe(pageloadSpan.trace_id);
-});
-
-sentryTest('CLS streamed span has web vital value attribute', async ({ getLocalTestUrl, page }) => {
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const clsSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.webvital.cls');
-
-  await page.goto(`${url}#0.1`);
-  await waitForLayoutShift(page);
-  await hidePage(page);
-
-  const clsSpan = await clsSpanPromise;
-
-  // The CLS value should be set as a browser.web_vital.cls.value attribute
-  expect(clsSpan.attributes['browser.web_vital.cls.value']?.type).toBe('double');
-  // Flakey value dependent on timings -> we check for a range
-  const clsValue = clsSpan.attributes['browser.web_vital.cls.value']?.value as number;
-  expect(clsValue).toBeGreaterThan(0.05);
-  expect(clsValue).toBeLessThan(0.15);
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/init.js
index 38429010914d..1f0b64911a75 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/init.js
@@ -1,14 +1,10 @@
 import * as Sentry from '@sentry/browser';
 
 window.Sentry = Sentry;
+window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [
-    Sentry.browserTracingIntegration({
-      idleTimeout: 5000,
-    }),
-  ],
+  integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/subject.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/subject.js
index b33aea72d7c9..9742a4a5cc29 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/subject.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/subject.js
@@ -1,9 +1,17 @@
 import { simulateCLS } from '../../../../utils/web-vitals/cls.ts';
 
-// Getting expected CLS parameter from URL hash
+// Simulate Layout shift right at the beginning of the page load, depending on the URL hash
+// don't run if expected CLS is NaN
 const expectedCLS = Number(location.hash.slice(1));
+if (expectedCLS && expectedCLS >= 0) {
+  simulateCLS(expectedCLS).then(() => window.dispatchEvent(new Event('cls-done')));
+}
 
-// CLS lands on the pageload span when it ends on the idle timeout, so nothing has to force the
-// page away to finalize it. Reloading here used to do that, but it raced the envelope: on a fast
-// browser the reload cancelled the in-flight send before it left the page.
-simulateCLS(expectedCLS);
+// Simulate layout shift whenever the trigger-cls event is dispatched
+// Cannot trigger via a button click because expected layout shift after
+// an interaction doesn't contribute to CLS.
+window.addEventListener('trigger-cls', () => {
+  simulateCLS(0.1).then(() => {
+    window.dispatchEvent(new Event('cls-done'));
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/template.html b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/template.html
index 72c22be8e49a..10e2e22f7d6a 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/template.html
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/template.html
@@ -5,5 +5,6 @@
   </head>
   <body>
     <div id="content"></div>
+    <p>Some content</p>
   </body>
 </html>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/test.ts
index f00a2b60f100..22e494e73447 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls/test.ts
@@ -1,7 +1,17 @@
+import {
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_EXCLUSIVE_TIME,
+  USER_AGENT_ORIGINAL,
+  SENTRY_SEGMENT_NAME,
+  SENTRY_PAGELOAD_SPAN_ID,
+  BROWSER_WEB_VITAL_CLS_VALUE,
+} from '@sentry/conventions/attributes';
+import type { Page } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest.beforeEach(async ({ browserName, page }) => {
   if (shouldSkipTracingTest() || browserName !== 'chromium') {
@@ -11,43 +21,70 @@ sentryTest.beforeEach(async ({ browserName, page }) => {
   await page.setViewportSize({ width: 800, height: 1200 });
 });
 
-sentryTest('should capture a "GOOD" CLS vital with its source(s).', async ({ getLocalTestUrl, page }) => {
+function waitForLayoutShift(page: Page): Promise<void> {
+  return page.evaluate(() => {
+    return new Promise(resolve => {
+      window.addEventListener('cls-done', () => resolve());
+    });
+  });
+}
+
+sentryTest('captures CLS as a streamed span with source attributes', async ({ getLocalTestUrl, page }) => {
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#0.05`);
 
-  expect(eventData.measurements).toBeDefined();
-  expect(eventData.measurements?.cls?.value).toBeDefined();
+  const clsSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.webvital.cls');
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
 
-  // Flakey value dependent on timings -> we check for a range
-  expect(eventData.measurements?.cls?.value).toBeGreaterThan(0.03);
-  expect(eventData.measurements?.cls?.value).toBeLessThan(0.07);
+  await page.goto(`${url}#0.15`);
+  await waitForLayoutShift(page);
+  await hidePage(page);
 
-  expect(eventData.contexts?.trace?.data?.['cls.source.1']).toBe('body > div#content > p#partial');
-});
+  const clsSpan = await clsSpanPromise;
+  const pageloadSpan = await pageloadSpanPromise;
 
-sentryTest('should capture a "MEH" CLS vital with its source(s).', async ({ getLocalTestUrl, page }) => {
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#0.21`);
+  expect(clsSpan.attributes[SENTRY_OP]).toEqual({ type: 'string', value: 'ui.webvital.cls' });
+  expect(clsSpan.attributes[SENTRY_ORIGIN]).toEqual({ type: 'string', value: 'auto.http.browser.cls' });
+  expect(clsSpan.attributes[SENTRY_EXCLUSIVE_TIME]).toEqual({ type: 'integer', value: 0 });
+  expect(clsSpan.attributes[USER_AGENT_ORIGINAL]?.value).toEqual(expect.stringContaining('Chrome'));
 
-  expect(eventData.measurements).toBeDefined();
-  expect(eventData.measurements?.cls?.value).toBeDefined();
+  // Check the CLS span carries the segment name it belongs to
+  expect(clsSpan.attributes[SENTRY_SEGMENT_NAME]).toEqual({ type: 'string', value: 'Pageload' });
 
-  // Flakey value dependent on timings -> we check for a range
-  expect(eventData.measurements?.cls?.value).toBeGreaterThan(0.18);
-  expect(eventData.measurements?.cls?.value).toBeLessThan(0.23);
+  // Check browser.web_vital.cls.source attributes
+  expect(clsSpan.attributes['browser.web_vital.cls.source.1']?.value).toEqual(
+    expect.stringContaining('body > div#content > p'),
+  );
 
-  expect(eventData.contexts?.trace?.data?.['cls.source.1']).toBe('body > div#content > p');
-});
+  // Check pageload span id is present
+  expect(clsSpan.attributes[SENTRY_PAGELOAD_SPAN_ID]?.value).toBe(pageloadSpan.span_id);
 
-sentryTest('should capture a "POOR" CLS vital with its source(s).', async ({ getLocalTestUrl, page }) => {
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, `${url}#0.35`);
+  // CLS is a point-in-time metric
+  expect(clsSpan.start_timestamp).toEqual(clsSpan.end_timestamp);
+
+  expect(clsSpan.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(clsSpan.trace_id).toMatch(/^[\da-f]{32}$/);
+
+  expect(clsSpan.parent_span_id).toBe(pageloadSpan.span_id);
+  expect(clsSpan.trace_id).toBe(pageloadSpan.trace_id);
+});
 
-  expect(eventData.measurements).toBeDefined();
-  expect(eventData.measurements?.cls?.value).toBeDefined();
+[
+  { cls: 0.05, min: 0.03, max: 0.07, source: 'body > div#content > p#partial' },
+  { cls: 0.21, min: 0.18, max: 0.23, source: 'body > div#content > p' },
+  { cls: 0.35, min: 0.34, max: 0.36, source: 'body > div#content > p' },
+].forEach(({ cls, min, max, source }) => {
+  sentryTest(`captures CLS ${cls} with its source`, async ({ getLocalTestUrl, page }) => {
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    const clsPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.webvital.cls');
+    await page.goto(`${url}#${cls}`);
+    await waitForLayoutShift(page);
+    await hidePage(page);
+    const span = await clsPromise;
 
-  // Flakey value dependent on timings -> we check for a range
-  expect(eventData.measurements?.cls?.value).toBeGreaterThan(0.34);
-  expect(eventData.measurements?.cls?.value).toBeLessThan(0.36);
-  expect(eventData.contexts?.trace?.data?.['cls.source.1']).toBe('body > div#content > p');
+    expect(span.attributes[BROWSER_WEB_VITAL_CLS_VALUE]?.type).toBe('double');
+    const value = span.attributes[BROWSER_WEB_VITAL_CLS_VALUE]?.value;
+    expect(value).toBeGreaterThan(min);
+    expect(value).toBeLessThan(max);
+    expect(span.attributes['browser.web_vital.cls.source.1']).toEqual({ type: 'string', value: source });
+  });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp-static/init.js
similarity index 57%
rename from dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp-static/init.js
index 4deba4c452dd..bb6d4918d1bf 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/pageload-resource-spans-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp-static/init.js
@@ -3,8 +3,8 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
-  traceLifecycle: 'stream',
+  integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp-static/template.html b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp-static/template.html
new file mode 100644
index 000000000000..b81f11e967e3
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp-static/template.html
@@ -0,0 +1,9 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <div>Rendered</div>
+  </body>
+</html>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp-static/test.ts
new file mode 100644
index 000000000000..6148701b53ba
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp-static/test.ts
@@ -0,0 +1,46 @@
+import { PAGELOAD } from '@sentry/conventions/op';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest('should capture FP vital.', async ({ browserName, getLocalTestUrl, page }) => {
+  // FP is not generated on webkit or firefox
+  if (shouldSkipTracingTest() || browserName !== 'chromium') {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const pageloadPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+  await page.goto(url);
+  const eventData = envelopeRequestParser<Event>(await pageloadPromise);
+
+  expect(eventData.measurements).toBeDefined();
+  expect(eventData.measurements?.fp?.value).toBeDefined();
+
+  const fpSpan = eventData.spans?.filter(({ description }) => description === 'first-paint')[0];
+
+  expect(fpSpan).toBeDefined();
+  expect(fpSpan?.op).toBe('browser.paint');
+  expect(fpSpan?.parent_span_id).toBe(eventData.contexts?.trace?.span_id);
+});
+
+sentryTest('should capture FCP vital.', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const pageloadPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+  await page.goto(url);
+  const eventData = envelopeRequestParser<Event>(await pageloadPromise);
+
+  expect(eventData.measurements).toBeDefined();
+  expect(eventData.measurements?.fcp?.value).toBeDefined();
+
+  const fcpSpan = eventData.spans?.filter(({ description }) => description === 'first-contentful-paint')[0];
+
+  expect(fcpSpan).toBeDefined();
+  expect(fcpSpan?.op).toBe('browser.paint');
+  expect(fcpSpan?.parent_span_id).toBe(eventData.contexts?.trace?.span_id);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp/test.ts
index cd63b699cc06..f3769c45992e 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-fp-fcp/test.ts
@@ -1,41 +1,28 @@
+import { PAGELOAD, BROWSER_PAINT } from '@sentry/conventions/op';
+import { BROWSER_WEB_VITAL_FP_VALUE, BROWSER_WEB_VITAL_FCP_VALUE } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
-
-sentryTest('should capture FP vital.', async ({ browserName, getLocalTestUrl, page }) => {
-  // FP is not generated on webkit or firefox
-  if (shouldSkipTracingTest() || browserName !== 'chromium') {
-    sentryTest.skip();
-  }
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-
-  expect(eventData.measurements).toBeDefined();
-  expect(eventData.measurements?.fp?.value).toBeDefined();
-
-  const fpSpan = eventData.spans?.filter(({ description }) => description === 'first-paint')[0];
-
-  expect(fpSpan).toBeDefined();
-  expect(fpSpan?.op).toBe('browser.paint');
-  expect(fpSpan?.parent_span_id).toBe(eventData.contexts?.trace?.span_id);
-});
-
-sentryTest('should capture FCP vital.', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-
-  expect(eventData.measurements).toBeDefined();
-  expect(eventData.measurements?.fcp?.value).toBeDefined();
-
-  const fcpSpan = eventData.spans?.filter(({ description }) => description === 'first-contentful-paint')[0];
-
-  expect(fcpSpan).toBeDefined();
-  expect(fcpSpan?.op).toBe('browser.paint');
-  expect(fcpSpan?.parent_span_id).toBe(eventData.contexts?.trace?.span_id);
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
+
+[
+  { vital: 'fp', attribute: BROWSER_WEB_VITAL_FP_VALUE, name: 'first-paint', chromiumOnly: true },
+  { vital: 'fcp', attribute: BROWSER_WEB_VITAL_FCP_VALUE, name: 'first-contentful-paint', chromiumOnly: false },
+].forEach(({ vital, attribute, name, chromiumOnly }) => {
+  sentryTest(`captures ${vital.toUpperCase()} and its paint span`, async ({ getLocalTestUrl, page, browserName }) => {
+    sentryTest.skip(shouldSkipTracingTest() || (chromiumOnly && browserName !== 'chromium'));
+    const spans = collectStreamedSpans(page);
+    const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === PAGELOAD);
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    await page.goto(url);
+    const pageload = await pageloadPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
+
+    expect(pageload.attributes[attribute]?.value).toBeGreaterThan(0);
+    const paintSpans = spans.filter(span => span.name === name);
+    expect(paintSpans).toHaveLength(1);
+    expect(getSpanOp(paintSpans[0])).toBe(BROWSER_PAINT);
+    expect(paintSpans[0].parent_span_id).toBe(pageload.span_id);
+    expect(paintSpans[0].trace_id).toBe(pageload.trace_id);
+  });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/init.js
new file mode 100644
index 000000000000..5dd891ccc2f8
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/init.js
@@ -0,0 +1,39 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [
+    Sentry.browserTracingIntegration({
+      idleTimeout: 4000,
+      enableLongTask: false,
+      enableInp: true,
+      instrumentPageLoad: false,
+      instrumentNavigation: false,
+    }),
+  ],
+  tracesSampleRate: 1,
+  // A plain (non-streamed) `beforeSendSpan` operates on the v1 `SpanJSON`. INP is sent as a v2 span,
+  // so this verifies the static callback still runs and its changes are carried into the v2 span.
+  beforeSendSpan: Sentry.withStaticSpan(span => {
+    if (span.op === 'ui.interaction.click') {
+      span.description = 'scrubbed';
+      span.data['custom.attribute'] = 'from-before-send-span';
+    }
+
+    return span;
+  }),
+  debug: true,
+});
+
+const client = Sentry.getClient();
+
+// Force page load transaction name to a testable value
+Sentry.startBrowserTracingPageLoadSpan(client, {
+  name: 'test-url',
+  attributes: {
+    ['sentry.segment.name.source']: 'url',
+  },
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/subject.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/subject.js
similarity index 70%
rename from dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/subject.js
index f4ea1cd46d67..64524952dfa7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/subject.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/subject.js
@@ -3,17 +3,18 @@ const blockUI =
   e => {
     const startTime = Date.now();
 
-    function getElapsed() {
+    function getElasped() {
       const time = Date.now();
       return time - startTime;
     }
 
-    while (getElapsed() < delay) {
+    while (getElasped() < delay) {
       //
     }
 
     e.target.classList.add('clicked');
   };
 
+document.querySelector('[data-test-id=not-so-slow-button]').addEventListener('click', blockUI(300));
 document.querySelector('[data-test-id=slow-button]').addEventListener('click', blockUI(450));
 document.querySelector('[data-test-id=normal-button]').addEventListener('click', blockUI());
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/template.html b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/template.html
similarity index 65%
rename from dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/template.html
index d5f28c7c8847..437426e9ab01 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/template.html
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/template.html
@@ -4,7 +4,9 @@
     <meta charset="utf-8" />
   </head>
   <body>
+    <div>Rendered Before Long Task</div>
     <button data-test-id="slow-button" data-sentry-element="SlowButton">Slow</button>
+    <button data-test-id="not-so-slow-button" data-sentry-element="NotSoSlowButton">Not so slow</button>
     <button data-test-id="normal-button" data-sentry-element="NormalButton">Click Me</button>
   </body>
 </html>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/test.ts
new file mode 100644
index 000000000000..6368c5df996f
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span-static/test.ts
@@ -0,0 +1,48 @@
+import { UI_INTERACTION_CLICK } from '@sentry/conventions/op';
+import { BROWSER_WEB_VITAL_INP_VALUE } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
+import {
+  collectStreamedSpans,
+  getSpanOp,
+  getSpansFromEnvelope,
+  waitForStreamedSpanEnvelope,
+} from '../../../../utils/spanUtils';
+
+sentryTest('runs a static `beforeSendSpan` for the INP span', async ({ browserName, getLocalTestUrl, page }) => {
+  const supportedBrowsers = ['chromium'];
+
+  if (shouldSkipTracingTest() || !supportedBrowsers.includes(browserName)) {
+    sentryTest.skip();
+  }
+
+  const spans = collectStreamedSpans(page);
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const spanEnvelopePromise = waitForStreamedSpanEnvelope(page, env =>
+    getSpansFromEnvelope(env).some(span => getSpanOp(span) === UI_INTERACTION_CLICK),
+  );
+
+  await page.goto(url);
+
+  await page.locator('[data-test-id=normal-button]').click();
+  await expect(page.locator('.clicked[data-test-id=normal-button]')).toBeVisible();
+
+  // Page hide to trigger INP
+  await hidePage(page);
+
+  await spanEnvelopePromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const inpSpans = spans.filter(span => getSpanOp(span) === UI_INTERACTION_CLICK);
+  expect(inpSpans).toHaveLength(1);
+  const [inpSpan] = inpSpans;
+
+  // The callback rewrote the name and added a custom attribute.
+  expect(inpSpan.name).toBe('scrubbed');
+  expect(inpSpan.attributes['custom.attribute']).toEqual({ value: 'from-before-send-span', type: 'string' });
+
+  // The span is still a valid v2 INP span carrying its web vital value.
+  const inpValue = inpSpan.attributes[BROWSER_WEB_VITAL_INP_VALUE]?.value as number;
+  expect(inpValue).toBeGreaterThan(0);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span/init.js
index 5dd891ccc2f8..b320fb9f5984 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
@@ -15,16 +14,14 @@ Sentry.init({
     }),
   ],
   tracesSampleRate: 1,
-  // A plain (non-streamed) `beforeSendSpan` operates on the v1 `SpanJSON`. INP is sent as a v2 span,
-  // so this verifies the static callback still runs and its changes are carried into the v2 span.
-  beforeSendSpan: Sentry.withStaticSpan(span => {
-    if (span.op === 'ui.interaction.click') {
-      span.description = 'scrubbed';
-      span.data['custom.attribute'] = 'from-before-send-span';
+  beforeSendSpan: span => {
+    if (span.attributes['sentry.op'] === 'ui.interaction.click') {
+      span.name = 'scrubbed';
+      span.attributes['custom.attribute'] = 'from-before-send-span';
     }
 
     return span;
-  }),
+  },
   debug: true,
 });
 
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span/test.ts
index add8a0ac71c3..e65c3e9b90de 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-before-send-span/test.ts
@@ -1,44 +1,48 @@
+import { UI_INTERACTION_CLICK } from '@sentry/conventions/op';
+import { BROWSER_WEB_VITAL_INP_VALUE } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
 import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, getSpansFromEnvelope, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
-
-// This app does not enable span streaming (`traceLifecycle: 'static'`) and defines a plain, non-streamed
-// `beforeSendSpan` callback (operating on the v1 `SpanJSON`). INP is still emitted as a v2 span, so this
-// verifies the static callback runs for INP and its modifications are carried into the v2 span.
-
-sentryTest('runs a non-streamed `beforeSendSpan` for the INP span', async ({ browserName, getLocalTestUrl, page }) => {
+import {
+  collectStreamedSpans,
+  getSpanOp,
+  getSpansFromEnvelope,
+  waitForStreamedSpanEnvelope,
+} from '../../../../utils/spanUtils';
+
+sentryTest('runs `beforeSendSpan` for the streamed INP span', async ({ browserName, getLocalTestUrl, page }) => {
   const supportedBrowsers = ['chromium'];
 
   if (shouldSkipTracingTest() || !supportedBrowsers.includes(browserName)) {
     sentryTest.skip();
   }
 
+  const spans = collectStreamedSpans(page);
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const spanEnvelopePromise = waitForStreamedSpanEnvelope(
-    page,
-    env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'ui.interaction.click'),
+  const spanEnvelopePromise = waitForStreamedSpanEnvelope(page, env =>
+    getSpansFromEnvelope(env).some(span => getSpanOp(span) === UI_INTERACTION_CLICK),
   );
 
   await page.goto(url);
 
   await page.locator('[data-test-id=normal-button]').click();
-  await page.locator('.clicked[data-test-id=normal-button]').isVisible();
-
-  await page.waitForTimeout(500);
+  await expect(page.locator('.clicked[data-test-id=normal-button]')).toBeVisible();
 
   // Page hide to trigger INP
   await hidePage(page);
 
-  const spanEnvelope = await spanEnvelopePromise;
-  const inpSpan = getSpansFromEnvelope(spanEnvelope).find(s => getSpanOp(s) === 'ui.interaction.click')!;
+  await spanEnvelopePromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const inpSpans = spans.filter(span => getSpanOp(span) === UI_INTERACTION_CLICK);
+  expect(inpSpans).toHaveLength(1);
+  const [inpSpan] = inpSpans;
 
   // The callback rewrote the name and added a custom attribute.
   expect(inpSpan.name).toBe('scrubbed');
   expect(inpSpan.attributes['custom.attribute']).toEqual({ value: 'from-before-send-span', type: 'string' });
 
   // The span is still a valid v2 INP span carrying its web vital value.
-  const inpValue = inpSpan.attributes['browser.web_vital.inp.value']?.value as number;
+  const inpValue = inpSpan.attributes[BROWSER_WEB_VITAL_INP_VALUE]?.value as number;
   expect(inpValue).toBeGreaterThan(0);
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-late/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-late/init.js
index 398edbd14fe2..9ae2938e2969 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-late/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-late/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-late/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-late/test.ts
index 10073a27e212..63f6f5ca17a6 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-late/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-late/test.ts
@@ -1,8 +1,34 @@
+import { UI_INTERACTION_CLICK } from '@sentry/conventions/op';
+import {
+  BROWSER_WEB_VITAL_INP_VALUE,
+  SENTRY_IS_LOCALHOST,
+  SENTRY_ORIGIN,
+  SENTRY_OP,
+  UI_COMPONENT_NAME,
+  BROWSER_WEB_VITAL_INP_TARGET,
+  SENTRY_EXCLUSIVE_TIME,
+  BROWSER_WEB_VITAL_INP_INTERACTION_TYPE,
+  BROWSER_NAVIGATION_TYPE,
+  SENTRY_TRANSACTION,
+  SENTRY_SEGMENT_NAME,
+  USER_AGENT_ORIGINAL,
+  SENTRY_PAGELOAD_SPAN_ID,
+  SENTRY_TRACE_LIFECYCLE,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_ENVIRONMENT,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SDK_VERSION } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
 import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, getSpansFromEnvelope, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
+import {
+  collectStreamedSpans,
+  getSpanOp,
+  getSpansFromEnvelope,
+  waitForStreamedSpanEnvelope,
+} from '../../../../utils/spanUtils';
 
 sentryTest(
   'captures an INP click as a streamed span after pageload',
@@ -13,19 +39,17 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const spans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const spanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'ui.interaction.click'),
+    const spanEnvelopePromise = waitForStreamedSpanEnvelope(page, env =>
+      getSpansFromEnvelope(env).some(span => getSpanOp(span) === UI_INTERACTION_CLICK),
     );
 
     await page.goto(url);
 
     await page.locator('[data-test-id=normal-button]').click();
-    await page.locator('.clicked[data-test-id=normal-button]').isVisible();
-
-    await page.waitForTimeout(500);
+    await expect(page.locator('.clicked[data-test-id=normal-button]')).toBeVisible();
 
     // Page hide to trigger INP
     await hidePage(page);
@@ -33,7 +57,10 @@ sentryTest(
     const spanEnvelope = await spanEnvelopePromise;
     const envelopeHeader = spanEnvelope[0];
     const itemHeader = spanEnvelope[1][0][0];
-    const inpSpan = getSpansFromEnvelope(spanEnvelope).find(s => getSpanOp(s) === 'ui.interaction.click')!;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const inpSpans = spans.filter(span => getSpanOp(span) === UI_INTERACTION_CLICK);
+    expect(inpSpans).toHaveLength(1);
+    const [inpSpan] = inpSpans;
 
     const traceId = envelopeHeader.trace!.trace_id;
     expect(traceId).toMatch(/^[\da-f]{32}$/);
@@ -54,17 +81,17 @@ sentryTest(
 
     expect(itemHeader).toEqual({
       type: 'span',
-      item_count: 1,
+      item_count: getSpansFromEnvelope(spanEnvelope).length,
       content_type: 'application/vnd.sentry.items.span.v2+json',
     });
 
-    const inpValue = inpSpan.attributes['browser.web_vital.inp.value']?.value as number;
+    const inpValue = inpSpan.attributes[BROWSER_WEB_VITAL_INP_VALUE]?.value as number;
     expect(inpValue).toBeGreaterThan(0);
 
     const pageloadSpanId = inpSpan.parent_span_id;
 
     expect(inpSpan).toEqual({
-      name: 'body > NormalButton',
+      name: 'NormalButton',
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
       trace_id: traceId,
       parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
@@ -73,24 +100,24 @@ sentryTest(
       is_segment: false,
       status: 'ok',
       attributes: {
-        'sentry.is_localhost': { value: false, type: 'boolean' },
-        'sentry.origin': { value: 'auto.http.browser.inp', type: 'string' },
-        'sentry.op': { value: 'ui.interaction.click', type: 'string' },
-        'ui.component_name': { value: 'NormalButton', type: 'string' },
-        'browser.web_vital.inp.target': { value: 'body > NormalButton', type: 'string' },
-        'sentry.exclusive_time': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.value': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.interaction_type': { value: 'click', type: 'string' },
-        'browser.navigation.type': { value: 'navigate', type: 'string' },
-        'sentry.transaction': { value: 'test-url', type: 'string' },
-        'sentry.segment.name': { value: 'test-url', type: 'string' },
-        'user_agent.original': { value: expect.stringContaining('Chrome'), type: 'string' },
-        'sentry.pageload.span_id': { value: pageloadSpanId, type: 'string' },
-        'sentry.trace_lifecycle': { value: 'stream', type: 'string' },
-        'sentry.segment.id': { value: pageloadSpanId, type: 'string' },
-        'sentry.sdk.name': { value: 'sentry.javascript.browser', type: 'string' },
-        'sentry.sdk.version': { value: SDK_VERSION, type: 'string' },
-        'sentry.environment': { value: 'production', type: 'string' },
+        [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
+        [SENTRY_ORIGIN]: { value: 'auto.http.browser.inp', type: 'string' },
+        [SENTRY_OP]: { value: UI_INTERACTION_CLICK, type: 'string' },
+        [UI_COMPONENT_NAME]: { value: 'NormalButton', type: 'string' },
+        [BROWSER_WEB_VITAL_INP_TARGET]: { value: 'body > NormalButton', type: 'string' },
+        [SENTRY_EXCLUSIVE_TIME]: { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
+        [BROWSER_WEB_VITAL_INP_VALUE]: { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
+        [BROWSER_WEB_VITAL_INP_INTERACTION_TYPE]: { value: 'click', type: 'string' },
+        [BROWSER_NAVIGATION_TYPE]: { value: 'navigate', type: 'string' },
+        [SENTRY_TRANSACTION]: { value: 'test-url', type: 'string' },
+        [SENTRY_SEGMENT_NAME]: { value: 'test-url', type: 'string' },
+        [USER_AGENT_ORIGINAL]: { value: expect.stringContaining('Chrome'), type: 'string' },
+        [SENTRY_PAGELOAD_SPAN_ID]: { value: pageloadSpanId, type: 'string' },
+        [SENTRY_TRACE_LIFECYCLE]: { value: 'stream', type: 'string' },
+        [SENTRY_SEGMENT_ID]: { value: pageloadSpanId, type: 'string' },
+        [SENTRY_SDK_NAME]: { value: 'sentry.javascript.browser', type: 'string' },
+        [SENTRY_SDK_VERSION]: { value: SDK_VERSION, type: 'string' },
+        [SENTRY_ENVIRONMENT]: { value: 'production', type: 'string' },
       },
     });
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-navigate/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-navigate/init.js
index 822c40214adb..cf36be344e01 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-navigate/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-navigate/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-navigate/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-navigate/test.ts
index c7a29f406c1e..8cdafe4870c0 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-navigate/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-navigate/test.ts
@@ -1,8 +1,34 @@
+import { UI_INTERACTION_CLICK } from '@sentry/conventions/op';
+import {
+  BROWSER_WEB_VITAL_INP_VALUE,
+  SENTRY_IS_LOCALHOST,
+  SENTRY_ORIGIN,
+  SENTRY_OP,
+  UI_COMPONENT_NAME,
+  BROWSER_WEB_VITAL_INP_TARGET,
+  SENTRY_EXCLUSIVE_TIME,
+  BROWSER_WEB_VITAL_INP_INTERACTION_TYPE,
+  BROWSER_NAVIGATION_TYPE,
+  SENTRY_TRANSACTION,
+  SENTRY_SEGMENT_NAME,
+  USER_AGENT_ORIGINAL,
+  SENTRY_PAGELOAD_SPAN_ID,
+  SENTRY_TRACE_LIFECYCLE,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_ENVIRONMENT,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SDK_VERSION } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
 import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, getSpansFromEnvelope, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
+import {
+  collectStreamedSpans,
+  getSpanOp,
+  getSpansFromEnvelope,
+  waitForStreamedSpanEnvelope,
+} from '../../../../utils/spanUtils';
 
 const supportedBrowsers = ['chromium'];
 
@@ -13,20 +39,18 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const spans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const spanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'ui.interaction.click'),
+    const spanEnvelopePromise = waitForStreamedSpanEnvelope(page, env =>
+      getSpansFromEnvelope(env).some(span => getSpanOp(span) === UI_INTERACTION_CLICK),
     );
 
     await page.goto(url);
 
     // Simulating route change (keeping <nav> in DOM)
     await page.locator('[data-test-id=nav-link-keepDOM]').click();
-    await page.locator('.navigated').isVisible();
-
-    await page.waitForTimeout(500);
+    await expect(page.locator('.navigated')).toBeVisible();
 
     // Page hide to trigger INP
     await hidePage(page);
@@ -34,7 +58,10 @@ sentryTest(
     const spanEnvelope = await spanEnvelopePromise;
     const envelopeHeader = spanEnvelope[0];
     const itemHeader = spanEnvelope[1][0][0];
-    const inpSpan = getSpansFromEnvelope(spanEnvelope).find(s => getSpanOp(s) === 'ui.interaction.click')!;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const inpSpans = spans.filter(span => getSpanOp(span) === UI_INTERACTION_CLICK);
+    expect(inpSpans).toHaveLength(1);
+    const [inpSpan] = inpSpans;
 
     const traceId = envelopeHeader.trace!.trace_id;
     expect(traceId).toMatch(/^[\da-f]{32}$/);
@@ -54,17 +81,17 @@ sentryTest(
 
     expect(itemHeader).toEqual({
       type: 'span',
-      item_count: 1,
+      item_count: getSpansFromEnvelope(spanEnvelope).length,
       content_type: 'application/vnd.sentry.items.span.v2+json',
     });
 
-    const inpValue = inpSpan.attributes['browser.web_vital.inp.value']?.value as number;
+    const inpValue = inpSpan.attributes[BROWSER_WEB_VITAL_INP_VALUE]?.value as number;
     expect(inpValue).toBeGreaterThan(0);
 
     const pageloadSpanId = inpSpan.parent_span_id;
 
     expect(inpSpan).toEqual({
-      name: 'body > nav#navigation > NavigationLink',
+      name: 'NavigationLink',
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
       trace_id: traceId,
       parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
@@ -73,24 +100,24 @@ sentryTest(
       is_segment: false,
       status: 'ok',
       attributes: {
-        'sentry.is_localhost': { value: false, type: 'boolean' },
-        'sentry.origin': { value: 'auto.http.browser.inp', type: 'string' },
-        'sentry.op': { value: 'ui.interaction.click', type: 'string' },
-        'ui.component_name': { value: 'NavigationLink', type: 'string' },
-        'browser.web_vital.inp.target': { value: 'body > nav#navigation > NavigationLink', type: 'string' },
-        'sentry.exclusive_time': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.value': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.interaction_type': { value: 'click', type: 'string' },
-        'browser.navigation.type': { value: 'navigate', type: 'string' },
-        'sentry.transaction': { value: 'test-url', type: 'string' },
-        'sentry.segment.name': { value: 'test-url', type: 'string' },
-        'user_agent.original': { value: expect.stringContaining('Chrome'), type: 'string' },
-        'sentry.pageload.span_id': { value: pageloadSpanId, type: 'string' },
-        'sentry.trace_lifecycle': { value: 'stream', type: 'string' },
-        'sentry.segment.id': { value: pageloadSpanId, type: 'string' },
-        'sentry.sdk.name': { value: 'sentry.javascript.browser', type: 'string' },
-        'sentry.sdk.version': { value: SDK_VERSION, type: 'string' },
-        'sentry.environment': { value: 'production', type: 'string' },
+        [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
+        [SENTRY_ORIGIN]: { value: 'auto.http.browser.inp', type: 'string' },
+        [SENTRY_OP]: { value: UI_INTERACTION_CLICK, type: 'string' },
+        [UI_COMPONENT_NAME]: { value: 'NavigationLink', type: 'string' },
+        [BROWSER_WEB_VITAL_INP_TARGET]: { value: 'body > nav#navigation > NavigationLink', type: 'string' },
+        [SENTRY_EXCLUSIVE_TIME]: { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
+        [BROWSER_WEB_VITAL_INP_VALUE]: { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
+        [BROWSER_WEB_VITAL_INP_INTERACTION_TYPE]: { value: 'click', type: 'string' },
+        [BROWSER_NAVIGATION_TYPE]: { value: 'navigate', type: 'string' },
+        [SENTRY_TRANSACTION]: { value: 'test-url', type: 'string' },
+        [SENTRY_SEGMENT_NAME]: { value: 'test-url', type: 'string' },
+        [USER_AGENT_ORIGINAL]: { value: expect.stringContaining('Chrome'), type: 'string' },
+        [SENTRY_PAGELOAD_SPAN_ID]: { value: pageloadSpanId, type: 'string' },
+        [SENTRY_TRACE_LIFECYCLE]: { value: 'stream', type: 'string' },
+        [SENTRY_SEGMENT_ID]: { value: pageloadSpanId, type: 'string' },
+        [SENTRY_SDK_NAME]: { value: 'sentry.javascript.browser', type: 'string' },
+        [SENTRY_SDK_VERSION]: { value: SDK_VERSION, type: 'string' },
+        [SENTRY_ENVIRONMENT]: { value: 'production', type: 'string' },
       },
     });
   },
@@ -103,20 +130,18 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const spans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const spanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'ui.interaction.click'),
+    const spanEnvelopePromise = waitForStreamedSpanEnvelope(page, env =>
+      getSpansFromEnvelope(env).some(span => getSpanOp(span) === UI_INTERACTION_CLICK),
     );
 
     await page.goto(url);
 
     // Simulating route change (also changing <nav> in DOM)
     await page.locator('[data-test-id=nav-link-changeDOM]').click();
-    await page.locator('.navigated').isVisible();
-
-    await page.waitForTimeout(500);
+    await expect(page.locator('.navigated')).toBeVisible();
 
     // Page hide to trigger INP
     await hidePage(page);
@@ -124,7 +149,10 @@ sentryTest(
     const spanEnvelope = await spanEnvelopePromise;
     const envelopeHeader = spanEnvelope[0];
     const itemHeader = spanEnvelope[1][0][0];
-    const inpSpan = getSpansFromEnvelope(spanEnvelope).find(s => getSpanOp(s) === 'ui.interaction.click')!;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const inpSpans = spans.filter(span => getSpanOp(span) === UI_INTERACTION_CLICK);
+    expect(inpSpans).toHaveLength(1);
+    const [inpSpan] = inpSpans;
 
     const traceId = envelopeHeader.trace!.trace_id;
     expect(traceId).toMatch(/^[\da-f]{32}$/);
@@ -144,17 +172,17 @@ sentryTest(
 
     expect(itemHeader).toEqual({
       type: 'span',
-      item_count: 1,
+      item_count: getSpansFromEnvelope(spanEnvelope).length,
       content_type: 'application/vnd.sentry.items.span.v2+json',
     });
 
-    const inpValue = inpSpan.attributes['browser.web_vital.inp.value']?.value as number;
+    const inpValue = inpSpan.attributes[BROWSER_WEB_VITAL_INP_VALUE]?.value as number;
     expect(inpValue).toBeGreaterThan(0);
 
     const pageloadSpanId = inpSpan.parent_span_id;
 
     expect(inpSpan).toEqual({
-      name: 'body > nav#navigation > NavigationLink',
+      name: 'Click',
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
       trace_id: expect.stringMatching(/^[\da-f]{32}$/),
       parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
@@ -163,23 +191,23 @@ sentryTest(
       is_segment: false,
       status: 'ok',
       attributes: {
-        'sentry.is_localhost': { value: false, type: 'boolean' },
-        'sentry.origin': { value: 'auto.http.browser.inp', type: 'string' },
-        'sentry.op': { value: 'ui.interaction.click', type: 'string' },
-        'browser.web_vital.inp.target': { value: 'body > nav#navigation > NavigationLink', type: 'string' },
-        'sentry.exclusive_time': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.value': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.interaction_type': { value: 'click', type: 'string' },
-        'browser.navigation.type': { value: 'navigate', type: 'string' },
-        'sentry.transaction': { value: 'test-url', type: 'string' },
-        'sentry.segment.name': { value: 'test-url', type: 'string' },
-        'user_agent.original': { value: expect.stringContaining('Chrome'), type: 'string' },
-        'sentry.pageload.span_id': { value: pageloadSpanId, type: 'string' },
-        'sentry.trace_lifecycle': { value: 'stream', type: 'string' },
-        'sentry.segment.id': { value: pageloadSpanId, type: 'string' },
-        'sentry.sdk.name': { value: 'sentry.javascript.browser', type: 'string' },
-        'sentry.sdk.version': { value: SDK_VERSION, type: 'string' },
-        'sentry.environment': { value: 'production', type: 'string' },
+        [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
+        [SENTRY_ORIGIN]: { value: 'auto.http.browser.inp', type: 'string' },
+        [SENTRY_OP]: { value: UI_INTERACTION_CLICK, type: 'string' },
+        [BROWSER_WEB_VITAL_INP_TARGET]: { value: 'body > nav#navigation > NavigationLink', type: 'string' },
+        [SENTRY_EXCLUSIVE_TIME]: { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
+        [BROWSER_WEB_VITAL_INP_VALUE]: { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
+        [BROWSER_WEB_VITAL_INP_INTERACTION_TYPE]: { value: 'click', type: 'string' },
+        [BROWSER_NAVIGATION_TYPE]: { value: 'navigate', type: 'string' },
+        [SENTRY_TRANSACTION]: { value: 'test-url', type: 'string' },
+        [SENTRY_SEGMENT_NAME]: { value: 'test-url', type: 'string' },
+        [USER_AGENT_ORIGINAL]: { value: expect.stringContaining('Chrome'), type: 'string' },
+        [SENTRY_PAGELOAD_SPAN_ID]: { value: pageloadSpanId, type: 'string' },
+        [SENTRY_TRACE_LIFECYCLE]: { value: 'stream', type: 'string' },
+        [SENTRY_SEGMENT_ID]: { value: pageloadSpanId, type: 'string' },
+        [SENTRY_SDK_NAME]: { value: 'sentry.javascript.browser', type: 'string' },
+        [SENTRY_SDK_VERSION]: { value: SDK_VERSION, type: 'string' },
+        [SENTRY_ENVIRONMENT]: { value: 'production', type: 'string' },
       },
     });
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized-late/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized-late/init.js
index 4745a0f370de..8234edd4039b 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized-late/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized-late/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized-late/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized-late/test.ts
index 197c89ec78fb..81d264959eb5 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized-late/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized-late/test.ts
@@ -1,8 +1,34 @@
+import { UI_INTERACTION_CLICK } from '@sentry/conventions/op';
+import {
+  BROWSER_WEB_VITAL_INP_VALUE,
+  SENTRY_IS_LOCALHOST,
+  SENTRY_ORIGIN,
+  SENTRY_OP,
+  UI_COMPONENT_NAME,
+  BROWSER_WEB_VITAL_INP_TARGET,
+  SENTRY_EXCLUSIVE_TIME,
+  BROWSER_WEB_VITAL_INP_INTERACTION_TYPE,
+  BROWSER_NAVIGATION_TYPE,
+  SENTRY_TRANSACTION,
+  SENTRY_SEGMENT_NAME,
+  USER_AGENT_ORIGINAL,
+  SENTRY_PAGELOAD_SPAN_ID,
+  SENTRY_TRACE_LIFECYCLE,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_ENVIRONMENT,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SDK_VERSION } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
 import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, getSpansFromEnvelope, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
+import {
+  collectStreamedSpans,
+  getSpanOp,
+  getSpansFromEnvelope,
+  waitForStreamedSpanEnvelope,
+} from '../../../../utils/spanUtils';
 
 sentryTest(
   'captures an INP click as a streamed span after pageload for a parametrized transaction',
@@ -13,19 +39,17 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const spans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const spanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'ui.interaction.click'),
+    const spanEnvelopePromise = waitForStreamedSpanEnvelope(page, env =>
+      getSpansFromEnvelope(env).some(span => getSpanOp(span) === UI_INTERACTION_CLICK),
     );
 
     await page.goto(url);
 
     await page.locator('[data-test-id=normal-button]').click();
-    await page.locator('.clicked[data-test-id=normal-button]').isVisible();
-
-    await page.waitForTimeout(500);
+    await expect(page.locator('.clicked[data-test-id=normal-button]')).toBeVisible();
 
     // Page hide to trigger INP
     await hidePage(page);
@@ -33,7 +57,10 @@ sentryTest(
     const spanEnvelope = await spanEnvelopePromise;
     const envelopeHeader = spanEnvelope[0];
     const itemHeader = spanEnvelope[1][0][0];
-    const inpSpan = getSpansFromEnvelope(spanEnvelope).find(s => getSpanOp(s) === 'ui.interaction.click')!;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const inpSpans = spans.filter(span => getSpanOp(span) === UI_INTERACTION_CLICK);
+    expect(inpSpans).toHaveLength(1);
+    const [inpSpan] = inpSpans;
 
     const traceId = envelopeHeader.trace!.trace_id;
     expect(traceId).toMatch(/^[\da-f]{32}$/);
@@ -55,17 +82,17 @@ sentryTest(
 
     expect(itemHeader).toEqual({
       type: 'span',
-      item_count: 1,
+      item_count: getSpansFromEnvelope(spanEnvelope).length,
       content_type: 'application/vnd.sentry.items.span.v2+json',
     });
 
-    const inpValue = inpSpan.attributes['browser.web_vital.inp.value']?.value as number;
+    const inpValue = inpSpan.attributes[BROWSER_WEB_VITAL_INP_VALUE]?.value as number;
     expect(inpValue).toBeGreaterThan(0);
 
     const pageloadSpanId = inpSpan.parent_span_id;
 
     expect(inpSpan).toEqual({
-      name: 'body > NormalButton',
+      name: 'NormalButton',
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
       trace_id: traceId,
       parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
@@ -74,25 +101,25 @@ sentryTest(
       is_segment: false,
       status: 'ok',
       attributes: {
-        'sentry.is_localhost': { value: false, type: 'boolean' },
-        'sentry.origin': { value: 'auto.http.browser.inp', type: 'string' },
-        'sentry.op': { value: 'ui.interaction.click', type: 'string' },
-        'ui.component_name': { value: 'NormalButton', type: 'string' },
-        'browser.web_vital.inp.target': { value: 'body > NormalButton', type: 'string' },
-        'sentry.exclusive_time': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.value': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.interaction_type': { value: 'click', type: 'string' },
-        'browser.navigation.type': { value: 'navigate', type: 'string' },
+        [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
+        [SENTRY_ORIGIN]: { value: 'auto.http.browser.inp', type: 'string' },
+        [SENTRY_OP]: { value: UI_INTERACTION_CLICK, type: 'string' },
+        [UI_COMPONENT_NAME]: { value: 'NormalButton', type: 'string' },
+        [BROWSER_WEB_VITAL_INP_TARGET]: { value: 'body > NormalButton', type: 'string' },
+        [SENTRY_EXCLUSIVE_TIME]: { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
+        [BROWSER_WEB_VITAL_INP_VALUE]: { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
+        [BROWSER_WEB_VITAL_INP_INTERACTION_TYPE]: { value: 'click', type: 'string' },
+        [BROWSER_NAVIGATION_TYPE]: { value: 'navigate', type: 'string' },
         // the parametrized route name flows onto the INP span
-        'sentry.transaction': { value: 'test-route', type: 'string' },
-        'sentry.segment.name': { value: 'test-route', type: 'string' },
-        'user_agent.original': { value: expect.stringContaining('Chrome'), type: 'string' },
-        'sentry.pageload.span_id': { value: pageloadSpanId, type: 'string' },
-        'sentry.trace_lifecycle': { value: 'stream', type: 'string' },
-        'sentry.segment.id': { value: pageloadSpanId, type: 'string' },
-        'sentry.sdk.name': { value: 'sentry.javascript.browser', type: 'string' },
-        'sentry.sdk.version': { value: SDK_VERSION, type: 'string' },
-        'sentry.environment': { value: 'production', type: 'string' },
+        [SENTRY_TRANSACTION]: { value: 'test-route', type: 'string' },
+        [SENTRY_SEGMENT_NAME]: { value: 'test-route', type: 'string' },
+        [USER_AGENT_ORIGINAL]: { value: expect.stringContaining('Chrome'), type: 'string' },
+        [SENTRY_PAGELOAD_SPAN_ID]: { value: pageloadSpanId, type: 'string' },
+        [SENTRY_TRACE_LIFECYCLE]: { value: 'stream', type: 'string' },
+        [SENTRY_SEGMENT_ID]: { value: pageloadSpanId, type: 'string' },
+        [SENTRY_SDK_NAME]: { value: 'sentry.javascript.browser', type: 'string' },
+        [SENTRY_SDK_VERSION]: { value: SDK_VERSION, type: 'string' },
+        [SENTRY_ENVIRONMENT]: { value: 'production', type: 'string' },
       },
     });
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized/init.js
index 3adb365703b9..1b55260e60d3 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized/test.ts
index 83b3695628f3..cda0412f8d4e 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-parametrized/test.ts
@@ -1,8 +1,34 @@
+import { UI_INTERACTION_CLICK } from '@sentry/conventions/op';
+import {
+  BROWSER_WEB_VITAL_INP_VALUE,
+  SENTRY_IS_LOCALHOST,
+  SENTRY_ORIGIN,
+  SENTRY_OP,
+  UI_COMPONENT_NAME,
+  BROWSER_WEB_VITAL_INP_TARGET,
+  SENTRY_EXCLUSIVE_TIME,
+  BROWSER_WEB_VITAL_INP_INTERACTION_TYPE,
+  BROWSER_NAVIGATION_TYPE,
+  SENTRY_TRANSACTION,
+  SENTRY_SEGMENT_NAME,
+  USER_AGENT_ORIGINAL,
+  SENTRY_PAGELOAD_SPAN_ID,
+  SENTRY_TRACE_LIFECYCLE,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_ENVIRONMENT,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { SDK_VERSION } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
 import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, getSpansFromEnvelope, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
+import {
+  collectStreamedSpans,
+  getSpanOp,
+  getSpansFromEnvelope,
+  waitForStreamedSpanEnvelope,
+} from '../../../../utils/spanUtils';
 
 sentryTest(
   'captures an INP click as a streamed span for a parametrized transaction',
@@ -13,19 +39,17 @@ sentryTest(
       sentryTest.skip();
     }
 
+    const spans = collectStreamedSpans(page);
     const url = await getLocalTestUrl({ testDir: __dirname });
 
-    const spanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'ui.interaction.click'),
+    const spanEnvelopePromise = waitForStreamedSpanEnvelope(page, env =>
+      getSpansFromEnvelope(env).some(span => getSpanOp(span) === UI_INTERACTION_CLICK),
     );
 
     await page.goto(url);
 
     await page.locator('[data-test-id=normal-button]').click();
-    await page.locator('.clicked[data-test-id=normal-button]').isVisible();
-
-    await page.waitForTimeout(500);
+    await expect(page.locator('.clicked[data-test-id=normal-button]')).toBeVisible();
 
     // Page hide to trigger INP
     await hidePage(page);
@@ -33,7 +57,10 @@ sentryTest(
     const spanEnvelope = await spanEnvelopePromise;
     const envelopeHeader = spanEnvelope[0];
     const itemHeader = spanEnvelope[1][0][0];
-    const inpSpan = getSpansFromEnvelope(spanEnvelope).find(s => getSpanOp(s) === 'ui.interaction.click')!;
+    await page.evaluate(() => (window as any).Sentry.flush());
+    const inpSpans = spans.filter(span => getSpanOp(span) === UI_INTERACTION_CLICK);
+    expect(inpSpans).toHaveLength(1);
+    const [inpSpan] = inpSpans;
 
     const traceId = envelopeHeader.trace!.trace_id;
     expect(traceId).toMatch(/^[\da-f]{32}$/);
@@ -55,17 +82,17 @@ sentryTest(
 
     expect(itemHeader).toEqual({
       type: 'span',
-      item_count: 1,
+      item_count: getSpansFromEnvelope(spanEnvelope).length,
       content_type: 'application/vnd.sentry.items.span.v2+json',
     });
 
-    const inpValue = inpSpan.attributes['browser.web_vital.inp.value']?.value as number;
+    const inpValue = inpSpan.attributes[BROWSER_WEB_VITAL_INP_VALUE]?.value as number;
     expect(inpValue).toBeGreaterThan(0);
 
     const pageloadSpanId = inpSpan.parent_span_id;
 
     expect(inpSpan).toEqual({
-      name: 'body > NormalButton',
+      name: 'NormalButton',
       span_id: expect.stringMatching(/^[\da-f]{16}$/),
       trace_id: traceId,
       parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
@@ -74,25 +101,25 @@ sentryTest(
       is_segment: false,
       status: 'ok',
       attributes: {
-        'sentry.is_localhost': { value: false, type: 'boolean' },
-        'sentry.origin': { value: 'auto.http.browser.inp', type: 'string' },
-        'sentry.op': { value: 'ui.interaction.click', type: 'string' },
-        'ui.component_name': { value: 'NormalButton', type: 'string' },
-        'browser.web_vital.inp.target': { value: 'body > NormalButton', type: 'string' },
-        'sentry.exclusive_time': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.value': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.interaction_type': { value: 'click', type: 'string' },
-        'browser.navigation.type': { value: 'navigate', type: 'string' },
+        [SENTRY_IS_LOCALHOST]: { value: false, type: 'boolean' },
+        [SENTRY_ORIGIN]: { value: 'auto.http.browser.inp', type: 'string' },
+        [SENTRY_OP]: { value: UI_INTERACTION_CLICK, type: 'string' },
+        [UI_COMPONENT_NAME]: { value: 'NormalButton', type: 'string' },
+        [BROWSER_WEB_VITAL_INP_TARGET]: { value: 'body > NormalButton', type: 'string' },
+        [SENTRY_EXCLUSIVE_TIME]: { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
+        [BROWSER_WEB_VITAL_INP_VALUE]: { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
+        [BROWSER_WEB_VITAL_INP_INTERACTION_TYPE]: { value: 'click', type: 'string' },
+        [BROWSER_NAVIGATION_TYPE]: { value: 'navigate', type: 'string' },
         // the parametrized route name flows onto the INP span
-        'sentry.transaction': { value: 'test-route', type: 'string' },
-        'sentry.segment.name': { value: 'test-route', type: 'string' },
-        'user_agent.original': { value: expect.stringContaining('Chrome'), type: 'string' },
-        'sentry.pageload.span_id': { value: pageloadSpanId, type: 'string' },
-        'sentry.trace_lifecycle': { value: 'stream', type: 'string' },
-        'sentry.segment.id': { value: pageloadSpanId, type: 'string' },
-        'sentry.sdk.name': { value: 'sentry.javascript.browser', type: 'string' },
-        'sentry.sdk.version': { value: SDK_VERSION, type: 'string' },
-        'sentry.environment': { value: 'production', type: 'string' },
+        [SENTRY_TRANSACTION]: { value: 'test-route', type: 'string' },
+        [SENTRY_SEGMENT_NAME]: { value: 'test-route', type: 'string' },
+        [USER_AGENT_ORIGINAL]: { value: expect.stringContaining('Chrome'), type: 'string' },
+        [SENTRY_PAGELOAD_SPAN_ID]: { value: pageloadSpanId, type: 'string' },
+        [SENTRY_TRACE_LIFECYCLE]: { value: 'stream', type: 'string' },
+        [SENTRY_SEGMENT_ID]: { value: pageloadSpanId, type: 'string' },
+        [SENTRY_SDK_NAME]: { value: 'sentry.javascript.browser', type: 'string' },
+        [SENTRY_SDK_VERSION]: { value: SDK_VERSION, type: 'string' },
+        [SENTRY_ENVIRONMENT]: { value: 'production', type: 'string' },
       },
     });
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/test.ts
deleted file mode 100644
index f1ba7c9138f7..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp-streamed-spans/test.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
-
-sentryTest.beforeEach(async ({ browserName }) => {
-  if (shouldSkipTracingTest() || browserName !== 'chromium') {
-    sentryTest.skip();
-  }
-});
-
-sentryTest('captures INP click as a streamed span', async ({ getLocalTestUrl, page }) => {
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-  const inpSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.interaction.click');
-
-  await page.goto(url);
-
-  await page.locator('[data-test-id=normal-button]').click();
-  await page.locator('.clicked[data-test-id=normal-button]').isVisible();
-
-  await page.waitForTimeout(500);
-
-  await hidePage(page);
-
-  const inpSpan = await inpSpanPromise;
-  const pageloadSpan = await pageloadSpanPromise;
-
-  expect(inpSpan.attributes['sentry.op']).toEqual({ type: 'string', value: 'ui.interaction.click' });
-  expect(inpSpan.attributes['sentry.origin']).toEqual({ type: 'string', value: 'auto.http.browser.inp' });
-  expect(inpSpan.attributes['user_agent.original']?.value).toEqual(expect.stringContaining('Chrome'));
-
-  // Check the INP span carries the transaction/segment name it belongs to
-  expect(inpSpan.attributes['sentry.transaction']).toEqual({ type: 'string', value: 'Pageload' });
-  expect(inpSpan.attributes['sentry.segment.name']).toEqual({ type: 'string', value: 'Pageload' });
-
-  const inpValue = inpSpan.attributes['browser.web_vital.inp.value']?.value as number;
-  expect(inpValue).toBeGreaterThan(0);
-
-  expect(inpSpan.attributes['sentry.exclusive_time']?.value).toBeGreaterThan(0);
-
-  expect(inpSpan.name).toBe('NormalButton');
-  expect(inpSpan.attributes['ui.component_name']).toEqual({ type: 'string', value: 'NormalButton' });
-  expect(inpSpan.attributes['browser.web_vital.inp.target']).toEqual({ type: 'string', value: 'body > NormalButton' });
-
-  expect(inpSpan.end_timestamp).toBeGreaterThan(inpSpan.start_timestamp);
-
-  expect(inpSpan.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(inpSpan.trace_id).toMatch(/^[\da-f]{32}$/);
-
-  expect(inpSpan.parent_span_id).toBe(pageloadSpan.span_id);
-  expect(inpSpan.trace_id).toBe(pageloadSpan.trace_id);
-});
-
-sentryTest('captures the slowest interaction as streamed INP span', async ({ getLocalTestUrl, page }) => {
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  await page.goto(url);
-
-  await page.locator('[data-test-id=normal-button]').click();
-  await page.locator('.clicked[data-test-id=normal-button]').isVisible();
-
-  await page.waitForTimeout(500);
-
-  const inpSpanPromise = waitForStreamedSpan(page, span => {
-    const op = getSpanOp(span);
-    return op === 'ui.interaction.click';
-  });
-
-  await page.locator('[data-test-id=slow-button]').click();
-  await page.locator('.clicked[data-test-id=slow-button]').isVisible();
-
-  await page.waitForTimeout(500);
-
-  await hidePage(page);
-
-  const inpSpan = await inpSpanPromise;
-
-  expect(inpSpan.name).toBe('SlowButton');
-  expect(inpSpan.attributes['ui.component_name']).toEqual({ type: 'string', value: 'SlowButton' });
-  expect(inpSpan.attributes['browser.web_vital.inp.target']).toEqual({ type: 'string', value: 'body > SlowButton' });
-  expect(inpSpan.attributes['sentry.exclusive_time']?.value).toBeGreaterThan(400);
-
-  const inpValue = inpSpan.attributes['browser.web_vital.inp.value']?.value as number;
-  expect(inpValue).toBeGreaterThan(400);
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/init.js
index 44acb2f6c147..6ebfc6540022 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/init.js
@@ -1,29 +1,14 @@
 import * as Sentry from '@sentry/browser';
 
 window.Sentry = Sentry;
+window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [
     Sentry.browserTracingIntegration({
-      idleTimeout: 4000,
-      enableLongTask: false,
-      enableInp: true,
-      instrumentPageLoad: false,
-      instrumentNavigation: false,
+      idleTimeout: 5000,
     }),
   ],
   tracesSampleRate: 1,
-  debug: true,
-});
-
-const client = Sentry.getClient();
-
-// Force page load transaction name to a testable value
-Sentry.startBrowserTracingPageLoadSpan(client, {
-  name: 'test-url',
-  attributes: {
-    ['sentry.segment.name.source']: 'url',
-  },
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/subject.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/subject.js
index 64524952dfa7..f4ea1cd46d67 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/subject.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/subject.js
@@ -3,18 +3,17 @@ const blockUI =
   e => {
     const startTime = Date.now();
 
-    function getElasped() {
+    function getElapsed() {
       const time = Date.now();
       return time - startTime;
     }
 
-    while (getElasped() < delay) {
+    while (getElapsed() < delay) {
       //
     }
 
     e.target.classList.add('clicked');
   };
 
-document.querySelector('[data-test-id=not-so-slow-button]').addEventListener('click', blockUI(300));
 document.querySelector('[data-test-id=slow-button]').addEventListener('click', blockUI(450));
 document.querySelector('[data-test-id=normal-button]').addEventListener('click', blockUI());
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/template.html b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/template.html
index 437426e9ab01..d5f28c7c8847 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/template.html
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/template.html
@@ -4,9 +4,7 @@
     <meta charset="utf-8" />
   </head>
   <body>
-    <div>Rendered Before Long Task</div>
     <button data-test-id="slow-button" data-sentry-element="SlowButton">Slow</button>
-    <button data-test-id="not-so-slow-button" data-sentry-element="NotSoSlowButton">Not so slow</button>
     <button data-test-id="normal-button" data-sentry-element="NormalButton">Click Me</button>
   </body>
 </html>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/test.ts
index f47e7dcd6f09..3510b5bb1d9b 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-inp/test.ts
@@ -1,172 +1,100 @@
+import { PAGELOAD, UI_INTERACTION_CLICK } from '@sentry/conventions/op';
+import {
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  USER_AGENT_ORIGINAL,
+  SENTRY_TRANSACTION,
+  SENTRY_SEGMENT_NAME,
+  BROWSER_WEB_VITAL_INP_VALUE,
+  SENTRY_EXCLUSIVE_TIME,
+  UI_COMPONENT_NAME,
+  BROWSER_WEB_VITAL_INP_TARGET,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import { SDK_VERSION } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
 import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, getSpansFromEnvelope, waitForStreamedSpanEnvelope } from '../../../../utils/spanUtils';
-
-// This app does not enable span streaming (no `traceLifecycle: 'stream'`). INP is still emitted as a
-// streamed span, because INP overrides the static trace lifecycle for itself (it would otherwise be
-// dropped as a late child of the already-ended pageload span).
-
-sentryTest(
-  'captures an INP click as a streamed span during pageload',
-  async ({ browserName, getLocalTestUrl, page }) => {
-    const supportedBrowsers = ['chromium'];
-
-    if (shouldSkipTracingTest() || !supportedBrowsers.includes(browserName)) {
-      sentryTest.skip();
-    }
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const spanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'ui.interaction.click'),
-    );
-
-    await page.goto(url);
-
-    await page.locator('[data-test-id=normal-button]').click();
-    await page.locator('.clicked[data-test-id=normal-button]').isVisible();
-
-    await page.waitForTimeout(500);
-
-    // Page hide to trigger INP
-    await hidePage(page);
-
-    const spanEnvelope = await spanEnvelopePromise;
-    const envelopeHeader = spanEnvelope[0];
-    const itemHeader = spanEnvelope[1][0][0];
-    const inpSpan = getSpansFromEnvelope(spanEnvelope).find(s => getSpanOp(s) === 'ui.interaction.click')!;
-
-    const traceId = envelopeHeader.trace!.trace_id;
-    expect(traceId).toMatch(/^[\da-f]{32}$/);
-
-    expect(envelopeHeader).toEqual({
-      sdk: { name: 'sentry.javascript.browser', version: SDK_VERSION },
-      sent_at: expect.any(String),
-      trace: {
-        environment: 'production',
-        public_key: 'public',
-        sample_rand: expect.any(String),
-        sample_rate: '1',
-        sampled: 'true',
-        trace_id: traceId,
-        // no `transaction`, because the span source is the URL
-      },
-    });
-
-    expect(itemHeader).toEqual({
-      type: 'span',
-      item_count: 1,
-      content_type: 'application/vnd.sentry.items.span.v2+json',
-    });
-
-    const inpValue = inpSpan.attributes['browser.web_vital.inp.value']?.value as number;
-    expect(inpValue).toBeGreaterThan(0);
-
-    const pageloadSpanId = inpSpan.parent_span_id;
-
-    expect(inpSpan).toEqual({
-      name: 'body > NormalButton',
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-      trace_id: traceId,
-      parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
-      start_timestamp: expect.any(Number),
-      end_timestamp: expect.any(Number),
-      is_segment: false,
-      status: 'ok',
-      attributes: {
-        'sentry.is_localhost': { value: false, type: 'boolean' },
-        'sentry.origin': { value: 'auto.http.browser.inp', type: 'string' },
-        'sentry.op': { value: 'ui.interaction.click', type: 'string' },
-        'ui.component_name': { value: 'NormalButton', type: 'string' },
-        'browser.web_vital.inp.target': { value: 'body > NormalButton', type: 'string' },
-        'sentry.exclusive_time': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.value': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.interaction_type': { value: 'click', type: 'string' },
-        'browser.navigation.type': { value: 'navigate', type: 'string' },
-        'sentry.transaction': { value: 'test-url', type: 'string' },
-        'sentry.segment.name': { value: 'test-url', type: 'string' },
-        'user_agent.original': { value: expect.stringContaining('Chrome'), type: 'string' },
-        'sentry.pageload.span_id': { value: pageloadSpanId, type: 'string' },
-        'sentry.trace_lifecycle': { value: 'stream', type: 'string' },
-        'sentry.segment.id': { value: pageloadSpanId, type: 'string' },
-        'sentry.sdk.name': { value: 'sentry.javascript.browser', type: 'string' },
-        'sentry.sdk.version': { value: SDK_VERSION, type: 'string' },
-        'sentry.environment': { value: 'production', type: 'string' },
-      },
-    });
-  },
-);
-
-sentryTest(
-  'chooses the slowest interaction click event when INP is triggered',
-  async ({ browserName, getLocalTestUrl, page }) => {
-    const supportedBrowsers = ['chromium'];
-
-    if (shouldSkipTracingTest() || !supportedBrowsers.includes(browserName)) {
-      sentryTest.skip();
-    }
-
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    await page.goto(url);
-
-    await page.locator('[data-test-id=normal-button]').click();
-    await page.locator('.clicked[data-test-id=normal-button]').isVisible();
-
-    await page.waitForTimeout(500);
-
-    const spanEnvelopePromise = waitForStreamedSpanEnvelope(
-      page,
-      env => !!getSpansFromEnvelope(env).find(s => getSpanOp(s) === 'ui.interaction.click'),
-    );
-
-    await page.locator('[data-test-id=slow-button]').click();
-    await page.locator('.clicked[data-test-id=slow-button]').isVisible();
-
-    await page.waitForTimeout(500);
-
-    // Page hide to trigger INP reporting
-    await hidePage(page);
-
-    const inpSpan = getSpansFromEnvelope(await spanEnvelopePromise).find(s => getSpanOp(s) === 'ui.interaction.click')!;
-
-    const inpValue = inpSpan.attributes['browser.web_vital.inp.value']?.value as number;
-    expect(inpValue).toBeGreaterThan(400);
-
-    const pageloadSpanId = inpSpan.parent_span_id;
-
-    expect(inpSpan).toEqual({
-      name: 'body > SlowButton',
-      span_id: expect.stringMatching(/^[\da-f]{16}$/),
-      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
-      start_timestamp: expect.any(Number),
-      end_timestamp: expect.any(Number),
-      is_segment: false,
-      status: 'ok',
-      attributes: {
-        'sentry.is_localhost': { value: false, type: 'boolean' },
-        'sentry.origin': { value: 'auto.http.browser.inp', type: 'string' },
-        'sentry.op': { value: 'ui.interaction.click', type: 'string' },
-        'ui.component_name': { value: 'SlowButton', type: 'string' },
-        'browser.web_vital.inp.target': { value: 'body > SlowButton', type: 'string' },
-        'sentry.exclusive_time': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.value': { value: inpValue, type: expect.stringMatching(/^(integer)|(double)$/) },
-        'browser.web_vital.inp.interaction_type': { value: 'click', type: 'string' },
-        'browser.navigation.type': { value: 'navigate', type: 'string' },
-        'sentry.transaction': { value: 'test-url', type: 'string' },
-        'sentry.segment.name': { value: 'test-url', type: 'string' },
-        'user_agent.original': { value: expect.stringContaining('Chrome'), type: 'string' },
-        'sentry.pageload.span_id': { value: pageloadSpanId, type: 'string' },
-        'sentry.trace_lifecycle': { value: 'stream', type: 'string' },
-        'sentry.segment.id': { value: pageloadSpanId, type: 'string' },
-        'sentry.sdk.name': { value: 'sentry.javascript.browser', type: 'string' },
-        'sentry.sdk.version': { value: SDK_VERSION, type: 'string' },
-        'sentry.environment': { value: 'production', type: 'string' },
-      },
-    });
-  },
-);
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
+
+sentryTest.beforeEach(async ({ browserName }) => {
+  if (shouldSkipTracingTest() || browserName !== 'chromium') {
+    sentryTest.skip();
+  }
+});
+
+sentryTest('captures INP click as a streamed span', async ({ getLocalTestUrl, page }) => {
+  const spans = collectStreamedSpans(page);
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === PAGELOAD);
+  const inpSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === UI_INTERACTION_CLICK);
+
+  await page.goto(url);
+
+  await page.locator('[data-test-id=normal-button]').click();
+  await expect(page.locator('.clicked[data-test-id=normal-button]')).toBeVisible();
+
+  await hidePage(page);
+
+  await inpSpanPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const inpSpans = spans.filter(span => getSpanOp(span) === UI_INTERACTION_CLICK);
+  expect(inpSpans).toHaveLength(1);
+  const [inpSpan] = inpSpans;
+  const pageloadSpan = await pageloadSpanPromise;
+
+  expect(inpSpan.attributes[SENTRY_OP]).toEqual({ type: 'string', value: UI_INTERACTION_CLICK });
+  expect(inpSpan.attributes[SENTRY_ORIGIN]).toEqual({ type: 'string', value: 'auto.http.browser.inp' });
+  expect(inpSpan.attributes[USER_AGENT_ORIGINAL]?.value).toEqual(expect.stringContaining('Chrome'));
+
+  // Check the INP span carries the transaction/segment name it belongs to
+  expect(inpSpan.attributes[SENTRY_TRANSACTION]).toEqual({ type: 'string', value: 'Pageload' });
+  expect(inpSpan.attributes[SENTRY_SEGMENT_NAME]).toEqual({ type: 'string', value: 'Pageload' });
+
+  const inpValue = inpSpan.attributes[BROWSER_WEB_VITAL_INP_VALUE]?.value as number;
+  expect(inpValue).toBeGreaterThan(0);
+
+  expect(inpSpan.attributes[SENTRY_EXCLUSIVE_TIME]?.value).toBeGreaterThan(0);
+
+  expect(inpSpan.name).toBe('NormalButton');
+  expect(inpSpan.attributes[UI_COMPONENT_NAME]).toEqual({ type: 'string', value: 'NormalButton' });
+  expect(inpSpan.attributes[BROWSER_WEB_VITAL_INP_TARGET]).toEqual({ type: 'string', value: 'body > NormalButton' });
+
+  expect(inpSpan.end_timestamp).toBeGreaterThan(inpSpan.start_timestamp);
+
+  expect(inpSpan.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(inpSpan.trace_id).toMatch(/^[\da-f]{32}$/);
+
+  expect(inpSpan.parent_span_id).toBe(pageloadSpan.span_id);
+  expect(inpSpan.trace_id).toBe(pageloadSpan.trace_id);
+});
+
+sentryTest('captures the slowest interaction as streamed INP span', async ({ getLocalTestUrl, page }) => {
+  const spans = collectStreamedSpans(page);
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const inpSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === UI_INTERACTION_CLICK);
+
+  await page.goto(url);
+
+  await page.locator('[data-test-id=normal-button]').click();
+  await expect(page.locator('.clicked[data-test-id=normal-button]')).toBeVisible();
+
+  await page.locator('[data-test-id=slow-button]').click();
+  await expect(page.locator('.clicked[data-test-id=slow-button]')).toBeVisible();
+
+  await hidePage(page, '[data-test-id=slow-button]');
+
+  await inpSpanPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const inpSpans = spans.filter(span => getSpanOp(span) === UI_INTERACTION_CLICK);
+  expect(inpSpans).toHaveLength(1);
+  const [inpSpan] = inpSpans;
+
+  expect(inpSpan.name).toBe('SlowButton');
+  expect(inpSpan.attributes[UI_COMPONENT_NAME]).toEqual({ type: 'string', value: 'SlowButton' });
+  expect(inpSpan.attributes[BROWSER_WEB_VITAL_INP_TARGET]).toEqual({ type: 'string', value: 'body > SlowButton' });
+  expect(inpSpan.attributes[SENTRY_EXCLUSIVE_TIME]?.value).toBeGreaterThan(400);
+
+  const inpValue = inpSpan.attributes[BROWSER_WEB_VITAL_INP_VALUE]?.value as number;
+  expect(inpValue).toBeGreaterThan(400);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/assets/sentry-logo-600x179.png b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/assets/sentry-logo-600x179.png
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/assets/sentry-logo-600x179.png
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/assets/sentry-logo-600x179.png
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/init.js
new file mode 100644
index 000000000000..bb6d4918d1bf
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/template.html b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/template.html
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/template.html
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/template.html
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/test.ts
new file mode 100644
index 000000000000..3c0b3c5af990
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/test.ts
@@ -0,0 +1,42 @@
+import { PAGELOAD } from '@sentry/conventions/op';
+import type { Route } from '@playwright/test';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  shouldSkipTracingTest,
+  waitForLcpCandidate,
+  waitForTransactionRequest,
+} from '../../../../utils/helpers';
+
+sentryTest('captures LCP vitals with element details', async ({ browserName, getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest() || browserName !== 'chromium') {
+    sentryTest.skip();
+  }
+
+  page.route('**', route => route.continue());
+  page.route('**/my/image.png', async (route: Route) => {
+    return route.fulfill({
+      path: `${__dirname}/assets/sentry-logo-600x179.png`,
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const eventPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+  await page.goto(url);
+  await waitForLcpCandidate(page, 'img');
+  await page.click('body');
+  const eventData = envelopeRequestParser<Event>(await eventPromise);
+
+  expect(eventData.measurements).toBeDefined();
+  expect(eventData.measurements?.lcp?.value).toBeDefined();
+
+  expect(eventData.contexts?.trace?.data?.['lcp.element'].startsWith('body >')).toBe(true);
+  expect(eventData.contexts?.trace?.data?.['lcp.size']).toBeGreaterThan(0);
+  expect(eventData.contexts?.trace?.data?.['lcp.loadTime']).toBeGreaterThan(0);
+  expect(eventData.contexts?.trace?.data?.['lcp.renderTime']).toBeGreaterThan(0);
+
+  // The LCP value should be the renderTime because the renderTime is set
+  expect(eventData.measurements?.lcp?.value).toBeCloseTo(eventData.contexts?.trace?.data?.['lcp.renderTime']);
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/init.js
deleted file mode 100644
index bd3b6ed17872..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/init.js
+++ /dev/null
@@ -1,11 +0,0 @@
-import * as Sentry from '@sentry/browser';
-
-window.Sentry = Sentry;
-window._testBaseTimestamp = performance.timeOrigin / 1000;
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
-  traceLifecycle: 'stream',
-  tracesSampleRate: 1,
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/test.ts
deleted file mode 100644
index 57a2d907eeb0..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-streamed-spans/test.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-import type { Route } from '@playwright/test';
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
-
-sentryTest.beforeEach(async ({ browserName, page }) => {
-  if (shouldSkipTracingTest() || browserName !== 'chromium') {
-    sentryTest.skip();
-  }
-
-  await page.setViewportSize({ width: 800, height: 1200 });
-});
-
-sentryTest('captures LCP as a streamed span with element attributes', async ({ getLocalTestUrl, page }) => {
-  page.route('**', route => route.continue());
-  page.route('**/my/image.png', async (route: Route) => {
-    return route.fulfill({
-      path: `${__dirname}/assets/sentry-logo-600x179.png`,
-    });
-  });
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const lcpSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.webvital.lcp');
-  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-
-  await page.goto(url);
-
-  // Wait for LCP to be captured
-  await page.waitForTimeout(1000);
-
-  // LCP finalizes on the first trusted input or visibility change, and web-vitals checks
-  // `isTrusted`, so a synthetically dispatched `visibilitychange` does not finalize it. Click to
-  // finalize the way a real user would.
-  await page.click('body');
-
-  const lcpSpan = await lcpSpanPromise;
-  const pageloadSpan = await pageloadSpanPromise;
-
-  expect(lcpSpan.attributes['sentry.op']).toEqual({ type: 'string', value: 'ui.webvital.lcp' });
-  expect(lcpSpan.attributes['sentry.origin']).toEqual({ type: 'string', value: 'auto.http.browser.lcp' });
-  expect(lcpSpan.attributes['sentry.exclusive_time']).toEqual({ type: 'integer', value: 0 });
-  expect(lcpSpan.attributes['user_agent.original']?.value).toEqual(expect.stringContaining('Chrome'));
-
-  // Check the LCP span carries the segment name it belongs to
-  expect(lcpSpan.attributes['sentry.segment.name']).toEqual({ type: 'string', value: 'Pageload' });
-
-  // Check browser.web_vital.lcp.* attributes
-  expect(lcpSpan.attributes['browser.web_vital.lcp.element']?.value).toEqual(expect.stringContaining('body > img'));
-  expect(lcpSpan.attributes['browser.web_vital.lcp.url']?.value).toBe('https://sentry-test-site.example/my/image.png');
-  expect(lcpSpan.attributes['browser.web_vital.lcp.size']?.value).toEqual(expect.any(Number));
-
-  // Check web vital value attribute
-  expect(lcpSpan.attributes['browser.web_vital.lcp.value']?.type).toMatch(/^(double)|(integer)$/);
-  expect(lcpSpan.attributes['browser.web_vital.lcp.value']?.value).toBeGreaterThan(0);
-
-  // Check pageload span id is present
-  expect(lcpSpan.attributes['sentry.pageload.span_id']?.value).toBe(pageloadSpan.span_id);
-
-  // Span should have meaningful duration (navigation start -> LCP event)
-  expect(lcpSpan.end_timestamp).toBeGreaterThan(lcpSpan.start_timestamp);
-
-  expect(lcpSpan.span_id).toMatch(/^[\da-f]{16}$/);
-  expect(lcpSpan.trace_id).toMatch(/^[\da-f]{32}$/);
-
-  expect(lcpSpan.parent_span_id).toBe(pageloadSpan.span_id);
-  expect(lcpSpan.trace_id).toBe(pageloadSpan.trace_id);
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp/init.js
similarity index 65%
rename from dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp/init.js
index bd3b6ed17872..1f0b64911a75 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-cls-streamed-spans/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp/init.js
@@ -5,7 +5,6 @@ window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
-  traceLifecycle: 'stream',
+  integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp/test.ts
index 4d61904c58ac..263b31d96660 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp/test.ts
@@ -1,14 +1,32 @@
+import {
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_EXCLUSIVE_TIME,
+  USER_AGENT_ORIGINAL,
+  SENTRY_SEGMENT_NAME,
+  BROWSER_WEB_VITAL_LCP_ELEMENT,
+  BROWSER_WEB_VITAL_LCP_URL,
+  BROWSER_WEB_VITAL_LCP_SIZE,
+  BROWSER_WEB_VITAL_LCP_VALUE,
+  BROWSER_WEB_VITAL_LCP_RENDER_TIME,
+  BROWSER_WEB_VITAL_LCP_LOAD_TIME,
+  SENTRY_PAGELOAD_SPAN_ID,
+} from '@sentry/conventions/attributes';
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest, waitForLcpCandidate } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest('captures LCP vitals with element details', async ({ browserName, getLocalTestUrl, page }) => {
+sentryTest.beforeEach(async ({ browserName, page }) => {
   if (shouldSkipTracingTest() || browserName !== 'chromium') {
     sentryTest.skip();
   }
 
+  await page.setViewportSize({ width: 800, height: 1200 });
+});
+
+sentryTest('captures LCP as a streamed span with element attributes', async ({ getLocalTestUrl, page }) => {
   page.route('**', route => route.continue());
   page.route('**/my/image.png', async (route: Route) => {
     return route.fulfill({
@@ -17,16 +35,53 @@ sentryTest('captures LCP vitals with element details', async ({ browserName, get
   });
 
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const [eventData] = await Promise.all([getFirstSentryEnvelopeRequest<Event>(page), page.goto(url)]);
 
-  expect(eventData.measurements).toBeDefined();
-  expect(eventData.measurements?.lcp?.value).toBeDefined();
+  const lcpSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.webvital.lcp');
+  const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+
+  await page.goto(url);
+
+  await waitForLcpCandidate(page, 'img');
+
+  // LCP finalizes on the first trusted input or visibility change, and web-vitals checks
+  // `isTrusted`, so a synthetically dispatched `visibilitychange` does not finalize it. Click to
+  // finalize the way a real user would.
+  await page.click('body');
+
+  const lcpSpan = await lcpSpanPromise;
+  const pageloadSpan = await pageloadSpanPromise;
+
+  expect(lcpSpan.attributes[SENTRY_OP]).toEqual({ type: 'string', value: 'ui.webvital.lcp' });
+  expect(lcpSpan.attributes[SENTRY_ORIGIN]).toEqual({ type: 'string', value: 'auto.http.browser.lcp' });
+  expect(lcpSpan.attributes[SENTRY_EXCLUSIVE_TIME]).toEqual({ type: 'integer', value: 0 });
+  expect(lcpSpan.attributes[USER_AGENT_ORIGINAL]?.value).toEqual(expect.stringContaining('Chrome'));
+
+  // Check the LCP span carries the segment name it belongs to
+  expect(lcpSpan.attributes[SENTRY_SEGMENT_NAME]).toEqual({ type: 'string', value: 'Pageload' });
+
+  // Check browser.web_vital.lcp.* attributes
+  expect(lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_ELEMENT]?.value).toEqual(expect.stringContaining('body > img'));
+  expect(lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_URL]?.value).toBe('https://sentry-test-site.example/my/image.png');
+  expect(lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_SIZE]?.value).toEqual(expect.any(Number));
+
+  // Check web vital value attribute
+  expect(lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_VALUE]?.type).toMatch(/^(double)|(integer)$/);
+  expect(lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_VALUE]?.value).toBeGreaterThan(0);
+
+  const renderTime = lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_RENDER_TIME]?.value as number;
+  expect(renderTime).toBeGreaterThan(0);
+  expect(lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_LOAD_TIME]?.value).toBeGreaterThan(0);
+  expect(lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_VALUE]?.value).toBeCloseTo(renderTime);
+
+  // Check pageload span id is present
+  expect(lcpSpan.attributes[SENTRY_PAGELOAD_SPAN_ID]?.value).toBe(pageloadSpan.span_id);
+
+  // Span should have meaningful duration (navigation start -> LCP event)
+  expect(lcpSpan.end_timestamp).toBeGreaterThan(lcpSpan.start_timestamp);
 
-  expect(eventData.contexts?.trace?.data?.['lcp.element'].startsWith('body >')).toBe(true);
-  expect(eventData.contexts?.trace?.data?.['lcp.size']).toBeGreaterThan(0);
-  expect(eventData.contexts?.trace?.data?.['lcp.loadTime']).toBeGreaterThan(0);
-  expect(eventData.contexts?.trace?.data?.['lcp.renderTime']).toBeGreaterThan(0);
+  expect(lcpSpan.span_id).toMatch(/^[\da-f]{16}$/);
+  expect(lcpSpan.trace_id).toMatch(/^[\da-f]{32}$/);
 
-  // The LCP value should be the renderTime because the renderTime is set
-  expect(eventData.measurements?.lcp?.value).toBeCloseTo(eventData.contexts?.trace?.data?.['lcp.renderTime']);
+  expect(lcpSpan.parent_span_id).toBe(pageloadSpan.span_id);
+  expect(lcpSpan.trace_id).toBe(pageloadSpan.trace_id);
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/init.js
new file mode 100644
index 000000000000..bb6d4918d1bf
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/template.html b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/template.html
new file mode 100644
index 000000000000..b81f11e967e3
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/template.html
@@ -0,0 +1,9 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <div>Rendered</div>
+  </body>
+</html>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/test.ts
new file mode 100644
index 000000000000..ed0a9adf9132
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-static/test.ts
@@ -0,0 +1,28 @@
+import { PAGELOAD } from '@sentry/conventions/op';
+import { TTFB_REQUESTTIME } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest('should capture TTFB vital.', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const pageloadPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+  await page.goto(url);
+  const eventData = envelopeRequestParser<Event>(await pageloadPromise);
+
+  expect(eventData.measurements).toBeDefined();
+
+  // If responseStart === 0, ttfb is not reported
+  // This seems to happen somewhat randomly, so we just ignore this in that case
+  const responseStart = await page.evaluate("performance.getEntriesByType('navigation')[0].responseStart;");
+  if (responseStart !== 0) {
+    expect(eventData.measurements?.ttfb?.value).toBeDefined();
+  }
+
+  expect(eventData.measurements?.[TTFB_REQUESTTIME]?.value).toBeDefined();
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-streamed/test.ts
deleted file mode 100644
index 4a51ad0f6948..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-streamed/test.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
-
-sentryTest.beforeEach(async ({ page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
-
-  await page.setViewportSize({ width: 800, height: 1200 });
-});
-
-sentryTest(
-  'captures TTFB and TTFB request time as attributes on the streamed pageload span',
-  async ({ getLocalTestUrl, page }) => {
-    const url = await getLocalTestUrl({ testDir: __dirname });
-
-    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
-
-    await page.goto(url);
-    await hidePage(page);
-
-    const pageloadSpan = await pageloadSpanPromise;
-
-    // If responseStart === 0, TTFB is not reported.
-    // This seems to happen somewhat randomly, so we handle it.
-    const responseStart = await page.evaluate("performance.getEntriesByType('navigation')[0].responseStart;");
-    if (responseStart !== 0) {
-      expect(pageloadSpan.attributes['browser.web_vital.ttfb.value']?.type).toMatch(/^(double)|(integer)$/);
-      expect(pageloadSpan.attributes['browser.web_vital.ttfb.value']?.value).toBeGreaterThan(0);
-    }
-
-    expect(pageloadSpan.attributes['browser.web_vital.ttfb.request_time']?.type).toMatch(/^(double)|(integer)$/);
-  },
-);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb/init.js
similarity index 66%
rename from dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb/init.js
index d8da96d88a64..a9df1902a276 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb/init.js
@@ -5,8 +5,7 @@ window._testBaseTimestamp = performance.timeOrigin / 1000;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
-  traceLifecycle: 'stream',
+  integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
   debug: true,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb/test.ts
index d2997f712c39..7c5693468874 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-ttfb/test.ts
@@ -1,24 +1,37 @@
+import { BROWSER_WEB_VITAL_TTFB_VALUE, BROWSER_WEB_VITAL_TTFB_REQUEST_TIME } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { hidePage, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest('should capture TTFB vital.', async ({ getLocalTestUrl, page }) => {
+sentryTest.beforeEach(async ({ page }) => {
   if (shouldSkipTracingTest()) {
     sentryTest.skip();
   }
 
-  const url = await getLocalTestUrl({ testDir: __dirname });
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  await page.setViewportSize({ width: 800, height: 1200 });
+});
 
-  expect(eventData.measurements).toBeDefined();
+sentryTest(
+  'captures TTFB and TTFB request time as attributes on the streamed pageload span',
+  async ({ getLocalTestUrl, page }) => {
+    const url = await getLocalTestUrl({ testDir: __dirname });
 
-  // If responseStart === 0, ttfb is not reported
-  // This seems to happen somewhat randomly, so we just ignore this in that case
-  const responseStart = await page.evaluate("performance.getEntriesByType('navigation')[0].responseStart;");
-  if (responseStart !== 0) {
-    expect(eventData.measurements?.ttfb?.value).toBeDefined();
-  }
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
 
-  expect(eventData.measurements?.['ttfb.requestTime']?.value).toBeDefined();
-});
+    await page.goto(url);
+    await hidePage(page);
+
+    const pageloadSpan = await pageloadSpanPromise;
+
+    // If responseStart === 0, TTFB is not reported.
+    // This seems to happen somewhat randomly, so we handle it.
+    const responseStart = await page.evaluate("performance.getEntriesByType('navigation')[0].responseStart;");
+    if (responseStart !== 0) {
+      expect(pageloadSpan.attributes[BROWSER_WEB_VITAL_TTFB_VALUE]?.type).toMatch(/^(double)|(integer)$/);
+      expect(pageloadSpan.attributes[BROWSER_WEB_VITAL_TTFB_VALUE]?.value).toBeGreaterThan(0);
+    }
+
+    expect(pageloadSpan.attributes[BROWSER_WEB_VITAL_TTFB_REQUEST_TIME]?.type).toMatch(/^(double)|(integer)$/);
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals/test.ts
index 751a7111ce54..7b1c241dee2d 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals/test.ts
@@ -1,8 +1,16 @@
+import {
+  BROWSER_WEB_VITAL_TTFB_VALUE,
+  BROWSER_WEB_VITAL_LCP_VALUE,
+  BROWSER_WEB_VITAL_FCP_VALUE,
+  BROWSER_WEB_VITAL_FP_VALUE,
+  BROWSER_PERFORMANCE_TIME_ORIGIN,
+  BROWSER_PERFORMANCE_NAVIGATION_ACTIVATION_START,
+} from '@sentry/conventions/attributes';
 import type { Route } from '@playwright/test';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest, waitForLcpCandidate } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 /**
  * Bit of an odd test but we previously ran into cases where we would report TTFB > (LCP, FCP, FP)
@@ -23,15 +31,14 @@ sentryTest('paint web vitals values are greater than TTFB', async ({ browserName
   });
 
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const [eventData] = await Promise.all([
-    getFirstSentryEnvelopeRequest<Event>(page),
-    page.goto(url),
-    page.locator('button').click(),
-  ]);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
+  const lcpPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'ui.webvital.lcp');
+  await page.goto(url);
+  await waitForLcpCandidate(page, 'img');
+  await page.locator('button').click();
+  const [eventData, lcpSpan] = await Promise.all([pageloadPromise, lcpPromise]);
 
-  expect(eventData.measurements).toBeDefined();
-
-  const ttfbValue = eventData.measurements?.ttfb?.value;
+  const ttfbValue = eventData.attributes[BROWSER_WEB_VITAL_TTFB_VALUE]?.value as number | undefined;
 
   if (!ttfbValue) {
     // TTFB is unfortunately quite flaky. Sometimes, the web-vitals library doesn't report TTFB because
@@ -44,9 +51,9 @@ sentryTest('paint web vitals values are greater than TTFB', async ({ browserName
     sentryTest.skip();
   }
 
-  const lcpValue = eventData.measurements?.lcp?.value;
-  const fcpValue = eventData.measurements?.fcp?.value;
-  const fpValue = eventData.measurements?.fp?.value;
+  const lcpValue = lcpSpan.attributes[BROWSER_WEB_VITAL_LCP_VALUE]?.value;
+  const fcpValue = eventData.attributes[BROWSER_WEB_VITAL_FCP_VALUE]?.value;
+  const fpValue = eventData.attributes[BROWSER_WEB_VITAL_FP_VALUE]?.value;
 
   expect(lcpValue).toBeDefined();
   expect(fcpValue).toBeDefined();
@@ -67,17 +74,20 @@ sentryTest(
     }
 
     const url = await getLocalTestUrl({ testDir: __dirname });
-    const [eventData] = await Promise.all([getFirstSentryEnvelopeRequest<Event>(page), page.goto(url)]);
+    const [eventData] = await Promise.all([
+      waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload'),
+      page.goto(url),
+    ]);
 
-    const timeOriginAttribute = eventData.contexts?.trace?.data?.['performance.timeOrigin'];
-    const activationStart = eventData.contexts?.trace?.data?.['performance.activationStart'];
+    const timeOriginAttribute = eventData.attributes[BROWSER_PERFORMANCE_TIME_ORIGIN]?.value as number;
+    const activationStart = eventData.attributes[BROWSER_PERFORMANCE_NAVIGATION_ACTIVATION_START]?.value;
 
-    const transactionStartTimestamp = eventData.start_timestamp;
+    const spanStartTimestamp = eventData.start_timestamp;
 
     expect(timeOriginAttribute).toBeDefined();
-    expect(transactionStartTimestamp).toBeDefined();
+    expect(spanStartTimestamp).toBeDefined();
 
-    const delta = Math.abs(transactionStartTimestamp! - timeOriginAttribute);
+    const delta = Math.abs(spanStartTimestamp! - timeOriginAttribute);
 
     // The delta should be less than 1ms if this flakes, we should increase the threshold
     expect(delta).toBeLessThanOrEqual(1);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-data-url/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-data-url/init.js
index d1c5e9767aa2..5ab240338c8c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-data-url/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-data-url/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-data-url/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-data-url/test.ts
index 2e79255e3993..251536177d0c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-data-url/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-data-url/test.ts
@@ -1,34 +1,28 @@
+import { HTTP_REQUEST_METHOD, URL_FULL } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  shouldSkipTracingTest,
-  waitForTransactionRequestOnUrl,
-} from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('sanitizes data URLs in fetch span name and attributes', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
-
+  sentryTest.skip(shouldSkipTracingTest());
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
   const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const req = await waitForTransactionRequestOnUrl(page, url);
-  const transactionEvent = envelopeRequestParser(req);
-
-  const requestSpans = transactionEvent.spans?.filter(({ op }) => op === 'http.client');
-
-  expect(requestSpans).toHaveLength(1);
-
-  const span = requestSpans?.[0];
-
-  const sanitizedUrl = 'data:text/plain,base64,SGVsbG8gV2... [truncated]';
-  expect(span?.description).toBe(`GET ${sanitizedUrl}`);
-
-  expect(span?.data).toMatchObject({
-    'http.request.method': 'GET',
-    type: 'fetch',
+  await page.goto(url);
+  const pageload = await pageloadPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+
+  const requests = spans.filter(span => getSpanOp(span) === 'http.client');
+  expect(requests).toHaveLength(1);
+  const span = requests[0];
+  expect(span.name).toBe('GET');
+  expect(span.parent_span_id).toBe(pageload.span_id);
+  expect(span.trace_id).toBe(pageload.trace_id);
+  expect(span.attributes[HTTP_REQUEST_METHOD]).toEqual({ type: 'string', value: 'GET' });
+  expect(span.attributes.type).toEqual({ type: 'string', value: 'fetch' });
+  expect(span.attributes[URL_FULL]).toEqual({
+    type: 'string',
+    value: 'data:text/plain,base64,SGVsbG8gV2... [truncated]',
   });
-
-  expect(span?.data?.['url.full']).toBe(sanitizedUrl);
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-immediate/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-immediate/init.js
index 1ad638ebeadb..0a301839c169 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-immediate/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-immediate/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-immediate/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-immediate/test.ts
index f43ff5448679..a8f7e77be1c8 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-immediate/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-immediate/test.ts
@@ -1,10 +1,8 @@
+import { HTTP_REQUEST_METHOD, URL_FULL, SERVER_ADDRESS } from '@sentry/conventions/attributes';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  shouldSkipTracingTest,
-  waitForTransactionRequestOnUrl,
-} from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
 
 sentryTest('should create spans for fetch requests called directly after init', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
@@ -15,25 +13,28 @@ sentryTest('should create spans for fetch requests called directly after init',
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const req = await waitForTransactionRequestOnUrl(page, url);
-  const tracingEvent = envelopeRequestParser(req);
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
+  await page.goto(url);
+  const pageload = await pageloadPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-  const requestSpans = tracingEvent.spans?.filter(({ op }) => op === 'http.client');
+  const requestSpans = spans.filter(span => getSpanOp(span) === 'http.client');
 
   expect(requestSpans).toHaveLength(1);
 
   expect(requestSpans![0]).toMatchObject({
-    description: 'GET http://sentry-test-site.example/0',
-    parent_span_id: tracingEvent.contexts?.trace?.span_id,
+    name: 'GET sentry-test-site.example',
+    parent_span_id: pageload.span_id,
     span_id: expect.stringMatching(/[a-f\d]{16}/),
     start_timestamp: expect.any(Number),
-    timestamp: expect.any(Number),
-    trace_id: tracingEvent.contexts?.trace?.trace_id,
-    data: {
-      'http.request.method': 'GET',
-      'url.full': 'http://sentry-test-site.example/0',
-      'server.address': 'sentry-test-site.example',
-      type: 'fetch',
-    },
+    end_timestamp: expect.any(Number),
+    trace_id: pageload.trace_id,
+    attributes: expect.objectContaining({
+      [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+      [URL_FULL]: { type: 'string', value: 'http://sentry-test-site.example/0' },
+      [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
+      type: { type: 'string', value: 'fetch' },
+    }),
   });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/init.js
index 2db7a75be0e6..3cbcaa4fe152 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-no-tracing/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracePropagationTargets: ['http://sentry-test-site.example'],
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-propagateTraceparent/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-propagateTraceparent/init.js
index efcc9dde33fa..cb785bbf7fda 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-propagateTraceparent/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-propagateTraceparent/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/init.js
new file mode 100644
index 000000000000..bb6d4918d1bf
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/subject.js
new file mode 100644
index 000000000000..b0d4abc78c65
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/subject.js
@@ -0,0 +1,3 @@
+fetch('/test-req/0').then(
+  fetch('/test-req/1', { headers: { 'X-Test-Header': 'existing-header' } }).then(fetch('/test-req/2')),
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/test.ts
new file mode 100644
index 000000000000..704b986d9550
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-static/test.ts
@@ -0,0 +1,78 @@
+import { HTTP_REQUEST_METHOD, URL_FULL, SERVER_ADDRESS } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { sentryTest, TEST_HOST } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  shouldSkipTracingTest,
+  waitForTransactionRequestOnUrl,
+} from '../../../../utils/helpers';
+
+sentryTest('should create spans for fetch requests', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const req = await waitForTransactionRequestOnUrl(page, url);
+  const tracingEvent = envelopeRequestParser(req);
+
+  const requestSpans = tracingEvent.spans?.filter(({ op }) => op === 'http.client');
+
+  expect(requestSpans).toHaveLength(3);
+
+  requestSpans?.forEach((span, index) =>
+    expect(span).toMatchObject({
+      description: `GET /test-req/${index}`,
+      parent_span_id: tracingEvent.contexts?.trace?.span_id,
+      span_id: expect.stringMatching(/[a-f\d]{16}/),
+      start_timestamp: expect.any(Number),
+      timestamp: expect.any(Number),
+      trace_id: tracingEvent.contexts?.trace?.trace_id,
+      data: {
+        [HTTP_REQUEST_METHOD]: 'GET',
+        [URL_FULL]: `${TEST_HOST}/test-req/${index}`,
+        [SERVER_ADDRESS]: 'sentry-test.io',
+        type: 'fetch',
+      },
+    }),
+  );
+});
+
+sentryTest('should attach `sentry-trace` header to fetch requests', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const requests = (
+    await Promise.all([
+      page.goto(url),
+      Promise.all([0, 1, 2].map(idx => page.waitForRequest(`${TEST_HOST}/test-req/${idx}`))),
+    ])
+  )[1];
+
+  expect(requests).toHaveLength(3);
+
+  const request1 = requests[0];
+  const requestHeaders1 = request1.headers();
+  expect(requestHeaders1).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+  });
+
+  const request2 = requests[1];
+  const requestHeaders2 = request2.headers();
+  expect(requestHeaders2).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+    'x-test-header': 'existing-header',
+  });
+
+  const request3 = requests[2];
+  const requestHeaders3 = request3.headers();
+  expect(requestHeaders3).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-streamed/subject.js
deleted file mode 100644
index 143b078692db..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-streamed/subject.js
+++ /dev/null
@@ -1 +0,0 @@
-fetch('/test-req/0').then(fetch('/test-req/1').then(fetch('/test-req/2')));
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-streamed/test.ts
deleted file mode 100644
index 820103bac06e..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url-streamed/test.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest, TEST_HOST } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest('names spans for relative fetch requests after the page domain', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const spansPromise = waitForStreamedSpans(
-    page,
-    spans => spans.filter(s => getSpanOp(s) === 'http.client').length >= 3,
-  );
-
-  await page.goto(url);
-
-  const requestSpans = (await spansPromise)
-    .filter(s => getSpanOp(s) === 'http.client')
-    .sort((a, b) =>
-      (a.attributes!['url.full']!.value as string).localeCompare(b.attributes!['url.full']!.value as string),
-    );
-
-  expect(requestSpans).toHaveLength(3);
-
-  requestSpans.forEach((span, index) =>
-    expect(span).toMatchObject({
-      // A relative URL has no domain of its own, so it resolves against the page origin.
-      name: 'GET sentry-test.io',
-      attributes: expect.objectContaining({
-        'http.request.method': { type: 'string', value: 'GET' },
-        'url.full': { type: 'string', value: `${TEST_HOST}/test-req/${index}` },
-        'url.domain': { type: 'string', value: 'sentry-test.io' },
-        'server.address': { type: 'string', value: 'sentry-test.io' },
-        type: { type: 'string', value: 'fetch' },
-      }),
-    }),
-  );
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url/init.js
index bb6d4918d1bf..5ab240338c8c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url/init.js
@@ -3,8 +3,8 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
+  autoSessionTracking: false,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url/test.ts
index 323060c7e4b2..8c7335957673 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-relative-url/test.ts
@@ -1,38 +1,40 @@
+import { URL_FULL, HTTP_REQUEST_METHOD, URL_DOMAIN, SERVER_ADDRESS } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest, TEST_HOST } from '../../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  shouldSkipTracingTest,
-  waitForTransactionRequestOnUrl,
-} from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest('should create spans for fetch requests', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+sentryTest('names spans for relative fetch requests after the page domain', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const req = await waitForTransactionRequestOnUrl(page, url);
-  const tracingEvent = envelopeRequestParser(req);
 
-  const requestSpans = tracingEvent.spans?.filter(({ op }) => op === 'http.client');
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
+
+  await page.goto(url);
+
+  const pageloadSpan = await pageloadPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const requestSpans = spans
+    .filter(s => getSpanOp(s) === 'http.client')
+    .sort((a, b) => (a.attributes![URL_FULL]!.value as string).localeCompare(b.attributes![URL_FULL]!.value as string));
 
   expect(requestSpans).toHaveLength(3);
 
-  requestSpans?.forEach((span, index) =>
+  requestSpans.forEach((span, index) =>
     expect(span).toMatchObject({
-      description: `GET /test-req/${index}`,
-      parent_span_id: tracingEvent.contexts?.trace?.span_id,
-      span_id: expect.stringMatching(/[a-f\d]{16}/),
-      start_timestamp: expect.any(Number),
-      timestamp: expect.any(Number),
-      trace_id: tracingEvent.contexts?.trace?.trace_id,
-      data: {
-        'http.request.method': 'GET',
-        'url.full': `${TEST_HOST}/test-req/${index}`,
-        'server.address': 'sentry-test.io',
-        type: 'fetch',
-      },
+      // A relative URL has no domain of its own, so it resolves against the page origin.
+      name: 'GET sentry-test.io',
+      parent_span_id: pageloadSpan.span_id,
+      trace_id: pageloadSpan.trace_id,
+      attributes: expect.objectContaining({
+        [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+        [URL_FULL]: { type: 'string', value: `${TEST_HOST}/test-req/${index}` },
+        [URL_DOMAIN]: { type: 'string', value: 'sentry-test.io' },
+        [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test.io' },
+        type: { type: 'string', value: 'fetch' },
+      }),
     }),
   );
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-static/init.js
similarity index 74%
rename from dev-packages/browser-integration-tests/suites/tracing/request/xhr-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/request/fetch-static/init.js
index c4c8791cf32c..847df632b642 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-static/init.js
@@ -3,8 +3,9 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
+  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
   tracesSampleRate: 1,
   autoSessionTracking: false,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-static/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/request/fetch-static/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-static/test.ts
new file mode 100644
index 000000000000..bb8c594ffd42
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-static/test.ts
@@ -0,0 +1,87 @@
+import { HTTP_REQUEST_METHOD, URL_FULL, SERVER_ADDRESS } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  shouldSkipTracingTest,
+  waitForTransactionRequestOnUrl,
+} from '../../../../utils/helpers';
+
+sentryTest('should create spans for fetch requests', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  await page.route('http://sentry-test-site.example/*', route => route.fulfill({ body: 'ok' }));
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const req = await waitForTransactionRequestOnUrl(page, url);
+  const tracingEvent = envelopeRequestParser(req);
+
+  const requestSpans = tracingEvent.spans?.filter(({ op }) => op === 'http.client');
+
+  expect(requestSpans).toHaveLength(3);
+
+  requestSpans?.forEach((span, index) =>
+    expect(span).toMatchObject({
+      description: `GET http://sentry-test-site.example/${index}`,
+      parent_span_id: tracingEvent.contexts?.trace?.span_id,
+      span_id: expect.stringMatching(/[a-f\d]{16}/),
+      start_timestamp: expect.any(Number),
+      timestamp: expect.any(Number),
+      trace_id: tracingEvent.contexts?.trace?.trace_id,
+      data: {
+        [HTTP_REQUEST_METHOD]: 'GET',
+        [URL_FULL]: `http://sentry-test-site.example/${index}`,
+        [SERVER_ADDRESS]: 'sentry-test-site.example',
+        type: 'fetch',
+      },
+    }),
+  );
+});
+
+sentryTest('attaches `sentry-trace` and `baggage` headers to fetch requests', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  await page.route('http://sentry-test-site.example/*', route => route.fulfill({ body: 'ok' }));
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const requests = (
+    await Promise.all([
+      page.goto(url),
+      Promise.all([0, 1, 2].map(idx => page.waitForRequest(`http://sentry-test-site.example/${idx}`))),
+    ])
+  )[1];
+
+  expect(requests).toHaveLength(3);
+
+  const request1 = requests[0];
+  const requestHeaders1 = request1.headers();
+  expect(requestHeaders1).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+  });
+  // traceparent must only be attached if propagateTraceparent is `true`
+  expect(requestHeaders1).not.toHaveProperty('traceparent');
+
+  const request2 = requests[1];
+  const requestHeaders2 = request2.headers();
+  expect(requestHeaders2).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+    'x-test-header': 'existing-header',
+  });
+  expect(requestHeaders2).not.toHaveProperty('traceparent');
+
+  const request3 = requests[2];
+  const requestHeaders3 = request3.headers();
+  expect(requestHeaders3).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+  });
+  expect(requestHeaders3).not.toHaveProperty('traceparent');
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed/test.ts
deleted file mode 100644
index 484a7151de1f..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed/test.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest('creates spans for fetch requests', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  await page.route('http://sentry-test-site.example/*', route => route.fulfill({ body: 'ok' }));
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const spansPromise = waitForStreamedSpans(
-    page,
-    spans => spans.filter(s => getSpanOp(s) === 'http.client').length >= 3,
-  );
-
-  await page.goto(url);
-
-  const allSpans = await spansPromise;
-  const pageloadSpan = allSpans.find(s => getSpanOp(s) === 'pageload');
-  const requestSpans = allSpans
-    .filter(s => getSpanOp(s) === 'http.client')
-    .sort((a, b) =>
-      (a.attributes!['url.full']!.value as string).localeCompare(b.attributes!['url.full']!.value as string),
-    );
-
-  expect(requestSpans).toHaveLength(3);
-
-  requestSpans.forEach((span, index) =>
-    expect(span).toMatchObject({
-      // Streamed span names drop the high-cardinality URL path.
-      name: 'GET sentry-test-site.example',
-      parent_span_id: pageloadSpan?.span_id,
-      span_id: expect.stringMatching(/[a-f\d]{16}/),
-      start_timestamp: expect.any(Number),
-      end_timestamp: expect.any(Number),
-      trace_id: pageloadSpan?.trace_id,
-      attributes: expect.objectContaining({
-        'http.request.method': { type: 'string', value: 'GET' },
-        'url.full': { type: 'string', value: `http://sentry-test-site.example/${index}` },
-        'url.domain': { type: 'string', value: 'sentry-test-site.example' },
-        'server.address': { type: 'string', value: 'sentry-test-site.example' },
-        type: { type: 'string', value: 'fetch' },
-      }),
-    }),
-  );
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-strip-query-and-fragment/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-strip-query-and-fragment/init.js
index d334f6a7d2a6..de6b87574482 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-strip-query-and-fragment/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-strip-query-and-fragment/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration({ instrumentPageLoad: false, instrumentNavigation: false })],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-strip-query-and-fragment/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-strip-query-and-fragment/test.ts
index bbe15d81429f..534f784d5e60 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-strip-query-and-fragment/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-strip-query-and-fragment/test.ts
@@ -1,6 +1,19 @@
+import { HTTP_CLIENT } from '@sentry/conventions/op';
+import {
+  HTTP_REQUEST_METHOD,
+  URL_FULL,
+  URL_QUERY,
+  HTTP_RESPONSE_STATUS_CODE,
+  HTTP_RESPONSE_BODY_SIZE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SERVER_ADDRESS,
+  URL_FRAGMENT,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('strips query params in fetch request spans', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
@@ -13,35 +26,34 @@ sentryTest('strips query params in fetch request spans', async ({ getLocalTestUr
 
   await page.goto(url);
 
-  const txnPromise = waitForTransactionRequest(page);
+  const rootPromise = waitForStreamedSpan(page, span => span.is_segment && span.name === 'rootSpan');
+  const requestPromise = waitForStreamedSpan(page, span => getSpanOp(span) === HTTP_CLIENT);
   await page.locator('#btnQuery').click();
-  const transactionEvent = envelopeRequestParser(await txnPromise);
+  const [rootSpan, requestSpan] = await Promise.all([rootPromise, requestPromise]);
 
-  expect(transactionEvent.transaction).toEqual('rootSpan');
-
-  const requestSpan = transactionEvent.spans?.find(({ op }) => op === 'http.client');
+  expect(rootSpan.name).toBe('rootSpan');
 
   expect(requestSpan).toMatchObject({
-    description: 'GET http://sentry-test-site.example/0',
-    parent_span_id: transactionEvent.contexts?.trace?.span_id,
+    name: 'GET sentry-test-site.example',
+    parent_span_id: rootSpan.span_id,
     span_id: expect.stringMatching(/[a-f\d]{16}/),
     start_timestamp: expect.any(Number),
-    timestamp: expect.any(Number),
-    trace_id: transactionEvent.contexts?.trace?.trace_id,
-    data: expect.objectContaining({
-      'http.request.method': 'GET',
-      'url.full': 'http://sentry-test-site.example/0?id=123;page=5',
-      'url.query': 'id=123;page=5',
-      'http.response.status_code': 200,
-      'http.response.body.size': 2,
-      'sentry.op': 'http.client',
-      'sentry.origin': 'auto.http.browser',
-      type: 'fetch',
-      'server.address': 'sentry-test-site.example',
+    end_timestamp: expect.any(Number),
+    trace_id: rootSpan.trace_id,
+    attributes: expect.objectContaining({
+      [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+      [URL_FULL]: { type: 'string', value: 'http://sentry-test-site.example/0?id=123;page=5' },
+      [URL_QUERY]: { type: 'string', value: 'id=123;page=5' },
+      [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+      [HTTP_RESPONSE_BODY_SIZE]: { type: 'integer', value: 2 },
+      [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.browser' },
+      type: { type: 'string', value: 'fetch' },
+      [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
     }),
   });
 
-  expect(requestSpan?.data).not.toHaveProperty('url.fragment');
+  expect(requestSpan?.attributes).not.toHaveProperty([URL_FRAGMENT]);
 });
 
 sentryTest('strips hash fragment in fetch request spans', async ({ getLocalTestUrl, page }) => {
@@ -55,35 +67,34 @@ sentryTest('strips hash fragment in fetch request spans', async ({ getLocalTestU
 
   await page.goto(url);
 
-  const txnPromise = waitForTransactionRequest(page);
+  const rootPromise = waitForStreamedSpan(page, span => span.is_segment && span.name === 'rootSpan');
+  const requestPromise = waitForStreamedSpan(page, span => getSpanOp(span) === HTTP_CLIENT);
   await page.locator('#btnFragment').click();
-  const transactionEvent = envelopeRequestParser(await txnPromise);
-
-  expect(transactionEvent.transaction).toEqual('rootSpan');
+  const [rootSpan, requestSpan] = await Promise.all([rootPromise, requestPromise]);
 
-  const requestSpan = transactionEvent.spans?.find(({ op }) => op === 'http.client');
+  expect(rootSpan.name).toBe('rootSpan');
 
   expect(requestSpan).toMatchObject({
-    description: 'GET http://sentry-test-site.example/1',
-    parent_span_id: transactionEvent.contexts?.trace?.span_id,
+    name: 'GET sentry-test-site.example',
+    parent_span_id: rootSpan.span_id,
     span_id: expect.stringMatching(/[a-f\d]{16}/),
     start_timestamp: expect.any(Number),
-    timestamp: expect.any(Number),
-    trace_id: transactionEvent.contexts?.trace?.trace_id,
-    data: expect.objectContaining({
-      'http.request.method': 'GET',
-      'url.full': 'http://sentry-test-site.example/1#fragment',
-      'url.fragment': 'fragment',
-      'http.response.status_code': 200,
-      'http.response.body.size': 2,
-      'sentry.op': 'http.client',
-      'sentry.origin': 'auto.http.browser',
-      type: 'fetch',
-      'server.address': 'sentry-test-site.example',
+    end_timestamp: expect.any(Number),
+    trace_id: rootSpan.trace_id,
+    attributes: expect.objectContaining({
+      [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+      [URL_FULL]: { type: 'string', value: 'http://sentry-test-site.example/1#fragment' },
+      [URL_FRAGMENT]: { type: 'string', value: 'fragment' },
+      [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+      [HTTP_RESPONSE_BODY_SIZE]: { type: 'integer', value: 2 },
+      [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.browser' },
+      type: { type: 'string', value: 'fetch' },
+      [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
     }),
   });
 
-  expect(requestSpan?.data).not.toHaveProperty('url.query');
+  expect(requestSpan?.attributes).not.toHaveProperty([URL_QUERY]);
 });
 
 sentryTest('strips hash fragment and query params in fetch request spans', async ({ getLocalTestUrl, page }) => {
@@ -97,32 +108,31 @@ sentryTest('strips hash fragment and query params in fetch request spans', async
 
   await page.goto(url);
 
-  const txnPromise = waitForTransactionRequest(page);
+  const rootPromise = waitForStreamedSpan(page, span => span.is_segment && span.name === 'rootSpan');
+  const requestPromise = waitForStreamedSpan(page, span => getSpanOp(span) === HTTP_CLIENT);
   await page.locator('#btnQueryFragment').click();
-  const transactionEvent = envelopeRequestParser(await txnPromise);
+  const [rootSpan, requestSpan] = await Promise.all([rootPromise, requestPromise]);
 
-  expect(transactionEvent.transaction).toEqual('rootSpan');
-
-  const requestSpan = transactionEvent.spans?.find(({ op }) => op === 'http.client');
+  expect(rootSpan.name).toBe('rootSpan');
 
   expect(requestSpan).toMatchObject({
-    description: 'GET http://sentry-test-site.example/2',
-    parent_span_id: transactionEvent.contexts?.trace?.span_id,
+    name: 'GET sentry-test-site.example',
+    parent_span_id: rootSpan.span_id,
     span_id: expect.stringMatching(/[a-f\d]{16}/),
     start_timestamp: expect.any(Number),
-    timestamp: expect.any(Number),
-    trace_id: transactionEvent.contexts?.trace?.trace_id,
-    data: expect.objectContaining({
-      'http.request.method': 'GET',
-      'url.full': 'http://sentry-test-site.example/2?id=1#fragment',
-      'url.query': 'id=1',
-      'url.fragment': 'fragment',
-      'http.response.status_code': 200,
-      'http.response.body.size': 2,
-      'sentry.op': 'http.client',
-      'sentry.origin': 'auto.http.browser',
-      type: 'fetch',
-      'server.address': 'sentry-test-site.example',
+    end_timestamp: expect.any(Number),
+    trace_id: rootSpan.trace_id,
+    attributes: expect.objectContaining({
+      [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+      [URL_FULL]: { type: 'string', value: 'http://sentry-test-site.example/2?id=1#fragment' },
+      [URL_QUERY]: { type: 'string', value: 'id=1' },
+      [URL_FRAGMENT]: { type: 'string', value: 'fragment' },
+      [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+      [HTTP_RESPONSE_BODY_SIZE]: { type: 'integer', value: 2 },
+      [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.browser' },
+      type: { type: 'string', value: 'fetch' },
+      [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
     }),
   });
 });
@@ -140,32 +150,31 @@ sentryTest(
 
     await page.goto(url);
 
-    const txnPromise = waitForTransactionRequest(page);
+    const rootPromise = waitForStreamedSpan(page, span => span.is_segment && span.name === 'rootSpan');
+    const requestPromise = waitForStreamedSpan(page, span => getSpanOp(span) === HTTP_CLIENT);
     await page.locator('#btnQueryFragmentSameOrigin').click();
-    const transactionEvent = envelopeRequestParser(await txnPromise);
-
-    expect(transactionEvent.transaction).toEqual('rootSpan');
+    const [rootSpan, requestSpan] = await Promise.all([rootPromise, requestPromise]);
 
-    const requestSpan = transactionEvent.spans?.find(({ op }) => op === 'http.client');
+    expect(rootSpan.name).toBe('rootSpan');
 
     expect(requestSpan).toMatchObject({
-      description: 'GET /api/users',
-      parent_span_id: transactionEvent.contexts?.trace?.span_id,
+      name: 'GET sentry-test.io',
+      parent_span_id: rootSpan.span_id,
       span_id: expect.stringMatching(/[a-f\d]{16}/),
       start_timestamp: expect.any(Number),
-      timestamp: expect.any(Number),
-      trace_id: transactionEvent.contexts?.trace?.trace_id,
-      data: expect.objectContaining({
-        'http.request.method': 'GET',
-        'url.full': 'http://sentry-test.io/api/users?id=1#fragment',
-        'url.query': 'id=1',
-        'url.fragment': 'fragment',
-        'http.response.status_code': 200,
-        'http.response.body.size': 2,
-        'sentry.op': 'http.client',
-        'sentry.origin': 'auto.http.browser',
-        type: 'fetch',
-        'server.address': 'sentry-test.io',
+      end_timestamp: expect.any(Number),
+      trace_id: rootSpan.trace_id,
+      attributes: expect.objectContaining({
+        [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+        [URL_FULL]: { type: 'string', value: 'http://sentry-test.io/api/users?id=1#fragment' },
+        [URL_QUERY]: { type: 'string', value: 'id=1' },
+        [URL_FRAGMENT]: { type: 'string', value: 'fragment' },
+        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+        [HTTP_RESPONSE_BODY_SIZE]: { type: 'integer', value: 2 },
+        [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+        [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.browser' },
+        type: { type: 'string', value: 'fetch' },
+        [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test.io' },
       }),
     });
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-trace-header-merging/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-trace-header-merging/init.js
index 65cfbab96ee2..b2280b70e307 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-trace-header-merging/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-trace-header-merging/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled-propagateTraceparent/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled-propagateTraceparent/init.js
index d24ea3bd6ea5..fa09e056425e 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled-propagateTraceparent/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled-propagateTraceparent/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/init.js
index 06a40a8e55ec..5e9c86105ae7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-unsampled/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance-propagateTraceparent/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance-propagateTraceparent/init.js
index bc687b1606dd..8d3c1948d89d 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance-propagateTraceparent/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance-propagateTraceparent/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/init.js
index 9e18155fa4aa..69d4c5781782 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-tracing-without-performance/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed-track-stream-performance/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-track-stream-performance/init.js
similarity index 62%
rename from dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed-track-stream-performance/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/request/fetch-track-stream-performance/init.js
index 260d01fe817b..4a965f288264 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed-track-stream-performance/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-track-stream-performance/init.js
@@ -4,11 +4,7 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [
-    Sentry.browserTracingIntegration(),
-    Sentry.spanStreamingIntegration(),
-    Sentry.fetchStreamPerformanceIntegration(),
-  ],
+  integrations: [Sentry.browserTracingIntegration(), Sentry.fetchStreamPerformanceIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
   tracesSampleRate: 1,
   autoSessionTracking: false,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed-track-stream-performance/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-track-stream-performance/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed-track-stream-performance/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/request/fetch-track-stream-performance/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed-track-stream-performance/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-track-stream-performance/test.ts
similarity index 85%
rename from dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed-track-stream-performance/test.ts
rename to dev-packages/browser-integration-tests/suites/tracing/request/fetch-track-stream-performance/test.ts
index 04f0261beff4..3c5ee8ee33fe 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed-track-stream-performance/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-track-stream-performance/test.ts
@@ -1,3 +1,4 @@
+import { HTTP_REQUEST_METHOD, URL_FULL, URL_DOMAIN } from '@sentry/conventions/attributes';
 import http from 'http';
 import type { AddressInfo } from 'net';
 import { expect } from '@playwright/test';
@@ -53,13 +54,15 @@ sentryTest(
       expect(streamSpan).toMatchObject({
         name: 'GET sentry-test-site.example',
         attributes: expect.objectContaining({
-          'http.request.method': { type: 'string', value: 'GET' },
-          'url.full': { type: 'string', value: 'http://sentry-test-site.example/delayed' },
-          'url.domain': { type: 'string', value: 'sentry-test-site.example' },
+          [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+          [URL_FULL]: { type: 'string', value: 'http://sentry-test-site.example/delayed' },
+          [URL_DOMAIN]: { type: 'string', value: 'sentry-test-site.example' },
           type: { type: 'string', value: 'fetch' },
         }),
       });
 
+      expect(streamSpan.parent_span_id).toBe(requestSpan.parent_span_id);
+      expect(streamSpan.trace_id).toBe(requestSpan.trace_id);
       expect(streamSpan.end_timestamp).toBeGreaterThan(streamSpan.start_timestamp);
     } finally {
       server.close();
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-custom-sentry-headers-propagateTraceparent/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-custom-sentry-headers-propagateTraceparent/init.js
index efcc9dde33fa..cb785bbf7fda 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-custom-sentry-headers-propagateTraceparent/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-custom-sentry-headers-propagateTraceparent/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-custom-sentry-headers/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-custom-sentry-headers/init.js
index 65cfbab96ee2..b2280b70e307 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-custom-sentry-headers/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-custom-sentry-headers/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-request/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-request/init.js
index 65cfbab96ee2..b2280b70e307 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-request/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch-with-request/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/fetch/init.js
similarity index 74%
rename from dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed/init.js
rename to dev-packages/browser-integration-tests/suites/tracing/request/fetch/init.js
index c4c8791cf32c..439f60ae6dc4 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch-streamed/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch/init.js
@@ -4,7 +4,7 @@ window.Sentry = Sentry;
 
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
   tracesSampleRate: 1,
   autoSessionTracking: false,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/fetch/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/fetch/test.ts
index a177445bb980..1f8ec9ba655e 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/fetch/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/fetch/test.ts
@@ -1,41 +1,46 @@
+import { URL_FULL, HTTP_REQUEST_METHOD, URL_DOMAIN, SERVER_ADDRESS } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  shouldSkipTracingTest,
-  waitForTransactionRequestOnUrl,
-} from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest('should create spans for fetch requests', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+sentryTest('creates spans for fetch requests', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
 
   await page.route('http://sentry-test-site.example/*', route => route.fulfill({ body: 'ok' }));
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const req = await waitForTransactionRequestOnUrl(page, url);
-  const tracingEvent = envelopeRequestParser(req);
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
+
+  await page.goto(url);
 
-  const requestSpans = tracingEvent.spans?.filter(({ op }) => op === 'http.client');
+  const pageloadSpan = await pageloadPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const allSpans = spans;
+  const requestSpans = allSpans
+    .filter(s => getSpanOp(s) === 'http.client')
+    .sort((a, b) => (a.attributes![URL_FULL]!.value as string).localeCompare(b.attributes![URL_FULL]!.value as string));
 
   expect(requestSpans).toHaveLength(3);
 
-  requestSpans?.forEach((span, index) =>
+  requestSpans.forEach((span, index) =>
     expect(span).toMatchObject({
-      description: `GET http://sentry-test-site.example/${index}`,
-      parent_span_id: tracingEvent.contexts?.trace?.span_id,
+      // Streamed span names drop the high-cardinality URL path.
+      name: 'GET sentry-test-site.example',
+      parent_span_id: pageloadSpan?.span_id,
       span_id: expect.stringMatching(/[a-f\d]{16}/),
       start_timestamp: expect.any(Number),
-      timestamp: expect.any(Number),
-      trace_id: tracingEvent.contexts?.trace?.trace_id,
-      data: {
-        'http.request.method': 'GET',
-        'url.full': `http://sentry-test-site.example/${index}`,
-        'server.address': 'sentry-test-site.example',
-        type: 'fetch',
-      },
+      end_timestamp: expect.any(Number),
+      trace_id: pageloadSpan?.trace_id,
+      attributes: expect.objectContaining({
+        [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+        [URL_FULL]: { type: 'string', value: `http://sentry-test-site.example/${index}` },
+        [URL_DOMAIN]: { type: 'string', value: 'sentry-test-site.example' },
+        [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
+        type: { type: 'string', value: 'fetch' },
+      }),
     }),
   );
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/init.js
index 847df632b642..439f60ae6dc4 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-data-url/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-data-url/init.js
index d1c5e9767aa2..5ab240338c8c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-data-url/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-data-url/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-data-url/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-data-url/test.ts
index 549c468c2e0b..29f49ae5a6b9 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-data-url/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-data-url/test.ts
@@ -1,29 +1,28 @@
+import { HTTP_REQUEST_METHOD, URL_FULL } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
-
-sentryTest('sanitizes data URLs in XHR span name and attributes', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
+sentryTest('sanitizes data URLs in xhr span name and attributes', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
   const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const requestSpans = eventData.spans?.filter(({ op }) => op === 'http.client');
-
-  expect(requestSpans).toHaveLength(1);
-
-  const span = requestSpans?.[0];
-
-  const sanitizedUrl = 'data:text/plain,base64,SGVsbG8gV2... [truncated]';
-  expect(span?.description).toBe(`GET ${sanitizedUrl}`);
-
-  expect(span?.data).toMatchObject({
-    'http.request.method': 'GET',
-    type: 'xhr',
+  await page.goto(url);
+  const pageload = await pageloadPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+
+  const requests = spans.filter(span => getSpanOp(span) === 'http.client');
+  expect(requests).toHaveLength(1);
+  const span = requests[0];
+  expect(span.name).toBe('GET');
+  expect(span.parent_span_id).toBe(pageload.span_id);
+  expect(span.trace_id).toBe(pageload.trace_id);
+  expect(span.attributes[HTTP_REQUEST_METHOD]).toEqual({ type: 'string', value: 'GET' });
+  expect(span.attributes.type).toEqual({ type: 'string', value: 'xhr' });
+  expect(span.attributes[URL_FULL]).toEqual({
+    type: 'string',
+    value: 'data:text/plain,base64,SGVsbG8gV2... [truncated]',
   });
-
-  expect(span?.data?.['url.full']).toBe(sanitizedUrl);
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/init.js
index 2db7a75be0e6..3cbcaa4fe152 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-no-tracing/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracePropagationTargets: ['http://sentry-test-site.example'],
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-propagateTraceparent/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-propagateTraceparent/init.js
index efcc9dde33fa..cb785bbf7fda 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-propagateTraceparent/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-propagateTraceparent/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-static/init.js
new file mode 100644
index 000000000000..bb6d4918d1bf
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-static/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-static/subject.js
similarity index 80%
rename from dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-streamed/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-static/subject.js
index 75155522ab50..5fc9f91ab568 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-streamed/subject.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-static/subject.js
@@ -4,6 +4,7 @@ xhr_1.send();
 
 const xhr_2 = new XMLHttpRequest();
 xhr_2.open('GET', '/test-req/1');
+xhr_2.setRequestHeader('X-Test-Header', 'existing-header');
 xhr_2.send();
 
 const xhr_3 = new XMLHttpRequest();
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-static/test.ts
new file mode 100644
index 000000000000..096ca7325688
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-static/test.ts
@@ -0,0 +1,78 @@
+import { HTTP_REQUEST_METHOD, URL_FULL, SERVER_ADDRESS } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import { sentryTest, TEST_HOST } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  shouldSkipTracingTest,
+  waitForTransactionRequestOnUrl,
+} from '../../../../utils/helpers';
+
+sentryTest('should create spans for xhr requests', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  const req = await waitForTransactionRequestOnUrl(page, url);
+  const tracingEvent = envelopeRequestParser(req);
+
+  const requestSpans = tracingEvent.spans?.filter(({ op }) => op === 'http.client');
+
+  expect(requestSpans).toHaveLength(3);
+
+  requestSpans?.forEach((span, index) =>
+    expect(span).toMatchObject({
+      description: `GET /test-req/${index}`,
+      parent_span_id: tracingEvent.contexts?.trace?.span_id,
+      span_id: expect.stringMatching(/[a-f\d]{16}/),
+      start_timestamp: expect.any(Number),
+      timestamp: expect.any(Number),
+      trace_id: tracingEvent.contexts?.trace?.trace_id,
+      data: {
+        [HTTP_REQUEST_METHOD]: 'GET',
+        [URL_FULL]: `${TEST_HOST}/test-req/${index}`,
+        [SERVER_ADDRESS]: 'sentry-test.io',
+        type: 'xhr',
+      },
+    }),
+  );
+});
+
+sentryTest('should attach `sentry-trace` header to xhr requests', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const requests = (
+    await Promise.all([
+      page.goto(url),
+      Promise.all([0, 1, 2].map(idx => page.waitForRequest(`${TEST_HOST}/test-req/${idx}`))),
+    ])
+  )[1];
+
+  expect(requests).toHaveLength(3);
+
+  const request1 = requests[0];
+  const requestHeaders1 = request1.headers();
+  expect(requestHeaders1).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+  });
+
+  const request2 = requests[1];
+  const requestHeaders2 = request2.headers();
+  expect(requestHeaders2).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+    'x-test-header': 'existing-header',
+  });
+
+  const request3 = requests[2];
+  const requestHeaders3 = request3.headers();
+  expect(requestHeaders3).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-streamed/test.ts
deleted file mode 100644
index 31ab73597b88..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url-streamed/test.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest, TEST_HOST } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest('names spans for relative XHR requests after the page domain', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const spansPromise = waitForStreamedSpans(
-    page,
-    spans => spans.filter(s => getSpanOp(s) === 'http.client').length >= 3,
-  );
-
-  await page.goto(url);
-
-  const requestSpans = (await spansPromise)
-    .filter(s => getSpanOp(s) === 'http.client')
-    .sort((a, b) =>
-      (a.attributes!['url.full']!.value as string).localeCompare(b.attributes!['url.full']!.value as string),
-    );
-
-  expect(requestSpans).toHaveLength(3);
-
-  requestSpans.forEach((span, index) =>
-    expect(span).toMatchObject({
-      // A relative URL has no domain of its own, so it resolves against the page origin.
-      name: 'GET sentry-test.io',
-      attributes: expect.objectContaining({
-        'http.request.method': { type: 'string', value: 'GET' },
-        'url.full': { type: 'string', value: `${TEST_HOST}/test-req/${index}` },
-        'url.domain': { type: 'string', value: 'sentry-test.io' },
-        'server.address': { type: 'string', value: 'sentry-test.io' },
-        type: { type: 'string', value: 'xhr' },
-      }),
-    }),
-  );
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url/init.js
index bb6d4918d1bf..5ab240338c8c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url/init.js
@@ -3,8 +3,8 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracesSampleRate: 1,
+  autoSessionTracking: false,
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url/test.ts
index 110df467837f..ec485b0bf340 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-relative-url/test.ts
@@ -1,38 +1,40 @@
+import { URL_FULL, HTTP_REQUEST_METHOD, URL_DOMAIN, SERVER_ADDRESS } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest, TEST_HOST } from '../../../../utils/fixtures';
-import {
-  envelopeRequestParser,
-  shouldSkipTracingTest,
-  waitForTransactionRequestOnUrl,
-} from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest('should create spans for xhr requests', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+sentryTest('names spans for relative XHR requests after the page domain', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const req = await waitForTransactionRequestOnUrl(page, url);
-  const tracingEvent = envelopeRequestParser(req);
 
-  const requestSpans = tracingEvent.spans?.filter(({ op }) => op === 'http.client');
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
+
+  await page.goto(url);
+
+  const pageloadSpan = await pageloadPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const requestSpans = spans
+    .filter(s => getSpanOp(s) === 'http.client')
+    .sort((a, b) => (a.attributes![URL_FULL]!.value as string).localeCompare(b.attributes![URL_FULL]!.value as string));
 
   expect(requestSpans).toHaveLength(3);
 
-  requestSpans?.forEach((span, index) =>
+  requestSpans.forEach((span, index) =>
     expect(span).toMatchObject({
-      description: `GET /test-req/${index}`,
-      parent_span_id: tracingEvent.contexts?.trace?.span_id,
-      span_id: expect.stringMatching(/[a-f\d]{16}/),
-      start_timestamp: expect.any(Number),
-      timestamp: expect.any(Number),
-      trace_id: tracingEvent.contexts?.trace?.trace_id,
-      data: {
-        'http.request.method': 'GET',
-        'url.full': `${TEST_HOST}/test-req/${index}`,
-        'server.address': 'sentry-test.io',
-        type: 'xhr',
-      },
+      // A relative URL has no domain of its own, so it resolves against the page origin.
+      name: 'GET sentry-test.io',
+      parent_span_id: pageloadSpan.span_id,
+      trace_id: pageloadSpan.trace_id,
+      attributes: expect.objectContaining({
+        [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+        [URL_FULL]: { type: 'string', value: `${TEST_HOST}/test-req/${index}` },
+        [URL_DOMAIN]: { type: 'string', value: 'sentry-test.io' },
+        [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test.io' },
+        type: { type: 'string', value: 'xhr' },
+      }),
     }),
   );
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-static/init.js
new file mode 100644
index 000000000000..847df632b642
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-static/init.js
@@ -0,0 +1,12 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracePropagationTargets: ['http://sentry-test-site.example'],
+  tracesSampleRate: 1,
+  autoSessionTracking: false,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-streamed/subject.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-static/subject.js
similarity index 100%
rename from dev-packages/browser-integration-tests/suites/tracing/request/xhr-streamed/subject.js
rename to dev-packages/browser-integration-tests/suites/tracing/request/xhr-static/subject.js
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-static/test.ts
new file mode 100644
index 000000000000..585937e157b1
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-static/test.ts
@@ -0,0 +1,76 @@
+import { HTTP_REQUEST_METHOD, URL_FULL, SERVER_ADDRESS } from '@sentry/conventions/attributes';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+
+sentryTest('should create spans for XHR requests', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  await page.route('http://sentry-test-site.example/*', route => route.fulfill({ body: 'ok' }));
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+  const requestSpans = eventData.spans?.filter(({ op }) => op === 'http.client');
+
+  expect(requestSpans).toHaveLength(3);
+
+  requestSpans?.forEach((span, index) =>
+    expect(span).toMatchObject({
+      description: `GET http://sentry-test-site.example/${index}`,
+      parent_span_id: eventData.contexts?.trace?.span_id,
+      span_id: expect.stringMatching(/[a-f\d]{16}/),
+      start_timestamp: expect.any(Number),
+      timestamp: expect.any(Number),
+      trace_id: eventData.contexts?.trace?.trace_id,
+      data: {
+        [HTTP_REQUEST_METHOD]: 'GET',
+        [URL_FULL]: `http://sentry-test-site.example/${index}`,
+        [SERVER_ADDRESS]: 'sentry-test-site.example',
+        type: 'xhr',
+      },
+    }),
+  );
+});
+
+sentryTest('should attach `sentry-trace` header to XHR requests', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const requests = (
+    await Promise.all([
+      page.goto(url),
+      Promise.all([0, 1, 2].map(idx => page.waitForRequest(`http://sentry-test-site.example/${idx}`))),
+    ])
+  )[1];
+
+  expect(requests).toHaveLength(3);
+
+  const request1 = requests[0];
+  const requestHeaders1 = request1.headers();
+  expect(requestHeaders1).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+  });
+
+  const request2 = requests[1];
+  const requestHeaders2 = request2.headers();
+  expect(requestHeaders2).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+    'x-test-header': 'existing-header',
+  });
+
+  const request3 = requests[2];
+  const requestHeaders3 = request3.headers();
+  expect(requestHeaders3).toMatchObject({
+    'sentry-trace': expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/),
+    baggage: expect.any(String),
+  });
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-streamed/test.ts
deleted file mode 100644
index 2fd96eb8af58..000000000000
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-streamed/test.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { expect } from '@playwright/test';
-import { sentryTest } from '../../../../utils/fixtures';
-import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
-
-sentryTest('creates spans for XHR requests', async ({ getLocalTestUrl, page }) => {
-  sentryTest.skip(shouldSkipTracingTest());
-
-  await page.route('http://sentry-test-site.example/*', route => route.fulfill({ body: 'ok' }));
-
-  const url = await getLocalTestUrl({ testDir: __dirname });
-
-  const spansPromise = waitForStreamedSpans(
-    page,
-    spans => spans.filter(s => getSpanOp(s) === 'http.client').length >= 3,
-  );
-
-  await page.goto(url);
-
-  const allSpans = await spansPromise;
-  const pageloadSpan = allSpans.find(s => getSpanOp(s) === 'pageload');
-  const requestSpans = allSpans
-    .filter(s => getSpanOp(s) === 'http.client')
-    .sort((a, b) =>
-      (a.attributes!['url.full']!.value as string).localeCompare(b.attributes!['url.full']!.value as string),
-    );
-
-  expect(requestSpans).toHaveLength(3);
-
-  requestSpans.forEach((span, index) =>
-    expect(span).toMatchObject({
-      // Streamed span names drop the high-cardinality URL path.
-      name: 'GET sentry-test-site.example',
-      parent_span_id: pageloadSpan?.span_id,
-      span_id: expect.stringMatching(/[a-f\d]{16}/),
-      start_timestamp: expect.any(Number),
-      end_timestamp: expect.any(Number),
-      trace_id: pageloadSpan?.trace_id,
-      attributes: expect.objectContaining({
-        'http.request.method': { type: 'string', value: 'GET' },
-        'url.full': { type: 'string', value: `http://sentry-test-site.example/${index}` },
-        'url.domain': { type: 'string', value: 'sentry-test-site.example' },
-        'server.address': { type: 'string', value: 'sentry-test-site.example' },
-        type: { type: 'string', value: 'xhr' },
-      }),
-    }),
-  );
-});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-strip-query-and-fragment/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-strip-query-and-fragment/init.js
index d334f6a7d2a6..de6b87574482 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-strip-query-and-fragment/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-strip-query-and-fragment/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration({ instrumentPageLoad: false, instrumentNavigation: false })],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-strip-query-and-fragment/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-strip-query-and-fragment/test.ts
index f5445029b4c3..27137e9116a0 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-strip-query-and-fragment/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-strip-query-and-fragment/test.ts
@@ -1,6 +1,17 @@
+import {
+  HTTP_REQUEST_METHOD,
+  URL_FULL,
+  URL_QUERY,
+  HTTP_RESPONSE_STATUS_CODE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SERVER_ADDRESS,
+  URL_FRAGMENT,
+} from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
-import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('strips query params in XHR request spans', async ({ getLocalTestUrl, page }) => {
   if (shouldSkipTracingTest()) {
@@ -13,34 +24,33 @@ sentryTest('strips query params in XHR request spans', async ({ getLocalTestUrl,
 
   await page.goto(url);
 
-  const txnPromise = waitForTransactionRequest(page);
+  const rootPromise = waitForStreamedSpan(page, span => span.is_segment && span.name === 'rootSpan');
+  const requestPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'http.client');
   await page.locator('#btnQuery').click();
-  const transactionEvent = envelopeRequestParser(await txnPromise);
+  const [rootSpan, requestSpan] = await Promise.all([rootPromise, requestPromise]);
 
-  expect(transactionEvent.transaction).toEqual('rootSpan');
-
-  const requestSpan = transactionEvent.spans?.find(({ op }) => op === 'http.client');
+  expect(rootSpan.name).toBe('rootSpan');
 
   expect(requestSpan).toMatchObject({
-    description: 'GET http://sentry-test-site.example/0',
-    parent_span_id: transactionEvent.contexts?.trace?.span_id,
+    name: 'GET sentry-test-site.example',
+    parent_span_id: rootSpan.span_id,
     span_id: expect.stringMatching(/[a-f\d]{16}/),
     start_timestamp: expect.any(Number),
-    timestamp: expect.any(Number),
-    trace_id: transactionEvent.contexts?.trace?.trace_id,
-    data: expect.objectContaining({
-      'http.request.method': 'GET',
-      'url.full': 'http://sentry-test-site.example/0?id=123;page=5',
-      'url.query': 'id=123;page=5',
-      'http.response.status_code': 200,
-      'sentry.op': 'http.client',
-      'sentry.origin': 'auto.http.browser',
-      type: 'xhr',
-      'server.address': 'sentry-test-site.example',
+    end_timestamp: expect.any(Number),
+    trace_id: rootSpan.trace_id,
+    attributes: expect.objectContaining({
+      [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+      [URL_FULL]: { type: 'string', value: 'http://sentry-test-site.example/0?id=123;page=5' },
+      [URL_QUERY]: { type: 'string', value: 'id=123;page=5' },
+      [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+      [SENTRY_OP]: { type: 'string', value: 'http.client' },
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.browser' },
+      type: { type: 'string', value: 'xhr' },
+      [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
     }),
   });
 
-  expect(requestSpan?.data).not.toHaveProperty('url.fragment');
+  expect(requestSpan?.attributes).not.toHaveProperty([URL_FRAGMENT]);
 });
 
 sentryTest('strips hash fragment in XHR request spans', async ({ getLocalTestUrl, page }) => {
@@ -54,34 +64,33 @@ sentryTest('strips hash fragment in XHR request spans', async ({ getLocalTestUrl
 
   await page.goto(url);
 
-  const txnPromise = waitForTransactionRequest(page);
+  const rootPromise = waitForStreamedSpan(page, span => span.is_segment && span.name === 'rootSpan');
+  const requestPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'http.client');
   await page.locator('#btnFragment').click();
-  const transactionEvent = envelopeRequestParser(await txnPromise);
-
-  expect(transactionEvent.transaction).toEqual('rootSpan');
+  const [rootSpan, requestSpan] = await Promise.all([rootPromise, requestPromise]);
 
-  const requestSpan = transactionEvent.spans?.find(({ op }) => op === 'http.client');
+  expect(rootSpan.name).toBe('rootSpan');
 
   expect(requestSpan).toMatchObject({
-    description: 'GET http://sentry-test-site.example/1',
-    parent_span_id: transactionEvent.contexts?.trace?.span_id,
+    name: 'GET sentry-test-site.example',
+    parent_span_id: rootSpan.span_id,
     span_id: expect.stringMatching(/[a-f\d]{16}/),
     start_timestamp: expect.any(Number),
-    timestamp: expect.any(Number),
-    trace_id: transactionEvent.contexts?.trace?.trace_id,
-    data: expect.objectContaining({
-      'http.request.method': 'GET',
-      'url.full': 'http://sentry-test-site.example/1#fragment',
-      'url.fragment': 'fragment',
-      'http.response.status_code': 200,
-      'sentry.op': 'http.client',
-      'sentry.origin': 'auto.http.browser',
-      type: 'xhr',
-      'server.address': 'sentry-test-site.example',
+    end_timestamp: expect.any(Number),
+    trace_id: rootSpan.trace_id,
+    attributes: expect.objectContaining({
+      [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+      [URL_FULL]: { type: 'string', value: 'http://sentry-test-site.example/1#fragment' },
+      [URL_FRAGMENT]: { type: 'string', value: 'fragment' },
+      [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+      [SENTRY_OP]: { type: 'string', value: 'http.client' },
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.browser' },
+      type: { type: 'string', value: 'xhr' },
+      [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
     }),
   });
 
-  expect(requestSpan?.data).not.toHaveProperty('url.query');
+  expect(requestSpan?.attributes).not.toHaveProperty([URL_QUERY]);
 });
 
 sentryTest('strips hash fragment and query params in XHR request spans', async ({ getLocalTestUrl, page }) => {
@@ -95,31 +104,30 @@ sentryTest('strips hash fragment and query params in XHR request spans', async (
 
   await page.goto(url);
 
-  const txnPromise = waitForTransactionRequest(page);
+  const rootPromise = waitForStreamedSpan(page, span => span.is_segment && span.name === 'rootSpan');
+  const requestPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'http.client');
   await page.locator('#btnQueryFragment').click();
-  const transactionEvent = envelopeRequestParser(await txnPromise);
+  const [rootSpan, requestSpan] = await Promise.all([rootPromise, requestPromise]);
 
-  expect(transactionEvent.transaction).toEqual('rootSpan');
-
-  const requestSpan = transactionEvent.spans?.find(({ op }) => op === 'http.client');
+  expect(rootSpan.name).toBe('rootSpan');
 
   expect(requestSpan).toMatchObject({
-    description: 'GET http://sentry-test-site.example/2',
-    parent_span_id: transactionEvent.contexts?.trace?.span_id,
+    name: 'GET sentry-test-site.example',
+    parent_span_id: rootSpan.span_id,
     span_id: expect.stringMatching(/[a-f\d]{16}/),
     start_timestamp: expect.any(Number),
-    timestamp: expect.any(Number),
-    trace_id: transactionEvent.contexts?.trace?.trace_id,
-    data: expect.objectContaining({
-      'http.request.method': 'GET',
-      'url.full': 'http://sentry-test-site.example/2?id=1#fragment',
-      'url.query': 'id=1',
-      'url.fragment': 'fragment',
-      'http.response.status_code': 200,
-      'sentry.op': 'http.client',
-      'sentry.origin': 'auto.http.browser',
-      type: 'xhr',
-      'server.address': 'sentry-test-site.example',
+    end_timestamp: expect.any(Number),
+    trace_id: rootSpan.trace_id,
+    attributes: expect.objectContaining({
+      [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+      [URL_FULL]: { type: 'string', value: 'http://sentry-test-site.example/2?id=1#fragment' },
+      [URL_QUERY]: { type: 'string', value: 'id=1' },
+      [URL_FRAGMENT]: { type: 'string', value: 'fragment' },
+      [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+      [SENTRY_OP]: { type: 'string', value: 'http.client' },
+      [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.browser' },
+      type: { type: 'string', value: 'xhr' },
+      [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
     }),
   });
 });
@@ -137,31 +145,30 @@ sentryTest(
 
     await page.goto(url);
 
-    const txnPromise = waitForTransactionRequest(page);
+    const rootPromise = waitForStreamedSpan(page, span => span.is_segment && span.name === 'rootSpan');
+    const requestPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'http.client');
     await page.locator('#btnQueryFragmentSameOrigin').click();
-    const transactionEvent = envelopeRequestParser(await txnPromise);
-
-    expect(transactionEvent.transaction).toEqual('rootSpan');
+    const [rootSpan, requestSpan] = await Promise.all([rootPromise, requestPromise]);
 
-    const requestSpan = transactionEvent.spans?.find(({ op }) => op === 'http.client');
+    expect(rootSpan.name).toBe('rootSpan');
 
     expect(requestSpan).toMatchObject({
-      description: 'GET /api/users',
-      parent_span_id: transactionEvent.contexts?.trace?.span_id,
+      name: 'GET sentry-test.io',
+      parent_span_id: rootSpan.span_id,
       span_id: expect.stringMatching(/[a-f\d]{16}/),
       start_timestamp: expect.any(Number),
-      timestamp: expect.any(Number),
-      trace_id: transactionEvent.contexts?.trace?.trace_id,
-      data: expect.objectContaining({
-        'http.request.method': 'GET',
-        'url.full': 'http://sentry-test.io/api/users?id=1#fragment',
-        'url.query': 'id=1',
-        'url.fragment': 'fragment',
-        'http.response.status_code': 200,
-        'sentry.op': 'http.client',
-        'sentry.origin': 'auto.http.browser',
-        type: 'xhr',
-        'server.address': 'sentry-test.io',
+      end_timestamp: expect.any(Number),
+      trace_id: rootSpan.trace_id,
+      attributes: expect.objectContaining({
+        [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+        [URL_FULL]: { type: 'string', value: 'http://sentry-test.io/api/users?id=1#fragment' },
+        [URL_QUERY]: { type: 'string', value: 'id=1' },
+        [URL_FRAGMENT]: { type: 'string', value: 'fragment' },
+        [HTTP_RESPONSE_STATUS_CODE]: { type: 'integer', value: 200 },
+        [SENTRY_OP]: { type: 'string', value: 'http.client' },
+        [SENTRY_ORIGIN]: { type: 'string', value: 'auto.http.browser' },
+        type: { type: 'string', value: 'xhr' },
+        [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test.io' },
       }),
     });
   },
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled-propagateTraceparent/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled-propagateTraceparent/init.js
index d24ea3bd6ea5..fa09e056425e 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled-propagateTraceparent/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled-propagateTraceparent/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/init.js
index 06a40a8e55ec..5e9c86105ae7 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-unsampled/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance-propagateTraceparent/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance-propagateTraceparent/init.js
index c2beb16cffc6..db749bf038e0 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance-propagateTraceparent/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance-propagateTraceparent/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/init.js
index b48b09d10f9b..11f91541bb18 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-tracing-without-performance/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-custom-sentry-headers-propagateTraceparent/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-custom-sentry-headers-propagateTraceparent/init.js
index efcc9dde33fa..cb785bbf7fda 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-custom-sentry-headers-propagateTraceparent/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr-with-custom-sentry-headers-propagateTraceparent/init.js
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/browser';
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration()],
   tracePropagationTargets: ['http://sentry-test-site.example'],
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr/init.js b/dev-packages/browser-integration-tests/suites/tracing/request/xhr/init.js
new file mode 100644
index 000000000000..439f60ae6dc4
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr/init.js
@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracePropagationTargets: ['http://sentry-test-site.example'],
+  tracesSampleRate: 1,
+  autoSessionTracking: false,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/request/xhr/test.ts b/dev-packages/browser-integration-tests/suites/tracing/request/xhr/test.ts
index 971cb0f5c030..87f89ba4b05c 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/request/xhr/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/request/xhr/test.ts
@@ -1,36 +1,46 @@
+import { URL_FULL, HTTP_REQUEST_METHOD, URL_DOMAIN, SERVER_ADDRESS } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
-sentryTest('should create spans for XHR requests', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+sentryTest('creates spans for XHR requests', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
 
   await page.route('http://sentry-test-site.example/*', route => route.fulfill({ body: 'ok' }));
 
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const requestSpans = eventData.spans?.filter(({ op }) => op === 'http.client');
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
+
+  await page.goto(url);
+
+  const pageloadSpan = await pageloadPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
+  const allSpans = spans;
+  const requestSpans = allSpans
+    .filter(s => getSpanOp(s) === 'http.client')
+    .sort((a, b) => (a.attributes![URL_FULL]!.value as string).localeCompare(b.attributes![URL_FULL]!.value as string));
 
   expect(requestSpans).toHaveLength(3);
 
-  requestSpans?.forEach((span, index) =>
+  requestSpans.forEach((span, index) =>
     expect(span).toMatchObject({
-      description: `GET http://sentry-test-site.example/${index}`,
-      parent_span_id: eventData.contexts?.trace?.span_id,
+      // Streamed span names drop the high-cardinality URL path.
+      name: 'GET sentry-test-site.example',
+      parent_span_id: pageloadSpan?.span_id,
       span_id: expect.stringMatching(/[a-f\d]{16}/),
       start_timestamp: expect.any(Number),
-      timestamp: expect.any(Number),
-      trace_id: eventData.contexts?.trace?.trace_id,
-      data: {
-        'http.request.method': 'GET',
-        'url.full': `http://sentry-test-site.example/${index}`,
-        'server.address': 'sentry-test-site.example',
-        type: 'xhr',
-      },
+      end_timestamp: expect.any(Number),
+      trace_id: pageloadSpan?.trace_id,
+      attributes: expect.objectContaining({
+        [HTTP_REQUEST_METHOD]: { type: 'string', value: 'GET' },
+        [URL_FULL]: { type: 'string', value: `http://sentry-test-site.example/${index}` },
+        [URL_DOMAIN]: { type: 'string', value: 'sentry-test-site.example' },
+        [SERVER_ADDRESS]: { type: 'string', value: 'sentry-test-site.example' },
+        type: { type: 'string', value: 'xhr' },
+      }),
     }),
   );
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/user-timing/disabled/test.ts b/dev-packages/browser-integration-tests/suites/tracing/user-timing/disabled/test.ts
index 8d69125cbd1c..c17f621b7cde 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/user-timing/disabled/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/user-timing/disabled/test.ts
@@ -1,17 +1,19 @@
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
 import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('does not capture mark and measure spans by default', async ({ getLocalTestUrl, page }) => {
   sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const spansPromise = waitForStreamedSpans(page, spans => spans.some(span => getSpanOp(span) === 'pageload'));
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
 
   await page.goto(url);
 
-  const spans = await spansPromise;
+  await pageloadPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
   const userTimingSpans = spans.filter(span => ['mark', 'measure'].includes(getSpanOp(span) ?? ''));
 
   expect(userTimingSpans).toHaveLength(0);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans-domexception-details/init.js b/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans-domexception-details/init.js
index d96c6f65b682..d82045937810 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans-domexception-details/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans-domexception-details/init.js
@@ -22,7 +22,6 @@ Object.defineProperty(measure, 'detail', {
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration(), userTimingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans-domexception-details/test.ts b/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans-domexception-details/test.ts
index 7a39e97420e3..b3bb77c23c64 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans-domexception-details/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans-domexception-details/test.ts
@@ -1,65 +1,40 @@
+import { SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
-
-// This is a regression test for https://github.com/getsentry/sentry-javascript/issues/16347
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest(
-  'should handle permission denial gracefully and still create measure spans',
+  'captures measure details when another measure denies access',
   async ({ getLocalTestUrl, page, browserName }) => {
-    // Skip test on webkit because we can't validate the detail in the browser
-    if (shouldSkipTracingTest() || browserName === 'webkit') {
-      sentryTest.skip();
-    }
-
+    sentryTest.skip(shouldSkipTracingTest() || browserName === 'webkit');
+    const spans = collectStreamedSpans(page);
+    const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
     const url = await getLocalTestUrl({ testDir: __dirname });
-    const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-
-    // Find all measure spans
-    const measureSpans = eventData.spans?.filter(({ op }) => op === 'measure');
-    expect(measureSpans?.length).toBe(3); // All three measures should create spans
-
-    // Test 1: Verify the restricted-test-measure span exists but has no detail
-    const restrictedMeasure = measureSpans?.find(span => span.description === 'restricted-test-measure');
-    expect(restrictedMeasure).toBeDefined();
-    expect(restrictedMeasure?.data).toMatchObject({
-      'sentry.op': 'measure',
-      'sentry.origin': 'auto.browser.user_timing.measure',
+    await page.goto(url);
+    const pageload = await pageloadPromise;
+    await page.evaluate(() => (window as any).Sentry.flush());
+
+    const measures = spans.filter(span => getSpanOp(span) === 'measure');
+    expect(measures).toHaveLength(3);
+    measures.forEach(span => {
+      expect(span.parent_span_id).toBe(pageload.span_id);
+      expect(span.attributes[SENTRY_ORIGIN]).toEqual({ type: 'string', value: 'auto.browser.user_timing.measure' });
     });
+    const restricted = measures.find(span => span.name === 'restricted-test-measure')!;
+    expect(Object.keys(restricted.attributes).filter(key => key.includes('detail'))).toHaveLength(0);
 
-    // Verify no detail attributes were added due to the permission error
-    const restrictedDataKeys = Object.keys(restrictedMeasure?.data || {});
-    const restrictedDetailKeys = restrictedDataKeys.filter(key => key.includes('detail'));
-    expect(restrictedDetailKeys).toHaveLength(0);
+    const normal = measures.find(span => span.name === 'normal-measure')!;
+    expect(normal.attributes['sentry.browser.measure.detail']).toEqual({ type: 'string', value: 'this-should-work' });
 
-    // Test 2: Verify the normal measure still captures detail correctly
-    const normalMeasure = measureSpans?.find(span => span.description === 'normal-measure');
-    expect(normalMeasure).toBeDefined();
-    expect(normalMeasure?.data).toMatchObject({
-      'sentry.browser.measure.detail': 'this-should-work',
-      'sentry.op': 'measure',
-      'sentry.origin': 'auto.browser.user_timing.measure',
+    const complex = measures.find(span => span.name === 'complex-detail-measure')!;
+    expect(complex.attributes['sentry.browser.measure.detail.nested']).toEqual({
+      type: 'string',
+      value: JSON.stringify({ array: [1, 2, 3], object: { key: 'value' } }),
     });
-
-    // Test 3: Verify the complex detail object is captured correctly
-    const complexMeasure = measureSpans?.find(span => span.description === 'complex-detail-measure');
-    expect(complexMeasure).toBeDefined();
-    expect(complexMeasure?.data).toMatchObject({
-      'sentry.op': 'measure',
-      'sentry.origin': 'auto.browser.user_timing.measure',
-      // The entire nested object is stringified as a single value
-      'sentry.browser.measure.detail.nested': JSON.stringify({
-        array: [1, 2, 3],
-        object: {
-          key: 'value',
-        },
-      }),
-      'sentry.browser.measure.detail.metadata': JSON.stringify({
-        type: 'test',
-        version: '1.0',
-        tags: ['complex', 'nested', 'object'],
-      }),
+    expect(complex.attributes['sentry.browser.measure.detail.metadata']).toEqual({
+      type: 'string',
+      value: JSON.stringify({ type: 'test', version: '1.0', tags: ['complex', 'nested', 'object'] }),
     });
   },
 );
diff --git a/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans/init.js b/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans/init.js
index 3c2db904fabe..84eb34cca961 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans/init.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans/init.js
@@ -11,7 +11,6 @@ performance.measure('Next.js-before-hydration', {
 window.Sentry = Sentry;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.browserTracingIntegration(), userTimingIntegration()],
   tracesSampleRate: 1,
diff --git a/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans/test.ts
index 365bc082372f..d85d6b7fc662 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/user-timing/pageload-measure-spans/test.ts
@@ -1,35 +1,35 @@
+import { URL_FULL, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
-import type { Event } from '@sentry/core';
 import { sentryTest } from '../../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest, shouldSkipTracingTest } from '../../../../utils/helpers';
-
-// Validation test for https://github.com/getsentry/sentry-javascript/issues/12281
-sentryTest('should add browser-related spans to pageload transaction', async ({ getLocalTestUrl, page }) => {
-  if (shouldSkipTracingTest()) {
-    sentryTest.skip();
-  }
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
+sentryTest('clamps pre-SDK measures to the document request start', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest());
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
   const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
+  const pageload = await pageloadPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
 
-  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
-  const browserSpans = eventData.spans?.filter(({ op }) => op?.startsWith('browser'));
-
-  // Spans `dom_content_loaded_event`, `connect`, `cache` and `dns` are not
-  // always inside `pageload` transaction.
-  expect(browserSpans?.length).toBeGreaterThanOrEqual(4);
-
-  const requestSpan = browserSpans!.find(({ op }) => op === 'browser.request');
-  expect(requestSpan).toBeDefined();
-  expect(requestSpan?.description).toBe(page.url());
-
-  const measureSpan = eventData.spans?.find(({ op }) => op === 'measure');
-  expect(measureSpan).toBeDefined();
-
-  expect(requestSpan!.start_timestamp).toBeLessThanOrEqual(measureSpan!.start_timestamp);
-  expect(measureSpan?.data).toEqual({
-    'sentry.browser.measure_happened_before_request': true,
-    'sentry.browser.measure_start_time': expect.any(Number),
-    'sentry.op': 'measure',
-    'sentry.origin': 'auto.browser.user_timing.measure',
+  const browserSpans = spans.filter(span => getSpanOp(span)?.startsWith('browser'));
+  expect(browserSpans.length).toBeGreaterThanOrEqual(4);
+  const request = browserSpans.find(span => getSpanOp(span) === 'browser.request')!;
+  expect(request.name).toBe('Request');
+  expect(request.attributes[URL_FULL]).toEqual({ type: 'string', value: page.url() });
+  const measures = spans.filter(span => getSpanOp(span) === 'measure');
+  expect(measures).toHaveLength(1);
+  const measure = measures[0];
+  expect(measure.parent_span_id).toBe(pageload.span_id);
+  expect(request.start_timestamp).toBeLessThanOrEqual(measure.start_timestamp);
+  expect(measure.attributes).toMatchObject({
+    'sentry.browser.measure_happened_before_request': { type: 'boolean', value: true },
+    'sentry.browser.measure_start_time': {
+      type: expect.stringMatching(/^(double|integer)$/),
+      value: expect.any(Number),
+    },
+    [SENTRY_OP]: { type: 'string', value: 'measure' },
+    [SENTRY_ORIGIN]: { type: 'string', value: 'auto.browser.user_timing.measure' },
   });
 });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/user-timing/spans/test.ts b/dev-packages/browser-integration-tests/suites/tracing/user-timing/spans/test.ts
index 4e01eb11d375..536f5c2f4607 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/user-timing/spans/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/user-timing/spans/test.ts
@@ -1,23 +1,26 @@
+import { SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import { expect } from '@playwright/test';
 import { sentryTest } from '../../../../utils/fixtures';
 import { shouldSkipTracingTest } from '../../../../utils/helpers';
-import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
 
 sentryTest('captures non-ignored mark and measure spans', async ({ getLocalTestUrl, page }) => {
   sentryTest.skip(shouldSkipTracingTest());
 
   const url = await getLocalTestUrl({ testDir: __dirname });
-  const spansPromise = waitForStreamedSpans(page, spans => spans.some(span => getSpanOp(span) === 'pageload'));
+  const spans = collectStreamedSpans(page);
+  const pageloadPromise = waitForStreamedSpan(page, span => span.is_segment && getSpanOp(span) === 'pageload');
 
   await page.goto(url);
 
-  const spans = await spansPromise;
+  await pageloadPromise;
+  await page.evaluate(() => (window as any).Sentry.flush());
   const userTimingSpans = spans
     .filter(span => ['mark', 'measure'].includes(getSpanOp(span) ?? ''))
     .map(span => ({
       name: span.name,
       op: getSpanOp(span),
-      origin: span.attributes['sentry.origin']?.value,
+      origin: span.attributes[SENTRY_ORIGIN]?.value,
     }))
     .sort((a, b) => a.name.localeCompare(b.name));
 
diff --git a/dev-packages/browser-integration-tests/utils/helpers.ts b/dev-packages/browser-integration-tests/utils/helpers.ts
index 05b5aebcf5f4..90b3deae3cb9 100644
--- a/dev-packages/browser-integration-tests/utils/helpers.ts
+++ b/dev-packages/browser-integration-tests/utils/helpers.ts
@@ -548,7 +548,23 @@ export async function getFirstSentryEnvelopeRequest<T>(
   return req;
 }
 
-export async function hidePage(page: Page): Promise<void> {
+export async function waitForLcpCandidate(page: Page, selector: string): Promise<void> {
+  await page.locator(selector).evaluate(element => {
+    return new Promise<void>(resolve => {
+      const observer = new PerformanceObserver(list => {
+        if (list.getEntries().some(entry => 'element' in entry && entry.element === element)) {
+          observer.disconnect();
+          resolve();
+        }
+      });
+
+      // The image may already have painted before the test attaches its observer.
+      observer.observe({ type: 'largest-contentful-paint', buffered: true });
+    });
+  });
+}
+
+export async function hidePage(page: Page, interactionSelector?: string): Promise<void> {
   // web-vitals processes an interaction's event entries in `requestIdleCallback(..., { timeout:
   // 1000 })`, and Chromium only reaches idle here once that timeout elapses. Hiding before that
   // callback runs loses the interaction: the forced report web-vitals does on `visibilitychange`
@@ -559,7 +575,7 @@ export async function hidePage(page: Page): Promise<void> {
   // therefore queues it first and hides the page too early. Waiting for the entry and queuing from
   // a task after it keeps web-vitals ahead: its observer is registered first, so it is notified
   // first, and the `setTimeout` lands after the microtask it defers that work into.
-  await page.evaluate(() => {
+  await page.evaluate(interactionSelector => {
     return new Promise<void>(resolve => {
       const scheduleIdle = (): void => {
         if (typeof requestIdleCallback !== 'function') {
@@ -572,23 +588,25 @@ export async function hidePage(page: Page): Promise<void> {
       // Callers that never interacted have no Event Timing entry coming, so there is nothing to
       // order against and nothing to wait for.
       const interactionCount = (performance as Performance & { interactionCount?: number }).interactionCount ?? 0;
-      if (!interactionCount && !performance.getEntriesByType('first-input').length) {
+      if (!interactionSelector && !interactionCount && !performance.getEntriesByType('first-input').length) {
         scheduleIdle();
         return;
       }
 
       let observer: PerformanceObserver | undefined;
-      let fallback: ReturnType<typeof setTimeout>;
+      let fallback: ReturnType<typeof setTimeout> | undefined;
 
-      // An interaction the Event Timing buffer no longer reports would otherwise wait here forever,
-      // so cap the wait rather than require an entry.
       const done = (): void => {
         clearTimeout(fallback);
         observer?.disconnect();
         setTimeout(scheduleIdle, 0);
       };
 
-      fallback = setTimeout(done, 1000);
+      if (!interactionSelector) {
+        // Older interactions may no longer be buffered. A requested click must be observed,
+        // otherwise hiding would silently lose the INP value the caller is testing.
+        fallback = setTimeout(done, 1000);
+      }
 
       try {
         // `durationThreshold` is missing from the DOM types, as it is in the SDK's own observer.
@@ -598,14 +616,27 @@ export async function hidePage(page: Page): Promise<void> {
           durationThreshold: 0,
         };
 
-        observer = new PerformanceObserver(done);
+        observer = new PerformanceObserver(list => {
+          // An earlier buffered interaction can arrive before the last click's entries.
+          // Wait for the requested target so the SDK can include that interaction in INP.
+          if (
+            interactionSelector &&
+            !list.getEntries().some(entry => {
+              const target = (entry as PerformanceEntry & { target?: Element }).target;
+              return entry.name === 'click' && target?.matches(interactionSelector);
+            })
+          ) {
+            return;
+          }
+          done();
+        });
         observer.observe(eventOptions);
         observer.observe({ type: 'first-input', buffered: true });
       } catch {
         done();
       }
     });
-  });
+  }, interactionSelector);
 
   await page.evaluate(() => {
     Object.defineProperty(document, 'visibilityState', {
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4-static/tests/middleware.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-4-static/tests/middleware.test.ts
index 5d3d1246d0e5..4cc18837b1ba 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-4-static/tests/middleware.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4-static/tests/middleware.test.ts
@@ -171,9 +171,9 @@ test.describe('Server Middleware Instrumentation', () => {
     expect(onBeforeResponseSpan?.data?.['nuxt.middleware.hook.name']).toBe('onBeforeResponse');
 
     // Verify no index attributes for single hooks
-    expect(onRequestSpan?.data).not.toHaveProperty('nuxt.middleware.hook.index');
-    expect(handlerSpan?.data).not.toHaveProperty('nuxt.middleware.hook.index');
-    expect(onBeforeResponseSpan?.data).not.toHaveProperty('nuxt.middleware.hook.index');
+    expect(onRequestSpan?.data).not.toHaveProperty(['nuxt.middleware.hook.index']);
+    expect(handlerSpan?.data).not.toHaveProperty(['nuxt.middleware.hook.index']);
+    expect(onBeforeResponseSpan?.data).not.toHaveProperty(['nuxt.middleware.hook.index']);
   });
 
   test('should create spans with index attributes for array hooks', async ({ request }) => {
@@ -229,7 +229,7 @@ test.describe('Server Middleware Instrumentation', () => {
     expect(onBeforeResponse1Span?.description).toBe('05.array-hooks.onBeforeResponse');
 
     // Verify handler has no index
-    expect(handlerSpan?.data).not.toHaveProperty('nuxt.middleware.hook.index');
+    expect(handlerSpan?.data).not.toHaveProperty(['nuxt.middleware.hook.index']);
   });
 
   test('should handle errors in onRequest hooks', async ({ request }) => {

From b32a9b50320a6d5b074e28566f1977a941ad090a Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 13:06:49 +0200
Subject: [PATCH 29/84] test(node): Port baggage and metadata tests to span
 streaming (#25220)

Exercise baggage and trace metadata propagation with the default
streaming lifecycle.

Part of #24140

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../double-baggage/no-spans/instrument.mjs    |  1 -
 .../tracing/double-baggage/no-spans/test.ts   |  1 -
 .../spans-no-parent/instrument.mjs            |  1 -
 .../double-baggage/spans-no-parent/test.ts    | 17 +++++
 .../spans-parent/instrument.mjs               |  1 -
 .../double-baggage/spans-parent/test.ts       | 74 ++++++++++---------
 .../dsc-txn-name-update/scenario-events.ts    |  1 -
 .../dsc-txn-name-update/scenario-headers.ts   |  1 -
 .../tracing/dsc-txn-name-update/test.ts       |  4 +-
 .../tracing/meta-tags-twp-errors/no-server.js |  1 -
 .../tracing/meta-tags-twp-errors/server.js    |  1 -
 .../suites/tracing/meta-tags-twp/server.js    |  1 -
 .../tracing/meta-tags/server-sdk-disabled.js  |  1 -
 .../meta-tags/server-tracesSampleRate-zero.js |  1 -
 .../suites/tracing/meta-tags/server.js        |  1 -
 15 files changed, 59 insertions(+), 48 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/tracing/double-baggage/no-spans/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/double-baggage/no-spans/instrument.mjs
index 59e56d82bbb7..7acd36926f22 100644
--- a/dev-packages/node-integration-tests/suites/tracing/double-baggage/no-spans/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/double-baggage/no-spans/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   // explicitly not setting tracesSampleRate,
diff --git a/dev-packages/node-integration-tests/suites/tracing/double-baggage/no-spans/test.ts b/dev-packages/node-integration-tests/suites/tracing/double-baggage/no-spans/test.ts
index c517bca0d25b..283bd16b42df 100644
--- a/dev-packages/node-integration-tests/suites/tracing/double-baggage/no-spans/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/double-baggage/no-spans/test.ts
@@ -31,7 +31,6 @@ describe('double baggage prevention', () => {
 
       await createRunner()
         .withEnv({ SERVER_URL })
-        .ignore('transaction')
         .expect({
           event: {
             exception: {
diff --git a/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-no-parent/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-no-parent/instrument.mjs
index 170ad6f6a702..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-no-parent/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-no-parent/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-no-parent/test.ts b/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-no-parent/test.ts
index 6b5d20cdb5f7..601188c1d414 100644
--- a/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-no-parent/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-no-parent/test.ts
@@ -1,3 +1,5 @@
+import { SENTRY_OP, URL_FULL } from '@sentry/conventions/attributes';
+import { HTTP_CLIENT } from '@sentry/conventions/op';
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
@@ -31,6 +33,7 @@ describe('double baggage prevention', () => {
 
       await createRunner()
         .withEnv({ SERVER_URL })
+        .unordered()
         .expect({
           event: {
             exception: {
@@ -38,6 +41,20 @@ describe('double baggage prevention', () => {
             },
           },
         })
+        .expect({
+          span: container => {
+            const spans = container.items;
+            expect(spans.map(span => span.attributes[URL_FULL]?.value).sort()).toEqual([
+              `${SERVER_URL}/api/fetch`,
+              `${SERVER_URL}/api/fetch-custom-headers`,
+            ]);
+            for (const span of spans) {
+              expect(span.attributes[SENTRY_OP]?.value).toBe(HTTP_CLIENT);
+              expect(span.is_segment).toBe(true);
+              expect(span.parent_span_id).toBeUndefined();
+            }
+          },
+        })
         .start()
         .completed();
       closeTestServer();
diff --git a/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-parent/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-parent/instrument.mjs
index 170ad6f6a702..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-parent/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-parent/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-parent/test.ts b/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-parent/test.ts
index 22de5cb285b3..bc7e62105928 100644
--- a/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-parent/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/double-baggage/spans-parent/test.ts
@@ -1,3 +1,5 @@
+import { SENTRY_OP, URL_FULL } from '@sentry/conventions/attributes';
+import { HTTP_CLIENT } from '@sentry/conventions/op';
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
@@ -6,7 +8,7 @@ import { expectConsistentTraceId, expectNoDuplicateSentryBaggageKeys, expectUser
 
 describe('double baggage prevention - http.client spans with parent span', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
-    let transactionTraceId = '000';
+    let traceId = '000';
     let fetchSpanId = '000';
     let httpCustomHeadersSpanId = '000';
     let fetchCustomHeadersSpanId = '000';
@@ -16,7 +18,7 @@ describe('double baggage prevention - http.client spans with parent span', () =>
         .get('/api/fetch-custom-headers', headers => {
           // fetch with manual getTraceData() headers — core reproduction case
           const sentryTrace = extractTraceparentData(headers['sentry-trace'] as string);
-          transactionTraceId = sentryTrace!.traceId!;
+          traceId = sentryTrace!.traceId!;
           fetchCustomHeadersSpanId = sentryTrace!.parentSpanId!;
           expectNoDuplicateSentryBaggageKeys(headers['baggage']);
           expect(headers['sentry-trace']).not.toContain(',');
@@ -46,42 +48,46 @@ describe('double baggage prevention - http.client spans with parent span', () =>
         .withEnv({ SERVER_URL })
         .ignore('event')
         .expect({
-          transaction: txn => {
-            expect(transactionTraceId).toMatch(/^[a-f0-9]{32}$/);
+          span: container => {
+            expect(traceId).toMatch(/^[a-f0-9]{32}$/);
 
-            expect(txn).toMatchObject({
-              transaction: 'parent_span',
-              spans: [
-                {
-                  op: 'http.client',
-                  description: expect.stringMatching(/^GET .*\/api\/fetch-custom-headers$/),
-                  data: {},
-                  // span id is expected to be different since users call getTraceData() before the
-                  // http.client span is created
-                  span_id: expect.not.stringContaining(fetchCustomHeadersSpanId),
-                  start_timestamp: expect.any(Number),
-                  trace_id: transactionTraceId,
+            expect(container.items.find(span => span.is_segment)?.name).toBe('parent_span');
+            expect(container.items.filter(span => !span.is_segment)).toMatchObject([
+              {
+                name: 'GET localhost',
+                attributes: {
+                  [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+                  [URL_FULL]: { type: 'string', value: expect.stringMatching(/^.*\/api\/fetch-custom-headers$/) },
                 },
-                {
-                  op: 'http.client',
-                  description: expect.stringMatching(/^GET .*\/api\/fetch$/),
-                  data: {},
-                  span_id: fetchSpanId,
-                  start_timestamp: expect.any(Number),
-                  trace_id: transactionTraceId,
+                // span id is expected to be different since users call getTraceData() before the
+                // http.client span is created
+                span_id: expect.not.stringContaining(fetchCustomHeadersSpanId),
+                start_timestamp: expect.any(Number),
+                trace_id: traceId,
+              },
+              {
+                name: 'GET localhost',
+                attributes: {
+                  [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+                  [URL_FULL]: { type: 'string', value: expect.stringMatching(/^.*\/api\/fetch$/) },
                 },
-                {
-                  op: 'http.client',
-                  description: expect.stringMatching(/^GET .*\/api\/http-custom-headers$/),
-                  data: {},
-                  // span id is expected to be different since users call getTraceData() before the
-                  // http.client span is created
-                  span_id: expect.not.stringContaining(httpCustomHeadersSpanId),
-                  start_timestamp: expect.any(Number),
-                  trace_id: transactionTraceId,
+                span_id: fetchSpanId,
+                start_timestamp: expect.any(Number),
+                trace_id: traceId,
+              },
+              {
+                name: 'GET localhost',
+                attributes: {
+                  [SENTRY_OP]: { type: 'string', value: HTTP_CLIENT },
+                  [URL_FULL]: { type: 'string', value: expect.stringMatching(/^.*\/api\/http-custom-headers$/) },
                 },
-              ],
-            });
+                // span id is expected to be different since users call getTraceData() before the
+                // http.client span is created
+                span_id: expect.not.stringContaining(httpCustomHeadersSpanId),
+                start_timestamp: expect.any(Number),
+                trace_id: traceId,
+              },
+            ]);
           },
         })
         .start()
diff --git a/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/scenario-events.ts b/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/scenario-events.ts
index be9bb6c12b5b..37e20c8dc49b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/scenario-events.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/scenario-events.ts
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/scenario-headers.ts b/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/scenario-headers.ts
index 4dfae58a9059..33f1b78126c6 100644
--- a/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/scenario-headers.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/scenario-headers.ts
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/test.ts b/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/test.ts
index ddac08fe1b21..821662369b80 100644
--- a/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/test.ts
@@ -53,7 +53,7 @@ test('adds current transaction name to baggage when the txn name is high-quality
   await createRunner(__dirname, 'scenario-headers.ts')
     .withEnv({ SERVER_URL })
     .expect({
-      transaction: {},
+      span: {},
     })
     .start()
     .completed();
@@ -106,7 +106,7 @@ test('adds current transaction name to trace envelope header when the txn name i
       },
     })
     .expectHeader({
-      transaction: {
+      span: {
         trace: {
           environment: 'production',
           public_key: 'public',
diff --git a/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp-errors/no-server.js b/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp-errors/no-server.js
index 450a47635ef1..ac0122b48380 100644
--- a/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp-errors/no-server.js
+++ b/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp-errors/no-server.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   transport: loggingTransport,
diff --git a/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp-errors/server.js b/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp-errors/server.js
index f7a3ce3b9380..70e895389337 100644
--- a/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp-errors/server.js
+++ b/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp-errors/server.js
@@ -2,7 +2,6 @@ const { loggingTransport, startExpressServerAndSendPortToRunner } = require('@se
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   transport: loggingTransport,
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp/server.js b/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp/server.js
index 0b47fbdf999d..dbea874b90f6 100644
--- a/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp/server.js
+++ b/dev-packages/node-integration-tests/suites/tracing/meta-tags-twp/server.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   transport: loggingTransport,
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/meta-tags/server-sdk-disabled.js b/dev-packages/node-integration-tests/suites/tracing/meta-tags/server-sdk-disabled.js
index b226bf98efdb..03eb3cf16c2d 100644
--- a/dev-packages/node-integration-tests/suites/tracing/meta-tags/server-sdk-disabled.js
+++ b/dev-packages/node-integration-tests/suites/tracing/meta-tags/server-sdk-disabled.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
diff --git a/dev-packages/node-integration-tests/suites/tracing/meta-tags/server-tracesSampleRate-zero.js b/dev-packages/node-integration-tests/suites/tracing/meta-tags/server-tracesSampleRate-zero.js
index 32260783df21..be18fb9731ca 100644
--- a/dev-packages/node-integration-tests/suites/tracing/meta-tags/server-tracesSampleRate-zero.js
+++ b/dev-packages/node-integration-tests/suites/tracing/meta-tags/server-tracesSampleRate-zero.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 0,
   transport: loggingTransport,
diff --git a/dev-packages/node-integration-tests/suites/tracing/meta-tags/server.js b/dev-packages/node-integration-tests/suites/tracing/meta-tags/server.js
index 5f85d27e1918..5050887b78fe 100644
--- a/dev-packages/node-integration-tests/suites/tracing/meta-tags/server.js
+++ b/dev-packages/node-integration-tests/suites/tracing/meta-tags/server.js
@@ -2,7 +2,6 @@ const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 const Sentry = require('@sentry/node');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1.0,
   transport: loggingTransport,

From 3e2e07607617fb11f3c00eb7da8e364d96b02c66 Mon Sep 17 00:00:00 2001
From: Martin Sonnberger <martin.sonnberger@sentry.io>
Date: Fri, 9 Oct 2026 13:15:31 +0200
Subject: [PATCH 30/84] fix(core): Strip internal custom span name from
 streamed spans (#25212)

`Sentry.updateSpanName` stores `sentry.custom_span_name` for internal
naming precedence, but streamed spans currently send it to the backend.
Remove it during serialization, matching static spans while preserving
the renamed span name.

---------

Co-authored-by: OpenAI ChatGPT <codex@openai.com>
---
 .../pageload-updateSpanName/test.ts                          | 2 +-
 packages/core/src/tracing/spans/captureSpan.ts               | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/test.ts
index 0ee7a634717f..b62585b2f881 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-updateSpanName/test.ts
@@ -34,7 +34,7 @@ sentryTest(
       [SENTRY_OP]: { type: 'string', value: 'pageload' },
     });
 
-    expect(attributes[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]).toEqual({ type: 'string', value: 'new name' });
+    expect(attributes[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME]).toBeUndefined();
 
     expect(pageloadSpan.name).toBe('new name');
 
diff --git a/packages/core/src/tracing/spans/captureSpan.ts b/packages/core/src/tracing/spans/captureSpan.ts
index 60a68697ae58..886f0d95cc0e 100644
--- a/packages/core/src/tracing/spans/captureSpan.ts
+++ b/packages/core/src/tracing/spans/captureSpan.ts
@@ -1,6 +1,7 @@
 import type { RawAttributes } from '../../attributes';
 import type { Client } from '../../client';
 import type { ScopeData } from '../../scope';
+import { SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME } from '../../semanticAttributes';
 import type { SerializedStreamedSpan, Span, SpanAttributeValue, SpanJSON, StreamedSpanJSON } from '../../types/span';
 import { getCombinedScopeData } from '../../utils/scopeData';
 import {
@@ -45,6 +46,10 @@ export type SerializedStreamedSpanWithSegmentSpan = SerializedStreamedSpan & {
 export function captureSpan(span: Span, client: Client): SerializedStreamedSpanWithSegmentSpan {
   // Convert to JSON FIRST - we cannot write to an already-ended span
   const spanJSON = spanToJSON(span);
+  if (spanJSON.attributes) {
+    // oxlint-disable-next-line typescript/no-dynamic-delete
+    delete spanJSON.attributes[SEMANTIC_ATTRIBUTE_SENTRY_CUSTOM_SPAN_NAME];
+  }
 
   const segmentSpan = INTERNAL_getSegmentSpan(span);
   const serializedSegmentSpan = spanToJSON(segmentSpan);

From 090464a394eb80188e390241fe062216cb007157 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 9 Oct 2026 11:23:42 +0000
Subject: [PATCH 31/84] feat(deps): Bump handlebars from 4.7.9 to 4.7.10
 (#25206)

Bumps [handlebars](https://github.com/handlebars-lang/handlebars.js)
from 4.7.9 to 4.7.10.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a
href="https://github.com/handlebars-lang/handlebars.js/releases">handlebars's
releases</a>.</em></p>
<blockquote>
<h2>v4.7.10</h2>
<ul>
<li>security: Sanitize the source map URL when minifying - f37c599</li>
<li>security: Iterate lazily in #each and strip whitespace in linear
time - 812c226</li>
<li>security: Escape <code>&lt;!--</code> and <code>&lt;script</code> in
precompiled output - 609d1b1 GHSA-xw65-4hp5-5hc7</li>
<li>security: Don't trust special properties on context data - ceec388
GHSA-p8wg-vrv2-v86f</li>
<li>security: Only compile partials that are template strings -
c28ee7a</li>
<li>security: Only dispatch known node types in the Compiler and Visitor
- 7d501a5</li>
<li>security: Validate AST values in the compiler instead of the parser
- 703fdcc GHSA-8r5x-fm3f-whwj</li>
<li>Clarify that --root does not restrict filesystem access -
0fcf25c</li>
<li>Bump minimist to ^1.2.8 - ea8ed82</li>
<li>Fix Ruby component publishing documentation - d069c1c</li>
<li>Fix Composer component definition - 6714e07</li>
</ul>
<p>Compatibility notes:</p>
<ul>
<li><code>{{#each}}</code> iterates iterables such as <code>Map</code>,
<code>Set</code> and generators lazily, like <code>for...of</code>,
instead of
copying them into an array first. Values added to the iterable while the
block renders are now visited too.</li>
</ul>
<p><a
href="https://github.com/handlebars-lang/handlebars.js/compare/v4.7.9...v4.7.10">Commits</a></p>
</blockquote>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a
href="https://github.com/handlebars-lang/handlebars.js/blob/v4.7.10/release-notes.md">handlebars's
changelog</a>.</em></p>
<blockquote>
<h2>v4.7.10 - October 5th, 2026</h2>
<ul>
<li>security: Sanitize the source map URL when minifying - f37c599</li>
<li>security: Iterate lazily in #each and strip whitespace in linear
time - 812c226</li>
<li>security: Escape <code>&lt;!--</code> and <code>&lt;script</code> in
precompiled output - 609d1b1 GHSA-xw65-4hp5-5hc7</li>
<li>security: Don't trust special properties on context data - ceec388
GHSA-p8wg-vrv2-v86f</li>
<li>security: Only compile partials that are template strings -
c28ee7a</li>
<li>security: Only dispatch known node types in the Compiler and Visitor
- 7d501a5</li>
<li>security: Validate AST values in the compiler instead of the parser
- 703fdcc GHSA-8r5x-fm3f-whwj</li>
<li>Clarify that --root does not restrict filesystem access -
0fcf25c</li>
<li>Bump minimist to ^1.2.8 - ea8ed82</li>
<li>Fix Ruby component publishing documentation - d069c1c</li>
<li>Fix Composer component definition - 6714e07</li>
</ul>
<p>Compatibility notes:</p>
<ul>
<li><code>{{#each}}</code> iterates iterables such as <code>Map</code>,
<code>Set</code> and generators lazily, like <code>for...of</code>,
instead of
copying them into an array first. Values added to the iterable while the
block renders are now visited too.</li>
</ul>
<p><a
href="https://github.com/handlebars-lang/handlebars.js/compare/v4.7.9...v4.7.10">Commits</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/handlebars-lang/handlebars.js/commit/45ce15255e0f430ac6d19742b18e316b7539264e"><code>45ce152</code></a>
v4.7.10</li>
<li><a
href="https://github.com/handlebars-lang/handlebars.js/commit/e47b2365d5656ab5689ae226aef90a485a90c5d8"><code>e47b236</code></a>
Update release notes</li>
<li><a
href="https://github.com/handlebars-lang/handlebars.js/commit/f37c599de9187715eb1e9afedcb2d80c175487a0"><code>f37c599</code></a>
Sanitize the source map URL when minifying</li>
<li><a
href="https://github.com/handlebars-lang/handlebars.js/commit/812c2260cb8794ef4ab63a7f1d946431112560ca"><code>812c226</code></a>
Iterate lazily in #each and strip whitespace in linear time</li>
<li><a
href="https://github.com/handlebars-lang/handlebars.js/commit/609d1b11c833c9a3e00f56f2f34d22f425446725"><code>609d1b1</code></a>
Escape <code>&lt;!--</code> and <code>&lt;script</code> in precompiled
output</li>
<li><a
href="https://github.com/handlebars-lang/handlebars.js/commit/ceec388abe1d1aac8f6369860d5f390fa71ef4fa"><code>ceec388</code></a>
Don't trust special properties on context data</li>
<li><a
href="https://github.com/handlebars-lang/handlebars.js/commit/c28ee7adb312308e0fe26f4d435a481be5e1ff98"><code>c28ee7a</code></a>
Only compile partials that are template strings</li>
<li><a
href="https://github.com/handlebars-lang/handlebars.js/commit/7d501a5af2ac3aa9ac788a8889dbe419849e46f1"><code>7d501a5</code></a>
Only dispatch known node types in the Compiler and Visitor</li>
<li><a
href="https://github.com/handlebars-lang/handlebars.js/commit/703fdcc5fd6cc8d1cc0c33cc19de40c467c4b8d2"><code>703fdcc</code></a>
Validate AST values in the compiler instead of the parser</li>
<li><a
href="https://github.com/handlebars-lang/handlebars.js/commit/0fcf25c63038b43e78e17adbf029cf073e80554d"><code>0fcf25c</code></a>
Clarify that --root does not restrict filesystem access</li>
<li>Additional commits viewable in <a
href="https://github.com/handlebars-lang/handlebars.js/compare/v4.7.9...v4.7.10">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=handlebars&package-manager=npm_and_yarn&previous-version=4.7.9&new-version=4.7.10)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the
[Security Alerts
page](https://github.com/getsentry/sentry-javascript/network/alerts).

</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 yarn.lock | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/yarn.lock b/yarn.lock
index 190af4e5ae9e..f4376646ccb5 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -16786,11 +16786,11 @@ handle-thing@^2.0.0:
   integrity sha512-9Qn4yBxelxoh2Ow62nP+Ka/kMnOXRi8BXnRaUwezLNhqelnN49xKz4F/dPP8OYLxLxq6JDtZb2i9XznUQbNPTg==
 
 handlebars@^4.7.7, handlebars@^4.7.8:
-  version "4.7.9"
-  resolved "https://registry.yarnpkg.com/handlebars/-/handlebars-4.7.9.tgz#6f139082ab58dc4e5a0e51efe7db5ae890d56a0f"
-  integrity sha512-4E71E0rpOaQuJR2A3xDZ+GM1HyWYv1clR58tC8emQNeQe3RH7MAzSbat+V0wG78LQBo6m6bzSG/L4pBuCsgnUQ==
+  version "4.7.10"
+  resolved "https://registry.yarnpkg.com/handlebars/-/handlebars-4.7.10.tgz#12419ea1b41391b3ffcf003f2164dcbce090c417"
+  integrity sha512-P5VJMVM7qgBn6vjXMw8WG9uVI+ncf2pi72j4de4yz5ZULLj2RGqLYaKOYGsgyrViQ0tePOVlN1tDCCXXtFqXKg==
   dependencies:
-    minimist "^1.2.5"
+    minimist "^1.2.8"
     neo-async "^2.6.2"
     source-map "^0.6.1"
     wordwrap "^1.0.0"
@@ -20030,7 +20030,7 @@ minimatch@^9.0.0, minimatch@^9.0.4:
   dependencies:
     brace-expansion "^2.0.2"
 
-minimist@1.2.8, minimist@^1.1.1, minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6:
+minimist@1.2.8, minimist@^1.1.1, minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6, minimist@^1.2.8:
   version "1.2.8"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c"
   integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==

From 0df390322a452a69095c2e23a28807c688f235a3 Mon Sep 17 00:00:00 2001
From: Philip John <95682231+Philip-Nwabuwa@users.noreply.github.com>
Date: Fri, 9 Oct 2026 13:03:29 +0100
Subject: [PATCH 32/84] test(deno): Type-check Deno unit tests (#25227)

`deno test` runs with `--no-check`, and `lint:types` only covers `src`,
so type errors in `packages/deno/test` never failed CI. This adds a
`test:types` step that runs before `test:unit`, and fixes the five type
errors it surfaced.

Simply dropping `--no-check` doesn't work in the monorepo: workspace
packages (`@sentry/core`, `@sentry/server-utils`, ...) are symlinked
into `node_modules`, so Deno treats their emitted `.d.ts` files as local
modules and can't resolve their extensionless relative imports. Running
with `--unstable-sloppy-imports` resolves those and also picks up
`build/esm/*.d.ts` for the tests' `../build/esm/index.js` imports, so
the tests are checked against the SDK's real types.

The check runs as a separate `test:types` step so the test run itself
keeps Deno's strict runtime resolution and still catches a broken
specifier in the build output. It adds roughly 3.5s on a cold cache.

`dev-packages/deno-integration-tests` also runs with `--no-check`; I
left that for a follow-up.

Fixes #23899
---
 packages/deno/package.json                      | 3 ++-
 packages/deno/test/deno-runtime-metrics.test.ts | 2 +-
 packages/deno/test/opentelemetry.test.ts        | 5 +++--
 packages/deno/test/sdk.test.ts                  | 7 ++++---
 4 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/packages/deno/package.json b/packages/deno/package.json
index b1e3996e8dfd..99dcec12e7c6 100644
--- a/packages/deno/package.json
+++ b/packages/deno/package.json
@@ -49,7 +49,8 @@
     "lint:fix": "oxlint . --fix --type-aware",
     "lint:es-compatibility": "es-check es2022 ./build/esm/*.js --module",
     "install:deno": "node ./scripts/install-deno.mjs",
-    "test": "run-s install:deno deno-types test:unit",
+    "test": "run-s install:deno deno-types test:types test:unit",
+    "test:types": "deno check --unstable-sloppy-imports test",
     "test:unit": "deno test --allow-net --allow-read --allow-run --allow-env --no-check",
     "test:unit:update": "deno test --allow-net --allow-read --allow-run --allow-env --no-check --allow-write -- --update",
     "yalc:publish": "yalc publish --push --sig"
diff --git a/packages/deno/test/deno-runtime-metrics.test.ts b/packages/deno/test/deno-runtime-metrics.test.ts
index 0dfdc5d35d6a..947cc1777e0f 100644
--- a/packages/deno/test/deno-runtime-metrics.test.ts
+++ b/packages/deno/test/deno-runtime-metrics.test.ts
@@ -45,7 +45,7 @@ async function collectMetrics(
   await client.flush(2000);
 
   // Stop the collection interval so Deno's leak detector doesn't flag it.
-  metricsIntegration.teardown?.();
+  (metricsIntegration as { teardown?: () => void }).teardown?.();
 
   const items: MetricItem[] = [];
   for (const envelope of envelopes) {
diff --git a/packages/deno/test/opentelemetry.test.ts b/packages/deno/test/opentelemetry.test.ts
index 12349ea6a78a..c8847ad3c468 100644
--- a/packages/deno/test/opentelemetry.test.ts
+++ b/packages/deno/test/opentelemetry.test.ts
@@ -1,5 +1,6 @@
 import { getMainCarrier } from '@sentry/core';
 import { assertEquals, assertNotEquals } from 'https://deno.land/std@0.212.0/assert/mod.ts';
+import type { TracerProvider } from 'npm:@opentelemetry/api@1';
 import { context, propagation, trace } from 'npm:@opentelemetry/api@1';
 import type { DenoClient } from '../build/esm/index.js';
 import { init, startSpan } from '../build/esm/index.js';
@@ -149,8 +150,8 @@ Deno.test('should override pre-existing OTel provider with Sentry provider', asy
   resetSdk();
 
   // Simulate a pre-existing OTel registration (e.g. from Supabase Edge Runtime)
-  const fakeProvider = { getTracer: () => ({}) };
-  trace.setGlobalTracerProvider(fakeProvider as any);
+  const fakeProvider = { getTracer: () => ({}) } as unknown as TracerProvider;
+  trace.setGlobalTracerProvider(fakeProvider);
 
   const transactionEvents: any[] = [];
 
diff --git a/packages/deno/test/sdk.test.ts b/packages/deno/test/sdk.test.ts
index fe85e2ff9f45..032442ece005 100644
--- a/packages/deno/test/sdk.test.ts
+++ b/packages/deno/test/sdk.test.ts
@@ -6,10 +6,11 @@ import {
   init as initSdk,
   spanStreamingIntegration,
 } from '../build/esm/index.js';
+import type { DenoOptions } from '../build/esm/index.js';
 import { assert } from 'https://deno.land/std@0.212.0/assert/assert.ts';
 import { assertEquals } from 'https://deno.land/std@0.212.0/assert/assert_equals.ts';
 
-function init(options) {
+function init(options: DenoOptions) {
   getCurrentScope().setClient(undefined);
   return initSdk(options);
 }
@@ -40,7 +41,7 @@ Deno.test("doesn't add spanStreamingIntegration if user added it manually", () =
   });
   const integrations = client.getOptions().integrations.filter(i => i.name === 'SpanStreaming');
   assertEquals(integrations.length, 1);
-  assert(!integrations[0].isDefaultInstance);
+  assert(!(integrations[0] as { isDefaultInstance?: true }).isDefaultInstance);
 });
 
 Deno.test("doesn't add tracing integrations when tracing is disabled", () => {
@@ -73,7 +74,7 @@ Deno.test('getDefaultIntegrations gates the tracing set on the options it is giv
 });
 
 Deno.test("init doesn't write the computed default integrations back onto the options object", () => {
-  const options = { dsn: 'https://username@domain/123' };
+  const options: DenoOptions = { dsn: 'https://username@domain/123' };
   init(options);
   assertEquals('defaultIntegrations' in options, false);
   options.tracesSampleRate = 1;

From 072b26970aa51985f1aafae25b0bce55ea127072 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Fri, 9 Oct 2026 14:14:38 +0200
Subject: [PATCH 33/84] ref(core): Simplify transport item loss recording
 (#25224)

Realized a second after merging #25185 that the report logic can be
simplified to save a few bytes.
---
 packages/core/src/transports/base.ts           | 4 +---
 packages/core/test/lib/transports/base.test.ts | 6 +++---
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/packages/core/src/transports/base.ts b/packages/core/src/transports/base.ts
index 86c52037d6f7..b88568de269a 100644
--- a/packages/core/src/transports/base.ts
+++ b/packages/core/src/transports/base.ts
@@ -40,12 +40,10 @@ export function createTransport(
   function recordItemLoss(reason: EventDropReason, [headers, payload]: EnvelopeItem, type: EnvelopeItemType): void {
     const dataCategory = envelopeItemTypeToDataCategory(type);
     if (type === 'transaction') {
-      options.recordDroppedEvent(reason, dataCategory);
       // The transaction itself counts as a span, too
       options.recordDroppedEvent(reason, 'span', ((payload as Event).spans?.length ?? 0) + 1);
-    } else {
-      options.recordDroppedEvent(reason, dataCategory, typeof headers.item_count === 'number' ? headers.item_count : 1);
     }
+    options.recordDroppedEvent(reason, dataCategory, typeof headers.item_count === 'number' ? headers.item_count : 1);
   }
 
   function send(envelope: Envelope): PromiseLike<TransportMakeRequestResponse> {
diff --git a/packages/core/test/lib/transports/base.test.ts b/packages/core/test/lib/transports/base.test.ts
index 9a2a0ef6275b..3ef558c349a1 100644
--- a/packages/core/test/lib/transports/base.test.ts
+++ b/packages/core/test/lib/transports/base.test.ts
@@ -241,7 +241,7 @@ describe('createTransport', () => {
 
         await transport.send(TRANSACTION_ENVELOPE); // Transaction envelope should not be sent because of pending rate limit
         expect(requestExecutor).not.toHaveBeenCalled();
-        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'transaction');
+        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'transaction', 1);
         expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'span', 1);
         requestExecutor.mockClear();
         recordDroppedEventCallback.mockClear();
@@ -302,7 +302,7 @@ describe('createTransport', () => {
 
         await transport.send(TRANSACTION_ENVELOPE); // Transaction envelope should not be sent because of pending rate limit
         expect(requestExecutor).not.toHaveBeenCalled();
-        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'transaction');
+        expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'transaction', 1);
         expect(recordDroppedEventCallback).toHaveBeenCalledWith('ratelimit_backoff', 'span', 1);
         requestExecutor.mockClear();
         recordDroppedEventCallback.mockClear();
@@ -454,7 +454,7 @@ describe('createTransport', () => {
 
         expect(mockRecordDroppedEventCallback).toHaveBeenCalledTimes(3);
         expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'error', 1);
-        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'transaction');
+        expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'transaction', 1);
         expect(mockRecordDroppedEventCallback).toHaveBeenCalledWith('send_error', 'span', 3);
       });
 

From 01935a5f49d4c6c7229f7ed171bebf3a94637bc6 Mon Sep 17 00:00:00 2001
From: Charly Gomez <charly.gomez1310@gmail.com>
Date: Fri, 9 Oct 2026 14:15:09 +0200
Subject: [PATCH 34/84] fix(sveltekit): Stop adapter-node 6 output dir probe
 from deleting the build (#25193)

To find the Node adapter's output directory, we call the adapter's
`adapt()` with a stub builder. adapter-node 6 deletes its output folder
with `fs.rmSync` before it uses the builder, so every Vite config load
(`vite dev`, `svelte-kit sync`, `vite build`) wiped the user's `build/`
folder. We now call `adapt()` from an empty temp cwd, so the delete hits
the temp folder instead.

This also fixes custom `out` detection with SvelteKit 3. The stub
builder only had the SvelteKit 2 config shape, so adapter-node 6 threw
early and we always fell back to `build`.

An absolute `out` path is still deleted, since the temp cwd only
protects relative paths.

Fixes #25186

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../sveltekit/src/vite/sentryVitePlugins.ts   |  6 ++--
 packages/sveltekit/src/vite/svelteConfig.ts   | 30 +++++++++++++++-
 .../sveltekit/test/vite/svelteConfig.test.ts  | 36 ++++++++++++++++++-
 3 files changed, 67 insertions(+), 5 deletions(-)

diff --git a/packages/sveltekit/src/vite/sentryVitePlugins.ts b/packages/sveltekit/src/vite/sentryVitePlugins.ts
index 9052560af04b..d4bf6ead91ec 100644
--- a/packages/sveltekit/src/vite/sentryVitePlugins.ts
+++ b/packages/sveltekit/src/vite/sentryVitePlugins.ts
@@ -38,9 +38,9 @@ export async function sentrySvelteKit(options: SentrySvelteKitPluginOptions = {}
   const getAdapter = (): Promise<SupportedSvelteKitAdapters> =>
     (adapterPromise ??= (async () => options.adapter || detectAdapter(await getKitConfig(), options.debug))());
 
-  // Side effect: for the Node adapter we invoke `adapter.adapt()` to learn the output directory,
-  // and `@sveltejs/adapter-node` v6 wipes that directory when it runs. So this must happen once,
-  // before the build writes anything - never from a late hook like `closeBundle`.
+  // For the Node adapter we invoke `adapter.adapt()` to learn the output directory. It runs from a temp
+  // cwd so it can't wipe the real output, but it's still resolved once and before the build writes
+  // anything, never from a late hook like `closeBundle`, in case an adapter deletes an absolute `out`.
   let adapterOutputDirPromise: Promise<string> | undefined;
   const getAdapterOutputDirOnce = (): Promise<string> =>
     (adapterOutputDirPromise ??= (async () => getAdapterOutputDir(await getKitConfig(), await getAdapter()))());
diff --git a/packages/sveltekit/src/vite/svelteConfig.ts b/packages/sveltekit/src/vite/svelteConfig.ts
index 3941dc3dbc59..7151ba053f4c 100644
--- a/packages/sveltekit/src/vite/svelteConfig.ts
+++ b/packages/sveltekit/src/vite/svelteConfig.ts
@@ -1,5 +1,6 @@
 import type { Builder } from '@sveltejs/kit';
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import * as url from 'url';
 import type { SupportedSvelteKitAdapters } from './detectAdapter';
@@ -106,7 +107,11 @@ async function getNodeAdapterOutputDir(kitConfig: ResolvedKitConfig): Promise<st
     rimraf: () => {},
     mkdirp: () => {},
 
+    // SvelteKit 3 passes the kit config directly (`config.paths`), SvelteKit 2 nests it (`config.kit.paths`)
     config: {
+      paths: {
+        base: kitConfig.paths?.base || '',
+      },
       kit: {
         // @ts-expect-error - the builder expects a validated config but for our purpose it's fine to just pass this partial config
         paths: {
@@ -116,10 +121,33 @@ async function getNodeAdapterOutputDir(kitConfig: ResolvedKitConfig): Promise<st
     },
   };
 
+  // `@sveltejs/adapter-node` v6 deletes its (relative) output dir with `fs.rmSync` before it touches the
+  // builder, so our no-op `rimraf` doesn't help. Running `adapt()` from an empty temp cwd keeps it from
+  // wiping the user's real build output. The rm and `writeClient` both run synchronously, so the cwd is
+  // only changed for the synchronous part of the call and no other code observes it.
+  const originalCwd = process.cwd();
+  let sandboxDir: string | undefined;
+  let adaptResult: unknown;
   try {
-    await nodeAdapter.adapt(adapterBuilder);
+    sandboxDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sentry-sveltekit-'));
+    process.chdir(sandboxDir);
+    adaptResult = nodeAdapter.adapt(adapterBuilder);
   } catch {
     // We expect the adapter to throw in writeClient!
+  } finally {
+    if (process.cwd() !== originalCwd) {
+      process.chdir(originalCwd);
+    }
+  }
+
+  try {
+    await adaptResult;
+  } catch {
+    // We expect the adapter to throw in writeClient!
+  }
+
+  if (sandboxDir) {
+    fs.rmSync(sandboxDir, { recursive: true, force: true });
   }
 
   return outputDir;
diff --git a/packages/sveltekit/test/vite/svelteConfig.test.ts b/packages/sveltekit/test/vite/svelteConfig.test.ts
index 8fc78ff37647..2fbe8792b1b6 100644
--- a/packages/sveltekit/test/vite/svelteConfig.test.ts
+++ b/packages/sveltekit/test/vite/svelteConfig.test.ts
@@ -1,3 +1,6 @@
+import type * as FsModule from 'fs';
+import * as os from 'os';
+import * as path from 'path';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import type { SupportedSvelteKitAdapters } from '../../src/vite/detectAdapter';
 import { getAdapterOutputDir, getHooksFileName, loadSvelteConfig } from '../../src/vite/svelteConfig';
@@ -5,8 +8,10 @@ import { getAdapterOutputDir, getHooksFileName, loadSvelteConfig } from '../../s
 let existsFile: any;
 
 describe('loadSvelteConfig', () => {
-  vi.mock('fs', () => {
+  vi.mock('fs', async importOriginal => {
+    const actual = await importOriginal<typeof FsModule>();
     return {
+      ...actual,
       existsSync: () => existsFile,
     };
   });
@@ -67,6 +72,35 @@ describe('getAdapterOutputDir', () => {
     expect(outputDir).toEqual('customBuildDir');
   });
 
+  it("doesn't let the Node adapter delete the real output directory", async () => {
+    const actualFs = await vi.importActual<typeof FsModule>('fs');
+    const originalCwd = process.cwd();
+    const projectDir = actualFs.mkdtempSync(path.join(os.tmpdir(), 'sentry-sveltekit-test-'));
+    actualFs.mkdirSync(path.join(projectDir, 'customOut'));
+    actualFs.writeFileSync(path.join(projectDir, 'customOut', 'index.js'), '');
+
+    // Like `@sveltejs/adapter-node` v6, which removes its output dir itself instead of via `builder.rimraf`
+    const nodeAdapter = {
+      name: '@sveltejs/adapter-node',
+      async adapt(builder: any) {
+        actualFs.rmSync('customOut', { force: true, recursive: true });
+        builder.writeClient(`customOut/client${builder.config.paths.base}`);
+      },
+    };
+
+    process.chdir(projectDir);
+    try {
+      const outputDir = await getAdapterOutputDir({ adapter: nodeAdapter }, 'node');
+
+      expect(outputDir).toEqual('customOut');
+      expect(process.cwd()).toEqual(actualFs.realpathSync(projectDir));
+      expect(actualFs.readdirSync(path.join(projectDir, 'customOut'))).toEqual(['index.js']);
+    } finally {
+      process.chdir(originalCwd);
+      actualFs.rmSync(projectDir, { force: true, recursive: true });
+    }
+  });
+
   it('returns the output directory of the Cloudflare adapter', async () => {
     const outputDir = await getAdapterOutputDir({ outDir: 'customOutDir' }, 'cloudflare');
     expect(outputDir).toEqual('customOutDir/cloudflare');

From 7315691bed52e8b1a12642692921cb30dd54cc2d Mon Sep 17 00:00:00 2001
From: Sigrid <32902192+s1gr1d@users.noreply.github.com>
Date: Fri, 9 Oct 2026 14:53:36 +0200
Subject: [PATCH 35/84] test(nuxt): Test imports from `nuxt/server` in the
 nuxt-5 E2E app (#25232)

Adds the `nuxt/server` routes and tests from #25093 to `nuxt-5`, so
Nitro v3 also tests both import surfaces. All specs pass with no SDK
change.

The `$fetch` test was skipped on Nuxt 5. It passes with the `nuxt-4`
test assertions, so I updated them and removed the skip.

Closes https://github.com/getsentry/sentry-javascript/issues/25228
---
 .../nuxt-5/app/pages/fetch-server-routes.vue  |  10 +-
 .../nuxt-5/app/pages/test-param/[param].vue   |   3 +-
 .../app/pages/test-param/user/[userId].vue    |   3 +-
 .../server/api/nuxt-server/middleware-test.ts |   9 +
 .../server/api/nuxt-server/nitro-fetch.ts     |   7 +
 .../api/nuxt-server/param-error/[param].ts    |   5 +
 .../server/api/nuxt-server/server-error.ts    |   5 +
 .../api/nuxt-server/third-party-http-error.ts |  16 +
 .../server/api/nuxt-server/user/[userId].ts   |   7 +
 .../nuxt-5/server/api/param-error/[param].ts  |   2 +-
 .../nuxt-5/server/api/server-error.ts         |   2 +-
 .../nuxt-server/06.nuxt-server-first.ts       |   5 +
 .../nuxt-server/07.nuxt-server-auth.ts        |   9 +
 .../nuxt-5/tests/environment.test.ts          |   2 +-
 .../nuxt-5/tests/errors.server.test.ts        | 189 +++++-----
 .../nuxt-5/tests/importSurfaces.ts            |   6 +
 .../nuxt-5/tests/middleware.test.ts           | 327 +++++++-----------
 .../nuxt-5/tests/tracing.server.test.ts       |  58 ++--
 .../nuxt-5/tests/tracing.test.ts              | 192 +++++-----
 19 files changed, 426 insertions(+), 431 deletions(-)
 create mode 100644 dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/middleware-test.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/nitro-fetch.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/param-error/[param].ts
 create mode 100644 dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/server-error.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/third-party-http-error.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/user/[userId].ts
 create mode 100644 dev-packages/e2e-tests/test-applications/nuxt-5/server/middleware/nuxt-server/06.nuxt-server-first.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/nuxt-5/server/middleware/nuxt-server/07.nuxt-server-auth.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/nuxt-5/tests/importSurfaces.ts

diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/fetch-server-routes.vue b/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/fetch-server-routes.vue
index 3547773a1af9..2768eb370f94 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/fetch-server-routes.vue
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/fetch-server-routes.vue
@@ -7,17 +7,19 @@
 </template>
 
 <script setup lang="ts">
-import { useFetch } from '#imports';
+import { useFetch, useRoute } from '#imports';
+
+const apiPrefix = useRoute().query.apiPrefix ?? '/api';
 
 const fetchError = async () => {
-  await useFetch('/api/server-error');
+  await useFetch(`${apiPrefix}/server-error`);
 };
 
 const fetchNitroFetch = async () => {
-  await useFetch('/api/nitro-fetch');
+  await useFetch(`${apiPrefix}/nitro-fetch`);
 };
 
 const fetchThirdPartyHttpError = async () => {
-  await useFetch('/api/third-party-http-error');
+  await useFetch(`${apiPrefix}/third-party-http-error`);
 };
 </script>
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/test-param/[param].vue b/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/test-param/[param].vue
index 019404aaf460..fde203b1575c 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/test-param/[param].vue
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/test-param/[param].vue
@@ -3,9 +3,10 @@ import { useRoute, useFetch } from '#imports';
 
 const route = useRoute();
 const param = route.params.param;
+const apiPrefix = route.query.apiPrefix ?? '/api';
 
 const fetchError = async () => {
-  await useFetch(`/api/param-error/${param}`);
+  await useFetch(`${apiPrefix}/param-error/${param}`);
 };
 
 const fetchData = async () => {
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/test-param/user/[userId].vue b/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/test-param/user/[userId].vue
index 41daf0460b05..39d629b25ad6 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/test-param/user/[userId].vue
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/app/pages/test-param/user/[userId].vue
@@ -3,8 +3,9 @@ import { useFetch, useRoute } from '#imports';
 
 const route = useRoute();
 const userId = route.params.userId as string;
+const apiPrefix = route.query.apiPrefix ?? '/api';
 
-const { data } = await useFetch(`/api/user/${userId}`, {
+const { data } = await useFetch(`${apiPrefix}/user/${userId}`, {
   server: false, // Don't fetch during SSR, only client-side
 });
 </script>
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/middleware-test.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/middleware-test.ts
new file mode 100644
index 000000000000..ab0b283df34b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/middleware-test.ts
@@ -0,0 +1,9 @@
+import { defineEventHandler } from 'nuxt/server';
+
+export default defineEventHandler(event => {
+  return {
+    message: 'Server middleware test endpoint',
+    path: event.url.pathname,
+    method: event.req.method,
+  };
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/nitro-fetch.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/nitro-fetch.ts
new file mode 100644
index 000000000000..8f8f4c4ae4fb
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/nitro-fetch.ts
@@ -0,0 +1,7 @@
+import { defineEventHandler } from 'nuxt/server';
+
+// `$fetch` is a Nitro global, not a `nuxt/server` export, so the portable copy uses `fetch`.
+export default defineEventHandler(async () => {
+  const response = await fetch('https://example.com');
+  return response.text();
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/param-error/[param].ts b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/param-error/[param].ts
new file mode 100644
index 000000000000..6444b45fd145
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/param-error/[param].ts
@@ -0,0 +1,5 @@
+import { defineEventHandler } from 'nuxt/server';
+
+export default defineEventHandler(() => {
+  throw new Error('Nuxt 5 Param Server error');
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/server-error.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/server-error.ts
new file mode 100644
index 000000000000..1d6b6fe10f88
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/server-error.ts
@@ -0,0 +1,5 @@
+import { defineEventHandler } from 'nuxt/server';
+
+export default defineEventHandler(() => {
+  throw new Error('Nuxt 5 Server error');
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/third-party-http-error.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/third-party-http-error.ts
new file mode 100644
index 000000000000..988dd8d3002f
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/third-party-http-error.ts
@@ -0,0 +1,16 @@
+import { defineEventHandler } from 'nuxt/server';
+
+// Mimics ky's and got's `HTTPError`: it shares its `name` with h3's error class, but keeps the
+// status on `response` instead of on the error itself.
+class ThirdPartyHTTPError extends Error {
+  public readonly response = { status: 404 };
+
+  public constructor(message: string) {
+    super(message);
+    this.name = 'HTTPError';
+  }
+}
+
+export default defineEventHandler(() => {
+  throw new ThirdPartyHTTPError('Nuxt 5 third-party HTTPError');
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/user/[userId].ts b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/user/[userId].ts
new file mode 100644
index 000000000000..6fff4f8f91b4
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/nuxt-server/user/[userId].ts
@@ -0,0 +1,7 @@
+import { defineEventHandler, getRouterParam } from 'nuxt/server';
+
+export default defineEventHandler(event => {
+  const userId = getRouterParam(event, 'userId');
+
+  return `UserId Param: ${userId}!`;
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/param-error/[param].ts b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/param-error/[param].ts
index 3422c275abe0..a0e597ead72b 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/param-error/[param].ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/param-error/[param].ts
@@ -1,5 +1,5 @@
 import { defineHandler } from 'nitro';
 
 export default defineHandler(_e => {
-  throw new Error('Nuxt 4 Param Server error');
+  throw new Error('Nuxt 5 Param Server error');
 });
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/server-error.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/server-error.ts
index 23b89ce2c287..7533424e6657 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/server-error.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/server/api/server-error.ts
@@ -1,5 +1,5 @@
 import { defineHandler } from 'nitro';
 
 export default defineHandler(event => {
-  throw new Error('Nuxt 4 Server error');
+  throw new Error('Nuxt 5 Server error');
 });
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/server/middleware/nuxt-server/06.nuxt-server-first.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/server/middleware/nuxt-server/06.nuxt-server-first.ts
new file mode 100644
index 000000000000..58d68a494905
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/server/middleware/nuxt-server/06.nuxt-server-first.ts
@@ -0,0 +1,5 @@
+import { defineEventHandler } from 'nuxt/server';
+
+export default defineEventHandler(event => {
+  event.res.headers.set('x-nuxt-server-first-middleware', 'executed');
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/server/middleware/nuxt-server/07.nuxt-server-auth.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/server/middleware/nuxt-server/07.nuxt-server-auth.ts
new file mode 100644
index 000000000000..62b19ad9c1ef
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/server/middleware/nuxt-server/07.nuxt-server-auth.ts
@@ -0,0 +1,9 @@
+import { defineEventHandler, getQuery } from 'nuxt/server';
+
+export default defineEventHandler(event => {
+  if (getQuery(event).throwNuxtServerError === 'true') {
+    throw new Error('nuxt/server auth middleware error');
+  }
+
+  event.res.headers.set('x-nuxt-server-auth-middleware', 'executed');
+});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/environment.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/environment.test.ts
index d7ac4e437d7e..ecd946274a68 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/environment.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/environment.test.ts
@@ -39,7 +39,7 @@ test.describe('environment detection', async () => {
 
   test('sets correct environment for server-side errors', async ({ page }) => {
     const errorPromise = waitForError('nuxt-5', async errorEvent => {
-      return errorEvent?.exception?.values?.[0]?.value === 'Nuxt 4 Server error';
+      return errorEvent?.exception?.values?.[0]?.value === 'Nuxt 5 Server error';
     });
 
     await page.goto(`/fetch-server-routes`, isDevMode ? { waitUntil: 'networkidle' } : {});
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/errors.server.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/errors.server.test.ts
index ebe8b5097d5d..1917990af924 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/errors.server.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/errors.server.test.ts
@@ -1,95 +1,112 @@
 import { expect, test } from '@playwright/test';
 import { waitForError } from '@sentry-internal/test-utils';
-
-test.describe('server-side errors', async () => {
-  test('captures api fetch error (fetched on click)', async ({ page }) => {
-    const errorPromise = waitForError('nuxt-5', async errorEvent => {
-      return errorEvent?.exception?.values?.[0]?.value === 'Nuxt 4 Server error';
-    });
-
-    await page.goto(`/fetch-server-routes`);
-    await page.getByText('Fetch Server API Error', { exact: true }).click();
-
-    const error = await errorPromise;
-
-    expect(error.transaction).toEqual('GET /api/server-error');
-
-    const exception0 = error.exception.values[0];
-    const exception1 = error.exception.values[1];
-
-    expect(exception0.type).toEqual('Error');
-    expect(exception0.value).toEqual('Nuxt 4 Server error');
-    expect(exception0.mechanism).toEqual({
-      handled: true,
-      type: 'chained',
-      exception_id: 1,
-      parent_id: 0,
-      source: 'cause',
-    });
-
-    expect(exception1.type).toEqual('HTTPError');
-    expect(exception1.value).toEqual('Nuxt 4 Server error');
-    expect(exception1.mechanism).toEqual({
-      handled: false,
-      type: 'auto.function.nuxt.nitro',
-      exception_id: 0,
-    });
-  });
-
-  test('captures api fetch error (fetched on click) with parametrized route', async ({ page }) => {
-    const errorPromise = waitForError('nuxt-5', async errorEvent => {
-      return errorEvent?.exception?.values?.[0]?.value === 'Nuxt 4 Param Server error';
+import { IMPORT_SURFACES } from './importSurfaces';
+
+IMPORT_SURFACES.forEach(({ name, apiPrefix }) => {
+  test.describe(`server-side errors (${name})`, () => {
+    test('captures api fetch error (fetched on click)', async ({ page }) => {
+      const errorPromise = waitForError('nuxt-5', async errorEvent => {
+        return errorEvent?.exception?.values?.[0]?.value === 'Nuxt 5 Server error';
+      });
+
+      await page.goto(`/fetch-server-routes?apiPrefix=${apiPrefix}`);
+      await page.getByText('Fetch Server API Error', { exact: true }).click();
+
+      const error = await errorPromise;
+
+      expect(error.transaction).toEqual(`GET ${apiPrefix}/server-error`);
+
+      const exception0 = error.exception.values[0];
+      const exception1 = error.exception.values[1];
+
+      expect(exception0.type).toEqual('Error');
+      expect(exception0.value).toEqual('Nuxt 5 Server error');
+      expect(exception0.mechanism).toEqual({
+        handled: true,
+        type: 'chained',
+        exception_id: 1,
+        parent_id: 0,
+        source: 'cause',
+      });
+
+      expect(exception1.type).toEqual('HTTPError');
+      expect(exception1.value).toEqual('Nuxt 5 Server error');
+      expect(exception1.mechanism).toEqual({
+        handled: false,
+        type: 'auto.function.nuxt.nitro',
+        exception_id: 0,
+      });
     });
 
-    await page.goto(`/test-param/1234`);
-    await page.getByRole('button', { name: 'Fetch Server API Error', exact: true }).click();
-
-    const error = await errorPromise;
-
-    expect(error.transaction).toEqual('GET /api/param-error/1234');
-
-    const exception0 = error.exception.values[0];
-    const exception1 = error.exception.values[1];
-
-    expect(exception0.type).toEqual('Error');
-    expect(exception0.value).toEqual('Nuxt 4 Param Server error');
-    expect(exception0.mechanism).toEqual({
-      handled: true,
-      type: 'chained',
-      exception_id: 1,
-      parent_id: 0,
-      source: 'cause',
+    test('captures api fetch error (fetched on click) with parametrized route', async ({ page }) => {
+      const errorPromise = waitForError('nuxt-5', async errorEvent => {
+        return errorEvent?.exception?.values?.[0]?.value === 'Nuxt 5 Param Server error';
+      });
+
+      await page.goto(`/test-param/1234?apiPrefix=${apiPrefix}`);
+      await page.getByRole('button', { name: 'Fetch Server API Error', exact: true }).click();
+
+      const error = await errorPromise;
+
+      expect(error.transaction).toEqual(`GET ${apiPrefix}/param-error/1234`);
+
+      const exception0 = error.exception.values[0];
+      const exception1 = error.exception.values[1];
+
+      expect(exception0.type).toEqual('Error');
+      expect(exception0.value).toEqual('Nuxt 5 Param Server error');
+      expect(exception0.mechanism).toEqual({
+        handled: true,
+        type: 'chained',
+        exception_id: 1,
+        parent_id: 0,
+        source: 'cause',
+      });
+
+      expect(exception1.type).toEqual('HTTPError');
+      expect(exception1.value).toEqual('Nuxt 5 Param Server error');
+      expect(exception1.mechanism).toEqual({
+        handled: false,
+        type: 'auto.function.nuxt.nitro',
+        exception_id: 0,
+      });
     });
 
-    expect(exception1.type).toEqual('HTTPError');
-    expect(exception1.value).toEqual('Nuxt 4 Param Server error');
-    expect(exception1.mechanism).toEqual({
-      handled: false,
-      type: 'auto.function.nuxt.nitro',
-      exception_id: 0,
+    // ky and got name their errors `HTTPError` too. h3 wraps a thrown one in its own error before the
+    // hook sees it, so this checks it still gets reported. The hook's handling of an unwrapped lookalike
+    // is covered by the unit tests.
+    test('captures a thrown third-party `HTTPError`', async ({ page }) => {
+      const errorPromise = waitForError('nuxt-5', async errorEvent => {
+        return !!errorEvent?.exception?.values?.some(value => value.value === 'Nuxt 5 third-party HTTPError');
+      });
+
+      await page.goto(`/fetch-server-routes?apiPrefix=${apiPrefix}`);
+      await page.getByText('Fetch Third-Party HTTPError', { exact: true }).click();
+
+      const error = await errorPromise;
+
+      expect(error.transaction).toEqual(`GET ${apiPrefix}/third-party-http-error`);
+      expect(error.exception.values).toHaveLength(2);
+
+      const [thirdPartyError, h3Error] = error.exception.values;
+
+      expect(thirdPartyError.type).toEqual('HTTPError');
+      expect(thirdPartyError.value).toEqual('Nuxt 5 third-party HTTPError');
+      expect(thirdPartyError.mechanism).toEqual({
+        handled: true,
+        type: 'chained',
+        exception_id: 1,
+        parent_id: 0,
+        source: 'cause',
+      });
+
+      expect(h3Error.type).toEqual('HTTPError');
+      expect(h3Error.value).toEqual('Nuxt 5 third-party HTTPError');
+      expect(h3Error.mechanism).toEqual({
+        handled: false,
+        type: 'auto.function.nuxt.nitro',
+        exception_id: 0,
+      });
     });
   });
-
-  // ky and got name their errors `HTTPError` too. h3 wraps a thrown one in its own error before the
-  // hook sees it, so this checks it still gets reported. The hook's handling of an unwrapped lookalike
-  // is covered by the unit tests.
-  test('captures a thrown third-party `HTTPError`', async ({ page }) => {
-    const errorPromise = waitForError('nuxt-5', async errorEvent => {
-      return !!errorEvent?.exception?.values?.some(value => value.value === 'Nuxt 5 third-party HTTPError');
-    });
-
-    await page.goto(`/fetch-server-routes`);
-    await page.getByText('Fetch Third-Party HTTPError', { exact: true }).click();
-
-    const error = await errorPromise;
-
-    expect(error.transaction).toEqual('GET /api/third-party-http-error');
-    expect(error.exception.values).toContainEqual(
-      expect.objectContaining({
-        type: 'HTTPError',
-        value: 'Nuxt 5 third-party HTTPError',
-        mechanism: expect.objectContaining({ handled: false, type: 'auto.function.nuxt.nitro' }),
-      }),
-    );
-  });
 });
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/importSurfaces.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/importSurfaces.ts
new file mode 100644
index 000000000000..8c7d4b02b307
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/importSurfaces.ts
@@ -0,0 +1,6 @@
+// The server test routes under `apiPrefix` are copies of each other that differ only in where they import from.
+// Reference: https://github.com/nuxt/nuxt/pull/36275
+export const IMPORT_SURFACES = [
+  { name: 'nitro', apiPrefix: '/api' },
+  { name: 'nuxt/server', apiPrefix: '/api/nuxt-server' },
+] as const;
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/middleware.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/middleware.test.ts
index fdcade103524..e2c12def7864 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/middleware.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/middleware.test.ts
@@ -1,286 +1,193 @@
 import { expect, test } from '@playwright/test';
 import { collectStreamedSpansUntilSegment, getSpanOp, waitForError } from '@sentry-internal/test-utils';
+import type { SerializedStreamedSpan } from '@sentry-internal/test-utils';
+import { IMPORT_SURFACES } from './importSurfaces';
+
+// Nitro runs every file in `server/middleware/` on every request, so each surface tells its spans apart by
+// middleware name. `nuxt/server` has no object syntax (`middleware`) and no `eventHandler` alias, so only the
+// simple middleware has a copy.
+const MIDDLEWARE = {
+  nitro: {
+    names: ['01.first', '02.second', '03.auth', '04.hooks', '05.array-hooks'],
+    simpleNames: ['01.first', '02.second', '03.auth'],
+    // 3 simple + 2 hooks (middleware+handler) + 3 array hooks (2 middleware + 1 handler)
+    spanCount: 8,
+    authName: '03.auth',
+    authErrorQuery: 'throwError=true',
+    authErrorMessage: 'Auth middleware error',
+  },
+  'nuxt/server': {
+    names: ['06.nuxt-server-first', '07.nuxt-server-auth'],
+    simpleNames: ['06.nuxt-server-first', '07.nuxt-server-auth'],
+    spanCount: 2,
+    authName: '07.nuxt-server-auth',
+    authErrorQuery: 'throwNuxtServerError=true',
+    authErrorMessage: 'nuxt/server auth middleware error',
+  },
+} as const;
+
+async function collectRequestSpans(path = '/api/middleware-test') {
+  const spans = await collectStreamedSpansUntilSegment('nuxt-5', span => span.attributes['url.path']?.value === path);
+  const rootSpan = spans.find(span => span.is_segment && span.attributes['url.path']?.value === path);
+
+  return spans.filter(span => span.trace_id === rootSpan?.trace_id);
+}
 
-function collectRequestSpans() {
-  return collectStreamedSpansUntilSegment(
-    'nuxt-5',
-    span => span.attributes['url.path']?.value === '/api/middleware-test',
+function findMiddlewareSpan(spans: SerializedStreamedSpan[], name: string, hook?: string, index?: number) {
+  return spans.find(
+    span =>
+      getSpanOp(span) === 'middleware' &&
+      span.attributes['nuxt.middleware.name']?.value === name &&
+      (hook === undefined || span.attributes['nuxt.middleware.hook.name']?.value === hook) &&
+      (index === undefined || span.attributes['nuxt.middleware.hook.index']?.value === index),
   );
 }
 
-test.describe('Server Middleware Instrumentation', () => {
-  test('should create separate spans for each server middleware', async ({ request }) => {
-    const spansPromise = collectRequestSpans();
+IMPORT_SURFACES.forEach(({ name, apiPrefix }) => {
+  const middleware = MIDDLEWARE[name];
+  const path = `${apiPrefix}/middleware-test`;
+  const getSurfaceMiddlewareSpans = (spans: SerializedStreamedSpan[]) =>
+    spans.filter(
+      span =>
+        getSpanOp(span) === 'middleware' &&
+        (middleware.names as readonly unknown[]).includes(span.attributes['nuxt.middleware.name']?.value),
+    );
 
-    // Make request to the API endpoint that will trigger all server middleware
-    const response = await request.get('/api/middleware-test');
-    expect(response.status()).toBe(200);
+  test.describe(`Server Middleware Instrumentation (${name})`, () => {
+    test('creates one span per server middleware', async ({ request }) => {
+      const spansPromise = collectRequestSpans(path);
 
-    const responseData = await response.json();
-    expect(responseData.message).toBe('Server middleware test endpoint');
+      const response = await request.get(path);
+      expect(response.status()).toBe(200);
+      expect((await response.json()).message).toBe('Server middleware test endpoint');
 
-    const spans = await spansPromise;
+      const middlewareSpans = getSurfaceMiddlewareSpans(await spansPromise);
 
-    // Verify that we have spans for each middleware
-    const middlewareSpans = spans.filter(span => getSpanOp(span) === 'middleware');
-
-    // 3 simple + 2 hooks (middleware+handler) + 3 array hooks (2 middleware + 1 handler)
-    expect(middlewareSpans).toHaveLength(8);
-
-    // Check for specific middleware spans
-    const findSpanByName = (name: string) =>
-      middlewareSpans.find(span => span.attributes['nuxt.middleware.name']?.value === name);
-
-    const firstMiddlewareSpan = findSpanByName('01.first');
-    const secondMiddlewareSpan = findSpanByName('02.second');
-    const authMiddlewareSpan = findSpanByName('03.auth');
-    const hooksOnRequestSpan = findSpanByName('04.hooks');
-    const arrayHooksHandlerSpan = findSpanByName('05.array-hooks');
-
-    expect(firstMiddlewareSpan).toBeDefined();
-    expect(secondMiddlewareSpan).toBeDefined();
-    expect(authMiddlewareSpan).toBeDefined();
-    expect(hooksOnRequestSpan).toBeDefined();
-    expect(arrayHooksHandlerSpan).toBeDefined();
-
-    // Verify each span has the correct attributes
-    [firstMiddlewareSpan, secondMiddlewareSpan, authMiddlewareSpan].forEach(span => {
-      expect(span).toEqual(
-        expect.objectContaining({
-          is_segment: false,
-          attributes: expect.objectContaining({
-            'sentry.op': { type: 'string', value: 'middleware' },
-            'sentry.origin': { type: 'string', value: 'auto.middleware.nuxt' },
-            'http.request.method': { type: 'string', value: 'GET' },
-            'http.route': { type: 'string', value: '/api/middleware-test' },
-          }),
-          parent_span_id: expect.stringMatching(/[a-f0-9]{16}/),
-          span_id: expect.stringMatching(/[a-f0-9]{16}/),
-          trace_id: expect.stringMatching(/[a-f0-9]{32}/),
-        }),
+      expect(middlewareSpans).toHaveLength(middleware.spanCount);
+      expect(new Set(middlewareSpans.map(span => span.span_id)).size).toBe(middleware.spanCount);
+      expect(new Set(middlewareSpans.map(span => span.attributes['nuxt.middleware.name']?.value))).toEqual(
+        new Set(middleware.names),
       );
-    });
-
-    // Verify spans have different span IDs (each middleware gets its own span)
-    const spanIds = middlewareSpans.map(span => span.span_id);
-    const uniqueSpanIds = new Set(spanIds);
-    // 3 simple + 2 hooks (middleware+handler) + 3 array hooks (2 middleware + 1 handler)
-    expect(uniqueSpanIds.size).toBe(8);
-
-    // Verify spans share the same trace ID
-    const traceIds = middlewareSpans.map(span => span.trace_id);
-    const uniqueTraceIds = new Set(traceIds);
-    expect(uniqueTraceIds.size).toBe(1);
-  });
-
-  test('middleware spans should have proper parent-child relationship', async ({ request }) => {
-    const spansPromise = collectRequestSpans();
 
-    await request.get('/api/middleware-test');
-    const spans = await spansPromise;
+      middleware.simpleNames.forEach(middlewareName => {
+        const span = findMiddlewareSpan(middlewareSpans, middlewareName);
 
-    const segmentSpan = spans.find(
-      span => span.is_segment && span.attributes['url.path']?.value === '/api/middleware-test',
-    );
-    const middlewareSpans = spans.filter(span => getSpanOp(span) === 'middleware');
-
-    // All middleware spans should be children of the request's segment span
-    middlewareSpans.forEach(span => {
-      expect(span.parent_span_id).toBe(segmentSpan?.span_id);
+        expect(span?.name).toBe(middlewareName);
+        expect(span?.is_segment).toBe(false);
+        expect(span?.attributes['sentry.op']).toEqual({ type: 'string', value: 'middleware' });
+        expect(span?.attributes['sentry.origin']).toEqual({ type: 'string', value: 'auto.middleware.nuxt' });
+        expect(span?.attributes['http.request.method']).toEqual({ type: 'string', value: 'GET' });
+        expect(span?.attributes['http.route']).toEqual({ type: 'string', value: path });
+      });
     });
-  });
 
-  test('should capture errors thrown in middleware and associate them with the span', async ({ request }) => {
-    const spansPromise = collectRequestSpans();
+    test('parents middleware spans to the request segment', async ({ request }) => {
+      const spansPromise = collectRequestSpans(path);
 
-    const errorEventPromise = waitForError('nuxt-5', errorEvent => {
-      return errorEvent?.exception?.values?.[0]?.value === 'Auth middleware error';
-    });
+      await request.get(path);
+      const spans = await spansPromise;
 
-    // Make request with query param to trigger error in auth middleware
-    const response = await request.get('/api/middleware-test?throwError=true');
+      const segmentSpan = spans.find(span => span.is_segment && span.attributes['url.path']?.value === path);
+      const middlewareSpans = getSurfaceMiddlewareSpans(spans);
 
-    // The request should fail due to the middleware error
-    expect(response.status()).toBe(500);
-
-    const [spans, errorEvent] = await Promise.all([spansPromise, errorEventPromise]);
-
-    // Find the auth middleware span
-    const authMiddlewareSpan = spans.find(
-      span => getSpanOp(span) === 'middleware' && span.attributes['nuxt.middleware.name']?.value === '03.auth',
-    );
+      expect(segmentSpan).toBeDefined();
+      expect(middlewareSpans).toHaveLength(middleware.spanCount);
+      middlewareSpans.forEach(span => {
+        expect(span.parent_span_id).toBe(segmentSpan?.span_id);
+      });
+    });
 
-    expect(authMiddlewareSpan).toBeDefined();
+    test('captures a middleware error and marks its span as errored', async ({ request }) => {
+      const spansPromise = collectRequestSpans(path);
+      const errorEventPromise = waitForError('nuxt-5', errorEvent => {
+        return errorEvent?.exception?.values?.[0]?.value === middleware.authErrorMessage;
+      });
 
-    // Verify the span has error status
-    expect(authMiddlewareSpan?.status).toBe('error');
+      const response = await request.get(`${path}?${middleware.authErrorQuery}`);
+      expect(response.status()).toBe(500);
 
-    // Verify the error event is associated with the correct request
-    expect(errorEvent.transaction).toContain('GET /api/middleware-test');
+      const [spans, errorEvent] = await Promise.all([spansPromise, errorEventPromise]);
 
-    // Verify the error has the correct mechanism
-    expect(errorEvent.exception?.values?.[0]).toEqual(
-      expect.objectContaining({
-        value: 'Auth middleware error',
-        type: 'Error',
-        mechanism: expect.objectContaining({
-          handled: false,
-          type: 'auto.middleware.nuxt',
-        }),
-      }),
-    );
+      expect(findMiddlewareSpan(spans, middleware.authName)?.status).toBe('error');
+      expect(errorEvent.transaction).toBe(`GET ${path}`);
+      expect(errorEvent.exception?.values).toHaveLength(1);
+      expect(errorEvent.exception?.values?.[0]?.type).toBe('Error');
+      expect(errorEvent.exception?.values?.[0]?.value).toBe(middleware.authErrorMessage);
+      expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({ handled: false, type: 'auto.middleware.nuxt' });
+    });
   });
+});
 
-  test('should create spans for middleware and handler hooks', async ({ request }) => {
+// `nuxt/server` has no object syntax for middleware hooks, so these only run on the classic surface.
+test.describe('Server Middleware Instrumentation (nitro hooks)', () => {
+  test('creates spans for the middleware and handler hooks', async ({ request }) => {
     const spansPromise = collectRequestSpans();
 
-    // Make request to trigger middleware with hooks
     const response = await request.get('/api/middleware-test');
     expect(response.status()).toBe(200);
 
     const spans = await spansPromise;
-    const middlewareSpans = spans.filter(span => getSpanOp(span) === 'middleware');
+    const middlewareSpan = findMiddlewareSpan(spans, '04.hooks', 'middleware');
+    const handlerSpan = findMiddlewareSpan(spans, '04.hooks', 'handler');
 
-    // Find spans for the hooks middleware
-    const hooksSpans = middlewareSpans.filter(span => span.attributes['nuxt.middleware.name']?.value === '04.hooks');
+    // h3 v2 has no `onBeforeResponse`, so a hooks object gives only `middleware` and `handler` spans.
+    expect(spans.filter(span => span.attributes['nuxt.middleware.name']?.value === '04.hooks')).toHaveLength(2);
 
-    // Should have spans for middleware and handler (h3 v2 no longer has onBeforeResponse)
-    expect(hooksSpans).toHaveLength(2);
-
-    // Find specific hook spans
-    const findSpanByHook = (hook: string) =>
-      hooksSpans.find(span => span.attributes['nuxt.middleware.hook.name']?.value === hook);
-
-    const middlewareSpan = findSpanByHook('middleware');
-    const handlerSpan = findSpanByHook('handler');
-
-    expect(middlewareSpan).toBeDefined();
-    expect(handlerSpan).toBeDefined();
-
-    // Verify span names include hook types
     expect(middlewareSpan?.name).toBe('04.hooks.middleware');
-    expect(handlerSpan?.name).toBe('04.hooks');
-
-    // Verify all spans have correct middleware name (without hook suffix)
-    [middlewareSpan, handlerSpan].forEach(span => {
-      expect(span?.attributes['nuxt.middleware.name']?.value).toBe('04.hooks');
-    });
-
-    // Verify hook-specific attributes
-    expect(middlewareSpan?.attributes['nuxt.middleware.hook.name']?.value).toBe('middleware');
-    expect(handlerSpan?.attributes['nuxt.middleware.hook.name']?.value).toBe('handler');
-
-    // Verify middleware has index (middleware is always an array in h3 v2)
+    // h3 v2 always stores `middleware` as an array, so even a single hook has an index.
     expect(middlewareSpan?.attributes['nuxt.middleware.hook.index']?.value).toBe(0);
+
+    expect(handlerSpan?.name).toBe('04.hooks');
     expect(handlerSpan?.attributes['nuxt.middleware.hook.index']).toBeUndefined();
   });
 
-  test('should create spans with index attributes for array middleware', async ({ request }) => {
+  test('sets index attributes on array middleware spans', async ({ request }) => {
     const spansPromise = collectRequestSpans();
 
-    // Make request to trigger middleware with array hooks
     const response = await request.get('/api/middleware-test');
     expect(response.status()).toBe(200);
 
     const spans = await spansPromise;
-    const middlewareSpans = spans.filter(span => getSpanOp(span) === 'middleware');
-
-    // Find spans for the array hooks middleware
-    const arrayHooksSpans = middlewareSpans.filter(
-      span => span.attributes['nuxt.middleware.name']?.value === '05.array-hooks',
-    );
+    const arrayHooksSpans = spans.filter(span => span.attributes['nuxt.middleware.name']?.value === '05.array-hooks');
+    const middleware0Span = findMiddlewareSpan(spans, '05.array-hooks', 'middleware', 0);
+    const middleware1Span = findMiddlewareSpan(spans, '05.array-hooks', 'middleware', 1);
+    const handlerSpan = findMiddlewareSpan(spans, '05.array-hooks', 'handler');
 
-    // Should have spans for 2 middleware + 1 handler = 3 spans (h3 v2 no longer has onBeforeResponse)
     expect(arrayHooksSpans).toHaveLength(3);
-
-    // Find middleware array spans
-    const middlewareArraySpans = arrayHooksSpans.filter(
-      span => span.attributes['nuxt.middleware.hook.name']?.value === 'middleware',
-    );
-    expect(middlewareArraySpans).toHaveLength(2);
-
-    // Find handler span
-    const handlerSpan = arrayHooksSpans.find(span => span.attributes['nuxt.middleware.hook.name']?.value === 'handler');
-    expect(handlerSpan).toBeDefined();
-
-    // Verify index attributes for middleware array
-    const middleware0Span = middlewareArraySpans.find(
-      span => span.attributes['nuxt.middleware.hook.index']?.value === 0,
-    );
-    const middleware1Span = middlewareArraySpans.find(
-      span => span.attributes['nuxt.middleware.hook.index']?.value === 1,
-    );
-
-    expect(middleware0Span).toBeDefined();
-    expect(middleware1Span).toBeDefined();
-
-    // Verify span names for array middleware handlers
     expect(middleware0Span?.name).toBe('05.array-hooks.middleware');
     expect(middleware1Span?.name).toBe('05.array-hooks.middleware');
-
-    // Verify handler has no index
+    expect(handlerSpan?.name).toBe('05.array-hooks');
     expect(handlerSpan?.attributes['nuxt.middleware.hook.index']).toBeUndefined();
   });
 
-  test('should handle errors in middleware hooks', async ({ request }) => {
+  test('marks a failing middleware hook span as errored', async ({ request }) => {
     const spansPromise = collectRequestSpans();
-
     const errorEventPromise = waitForError('nuxt-5', errorEvent => {
       return errorEvent?.exception?.values?.[0]?.value === 'OnRequest hook error';
     });
 
-    // Make request with query param to trigger error in middleware
     const response = await request.get('/api/middleware-test?throwOnRequestError=true');
     expect(response.status()).toBe(500);
 
     const [spans, errorEvent] = await Promise.all([spansPromise, errorEventPromise]);
 
-    // Find the middleware span that should have error status
-    const middlewareSpan = spans.find(
-      span =>
-        getSpanOp(span) === 'middleware' &&
-        span.attributes['nuxt.middleware.name']?.value === '04.hooks' &&
-        span.attributes['nuxt.middleware.hook.name']?.value === 'middleware',
-    );
-
-    expect(middlewareSpan).toBeDefined();
-    expect(middlewareSpan?.status).toBe('error');
+    expect(findMiddlewareSpan(spans, '04.hooks', 'middleware')?.status).toBe('error');
     expect(errorEvent.exception?.values?.[0]?.value).toBe('OnRequest hook error');
   });
 
-  test('should handle errors in array middleware with proper index attribution', async ({ request }) => {
+  test('marks only the failing array middleware span as errored', async ({ request }) => {
     const spansPromise = collectRequestSpans();
-
     const errorEventPromise = waitForError('nuxt-5', errorEvent => {
       return errorEvent?.exception?.values?.[0]?.value === 'OnRequest[1] hook error';
     });
 
-    // Make request with query param to trigger error in second middleware handler
     const response = await request.get('/api/middleware-test?throwOnRequest1Error=true');
     expect(response.status()).toBe(500);
 
     const [spans, errorEvent] = await Promise.all([spansPromise, errorEventPromise]);
 
-    const findArrayHookSpan = (index: number) =>
-      spans.find(
-        span =>
-          getSpanOp(span) === 'middleware' &&
-          span.attributes['nuxt.middleware.name']?.value === '05.array-hooks' &&
-          span.attributes['nuxt.middleware.hook.name']?.value === 'middleware' &&
-          span.attributes['nuxt.middleware.hook.index']?.value === index,
-      );
-
-    // Find the second middleware span that should have error status
-    const middleware1Span = findArrayHookSpan(1);
-
-    expect(middleware1Span).toBeDefined();
-    expect(middleware1Span?.status).toBe('error');
+    expect(findMiddlewareSpan(spans, '05.array-hooks', 'middleware', 0)?.status).toBe('ok');
+    expect(findMiddlewareSpan(spans, '05.array-hooks', 'middleware', 1)?.status).toBe('error');
     expect(errorEvent.exception?.values?.[0]?.value).toBe('OnRequest[1] hook error');
-
-    // Verify the first middleware handler still executed successfully
-    const middleware0Span = findArrayHookSpan(0);
-
-    expect(middleware0Span).toBeDefined();
-    expect(middleware0Span?.status).not.toBe('error');
   });
 });
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/tracing.server.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/tracing.server.test.ts
index 9ffae3e03885..2a0dcebe48c4 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/tracing.server.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/tracing.server.test.ts
@@ -1,5 +1,6 @@
 import { expect, test } from '@playwright/test';
-import { collectStreamedSpansUntilSegment, getSpanOp, waitForStreamedSpan } from '@sentry-internal/test-utils';
+import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '@sentry-internal/test-utils';
+import { IMPORT_SURFACES } from './importSurfaces';
 
 test('sends a server root span on pageload', async ({ page }) => {
   const serverSpanPromise = waitForStreamedSpan('nuxt-5', span => {
@@ -38,27 +39,36 @@ test('does not send spans for build asset folder "_nuxt"', async ({ page }) => {
   expect(serverSpan.attributes['sentry.segment.name.source']?.value).toBe('route');
 });
 
-// TODO: Make test work with Nuxt 5
-test.skip('captures server API calls made with Nitro $fetch', async ({ page }) => {
-  const spansPromise = collectStreamedSpansUntilSegment(
-    'nuxt-5',
-    span => span.attributes['url.path']?.value === '/api/nitro-fetch',
-  );
-
-  await page.goto(`/fetch-server-routes`);
-  await page.getByText('Fetch Nitro $fetch', { exact: true }).click();
-
-  const spans = await spansPromise;
-
-  const httpServerSpan = spans.find(
-    span => span.is_segment && span.attributes['url.path']?.value === '/api/nitro-fetch',
-  );
-  const httpClientSpan = spans.find(
-    span => span.trace_id === httpServerSpan?.trace_id && span.attributes['url.full']?.value === 'https://example.com/',
-  );
-
-  expect(getSpanOp(httpServerSpan!)).toEqual('http.server');
-
-  expect(httpClientSpan?.parent_span_id).toEqual(httpServerSpan?.span_id);
-  expect(getSpanOp(httpClientSpan!)).toEqual('http.client');
+IMPORT_SURFACES.forEach(({ name, apiPrefix }) => {
+  test(`captures server API calls made with Nitro $fetch (${name})`, async ({ page }) => {
+    // The server-side http.client span can flush before its segment. Accumulate until both arrived.
+    const spansPromise = collectStreamedSpans('nuxt-5', spans => {
+      return (
+        spans.some(span => span.is_segment && span.attributes['url.path']?.value === `${apiPrefix}/nitro-fetch`) &&
+        spans.some(
+          span => getSpanOp(span) === 'http.client' && span.attributes['url.full']?.value === 'https://example.com/',
+        )
+      );
+    });
+
+    await page.goto(`/fetch-server-routes?apiPrefix=${apiPrefix}`);
+    await page.getByText('Fetch Nitro $fetch', { exact: true }).click();
+
+    const spans = await spansPromise;
+
+    const serverSegmentSpan = spans.find(
+      span => span.is_segment && span.attributes['url.path']?.value === `${apiPrefix}/nitro-fetch`,
+    );
+    const httpClientSpan = spans.find(
+      span => getSpanOp(span) === 'http.client' && span.attributes['url.full']?.value === 'https://example.com/',
+    );
+
+    expect(serverSegmentSpan).toBeDefined();
+    expect(getSpanOp(serverSegmentSpan!)).toBe('http.server');
+
+    expect(httpClientSpan).toBeDefined();
+    expect(httpClientSpan?.name).toBe('GET example.com');
+    expect(httpClientSpan?.trace_id).toBe(serverSegmentSpan?.trace_id);
+    expect(httpClientSpan?.parent_span_id).toBe(serverSegmentSpan?.span_id);
+  });
 });
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/tracing.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/tracing.test.ts
index 9476ea84df14..5580819bec1f 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/tracing.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/tracing.test.ts
@@ -1,11 +1,23 @@
 import { expect, test } from '@playwright/test';
 import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '@sentry-internal/test-utils';
+import type { SerializedStreamedSpan } from '@sentry-internal/test-utils';
+import { IMPORT_SURFACES } from './importSurfaces';
+
+function expectSegmentSpan(
+  span: SerializedStreamedSpan | undefined,
+  expected: { name: string; op: string; origin: string },
+) {
+  expect(span?.name).toBe(expected.name);
+  expect(span?.is_segment).toBe(true);
+  expect(span?.attributes['sentry.op']?.value).toBe(expected.op);
+  expect(span?.attributes['sentry.origin']?.value).toBe(expected.origin);
+  expect(span?.attributes['sentry.segment.name.source']?.value).toBe('route');
+}
 
 test.describe('distributed tracing', () => {
   const PARAM = 's0me-param';
-  const API_PATH = `/api/user/${PARAM}`;
 
-  test('capture a distributed pageload trace', async ({ page }) => {
+  test('captures a distributed pageload trace', async ({ page }) => {
     const clientSpanPromise = waitForStreamedSpan('nuxt-5', span => {
       return getSpanOp(span) === 'pageload' && span.is_segment;
     });
@@ -34,115 +46,91 @@ test.describe('distributed tracing', () => {
 
     expect(metaSampled).toBe('1');
 
-    expect(clientSpan).toMatchObject({
-      name: '/test-param/:param()',
-      is_segment: true,
-      trace_id: metaTraceId,
-      parent_span_id: metaParentSpanId,
-      attributes: expect.objectContaining({
-        'sentry.op': { type: 'string', value: 'pageload' },
-        'sentry.origin': { type: 'string', value: 'auto.pageload.vue' },
-        'sentry.segment.name.source': { type: 'string', value: 'route' },
-      }),
-    });
+    expectSegmentSpan(clientSpan, { name: '/test-param/:param()', op: 'pageload', origin: 'auto.pageload.vue' });
+    expect(clientSpan.trace_id).toBe(metaTraceId);
+    expect(clientSpan.parent_span_id).toBe(metaParentSpanId);
 
-    expect(serverSpan).toMatchObject({
-      name: 'GET /test-param/:param()', // parametrized
-      is_segment: true,
-      attributes: expect.objectContaining({
-        'sentry.op': { type: 'string', value: 'http.server' },
-        'sentry.origin': { type: 'string', value: 'auto.http.http_server' },
-        'sentry.segment.name.source': { type: 'string', value: 'route' },
-      }),
+    expectSegmentSpan(serverSpan, {
+      name: 'GET /test-param/:param()',
+      op: 'http.server',
+      origin: 'auto.http.http_server',
     });
-
-    // connected trace
-    expect(clientSpan.trace_id).toBe(serverSpan.trace_id);
-    expect(clientSpan.parent_span_id).toBe(serverSpan.span_id);
     expect(serverSpan.trace_id).toBe(metaTraceId);
+    expect(clientSpan.parent_span_id).toBe(serverSpan.span_id);
   });
 
-  test('capture a distributed trace from a client-side API request with parametrized routes', async ({ page }) => {
-    // The `http.client` span ends after the pageload segment, so it can be flushed in a later
-    // envelope. Accumulate until both spans have arrived.
-    const clientSpansPromise = collectStreamedSpans('nuxt-5', spans => {
-      return (
-        spans.some(span => span.name === '/test-param/user/:userId()' && span.is_segment) &&
-        spans.some(
-          span => getSpanOp(span) === 'http.client' && `${span.attributes['url.full']?.value}`.includes(API_PATH),
-        )
+  IMPORT_SURFACES.forEach(({ name, apiPrefix }) => {
+    test(`captures a distributed trace from a client-side API request with parametrized routes (${name})`, async ({
+      page,
+      baseURL,
+    }) => {
+      const API_PATH = `${apiPrefix}/user/${PARAM}`;
+
+      // The `http.client` span ends after the pageload segment, so it can be flushed in a later
+      // envelope. Accumulate until both spans have arrived.
+      const clientSpansPromise = collectStreamedSpans('nuxt-5', spans => {
+        return (
+          spans.some(span => span.name === '/test-param/user/:userId()' && span.is_segment) &&
+          spans.some(
+            span => getSpanOp(span) === 'http.client' && `${span.attributes['url.full']?.value}`.includes(API_PATH),
+          )
+        );
+      });
+      const ssrSpanPromise = waitForStreamedSpan('nuxt-5', span => {
+        return span.is_segment && span.name.includes('GET /test-param/user');
+      });
+      const serverReqSpanPromise = waitForStreamedSpan('nuxt-5', span => {
+        return span.is_segment && span.name.includes(`GET ${apiPrefix}/user/`);
+      });
+
+      // Navigate to the page which will trigger an API call from the client-side
+      await page.goto(`/test-param/user/${PARAM}?apiPrefix=${apiPrefix}`);
+
+      const [clientSpans, ssrSpan, serverReqSpan] = await Promise.all([
+        clientSpansPromise,
+        ssrSpanPromise,
+        serverReqSpanPromise,
+      ]);
+
+      const pageloadSpan = clientSpans.find(span => span.name === '/test-param/user/:userId()' && span.is_segment);
+      const httpClientSpan = clientSpans.find(
+        span => getSpanOp(span) === 'http.client' && `${span.attributes['url.full']?.value}`.includes(API_PATH),
       );
-    });
-    const ssrSpanPromise = waitForStreamedSpan('nuxt-5', span => {
-      return span.is_segment && span.name.includes('GET /test-param/user');
-    });
-    const serverReqSpanPromise = waitForStreamedSpan('nuxt-5', span => {
-      return span.is_segment && span.name.includes('GET /api/user/');
-    });
-
-    // Navigate to the page which will trigger an API call from the client-side
-    await page.goto(`/test-param/user/${PARAM}`);
 
-    const [clientSpans, ssrSpan, serverReqSpan] = await Promise.all([
-      clientSpansPromise,
-      ssrSpanPromise,
-      serverReqSpanPromise,
-    ]);
-
-    const pageloadSpan = clientSpans.find(span => span.name === '/test-param/user/:userId()' && span.is_segment);
-    const httpClientSpan = clientSpans.find(
-      span => getSpanOp(span) === 'http.client' && `${span.attributes['url.full']?.value}`.includes(API_PATH),
-    );
-
-    expect(pageloadSpan).toMatchObject({
-      name: '/test-param/user/:userId()',
-      is_segment: true,
-      attributes: expect.objectContaining({
-        'sentry.op': { type: 'string', value: 'pageload' },
-        'sentry.origin': { type: 'string', value: 'auto.pageload.vue' },
-        'sentry.segment.name.source': { type: 'string', value: 'route' },
-      }),
-    });
+      expectSegmentSpan(pageloadSpan, {
+        name: '/test-param/user/:userId()',
+        op: 'pageload',
+        origin: 'auto.pageload.vue',
+      });
 
-    expect(httpClientSpan).toBeDefined();
-    expect(httpClientSpan).toMatchObject({
       // A relative fetch has no domain of its own, so it resolves against the page origin.
-      name: 'GET localhost',
-      parent_span_id: pageloadSpan?.span_id, // pageload span is parent
-      attributes: expect.objectContaining({
-        type: { type: 'string', value: 'fetch' },
-        'sentry.op': { type: 'string', value: 'http.client' },
-        'sentry.origin': { type: 'string', value: 'auto.http.browser' },
-        'http.request.method': { type: 'string', value: 'GET' },
-        'url.full': { type: 'string', value: expect.stringContaining(API_PATH) },
-        'url.domain': { type: 'string', value: 'localhost' },
-      }),
-    });
-
-    expect(ssrSpan).toMatchObject({
-      name: 'GET /test-param/user/:userId()', // parametrized route
-      is_segment: true,
-      attributes: expect.objectContaining({
-        'sentry.op': { type: 'string', value: 'http.server' },
-        'sentry.origin': { type: 'string', value: 'auto.http.http_server' },
-        'sentry.segment.name.source': { type: 'string', value: 'route' },
-      }),
-    });
-
-    expect(serverReqSpan).toMatchObject({
-      name: 'GET /api/user/:userId', // parametrized route
-      is_segment: true,
-      parent_span_id: httpClientSpan?.span_id, // http.client span is parent
-      attributes: expect.objectContaining({
-        'sentry.op': { type: 'string', value: 'http.server' },
-        'sentry.origin': { type: 'string', value: 'auto.http.http_server' },
-      }),
+      expect(httpClientSpan?.name).toBe('GET localhost');
+      expect(httpClientSpan?.is_segment).toBe(false);
+      expect(httpClientSpan?.parent_span_id).toBe(pageloadSpan?.span_id);
+      expect(httpClientSpan?.attributes['type']?.value).toBe('fetch');
+      expect(httpClientSpan?.attributes['sentry.op']?.value).toBe('http.client');
+      expect(httpClientSpan?.attributes['sentry.origin']?.value).toBe('auto.http.browser');
+      expect(httpClientSpan?.attributes['http.request.method']?.value).toBe('GET');
+      expect(httpClientSpan?.attributes['url.full']?.value).toBe(`${baseURL}${API_PATH}`);
+      expect(httpClientSpan?.attributes['url.domain']?.value).toBe('localhost');
+
+      expectSegmentSpan(ssrSpan, {
+        name: 'GET /test-param/user/:userId()',
+        op: 'http.server',
+        origin: 'auto.http.http_server',
+      });
+
+      expectSegmentSpan(serverReqSpan, {
+        name: `GET ${apiPrefix}/user/:userId`,
+        op: 'http.server',
+        origin: 'auto.http.http_server',
+      });
+      expect(serverReqSpan.parent_span_id).toBe(httpClientSpan?.span_id);
+
+      // `collectStreamedSpans` already guarantees the pageload and http.client spans share a trace,
+      // so only the independently awaited server spans need the check.
+      expect(ssrSpan.trace_id).toBe(pageloadSpan?.trace_id);
+      expect(serverReqSpan.trace_id).toBe(pageloadSpan?.trace_id);
     });
-
-    // All 3 root spans and the http.client span should share the same trace_id
-    expect(pageloadSpan?.trace_id).toBeDefined();
-    expect(pageloadSpan?.trace_id).toBe(httpClientSpan?.trace_id);
-    expect(pageloadSpan?.trace_id).toBe(ssrSpan.trace_id);
-    expect(pageloadSpan?.trace_id).toBe(serverReqSpan.trace_id);
   });
 });

From 68f22aadca8c57e968efbc6b38c5dddba0f31273 Mon Sep 17 00:00:00 2001
From: "javascript-sdk-gitflow[bot]"
 <255134079+javascript-sdk-gitflow[bot]@users.noreply.github.com>
Date: Fri, 9 Oct 2026 15:12:10 +0200
Subject: [PATCH 36/84] chore: Add external contributor to CHANGELOG.md
 (#25230)

This PR adds the external contributor to the CHANGELOG.md file, so that
they are credited for their contribution. See #25227

Co-authored-by: JPeer264 <10677263+JPeer264@users.noreply.github.com>
---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 21394e7db5b2..ee97ad9d225e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+Work in this release was contributed by @Philip-Nwabuwa. Thank you for your contribution!
+
 ## 11.6.0
 
 ### Important Changes

From b8b6239ec4f2042f286a72b9d47071936258b199 Mon Sep 17 00:00:00 2001
From: Martin Sonnberger <martin.sonnberger@sentry.io>
Date: Fri, 9 Oct 2026 15:35:17 +0200
Subject: [PATCH 37/84] fix(nextjs): Filter query parameters in request error
 context (#25233)

---
 .../nextjs/src/common/captureRequestError.ts  |  4 +-
 .../test/common/captureRequestError.test.ts   | 41 +++++++++++++++++++
 2 files changed, 43 insertions(+), 2 deletions(-)
 create mode 100644 packages/nextjs/test/common/captureRequestError.test.ts

diff --git a/packages/nextjs/src/common/captureRequestError.ts b/packages/nextjs/src/common/captureRequestError.ts
index e0e1d094a211..8f8ed48a19fb 100644
--- a/packages/nextjs/src/common/captureRequestError.ts
+++ b/packages/nextjs/src/common/captureRequestError.ts
@@ -1,5 +1,5 @@
 import type { RequestEventData } from '@sentry/core';
-import { captureException, headersToDict, withScope } from '@sentry/core';
+import { captureException, filterCollectedUrl, headersToDict, withScope } from '@sentry/core';
 import { isPrerenderControlFlowError } from './nextNavigationErrorUtils';
 import { flushSafelyWithTimeout, waitUntil } from './utils/responseEnd';
 
@@ -32,7 +32,7 @@ export function captureRequestError(error: unknown, request: RequestInfo, errorC
     });
 
     scope.setContext('nextjs', {
-      request_path: request.path,
+      request_path: filterCollectedUrl(request.path, scope.getClient()),
       router_kind: errorContext.routerKind,
       router_path: errorContext.routePath,
       route_type: errorContext.routeType,
diff --git a/packages/nextjs/test/common/captureRequestError.test.ts b/packages/nextjs/test/common/captureRequestError.test.ts
new file mode 100644
index 000000000000..abc6a0c5f44c
--- /dev/null
+++ b/packages/nextjs/test/common/captureRequestError.test.ts
@@ -0,0 +1,41 @@
+import type { Event } from '@sentry/core';
+import { requestDataIntegration, withScope } from '@sentry/core';
+import { NodeClient } from '@sentry/node';
+import { describe, expect, it } from 'vitest';
+import { captureRequestError } from '../../src/common/captureRequestError';
+
+describe('captureRequestError', () => {
+  it('omits the query from the request context when query collection is disabled', async () => {
+    const events: Event[] = [];
+    const client = new NodeClient({
+      dsn: 'https://public@example.com/1',
+      integrations: [requestDataIntegration()],
+      stackParser: () => [],
+      transport: () => ({ send: async () => ({}), flush: async () => true }),
+      dataCollection: { urlQueryParams: false },
+      beforeSend: event => {
+        events.push(event);
+        return null;
+      },
+    });
+    client.init();
+
+    await withScope(async scope => {
+      scope.setClient(client);
+      captureRequestError(
+        new Error('Search failed'),
+        { path: '/search?token=secret&category=books', method: 'GET', headers: {} },
+        { routerKind: 'App Router', routePath: '/search', routeType: 'render' },
+      );
+      await client.flush();
+    });
+
+    expect(events).toHaveLength(1);
+    expect(events[0]?.contexts?.nextjs).toEqual({
+      request_path: '/search',
+      router_kind: 'App Router',
+      router_path: '/search',
+      route_type: 'render',
+    });
+  });
+});

From 4c22a847c0af81b0ef9daefdaa824ef18e2dcc7c Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 16:13:54 +0200
Subject: [PATCH 38/84] test(node): Port span linking and raw OTel tests to
 streaming (#25219)

Exercise span links and raw OTel error behavior with the default
streaming lifecycle.

Part of #24140

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../linking/scenario-addLink-nested.ts        |   6 +-
 .../tracing/linking/scenario-addLink.ts       |   4 +-
 .../linking/scenario-addLinks-nested.ts       |   4 +-
 .../tracing/linking/scenario-addLinks.ts      |   4 +-
 .../tracing/linking/scenario-span-options.ts  |   4 +-
 .../suites/tracing/linking/test.ts            | 240 +++++++++---------
 .../instrument.mjs                            |   1 -
 .../tracer-start-active-span-error/test.ts    |  17 +-
 8 files changed, 137 insertions(+), 143 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLink-nested.ts b/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLink-nested.ts
index 5eb3cb141e8d..660afb9ba1f7 100644
--- a/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLink-nested.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLink-nested.ts
@@ -1,8 +1,8 @@
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
 import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
@@ -16,7 +16,7 @@ Sentry.startSpan({ name: 'parent1' }, async parentSpan1 => {
   Sentry.startSpan({ name: 'child1.1' }, async childSpan1 => {
     childSpan1.addLink({
       context: parentSpan1.spanContext(),
-      attributes: { 'sentry.link.type': 'previous_trace' },
+      attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' },
     });
 
     childSpan1.end();
@@ -26,7 +26,7 @@ Sentry.startSpan({ name: 'parent1' }, async parentSpan1 => {
   Sentry.startSpan({ name: 'child1.2' }, async childSpan2 => {
     childSpan2.addLink({
       context: parentSpan1.spanContext(),
-      attributes: { 'sentry.link.type': 'previous_trace' },
+      attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' },
     });
 
     childSpan2.end();
diff --git a/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLink.ts b/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLink.ts
index c8ca1605d307..47537edafb1f 100644
--- a/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLink.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLink.ts
@@ -1,8 +1,8 @@
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
 import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
@@ -16,6 +16,6 @@ span1.end();
 Sentry.startSpan({ name: 'rootSpan' }, rootSpan => {
   rootSpan.addLink({
     context: span1.spanContext(),
-    attributes: { 'sentry.link.type': 'previous_trace' },
+    attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' },
   });
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLinks-nested.ts b/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLinks-nested.ts
index 6d8c85412892..84d1680e95cf 100644
--- a/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLinks-nested.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLinks-nested.ts
@@ -1,8 +1,8 @@
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
 import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
@@ -20,7 +20,7 @@ Sentry.startSpan({ name: 'parent1' }, async parentSpan1 => {
         { context: parentSpan1.spanContext() },
         {
           context: childSpan1.spanContext(),
-          attributes: { 'sentry.link.type': 'previous_trace' },
+          attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' },
         },
       ]);
 
diff --git a/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLinks.ts b/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLinks.ts
index 9ee7af7856bd..d401994901ef 100644
--- a/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLinks.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/linking/scenario-addLinks.ts
@@ -1,8 +1,8 @@
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
 import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
@@ -21,7 +21,7 @@ Sentry.startSpan({ name: 'rootSpan' }, rootSpan => {
     { context: span1.spanContext() },
     {
       context: span2.spanContext(),
-      attributes: { 'sentry.link.type': 'previous_trace' },
+      attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' },
     },
   ]);
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/linking/scenario-span-options.ts b/dev-packages/node-integration-tests/suites/tracing/linking/scenario-span-options.ts
index 7b28c3f6992c..b00b18c82405 100644
--- a/dev-packages/node-integration-tests/suites/tracing/linking/scenario-span-options.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/linking/scenario-span-options.ts
@@ -1,8 +1,8 @@
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
 import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
@@ -17,7 +17,7 @@ parentSpan1.end();
 Sentry.startSpan(
   {
     name: 'parent2',
-    links: [{ context: parentSpan1.spanContext(), attributes: { 'sentry.link.type': 'previous_trace' } }],
+    links: [{ context: parentSpan1.spanContext(), attributes: { [SENTRY_LINK_TYPE]: 'previous_trace' } }],
   },
   async () => {
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
diff --git a/dev-packages/node-integration-tests/suites/tracing/linking/test.ts b/dev-packages/node-integration-tests/suites/tracing/linking/test.ts
index a0874274d2bd..84ed6d94314e 100644
--- a/dev-packages/node-integration-tests/suites/tracing/linking/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/linking/test.ts
@@ -1,31 +1,25 @@
+import { SENTRY_LINK_TYPE, SENTRY_SEGMENT_ID } from '@sentry/conventions/attributes';
 import { describe, expect, test } from 'vitest';
 import { createRunner } from '../../../utils/runner';
 
 describe('span links', () => {
   test('should link spans by adding "links" to span options', async () => {
-    let span1_traceId: string, span1_spanId: string;
-
     await createRunner(__dirname, 'scenario-span-options.ts')
       .expect({
-        transaction: event => {
-          expect(event.transaction).toBe('parent1');
-
-          const traceContext = event.contexts?.trace;
-          span1_traceId = traceContext?.trace_id as string;
-          span1_spanId = traceContext?.span_id as string;
-        },
-      })
-      .expect({
-        transaction: event => {
-          expect(event.transaction).toBe('parent2');
-
-          const traceContext = event.contexts?.trace;
-          expect(traceContext).toBeDefined();
-          expect(traceContext?.links).toEqual([
-            expect.objectContaining({
-              trace_id: expect.stringMatching(span1_traceId),
-              span_id: expect.stringMatching(span1_spanId),
-            }),
+        span: container => {
+          const parent1 = container.items.find(span => span.is_segment && span.name === 'parent1');
+          expect(parent1).toBeDefined();
+
+          const parent2 = container.items.find(span => span.is_segment && span.name === 'parent2');
+          expect(parent2).toBeDefined();
+
+          expect(parent2?.links).toEqual([
+            {
+              trace_id: parent1?.trace_id,
+              span_id: parent1?.span_id,
+              sampled: true,
+              attributes: { [SENTRY_LINK_TYPE]: { type: 'string', value: 'previous_trace' } },
+            },
           ]);
         },
       })
@@ -34,31 +28,30 @@ describe('span links', () => {
   });
 
   test('should link spans with addLink() in trace context', async () => {
-    let span1_traceId: string, span1_spanId: string;
-
     await createRunner(__dirname, 'scenario-addLink.ts')
       .expect({
-        transaction: event => {
-          expect(event.transaction).toBe('span1');
-
-          span1_traceId = event.contexts?.trace?.trace_id as string;
-          span1_spanId = event.contexts?.trace?.span_id as string;
-
-          expect(event.spans).toEqual([]);
-        },
-      })
-      .expect({
-        transaction: event => {
-          expect(event.transaction).toBe('rootSpan');
-
-          expect(event.contexts?.trace?.links).toEqual([
-            expect.objectContaining({
-              trace_id: expect.stringMatching(span1_traceId),
-              span_id: expect.stringMatching(span1_spanId),
-              attributes: expect.objectContaining({
-                'sentry.link.type': 'previous_trace',
-              }),
-            }),
+        span: container => {
+          const span1 = container.items.find(span => span.is_segment && span.name === 'span1');
+          expect(span1).toBeDefined();
+
+          expect(
+            container.items.filter(
+              span => !span.is_segment && span.attributes[SENTRY_SEGMENT_ID]?.value === span1?.span_id,
+            ),
+          ).toEqual([]);
+
+          const rootSpan = container.items.find(span => span.is_segment && span.name === 'rootSpan');
+          expect(rootSpan).toBeDefined();
+
+          expect(rootSpan?.links).toEqual([
+            {
+              trace_id: span1?.trace_id,
+              span_id: span1?.span_id,
+              sampled: true,
+              attributes: {
+                [SENTRY_LINK_TYPE]: { type: 'string', value: 'previous_trace' },
+              },
+            },
           ]);
         },
       })
@@ -67,46 +60,45 @@ describe('span links', () => {
   });
 
   test('should link spans with addLinks() in trace context', async () => {
-    let span1_traceId: string, span1_spanId: string, span2_traceId: string, span2_spanId: string;
-
     await createRunner(__dirname, 'scenario-addLinks.ts')
       .expect({
-        transaction: event => {
-          expect(event.transaction).toBe('span1');
-
-          span1_traceId = event.contexts?.trace?.trace_id as string;
-          span1_spanId = event.contexts?.trace?.span_id as string;
-
-          expect(event.spans).toEqual([]);
-        },
-      })
-      .expect({
-        transaction: event => {
-          expect(event.transaction).toBe('span2');
-
-          span2_traceId = event.contexts?.trace?.trace_id as string;
-          span2_spanId = event.contexts?.trace?.span_id as string;
-
-          expect(event.spans).toEqual([]);
-        },
-      })
-      .expect({
-        transaction: event => {
-          expect(event.transaction).toBe('rootSpan');
-
-          expect(event.contexts?.trace?.links).toEqual([
-            expect.not.objectContaining({ attributes: expect.anything() }) &&
-              expect.objectContaining({
-                trace_id: expect.stringMatching(span1_traceId),
-                span_id: expect.stringMatching(span1_spanId),
-              }),
-            expect.objectContaining({
-              trace_id: expect.stringMatching(span2_traceId),
-              span_id: expect.stringMatching(span2_spanId),
-              attributes: expect.objectContaining({
-                'sentry.link.type': 'previous_trace',
-              }),
-            }),
+        span: container => {
+          const span1 = container.items.find(span => span.is_segment && span.name === 'span1');
+          expect(span1).toBeDefined();
+
+          expect(
+            container.items.filter(
+              span => !span.is_segment && span.attributes[SENTRY_SEGMENT_ID]?.value === span1?.span_id,
+            ),
+          ).toEqual([]);
+
+          const span2 = container.items.find(span => span.is_segment && span.name === 'span2');
+          expect(span2).toBeDefined();
+
+          expect(
+            container.items.filter(
+              span => !span.is_segment && span.attributes[SENTRY_SEGMENT_ID]?.value === span2?.span_id,
+            ),
+          ).toEqual([]);
+
+          const rootSpan = container.items.find(span => span.is_segment && span.name === 'rootSpan');
+          expect(rootSpan).toBeDefined();
+
+          expect(rootSpan?.links).toEqual([
+            {
+              trace_id: span1?.trace_id,
+              span_id: span1?.span_id,
+              sampled: true,
+              attributes: {},
+            },
+            {
+              trace_id: span2?.trace_id,
+              span_id: span2?.span_id,
+              sampled: true,
+              attributes: {
+                [SENTRY_LINK_TYPE]: { type: 'string', value: 'previous_trace' },
+              },
+            },
           ]);
         },
       })
@@ -117,36 +109,36 @@ describe('span links', () => {
   test('should link spans with addLink() in nested startSpan() calls', async () => {
     await createRunner(__dirname, 'scenario-addLink-nested.ts')
       .expect({
-        transaction: event => {
-          expect(event.transaction).toBe('parent1');
-
-          const parent1_traceId = event.contexts?.trace?.trace_id as string;
-          const parent1_spanId = event.contexts?.trace?.span_id as string;
+        span: container => {
+          const parent1 = container.items.find(span => span.is_segment && span.name === 'parent1');
+          expect(parent1).toBeDefined();
 
-          const spans = event.spans || [];
-          const child1_1 = spans.find(span => span.description === 'child1.1');
-          const child1_2 = spans.find(span => span.description === 'child1.2');
+          const spans = container.items.filter(span => !span.is_segment);
+          const child1_1 = spans.find(span => span.name === 'child1.1');
+          const child1_2 = spans.find(span => span.name === 'child1.2');
 
           expect(child1_1).toBeDefined();
           expect(child1_1?.links).toEqual([
-            expect.objectContaining({
-              trace_id: expect.stringMatching(parent1_traceId),
-              span_id: expect.stringMatching(parent1_spanId),
-              attributes: expect.objectContaining({
-                'sentry.link.type': 'previous_trace',
-              }),
-            }),
+            {
+              trace_id: parent1?.trace_id,
+              span_id: parent1?.span_id,
+              sampled: true,
+              attributes: {
+                [SENTRY_LINK_TYPE]: { type: 'string', value: 'previous_trace' },
+              },
+            },
           ]);
 
           expect(child1_2).toBeDefined();
           expect(child1_2?.links).toEqual([
-            expect.objectContaining({
-              trace_id: expect.stringMatching(parent1_traceId),
-              span_id: expect.stringMatching(parent1_spanId),
-              attributes: expect.objectContaining({
-                'sentry.link.type': 'previous_trace',
-              }),
-            }),
+            {
+              trace_id: parent1?.trace_id,
+              span_id: parent1?.span_id,
+              sampled: true,
+              attributes: {
+                [SENTRY_LINK_TYPE]: { type: 'string', value: 'previous_trace' },
+              },
+            },
           ]);
         },
       })
@@ -157,33 +149,33 @@ describe('span links', () => {
   test('should link spans with addLinks() in nested startSpan() calls', async () => {
     await createRunner(__dirname, 'scenario-addLinks-nested.ts')
       .expect({
-        transaction: event => {
-          expect(event.transaction).toBe('parent1');
-
-          const parent1_traceId = event.contexts?.trace?.trace_id as string;
-          const parent1_spanId = event.contexts?.trace?.span_id as string;
+        span: container => {
+          const parent1 = container.items.find(span => span.is_segment && span.name === 'parent1');
+          expect(parent1).toBeDefined();
 
-          const spans = event.spans || [];
-          const child1_1 = spans.find(span => span.description === 'child1.1');
-          const child2_1 = spans.find(span => span.description === 'child2.1');
+          const spans = container.items.filter(span => !span.is_segment);
+          const child1_1 = spans.find(span => span.name === 'child1.1');
+          const child2_1 = spans.find(span => span.name === 'child2.1');
 
           expect(child1_1).toBeDefined();
 
           expect(child2_1).toBeDefined();
 
           expect(child2_1?.links).toEqual([
-            expect.not.objectContaining({ attributes: expect.anything() }) &&
-              expect.objectContaining({
-                trace_id: expect.stringMatching(parent1_traceId),
-                span_id: expect.stringMatching(parent1_spanId),
-              }),
-            expect.objectContaining({
-              trace_id: expect.stringMatching(child1_1?.trace_id || 'non-existent-id-fallback'),
-              span_id: expect.stringMatching(child1_1?.span_id || 'non-existent-id-fallback'),
-              attributes: expect.objectContaining({
-                'sentry.link.type': 'previous_trace',
-              }),
-            }),
+            {
+              trace_id: parent1?.trace_id,
+              span_id: parent1?.span_id,
+              sampled: true,
+              attributes: {},
+            },
+            {
+              trace_id: child1_1?.trace_id,
+              span_id: child1_1?.span_id,
+              sampled: true,
+              attributes: {
+                [SENTRY_LINK_TYPE]: { type: 'string', value: 'previous_trace' },
+              },
+            },
           ]);
         },
       })
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/instrument.mjs
index a618d72f4469..5c80a151a31e 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1.0,
   transport: loggingTransport,
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/test.ts b/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/test.ts
index c315cf866900..b8d33d7976cf 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/test.ts
@@ -1,4 +1,4 @@
-import { afterAll, describe } from 'vitest';
+import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 describe('tracer.startActiveSpan errors', () => {
@@ -17,16 +17,19 @@ describe('tracer.startActiveSpan errors', () => {
     test('does NOT mark span errored when uncaught error escapes raw tracer.startActiveSpan callback', async () => {
       await createRunner()
         // The rejection is captured as an error event, which can reach the transport before the
-        // transaction.
+        // span envelope.
         .ignore('event')
         .expect({
-          transaction: {
-            transaction: 'test span name',
-            contexts: {
-              trace: {
+          span: {
+            items: [
+              {
+                name: 'test span name',
+                is_segment: true,
+                start_timestamp: expect.any(Number),
+                end_timestamp: expect.any(Number),
                 status: 'ok',
               },
-            },
+            ],
           },
         })
         .start()

From 6706e75b61cc65aa9509ce44b0113a992c2fdfa8 Mon Sep 17 00:00:00 2001
From: Andrei <168741329+andreiborza@users.noreply.github.com>
Date: Fri, 9 Oct 2026 16:23:50 +0200
Subject: [PATCH 39/84] test(cloudflare): Add LangChain TypeSafeClassifier
 integration test (#25234)

## What

Adds a Cloudflare integration test that runs a LangChain
`TypeSafeClassifier` in a Worker built with the Sentry Vite plugin, and
checks that the call is traced as a `gen_ai.evaluate` span.

- Moves the Cloudflare test package to LangChain v1, which
`@langchain/typesafe` requires.

## Why

TypeSafeClassifier tracing is tested on Node only. This test confirms
that it also works on Cloudflare.

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../cloudflare-integration-tests/package.json |   6 +-
 .../langchain-typesafe-classifier/index.ts    |  23 +++
 .../instrument.server.ts                      |  11 ++
 .../langchain-typesafe-classifier/test.ts     |  60 ++++++++
 .../vite.config.mts                           |   7 +
 .../wrangler.jsonc                            |   7 +
 yarn.lock                                     | 139 ++++++++++++++----
 7 files changed, 222 insertions(+), 31 deletions(-)
 create mode 100644 dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/index.ts
 create mode 100644 dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/instrument.server.ts
 create mode 100644 dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/test.ts
 create mode 100644 dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/vite.config.mts
 create mode 100644 dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/wrangler.jsonc

diff --git a/dev-packages/cloudflare-integration-tests/package.json b/dev-packages/cloudflare-integration-tests/package.json
index aa3fc77e2d9c..e23bcc9abcf6 100644
--- a/dev-packages/cloudflare-integration-tests/package.json
+++ b/dev-packages/cloudflare-integration-tests/package.json
@@ -17,15 +17,17 @@
     "ai": "^6.0.0",
     "@anthropic-ai/sdk": "0.63.0",
     "@google/genai": "^1.20.0",
-    "@langchain/core": "^0.3.80",
+    "@langchain/core": "^1.2.17",
     "@langchain/langgraph": "^1.0.1",
-    "@langchain/openai": "^0.5.0",
+    "@langchain/openai": "^1.6.2",
+    "@langchain/typesafe": "^0.0.2",
     "@prisma/adapter-d1": "6.15.0",
     "@prisma/client": "6.15.0",
     "@sentry/cloudflare": "11.6.0",
     "@sentry/core": "11.6.0",
     "@sentry/hono": "11.6.0",
     "hono": "^4.13.7",
+    "langchain": "^1.5.16",
     "openai": "5.18.1"
   },
   "devDependencies": {
diff --git a/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/index.ts b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/index.ts
new file mode 100644
index 000000000000..0fc778436064
--- /dev/null
+++ b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/index.ts
@@ -0,0 +1,23 @@
+import { HumanMessage } from '@langchain/core/messages';
+import { TypeSafeClassifier } from '@langchain/typesafe';
+
+const mockFetch: typeof fetch = async () =>
+  Response.json({
+    model: 'jev-1.13',
+    answers: { urgent: { type: 'noul', noul: 0.9 } },
+    usage: { input_tokens: 30, output_tokens: 2 },
+  });
+
+export default {
+  async fetch() {
+    const classifier = new TypeSafeClassifier({
+      apiKey: 'mock-api-key',
+      fetch: mockFetch,
+      questions: { urgent: { type: 'noul', instructions: 'Is this urgent?' } },
+    });
+
+    const result = await classifier.invoke([new HumanMessage('My payouts have been failing.')]);
+
+    return Response.json(result);
+  },
+} satisfies ExportedHandler;
diff --git a/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/instrument.server.ts b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/instrument.server.ts
new file mode 100644
index 000000000000..0982b0fc7bf8
--- /dev/null
+++ b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/instrument.server.ts
@@ -0,0 +1,11 @@
+import { defineCloudflareOptions } from '@sentry/cloudflare';
+
+interface Env {
+  SENTRY_DSN: string;
+}
+
+export default defineCloudflareOptions((env: Env) => ({
+  dsn: env.SENTRY_DSN,
+  tracesSampleRate: 1.0,
+  dataCollection: { genAI: { inputs: true, outputs: true } },
+}));
diff --git a/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/test.ts b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/test.ts
new file mode 100644
index 000000000000..b5681919fe82
--- /dev/null
+++ b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/test.ts
@@ -0,0 +1,60 @@
+import {
+  GEN_AI_INPUT_MESSAGES,
+  GEN_AI_OPERATION_NAME,
+  GEN_AI_OUTPUT_MESSAGES,
+  GEN_AI_PROVIDER_NAME,
+  GEN_AI_REQUEST_MODEL,
+  GEN_AI_RESPONSE_MODEL,
+  GEN_AI_USAGE_INPUT_TOKENS,
+  GEN_AI_USAGE_OUTPUT_TOKENS,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import { GEN_AI_EVALUATE } from '@sentry/conventions/op';
+import { expect, it } from 'vitest';
+import { createRunner } from '../../../runner';
+import { getSpanOp, getSpansFromEnvelope } from '../../../spanUtils';
+
+// The worker passes no callback handler, so the span only exists if the Vite plugin's build-time hook
+// on `TypeSafeClassifier.invoke` adds it. The input `state` is the transcript the classifier sends to
+// Jev, which only the hook records.
+
+it('traces a TypeSafeClassifier call through the Vite plugin instrumentation', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .ignore('event')
+    .expect(envelope => {
+      const spans = getSpansFromEnvelope(envelope);
+      const segmentSpan = spans.find(span => span.is_segment);
+      const genAiSpans = spans.filter(span => getSpanOp(span)?.startsWith('gen_ai.'));
+
+      expect(genAiSpans).toHaveLength(1);
+
+      const evaluateSpan = genAiSpans[0]!;
+      expect(evaluateSpan.name).toBe('evaluate jev-latest');
+      expect(evaluateSpan.parent_span_id).toBe(segmentSpan?.span_id);
+      expect(evaluateSpan.status).toBe('ok');
+      expect(evaluateSpan.attributes).toMatchObject({
+        [SENTRY_OP]: { value: GEN_AI_EVALUATE, type: 'string' },
+        [SENTRY_ORIGIN]: { value: 'auto.ai.langchain', type: 'string' },
+        [GEN_AI_OPERATION_NAME]: { value: 'evaluate', type: 'string' },
+        [GEN_AI_PROVIDER_NAME]: { value: 'typesafe', type: 'string' },
+        [GEN_AI_REQUEST_MODEL]: { value: 'jev-latest', type: 'string' },
+        [GEN_AI_RESPONSE_MODEL]: { value: 'jev-1.13', type: 'string' },
+        [GEN_AI_USAGE_INPUT_TOKENS]: { value: 30, type: 'integer' },
+        [GEN_AI_USAGE_OUTPUT_TOKENS]: { value: 2, type: 'integer' },
+      });
+      expect(JSON.parse(evaluateSpan.attributes[GEN_AI_INPUT_MESSAGES]!.value as string)).toEqual([
+        {
+          type: 'evaluation',
+          state: ['user: My payouts have been failing.'],
+          questions: { urgent: { type: 'noul', instructions: 'Is this urgent?' } },
+        },
+      ]);
+      expect(JSON.parse(evaluateSpan.attributes[GEN_AI_OUTPUT_MESSAGES]!.value as string)).toEqual([
+        { type: 'evaluation', answers: { urgent: { type: 'noul', noul: 0.9 } } },
+      ]);
+    })
+    .start(signal);
+  await runner.makeRequest('get', '/');
+  await runner.completed();
+});
diff --git a/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/vite.config.mts b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/vite.config.mts
new file mode 100644
index 000000000000..005f4448f6cb
--- /dev/null
+++ b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/vite.config.mts
@@ -0,0 +1,7 @@
+import { cloudflare } from '@cloudflare/vite-plugin';
+import { sentryCloudflareVitePlugin } from '@sentry/cloudflare/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [cloudflare(), sentryCloudflareVitePlugin()],
+});
diff --git a/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/wrangler.jsonc b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/wrangler.jsonc
new file mode 100644
index 000000000000..94b87d968ac9
--- /dev/null
+++ b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/wrangler.jsonc
@@ -0,0 +1,7 @@
+{
+  "$schema": "../../../node_modules/wrangler/config-schema.json",
+  "name": "cloudflare-langchain-typesafe-classifier",
+  "main": "index.ts",
+  "compatibility_date": "2025-06-17",
+  "compatibility_flags": ["nodejs_compat"],
+}
diff --git a/yarn.lock b/yarn.lock
index f4376646ccb5..d7ba446cb178 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5509,12 +5509,23 @@
     zod "^3.25.32"
     zod-to-json-schema "^3.22.3"
 
-"@langchain/langgraph-checkpoint@^1.0.0":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@langchain/langgraph-checkpoint/-/langgraph-checkpoint-1.0.0.tgz#ece2ede439d0d0b0b532c4be7817fd5029afe4f8"
-  integrity sha512-xrclBGvNCXDmi0Nz28t3vjpxSH6UYx6w5XAXSiiB1WEdc2xD2iY/a913I3x3a31XpInUW/GGfXXfePfaghV54A==
+"@langchain/core@^1.2.17":
+  version "1.2.17"
+  resolved "https://sfw.security.sentry.io/npm/@langchain/core/-/core-1.2.17.tgz#f889484a5eb8a32b493748a6f68ce26c70218445"
+  integrity sha512-aLQLSed6oLCMLtJHrINhnFmsu79G2UiDlRslbOx+TSN9NmU+WuDv1OtVxrLpYglhXNy53elSduMVk3XBPG9ulw==
   dependencies:
-    uuid "^10.0.0"
+    "@cfworker/json-schema" "^4.0.2"
+    "@standard-schema/spec" "^1.1.0"
+    js-tiktoken "^1.0.12"
+    langsmith ">=0.5.0 <1.0.0"
+    mustache "^4.2.0"
+    p-queue "^6.6.2"
+    zod "^3.25.76 || ^4"
+
+"@langchain/langgraph-checkpoint@^1.1.5", "@langchain/langgraph-checkpoint@^1.1.6":
+  version "1.1.6"
+  resolved "https://sfw.security.sentry.io/npm/@langchain/langgraph-checkpoint/-/langgraph-checkpoint-1.1.6.tgz#df833a5f3a4f42b969cc9f7682c193c274f481c5"
+  integrity sha512-CpDMGTY4Y6qzoGewMoL8MS9Ej35vyrrchbRpKCtUDWnHhrf4lbHp7wnu9dsHaavB3Z+M6aVRl+9GNQbIJVV1dg==
 
 "@langchain/langgraph-checkpoint@~0.0.17":
   version "0.0.18"
@@ -5533,14 +5544,15 @@
     p-retry "4"
     uuid "^9.0.0"
 
-"@langchain/langgraph-sdk@~1.0.0":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@langchain/langgraph-sdk/-/langgraph-sdk-1.0.0.tgz#16faca6cc426432dee9316428d0aecd94e5b7989"
-  integrity sha512-g25ti2W7Dl5wUPlNK+0uIGbeNFqf98imhHlbdVVKTTkDYLhi/pI1KTgsSSkzkeLuBIfvt2b0q6anQwCs7XBlbw==
+"@langchain/langgraph-sdk@~1.12.3":
+  version "1.12.3"
+  resolved "https://sfw.security.sentry.io/npm/@langchain/langgraph-sdk/-/langgraph-sdk-1.12.3.tgz#a30d94308f40971f2f31cf027f26d12ed7072afd"
+  integrity sha512-o5Qd1pepsJKHmHGIcWhOlZe2fvlPs2AEkVOxqzbL3R8IiMBPH2gNG8/kwK36czEnagiJtu4RUn02mKbGRwd5dQ==
   dependencies:
-    p-queue "^6.6.2"
-    p-retry "4"
-    uuid "^9.0.0"
+    "@langchain/protocol" "^0.0.19"
+    "@types/json-schema" "^7.0.15"
+    p-queue "^9.0.1"
+    p-retry "^7.1.1"
 
 "@langchain/langgraph@^0.2.32":
   version "0.2.74"
@@ -5552,14 +5564,15 @@
     uuid "^10.0.0"
     zod "^3.23.8"
 
-"@langchain/langgraph@^1.0.1":
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/@langchain/langgraph/-/langgraph-1.0.2.tgz#62de931edac0dd850daf708bd6f8f3835cf25a5e"
-  integrity sha512-syxzzWTnmpCL+RhUEvalUeOXFoZy/KkzHa2Da2gKf18zsf9Dkbh3rfnRDrTyUGS1XSTejq07s4rg1qntdEDs2A==
+"@langchain/langgraph@^1.0.1", "@langchain/langgraph@^1.4.18":
+  version "1.4.21"
+  resolved "https://sfw.security.sentry.io/npm/@langchain/langgraph/-/langgraph-1.4.21.tgz#390a2c36901b403faa7f5dae2064d18942300d12"
+  integrity sha512-0LRyRw594IO98etnnBCM6nhckVjWGNnObpdaQij1e+u+GsUwGvn9P4/P42UAJG56WFF72A9n93WwCOW7Mq9yug==
   dependencies:
-    "@langchain/langgraph-checkpoint" "^1.0.0"
-    "@langchain/langgraph-sdk" "~1.0.0"
-    uuid "^10.0.0"
+    "@langchain/langgraph-checkpoint" "^1.1.6"
+    "@langchain/langgraph-sdk" "~1.12.3"
+    "@langchain/protocol" "^0.0.19"
+    "@standard-schema/spec" "1.1.0"
 
 "@langchain/openai@^0.5.0":
   version "0.5.18"
@@ -5570,6 +5583,27 @@
     openai "^5.3.0"
     zod "^3.25.32"
 
+"@langchain/openai@^1.6.2":
+  version "1.6.2"
+  resolved "https://sfw.security.sentry.io/npm/@langchain/openai/-/openai-1.6.2.tgz#1a70df67e11680e9d38c2bb4214c753ce13a1ed9"
+  integrity sha512-KaXc3zjdM2/E24FdBlsk5NTT2Dyxh46vzCS2by78ehN6G5zdx+4OfVnPvyLl8r2tv2TqQCHpEhImVXgnAZaOvg==
+  dependencies:
+    js-tiktoken "^1.0.12"
+    openai "^7.10.0"
+    zod "^3.25.76 || ^4"
+
+"@langchain/protocol@^0.0.19":
+  version "0.0.19"
+  resolved "https://sfw.security.sentry.io/npm/@langchain/protocol/-/protocol-0.0.19.tgz#7fe43fed115dc34b3b4c246e8d5283fbcbfab7b0"
+  integrity sha512-9hKcRrH7cBX6gfutdfXPoft1OCchHe4FEpALoDJMl5Qu+n/YG5ynZmyu8+8cxORlPwHBoKTxggvXz+76M1yX1Q==
+
+"@langchain/typesafe@^0.0.2":
+  version "0.0.2"
+  resolved "https://sfw.security.sentry.io/npm/@langchain/typesafe/-/typesafe-0.0.2.tgz#c4bef22fd8509d9650ef91d255df8f9925678f30"
+  integrity sha512-FwNQ5ZzKRvguO4zGhwRsOxumH7zNQjfGdlfdla7KUUGCGfXbGpqXtFmxw+4DRdTCVxgsJQ3NIpke9WICukWlnQ==
+  dependencies:
+    zod "^4"
+
 "@leichtgewicht/ip-codec@^2.0.1":
   version "2.0.4"
   resolved "https://registry.yarnpkg.com/@leichtgewicht/ip-codec/-/ip-codec-2.0.4.tgz#b2ac626d6cb9c8718ab459166d4bb405b8ffa78b"
@@ -8693,7 +8727,7 @@
   resolved "https://registry.yarnpkg.com/@speed-highlight/core/-/core-1.2.15.tgz#88c45609a2b5c2293a2e1935417c507f98f39d0b"
   integrity sha512-BMq1K3DsElxDWawkX6eLg9+CKJrTVGCBAWVuHXVUV2u0s2711qiChLSId6ikYPfxhdYocLNt3wWwSvDiTvFabw==
 
-"@standard-schema/spec@^1.0.0", "@standard-schema/spec@^1.1.0":
+"@standard-schema/spec@1.1.0", "@standard-schema/spec@^1.0.0", "@standard-schema/spec@^1.1.0":
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/@standard-schema/spec/-/spec-1.1.0.tgz#a79b55dbaf8604812f52d140b2c9ab41bc150bb8"
   integrity sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==
@@ -15389,10 +15423,10 @@ eventemitter3@^4.0.0, eventemitter3@^4.0.4:
   resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
   integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
 
-eventemitter3@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-5.0.1.tgz#53f5ffd0a492ac800721bb42c66b841de96423c4"
-  integrity sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==
+eventemitter3@^5.0.1, eventemitter3@^5.0.4:
+  version "5.0.4"
+  resolved "https://sfw.security.sentry.io/npm/eventemitter3/-/eventemitter3-5.0.4.tgz#a86d66170433712dde814707ac52b5271ceb1feb"
+  integrity sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==
 
 events@^3.0.0, events@^3.2.0, events@^3.3.0:
   version "3.3.0"
@@ -17840,6 +17874,11 @@ is-negative-zero@^2.0.3:
   resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.3.tgz#ced903a027aca6381b777a5743069d7376a49747"
   integrity sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==
 
+is-network-error@^1.1.0:
+  version "1.3.2"
+  resolved "https://sfw.security.sentry.io/npm/is-network-error/-/is-network-error-1.3.2.tgz#9460bc30f8419a4bca77114f4de88a3ee5e0c519"
+  integrity sha512-PhBY86zaxNZUuWP6h13Vu5oFe0XY6/UlKzQnYFELzGVHygP3MxmvTfYSG7GN3aIab/iWudSMgjSnG9Dq+nHrgA==
+
 is-node-process@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/is-node-process/-/is-node-process-1.2.0.tgz#ea02a1b90ddb3934a19aea414e88edef7e11d134"
@@ -18663,6 +18702,23 @@ ky@1.7.5:
   resolved "https://registry.yarnpkg.com/ky/-/ky-1.7.5.tgz#69c9b70ff818fd6108fc04a89c1454412c11dfce"
   integrity sha512-HzhziW6sc5m0pwi5M196+7cEBtbt0lCYi67wNsiwMUmz833wloE0gbzJPWKs1gliFKQb34huItDQX97LyOdPdA==
 
+langchain@^1.5.16:
+  version "1.5.16"
+  resolved "https://sfw.security.sentry.io/npm/langchain/-/langchain-1.5.16.tgz#eb1549a885d67d2f7fe429ed2625bc89d1409d21"
+  integrity sha512-t5DvkNvySgkNAjWLJ5lIvg2R2WJJ/uF7hHtaSIwUEUUv/YzynzbtJLovwhIw0W1HdOnBbao6dkWOZthKjwBUPQ==
+  dependencies:
+    "@langchain/langgraph" "^1.4.18"
+    "@langchain/langgraph-checkpoint" "^1.1.5"
+    langsmith ">=0.5.0 <1.0.0"
+    zod "^3.25.76 || ^4"
+
+"langsmith@>=0.5.0 <1.0.0":
+  version "0.10.10"
+  resolved "https://sfw.security.sentry.io/npm/langsmith/-/langsmith-0.10.10.tgz#cc12ce1aa24e30b20770181cfe98eec2d52683e0"
+  integrity sha512-I83MmN/tqU662yHfv7DCMlJh8eFuRdY2Ri9rlvM61DGEsVdnVkOa0eyv9DpsstBM5dS877o5GDn+qHwZWfSgRg==
+  dependencies:
+    p-queue "6.6.2"
+
 langsmith@^0.3.67:
   version "0.3.74"
   resolved "https://registry.yarnpkg.com/langsmith/-/langsmith-0.3.74.tgz#014d31a9ff7530b54f0d797502abd512ce8fb6fb"
@@ -21436,6 +21492,11 @@ openai@^5.3.0:
   resolved "https://registry.yarnpkg.com/openai/-/openai-5.23.2.tgz#f13e2dc2ef6b88aab6a9b97cdc68d41a1d083c68"
   integrity sha512-MQBzmTulj+MM5O8SKEk/gL8a7s5mktS9zUtAkU257WjvobGc9nKcBuVwjyEEcb9SI8a8Y2G/mzn3vm9n1Jlleg==
 
+openai@^7.10.0:
+  version "7.31.0"
+  resolved "https://sfw.security.sentry.io/npm/openai/-/openai-7.31.0.tgz#af4cc2326673ba1ec8b27ccc854e8171eaee7ea3"
+  integrity sha512-ZGAzauuYb0DdB53qVbIR+X8rdmNtWgiElrrMthbZCVreLcIsQJBwzAIWUbpB2FkQu2Cj6OJ9zJR1EKMUYn4/SQ==
+
 optional-require@^1.1.8:
   version "1.1.8"
   resolved "https://registry.yarnpkg.com/optional-require/-/optional-require-1.1.8.tgz#16364d76261b75d964c482b2406cb824d8ec44b7"
@@ -21774,7 +21835,7 @@ p-map@^7.0.3:
   resolved "https://sfw.security.sentry.io/npm/p-map/-/p-map-7.0.7.tgz#a82175dd690468a930b9ae45c2b9829c5bf60fa3"
   integrity sha512-VaWRu2i4FJNRtiRWCuuQRgfQ1B7a6+gMSrO+3j0EQi/k0ULfS9kosRxGoiqwzIjZTDI02tGfk5mXXltLg6QtfQ==
 
-p-queue@^6.6.2:
+p-queue@6.6.2, p-queue@^6.6.2:
   version "6.6.2"
   resolved "https://registry.yarnpkg.com/p-queue/-/p-queue-6.6.2.tgz#2068a9dcf8e67dd0ec3e7a2bcb76810faa85e426"
   integrity sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==
@@ -21790,6 +21851,14 @@ p-queue@^8.0.1:
     eventemitter3 "^5.0.1"
     p-timeout "^6.1.2"
 
+p-queue@^9.0.1:
+  version "9.3.3"
+  resolved "https://sfw.security.sentry.io/npm/p-queue/-/p-queue-9.3.3.tgz#c5e528c7eb361b7ba8eb5a9406902f7f2e75fc8f"
+  integrity sha512-NXAOdnEe5FsZJfT4oK84lE1Y5cFFdWlRuOo5tww8DyNMxyRXwn39fIkUtNLKppcPC+UYU/bXujNCUGDv01y7CA==
+  dependencies:
+    eventemitter3 "^5.0.4"
+    p-timeout "^7.0.0"
+
 p-retry@4, p-retry@^4.5.0:
   version "4.6.2"
   resolved "https://registry.yarnpkg.com/p-retry/-/p-retry-4.6.2.tgz#9baae7184057edd4e17231cee04264106e092a16"
@@ -21798,6 +21867,13 @@ p-retry@4, p-retry@^4.5.0:
     "@types/retry" "0.12.0"
     retry "^0.13.1"
 
+p-retry@^7.1.1:
+  version "7.1.1"
+  resolved "https://sfw.security.sentry.io/npm/p-retry/-/p-retry-7.1.1.tgz#7470fdecb1152ba50f1334e48378c9e401330e24"
+  integrity sha512-J5ApzjyRkkf601HpEeykoiCvzHQjWxPAHhyjFcEUP2SWq0+35NKh8TLhpLw+Dkq5TZBFvUM6UigdE9hIVYTl5w==
+  dependencies:
+    is-network-error "^1.1.0"
+
 p-timeout@^3.0.0, p-timeout@^3.1.0, p-timeout@^3.2.0:
   version "3.2.0"
   resolved "https://registry.yarnpkg.com/p-timeout/-/p-timeout-3.2.0.tgz#c7e17abc971d2a7962ef83626b35d635acf23dfe"
@@ -21810,6 +21886,11 @@ p-timeout@^6.1.2:
   resolved "https://registry.yarnpkg.com/p-timeout/-/p-timeout-6.1.4.tgz#418e1f4dd833fa96a2e3f532547dd2abdb08dbc2"
   integrity sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg==
 
+p-timeout@^7.0.0:
+  version "7.0.2"
+  resolved "https://sfw.security.sentry.io/npm/p-timeout/-/p-timeout-7.0.2.tgz#6b5c8c8eb99ea96fa775508fb1604e7ea094dd47"
+  integrity sha512-prbX4Z3YszrFNgH+MW5Zoeq3baXrMtP/MQnFeET90UB/GtGcGDQ5Usg9OCy6ETjTTntOw1SL2z9fMPUppN3Guw==
+
 p-try@^2.0.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
@@ -28581,10 +28662,10 @@ zod@^3.23.8, zod@^3.24.1, zod@^3.25.32:
   resolved "https://registry.yarnpkg.com/zod/-/zod-3.25.76.tgz#26841c3f6fd22a6a2760e7ccb719179768471e34"
   integrity sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==
 
-"zod@^3.25.0 || ^4.0.0", zod@^4.0.0, zod@^4.2.0:
-  version "4.5.4"
-  resolved "https://sfw.security.sentry.io/npm/zod/-/zod-4.5.4.tgz#e215c62420c528dd7951e31fb52c5438f1fd184a"
-  integrity sha512-sC95tT5iHHH9gtpj6A81kh+NEaRAUFN+qlUPDUbRfOMvNf5QCBqsb3WgvnpVtK5Y+4UfA6KqufotuTvMGiTlsA==
+"zod@^3.25.0 || ^4.0.0", "zod@^3.25.76 || ^4", zod@^4, zod@^4.0.0, zod@^4.2.0:
+  version "4.6.5"
+  resolved "https://sfw.security.sentry.io/npm/zod/-/zod-4.6.5.tgz#e3af3edbdc260239c52f73caad05dbbffe6e82cd"
+  integrity sha512-v5l/aFXZQeai4awLbOpSoHecE9UiMrnfx75tEXLjNonXVARxQ5mOeipTjROUchszUNCqnE+hqAMujRsRHsut2Q==
 
 zone.js@^0.12.0:
   version "0.12.0"

From b7deb1fd50032e0478a15006f8bcaad7cf1654ca Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 16:52:12 +0200
Subject: [PATCH 40/84] test(node): Port parallel span and naming tests to
 streaming (#25217)

Exercise parallel root spans and span renaming with the default
streaming lifecycle. Consolidate the matching streamed suites.

Part of #24140

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../parallel-root-spans-streamed/scenario.ts  | 33 -----------------
 .../parallel-root-spans-streamed/test.ts      | 31 ----------------
 .../startSpan/parallel-root-spans/scenario.ts |  1 -
 .../startSpan/parallel-root-spans/test.ts     | 26 +++++++-------
 .../scenario.ts                               | 29 ---------------
 .../parallel-spans-in-scope-streamed/test.ts  | 30 ----------------
 .../scenario.ts                               | 35 -------------------
 .../test.ts                                   | 32 -----------------
 .../scenario.ts                               |  1 -
 .../test.ts                                   | 24 +++++++------
 .../parallel-spans-in-scope/scenario.ts       |  1 -
 .../startSpan/parallel-spans-in-scope/test.ts | 24 ++++++-------
 .../updateName-method-streamed/scenario.ts    | 17 ---------
 .../updateName-method-streamed/test.ts        | 28 ---------------
 .../startSpan/updateName-method/scenario.ts   |  1 -
 .../startSpan/updateName-method/test.ts       | 22 +++++++-----
 .../scenario.ts                               | 17 ---------
 .../updateSpanName-function-streamed/test.ts  | 26 --------------
 .../updateSpanName-function/scenario.ts       |  1 -
 .../startSpan/updateSpanName-function/test.ts | 18 ++++++----
 20 files changed, 62 insertions(+), 335 deletions(-)
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans-streamed/scenario.ts
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans-streamed/test.ts
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-streamed/scenario.ts
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-streamed/test.ts
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId-streamed/scenario.ts
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId-streamed/test.ts
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method-streamed/scenario.ts
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method-streamed/test.ts
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function-streamed/scenario.ts
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function-streamed/test.ts

diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans-streamed/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans-streamed/scenario.ts
deleted file mode 100644
index 5e8aedc0458a..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans-streamed/scenario.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  traceLifecycle: 'stream',
-  transport: loggingTransport,
-});
-
-Sentry.getCurrentScope().setPropagationContext({
-  parentSpanId: '1234567890123456',
-  traceId: '12345678901234567890123456789012',
-  sampleRand: Math.random(),
-});
-
-const spanIdTraceId = Sentry.startSpan(
-  {
-    name: 'test_span_1',
-  },
-  span1 => span1.spanContext().traceId,
-);
-
-Sentry.startSpan(
-  {
-    name: 'test_span_2',
-    attributes: { spanIdTraceId },
-  },
-  () => undefined,
-);
-
-Sentry.flush();
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans-streamed/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans-streamed/test.ts
deleted file mode 100644
index 5f45cccdbf8a..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans-streamed/test.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { afterAll, expect, test } from 'vitest';
-import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
-
-afterAll(() => {
-  cleanupChildProcesses();
-});
-
-test('sends manually started streamed parallel root spans in root context', async () => {
-  expect.assertions(6);
-
-  await createRunner(__dirname, 'scenario.ts')
-    .expect({
-      span: spanContainer => {
-        expect(spanContainer).toBeDefined();
-
-        const span1 = spanContainer.items.find(item => item.name === 'test_span_1');
-        const span2 = spanContainer.items.find(item => item.name === 'test_span_2');
-        expect(span1).toBeDefined();
-        expect(span2).toBeDefined();
-
-        // Both root spans continue the scope's propagation context, matching the core SDK behavior.
-        expect(span1!.trace_id).toBe('12345678901234567890123456789012');
-        expect(span1!.parent_span_id).toBe('1234567890123456');
-
-        // Same trace ID for both spans
-        expect(span2!.trace_id).toBe(span1!.trace_id);
-      },
-    })
-    .start()
-    .completed();
-});
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans/scenario.ts
index 099a8e73f57e..ab031429489b 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans/scenario.ts
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans/test.ts
index 674cafad1f70..c30a35bc06ba 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans/test.ts
@@ -6,23 +6,23 @@ afterAll(() => {
 });
 
 test('should send manually started parallel root spans in root context', async () => {
-  expect.assertions(6);
-
   await createRunner(__dirname, 'scenario.ts')
-    .expect({ transaction: { transaction: 'test_span_1' } })
     .expect({
-      transaction: transaction => {
-        expect(transaction).toBeDefined();
-        const traceId = transaction.contexts?.trace?.trace_id;
+      span: container => {
+        const span1 = container.items.find(span => span.name === 'test_span_1');
+        const span2 = container.items.find(span => span.name === 'test_span_2');
+        expect(span1?.is_segment).toBe(true);
+        expect(span2?.is_segment).toBe(true);
+        expect(span1?.start_timestamp).toEqual(expect.any(Number));
+        expect(span1?.end_timestamp).toEqual(expect.any(Number));
 
-        // Both root spans continue the scope's propagation context, matching the core SDK behavior.
-        expect(traceId).toBe('12345678901234567890123456789012');
-        expect(transaction.contexts?.trace?.parent_span_id).toBe('1234567890123456');
+        // Both root spans continue the scope's propagation context, including the parentSpanId.
+        expect(span1?.trace_id).toBe('12345678901234567890123456789012');
+        expect(span1?.parent_span_id).toBe('1234567890123456');
+        expect(span2?.parent_span_id).toBe('1234567890123456');
 
-        // Same trace ID as the first span
-        const trace1Id = transaction.contexts?.trace?.data?.spanIdTraceId;
-        expect(trace1Id).toBe('12345678901234567890123456789012');
-        expect(trace1Id).toBe(traceId);
+        expect(span2?.trace_id).toBe(span1?.trace_id);
+        expect(span2?.attributes.spanIdTraceId).toEqual({ type: 'string', value: span1?.trace_id });
       },
     })
     .start()
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-streamed/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-streamed/scenario.ts
deleted file mode 100644
index d688d3c3adf7..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-streamed/scenario.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  traceLifecycle: 'stream',
-  transport: loggingTransport,
-});
-
-Sentry.withScope(() => {
-  const spanIdTraceId = Sentry.startSpan(
-    {
-      name: 'test_span_1',
-    },
-    span1 => span1.spanContext().traceId,
-  );
-
-  Sentry.startSpan(
-    {
-      name: 'test_span_2',
-      attributes: { spanIdTraceId },
-    },
-    () => undefined,
-  );
-});
-
-Sentry.flush();
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-streamed/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-streamed/test.ts
deleted file mode 100644
index 2d5de99aae9e..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-streamed/test.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-import { afterAll, expect, test } from 'vitest';
-import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
-
-afterAll(() => {
-  cleanupChildProcesses();
-});
-
-test('sends manually started streamed parallel root spans outside of root context', async () => {
-  expect.assertions(6);
-
-  await createRunner(__dirname, 'scenario.ts')
-    .expect({
-      span: spanContainer => {
-        expect(spanContainer).toBeDefined();
-
-        const span1 = spanContainer.items.find(item => item.name === 'test_span_1');
-        const span2 = spanContainer.items.find(item => item.name === 'test_span_2');
-        expect(span1).toBeDefined();
-        expect(span2).toBeDefined();
-
-        expect(span1!.trace_id).toMatch(/^[0-9a-f]{32}$/);
-        expect(span1!.parent_span_id).toBeUndefined();
-
-        // Same trace ID for both spans - both root spans share the scope's propagation context
-        expect(span2!.trace_id).toBe(span1!.trace_id);
-      },
-    })
-    .start()
-    .completed();
-});
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId-streamed/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId-streamed/scenario.ts
deleted file mode 100644
index 64f194549572..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId-streamed/scenario.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  traceLifecycle: 'stream',
-  transport: loggingTransport,
-});
-
-Sentry.withScope(scope => {
-  scope.setPropagationContext({
-    parentSpanId: '1234567890123456',
-    traceId: '12345678901234567890123456789012',
-    sampleRand: Math.random(),
-  });
-
-  const spanIdTraceId = Sentry.startSpan(
-    {
-      name: 'test_span_1',
-    },
-    span1 => span1.spanContext().traceId,
-  );
-
-  Sentry.startSpan(
-    {
-      name: 'test_span_2',
-      attributes: { spanIdTraceId },
-    },
-    () => undefined,
-  );
-});
-
-Sentry.flush();
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId-streamed/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId-streamed/test.ts
deleted file mode 100644
index 50666c267cdf..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId-streamed/test.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { afterAll, expect, test } from 'vitest';
-import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
-
-afterAll(() => {
-  cleanupChildProcesses();
-});
-
-test('sends manually started streamed parallel root spans outside of root context with parentSpanId', async () => {
-  expect.assertions(6);
-
-  await createRunner(__dirname, 'scenario.ts')
-    .expect({
-      span: spanContainer => {
-        expect(spanContainer).toBeDefined();
-
-        const span1 = spanContainer.items.find(item => item.name === 'test_span_1');
-        const span2 = spanContainer.items.find(item => item.name === 'test_span_2');
-        expect(span1).toBeDefined();
-        expect(span2).toBeDefined();
-
-        // Both root spans continue the scope's propagation context, including the parentSpanId,
-        // matching the core SDK behavior.
-        expect(span1!.trace_id).toBe('12345678901234567890123456789012');
-        expect(span1!.parent_span_id).toBe('1234567890123456');
-
-        // Same trace ID for both spans
-        expect(span2!.trace_id).toBe(span1!.trace_id);
-      },
-    })
-    .start()
-    .completed();
-});
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId/scenario.ts
index a7c31adbe7bb..bcbf0b91c4ee 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId/scenario.ts
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId/test.ts
index 509c01a41689..d4881a73f348 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId/test.ts
@@ -7,20 +7,22 @@ afterAll(() => {
 
 test('should send manually started parallel root spans outside of root context with parentSpanId', async () => {
   await createRunner(__dirname, 'scenario.ts')
-    .expect({ transaction: { transaction: 'test_span_1' } })
     .expect({
-      transaction: transaction => {
-        expect(transaction).toBeDefined();
-        const traceId = transaction.contexts?.trace?.trace_id;
+      span: container => {
+        const span1 = container.items.find(span => span.name === 'test_span_1');
+        const span2 = container.items.find(span => span.name === 'test_span_2');
+        expect(span1?.is_segment).toBe(true);
+        expect(span2?.is_segment).toBe(true);
+        expect(span1?.start_timestamp).toEqual(expect.any(Number));
+        expect(span1?.end_timestamp).toEqual(expect.any(Number));
 
-        // Both root spans continue the scope's propagation context, including the parentSpanId,
-        // matching the core SDK behavior.
-        expect(traceId).toBe('12345678901234567890123456789012');
-        expect(transaction.contexts?.trace?.parent_span_id).toBe('1234567890123456');
+        // Both root spans continue the scope's propagation context, including the parentSpanId.
+        expect(span1?.trace_id).toBe('12345678901234567890123456789012');
+        expect(span1?.parent_span_id).toBe('1234567890123456');
+        expect(span2?.parent_span_id).toBe('1234567890123456');
 
-        // Same trace ID as the first span
-        const trace1Id = transaction.contexts?.trace?.data?.spanIdTraceId;
-        expect(trace1Id).toBe(traceId);
+        expect(span2?.trace_id).toBe(span1?.trace_id);
+        expect(span2?.attributes.spanIdTraceId).toEqual({ type: 'string', value: span1?.trace_id });
       },
     })
     .start()
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope/scenario.ts
index 39975bdd1c10..80b74d48601c 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope/scenario.ts
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope/test.ts
index 2d125160dbc4..7217eb1d3228 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope/test.ts
@@ -6,22 +6,22 @@ afterAll(() => {
 });
 
 test('should send manually started parallel root spans outside of root context', async () => {
-  expect.assertions(6);
-
   await createRunner(__dirname, 'scenario.ts')
-    .expect({ transaction: { transaction: 'test_span_1' } })
     .expect({
-      transaction: transaction => {
-        expect(transaction).toBeDefined();
-        const traceId = transaction.contexts?.trace?.trace_id;
-        expect(traceId).toBeDefined();
-        expect(transaction.contexts?.trace?.parent_span_id).toBeUndefined();
+      span: container => {
+        const span1 = container.items.find(span => span.name === 'test_span_1');
+        const span2 = container.items.find(span => span.name === 'test_span_2');
+        expect(span1?.is_segment).toBe(true);
+        expect(span2?.is_segment).toBe(true);
+        expect(span1?.start_timestamp).toEqual(expect.any(Number));
+        expect(span1?.end_timestamp).toEqual(expect.any(Number));
 
-        const trace1Id = transaction.contexts?.trace?.data?.spanIdTraceId;
-        expect(trace1Id).toBeDefined();
+        expect(span1?.trace_id).toMatch(/^[0-9a-f]{32}$/);
+        expect(span1?.parent_span_id).toBeUndefined();
+        expect(span2?.parent_span_id).toBeUndefined();
 
-        // Same trace ID as the first span - both root spans share the scope's propagation context
-        expect(trace1Id).toBe(traceId);
+        expect(span2?.trace_id).toBe(span1?.trace_id);
+        expect(span2?.attributes.spanIdTraceId).toEqual({ type: 'string', value: span1?.trace_id });
       },
     })
     .start()
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method-streamed/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method-streamed/scenario.ts
deleted file mode 100644
index 1d3485112fc3..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method-streamed/scenario.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { SENTRY_SEGMENT_NAME_SOURCE } from '@sentry/conventions/attributes';
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  traceLifecycle: 'stream',
-  transport: loggingTransport,
-});
-
-Sentry.startSpan({ name: 'test_span', attributes: { [SENTRY_SEGMENT_NAME_SOURCE]: 'url' } }, (span: Sentry.Span) => {
-  span.updateName('new name');
-});
-
-void Sentry.flush();
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method-streamed/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method-streamed/test.ts
deleted file mode 100644
index fb913fb24559..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method-streamed/test.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { SENTRY_SEGMENT_NAME_SOURCE } from '@sentry/conventions/attributes';
-import { afterAll, test } from 'vitest';
-import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
-
-afterAll(() => {
-  cleanupChildProcesses();
-});
-
-test('updates the span name when calling `span.updateName` (streamed)', async () => {
-  await createRunner(__dirname, 'scenario.ts')
-    .expect({
-      span: {
-        items: [
-          {
-            name: 'new name',
-            is_segment: true,
-            attributes: {
-              // `updateName` marks the name as explicitly chosen, so the source becomes `custom`,
-              // overriding the `url` source set at span start (a stale `url` no longer describes the name).
-              [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'custom' },
-            },
-          },
-        ],
-      },
-    })
-    .start()
-    .completed();
-});
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method/scenario.ts
index 803576fd46a7..5c04a121fe45 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method/scenario.ts
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method/test.ts
index 5db29cd032dc..b7f024ce98a5 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateName-method/test.ts
@@ -9,18 +9,22 @@ afterAll(() => {
 test('updates the span name when calling `span.updateName`', async () => {
   await createRunner(__dirname, 'scenario.ts')
     .expect({
-      transaction: {
-        transaction: 'new name',
-        // `updateName` marks the name as explicitly chosen, so the source becomes `custom`,
-        // overriding the `url` source set at span start (a stale `url` no longer describes the name).
-        transaction_info: { source: 'custom' },
-        contexts: {
-          trace: {
+      span: {
+        items: [
+          {
+            name: 'new name',
+            is_segment: true,
             span_id: expect.any(String),
             trace_id: expect.any(String),
-            data: { [SENTRY_SEGMENT_NAME_SOURCE]: 'custom' },
+            start_timestamp: expect.any(Number),
+            end_timestamp: expect.any(Number),
+            attributes: {
+              // `updateName` marks the name as explicitly chosen, so the source becomes `custom`,
+              // overriding the `url` source set at span start (a stale `url` no longer describes the name).
+              [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'custom' },
+            },
           },
-        },
+        ],
       },
     })
     .start()
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function-streamed/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function-streamed/scenario.ts
deleted file mode 100644
index cd85685fb5e6..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function-streamed/scenario.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { SENTRY_SEGMENT_NAME_SOURCE } from '@sentry/conventions/attributes';
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  traceLifecycle: 'stream',
-  transport: loggingTransport,
-});
-
-Sentry.startSpan({ name: 'test_span', attributes: { [SENTRY_SEGMENT_NAME_SOURCE]: 'url' } }, (span: Sentry.Span) => {
-  Sentry.updateSpanName(span, 'new name');
-});
-
-void Sentry.flush();
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function-streamed/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function-streamed/test.ts
deleted file mode 100644
index 7479790f0c25..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function-streamed/test.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { SENTRY_SEGMENT_NAME_SOURCE } from '@sentry/conventions/attributes';
-import { afterAll, test } from 'vitest';
-import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
-
-afterAll(() => {
-  cleanupChildProcesses();
-});
-
-test('updates the span name and source when calling `updateSpanName` (streamed)', async () => {
-  await createRunner(__dirname, 'scenario.ts')
-    .expect({
-      span: {
-        items: [
-          {
-            name: 'new name',
-            is_segment: true,
-            attributes: {
-              [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'custom' },
-            },
-          },
-        ],
-      },
-    })
-    .start()
-    .completed();
-});
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function/scenario.ts
index 21aa4865c4aa..30b2953a8625 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function/scenario.ts
@@ -3,7 +3,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function/test.ts
index 0c8ae9ef706b..95e380521e8c 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/updateSpanName-function/test.ts
@@ -9,16 +9,20 @@ afterAll(() => {
 test('updates the span name and source when calling `updateSpanName`', async () => {
   await createRunner(__dirname, 'scenario.ts')
     .expect({
-      transaction: {
-        transaction: 'new name',
-        transaction_info: { source: 'custom' },
-        contexts: {
-          trace: {
+      span: {
+        items: [
+          {
+            name: 'new name',
+            is_segment: true,
             span_id: expect.any(String),
             trace_id: expect.any(String),
-            data: { [SENTRY_SEGMENT_NAME_SOURCE]: 'custom' },
+            start_timestamp: expect.any(Number),
+            end_timestamp: expect.any(Number),
+            attributes: {
+              [SENTRY_SEGMENT_NAME_SOURCE]: { type: 'string', value: 'custom' },
+            },
           },
-        },
+        ],
       },
     })
     .start()

From f7bc9a454f456cf2772ba830aa0e0a62e3d856ad Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 9 Oct 2026 16:26:31 +0000
Subject: [PATCH 41/84] chore(deps): Bump next from 16.2.11 to 16.3.8 in
 /dev-packages/e2e-tests/test-applications/nextjs-16-tunnel (#25190)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [next](https://github.com/vercel/next.js) from 16.2.11 to 16.3.8.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a
href="https://github.com/vercel/next.js/releases">next's
releases</a>.</em></p>
<blockquote>
<h2>v16.3.8</h2>
<p>This release contains security fixes for the following
advisories:</p>
<p>High:</p>
<ul>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-cjq9-62q9-8jv4">Server-Side
Request Forgery in Image Optimization</a></li>
</ul>
<p>Medium:</p>
<ul>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-f87g-xv8r-7p7x">Information
disclosure in Next.js App Router metadata image routes via dynamicParams
bypass</a></li>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-4jqv-mc3x-m676">Cache
poisoning of SSG and ISR pages in self-hosted Next.js
applications</a></li>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-mcj8-r9mp-w47p">Cache
poisoning in Next.js SSG/ISR rendering leads to cross-user content
substitution and persistent denial of service</a></li>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-3w37-wq28-93x7">Pending
<code>use cache</code> fill can leak Draft Mode content into regular
responses and persisted pages</a></li>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-h694-7cp9-m8p3">Cache
leak across root param values in nested 'use cache' functions</a></li>
</ul>
<p>Low:</p>
<ul>
<li><a
href="https://github.com/vercel/next.js/security/advisories/GHSA-39w2-rjm5-chcv">Information
disclosure in the Next.js development server's Model Context Protocol
endpoint</a></li>
</ul>
<h2>v16.3.7</h2>
<blockquote>
<p>[!NOTE]
This release is backporting bug fixes. It does <strong>not</strong>
include all pending features/changes on canary.</p>
</blockquote>
<h3>Core Changes</h3>
<ul>
<li>turbo-tasks-backend: fix strongly consistent read hanging on a
canceled task (<a
href="https://redirect.github.com/vercel/next.js/issues/98931">#98931</a>)</li>
</ul>
<h3>Credits</h3>
<p>Huge thanks to <a
href="https://github.com/lukesandberg"><code>@​lukesandberg</code></a>
for helping!</p>
<h2>v16.3.6</h2>
<p>This release contains a security fix for <a
href="https://github.com/vercel/next.js/security/advisories/GHSA-vcvr-r3jv-pc5j">GHSA-vcvr-r3jv-pc5j:
Remote Code Execution in next/og ImageResponse</a></p>
<h2>v16.3.5</h2>
<p>The following bug fixes have been backported. It does not include all
pending features/changes on canary.</p>
<ul>
<li>next/image: Skip 0-byte entries when initializing disk LRU cache (<a
href="https://redirect.github.com/vercel/next.js/issues/98185">#98185</a>)</li>
<li>next/image: Reject empty images when reading/writing to the disk
cache (<a
href="https://redirect.github.com/vercel/next.js/issues/98186">#98186</a>)</li>
<li>Emit whole-app server NFTs when <code>output: 'standalone'</code> is
used with an adapter (<a
href="https://redirect.github.com/vercel/next.js/issues/98167">#98167</a>)</li>
<li>Add CSP nonce to script tags of loading and template files (<a
href="https://redirect.github.com/vercel/next.js/issues/98403">#98403</a>)</li>
<li>Fix <code>use cache</code> prerender signal retention (<a
href="https://redirect.github.com/vercel/next.js/issues/98448">#98448</a>)</li>
</ul>
<h2>v16.3.4</h2>
<p>Follow-up release to <a
href="https://github.com/vercel/next.js/releases/tag/v16.3.3">v16.3.3</a>
re-enabling AVIF Image Optimization (<a
href="https://redirect.github.com/vercel/next.js/pull/97949">#97949</a>).</p>
<p>The following bug fixes have been backported. It does
<strong>not</strong> include all pending features/changes on canary.</p>
<ul>
<li>testmode: Fix infinite recursion in testmode passthrough fetch (<a
href="https://redirect.github.com/vercel/next.js/issues/97691">#97691</a>)</li>
<li>Fix build error when aliasing typescript to
<code>@​typescript/typescript6</code> (<a
href="https://redirect.github.com/vercel/next.js/issues/97997">#97997</a>)</li>
<li>Fix unset crossOrigin in Turbopack manifests (<a
href="https://redirect.github.com/vercel/next.js/issues/97930">#97930</a>)</li>
</ul>
<h3>Credits</h3>
<!-- raw HTML omitted -->
</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/vercel/next.js/commit/b0fad0d45eb4c4430fda5eeeb442e8a5af08a5f6"><code>b0fad0d</code></a>
v16.3.8</li>
<li><a
href="https://github.com/vercel/next.js/commit/719e4c67d6e92df60246f95e1d96e2dd60789a52"><code>719e4c6</code></a>
[lts-active] Scope response cache keys to their source route (<a
href="https://redirect.github.com/vercel/next.js/issues/218">#218</a>)</li>
<li><a
href="https://github.com/vercel/next.js/commit/e92db4536a7f34ae2dbda583cfa1b4e0d06d1865"><code>e92db45</code></a>
[lts-active] Fix metadata propagation for deduplicated nested caches (<a
href="https://redirect.github.com/vercel/next.js/issues/223">#223</a>)</li>
<li><a
href="https://github.com/vercel/next.js/commit/40c2ba904289a65ed2fd4633c5dfb1bdc29b52de"><code>40c2ba9</code></a>
[lts-active] Match Next data paths case-sensitively (<a
href="https://redirect.github.com/vercel/next.js/issues/196">#196</a>)</li>
<li><a
href="https://github.com/vercel/next.js/commit/2d9f50a409312696145b82b3157aadb6b1fef476"><code>2d9f50a</code></a>
[lts-active] Fix MCP middleware DNS rebinding (<a
href="https://redirect.github.com/vercel/next.js/issues/213">#213</a>)</li>
<li><a
href="https://github.com/vercel/next.js/commit/bd9214f9a32854a011bf5fe58e481dffe1bbf598"><code>bd9214f</code></a>
[lts-active] Fix draft mode leaks through cross-request <code>'use
cache'</code> dedupli...</li>
<li><a
href="https://github.com/vercel/next.js/commit/8db4a627c91e718514406ff5644ea4985dcaaae0"><code>8db4a62</code></a>
[lts-active][webpack] Ensure <code>dynamicParams</code> is respected in
`opengraph-image...</li>
<li><a
href="https://github.com/vercel/next.js/commit/e002ad68bd676bb0ed0c87bb22e3590304763e0b"><code>e002ad6</code></a>
[lts-active] fix(next/image): Pin DNS resolution when fetching external
image...</li>
<li><a
href="https://github.com/vercel/next.js/commit/4c20699e29178d444994cf5a31b8a617ca3a2c80"><code>4c20699</code></a>
v16.3.7</li>
<li><a
href="https://github.com/vercel/next.js/commit/2521aec5815e7de2121db253d12dae9f13e25361"><code>2521aec</code></a>
[backport] turbo-tasks-backend: fix strongly consistent read hanging on
a can...</li>
<li>Additional commits viewable in <a
href="https://github.com/vercel/next.js/compare/v16.2.11...v16.3.8">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=next&package-manager=npm_and_yarn&previous-version=16.2.11&new-version=16.3.8)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the
[Security Alerts
page](https://github.com/getsentry/sentry-javascript/network/alerts).

</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../e2e-tests/test-applications/nextjs-16-tunnel/package.json   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16-tunnel/package.json b/dev-packages/e2e-tests/test-applications/nextjs-16-tunnel/package.json
index cf2556fbff27..a532785bd351 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16-tunnel/package.json
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16-tunnel/package.json
@@ -27,7 +27,7 @@
     "@sentry/core": "file:../../packed/sentry-core-packed.tgz",
     "ai": "^3.0.0",
     "import-in-the-middle": "^1",
-    "next": "16.2.11",
+    "next": "16.3.8",
     "react": "19.1.0",
     "react-dom": "19.1.0",
     "require-in-the-middle": "^7",

From 3ed6fdadeca77406cd2d7317e3295424819f5d6a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 9 Oct 2026 19:46:35 +0200
Subject: [PATCH 42/84] feat(deps): Bump @aws-sdk/client-kinesis from 3.1068.0
 to 3.1146.0 (#25240)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps
[@aws-sdk/client-kinesis](https://github.com/aws/aws-sdk-js-v3/tree/HEAD/clients/client-kinesis)
from 3.1068.0 to 3.1146.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a
href="https://github.com/aws/aws-sdk-js-v3/releases">@​aws-sdk/client-kinesis's
releases</a>.</em></p>
<blockquote>
<h2>v3.1146.0</h2>
<h4>3.1146.0(2026-10-02)</h4>
<h5>Documentation Changes</h5>
<ul>
<li><strong>client-lambda-web:</strong> Documentation update for AWS
Lambda Web Functions, clarifies that the LambdaWeb APIs are experimental
and not yet available to external customers. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/de11d1e19ac647382c35d04c9adc706db43104f9">de11d1e1</a>)</li>
</ul>
<h5>New Features</h5>
<ul>
<li><strong>client-mediapackagev2:</strong> Dynamic Multiview enables
viewers to watch multiple live video streams in a single combined
output. Static filter configuration allows users to configure endpoints
with layouts and sources without using query parameters. The number of
sources per multiview channel has been increased to 50. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/8a1ac09ce8953bad912b4b6142b33d5419e856ac">8a1ac09c</a>)</li>
<li><strong>client-invoicing:</strong> API and doc updates related to
adding MarketplacePunchOutEnabled and MarketplacePunchOutPreference
fields to ProcurementPortalPreferences related APIs (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/948be4b558efb92f398c77203737dde32adde801">948be4b5</a>)</li>
<li><strong>client-glue:</strong> Added refresh token grant type to Glue
Connection supported OAuth 2.0 grant types (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/6101fef043d32d50593ff9de58d9a424e055a679">6101fef0</a>)</li>
<li><strong>client-cognito-identity-provider:</strong> Amazon Cognito
User Pools now supports the OIDC-standard authentication context class
reference (ACR) and authentication methods reference (AMR) claims on
issued access and Id tokens. Amazon Cognito User Pools also now supports
step-up authentication via our existing authentication APIs. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/196e191fb2da07ee24d7f64c67c8ad6e949b801d">196e191f</a>)</li>
<li><strong>client-pinpoint-sms-voice-v2:</strong> AWS End User
Messaging SMS CarrierLookup API now supports phone number cleansing on
customer opt-in. when selected, the response includes the additional
field &quot;OriginalPhoneNumber&quot;. It can also return additional
PhoneNumberType enums, VOIP and PREPAID. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/42d43613a4cf6b164fe206389d74f93579b8cff9">42d43613</a>)</li>
<li><strong>client-securityagent:</strong> Adds trigger filters that
control which pull request events, target branches, and labels start an
automatic code review. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/3d73df94ceaa545b3039dfaadf87bec1dc79eabe">3d73df94</a>)</li>
</ul>
<hr />
<p>For list of updated packages, view
<strong>updated-packages.md</strong> in
<strong>assets-3.1146.0.zip</strong></p>
<h2>v3.1145.0</h2>
<h4>3.1145.0(2026-10-01)</h4>
<h5>Chores</h5>
<ul>
<li>update lock-threads workflow (<a
href="https://redirect.github.com/aws/aws-sdk-js-v3/pull/8327">#8327</a>)
(<a
href="https://github.com/aws/aws-sdk-js-v3/commit/5daff5f2a46619fc7ce5a7b0973cf7b59280a27a">5daff5f2</a>)</li>
</ul>
<h5>Documentation Changes</h5>
<ul>
<li><strong>client-ec2:</strong> This release launches the AMI tag
sharing feature, which lets AMI owners share tags alongside their AMIs,
eliminating the need to build and maintain custom tag replication
workflows. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/82608f8c3bc37b277a37ed95d3528fb2c1289803">82608f8c</a>)</li>
</ul>
<h5>New Features</h5>
<ul>
<li><strong>clients:</strong> update client endpoints as of 2026-10-01
(<a
href="https://github.com/aws/aws-sdk-js-v3/commit/5244c2a9be26ccffb1a29e1b3c9863b01e80dc7c">5244c2a9</a>)</li>
<li><strong>client-bedrock-agent:</strong> Adds an optional textReadyAt
field to ListIngestionJobs and GetIngestionJob for Managed Knowledge
Bases data source sync jobs. The field denotes the timestamp at which
all the documents in the scope of a sync job had their text content
indexed and are available for retrieval. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/a810c753836b472ed51cc5224ba220364e36dc30">a810c753</a>)</li>
<li><strong>client-lambda-web:</strong> Lambda Web Functions GA launch.
Lambda Web Functions enable customers to run web applications and API
backends (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/ed0d05402ac62f61b2a97e90108e1723aa6a1d03">ed0d0540</a>)</li>
<li><strong>client-quicksight:</strong> This release adds
HierarchyFilter support for Amazon QuickSight analysis and dashboard and
2 legged OAuth for databricks datasources. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/a1730e330f03d9fb60a1ea098f46a0e5b2d21c84">a1730e33</a>)</li>
<li><strong>client-endusermessaging:</strong> AWS End User Messaging now
supports Brand profiles and Notify code configurations. Brand profiles
capture your sender details once to reuse across phone number
registrations. Notify code configurations let you define your OTP policy
and delivery settings to send passcodes in minutes. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/3e5402c695d41a43eaa30cfc13c7d4b27d8efa4c">3e5402c6</a>)</li>
<li><strong>client-transfer:</strong> AWS Transfer Family Workflows adds
support for the structuredLogDestinations option, enabling customers to
specify a custom Amazon CloudWatch Logs log group for managed workflow
execution logs. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/db1f83302598dc19149b0492228d3abc85e76ab2">db1f8330</a>)</li>
<li><strong>client-health:</strong> Adds DescribeServiceLifecycle
operation returning lifecycle information for AWS services, including
end-of-support dates, version recommendations, and lifecycle events. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/db93c01618907b6cc3617b9e12606047f17a7b86">db93c016</a>)</li>
<li><strong>client-cloudfront:</strong> Added always-amz-auth as a
supported signing behavior for Origin Access Control (OAC), enabling
CloudFront to authenticate requests to Lambda-Web origins. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/e24eb7cf0f69c58144d41d75e9df3fcb6ef7c3ea">e24eb7cf</a>)</li>
<li><strong>client-sagemaker:</strong> Release support for c8a.16xlarge
and m8a.16xlarge instance types for SageMaker HyperPod (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/cfa700a6774b764d1580e22bdd89e18e34564037">cfa700a6</a>)</li>
<li><strong>client-securityhub:</strong> Adds GetRemediationsV2 and
ListExposuresByRemediationV2 APIs. This feature allows customers to see
their highest priority remediations for their Exposure findings.
Remediations target key changes customers can make to resources to drive
finding resolution. (<a
href="https://github.com/aws/aws-sdk-js-v3/commit/fe355577b21c180540c45327ba3e9ac9961b5871">fe355577</a>)</li>
</ul>
<h5>Bug Fixes</h5>
<ul>
<li><strong>lib-transfer-manager:</strong> respect file read stream's
byte range on upload (<a
href="https://redirect.github.com/aws/aws-sdk-js-v3/pull/8324">#8324</a>)
(<a
href="https://github.com/aws/aws-sdk-js-v3/commit/449c2814f04220f665f3c939f0c92b064986ac57">449c2814</a>)</li>
<li><strong>ci:</strong> run format-check when a draft PR is marked
ready for review (<a
href="https://redirect.github.com/aws/aws-sdk-js-v3/pull/8326">#8326</a>)
(<a
href="https://github.com/aws/aws-sdk-js-v3/commit/d99dd58e57a5fd50ce20047fcb255dfdabb6c973">d99dd58e</a>)</li>
</ul>
<!-- raw HTML omitted -->
</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a
href="https://github.com/aws/aws-sdk-js-v3/blob/main/clients/client-kinesis/CHANGELOG.md">@​aws-sdk/client-kinesis's
changelog</a>.</em></p>
<blockquote>
<h1><a
href="https://github.com/aws/aws-sdk-js-v3/compare/v3.1145.0...v3.1146.0">3.1146.0</a>
(2026-10-02)</h1>
<p><strong>Note:</strong> Version bump only for package
<code>@​aws-sdk/client-kinesis</code></p>
<h1><a
href="https://github.com/aws/aws-sdk-js-v3/compare/v3.1144.0...v3.1145.0">3.1145.0</a>
(2026-10-01)</h1>
<p><strong>Note:</strong> Version bump only for package
<code>@​aws-sdk/client-kinesis</code></p>
<h1><a
href="https://github.com/aws/aws-sdk-js-v3/compare/v3.1143.0...v3.1144.0">3.1144.0</a>
(2026-09-30)</h1>
<p><strong>Note:</strong> Version bump only for package
<code>@​aws-sdk/client-kinesis</code></p>
<h1><a
href="https://github.com/aws/aws-sdk-js-v3/compare/v3.1142.0...v3.1143.0">3.1143.0</a>
(2026-09-29)</h1>
<p><strong>Note:</strong> Version bump only for package
<code>@​aws-sdk/client-kinesis</code></p>
<h1><a
href="https://github.com/aws/aws-sdk-js-v3/compare/v3.1141.0...v3.1142.0">3.1142.0</a>
(2026-09-28)</h1>
<p><strong>Note:</strong> Version bump only for package
<code>@​aws-sdk/client-kinesis</code></p>
<h1><a
href="https://github.com/aws/aws-sdk-js-v3/compare/v3.1140.0...v3.1141.0">3.1141.0</a>
(2026-09-25)</h1>
<p><strong>Note:</strong> Version bump only for package
<code>@​aws-sdk/client-kinesis</code></p>
<h1><a
href="https://github.com/aws/aws-sdk-js-v3/compare/v3.1139.0...v3.1140.0">3.1140.0</a>
(2026-09-24)</h1>
<!-- raw HTML omitted -->
</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/aws/aws-sdk-js-v3/commit/054298b1520fc45a7017966674a5ac3aa6f32a04"><code>054298b</code></a>
Publish v3.1146.0</li>
<li><a
href="https://github.com/aws/aws-sdk-js-v3/commit/0199117830b689aa169a0e4c472484cde9c129cd"><code>0199117</code></a>
Publish v3.1145.0</li>
<li><a
href="https://github.com/aws/aws-sdk-js-v3/commit/ce262812f5156daee0c2070854970e504b7cd15c"><code>ce26281</code></a>
Publish v3.1144.0</li>
<li><a
href="https://github.com/aws/aws-sdk-js-v3/commit/81afad00ca9394ca4d767468216743ac3ba90fb1"><code>81afad0</code></a>
Publish v3.1143.0</li>
<li><a
href="https://github.com/aws/aws-sdk-js-v3/commit/c935fdd2bc9b36c689ef8e17b75c57bf9a780990"><code>c935fdd</code></a>
Publish v3.1142.0</li>
<li><a
href="https://github.com/aws/aws-sdk-js-v3/commit/5bc8d9a96936723ac90d721e0c5a2bff7ee8520d"><code>5bc8d9a</code></a>
Publish v3.1141.0</li>
<li><a
href="https://github.com/aws/aws-sdk-js-v3/commit/6050a3813c26795562b5ada8b0d9ea498eb9f8a1"><code>6050a38</code></a>
Publish v3.1140.0</li>
<li><a
href="https://github.com/aws/aws-sdk-js-v3/commit/03d54a858f80012bbc60046a77242223e8dfd9d9"><code>03d54a8</code></a>
Publish v3.1139.0</li>
<li><a
href="https://github.com/aws/aws-sdk-js-v3/commit/c556a9e4ed257dceac78b2deb44667f5fce88dd9"><code>c556a9e</code></a>
feat(client-kinesis): Amazon Kinesis Data Streams now supports service
manage...</li>
<li><a
href="https://github.com/aws/aws-sdk-js-v3/commit/c68e50e4a6e0469a20c2894fe8a29c140553ebb8"><code>c68e50e</code></a>
Publish v3.1138.0</li>
<li>Additional commits viewable in <a
href="https://github.com/aws/aws-sdk-js-v3/commits/v3.1146.0/clients/client-kinesis">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=@aws-sdk/client-kinesis&package-manager=npm_and_yarn&previous-version=3.1068.0&new-version=3.1146.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Andrei Borza <andrei.borza@sentry.io>
Co-authored-by: Andrei <168741329+andreiborza@users.noreply.github.com>
---
 .../node-integration-tests/package.json       |   2 +-
 yarn.lock                                     | 391 +++++++++---------
 2 files changed, 196 insertions(+), 197 deletions(-)

diff --git a/dev-packages/node-integration-tests/package.json b/dev-packages/node-integration-tests/package.json
index d5d4dd9d8f83..2495dcc2c794 100644
--- a/dev-packages/node-integration-tests/package.json
+++ b/dev-packages/node-integration-tests/package.json
@@ -28,7 +28,7 @@
     "@anthropic-ai/sdk": "0.63.0",
     "@apollo/server": "^5.5.0",
     "@aws-sdk/client-dynamodb": "^3.1046.0",
-    "@aws-sdk/client-kinesis": "^3.1046.0",
+    "@aws-sdk/client-kinesis": "^3.1146.0",
     "@aws-sdk/client-lambda": "^3.1046.0",
     "@aws-sdk/client-s3": "^3.1046.0",
     "@aws-sdk/client-secrets-manager": "^3.1046.0",
diff --git a/yarn.lock b/yarn.lock
index d7ba446cb178..a93dfb60ddd6 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -837,20 +837,18 @@
     "@smithy/types" "^4.14.3"
     tslib "^2.6.2"
 
-"@aws-sdk/client-kinesis@^3.1046.0":
-  version "3.1068.0"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/client-kinesis/-/client-kinesis-3.1068.0.tgz#fd66246383415956283dd885e85f91641b0e9c2e"
-  integrity sha512-0+5P4CJFf/K5/EBxzRR97OLeQqe3GazyCjV47/ksyTnfr+Bif2UhvZ2Kq6c+s/dqie6LPP4NFAB5Q8D/TZ3+og==
-  dependencies:
-    "@aws-crypto/sha256-browser" "5.2.0"
-    "@aws-crypto/sha256-js" "5.2.0"
-    "@aws-sdk/core" "^3.974.20"
-    "@aws-sdk/credential-provider-node" "^3.972.55"
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/core" "^3.24.6"
-    "@smithy/fetch-http-handler" "^5.4.6"
-    "@smithy/node-http-handler" "^4.7.6"
-    "@smithy/types" "^4.14.3"
+"@aws-sdk/client-kinesis@^3.1146.0":
+  version "3.1146.0"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/client-kinesis/-/client-kinesis-3.1146.0.tgz#f53ad0327f70d8c2c777febe3d2f050d3cc57faa"
+  integrity sha512-/WpJG6dIJHKXxqoCNA79SFcbxZCeQ5AVOkVkdzwV1LJDWo/23HFtprUVNldYa50JmqVPkVGO58muAt8jSFN+wA==
+  dependencies:
+    "@aws-sdk/core" "^3.978.1"
+    "@aws-sdk/credential-provider-node" "^3.972.84"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/core" "^3.35.0"
+    "@smithy/fetch-http-handler" "^5.8.0"
+    "@smithy/node-http-handler" "^4.12.1"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
 "@aws-sdk/client-lambda@^3.1046.0":
@@ -954,17 +952,17 @@
     "@smithy/types" "^4.14.3"
     tslib "^2.6.2"
 
-"@aws-sdk/core@^3.973.5", "@aws-sdk/core@^3.973.6", "@aws-sdk/core@^3.974.20", "@aws-sdk/core@^3.974.8":
-  version "3.974.20"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/core/-/core-3.974.20.tgz#fc9727897662e148fad2276995298f56b587c3ab"
-  integrity sha512-7sDi2B2N3mc3nf1nz6FyEx/FCrJ1N1QnBmraHHQNabFaeAh2IaOOLml48/rHOD1bICHgTRkbBgNTvUzEr5Z35g==
-  dependencies:
-    "@aws-sdk/types" "^3.973.12"
-    "@aws-sdk/xml-builder" "^3.972.29"
-    "@aws/lambda-invoke-store" "^0.2.2"
-    "@smithy/core" "^3.24.6"
-    "@smithy/signature-v4" "^5.4.6"
-    "@smithy/types" "^4.14.3"
+"@aws-sdk/core@^3.973.5", "@aws-sdk/core@^3.973.6", "@aws-sdk/core@^3.974.20", "@aws-sdk/core@^3.974.8", "@aws-sdk/core@^3.978.1":
+  version "3.978.1"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/core/-/core-3.978.1.tgz#1e4db18f9c450e0aba550edfee4c6897e09af879"
+  integrity sha512-LbY9aGsEiznDWmUc30Nwv3aIX/+dbwTx8KfS0yOC3NPYMO+O91e6jkT1azf34FwjOndq8/Q+RcVVZz5xnerwdg==
+  dependencies:
+    "@aws-sdk/types" "^3.974.6"
+    "@aws-sdk/xml-builder" "^3.972.41"
+    "@aws/lambda-invoke-store" "^0.3.0"
+    "@smithy/core" "^3.35.0"
+    "@smithy/signature-v4" "^5.7.3"
+    "@smithy/types" "^4.19.0"
     bowser "^2.11.0"
     tslib "^2.6.2"
 
@@ -979,112 +977,112 @@
     "@smithy/types" "^4.12.0"
     tslib "^2.6.2"
 
-"@aws-sdk/credential-provider-env@^3.972.4", "@aws-sdk/credential-provider-env@^3.972.46":
-  version "3.972.46"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-env/-/credential-provider-env-3.972.46.tgz#590695585036566535b9d9f28d90658a725a123b"
-  integrity sha512-+GPXVS2srMOlH74S+SmC1gVuP2TvUZ0siuC0onKO93q+udP+M72dmY8wJfVQ5CX9z/9X5A1HHwz5yRIGBtskvQ==
+"@aws-sdk/credential-provider-env@^3.972.4", "@aws-sdk/credential-provider-env@^3.972.72":
+  version "3.972.72"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-env/-/credential-provider-env-3.972.72.tgz#5bf3c87784901426716dad12f2036b87ce2d9793"
+  integrity sha512-xTKO/FWJPozTIXbozVnVGoNBhaGba8TBcx+KyUjRVeOlXE+dUc7GTR1cLvu0uTdIdmemzaFbqqCshXeZA1fZew==
   dependencies:
-    "@aws-sdk/core" "^3.974.20"
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/core" "^3.24.6"
-    "@smithy/types" "^4.14.3"
+    "@aws-sdk/core" "^3.978.1"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/core" "^3.35.0"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
-"@aws-sdk/credential-provider-http@^3.972.48", "@aws-sdk/credential-provider-http@^3.972.6":
-  version "3.972.48"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-http/-/credential-provider-http-3.972.48.tgz#074fe92aa255f0c42441955da6cfeb2bbc57a263"
-  integrity sha512-fA5loSdlocacRxyUXtpoHSMuk5rsIKRDzQYVMnMxjcmFeZshaJlJ8lymy/hYKji6sne/UmNGj5pxuEs6kq/Qcg==
-  dependencies:
-    "@aws-sdk/core" "^3.974.20"
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/core" "^3.24.6"
-    "@smithy/fetch-http-handler" "^5.4.6"
-    "@smithy/node-http-handler" "^4.7.6"
-    "@smithy/types" "^4.14.3"
+"@aws-sdk/credential-provider-http@^3.972.6", "@aws-sdk/credential-provider-http@^3.972.74":
+  version "3.972.74"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-http/-/credential-provider-http-3.972.74.tgz#15b366f17177ac07a7b463662e02f2ead1fcfa67"
+  integrity sha512-u91E/hT8f4d1xy0Jl7VG4nVKJ3lxbrZkoBTeSVoJdWBiSEUMwMS/9+e0H/aJVQV//Lt5wuzP+E69v4aRSsNTmw==
+  dependencies:
+    "@aws-sdk/core" "^3.978.1"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/core" "^3.35.0"
+    "@smithy/fetch-http-handler" "^5.8.0"
+    "@smithy/node-http-handler" "^4.12.1"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
-"@aws-sdk/credential-provider-ini@^3.972.4", "@aws-sdk/credential-provider-ini@^3.972.53":
-  version "3.972.53"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-ini/-/credential-provider-ini-3.972.53.tgz#d17c2ebfab9c3a38c45f857567535bf4dd9290a0"
-  integrity sha512-ZfdhIOR41q8TcWEnUac+gCOb+O2LBWdHLmjedXpXz4IEFW2ppNuFcm6p0sMTavpM+zD5TYfpH5Gp7guRyqSgsQ==
-  dependencies:
-    "@aws-sdk/core" "^3.974.20"
-    "@aws-sdk/credential-provider-env" "^3.972.46"
-    "@aws-sdk/credential-provider-http" "^3.972.48"
-    "@aws-sdk/credential-provider-login" "^3.972.52"
-    "@aws-sdk/credential-provider-process" "^3.972.46"
-    "@aws-sdk/credential-provider-sso" "^3.972.52"
-    "@aws-sdk/credential-provider-web-identity" "^3.972.52"
-    "@aws-sdk/nested-clients" "^3.997.20"
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/core" "^3.24.6"
-    "@smithy/credential-provider-imds" "^4.3.7"
-    "@smithy/types" "^4.14.3"
+"@aws-sdk/credential-provider-ini@^3.972.4", "@aws-sdk/credential-provider-ini@^3.973.17":
+  version "3.973.17"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-ini/-/credential-provider-ini-3.973.17.tgz#4f4b329cb3252322dc2261fe2985c45eeefbcd22"
+  integrity sha512-ged4KXdBkvIC81bLvNHHuQKdKak/VXhQTR1NWYTTqW0474nlmsxy9O/vlgTIohDDWH3xpBdtVMZRyjb+DnocDA==
+  dependencies:
+    "@aws-sdk/core" "^3.978.1"
+    "@aws-sdk/credential-provider-env" "^3.972.72"
+    "@aws-sdk/credential-provider-http" "^3.972.74"
+    "@aws-sdk/credential-provider-login" "^3.972.79"
+    "@aws-sdk/credential-provider-process" "^3.972.72"
+    "@aws-sdk/credential-provider-sso" "^3.973.16"
+    "@aws-sdk/credential-provider-web-identity" "^3.972.78"
+    "@aws-sdk/nested-clients" "^3.997.46"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/core" "^3.35.0"
+    "@smithy/credential-provider-imds" "^4.5.2"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
-"@aws-sdk/credential-provider-login@^3.972.4", "@aws-sdk/credential-provider-login@^3.972.52":
-  version "3.972.52"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-login/-/credential-provider-login-3.972.52.tgz#43f2db767db000a1c5317ba35ecd2124cb0a883e"
-  integrity sha512-9hu2oR0qH7Fst5Tzdx+UWxm+w5zCXtErTLtOOW5hwwQc170CLwOeniRxyFY6s9mHfGEfC5zFukNBdKBwJR8mhQ==
+"@aws-sdk/credential-provider-login@^3.972.4", "@aws-sdk/credential-provider-login@^3.972.79":
+  version "3.972.79"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-login/-/credential-provider-login-3.972.79.tgz#7b7b75f051e0cb79958a0d2e894f26660e65ad0f"
+  integrity sha512-L+Z85anONJd8MaiuraO4wRxATCdEejBZ3K3eymzWI5JPXa9sOS9CkIm72PBKqXKX+Z9p9NGMX5AIMXm0LEflgw==
   dependencies:
-    "@aws-sdk/core" "^3.974.20"
-    "@aws-sdk/nested-clients" "^3.997.20"
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/core" "^3.24.6"
-    "@smithy/types" "^4.14.3"
+    "@aws-sdk/core" "^3.978.1"
+    "@aws-sdk/nested-clients" "^3.997.46"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/core" "^3.35.0"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
-"@aws-sdk/credential-provider-node@^3.972.4", "@aws-sdk/credential-provider-node@^3.972.5", "@aws-sdk/credential-provider-node@^3.972.55":
-  version "3.972.55"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-node/-/credential-provider-node-3.972.55.tgz#117eaec668dde8e3366bdb750d4c5c247a59a31f"
-  integrity sha512-zMGLa/dhESVqmCD7mmIFFKSwSFrJGScvCXcjvBZEVOOMauFS5JRQvLTMukFpMEFWiV6dTAlsen2ATDBulLPtbg==
-  dependencies:
-    "@aws-sdk/credential-provider-env" "^3.972.46"
-    "@aws-sdk/credential-provider-http" "^3.972.48"
-    "@aws-sdk/credential-provider-ini" "^3.972.53"
-    "@aws-sdk/credential-provider-process" "^3.972.46"
-    "@aws-sdk/credential-provider-sso" "^3.972.52"
-    "@aws-sdk/credential-provider-web-identity" "^3.972.52"
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/core" "^3.24.6"
-    "@smithy/credential-provider-imds" "^4.3.7"
-    "@smithy/types" "^4.14.3"
+"@aws-sdk/credential-provider-node@^3.972.4", "@aws-sdk/credential-provider-node@^3.972.5", "@aws-sdk/credential-provider-node@^3.972.55", "@aws-sdk/credential-provider-node@^3.972.84":
+  version "3.972.84"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-node/-/credential-provider-node-3.972.84.tgz#226bc8d9110d0562dc895e609ec54b4bc8f68155"
+  integrity sha512-oHt854odINVwzwsh+c5x69j0ajm4DbqqqVJ+O1ECsCIZeMDAbzFpXItaqP7UZstJj/ATdTk/KFSH0LaNAgV+kA==
+  dependencies:
+    "@aws-sdk/credential-provider-env" "^3.972.72"
+    "@aws-sdk/credential-provider-http" "^3.972.74"
+    "@aws-sdk/credential-provider-ini" "^3.973.17"
+    "@aws-sdk/credential-provider-process" "^3.972.72"
+    "@aws-sdk/credential-provider-sso" "^3.973.16"
+    "@aws-sdk/credential-provider-web-identity" "^3.972.78"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/core" "^3.35.0"
+    "@smithy/credential-provider-imds" "^4.5.2"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
-"@aws-sdk/credential-provider-process@^3.972.4", "@aws-sdk/credential-provider-process@^3.972.46":
-  version "3.972.46"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-process/-/credential-provider-process-3.972.46.tgz#b8d967fa7ea65bdb51a0d60609b3947f01ad1390"
-  integrity sha512-VUoNFBIjWrUN8NbFiQiuxQEgFjvziAlBRPK+ddh27aj65gk0BYu6bLZnrdrNZwpW6vAihtSUtEMQ1PUJ32QRPA==
+"@aws-sdk/credential-provider-process@^3.972.4", "@aws-sdk/credential-provider-process@^3.972.72":
+  version "3.972.72"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-process/-/credential-provider-process-3.972.72.tgz#c4efac7cf0582351c98ab16675d8d6944b6df000"
+  integrity sha512-rLIp2xbMjX/k9/od7APpqq1ZgXXnV0pOL1Th3ZsL8Wu0TRtBsDTVS8iPqcfRFcHakFxPvR04OSTv2ka2qOb/2A==
   dependencies:
-    "@aws-sdk/core" "^3.974.20"
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/core" "^3.24.6"
-    "@smithy/types" "^4.14.3"
+    "@aws-sdk/core" "^3.978.1"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/core" "^3.35.0"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
-"@aws-sdk/credential-provider-sso@^3.972.4", "@aws-sdk/credential-provider-sso@^3.972.52":
-  version "3.972.52"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-sso/-/credential-provider-sso-3.972.52.tgz#d3f43251c0a02378d9278508385f511dcc105fb8"
-  integrity sha512-nb2/n4o/HQf+FVpVbZe9vCTFngmuDoIsltMgLAtjixaKzvzhB4J8WSDFyWgnErgLHk55ctWH+I4PU+LIHhyffg==
-  dependencies:
-    "@aws-sdk/core" "^3.974.20"
-    "@aws-sdk/nested-clients" "^3.997.20"
-    "@aws-sdk/token-providers" "3.1066.0"
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/core" "^3.24.6"
-    "@smithy/types" "^4.14.3"
+"@aws-sdk/credential-provider-sso@^3.972.4", "@aws-sdk/credential-provider-sso@^3.973.16":
+  version "3.973.16"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-sso/-/credential-provider-sso-3.973.16.tgz#bdaf55e64c96df4308fd1fdabbdc13136b58c144"
+  integrity sha512-IGihaJfFZYacJJr/odqILCoK7W/mvrZ7cuK7ECn3sAu4vLC6u0V8bS7mCGbdugJ8Aum2tnvqmx0F2MRFp2rn9g==
+  dependencies:
+    "@aws-sdk/core" "^3.978.1"
+    "@aws-sdk/nested-clients" "^3.997.46"
+    "@aws-sdk/token-providers" "3.1138.0"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/core" "^3.35.0"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
-"@aws-sdk/credential-provider-web-identity@^3.972.4", "@aws-sdk/credential-provider-web-identity@^3.972.52":
-  version "3.972.52"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-web-identity/-/credential-provider-web-identity-3.972.52.tgz#28201a0e787f83aac75b80922d699cbe489a3d94"
-  integrity sha512-lKj6aRSGbqLmpYmM24bY7a1Xmfcq2vkE3hv8CSPYfc1yCu0BPu/XEJ1L4Fm61MsU6ULLNSG8UGsffNoFUBjESA==
+"@aws-sdk/credential-provider-web-identity@^3.972.4", "@aws-sdk/credential-provider-web-identity@^3.972.78":
+  version "3.972.78"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/credential-provider-web-identity/-/credential-provider-web-identity-3.972.78.tgz#2ff347600d79a2b838296da3278998c7a1cdcbac"
+  integrity sha512-/y9WvNtlcPBGLR0qc1a+9J/xtYZfVczvLUOuXaVWylzttH7ewsxwHtjmiJSolNrVSDorIxHGHMU61CbonRkmwA==
   dependencies:
-    "@aws-sdk/core" "^3.974.20"
-    "@aws-sdk/nested-clients" "^3.997.20"
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/core" "^3.24.6"
-    "@smithy/types" "^4.14.3"
+    "@aws-sdk/core" "^3.978.1"
+    "@aws-sdk/nested-clients" "^3.997.46"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/core" "^3.35.0"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
 "@aws-sdk/credential-providers@^3.186.0":
@@ -1260,20 +1258,18 @@
     "@smithy/util-utf8" "^4.2.0"
     tslib "^2.6.2"
 
-"@aws-sdk/nested-clients@^3.997.20":
-  version "3.997.20"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/nested-clients/-/nested-clients-3.997.20.tgz#00607f294f0109c1ee96cccab411106b8fa55625"
-  integrity sha512-IYJuLpXp2DEILVQpQOy0PMpkftv0AHEOCn52o0atyOaumA0CdWQ3klPyXdViGYLbNpESsVFMVybvHUeZAuiGxA==
-  dependencies:
-    "@aws-crypto/sha256-browser" "5.2.0"
-    "@aws-crypto/sha256-js" "5.2.0"
-    "@aws-sdk/core" "^3.974.20"
-    "@aws-sdk/signature-v4-multi-region" "^3.996.34"
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/core" "^3.24.6"
-    "@smithy/fetch-http-handler" "^5.4.6"
-    "@smithy/node-http-handler" "^4.7.6"
-    "@smithy/types" "^4.14.3"
+"@aws-sdk/nested-clients@^3.997.46":
+  version "3.997.46"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/nested-clients/-/nested-clients-3.997.46.tgz#71fce1a139f9f81c81603d704c9300f45be74477"
+  integrity sha512-oRxtBcka/JGHGs9l9p9IVajGoTP8vTPmoAzdHGy4Qcy9P5vPnDf6nhIeM/COQNY9k/OahImTRaLkHftoXvfcmQ==
+  dependencies:
+    "@aws-sdk/core" "^3.978.1"
+    "@aws-sdk/signature-v4-multi-region" "^3.996.47"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/core" "^3.35.0"
+    "@smithy/fetch-http-handler" "^5.8.0"
+    "@smithy/node-http-handler" "^4.12.1"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
 "@aws-sdk/region-config-resolver@^3.972.3":
@@ -1287,34 +1283,34 @@
     "@smithy/types" "^4.14.1"
     tslib "^2.6.2"
 
-"@aws-sdk/signature-v4-multi-region@^3.996.34":
-  version "3.996.34"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/signature-v4-multi-region/-/signature-v4-multi-region-3.996.34.tgz#99749163def9dfc720eef85f7fe2d14bb4b763fb"
-  integrity sha512-mx1L5qlumSOt/nKM3BFaHE2HVkWwz0i4Bw0pyYO42FfX/FeLlo8YI6csC0gSPprEk6fTIqI+CZN9RwUwKd5krQ==
+"@aws-sdk/signature-v4-multi-region@^3.996.34", "@aws-sdk/signature-v4-multi-region@^3.996.47":
+  version "3.996.47"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/signature-v4-multi-region/-/signature-v4-multi-region-3.996.47.tgz#4a707c1d5b43ea242897c393b03f8583fcfbb8ab"
+  integrity sha512-Zk08macMvQTHzQJCLJVkOlviVoqwYMrpXv4lmLN7b7sAbiMoOK7Go0NYdR5UeF+MW8LIbRmwrNy9u/5VvX1U5g==
   dependencies:
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/signature-v4" "^5.4.6"
-    "@smithy/types" "^4.14.3"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/signature-v4" "^5.7.3"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
-"@aws-sdk/token-providers@3.1066.0":
-  version "3.1066.0"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/token-providers/-/token-providers-3.1066.0.tgz#1253c27ab45284655ab935411a0fbbf91b2c7c7f"
-  integrity sha512-UqEUJq7dqa44hneLDUcX7UJy95cg8YqEWyakRpvIPnrNS3Mq+UlQHgCDGu5pvwAPtlIW4qcYbvW6reG6++FyvA==
+"@aws-sdk/token-providers@3.1138.0":
+  version "3.1138.0"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/token-providers/-/token-providers-3.1138.0.tgz#bf7042681ed21c64a0c4f1bc0e8f18f9be59af2c"
+  integrity sha512-GpyAr0DD63YOEmYFM6Df+gJuIgC92MMTiBK4FTKfxii5MJ9ge20epR7LyroulscYlG89J+ZB2ivFDPjvfQhzdw==
   dependencies:
-    "@aws-sdk/core" "^3.974.20"
-    "@aws-sdk/nested-clients" "^3.997.20"
-    "@aws-sdk/types" "^3.973.12"
-    "@smithy/core" "^3.24.6"
-    "@smithy/types" "^4.14.3"
+    "@aws-sdk/core" "^3.978.1"
+    "@aws-sdk/nested-clients" "^3.997.46"
+    "@aws-sdk/types" "^3.974.6"
+    "@smithy/core" "^3.35.0"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
-"@aws-sdk/types@^3.222.0", "@aws-sdk/types@^3.973.1", "@aws-sdk/types@^3.973.12", "@aws-sdk/types@^3.973.8":
-  version "3.973.12"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/types/-/types-3.973.12.tgz#a3ae50d325644e4e890030d187febbeef2d238ef"
-  integrity sha512-43ajd1NF0RMgX5k0hxCNUyEdrtFUsb2aHT2QvpktSC/2Eyb2Jr/JPVqdp0XIoaHWikZJq5tNWSLO6kB5q2eMCA==
+"@aws-sdk/types@^3.222.0", "@aws-sdk/types@^3.973.1", "@aws-sdk/types@^3.973.12", "@aws-sdk/types@^3.973.8", "@aws-sdk/types@^3.974.6":
+  version "3.974.6"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/types/-/types-3.974.6.tgz#e388d89a012ce70e60fef26174562f99285b1e95"
+  integrity sha512-v/clNZzZnDxGyvpHMOGpJKVXFAExJzUNAAjaWGdcx8QAcXLGwTaOkw33p5SHAi0YAioK32xB3hWwOekRVfmfKg==
   dependencies:
-    "@smithy/types" "^4.14.3"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
 "@aws-sdk/util-endpoints@3.980.0":
@@ -1379,13 +1375,12 @@
     "@smithy/util-config-provider" "^4.2.2"
     tslib "^2.6.2"
 
-"@aws-sdk/xml-builder@^3.972.29":
-  version "3.972.29"
-  resolved "https://registry.yarnpkg.com/@aws-sdk/xml-builder/-/xml-builder-3.972.29.tgz#1fffe1dd3fbb84c034ff2f8008de8a6926a4a672"
-  integrity sha512-fk0niuGFxfi8yIJuMVM4mhwObkiQSuwZFj3tAPrLVx64Pk3BkrEIpqjzHKY4hKoEBUD6Jg/S74Zj9jy+5F3DnQ==
+"@aws-sdk/xml-builder@^3.972.41":
+  version "3.972.41"
+  resolved "https://registry.yarnpkg.com/@aws-sdk/xml-builder/-/xml-builder-3.972.41.tgz#d3154d8893c3a85f58ce629b70a17ce70e0a1137"
+  integrity sha512-ctjVSyCMegrWfXlx6VqzSBFI6UqmQ5ZlnfMhdLIiWmhoH8UAQxSCP5N3OpG7X3k4LnS7ou74C4mt20+bfTW2aQ==
   dependencies:
-    "@smithy/types" "^4.14.3"
-    fast-xml-parser "5.7.3"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
 "@aws/lambda-invoke-store@^0.2.2":
@@ -1393,6 +1388,11 @@
   resolved "https://registry.yarnpkg.com/@aws/lambda-invoke-store/-/lambda-invoke-store-0.2.3.tgz#f1137f56209ccc69c15f826242cbf37f828617dd"
   integrity sha512-oLvsaPMTBejkkmHhjf09xTgk71mOqyr/409NKhRIL08If7AhVfUsJhVsx386uJaqNd42v9kWamQ9lFbkoC2dYw==
 
+"@aws/lambda-invoke-store@^0.3.0":
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/@aws/lambda-invoke-store/-/lambda-invoke-store-0.3.0.tgz#708802d987f8e17bdf4af4de1031660ce1cdd65f"
+  integrity sha512-sl4Bm6yiMNYrZKkqqDFWN0UfnWhlS8ivKxrYl+6t0gCLrqr8y3B2IqZZbFRkfaVVp7C/baApyh71P+LeE1A2sQ==
+
 "@azure/abort-controller@^1.0.0":
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/@azure/abort-controller/-/abort-controller-1.1.0.tgz#788ee78457a55af8a1ad342acb182383d2119249"
@@ -8200,31 +8200,30 @@
     "@smithy/util-middleware" "^4.2.14"
     tslib "^2.6.2"
 
-"@smithy/core@^3.22.0", "@smithy/core@^3.23.17", "@smithy/core@^3.24.6", "@smithy/core@^3.24.7":
-  version "3.24.7"
-  resolved "https://registry.yarnpkg.com/@smithy/core/-/core-3.24.7.tgz#040621b1150844abf763fc77691232ea0719a006"
-  integrity sha512-KoUi4M1f3BG6kzN1FnCwL7oyFptTbyBJKjR6yhSib+JHRdUmM1o+VwsFtJ66NZCkCzVfJMWRHJNo0R0jznp0Pg==
+"@smithy/core@^3.22.0", "@smithy/core@^3.23.17", "@smithy/core@^3.24.6", "@smithy/core@^3.33.2", "@smithy/core@^3.33.3", "@smithy/core@^3.35.0":
+  version "3.35.2"
+  resolved "https://registry.yarnpkg.com/@smithy/core/-/core-3.35.2.tgz#6c45b08ba0cb68f610d764d0b0bafb258268670e"
+  integrity sha512-ejTukBuP/Pg3t9N8Ux+0zKsXeHWm7p6W3HbXFOyltKasSxZwCFmvTut7kBdZSCF3m9y1bXXyVu6p2xuMFcsTyQ==
   dependencies:
-    "@aws-crypto/crc32" "5.2.0"
-    "@smithy/types" "^4.14.4"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
-"@smithy/credential-provider-imds@^4.2.14", "@smithy/credential-provider-imds@^4.2.8", "@smithy/credential-provider-imds@^4.3.7":
-  version "4.3.9"
-  resolved "https://registry.yarnpkg.com/@smithy/credential-provider-imds/-/credential-provider-imds-4.3.9.tgz#3bb51eea08fb40c519df3c4d3b7c5d24dde0094d"
-  integrity sha512-ZlfJ/4Fa3jYb+3eaohPfG9utX9HmdhFNcFtpoGAhUhdynAOmGXtmigbi7eEiONKM+ykHw8RwKuDEb85Lx7t7fA==
+"@smithy/credential-provider-imds@^4.2.14", "@smithy/credential-provider-imds@^4.2.8", "@smithy/credential-provider-imds@^4.5.2":
+  version "4.5.2"
+  resolved "https://registry.yarnpkg.com/@smithy/credential-provider-imds/-/credential-provider-imds-4.5.2.tgz#da3ea9636b5566b36b0761382d841a6d8fdde14f"
+  integrity sha512-A9uSdn72ozbRUSit0eib0TW7nXuNPlaeM0zcGkJ+nE6tFcSDbnmtwoxbTCFBukVQcszDAyvsd7+rTduPTXpygg==
   dependencies:
-    "@smithy/core" "^3.24.7"
-    "@smithy/types" "^4.14.4"
+    "@smithy/core" "^3.33.2"
+    "@smithy/types" "^4.17.2"
     tslib "^2.6.2"
 
-"@smithy/fetch-http-handler@^5.3.17", "@smithy/fetch-http-handler@^5.3.9", "@smithy/fetch-http-handler@^5.4.6":
-  version "5.4.7"
-  resolved "https://registry.yarnpkg.com/@smithy/fetch-http-handler/-/fetch-http-handler-5.4.7.tgz#fe82b38c6201aa4a413062020cf47c35bd4d44c0"
-  integrity sha512-NslaM2ir0N2hisDmzXLstPaVINZheh8SokyOC++kzFPloZucL2R7Y7bS57mSzx/1Fc/fqmn7twjkeezTTrV0EA==
+"@smithy/fetch-http-handler@^5.3.17", "@smithy/fetch-http-handler@^5.3.9", "@smithy/fetch-http-handler@^5.4.6", "@smithy/fetch-http-handler@^5.8.0":
+  version "5.8.0"
+  resolved "https://registry.yarnpkg.com/@smithy/fetch-http-handler/-/fetch-http-handler-5.8.0.tgz#349464e31682d739a74efa42362756be49eb2883"
+  integrity sha512-ycSJu3tFAQ4v04CBB0agqFMVsSQ1iG3yw+SpgxRqKfaURpQD4CZ8Wn0zPMmSnOuTpTh65Vz+EA0rMrw089wvkA==
   dependencies:
-    "@smithy/core" "^3.24.7"
-    "@smithy/types" "^4.14.4"
+    "@smithy/core" "^3.33.3"
+    "@smithy/types" "^4.18.0"
     tslib "^2.6.2"
 
 "@smithy/hash-node@^4.2.8":
@@ -8326,13 +8325,13 @@
     "@smithy/types" "^4.14.1"
     tslib "^2.6.2"
 
-"@smithy/node-http-handler@^4.4.8", "@smithy/node-http-handler@^4.6.1", "@smithy/node-http-handler@^4.7.6":
-  version "4.7.8"
-  resolved "https://registry.yarnpkg.com/@smithy/node-http-handler/-/node-http-handler-4.7.8.tgz#c6a42bc967cc1d9961b1be54d4f3fc5f38f8f4bc"
-  integrity sha512-f+DbsWUwSbtMu1a/j8Y93KiU1SRg9nyzfjereqn1BJ33QOTUXxdlYvVXMhAYl1vuR1Kmna5aIJe09KSIfyFNYw==
+"@smithy/node-http-handler@^4.12.1", "@smithy/node-http-handler@^4.4.8", "@smithy/node-http-handler@^4.6.1", "@smithy/node-http-handler@^4.7.6":
+  version "4.12.1"
+  resolved "https://registry.yarnpkg.com/@smithy/node-http-handler/-/node-http-handler-4.12.1.tgz#e4da9379d228517ba85845081e4e6758ca315c5d"
+  integrity sha512-ThMkboGeONWXAelq9FvGsuJC4rOi+qyC4/zhUF58xYpxUg5sQKx2VXZYJmtNjr4dSuBJ1HeJXETQILCz3wOHvw==
   dependencies:
-    "@smithy/core" "^3.24.7"
-    "@smithy/types" "^4.14.4"
+    "@smithy/core" "^3.33.3"
+    "@smithy/types" "^4.18.0"
     tslib "^2.6.2"
 
 "@smithy/property-provider@^4.2.14", "@smithy/property-provider@^4.2.8":
@@ -8374,13 +8373,13 @@
     "@smithy/types" "^4.14.1"
     tslib "^2.6.2"
 
-"@smithy/signature-v4@^5.4.6":
-  version "5.4.7"
-  resolved "https://registry.yarnpkg.com/@smithy/signature-v4/-/signature-v4-5.4.7.tgz#a56fc486928bb54d822f1f18f81a1e00328e78ce"
-  integrity sha512-LwQZazFayImv+IOm0S0enoLeUJwmAlhGC5O6YCcLWezyu08dF46GOxPOq35OpBIHkgd7OvNvBStIFwVNyrvoBw==
+"@smithy/signature-v4@^5.7.3":
+  version "5.7.4"
+  resolved "https://registry.yarnpkg.com/@smithy/signature-v4/-/signature-v4-5.7.4.tgz#f188be5238ddb5c5b3117f6fb75d36a38f8b033f"
+  integrity sha512-tHy0K0VtqNd5Y7Y41h0a0Lhh0L1GzC08dTWg0F7vRJWFtTENg7IZikf3wQkanYIRdb7ngoIPMTmqgUi401fEeQ==
   dependencies:
-    "@smithy/core" "^3.24.7"
-    "@smithy/types" "^4.14.4"
+    "@smithy/core" "^3.35.0"
+    "@smithy/types" "^4.19.0"
     tslib "^2.6.2"
 
 "@smithy/smithy-client@^4.11.1", "@smithy/smithy-client@^4.12.13":
@@ -8396,10 +8395,10 @@
     "@smithy/util-stream" "^4.5.25"
     tslib "^2.6.2"
 
-"@smithy/types@^4.12.0", "@smithy/types@^4.14.1", "@smithy/types@^4.14.3", "@smithy/types@^4.14.4":
-  version "4.14.4"
-  resolved "https://registry.yarnpkg.com/@smithy/types/-/types-4.14.4.tgz#0c83b7e011d30730ec43fa13290e61a7ca234ccc"
-  integrity sha512-B2S9+UGm1+/pHkcx3ZoLVX1a+pmSk8rqxRR+ZsNqZaJ5q9FWX9AFGQVM4qG5+OBeQUZVy99HY8HqW8gK/wgXzQ==
+"@smithy/types@^4.12.0", "@smithy/types@^4.14.1", "@smithy/types@^4.14.3", "@smithy/types@^4.17.2", "@smithy/types@^4.18.0", "@smithy/types@^4.19.0":
+  version "4.19.0"
+  resolved "https://registry.yarnpkg.com/@smithy/types/-/types-4.19.0.tgz#a0dd9c9d7b2a070fc7c3d69efedea8404b3646be"
+  integrity sha512-r7jh49VJxGerfAcTQA6gXcKc+98zOp/tqRwzYjgOE+iSQsP6cEU1hq2QzbuipmP68QtYdY9wKEhiCQZIzHgZ4Q==
   dependencies:
     tslib "^2.6.2"
 
@@ -15797,7 +15796,14 @@ fast-xml-builder@^1.1.7:
     path-expression-matcher "^1.5.0"
     xml-naming "^0.1.0"
 
-fast-xml-parser@5.7.3, fast-xml-parser@^5.0.7:
+fast-xml-parser@^4.4.1:
+  version "4.5.6"
+  resolved "https://registry.yarnpkg.com/fast-xml-parser/-/fast-xml-parser-4.5.6.tgz#4ff57d4aca13a2d11aa42ad460495cf00f32b655"
+  integrity sha512-Yd4vkROfJf8AuJrDIVMVmYfULKmIJszVsMv7Vo71aocsKgFxpdlpSHXSaInvyYfgw2PRuObQSW2GFpVMUjxu9A==
+  dependencies:
+    strnum "^1.0.5"
+
+fast-xml-parser@^5.0.7:
   version "5.7.3"
   resolved "https://registry.yarnpkg.com/fast-xml-parser/-/fast-xml-parser-5.7.3.tgz#309b04b08d835defc62ab657a0bb340c0e0fbe6a"
   integrity sha512-C0AaNuC+mscy6vrAQKAc/rMq+zAPHodfHGZu4sGVehvAQt/JLG1O5zEcYcXSY5zSqr4YVgxsB+pHXTq0i7eDlg==
@@ -15807,13 +15813,6 @@ fast-xml-parser@5.7.3, fast-xml-parser@^5.0.7:
     path-expression-matcher "^1.5.0"
     strnum "^2.2.3"
 
-fast-xml-parser@^4.4.1:
-  version "4.5.6"
-  resolved "https://registry.yarnpkg.com/fast-xml-parser/-/fast-xml-parser-4.5.6.tgz#4ff57d4aca13a2d11aa42ad460495cf00f32b655"
-  integrity sha512-Yd4vkROfJf8AuJrDIVMVmYfULKmIJszVsMv7Vo71aocsKgFxpdlpSHXSaInvyYfgw2PRuObQSW2GFpVMUjxu9A==
-  dependencies:
-    strnum "^1.0.5"
-
 fastify@^5.12.5:
   version "5.12.5"
   resolved "https://registry.yarnpkg.com/fastify/-/fastify-5.12.5.tgz#e3a6937e154a51332889a30ff3b8f97db52d7355"

From 954484b0d56c29d577ba6f2deadb4295041ec8de Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 9 Oct 2026 19:50:49 +0200
Subject: [PATCH 43/84] chore(deps-dev): Bump rimraf from 5.0.10 to 6.1.3
 (#25241)

Bumps [rimraf](https://github.com/isaacs/rimraf) from 5.0.10 to 6.1.3.
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a
href="https://github.com/isaacs/rimraf/blob/main/CHANGELOG.md">rimraf's
changelog</a>.</em></p>
<blockquote>
<h1>6.1</h1>
<ul>
<li>Move to native <code>fs/promises</code> usage instead of
promisifying
manually.</li>
</ul>
<h1>6.0</h1>
<ul>
<li>Drop support for nodes before v20</li>
<li>Add <code>--version</code> to CLI</li>
</ul>
<h1>5.0</h1>
<ul>
<li>No default export, only named exports</li>
</ul>
<h1>4.4</h1>
<ul>
<li>Provide Dirent or Stats object as second argument to filter</li>
</ul>
<h1>4.3</h1>
<ul>
<li>Return boolean indicating whether the path was fully removed</li>
<li>Add filter option</li>
<li>bin: add --verbose, -v to print files as they are deleted</li>
<li>bin: add --no-verbose, -V to not print files as they are
deleted</li>
<li>bin: add -i --interactive to be prompted on each deletion</li>
<li>bin: add -I --no-interactive to not be prompted on each
deletion</li>
<li><strong>4.3.1</strong> Fixed inappropriately following symbolic
links to
directories</li>
</ul>
<h1>v4.2</h1>
<ul>
<li>Brought back <code>glob</code> support, using the new and improved
glob v9</li>
</ul>
<h1>v4.1</h1>
<ul>
<li>Improved hybrid module with no need to look at the
<code>.default</code>
dangly bit. <code>.default</code> preserved as a reference to
<code>rimraf</code>
for compatibility with anyone who came to rely on it in v4.0.</li>
<li>Accept and ignore <code>-rf</code> and <code>-fr</code> arguments to
the bin.</li>
</ul>
<h1>v4.0</h1>
<ul>
<li>Remove <code>glob</code> dependency entirely. This library now only
accepts actual file and folder names to delete.</li>
<li>Accept array of paths or single path.</li>
<li>Windows performance and reliability improved.</li>
<li>All strategies separated into explicitly exported methods.</li>
<li>Drop support for Node.js below version 14</li>
<li>rewrite in TypeScript</li>
</ul>
<!-- raw HTML omitted -->
</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/isaacs/rimraf/commit/f738c781d14fa7bc06f8e39e062d78f701fde3f1"><code>f738c78</code></a>
6.1.3</li>
<li><a
href="https://github.com/isaacs/rimraf/commit/a164a85093f78e40d8f995b0d8ff3a1856324768"><code>a164a85</code></a>
update deps</li>
<li><a
href="https://github.com/isaacs/rimraf/commit/4635ba7498849cade724bd34c1ec9feae4b56236"><code>4635ba7</code></a>
update deps</li>
<li><a
href="https://github.com/isaacs/rimraf/commit/509c53f8b0298508c3a536dc121bbc0652d3e56f"><code>509c53f</code></a>
limit ci workflow permissions</li>
<li><a
href="https://github.com/isaacs/rimraf/commit/68ce04f9bfb436e66356428e2970c78fa2a76d02"><code>68ce04f</code></a>
formatting</li>
<li><a
href="https://github.com/isaacs/rimraf/commit/37680c5d7f0104042ab8e8fae3e77484dc7687ca"><code>37680c5</code></a>
add warning to not pass untrusted input to this method ever</li>
<li><a
href="https://github.com/isaacs/rimraf/commit/786563d3901763fa77090271d239233aa27e7a3a"><code>786563d</code></a>
remove contributing doc, already covered by .github repo</li>
<li><a
href="https://github.com/isaacs/rimraf/commit/dbeef7399038d0cc467dbac5f91074cd0dc847dd"><code>dbeef73</code></a>
contributing</li>
<li><a
href="https://github.com/isaacs/rimraf/commit/84d27afdbf7a211ecce6e9e73530aeb7278ea5d2"><code>84d27af</code></a>
update workflows and standard project junk</li>
<li><a
href="https://github.com/isaacs/rimraf/commit/cd45498f616f9265dfe1e30640d6424348f75f04"><code>cd45498</code></a>
6.1.2</li>
<li>Additional commits viewable in <a
href="https://github.com/isaacs/rimraf/compare/v5.0.10...v6.1.3">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=rimraf&package-manager=npm_and_yarn&previous-version=5.0.10&new-version=6.1.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 package.json | 2 +-
 yarn.lock    | 9 +--------
 2 files changed, 2 insertions(+), 9 deletions(-)

diff --git a/package.json b/package.json
index 4eb2f0af3612..d009220ac089 100644
--- a/package.json
+++ b/package.json
@@ -136,7 +136,7 @@
     "oxfmt": "^0.70.0",
     "oxlint": "^1.75.0",
     "oxlint-tsgolint": "7",
-    "rimraf": "^5.0.10",
+    "rimraf": "^6.1.3",
     "rollup": "^4.60.3",
     "rollup-plugin-esbuild": "^6.2.1",
     "rollup-plugin-license": "^3.7.1",
diff --git a/yarn.lock b/yarn.lock
index a93dfb60ddd6..1b17dca8b628 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -16511,7 +16511,7 @@ glob@8.0.3:
     minimatch "^5.0.1"
     once "^1.3.0"
 
-glob@^10.0.0, glob@^10.3.7:
+glob@^10.0.0:
   version "10.5.0"
   resolved "https://registry.yarnpkg.com/glob/-/glob-10.5.0.tgz#8ec0355919cd3338c28428a23d4f24ecc5fe738c"
   integrity sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==
@@ -24330,13 +24330,6 @@ rimraf@^3.0.0, rimraf@^3.0.2:
   dependencies:
     glob "^7.1.3"
 
-rimraf@^5.0.10:
-  version "5.0.10"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-5.0.10.tgz#23b9843d3dc92db71f96e1a2ce92e39fd2a8221c"
-  integrity sha512-l0OE8wL34P4nJH/H2ffoaniAokM2qSmrtXHmlpvYr5AVVX8msAyW0l8NVJFDxlSK4u3Uh/f41cQheDVdnYijwQ==
-  dependencies:
-    glob "^10.3.7"
-
 rimraf@^6.1.0, rimraf@^6.1.3:
   version "6.1.3"
   resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-6.1.3.tgz#afbee236b3bd2be331d4e7ce4493bac1718981af"

From 84f8010fed8c65a5d5d99911197ada8e3a943c02 Mon Sep 17 00:00:00 2001
From: Dan Fuller <dfuller@sentry.io>
Date: Fri, 9 Oct 2026 11:05:31 -0700
Subject: [PATCH 44/84] feat(cloudflare): Add opt-in cron monitoring for Cron
 Triggers (#25014)

## Description

Adds an opt-in `cronTriggersIntegration` that sends check-ins for Cron
Triggers, with the schedule from `controller.cron`, so Sentry creates
the monitor on the first run:

```ts
const jobs = { '30 9 * * MON-FRI': { slug: 'daily-report', run: dailyReport } };

export default Sentry.withSentry(
  env => ({
    dsn: env.SENTRY_DSN,
    integrations: [Sentry.cronTriggersIntegration({ slug: cron => jobs[cron]?.slug })],
  }),
  { async scheduled(controller, env) { await jobs[controller.cron]?.run(env); } },
);
```

It's opt-in because monitors are billed. `slug` can also return monitor
settings, or `undefined` to skip a trigger; without it the slug is
derived from the expression. Schedules Sentry would read differently
from Cloudflare (`L`/`#`/`W`/`?`, or both day fields set) are sent
without a monitor config, because a wrong schedule causes false missed
check-in alerts. Weekday numbers are sent as names, since Cloudflare
counts from 1 = Sunday.

Tree-shaken when not imported: +267 B on `@sentry/cloudflare
(withSentry) - minified`.

## Motivation

Check-ins for monitors that don't exist are dropped, so users have to
create each monitor by hand, even though the schedule is already in
their `wrangler` config.

## Testing

Unit tests for the integration and the schedule conversion.

Docs: https://github.com/getsentry/sentry-docs/pull/19783

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: JPeer264 <jan.peer@sentry.io>
---
 .../suites/cron-triggers/index.ts             |  17 ++
 .../suites/cron-triggers/instrument.server.ts |   8 +
 .../suites/cron-triggers/monitorSlugs.ts      |   4 +
 .../suites/cron-triggers/test.ts              |  91 ++++++++
 .../suites/cron-triggers/vite.config.mts      |   7 +
 .../suites/cron-triggers/wrangler.jsonc       |   7 +
 packages/cloudflare/src/index.ts              |   2 +
 .../worker/instrumentScheduled.ts             |  31 ++-
 .../src/integrations/cronTriggers.ts          | 195 +++++++++++++++++
 .../worker/instrumentScheduled.test.ts        | 204 +++++++++++++++++-
 .../test/integrations/cronTriggers.test.ts    | 198 +++++++++++++++++
 11 files changed, 761 insertions(+), 3 deletions(-)
 create mode 100644 dev-packages/cloudflare-integration-tests/suites/cron-triggers/index.ts
 create mode 100644 dev-packages/cloudflare-integration-tests/suites/cron-triggers/instrument.server.ts
 create mode 100644 dev-packages/cloudflare-integration-tests/suites/cron-triggers/monitorSlugs.ts
 create mode 100644 dev-packages/cloudflare-integration-tests/suites/cron-triggers/test.ts
 create mode 100644 dev-packages/cloudflare-integration-tests/suites/cron-triggers/vite.config.mts
 create mode 100644 dev-packages/cloudflare-integration-tests/suites/cron-triggers/wrangler.jsonc
 create mode 100644 packages/cloudflare/src/integrations/cronTriggers.ts
 create mode 100644 packages/cloudflare/test/integrations/cronTriggers.test.ts

diff --git a/dev-packages/cloudflare-integration-tests/suites/cron-triggers/index.ts b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/index.ts
new file mode 100644
index 000000000000..8d84e6709ea5
--- /dev/null
+++ b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/index.ts
@@ -0,0 +1,17 @@
+import { monitorSlugs } from './monitorSlugs';
+
+interface Env {
+  SERVER_URL: string;
+}
+
+export default {
+  async scheduled(controller, env) {
+    switch (monitorSlugs[controller.cron]) {
+      case 'daily-report':
+        await fetch(env.SERVER_URL);
+        break;
+      case 'sync-inventory':
+        throw new Error('Boom from sync-inventory');
+    }
+  },
+} satisfies ExportedHandler<Env>;
diff --git a/dev-packages/cloudflare-integration-tests/suites/cron-triggers/instrument.server.ts b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/instrument.server.ts
new file mode 100644
index 000000000000..932d25662304
--- /dev/null
+++ b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/instrument.server.ts
@@ -0,0 +1,8 @@
+import { cronTriggersIntegration, defineCloudflareOptions } from '@sentry/cloudflare';
+import { monitorSlugs } from './monitorSlugs';
+
+export default defineCloudflareOptions((env: { SENTRY_DSN: string; CACHE_CLIENT?: string }) => ({
+  dsn: env.SENTRY_DSN,
+  cacheClient: env.CACHE_CLIENT !== 'false',
+  integrations: [cronTriggersIntegration({ monitorSlug: cron => monitorSlugs[cron] })],
+}));
diff --git a/dev-packages/cloudflare-integration-tests/suites/cron-triggers/monitorSlugs.ts b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/monitorSlugs.ts
new file mode 100644
index 000000000000..36972a73a189
--- /dev/null
+++ b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/monitorSlugs.ts
@@ -0,0 +1,4 @@
+export const monitorSlugs: Record<string, string> = {
+  '30 9 * * MON-FRI': 'daily-report',
+  '0 */6 * * *': 'sync-inventory',
+};
diff --git a/dev-packages/cloudflare-integration-tests/suites/cron-triggers/test.ts b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/test.ts
new file mode 100644
index 000000000000..e46ead83126a
--- /dev/null
+++ b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/test.ts
@@ -0,0 +1,91 @@
+import type { Envelope, SerializedCheckIn } from '@sentry/core';
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { expect, it, onTestFinished } from 'vitest';
+import { createRunner } from '../../runner';
+
+it.for([true, false])(
+  'cacheClient: %s - sends the in_progress check-in while the scheduled handler runs, then the ok check-in',
+  async (cacheClient, { signal }) => {
+    // The handler waits for a response from this server, which answers only after the in_progress check-in
+    // has arrived. A check-in that waits for the flush after the handler would keep the run from ending.
+    let openGate: () => void = () => undefined;
+    const gateOpened = new Promise<void>(resolve => {
+      openGate = resolve;
+    });
+    const gate = createServer((_req, res) => {
+      void gateOpened.then(() => res.end());
+    });
+    await new Promise<void>(resolve => gate.listen(0, resolve));
+    onTestFinished(() => {
+      gate.closeAllConnections();
+      gate.close();
+    });
+
+    let inProgressCheckInId: string | undefined;
+
+    const runner = createRunner(__dirname)
+      .withServerUrl(`http://localhost:${(gate.address() as AddressInfo).port}`)
+      .withWranglerArgs('--var', `CACHE_CLIENT:${cacheClient}`)
+      .expect((envelope: Envelope) => {
+        const checkIn = envelope[1][0]?.[1] as SerializedCheckIn;
+
+        expect(checkIn).toEqual(
+          expect.objectContaining({
+            monitor_slug: 'daily-report',
+            status: 'in_progress',
+            monitor_config: { schedule: { type: 'crontab', value: '30 9 * * MON-FRI' } },
+          }),
+        );
+        inProgressCheckInId = checkIn.check_in_id;
+        openGate();
+      })
+      .expect((envelope: Envelope) => {
+        expect(envelope[1][0]?.[1]).toEqual(
+          expect.objectContaining({
+            check_in_id: inProgressCheckInId,
+            monitor_slug: 'daily-report',
+            status: 'ok',
+            duration: expect.any(Number),
+          }),
+        );
+      })
+      .start(signal);
+
+    await runner.makeRequest('get', '/cdn-cgi/handler/scheduled?cron=30+9+*+*+MON-FRI');
+    await runner.completed();
+  },
+);
+
+it('sends an error check-in and the error when the scheduled handler throws', async ({ signal }) => {
+  const runner = createRunner(__dirname)
+    .unordered()
+    .expect((envelope: Envelope) => {
+      expect(envelope[1][0]?.[1]).toEqual(
+        expect.objectContaining({
+          monitor_slug: 'sync-inventory',
+          status: 'in_progress',
+          monitor_config: { schedule: { type: 'crontab', value: '0 */6 * * *' } },
+        }),
+      );
+    })
+    .expect((envelope: Envelope) => {
+      expect(envelope[1][0]?.[1]).toEqual(expect.objectContaining({ monitor_slug: 'sync-inventory', status: 'error' }));
+    })
+    .expect((envelope: Envelope) => {
+      expect(envelope[1][0]?.[1]).toMatchObject({
+        exception: {
+          values: [
+            {
+              value: 'Boom from sync-inventory',
+              mechanism: { type: 'auto.faas.cloudflare.scheduled', handled: false },
+            },
+          ],
+        },
+      });
+    })
+    .start(signal);
+
+  await runner.makeRequest('get', '/cdn-cgi/handler/scheduled?cron=0+*/6+*+*+*', { expectError: true });
+  await runner.completed();
+});
diff --git a/dev-packages/cloudflare-integration-tests/suites/cron-triggers/vite.config.mts b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/vite.config.mts
new file mode 100644
index 000000000000..005f4448f6cb
--- /dev/null
+++ b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/vite.config.mts
@@ -0,0 +1,7 @@
+import { cloudflare } from '@cloudflare/vite-plugin';
+import { sentryCloudflareVitePlugin } from '@sentry/cloudflare/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [cloudflare(), sentryCloudflareVitePlugin()],
+});
diff --git a/dev-packages/cloudflare-integration-tests/suites/cron-triggers/wrangler.jsonc b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/wrangler.jsonc
new file mode 100644
index 000000000000..4b39fe403d3a
--- /dev/null
+++ b/dev-packages/cloudflare-integration-tests/suites/cron-triggers/wrangler.jsonc
@@ -0,0 +1,7 @@
+{
+  "$schema": "../../node_modules/wrangler/config-schema.json",
+  "name": "cloudflare-cron-triggers",
+  "main": "index.ts",
+  "compatibility_date": "2025-06-17",
+  "compatibility_flags": ["nodejs_compat"],
+}
diff --git a/packages/cloudflare/src/index.ts b/packages/cloudflare/src/index.ts
index 1d3aef44a03c..88ce8deaac01 100644
--- a/packages/cloudflare/src/index.ts
+++ b/packages/cloudflare/src/index.ts
@@ -124,6 +124,8 @@ export { httpServerIntegration } from './integrations/httpServer';
 export { fetchIntegration } from './integrations/fetch';
 export type { FetchIntegrationOptions } from '@sentry/core';
 export { spotlightIntegration } from './integrations/spotlight';
+export { cronTriggersIntegration } from './integrations/cronTriggers';
+export type { CronTriggerMonitorSettings, CronTriggersOptions } from './integrations/cronTriggers';
 export {
   openTelemetryIntegration,
   getOtlpTracesEndpoint,
diff --git a/packages/cloudflare/src/instrumentations/worker/instrumentScheduled.ts b/packages/cloudflare/src/instrumentations/worker/instrumentScheduled.ts
index b0da3a279a39..8bf690d05175 100644
--- a/packages/cloudflare/src/instrumentations/worker/instrumentScheduled.ts
+++ b/packages/cloudflare/src/instrumentations/worker/instrumentScheduled.ts
@@ -12,10 +12,12 @@ import {
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
 import { FUNCTION } from '@sentry/conventions/op';
-import { captureException, hasSpanStreamingEnabled, startSpan, withIsolationScope } from '@sentry/core';
+import { captureException, debug, hasSpanStreamingEnabled, startSpan, withIsolationScope } from '@sentry/core';
 import type { CloudflareOptions } from '../../client';
+import { DEBUG_BUILD } from '../../debug-build';
 import { flushAndDispose } from '../../flush';
 import { ensureInstrumented } from '../../instrument';
+import type { CronTriggersIntegration } from '../../integrations/cronTriggers';
 import { getFinalOptions } from '../../options';
 import { addCloudResourceContext } from '../../scope-utils';
 import { init } from '../../sdk';
@@ -58,9 +60,34 @@ function wrapScheduledHandler(
         },
       },
       async () => {
+        let finishCheckIn: ReturnType<CronTriggersIntegration['startCheckIn']>;
         try {
-          return await fn();
+          finishCheckIn = client
+            ?.getIntegrationByName<CronTriggersIntegration>('CronTriggers')
+            ?.startCheckIn(controller.cron);
+          // The transport holds envelopes until the flush after the handler, so a run that is longer than
+          // the check-in margin would deliver its in_progress check-in too late and show as missed.
+          if (finishCheckIn) {
+            waitUntil(Promise.resolve(client?.getTransport()?.flush(2000)).catch(() => undefined));
+          }
         } catch (e) {
+          DEBUG_BUILD && debug.warn('Failed to send the in_progress cron check-in', e);
+        }
+
+        const finish = (status: 'ok' | 'error'): void => {
+          try {
+            finishCheckIn?.(status);
+          } catch (e) {
+            DEBUG_BUILD && debug.warn(`Failed to send the ${status} cron check-in`, e);
+          }
+        };
+
+        try {
+          const result = await fn();
+          finish('ok');
+          return result;
+        } catch (e) {
+          finish('error');
           captureException(e, { mechanism: { handled: false, type: 'auto.faas.cloudflare.scheduled' } });
           throw e;
         } finally {
diff --git a/packages/cloudflare/src/integrations/cronTriggers.ts b/packages/cloudflare/src/integrations/cronTriggers.ts
new file mode 100644
index 000000000000..289cfd18c849
--- /dev/null
+++ b/packages/cloudflare/src/integrations/cronTriggers.ts
@@ -0,0 +1,195 @@
+import type { IntegrationFn, MonitorConfig } from '@sentry/core';
+import { captureCheckIn, debug, defineIntegration, timestampInSeconds } from '@sentry/core';
+import { DEBUG_BUILD } from '../debug-build';
+
+const INTEGRATION_NAME = 'CronTriggers' as const;
+
+/**
+ * The monitor slug and settings for a Cron Trigger, see `cronTriggersIntegration`.
+ */
+export type CronTriggerMonitorSettings = { monitorSlug: string } & Omit<MonitorConfig, 'schedule' | 'timezone'>;
+
+export interface CronTriggersOptions {
+  /**
+   * Chooses the monitor slug for a cron expression. It can also return an object with the `monitorSlug`
+   * and other monitor settings, such as `checkinMargin` or `maxRuntime`. Returning `undefined`
+   * sends no check-ins for that trigger, and so does a function that throws.
+   */
+  monitorSlug?: (cron: string) => string | CronTriggerMonitorSettings | undefined;
+}
+
+/** @internal Used by the scheduled handler instrumentation. */
+export interface CronTriggersIntegration {
+  name: string;
+  startCheckIn(cron: string): ((status: 'ok' | 'error') => void) | undefined;
+}
+
+const SLUG_TOKENS: Record<string, string> = { ' ': '-', '*': 'x', ',': '_', '-': 'to', '/': 'by' };
+
+/**
+ * Derives a monitor slug from a cron expression, e.g. `30 9 * * MON-FRI` -> `cron-30-9-x-x-montofri`.
+ *
+ * A hash of the expression is appended when it has any other characters or the slug would be
+ * longer than 50 characters, so different expressions don't share a slug.
+ */
+function cronToMonitorSlug(cron: string): string {
+  const expression = cron.trim().toLowerCase().split(/\s+/).join(' ');
+  const slug = `cron-${expression.replace(/[ *,\-/]/g, char => SLUG_TOKENS[char] as string)}`;
+  if (/^[a-z0-9_-]{1,50}$/.test(slug)) {
+    return slug;
+  }
+
+  // A polynomial string hash modulo 2^31 - 1, at most 6 characters in base 36.
+  let hash = 0;
+  for (let i = 0; i < expression.length; i++) {
+    hash = (hash * 31 + expression.charCodeAt(i)) % 2147483647;
+  }
+  return `${slug.replace(/[^a-z0-9_-]+/g, '-').slice(0, 43)}-${hash.toString(36)}`;
+}
+
+const WEEKDAYS = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT'];
+
+// Cloudflare numbers weekdays from 1 = Sunday to 7 = Saturday. Returns -1 for anything else.
+function weekdayIndex(value: string): number {
+  return /^[1-7]$/.test(value) ? Number(value) - 1 : WEEKDAYS.indexOf(value.toUpperCase());
+}
+
+function convertWeekdayItem(item: string): string | undefined {
+  const match = item.match(/^(\*|\w+)(?:-(\w+))?(?:\/(\d+))?$/);
+  if (!match) {
+    return undefined;
+  }
+  const [, from, to, step] = match;
+  if (step && !(Number(step) > 0)) {
+    return undefined;
+  }
+
+  // `*` and `*/n` give the same days in both numberings, and keep their `*` meaning for Sentry.
+  if (from === '*') {
+    return to ? undefined : item;
+  }
+
+  const start = weekdayIndex(from as string);
+  // A step without an end runs to Saturday, so it is written as a range.
+  const end = to ? weekdayIndex(to) : step ? 6 : start;
+  if (start < 0 || end < start) {
+    return undefined;
+  }
+
+  // A step over a single day would run on to Sunday in Sentry's cron parser, so it is left out.
+  if (start === end) {
+    return WEEKDAYS[start];
+  }
+  const days = `${WEEKDAYS[start]}-${WEEKDAYS[end]}`;
+  return step ? `${days}/${step}` : days;
+}
+
+/**
+ * Converts a Cloudflare cron expression into a crontab Sentry accepts, which numbers weekdays from
+ * 0 = Sunday. Returns `undefined` if the day fields can't be converted.
+ */
+function cloudflareCronToCrontab(cron: string): string | undefined {
+  const fields = cron.trim().split(/\s+/);
+  const [, , dayOfMonth = '', , dayOfWeek = ''] = fields;
+  // Sentry rejects `W`, `?` and `L-n` in the day of month. When both day fields are set, Cloudflare and Sentry
+  // run on the days that match either field, but Sentry requires both to match when one starts with `*`.
+  if (
+    fields.length !== 5 ||
+    /[w?]|l-/i.test(dayOfMonth) ||
+    (dayOfMonth !== '*' && dayOfWeek !== '*' && (dayOfMonth.startsWith('*') || dayOfWeek.startsWith('*')))
+  ) {
+    return undefined;
+  }
+
+  const weekdays = dayOfWeek.split(',').map(convertWeekdayItem);
+  return weekdays.includes(undefined) ? undefined : [...fields.slice(0, 4), weekdays.join(',')].join(' ');
+}
+
+const _cronTriggersIntegration = ((options: CronTriggersOptions = {}): CronTriggersIntegration => {
+  return {
+    name: INTEGRATION_NAME,
+    startCheckIn(cron) {
+      // Manual runs, e.g. through `wrangler dev --test-scheduled`, can have no cron expression.
+      if (!cron) {
+        return undefined;
+      }
+
+      let monitor: string | CronTriggerMonitorSettings | undefined;
+      try {
+        monitor = options.monitorSlug ? options.monitorSlug(cron) : cronToMonitorSlug(cron);
+      } catch (e) {
+        DEBUG_BUILD && debug.warn(`[Cron Triggers] \`monitorSlug\` threw for "${cron}", sending no check-ins:`, e);
+        return undefined;
+      }
+
+      if (!monitor) {
+        return undefined;
+      }
+
+      const { monitorSlug, ...monitorSettings } = typeof monitor === 'string' ? { monitorSlug: monitor } : monitor;
+      if (!monitorSlug) {
+        return undefined;
+      }
+
+      const crontab = cloudflareCronToCrontab(cron);
+      if (!crontab) {
+        DEBUG_BUILD &&
+          debug.warn(
+            `[Cron Triggers] Can't convert "${cron}" to a Sentry schedule, sending check-ins without a schedule or the other monitor settings.`,
+          );
+      }
+
+      // Check-ins are captured directly rather than through `withMonitor`, which would fork the
+      // isolation scope and lose the invocation state attached to it.
+      const checkInId = captureCheckIn(
+        { monitorSlug, status: 'in_progress' },
+        crontab ? { ...monitorSettings, schedule: { type: 'crontab', value: crontab } } : undefined,
+      );
+      const startTime = timestampInSeconds();
+
+      return status => {
+        captureCheckIn({ monitorSlug, status, checkInId, duration: timestampInSeconds() - startTime });
+      };
+    },
+  };
+}) satisfies IntegrationFn;
+
+/**
+ * Sends cron check-ins for every Cron Trigger run of the `scheduled` handler, with the trigger's
+ * schedule, so Sentry creates the monitor on the first run.
+ *
+ * Cron Triggers have no names, so map each cron expression to a slug. Without `monitorSlug`, the slug is
+ * derived from the expression (`30 9 * * MON-FRI` becomes `cron-30-9-x-x-montofri`) and changes with it.
+ * Workers that send to the same project get the same slug for the same expression, so they share a monitor.
+ *
+ * @example
+ * ```ts
+ * // src/monitorSlugs.ts
+ * export const monitorSlugs: Record<string, string> = {
+ *   '30 9 * * MON-FRI': 'daily-report',
+ * };
+ *
+ * // src/instrument.server.ts
+ * import { cronTriggersIntegration, defineCloudflareOptions } from '@sentry/cloudflare';
+ * import { monitorSlugs } from './monitorSlugs';
+ *
+ * export default defineCloudflareOptions((env) => ({
+ *   dsn: env.SENTRY_DSN,
+ *   integrations: [cronTriggersIntegration({ monitorSlug: (cron) => monitorSlugs[cron] })],
+ * }));
+ *
+ * // src/index.ts
+ * import { monitorSlugs } from './monitorSlugs';
+ *
+ * export default {
+ *   async scheduled(controller, env) {
+ *     switch (monitorSlugs[controller.cron]) {
+ *       case 'daily-report':
+ *         // ...
+ *         break;
+ *     }
+ *   },
+ * };
+ * ```
+ */
+export const cronTriggersIntegration = defineIntegration(_cronTriggersIntegration);
diff --git a/packages/cloudflare/test/instrumentations/worker/instrumentScheduled.test.ts b/packages/cloudflare/test/instrumentations/worker/instrumentScheduled.test.ts
index 46090684daea..33649a188f06 100644
--- a/packages/cloudflare/test/instrumentations/worker/instrumentScheduled.test.ts
+++ b/packages/cloudflare/test/instrumentations/worker/instrumentScheduled.test.ts
@@ -2,10 +2,15 @@
 // Although this is not ideal, this is the best we can do until we have a better way to test cloudflare workers.
 
 import type { ExecutionContext, ScheduledController } from '@cloudflare/workers-types';
-import type { Event } from '@sentry/core';
+import type { Event, Integration } from '@sentry/core';
 import * as SentryCore from '@sentry/core';
 import { beforeEach, describe, expect, onTestFinished, test, vi } from 'vitest';
 import { CloudflareClient } from '../../../src/client';
+import {
+  instrumentWorkerEntrypoint,
+  type WorkerEntrypointConstructor,
+} from '../../../src/instrumentations/instrumentWorkerEntrypoint';
+import { cronTriggersIntegration } from '../../../src/integrations/cronTriggers';
 import { withSentry } from '../../../src/withSentry';
 import { resetSdk } from '../../testUtils';
 
@@ -302,6 +307,203 @@ describe('instrumentScheduled', () => {
     });
   });
 
+  describe('cron monitoring', () => {
+    function controllerFor(cron: string): ScheduledController {
+      return { scheduledTime: 123, cron, noRetry: vi.fn() };
+    }
+
+    async function runScheduled(
+      integrations: Integration[],
+      scheduled: ExportedHandler<typeof MOCK_ENV>['scheduled'] = () => {},
+    ): Promise<void> {
+      const wrappedHandler = withSentry(env => ({ dsn: env.SENTRY_DSN, integrations }), { scheduled });
+      await wrappedHandler.scheduled?.(controllerFor('30 9 * * 1-5'), MOCK_ENV, createMockExecutionContext());
+    }
+
+    test('sends no check-ins without the integration', async () => {
+      const captureCheckInSpy = vi.spyOn(SentryCore, 'captureCheckIn');
+
+      await runScheduled([]);
+
+      expect(captureCheckInSpy).not.toHaveBeenCalled();
+    });
+
+    test('sends check-ins with the cron schedule with the integration', async () => {
+      const captureCheckInSpy = vi.spyOn(SentryCore, 'captureCheckIn');
+
+      await runScheduled([cronTriggersIntegration()]);
+
+      expect(captureCheckInSpy).toHaveBeenCalledTimes(2);
+      expect(captureCheckInSpy).toHaveBeenNthCalledWith(
+        1,
+        { monitorSlug: 'cron-30-9-x-x-1to5', status: 'in_progress' },
+        { schedule: { type: 'crontab', value: '30 9 * * SUN-THU' } },
+      );
+      expect(captureCheckInSpy).toHaveBeenNthCalledWith(2, {
+        monitorSlug: 'cron-30-9-x-x-1to5',
+        status: 'ok',
+        checkInId: expect.any(String),
+        duration: expect.any(Number),
+      });
+    });
+
+    test('marks the check-in as failed when the handler throws', async () => {
+      const captureCheckInSpy = vi.spyOn(SentryCore, 'captureCheckIn');
+      const captureExceptionSpy = vi.spyOn(SentryCore, 'captureException');
+      const error = new Error('test');
+
+      await expect(
+        runScheduled([cronTriggersIntegration()], () => {
+          throw error;
+        }),
+      ).rejects.toThrow('test');
+
+      expect(captureCheckInSpy).toHaveBeenLastCalledWith(
+        expect.objectContaining({ status: 'error', duration: expect.any(Number) }),
+      );
+      expect(captureExceptionSpy).toHaveBeenCalledWith(error, {
+        mechanism: { handled: false, type: 'auto.faas.cloudflare.scheduled' },
+      });
+    });
+
+    test('marks the check-in as failed when the handler rejects', async () => {
+      const captureCheckInSpy = vi.spyOn(SentryCore, 'captureCheckIn');
+
+      await expect(
+        runScheduled([cronTriggersIntegration()], () => Promise.reject(new Error('rejected'))),
+      ).rejects.toThrow('rejected');
+
+      expect(captureCheckInSpy).toHaveBeenCalledTimes(2);
+      expect(captureCheckInSpy).toHaveBeenLastCalledWith(
+        expect.objectContaining({ monitorSlug: 'cron-30-9-x-x-1to5', status: 'error' }),
+      );
+    });
+
+    test('runs the handler without check-ins when the in_progress check-in throws', async () => {
+      const captureCheckInSpy = vi.spyOn(SentryCore, 'captureCheckIn').mockImplementation(() => {
+        throw new Error('check-in error');
+      });
+      onTestFinished(() => captureCheckInSpy.mockRestore());
+      const captureExceptionSpy = vi.spyOn(SentryCore, 'captureException');
+      const scheduled = vi.fn().mockResolvedValue('result');
+      const wrappedHandler = withSentry(env => ({ dsn: env.SENTRY_DSN, integrations: [cronTriggersIntegration()] }), {
+        scheduled,
+      } as ExportedHandler<typeof MOCK_ENV>);
+
+      const result = await wrappedHandler.scheduled?.(
+        controllerFor('30 9 * * 1-5'),
+        MOCK_ENV,
+        createMockExecutionContext(),
+      );
+
+      expect(result).toBe('result');
+      expect(scheduled).toHaveBeenCalledTimes(1);
+      expect(captureCheckInSpy).toHaveBeenCalledTimes(1);
+      expect(captureExceptionSpy).not.toHaveBeenCalled();
+    });
+
+    test('returns the handler result when the ok check-in throws', async () => {
+      const captureCheckInSpy = vi
+        .spyOn(SentryCore, 'captureCheckIn')
+        .mockReturnValueOnce('check-in-id')
+        .mockImplementationOnce(() => {
+          throw new Error('check-in error');
+        });
+      onTestFinished(() => captureCheckInSpy.mockRestore());
+      const captureExceptionSpy = vi.spyOn(SentryCore, 'captureException');
+      const wrappedHandler = withSentry(env => ({ dsn: env.SENTRY_DSN, integrations: [cronTriggersIntegration()] }), {
+        scheduled: () => Promise.resolve('result'),
+      } as unknown as ExportedHandler<typeof MOCK_ENV>);
+
+      const result = await wrappedHandler.scheduled?.(
+        controllerFor('30 9 * * 1-5'),
+        MOCK_ENV,
+        createMockExecutionContext(),
+      );
+
+      expect(result).toBe('result');
+      expect(captureExceptionSpy).not.toHaveBeenCalled();
+    });
+
+    test('sends check-ins for the scheduled method of a WorkerEntrypoint', async () => {
+      const captureCheckInSpy = vi.spyOn(SentryCore, 'captureCheckIn');
+      const TestEntrypoint = class {
+        scheduled() {}
+      };
+      const instrumented = instrumentWorkerEntrypoint(
+        () => ({ dsn: MOCK_ENV.SENTRY_DSN, integrations: [cronTriggersIntegration()] }),
+        TestEntrypoint as unknown as WorkerEntrypointConstructor,
+      );
+      const entrypoint = Reflect.construct(instrumented, [createMockExecutionContext(), MOCK_ENV]);
+
+      await entrypoint.scheduled(controllerFor('30 9 * * 1-5'));
+
+      expect(captureCheckInSpy).toHaveBeenCalledTimes(2);
+      expect(captureCheckInSpy).toHaveBeenNthCalledWith(
+        1,
+        { monitorSlug: 'cron-30-9-x-x-1to5', status: 'in_progress' },
+        { schedule: { type: 'crontab', value: '30 9 * * SUN-THU' } },
+      );
+      expect(captureCheckInSpy).toHaveBeenLastCalledWith(expect.objectContaining({ status: 'ok' }));
+    });
+
+    test('flushes both check-ins before the invocation ends', async () => {
+      const sentItemTypes: string[] = [];
+      const handler = {
+        scheduled() {},
+      } satisfies ExportedHandler<typeof MOCK_ENV>;
+      const wrappedHandler = withSentry(
+        env => ({
+          dsn: env.SENTRY_DSN,
+          cacheClient: false,
+          integrations: [cronTriggersIntegration()],
+          transport: () => ({
+            send: async envelope => {
+              sentItemTypes.push(...envelope[1].map(([itemHeader]) => itemHeader.type));
+              return {};
+            },
+            flush: async () => true,
+          }),
+        }),
+        handler,
+      );
+
+      const waits: Promise<unknown>[] = [];
+      await wrappedHandler.scheduled?.(controllerFor('30 9 * * 1-5'), MOCK_ENV, {
+        waitUntil: vi.fn(promise => waits.push(promise)),
+        passThroughOnException: vi.fn(),
+      } as unknown as ExecutionContext);
+      await Promise.all(waits);
+
+      expect(sentItemTypes.filter(type => type === 'check_in')).toHaveLength(2);
+    });
+
+    test('drains the transport for the in_progress check-in while the handler runs', async () => {
+      const transportFlush = vi.fn(async () => true);
+      let finishHandler: () => void = () => undefined;
+      const wrappedHandler = withSentry(
+        env => ({
+          dsn: env.SENTRY_DSN,
+          integrations: [cronTriggersIntegration()],
+          transport: () => ({ send: async () => ({}), flush: transportFlush }),
+        }),
+        {
+          scheduled: () =>
+            new Promise<void>(resolve => {
+              finishHandler = resolve;
+            }),
+        } satisfies ExportedHandler<typeof MOCK_ENV>,
+      );
+
+      const run = wrappedHandler.scheduled?.(controllerFor('30 9 * * 1-5'), MOCK_ENV, createMockExecutionContext());
+
+      expect(transportFlush).toHaveBeenCalledTimes(1);
+
+      finishHandler();
+      await run;
+    });
+  });
+
   test('flush must be called when all waitUntil are done', async () => {
     const flush = vi.spyOn(SentryCore.Client.prototype, 'flush');
     vi.useFakeTimers();
diff --git a/packages/cloudflare/test/integrations/cronTriggers.test.ts b/packages/cloudflare/test/integrations/cronTriggers.test.ts
new file mode 100644
index 000000000000..46f3fdb320e2
--- /dev/null
+++ b/packages/cloudflare/test/integrations/cronTriggers.test.ts
@@ -0,0 +1,198 @@
+import * as SentryCore from '@sentry/core';
+import { beforeEach, describe, expect, type MockInstance, test, vi } from 'vitest';
+import type { CronTriggersIntegration, CronTriggersOptions } from '../../src/integrations/cronTriggers';
+import { cronTriggersIntegration } from '../../src/integrations/cronTriggers';
+
+function startCheckIn(
+  cron: string,
+  options?: CronTriggersOptions,
+): ReturnType<CronTriggersIntegration['startCheckIn']> {
+  return (cronTriggersIntegration(options) as unknown as CronTriggersIntegration).startCheckIn(cron);
+}
+
+describe('cronTriggersIntegration', () => {
+  let captureCheckInSpy: MockInstance<typeof SentryCore.captureCheckIn>;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    captureCheckInSpy = vi.spyOn(SentryCore, 'captureCheckIn').mockReturnValue('check-in-id');
+  });
+
+  test('captures in_progress and then the final status with a duration', () => {
+    const finish = startCheckIn('30 9 * * 1-5');
+    finish?.('error');
+
+    expect(captureCheckInSpy).toHaveBeenCalledTimes(2);
+    expect(captureCheckInSpy).toHaveBeenNthCalledWith(
+      1,
+      { monitorSlug: 'cron-30-9-x-x-1to5', status: 'in_progress' },
+      { schedule: { type: 'crontab', value: '30 9 * * SUN-THU' } },
+    );
+    expect(captureCheckInSpy).toHaveBeenNthCalledWith(2, {
+      monitorSlug: 'cron-30-9-x-x-1to5',
+      status: 'error',
+      checkInId: 'check-in-id',
+      duration: expect.any(Number),
+    });
+  });
+
+  test('uses the slug returned by the monitorSlug function', () => {
+    const monitorSlug = vi.fn().mockReturnValue('weekday-report');
+
+    startCheckIn('30 9 * * MON-FRI', { monitorSlug });
+
+    expect(monitorSlug).toHaveBeenCalledWith('30 9 * * MON-FRI');
+    expect(captureCheckInSpy).toHaveBeenCalledWith(
+      { monitorSlug: 'weekday-report', status: 'in_progress' },
+      { schedule: { type: 'crontab', value: '30 9 * * MON-FRI' } },
+    );
+  });
+
+  test('sends the monitor settings returned by the monitorSlug function', () => {
+    startCheckIn('0 0 * * *', {
+      monitorSlug: () => ({ monitorSlug: 'nightly', checkinMargin: 5, maxRuntime: 30 }),
+    });
+
+    expect(captureCheckInSpy).toHaveBeenCalledWith(
+      { monitorSlug: 'nightly', status: 'in_progress' },
+      { schedule: { type: 'crontab', value: '0 0 * * *' }, checkinMargin: 5, maxRuntime: 30 },
+    );
+  });
+
+  test('sends no check-ins when the monitorSlug function returns undefined', () => {
+    expect(startCheckIn('0 0 * * *', { monitorSlug: () => undefined })).toBeUndefined();
+    expect(captureCheckInSpy).not.toHaveBeenCalled();
+  });
+
+  test('sends no check-ins and warns when the monitorSlug function throws', () => {
+    const warnSpy = vi.spyOn(SentryCore.debug, 'warn').mockImplementation(() => undefined);
+    const monitorSlug = (): string => {
+      throw new Error('slug error');
+    };
+
+    expect(startCheckIn('0 0 * * *', { monitorSlug })).toBeUndefined();
+    expect(captureCheckInSpy).not.toHaveBeenCalled();
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('`monitorSlug` threw'), expect.any(Error));
+  });
+
+  test('sends no check-ins for a run without a cron expression', () => {
+    expect(startCheckIn('')).toBeUndefined();
+    expect(captureCheckInSpy).not.toHaveBeenCalled();
+  });
+
+  test.each([
+    ['1', 'SUN'],
+    ['7', 'SAT'],
+    ['2,4,6', 'MON,WED,FRI'],
+    ['2-6', 'MON-FRI'],
+    ['1-7/2', 'SUN-SAT/2'],
+    ['2/3', 'MON-SAT/3'],
+    ['7/1', 'SAT'],
+    ['3-3/2', 'TUE'],
+    ['*/2', '*/2'],
+    ['*', '*'],
+    ['mon-fri', 'MON-FRI'],
+    ['SAT,1', 'SAT,SUN'],
+  ])('converts the weekday field %s to %s', (weekdays, expected) => {
+    startCheckIn(`0 9 * * ${weekdays}`);
+
+    expect(captureCheckInSpy).toHaveBeenCalledWith(expect.objectContaining({ status: 'in_progress' }), {
+      schedule: { type: 'crontab', value: `0 9 * * ${expected}` },
+    });
+  });
+
+  test.each([['0'], ['8'], ['6-2'], ['L'], ['6L'], ['6#2'], ['?'], ['1-*'], ['2/0']])(
+    'sends check-ins without a schedule for the weekday field %s',
+    weekdays => {
+      const warnSpy = vi.spyOn(SentryCore.debug, 'warn').mockImplementation(() => undefined);
+
+      startCheckIn(`0 9 * * ${weekdays}`);
+
+      expect(captureCheckInSpy).toHaveBeenCalledWith(expect.objectContaining({ status: 'in_progress' }), undefined);
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("Can't convert"));
+    },
+  );
+
+  test.each([['15W'], ['LW'], ['L-3'], ['L-3W'], ['?']])(
+    'sends check-ins without a schedule for the day of month %s',
+    dayOfMonth => {
+      startCheckIn(`0 9 ${dayOfMonth} * *`);
+
+      expect(captureCheckInSpy).toHaveBeenCalledWith(expect.objectContaining({ status: 'in_progress' }), undefined);
+    },
+  );
+
+  test('sends the last day of the month as L', () => {
+    startCheckIn('0 9 L * *');
+
+    expect(captureCheckInSpy).toHaveBeenCalledWith(expect.objectContaining({ status: 'in_progress' }), {
+      schedule: { type: 'crontab', value: '0 9 L * *' },
+    });
+  });
+
+  test.each([
+    ['0 9 1 * MON', '0 9 1 * MON'],
+    ['0 9 1-7 * 2', '0 9 1-7 * MON'],
+    ['0 9 1,15 * 2-6', '0 9 1,15 * MON-FRI'],
+  ])('sends the schedule %s as %s when both day fields are set', (cron, expected) => {
+    startCheckIn(cron);
+
+    expect(captureCheckInSpy).toHaveBeenCalledWith(expect.objectContaining({ status: 'in_progress' }), {
+      schedule: { type: 'crontab', value: expected },
+    });
+  });
+
+  test.each([['0 9 */2 * MON'], ['0 9 1 * */2']])(
+    'sends check-ins without a schedule when both day fields are set and one starts with * in %s',
+    cron => {
+      startCheckIn(cron);
+
+      expect(captureCheckInSpy).toHaveBeenCalledWith(expect.objectContaining({ status: 'in_progress' }), undefined);
+    },
+  );
+
+  test('sends check-ins without a schedule for an expression without five fields', () => {
+    startCheckIn('0 0 9 * * *');
+
+    expect(captureCheckInSpy).toHaveBeenCalledWith(expect.objectContaining({ status: 'in_progress' }), undefined);
+  });
+
+  test.each([
+    ['0 9 * * 1,5', 'cron-0-9-x-x-1_5'],
+    ['0 9 * * 1-5', 'cron-0-9-x-x-1to5'],
+    ['0 9 * * 1/5', 'cron-0-9-x-x-1by5'],
+    ['*/15 * * * *', 'cron-xby15-x-x-x-x'],
+    ['0  9 * * MON', 'cron-0-9-x-x-mon'],
+    ['30 9 * * MON-FRI', 'cron-30-9-x-x-montofri'],
+  ])('derives the slug for %s as %s', (cron, slug) => {
+    startCheckIn(cron);
+
+    expect(captureCheckInSpy).toHaveBeenCalledWith({ monitorSlug: slug, status: 'in_progress' }, expect.anything());
+  });
+
+  test('appends a hash to the slug of an expression with other characters', () => {
+    startCheckIn('0 9 * * 1#5');
+
+    expect(captureCheckInSpy).toHaveBeenCalledWith(
+      { monitorSlug: expect.stringMatching(/^cron-0-9-x-x-1-5-[a-z0-9]{1,6}$/), status: 'in_progress' },
+      undefined,
+    );
+  });
+
+  test('shortens long slugs and appends a hash', () => {
+    const slugs: string[] = [];
+    captureCheckInSpy.mockImplementation(checkIn => {
+      slugs.push(checkIn.monitorSlug);
+      return 'check-in-id';
+    });
+    const minutes = Array.from({ length: 30 }, (_, i) => i).join(',');
+
+    startCheckIn(`${minutes} * * * *`);
+    startCheckIn(`${minutes},59 * * * *`);
+
+    expect(slugs).toHaveLength(2);
+    expect(slugs[0]).toMatch(/^cron-0_1_2_.*-[a-z0-9]{1,6}$/);
+    expect(slugs[0]?.length).toBeLessThanOrEqual(50);
+    expect(slugs[1]).not.toBe(slugs[0]);
+  });
+});

From 7fa421adb5c4b8c6eddc87ce31e9cbd7ceaef104 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 21:02:03 +0200
Subject: [PATCH 45/84] test(node): Port trace context tests to span streaming
 (#25218)

Exercise trace continuation, fresh traces, request isolation, and
emitter context binding with the default streaming lifecycle. The
recycling test uses span collectors because its existing in-request
flush sends children before the request segment.

Part of #24140

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../public-api/bindScopeToEmitter/scenario.ts |  1 -
 .../public-api/bindScopeToEmitter/test.ts     | 59 +++++++++----------
 .../tracing/continueTrace/instrument.mjs      |  3 +-
 .../suites/tracing/continueTrace/scenario.mjs |  3 +-
 .../suites/tracing/continueTrace/test.ts      | 30 +++++-----
 .../tracing/startNewTrace/instrument.mjs      |  1 -
 .../suites/tracing/startNewTrace/test.ts      |  4 +-
 .../instrument.cjs                            |  1 -
 .../traceid-recycling-with-spans/server.js    |  4 +-
 .../traceid-recycling-with-spans/test.ts      | 50 ++++++++--------
 .../tracing/traceid-recycling/server.ts       |  1 -
 11 files changed, 74 insertions(+), 83 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/public-api/bindScopeToEmitter/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/bindScopeToEmitter/scenario.ts
index 5258dc9fb85e..a4a256d3171d 100644
--- a/dev-packages/node-integration-tests/suites/public-api/bindScopeToEmitter/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/bindScopeToEmitter/scenario.ts
@@ -4,7 +4,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/public-api/bindScopeToEmitter/test.ts b/dev-packages/node-integration-tests/suites/public-api/bindScopeToEmitter/test.ts
index 165eb6cc5fd8..d59909dfbea4 100644
--- a/dev-packages/node-integration-tests/suites/public-api/bindScopeToEmitter/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/bindScopeToEmitter/test.ts
@@ -1,4 +1,4 @@
-import type { TransactionEvent } from '@sentry/core';
+import { SENTRY_SEGMENT_ID } from '@sentry/conventions/attributes';
 import { afterAll, expect, test } from 'vitest';
 import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
 
@@ -7,36 +7,35 @@ afterAll(() => {
 });
 
 test('bindScopeToEmitter preserves the active span for listeners firing in a different async context', async () => {
-  // Collect both transactions regardless of the order they are flushed in.
-  const transactions: Record<string, TransactionEvent> = {};
-  const collect = (event: TransactionEvent): void => {
-    transactions[event.transaction as string] = event;
-  };
-
   await createRunner(__dirname, 'scenario.ts')
-    .expect({ transaction: collect })
-    .expect({ transaction: collect })
+    .expect({
+      span: container => {
+        const parent = container.items.find(span => span.name === 'parent');
+        const childUnbound = container.items.find(span => span.name === 'child-unbound');
+
+        expect(parent?.is_segment).toBe(true);
+        expect(childUnbound?.is_segment).toBe(true);
+
+        const parentTraceId = parent?.trace_id;
+        const parentSpanId = parent?.span_id;
+
+        // The bound emitter's listener ran inside the parent span context -> nested child span.
+        const childBound = container.items.find(span => span.name === 'child-bound');
+        expect(childBound?.is_segment).toBe(false);
+        expect(childBound?.parent_span_id).toBe(parentSpanId);
+        expect(childBound?.trace_id).toBe(parentTraceId);
+
+        // The unbound emitter's listener ran without the parent active -> its own root span,
+        // not nested under the parent span. It still shares the isolation scope's propagation context
+        // trace, matching the core SDK behavior for root spans.
+        expect(
+          container.items.filter(
+            span => !span.is_segment && span.attributes[SENTRY_SEGMENT_ID]?.value === childUnbound?.span_id,
+          ),
+        ).toEqual([]);
+        expect(childUnbound?.parent_span_id).toBeUndefined();
+      },
+    })
     .start()
     .completed();
-
-  const parent = transactions['parent'];
-  const childUnbound = transactions['child-unbound'];
-
-  expect(parent).toBeDefined();
-  expect(childUnbound).toBeDefined();
-
-  const parentTraceId = parent?.contexts?.trace?.trace_id;
-  const parentSpanId = parent?.contexts?.trace?.span_id;
-
-  // The bound emitter's listener ran inside the parent span context -> nested child span.
-  const childBound = parent?.spans?.find(span => span.description === 'child-bound');
-  expect(childBound).toBeDefined();
-  expect(childBound?.parent_span_id).toBe(parentSpanId);
-  expect(childBound?.trace_id).toBe(parentTraceId);
-
-  // The unbound emitter's listener ran without the parent active -> its own root transaction,
-  // not nested under the parent span. It still shares the isolation scope's propagation context
-  // trace, matching the core SDK behavior for root spans.
-  expect(childUnbound?.spans).toEqual([]);
-  expect(childUnbound?.contexts?.trace?.parent_span_id).toBeUndefined();
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/continueTrace/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/continueTrace/instrument.mjs
index 286cca321ab6..b45f2ba5b2b3 100644
--- a/dev-packages/node-integration-tests/suites/tracing/continueTrace/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/continueTrace/instrument.mjs
@@ -6,7 +6,6 @@ import { loggingTransport } from '@sentry-internal/node-integration-tests';
 const tracesSampleRate = process.env.TRACES_SAMPLE_RATE;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   ...(tracesSampleRate !== undefined ? { tracesSampleRate: Number(tracesSampleRate) } : {}),
@@ -14,7 +13,7 @@ Sentry.init({
   transport: loggingTransport,
   // Stash the outgoing propagation data as observed inside the continueTrace callback onto every
   // error event, so we can assert on it uniformly across all sampling configs (even when no
-  // transaction is emitted).
+  // span is emitted).
   beforeSend(event) {
     event.contexts = {
       ...event.contexts,
diff --git a/dev-packages/node-integration-tests/suites/tracing/continueTrace/scenario.mjs b/dev-packages/node-integration-tests/suites/tracing/continueTrace/scenario.mjs
index 1badd4ec54cd..e0f0845f30e7 100644
--- a/dev-packages/node-integration-tests/suites/tracing/continueTrace/scenario.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/continueTrace/scenario.mjs
@@ -7,8 +7,7 @@ const baggage = process.env.INCOMING_BAGGAGE || undefined;
 
 Sentry.continueTrace({ sentryTrace, baggage }, () => {
   Sentry.startSpan({ name: 'continued-root-span' }, () => {
-    // Captured while the root span is active. The error is emitted before the span ends, so the
-    // error envelope always precedes the transaction envelope (ordered assertions rely on this).
+    // Capture while the root span is active so the error carries its trace context.
     Sentry.captureException(new Error('continued-trace-error'));
   });
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/continueTrace/test.ts b/dev-packages/node-integration-tests/suites/tracing/continueTrace/test.ts
index 81c56c61af14..aba1bdda43b7 100644
--- a/dev-packages/node-integration-tests/suites/tracing/continueTrace/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/continueTrace/test.ts
@@ -72,7 +72,7 @@ const CONFIGS: { name: string; rate?: string }[] = [
  * - incoming parentSampled true/false -> overrides local rate.
  * - deferred/none -> local tracesSampleRate decides.
  */
-function expectsTransaction(rate: string | undefined, variant: Variant): boolean {
+function expectsSpan(rate: string | undefined, variant: Variant): boolean {
   if (rate === undefined) return false; // TwP: span recording disabled
   if (variant.parentSampled === true) return true; // positive parent decision wins
   if (variant.parentSampled === false) return false; // negative parent decision wins
@@ -87,7 +87,7 @@ describe('continueTrace', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     describe.each(CONFIGS)('$name', config => {
       test.each(VARIANTS)('continues the $key', async variant => {
-        const wantsTransaction = expectsTransaction(config.rate, variant);
+        const wantsSpan = expectsSpan(config.rate, variant);
 
         const runner = createRunner().withEnv({
           TRACES_SAMPLE_RATE: config.rate,
@@ -96,10 +96,10 @@ describe('continueTrace', () => {
         });
 
         let observedErrorTraceId: string | undefined;
-        let observedTxTraceId: string | undefined;
+        let observedSpanTraceId: string | undefined;
 
         // The error event is delayed by async enrichment (context lines, local variables) while the
-        // transaction flushes synchronously on span end, so the two envelopes can arrive in either
+        // span buffer flushes after span end, so the two envelopes can arrive in either
         // order. Match them by type rather than by position.
         runner.unordered();
 
@@ -124,30 +124,30 @@ describe('continueTrace', () => {
           },
         });
 
-        if (wantsTransaction) {
+        if (wantsSpan) {
           runner.expect({
-            transaction: transaction => {
-              const trace = transaction.contexts?.trace;
-              observedTxTraceId = trace?.trace_id;
+            span: container => {
+              const segment = container.items.find(span => span.is_segment);
+              observedSpanTraceId = segment?.trace_id;
 
               if (variant.traceId) {
-                expect(trace?.trace_id).toBe(variant.traceId);
+                expect(segment?.trace_id).toBe(variant.traceId);
               } else {
-                expect(trace?.trace_id).toMatch(/^[a-f0-9]{32}$/);
+                expect(segment?.trace_id).toMatch(/^[a-f0-9]{32}$/);
               }
               if (variant.parentSpanId) {
-                expect(trace?.parent_span_id).toBe(variant.parentSpanId);
+                expect(segment?.parent_span_id).toBe(variant.parentSpanId);
               }
-              expect(transaction.transaction).toBe('continued-root-span');
+              expect(segment?.name).toBe('continued-root-span');
             },
           });
         }
 
         await runner.start().completed();
 
-        if (wantsTransaction) {
-          // Error and transaction share the (continued or freshly generated) trace id.
-          expect(observedTxTraceId).toBe(observedErrorTraceId);
+        if (wantsSpan) {
+          // Error and span share the (continued or freshly generated) trace id.
+          expect(observedSpanTraceId).toBe(observedErrorTraceId);
         }
       });
     });
diff --git a/dev-packages/node-integration-tests/suites/tracing/startNewTrace/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/startNewTrace/instrument.mjs
index bf46e3f7af39..51f41678c3b3 100644
--- a/dev-packages/node-integration-tests/suites/tracing/startNewTrace/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/startNewTrace/instrument.mjs
@@ -6,7 +6,6 @@ import { loggingTransport } from '@sentry-internal/node-integration-tests';
 const tracesSampleRate = process.env.TRACES_SAMPLE_RATE;
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   ...(tracesSampleRate !== undefined ? { tracesSampleRate: Number(tracesSampleRate) } : {}),
diff --git a/dev-packages/node-integration-tests/suites/tracing/startNewTrace/test.ts b/dev-packages/node-integration-tests/suites/tracing/startNewTrace/test.ts
index 35eaed30c0dc..303fc28464f0 100644
--- a/dev-packages/node-integration-tests/suites/tracing/startNewTrace/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/startNewTrace/test.ts
@@ -16,9 +16,9 @@ describe('startNewTrace', () => {
     test.each(CONFIGS)('starts a fresh trace shared by every root span in the callback [%s]', async (_name, rate) => {
       await createRunner()
         .withEnv({ TRACES_SAMPLE_RATE: rate })
-        // Transactions (if any, in rate=1) are irrelevant here and their ordering vs. the error is
+        // Spans (if any, in rate=1) are irrelevant here and their ordering vs. the error is
         // not deterministic, so we ignore them and rely entirely on the stashed error context.
-        .ignore('transaction')
+        .ignore('span')
         .expect({
           event: event => {
             const trace = event.contexts?.trace;
diff --git a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/instrument.cjs b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/instrument.cjs
index 8a06ee49c873..1f8467691127 100644
--- a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/instrument.cjs
+++ b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/instrument.cjs
@@ -2,7 +2,6 @@ const Sentry = require('@sentry/node');
 const { loggingTransport } = require('@sentry-internal/node-integration-tests');
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   transport: loggingTransport,
diff --git a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/server.js b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/server.js
index 3ecc21e50159..e99b0a1d46cf 100644
--- a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/server.js
+++ b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/server.js
@@ -6,8 +6,8 @@ const app = express();
 
 app.get('/test', async (_req, res) => {
   Sentry.captureException(new Error('test error'));
-  // calling Sentry.flush() here to ensure that the order in which we send transaction and errors
-  // is guaranteed to be 1. error, 2. transaction (repeated 3x in test)
+  // calling Sentry.flush() here to ensure that the order in which we send root spans and errors
+  // is guaranteed to be 1. error, 2. root span (repeated 3x in test)
   await Sentry.flush();
   res.json({ success: true });
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/test.ts b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/test.ts
index 4706ce877361..5b046f933602 100644
--- a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling-with-spans/test.ts
@@ -6,9 +6,8 @@ afterAll(() => {
   cleanupChildProcesses();
 });
 
-test('errors and transactions get a unique traceId per request, when tracing is enabled', async () => {
+test('errors and spans get a unique traceId per request, when tracing is enabled', async () => {
   const eventTraceIds: string[] = [];
-  const transactionTraceIds: string[] = [];
 
   const runner = createRunner(__dirname, 'server.js')
     .withFlags('--import', join(__dirname, 'instrument.cjs'))
@@ -17,43 +16,42 @@ test('errors and transactions get a unique traceId per request, when tracing is
         eventTraceIds.push(event.contexts?.trace?.trace_id || '');
       },
     })
-    .expect({
-      transaction: transaction => {
-        transactionTraceIds.push(transaction.spans?.[0]?.trace_id || '');
-      },
-    })
     .expect({
       event: event => {
         eventTraceIds.push(event.contexts?.trace?.trace_id || '');
       },
     })
-    .expect({
-      transaction: transaction => {
-        transactionTraceIds.push(transaction.spans?.[0]?.trace_id || '');
-      },
-    })
     .expect({
       event: event => {
         eventTraceIds.push(event.contexts?.trace?.trace_id || '');
       },
-    })
-    .expect({
-      transaction: transaction => {
-        transactionTraceIds.push(transaction.spans?.[0]?.trace_id || '');
-      },
-    })
-    .start();
+    });
+
+  const seenSegmentIds = new Set<string>();
+  const spansPromises = Array.from({ length: 3 }, () =>
+    runner.collectStreamedSpansUntilSegment(segment => {
+      if (seenSegmentIds.has(segment.span_id)) return false;
+      seenSegmentIds.add(segment.span_id);
+      return true;
+    }),
+  );
+
+  const started = runner.start();
+
+  await started.makeRequest('get', '/test');
+  await started.makeRequest('get', '/test');
+  await started.makeRequest('get', '/test');
 
-  await runner.makeRequest('get', '/test');
-  await runner.makeRequest('get', '/test');
-  await runner.makeRequest('get', '/test');
+  await started.completed();
 
-  await runner.completed();
+  const spanTraceIds = (await Promise.all(spansPromises)).map(
+    spans => spans.find(span => !span.is_segment)?.trace_id || '',
+  );
 
-  expect(new Set(transactionTraceIds).size).toBe(3);
-  for (const traceId of transactionTraceIds) {
+  expect(new Set(spanTraceIds).size).toBe(3);
+  for (const traceId of spanTraceIds) {
     expect(traceId).toMatch(/^[a-f\d]{32}$/);
   }
 
-  expect(eventTraceIds.sort()).toEqual(transactionTraceIds.sort());
+  expect(eventTraceIds.sort()).toEqual(spanTraceIds.sort());
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling/server.ts b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling/server.ts
index d9b232f2ccc9..cc1347eeee86 100644
--- a/dev-packages/node-integration-tests/suites/tracing/traceid-recycling/server.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/traceid-recycling/server.ts
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport, startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   transport: loggingTransport,

From 2fd42baf88a94d2f7e5dc151bddd68a5348d4557 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 21:02:24 +0200
Subject: [PATCH 46/84] test(node): Port Postgres integration tests to span
 streaming (#25140)

Port Postgres and Postgres.js tests to default span streaming,
preserving assertions and folding in their streaming counterparts.

Closes #24137

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../node-suites/excludes.ts                   |   2 -
 .../postgres-streamed/docker-compose.yml      |  18 -
 .../instrument-ignoreConnect.mjs              |  11 -
 .../tracing/postgres-streamed/instrument.mjs  |  10 -
 .../postgres-streamed/scenario-native.mjs     |  47 --
 .../tracing/postgres-streamed/scenario.mjs    |  41 -
 .../suites/tracing/postgres-streamed/test.ts  | 283 -------
 .../postgres/instrument-ignoreConnect.mjs     |   1 -
 .../instrument-orchestrion-ignoreConnect.mjs  |   1 -
 .../postgres/instrument-orchestrion.mjs       |   1 -
 .../suites/tracing/postgres/instrument.mjs    |   1 -
 .../suites/tracing/postgres/test.ts           | 795 +++++++++++-------
 .../postgresjs-streamed/docker-compose.yml    |  18 -
 .../instrument-requestHook.mjs                |  26 -
 .../postgresjs-streamed/instrument.mjs        |   9 -
 .../scenario-requestHook.mjs                  |  39 -
 .../postgresjs-streamed/scenario-unsafe.mjs   |  37 -
 .../postgresjs-streamed/scenario-url.mjs      |  75 --
 .../tracing/postgresjs-streamed/scenario.mjs  |  74 --
 .../tracing/postgresjs-streamed/test.ts       | 325 -------
 .../postgresjs/instrument-requestHook.mjs     |  16 +-
 .../suites/tracing/postgresjs/instrument.mjs  |   1 -
 .../suites/tracing/postgresjs/test.ts         | 673 ++++++++-------
 23 files changed, 882 insertions(+), 1622 deletions(-)
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgres-streamed/docker-compose.yml
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgres-streamed/instrument-ignoreConnect.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgres-streamed/instrument.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgres-streamed/scenario-native.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgres-streamed/scenario.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgres-streamed/test.ts
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/docker-compose.yml
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/instrument-requestHook.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/instrument.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-requestHook.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-unsafe.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-url.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario.mjs
 delete mode 100644 dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/test.ts

diff --git a/dev-packages/bun-integration-tests/node-suites/excludes.ts b/dev-packages/bun-integration-tests/node-suites/excludes.ts
index 7eea10e62c6f..a883dbf49870 100644
--- a/dev-packages/bun-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/bun-integration-tests/node-suites/excludes.ts
@@ -126,9 +126,7 @@ export const NO_AUTO_INSTRUMENTATION = [
   'suites/tracing/openai/v7/test.ts',
   'suites/tracing/orchestrion-lazy-registration/test.ts',
   'suites/tracing/pi-durable/test.ts',
-  'suites/tracing/postgres-streamed/test.ts',
   'suites/tracing/postgres/test.ts',
-  'suites/tracing/postgresjs-streamed/test.ts',
   'suites/tracing/postgresjs/test.ts',
   'suites/tracing/prisma-orm-v5/test.ts',
   'suites/tracing/prisma-orm-v6/test.ts',
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/docker-compose.yml b/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/docker-compose.yml
deleted file mode 100644
index 05eebd27e0f0..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/docker-compose.yml
+++ /dev/null
@@ -1,18 +0,0 @@
-version: '3.9'
-
-services:
-  db:
-    image: postgres:13
-    restart: always
-    ports:
-      - '5495:5432'
-    environment:
-      POSTGRES_USER: test
-      POSTGRES_PASSWORD: test
-      POSTGRES_DB: tests
-    healthcheck:
-      test: ['CMD-SHELL', 'pg_isready -U test -d tests']
-      interval: 2s
-      timeout: 3s
-      retries: 30
-      start_period: 5s
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/instrument-ignoreConnect.mjs b/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/instrument-ignoreConnect.mjs
deleted file mode 100644
index fbf2369478ca..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/instrument-ignoreConnect.mjs
+++ /dev/null
@@ -1,11 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  integrations: [Sentry.postgresIntegration({ ignoreConnectSpans: true })],
-  transport: loggingTransport,
-  traceLifecycle: 'stream',
-});
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/instrument.mjs
deleted file mode 100644
index 53b9511a21f0..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/instrument.mjs
+++ /dev/null
@@ -1,10 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  transport: loggingTransport,
-  traceLifecycle: 'stream',
-});
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/scenario-native.mjs b/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/scenario-native.mjs
deleted file mode 100644
index bb229c2eb729..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/scenario-native.mjs
+++ /dev/null
@@ -1,47 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { uuid4 } from '@sentry/core';
-import { waitForConnection } from '@sentry-internal/node-integration-tests';
-import pg from 'pg';
-
-const { native } = pg;
-const { Client } = native;
-
-// `pg-native` uses libpq, which resolves `localhost` to IPv6 (`::1`) first and does not
-// fall back to IPv4. Docker Desktop only forwards the mapped port over IPv4, so we connect
-// to the IPv4 loopback explicitly to avoid an `ECONNREFUSED` on `::1`.
-const connectionConfig = { host: '127.0.0.1', port: 5495, user: 'test', password: 'test', database: 'tests' };
-const client = new Client(connectionConfig);
-
-async function run() {
-  // Gate on the DB actually accepting a connection before opening the span (see `waitForConnection`).
-  await waitForConnection(async () => {
-    const probe = new Client(connectionConfig);
-    await probe.connect();
-    await probe.end();
-  });
-
-  await Sentry.startSpan(
-    {
-      name: 'Test Span',
-      op: 'parent_span',
-    },
-    async () => {
-      try {
-        await client.connect();
-
-        await client.query(
-          'CREATE TABLE "NativeUser" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"));',
-        );
-
-        const email = `${uuid4()}@domain.com`;
-        await client.query('INSERT INTO "NativeUser" ("email", "name") VALUES ($1, $2)', [email, 'tim']);
-        await client.query('SELECT * FROM "NativeUser"');
-      } finally {
-        await client.query('DROP TABLE "NativeUser"');
-        await client.end();
-      }
-    },
-  );
-}
-
-run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/scenario.mjs b/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/scenario.mjs
deleted file mode 100644
index 81b9e08f910c..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/scenario.mjs
+++ /dev/null
@@ -1,41 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { uuid4 } from '@sentry/core';
-import { waitForConnection } from '@sentry-internal/node-integration-tests';
-import { Client } from 'pg';
-
-const connectionConfig = { port: 5495, user: 'test', password: 'test', database: 'tests' };
-const client = new Client(connectionConfig);
-
-async function run() {
-  // Gate on the DB actually accepting a connection before opening the span (see `waitForConnection`).
-  await waitForConnection(async () => {
-    const probe = new Client(connectionConfig);
-    await probe.connect();
-    await probe.end();
-  });
-
-  await Sentry.startSpan(
-    {
-      name: 'Test Span',
-      op: 'parent_span',
-    },
-    async () => {
-      try {
-        await client.connect();
-
-        await client.query(
-          'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"));',
-        );
-
-        const email = `${uuid4()}@domain.com`;
-        await client.query('INSERT INTO "User" ("email", "name") VALUES ($1, $2)', [email, 'tim']);
-        await client.query('SELECT * FROM "User"');
-      } finally {
-        await client.query('DROP TABLE "User"');
-        await client.end();
-      }
-    },
-  );
-}
-
-run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/test.ts b/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/test.ts
deleted file mode 100644
index bec779c70b02..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgres-streamed/test.ts
+++ /dev/null
@@ -1,283 +0,0 @@
-import type { SerializedStreamedSpanContainer } from '@sentry/core';
-import { SENTRY_TRACE_LIFECYCLE, SENTRY_OP } from '@sentry/conventions/attributes';
-import { afterAll, describe, expect } from 'vitest';
-import { conditionalTest, EXPECTED_SDK_NAME } from '../../../utils';
-import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
-
-// Query-span origin depends on which instrumentation is active. Blocks driving the SDK's default
-// integrations get the diagnostics-channel origin when the generic orchestrion run is enabled (via
-// INJECT_ORCHESTRION), since the OTel `Postgres` integration is then swapped for the channel one. Blocks
-// that pass an explicit `postgresIntegration()` (e.g. `ignoreConnectSpans`) keep the OTel origin.
-const QUERY_ORIGIN = 'auto.db.postgres';
-
-const COMMON_DB_ATTRIBUTES = {
-  'sentry.is_localhost': {
-    type: 'boolean',
-    value: false,
-  },
-  'db.connection_string': {
-    type: 'string',
-    value: expect.stringMatching(/^postgresql:\/\/localhost:\d+\/tests$/),
-  },
-  'db.namespace': {
-    type: 'string',
-    value: 'tests',
-  },
-  'db.system.name': {
-    type: 'string',
-    value: 'postgresql',
-  },
-  'db.user': {
-    type: 'string',
-    value: 'test',
-  },
-  'server.address': {
-    type: 'string',
-    value: 'localhost',
-  },
-  'server.port': {
-    type: 'integer',
-    value: expect.any(Number),
-  },
-  'sentry.kind': {
-    type: 'string',
-    value: 'client',
-  },
-  'sentry.environment': {
-    type: 'string',
-    value: 'production',
-  },
-  'sentry.op': {
-    type: 'string',
-    value: 'db',
-  },
-  'sentry.release': {
-    type: 'string',
-    value: '1.0',
-  },
-  'sentry.sdk.name': {
-    type: 'string',
-    value: EXPECTED_SDK_NAME,
-  },
-  'sentry.sdk.version': {
-    type: 'string',
-    value: expect.any(String),
-  },
-  'sentry.segment.id': {
-    type: 'string',
-    value: expect.stringMatching(/^[\da-f]{16}$/),
-  },
-  'sentry.segment.name': {
-    type: 'string',
-    value: 'Test Span',
-  },
-  [SENTRY_TRACE_LIFECYCLE]: {
-    type: 'string',
-    value: 'stream',
-  },
-};
-
-/**
- * Builds the expected strict shape of a streamed postgres db span.
- *
- * Query spans carry a `db.statement` and the query origin (`auto.db.postgres`, or
- * `auto.db.postgres` under the generic orchestrion run — see `QUERY_ORIGIN`). The
- * `pg.connect` span has no `db.statement`, and since the pg instrumentation sets no origin on it, it
- * carries the default `manual` origin (written as an attribute on the streamed-span path; the
- * non-streamed/SDK path omits the `manual` default).
- *
- * `host` defaults to `localhost`, but the `pg-native` scenarios connect to the IPv4 loopback
- * (`127.0.0.1`) explicitly, so the reported peer name and connection string reflect that.
- *
- * `origin` defaults to `QUERY_ORIGIN`; blocks that force the OTel path (explicit `postgresIntegration()`)
- * pass `auto.db.postgres` explicitly.
- */
-function expectedDbSpan({
-  name,
-  statement,
-  host = 'localhost',
-  origin = QUERY_ORIGIN,
-}: {
-  name: string;
-  statement?: string;
-  host?: string;
-  origin?: string;
-}): unknown {
-  const attributes: Record<string, unknown> = {
-    ...COMMON_DB_ATTRIBUTES,
-    'server.address': {
-      type: 'string',
-      value: host,
-    },
-    'db.connection_string': {
-      type: 'string',
-      value: expect.stringMatching(new RegExp(`^postgresql://${host.replace(/\./g, '\\.')}:\\d+/tests$`)),
-    },
-  };
-
-  if (statement) {
-    attributes['db.query.text'] = {
-      type: 'string',
-      value: statement,
-    };
-    // The name of a db query span is its `db.query.summary` attribute
-    attributes['db.query.summary'] = {
-      type: 'string',
-      value: name,
-    };
-    attributes['sentry.origin'] = {
-      type: 'string',
-      value: origin,
-    };
-  } else {
-    attributes['sentry.origin'] = {
-      type: 'string',
-      value: 'manual',
-    };
-  }
-
-  return {
-    attributes,
-    end_timestamp: expect.any(Number),
-    is_segment: false,
-    name,
-    parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    span_id: expect.stringMatching(/^[\da-f]{16}$/),
-    start_timestamp: expect.any(Number),
-    status: 'ok',
-    trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-  };
-}
-
-const CREATE_USER_TABLE_STATEMENT =
-  'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))';
-
-const CREATE_NATIVE_USER_TABLE_STATEMENT =
-  'CREATE TABLE "NativeUser" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))';
-
-function getDbSpans(container: SerializedStreamedSpanContainer): SerializedStreamedSpanContainer['items'] {
-  return container.items.filter(item => item.attributes[SENTRY_OP]?.value === 'db');
-}
-
-describeWithDockerCompose('postgres auto instrumentation (streamed)', { workingDirectory: [__dirname] }, () => {
-  afterAll(() => {
-    cleanupChildProcesses();
-  });
-
-  describe('default', () => {
-    createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createTestRunner, test) => {
-      test('should auto-instrument `pg` package with span streaming enabled', { timeout: 90_000 }, async () => {
-        await createTestRunner()
-          .expect({
-            span: container => {
-              const segmentSpan = container.items.find(item => item.is_segment);
-              expect(segmentSpan?.name).toBe('Test Span');
-
-              const dbSpans = getDbSpans(container);
-              expect(dbSpans.length).toBe(5);
-
-              expect(dbSpans).toEqual([
-                expectedDbSpan({ name: 'pg.connect' }),
-                expectedDbSpan({ name: 'CREATE TABLE "User"', statement: CREATE_USER_TABLE_STATEMENT }),
-                expectedDbSpan({
-                  name: 'INSERT "User"',
-                  statement: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
-                }),
-                expectedDbSpan({ name: 'SELECT "User"', statement: 'SELECT * FROM "User"' }),
-                expectedDbSpan({ name: 'DROP TABLE "User"', statement: 'DROP TABLE "User"' }),
-              ]);
-            },
-          })
-          .start()
-          .completed();
-      });
-    });
-  });
-
-  describe('ignoreConnectSpans', () => {
-    createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument-ignoreConnect.mjs', (createTestRunner, test) => {
-      test("doesn't emit connect spans if ignoreConnectSpans is true", { timeout: 90_000 }, async () => {
-        await createTestRunner()
-          .expect({
-            span: container => {
-              const dbSpans = getDbSpans(container);
-              expect(dbSpans.find(span => span.name.includes('connect'))).toBeUndefined();
-              expect(dbSpans.length).toBe(4);
-
-              // `postgresIntegration()` is the diagnostics-channel implementation by default, so query
-              // spans carry the orchestrion origin even when passing explicit options like
-              // `ignoreConnectSpans`.
-              const origin = 'auto.db.postgres';
-              expect(dbSpans).toEqual([
-                expectedDbSpan({ name: 'CREATE TABLE "User"', statement: CREATE_USER_TABLE_STATEMENT, origin }),
-                expectedDbSpan({
-                  name: 'INSERT "User"',
-                  statement: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
-                  origin,
-                }),
-                expectedDbSpan({ name: 'SELECT "User"', statement: 'SELECT * FROM "User"', origin }),
-                expectedDbSpan({ name: 'DROP TABLE "User"', statement: 'DROP TABLE "User"', origin }),
-              ]);
-            },
-          })
-          .start()
-          .completed();
-      });
-    });
-  });
-
-  // Deno: with a module load hook installed, Deno compiles a native addon (`libpq`) as JavaScript.
-  // Bun: the `libpq` addon needs the Node symbol `node::EmitAsyncInit`, which Bun does not provide.
-  conditionalTest({ max: 25, skipRuntimes: ['bun', 'deno'] })('pg-native', () => {
-    createEsmAndCjsTests(
-      __dirname,
-      'scenario-native.mjs',
-      'instrument.mjs',
-      (createTestRunner, test) => {
-        test(
-          'should auto-instrument `pg-native` package with span streaming enabled',
-          { timeout: 120_000 },
-          async () => {
-            await createTestRunner()
-              .expect({
-                span: container => {
-                  const segmentSpan = container.items.find(item => item.is_segment);
-                  expect(segmentSpan?.name).toBe('Test Span');
-
-                  const dbSpans = getDbSpans(container);
-                  expect(dbSpans.length).toBe(5);
-
-                  expect(dbSpans).toEqual([
-                    expectedDbSpan({ name: 'pg.connect', host: '127.0.0.1' }),
-                    expectedDbSpan({
-                      name: 'CREATE TABLE "NativeUser"',
-                      statement: CREATE_NATIVE_USER_TABLE_STATEMENT,
-                      host: '127.0.0.1',
-                    }),
-                    expectedDbSpan({
-                      name: 'INSERT "NativeUser"',
-                      statement: 'INSERT INTO "NativeUser" ("email", "name") VALUES ($1, $2)',
-                      host: '127.0.0.1',
-                    }),
-                    expectedDbSpan({
-                      name: 'SELECT "NativeUser"',
-                      statement: 'SELECT * FROM "NativeUser"',
-                      host: '127.0.0.1',
-                    }),
-                    expectedDbSpan({
-                      name: 'DROP TABLE "NativeUser"',
-                      statement: 'DROP TABLE "NativeUser"',
-                      host: '127.0.0.1',
-                    }),
-                  ]);
-                },
-              })
-              .start()
-              .completed();
-          },
-        );
-      },
-      { additionalDependencies: { 'pg-native': '3.7.0', pg: '8.20.0' } },
-    );
-  });
-});
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-ignoreConnect.mjs b/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-ignoreConnect.mjs
index 9ce51efd35ff..cd9240108020 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-ignoreConnect.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-ignoreConnect.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-orchestrion-ignoreConnect.mjs b/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-orchestrion-ignoreConnect.mjs
index c349b52dddd4..0d2a99ce3314 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-orchestrion-ignoreConnect.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-orchestrion-ignoreConnect.mjs
@@ -6,7 +6,6 @@ import { loggingTransport } from '@sentry-internal/node-integration-tests';
 import * as Sentry from '@sentry/node';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-orchestrion.mjs b/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-orchestrion.mjs
index a1923d42be9b..50479ee983af 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-orchestrion.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/postgres/instrument-orchestrion.mjs
@@ -5,7 +5,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/postgres/instrument.mjs
index 170ad6f6a702..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgres/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/postgres/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts b/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts
index 6533e2cca588..0d4fa1212fc8 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts
@@ -1,7 +1,57 @@
+import {
+  DB_CONNECTION_STRING,
+  DB_NAMESPACE,
+  DB_QUERY_SUMMARY,
+  DB_QUERY_TEXT,
+  DB_SYSTEM_NAME,
+  DB_USER,
+  SENTRY_ENVIRONMENT,
+  SENTRY_IS_LOCALHOST,
+  SENTRY_KIND,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_RELEASE,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SEGMENT_NAME,
+  SENTRY_TRACE_LIFECYCLE,
+  SERVER_ADDRESS,
+  SERVER_PORT,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
 import { afterAll, describe, expect } from 'vitest';
-import { conditionalTest } from '../../../utils';
+import { conditionalTest, EXPECTED_SDK_NAME } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
+const COMMON_DB_ATTRIBUTES = {
+  [SENTRY_IS_LOCALHOST]: { type: 'boolean', value: false },
+  [DB_CONNECTION_STRING]: { type: 'string', value: expect.stringMatching(/^postgresql:\/\/localhost:\d+\/tests$/) },
+  [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+  [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+  [DB_USER]: { type: 'string', value: 'test' },
+  [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+  [SERVER_PORT]: { type: 'integer', value: expect.any(Number) },
+  [SENTRY_KIND]: { type: 'string', value: 'client' },
+  [SENTRY_ENVIRONMENT]: { type: 'string', value: 'production' },
+  [SENTRY_OP]: { type: 'string', value: DB },
+  [SENTRY_RELEASE]: { type: 'string', value: '1.0' },
+  [SENTRY_SDK_NAME]: { type: 'string', value: EXPECTED_SDK_NAME },
+  [SENTRY_SDK_VERSION]: { type: 'string', value: expect.any(String) },
+  [SENTRY_SEGMENT_ID]: { type: 'string', value: expect.stringMatching(/^[\da-f]{16}$/) },
+  [SENTRY_SEGMENT_NAME]: { type: 'string', value: 'Test Transaction' },
+  [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
+};
+
+const COMMON_SPAN_FIELDS = {
+  end_timestamp: expect.any(Number),
+  is_segment: false,
+  parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  span_id: expect.stringMatching(/^[\da-f]{16}$/),
+  start_timestamp: expect.any(Number),
+  trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+};
+
 describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [__dirname] }, () => {
   afterAll(() => {
     cleanupChildProcesses();
@@ -12,79 +62,125 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
   const QUERY_ORIGIN = 'auto.db.postgres';
 
   describe('default', () => {
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Transaction',
-      spans: expect.arrayContaining([
-        expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'sentry.origin': 'manual',
-            'sentry.op': 'db',
-          }),
-          description: 'pg.connect',
-          op: 'db',
+    const EXPECTED_SPANS = {
+      items: expect.arrayContaining([
+        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
+        {
+          ...COMMON_SPAN_FIELDS,
+          attributes: {
+            ...COMMON_DB_ATTRIBUTES,
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+          },
+          name: 'pg.connect',
           status: 'ok',
-        }),
-        expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'db.query.text': 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
-            'sentry.origin': QUERY_ORIGIN,
-            'sentry.op': 'db',
-          }),
-          description: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
-          op: 'db',
+        },
+        {
+          ...COMMON_SPAN_FIELDS,
+          attributes: {
+            ...COMMON_DB_ATTRIBUTES,
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)' },
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'INSERT "User"' },
+          },
+          name: 'INSERT "User"',
           status: 'ok',
-          origin: QUERY_ORIGIN,
-        }),
-        expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'db.query.text': 'SELECT * FROM "User"',
-            'sentry.origin': QUERY_ORIGIN,
-            'sentry.op': 'db',
-          }),
-          description: 'SELECT * FROM "User"',
-          op: 'db',
+        },
+        {
+          ...COMMON_SPAN_FIELDS,
+          attributes: {
+            ...COMMON_DB_ATTRIBUTES,
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "User"' },
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "User"' },
+          },
+          name: 'SELECT "User"',
           status: 'ok',
-          origin: QUERY_ORIGIN,
-        }),
+        },
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'db.query.text': 'SELECT * FROM "User" WHERE "email" = $1',
-            'db.postgresql.plan': 'select-user-by-email',
-            'sentry.origin': QUERY_ORIGIN,
-            'sentry.op': 'db',
+          attributes: expect.objectContaining({
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "User" WHERE "email" = $1' },
+            'db.postgresql.plan': { type: 'string', value: 'select-user-by-email' },
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "User"' },
           }),
-          description: 'SELECT * FROM "User" WHERE "email" = $1',
-          op: 'db',
+          name: 'SELECT "User"',
           status: 'ok',
-          origin: QUERY_ORIGIN,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'db.query.text': 'SELECT * FROM "does_not_exist_table"',
-            'sentry.origin': QUERY_ORIGIN,
-            'sentry.op': 'db',
+          attributes: expect.objectContaining({
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "does_not_exist_table"' },
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "does_not_exist_table"' },
           }),
-          description: 'SELECT * FROM "does_not_exist_table"',
-          op: 'db',
-          status: 'internal_error',
-          origin: QUERY_ORIGIN,
+          name: 'SELECT "does_not_exist_table"',
+          status: 'error',
         }),
+        {
+          ...COMMON_SPAN_FIELDS,
+          name: 'CREATE TABLE "User"',
+          status: 'ok',
+          attributes: {
+            ...COMMON_DB_ATTRIBUTES,
+
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [DB_QUERY_TEXT]: {
+              type: 'string',
+              value:
+                'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
+            },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'CREATE TABLE "User"' },
+          },
+        },
+        {
+          ...COMMON_SPAN_FIELDS,
+          name: 'DROP TABLE "User"',
+          status: 'ok',
+          attributes: {
+            ...COMMON_DB_ATTRIBUTES,
+
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'DROP TABLE "User"' },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'DROP TABLE "User"' },
+          },
+        },
       ]),
     };
 
     createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createTestRunner, test) => {
       test('should auto-instrument `pg` package', { timeout: 90_000 }, async () => {
-        await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+        await createTestRunner()
+          .expect({
+            span: container => {
+              expect(container).toMatchObject(EXPECTED_SPANS);
+              const dbSpans = container.items.filter(span => span.attributes[SENTRY_OP]?.value === DB);
+              expect(dbSpans.map(span => span.name)).toEqual([
+                'pg.connect',
+                'CREATE TABLE "User"',
+                'INSERT "User"',
+                'SELECT "User"',
+                'SELECT "User"',
+                'SELECT "does_not_exist_table"',
+                'DROP TABLE "User"',
+              ]);
+            },
+          })
+          .start()
+          .completed();
       });
     });
   });
@@ -94,38 +190,80 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
       test("doesn't emit connect spans if ignoreConnectSpans is true", { timeout: 90_000 }, async () => {
         await createTestRunner()
           .expect({
-            transaction: txn => {
-              const spanNames = txn.spans?.map(span => span.description);
+            span: container => {
+              const dbSpans = container.items.filter(span => span.attributes[SENTRY_OP]?.value === DB);
+              expect(dbSpans.map(span => span.name)).toEqual([
+                'CREATE TABLE "User"',
+                'INSERT "User"',
+                'SELECT "User"',
+                'SELECT "User"',
+                'SELECT "does_not_exist_table"',
+                'DROP TABLE "User"',
+              ]);
+              const spanNames = container.items.map(span => span.name);
               expect(spanNames?.find(name => name?.includes('connect'))).toBeUndefined();
-              expect(txn).toMatchObject({
-                transaction: 'Test Transaction',
-                spans: expect.arrayContaining([
-                  expect.objectContaining({
-                    data: expect.objectContaining({
-                      'db.system.name': 'postgresql',
-                      'db.namespace': 'tests',
-                      'db.query.text': 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
-                      'sentry.origin': QUERY_ORIGIN,
-                      'sentry.op': 'db',
-                    }),
-                    description: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
-                    op: 'db',
+              expect(container).toMatchObject({
+                items: expect.arrayContaining([
+                  expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
+                  {
+                    ...COMMON_SPAN_FIELDS,
+                    attributes: {
+                      ...COMMON_DB_ATTRIBUTES,
+                      [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+                      [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+                      [DB_QUERY_TEXT]: {
+                        type: 'string',
+                        value: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
+                      },
+                      [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+                      [SENTRY_OP]: { type: 'string', value: DB },
+                      [DB_QUERY_SUMMARY]: { type: 'string', value: 'INSERT "User"' },
+                    },
+                    name: 'INSERT "User"',
                     status: 'ok',
-                    origin: QUERY_ORIGIN,
-                  }),
-                  expect.objectContaining({
-                    data: expect.objectContaining({
-                      'db.system.name': 'postgresql',
-                      'db.namespace': 'tests',
-                      'db.query.text': 'SELECT * FROM "User"',
-                      'sentry.origin': QUERY_ORIGIN,
-                      'sentry.op': 'db',
-                    }),
-                    description: 'SELECT * FROM "User"',
-                    op: 'db',
+                  },
+                  {
+                    ...COMMON_SPAN_FIELDS,
+                    attributes: {
+                      ...COMMON_DB_ATTRIBUTES,
+                      [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+                      [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+                      [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "User"' },
+                      [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+                      [SENTRY_OP]: { type: 'string', value: DB },
+                      [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "User"' },
+                    },
+                    name: 'SELECT "User"',
                     status: 'ok',
-                    origin: QUERY_ORIGIN,
-                  }),
+                  },
+                  {
+                    ...COMMON_SPAN_FIELDS,
+                    name: 'CREATE TABLE "User"',
+                    status: 'ok',
+                    attributes: {
+                      ...COMMON_DB_ATTRIBUTES,
+
+                      [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+                      [DB_QUERY_TEXT]: {
+                        type: 'string',
+                        value:
+                          'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
+                      },
+                      [DB_QUERY_SUMMARY]: { type: 'string', value: 'CREATE TABLE "User"' },
+                    },
+                  },
+                  {
+                    ...COMMON_SPAN_FIELDS,
+                    name: 'DROP TABLE "User"',
+                    status: 'ok',
+                    attributes: {
+                      ...COMMON_DB_ATTRIBUTES,
+
+                      [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+                      [DB_QUERY_TEXT]: { type: 'string', value: 'DROP TABLE "User"' },
+                      [DB_QUERY_SUMMARY]: { type: 'string', value: 'DROP TABLE "User"' },
+                    },
+                  },
                 ]),
               });
             },
@@ -137,36 +275,34 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
   });
 
   describe('pool', () => {
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Transaction',
-      spans: expect.arrayContaining([
+    const EXPECTED_SPANS = {
+      items: expect.arrayContaining([
+        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
         // Pool connect span: no origin is set on connect spans, so it defaults
         // to 'manual', and the connection-string credentials are masked out.
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'db.connection_string': 'postgresql://localhost:5494/tests',
-            'sentry.op': 'db',
+          attributes: expect.objectContaining({
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [DB_CONNECTION_STRING]: { type: 'string', value: 'postgresql://localhost:5494/tests' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
           }),
-          description: 'pg-pool.connect',
-          op: 'db',
+          name: 'pg-pool.connect',
           status: 'ok',
-          origin: 'manual',
         }),
         // Callback-style query (no awaited promise returned to the caller).
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'db.query.text': 'SELECT ? AS foo',
-            'sentry.origin': QUERY_ORIGIN,
-            'sentry.op': 'db',
+          attributes: expect.objectContaining({
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT ? AS foo' },
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT' },
           }),
-          description: 'SELECT ? AS foo',
-          op: 'db',
+          name: 'SELECT',
           status: 'ok',
-          origin: QUERY_ORIGIN,
         }),
       ]),
     };
@@ -176,26 +312,25 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
         'auto-instruments `pg.Pool`, masks connection-string credentials, and handles callback-style queries',
         { timeout: 90_000 },
         async () => {
-          await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+          await createTestRunner().expect({ span: EXPECTED_SPANS }).start().completed();
         },
       );
     });
   });
 
   describe('connect error', () => {
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Transaction',
-      spans: expect.arrayContaining([
+    const EXPECTED_SPANS = {
+      items: expect.arrayContaining([
+        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'sentry.op': 'db',
+          attributes: expect.objectContaining({
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
           }),
-          description: 'pg.connect',
-          op: 'db',
-          status: 'internal_error',
-          origin: 'manual',
+          name: 'pg.connect',
+          status: 'error',
         }),
       ]),
     };
@@ -203,7 +338,7 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
     // No DB needed: the scenario connects to a port where nothing is listening.
     createEsmAndCjsTests(__dirname, 'scenario-connect-error.mjs', 'instrument.mjs', (createTestRunner, test) => {
       test('records an errored connect span when the connection fails', { timeout: 90_000 }, async () => {
-        await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+        await createTestRunner().expect({ span: EXPECTED_SPANS }).start().completed();
       });
     });
   });
@@ -213,28 +348,27 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
   // parent span, the query only produces a span if the trace context survives the
   // connect promise's continuation.
   describe('connect promise continuation', () => {
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Transaction',
-      spans: expect.arrayContaining([
+    const EXPECTED_SPANS = {
+      items: expect.arrayContaining([
+        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'db.query.text': 'SELECT ? AS connect_then',
-            'sentry.origin': QUERY_ORIGIN,
-            'sentry.op': 'db',
+          attributes: expect.objectContaining({
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT ? AS connect_then' },
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT' },
           }),
-          description: 'SELECT ? AS connect_then',
-          op: 'db',
+          name: 'SELECT',
           status: 'ok',
-          origin: QUERY_ORIGIN,
         }),
       ]),
     };
 
     createEsmAndCjsTests(__dirname, 'scenario-connect-then.mjs', 'instrument.mjs', (createTestRunner, test) => {
       test('parents a query chained off connect() to the active transaction', { timeout: 90_000 }, async () => {
-        await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+        await createTestRunner().expect({ span: EXPECTED_SPANS }).start().completed();
       });
     });
   });
@@ -244,27 +378,28 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
       test('does not instrument queries or connects without an active parent span', { timeout: 90_000 }, async () => {
         await createTestRunner()
           .expect({
-            transaction: txn => {
-              const descriptions = txn.spans?.map(span => span.description) ?? [];
+            span: container => {
+              const descriptions = container.items.map(span => span.name);
               // The unparented connect + query must not have produced spans
-              expect(descriptions).not.toContain('SELECT ? AS unparented');
+              expect(container.items.map(span => span.attributes[DB_QUERY_TEXT]?.value)).not.toContain(
+                'SELECT ? AS unparented',
+              );
               expect(descriptions.find(name => name?.includes('connect'))).toBeUndefined();
               // Only the parented query is instrumented
-              expect(txn).toMatchObject({
-                transaction: 'Test Transaction',
-                spans: expect.arrayContaining([
+              expect(container).toMatchObject({
+                items: expect.arrayContaining([
+                  expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
                   expect.objectContaining({
-                    data: expect.objectContaining({
-                      'db.system.name': 'postgresql',
-                      'db.namespace': 'tests',
-                      'db.query.text': 'SELECT ? AS parented',
-                      'sentry.origin': QUERY_ORIGIN,
-                      'sentry.op': 'db',
+                    attributes: expect.objectContaining({
+                      [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+                      [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+                      [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT ? AS parented' },
+                      [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+                      [SENTRY_OP]: { type: 'string', value: DB },
+                      [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT' },
                     }),
-                    description: 'SELECT ? AS parented',
-                    op: 'db',
+                    name: 'SELECT',
                     status: 'ok',
-                    origin: QUERY_ORIGIN,
                   }),
                 ]),
               });
@@ -279,46 +414,100 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
   // Deno: with a module load hook installed, Deno compiles a native addon (`libpq`) as JavaScript.
   // Bun: the `libpq` addon needs the Node symbol `node::EmitAsyncInit`, which Bun does not provide.
   conditionalTest({ max: 25, skipRuntimes: ['bun', 'deno'] })('pg-native', () => {
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Transaction',
-      spans: expect.arrayContaining([
-        expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'sentry.origin': 'manual',
-            'sentry.op': 'db',
-          }),
-          description: 'pg.connect',
-          op: 'db',
+    const EXPECTED_SPANS = {
+      items: expect.arrayContaining([
+        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
+        {
+          ...COMMON_SPAN_FIELDS,
+          attributes: {
+            ...COMMON_DB_ATTRIBUTES,
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SERVER_ADDRESS]: { type: 'string', value: '127.0.0.1' },
+            [DB_CONNECTION_STRING]: {
+              type: 'string',
+              value: expect.stringMatching(/^postgresql:\/\/127\.0\.0\.1:\d+\/tests$/),
+            },
+          },
+          name: 'pg.connect',
           status: 'ok',
-        }),
-        expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'db.query.text': 'INSERT INTO "NativeUser" ("email", "name") VALUES ($1, $2)',
-            'sentry.origin': QUERY_ORIGIN,
-            'sentry.op': 'db',
-          }),
-          description: 'INSERT INTO "NativeUser" ("email", "name") VALUES ($1, $2)',
-          op: 'db',
+        },
+        {
+          ...COMMON_SPAN_FIELDS,
+          attributes: {
+            ...COMMON_DB_ATTRIBUTES,
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'INSERT INTO "NativeUser" ("email", "name") VALUES ($1, $2)' },
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'INSERT "NativeUser"' },
+            [SERVER_ADDRESS]: { type: 'string', value: '127.0.0.1' },
+            [DB_CONNECTION_STRING]: {
+              type: 'string',
+              value: expect.stringMatching(/^postgresql:\/\/127\.0\.0\.1:\d+\/tests$/),
+            },
+          },
+          name: 'INSERT "NativeUser"',
           status: 'ok',
-          origin: QUERY_ORIGIN,
-        }),
-        expect.objectContaining({
-          data: expect.objectContaining({
-            'db.system.name': 'postgresql',
-            'db.namespace': 'tests',
-            'db.query.text': 'SELECT * FROM "NativeUser"',
-            'sentry.origin': QUERY_ORIGIN,
-            'sentry.op': 'db',
-          }),
-          description: 'SELECT * FROM "NativeUser"',
-          op: 'db',
+        },
+        {
+          ...COMMON_SPAN_FIELDS,
+          attributes: {
+            ...COMMON_DB_ATTRIBUTES,
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "NativeUser"' },
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "NativeUser"' },
+            [SERVER_ADDRESS]: { type: 'string', value: '127.0.0.1' },
+            [DB_CONNECTION_STRING]: {
+              type: 'string',
+              value: expect.stringMatching(/^postgresql:\/\/127\.0\.0\.1:\d+\/tests$/),
+            },
+          },
+          name: 'SELECT "NativeUser"',
           status: 'ok',
-          origin: QUERY_ORIGIN,
-        }),
+        },
+        {
+          ...COMMON_SPAN_FIELDS,
+          name: 'CREATE TABLE "NativeUser"',
+          status: 'ok',
+          attributes: {
+            ...COMMON_DB_ATTRIBUTES,
+            [SERVER_ADDRESS]: { type: 'string', value: '127.0.0.1' },
+            [DB_CONNECTION_STRING]: {
+              type: 'string',
+              value: expect.stringMatching(/^postgresql:\/\/127\.0\.0\.1:\d+\/tests$/),
+            },
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [DB_QUERY_TEXT]: {
+              type: 'string',
+              value:
+                'CREATE TABLE "NativeUser" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
+            },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'CREATE TABLE "NativeUser"' },
+          },
+        },
+        {
+          ...COMMON_SPAN_FIELDS,
+          name: 'DROP TABLE "NativeUser"',
+          status: 'ok',
+          attributes: {
+            ...COMMON_DB_ATTRIBUTES,
+            [SERVER_ADDRESS]: { type: 'string', value: '127.0.0.1' },
+            [DB_CONNECTION_STRING]: {
+              type: 'string',
+              value: expect.stringMatching(/^postgresql:\/\/127\.0\.0\.1:\d+\/tests$/),
+            },
+            [SENTRY_ORIGIN]: { type: 'string', value: QUERY_ORIGIN },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'DROP TABLE "NativeUser"' },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'DROP TABLE "NativeUser"' },
+          },
+        },
       ]),
     };
 
@@ -328,7 +517,22 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
       'instrument.mjs',
       (createTestRunner, test) => {
         test('should auto-instrument `pg-native` package', { timeout: 120_000 }, async () => {
-          await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+          await createTestRunner()
+            .expect({
+              span: container => {
+                expect(container).toMatchObject(EXPECTED_SPANS);
+                const dbSpans = container.items.filter(span => span.attributes[SENTRY_OP]?.value === DB);
+                expect(dbSpans.map(span => span.name)).toEqual([
+                  'pg.connect',
+                  'CREATE TABLE "NativeUser"',
+                  'INSERT "NativeUser"',
+                  'SELECT "NativeUser"',
+                  'DROP TABLE "NativeUser"',
+                ]);
+              },
+            })
+            .start()
+            .completed();
         });
       },
       { additionalDependencies: { 'pg-native': '3.7.0', pg: '8.20.0' } },
@@ -343,126 +547,115 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
     const ORIGIN = 'auto.db.postgres';
 
     describe('default', () => {
-      const EXPECTED_TRANSACTION = {
-        transaction: 'Test Transaction',
-        spans: expect.arrayContaining([
+      const EXPECTED_SPANS = {
+        items: expect.arrayContaining([
+          expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
           expect.objectContaining({
-            data: expect.objectContaining({
-              'db.system.name': 'postgresql',
-              'db.namespace': 'tests',
-              'sentry.origin': 'manual',
-              'sentry.op': 'db',
+            attributes: expect.objectContaining({
+              [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+              [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+              [SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
+              [SENTRY_OP]: { type: 'string', value: DB },
             }),
-            description: 'pg.connect',
-            op: 'db',
+            name: 'pg.connect',
             status: 'ok',
           }),
           expect.objectContaining({
-            data: expect.objectContaining({
-              'db.system.name': 'postgresql',
-              'db.namespace': 'tests',
-              'db.query.text': 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
-              'sentry.origin': ORIGIN,
-              'sentry.op': 'db',
+            attributes: expect.objectContaining({
+              [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+              [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+              [DB_QUERY_TEXT]: { type: 'string', value: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)' },
+              [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+              [SENTRY_OP]: { type: 'string', value: DB },
+              [DB_QUERY_SUMMARY]: { type: 'string', value: 'INSERT "User"' },
             }),
-            description: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
-            op: 'db',
+            name: 'INSERT "User"',
             status: 'ok',
-            origin: ORIGIN,
           }),
           expect.objectContaining({
-            data: expect.objectContaining({
-              'db.system.name': 'postgresql',
-              'db.namespace': 'tests',
-              'db.query.text': 'SELECT * FROM "User" WHERE "email" = $1',
-              'db.postgresql.plan': 'select-user-by-email',
-              'sentry.origin': ORIGIN,
-              'sentry.op': 'db',
+            attributes: expect.objectContaining({
+              [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+              [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+              [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "User" WHERE "email" = $1' },
+              'db.postgresql.plan': { type: 'string', value: 'select-user-by-email' },
+              [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+              [SENTRY_OP]: { type: 'string', value: DB },
+              [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "User"' },
             }),
-            description: 'SELECT * FROM "User" WHERE "email" = $1',
-            op: 'db',
+            name: 'SELECT "User"',
             status: 'ok',
-            origin: ORIGIN,
           }),
           expect.objectContaining({
-            data: expect.objectContaining({
-              'db.system.name': 'postgresql',
-              'db.query.text': 'SELECT * FROM "does_not_exist_table"',
-              'sentry.origin': ORIGIN,
-              'sentry.op': 'db',
+            attributes: expect.objectContaining({
+              [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+              [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "does_not_exist_table"' },
+              [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+              [SENTRY_OP]: { type: 'string', value: DB },
+              [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "does_not_exist_table"' },
             }),
-            description: 'SELECT * FROM "does_not_exist_table"',
-            op: 'db',
-            status: 'internal_error',
-            origin: ORIGIN,
+            name: 'SELECT "does_not_exist_table"',
+            status: 'error',
           }),
         ]),
       };
 
       createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument-orchestrion.mjs', (createTestRunner, test) => {
         test('auto-instruments `pg` via diagnostics channels', { timeout: 90_000 }, async () => {
-          await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+          await createTestRunner().expect({ span: EXPECTED_SPANS }).start().completed();
         });
       });
     });
 
     describe('pool', () => {
-      const EXPECTED_TRANSACTION = {
-        transaction: 'Test Transaction',
-        spans: expect.arrayContaining([
+      const EXPECTED_SPANS = {
+        items: expect.arrayContaining([
+          expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
           expect.objectContaining({
-            data: expect.objectContaining({
-              'db.system.name': 'postgresql',
-              'db.namespace': 'tests',
-              'db.connection_string': 'postgresql://localhost:5494/tests',
-              'sentry.op': 'db',
+            attributes: expect.objectContaining({
+              [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+              [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+              [DB_CONNECTION_STRING]: { type: 'string', value: 'postgresql://localhost:5494/tests' },
+              [SENTRY_OP]: { type: 'string', value: DB },
+              [SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
             }),
-            description: 'pg-pool.connect',
-            op: 'db',
+            name: 'pg-pool.connect',
             status: 'ok',
-            origin: 'manual',
           }),
           expect.objectContaining({
-            data: expect.objectContaining({
-              'db.system.name': 'postgresql',
-              'db.namespace': 'tests',
-              'db.query.text': 'SELECT ? AS foo',
-              'sentry.origin': ORIGIN,
-              'sentry.op': 'db',
+            attributes: expect.objectContaining({
+              [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+              [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+              [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT ? AS foo' },
+              [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+              [SENTRY_OP]: { type: 'string', value: DB },
+              [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT' },
             }),
-            description: 'SELECT ? AS foo',
-            op: 'db',
+            name: 'SELECT',
             status: 'ok',
-            origin: ORIGIN,
           }),
         ]),
       };
 
       createEsmAndCjsTests(__dirname, 'scenario-pool.mjs', 'instrument-orchestrion.mjs', (createTestRunner, test) => {
         test('auto-instruments `pg.Pool` and handles callback-style queries', { timeout: 90_000 }, async () => {
-          await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+          await createTestRunner().expect({ span: EXPECTED_SPANS }).start().completed();
         });
       });
     });
 
     describe('connect error', () => {
-      const EXPECTED_TRANSACTION = {
-        transaction: 'Test Transaction',
-        spans: expect.arrayContaining([
+      const EXPECTED_SPANS = {
+        items: expect.arrayContaining([
+          expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
           expect.objectContaining({
-            data: expect.objectContaining({
-              'db.system.name': 'postgresql',
-              'db.namespace': 'tests',
-              'sentry.op': 'db',
+            attributes: expect.objectContaining({
+              [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+              [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+              [SENTRY_OP]: { type: 'string', value: DB },
+              [SENTRY_ORIGIN]: { type: 'string', value: 'manual' },
             }),
-            description: 'pg.connect',
-            op: 'db',
-            // A failed connect has no canonical status message, so serializes
-            // to `internal_error` (same as OTel). Holds across Node versions
-            // even though the error class differs: plain `Error` on Node 18,
-            // `AggregateError` on Node 20+.
-            status: 'internal_error',
-            origin: 'manual',
+            name: 'pg.connect',
+            status: 'error',
           }),
         ]),
       };
@@ -473,7 +666,7 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
         'instrument-orchestrion.mjs',
         (createTestRunner, test) => {
           test('records an errored connect span when the connection fails', { timeout: 90_000 }, async () => {
-            await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+            await createTestRunner().expect({ span: EXPECTED_SPANS }).start().completed();
           });
         },
       );
@@ -491,24 +684,25 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
             async () => {
               await createTestRunner()
                 .expect({
-                  transaction: txn => {
-                    const descriptions = txn.spans?.map(span => span.description) ?? [];
-                    expect(descriptions).not.toContain('SELECT ? AS unparented');
+                  span: container => {
+                    const descriptions = container.items.map(span => span.name);
+                    expect(container.items.map(span => span.attributes[DB_QUERY_TEXT]?.value)).not.toContain(
+                      'SELECT ? AS unparented',
+                    );
                     expect(descriptions.find(name => name?.includes('connect'))).toBeUndefined();
-                    expect(txn).toMatchObject({
-                      transaction: 'Test Transaction',
-                      spans: expect.arrayContaining([
+                    expect(container).toMatchObject({
+                      items: expect.arrayContaining([
+                        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
                         expect.objectContaining({
-                          data: expect.objectContaining({
-                            'db.system.name': 'postgresql',
-                            'db.query.text': 'SELECT ? AS parented',
-                            'sentry.origin': ORIGIN,
-                            'sentry.op': 'db',
+                          attributes: expect.objectContaining({
+                            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+                            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT ? AS parented' },
+                            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+                            [SENTRY_OP]: { type: 'string', value: DB },
+                            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT' },
                           }),
-                          description: 'SELECT ? AS parented',
-                          op: 'db',
+                          name: 'SELECT',
                           status: 'ok',
-                          origin: ORIGIN,
                         }),
                       ]),
                     });
@@ -534,39 +728,40 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
             async () => {
               await createTestRunner()
                 .expect({
-                  transaction: txn => {
-                    const spanNames = txn.spans?.map(span => span.description);
+                  span: container => {
+                    const spanNames = container.items.map(span => span.name);
                     // No `pg.connect` / `pg-pool.connect` spans were produced.
                     expect(spanNames?.find(name => name?.includes('connect'))).toBeUndefined();
                     // ...but the query spans are still instrumented via orchestrion.
-                    expect(txn).toMatchObject({
-                      transaction: 'Test Transaction',
-                      spans: expect.arrayContaining([
+                    expect(container).toMatchObject({
+                      items: expect.arrayContaining([
+                        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
                         expect.objectContaining({
-                          data: expect.objectContaining({
-                            'db.system.name': 'postgresql',
-                            'db.namespace': 'tests',
-                            'db.query.text': 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
-                            'sentry.origin': ORIGIN,
-                            'sentry.op': 'db',
+                          attributes: expect.objectContaining({
+                            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+                            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+                            [DB_QUERY_TEXT]: {
+                              type: 'string',
+                              value: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
+                            },
+                            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+                            [SENTRY_OP]: { type: 'string', value: DB },
+                            [DB_QUERY_SUMMARY]: { type: 'string', value: 'INSERT "User"' },
                           }),
-                          description: 'INSERT INTO "User" ("email", "name") VALUES ($1, $2)',
-                          op: 'db',
+                          name: 'INSERT "User"',
                           status: 'ok',
-                          origin: ORIGIN,
                         }),
                         expect.objectContaining({
-                          data: expect.objectContaining({
-                            'db.system.name': 'postgresql',
-                            'db.namespace': 'tests',
-                            'db.query.text': 'SELECT * FROM "User"',
-                            'sentry.origin': ORIGIN,
-                            'sentry.op': 'db',
+                          attributes: expect.objectContaining({
+                            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgresql' },
+                            [DB_NAMESPACE]: { type: 'string', value: 'tests' },
+                            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "User"' },
+                            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+                            [SENTRY_OP]: { type: 'string', value: DB },
+                            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "User"' },
                           }),
-                          description: 'SELECT * FROM "User"',
-                          op: 'db',
+                          name: 'SELECT "User"',
                           status: 'ok',
-                          origin: ORIGIN,
                         }),
                       ]),
                     });
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/docker-compose.yml b/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/docker-compose.yml
deleted file mode 100644
index e3e13e347bf6..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/docker-compose.yml
+++ /dev/null
@@ -1,18 +0,0 @@
-version: '3.9'
-
-services:
-  db:
-    image: postgres:13
-    restart: always
-    ports:
-      - '5446:5432'
-    environment:
-      POSTGRES_USER: test
-      POSTGRES_PASSWORD: test
-      POSTGRES_DB: test_db
-    healthcheck:
-      test: ['CMD-SHELL', 'pg_isready -U test -d test_db']
-      interval: 2s
-      timeout: 3s
-      retries: 30
-      start_period: 5s
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/instrument-requestHook.mjs b/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/instrument-requestHook.mjs
deleted file mode 100644
index a95f4861f159..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/instrument-requestHook.mjs
+++ /dev/null
@@ -1,26 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-const requestHook = (span, sanitizedSqlQuery, connectionContext) => {
-  // Add custom attributes to demonstrate requestHook functionality.
-  // Streamed spans carry no `extra`, so the connection context is asserted via span attributes
-  // rather than `Sentry.setExtra` (as the static-lifecycle suite does).
-  span.setAttributes({
-    'custom.requestHook': 'called',
-    'custom.requestHook.query': sanitizedSqlQuery,
-    'custom.requestHook.database': connectionContext?.ATTR_DB_NAMESPACE,
-    'custom.requestHook.host': connectionContext?.ATTR_SERVER_ADDRESS,
-    'custom.requestHook.port': connectionContext?.ATTR_SERVER_PORT,
-  });
-};
-
-// `postgresJsIntegration()` is the diagnostics-channel implementation by default; it forwards the
-// `requestHook` to the channel subscriber.
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  transport: loggingTransport,
-  integrations: [Sentry.postgresJsIntegration({ requestHook })],
-  traceLifecycle: 'stream',
-});
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/instrument.mjs
deleted file mode 100644
index 46a27dd03b74..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/instrument.mjs
+++ /dev/null
@@ -1,9 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  tracesSampleRate: 1.0,
-  transport: loggingTransport,
-});
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-requestHook.mjs b/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-requestHook.mjs
deleted file mode 100644
index 05f359f2b57f..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-requestHook.mjs
+++ /dev/null
@@ -1,39 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { uuid4 } from '@sentry/core';
-import postgres from 'postgres';
-import { waitForConnection } from '@sentry-internal/node-integration-tests';
-
-const sql = postgres({ port: 5446, user: 'test', password: 'test', database: 'test_db' });
-
-async function run() {
-  await Sentry.startSpan(
-    {
-      name: 'Test Transaction',
-      op: 'transaction',
-    },
-    async () => {
-      try {
-        await waitForConnection(() => sql`SELECT 1`);
-        await sql`
-          CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"));
-        `;
-
-        const email = `${uuid4()}@domain.com`;
-        await sql`
-          INSERT INTO "User" ("email", "name") VALUES (${email}, 'tim');
-        `;
-
-        await sql`
-          SELECT * FROM "User" WHERE "email" = ${email};
-        `;
-      } finally {
-        await sql`
-          DROP TABLE "User";
-        `;
-        await sql.end();
-      }
-    },
-  );
-}
-
-run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-unsafe.mjs b/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-unsafe.mjs
deleted file mode 100644
index 7d75758804b3..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-unsafe.mjs
+++ /dev/null
@@ -1,37 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { uuid4 } from '@sentry/core';
-import postgres from 'postgres';
-import { waitForConnection } from '@sentry-internal/node-integration-tests';
-
-// Test with plain object options
-const sql = postgres({ port: 5446, user: 'test', password: 'test', database: 'test_db' });
-
-async function run() {
-  await Sentry.startSpan(
-    {
-      name: 'Test Transaction',
-      op: 'transaction',
-    },
-    async () => {
-      try {
-        await waitForConnection(() => sql`SELECT 1`);
-        // Test sql.unsafe() - this was not being instrumented before the fix
-        await sql.unsafe('CREATE TABLE "User" ("id" SERIAL NOT NULL, "email" TEXT NOT NULL, PRIMARY KEY ("id"))');
-
-        const email = `${uuid4()}@domain.com`;
-        await sql.unsafe('INSERT INTO "User" ("email") VALUES ($1)', [email]);
-
-        await sql.unsafe('SELECT * FROM "User" WHERE "email" = $1', [email]);
-
-        await sql.unsafe('DROP TABLE "User"');
-
-        // This will be captured as an error as the table no longer exists
-        await sql.unsafe('SELECT * FROM "User"');
-      } finally {
-        await sql.end();
-      }
-    },
-  );
-}
-
-run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-url.mjs b/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-url.mjs
deleted file mode 100644
index 34301871ce16..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario-url.mjs
+++ /dev/null
@@ -1,75 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { uuid4 } from '@sentry/core';
-import postgres from 'postgres';
-import { waitForConnection } from '@sentry-internal/node-integration-tests';
-
-// Test URL-based initialization - this is the common pattern that was causing the regression
-const sql = postgres('postgres://test:test@localhost:5446/test_db');
-
-async function run() {
-  await Sentry.startSpan(
-    {
-      name: 'Test Transaction',
-      op: 'transaction',
-    },
-    async () => {
-      try {
-        await waitForConnection(() => sql`SELECT 1`);
-        await sql`
-          CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"));
-        `;
-
-        const email = `${uuid4()}@domain.com`;
-        await sql`
-          INSERT INTO "User" ("email", "name") VALUES (${email}, 'tim');
-        `;
-
-        await sql`
-          UPDATE "User" SET "name" = 'Foo' WHERE "email" = ${email};
-        `;
-
-        await sql`
-          SELECT * FROM "User" WHERE "email" = ${email};
-        `;
-
-        // Test parameterized queries
-        await sql`
-          SELECT * FROM "User" WHERE "email" = ${email} AND "name" = ${'Foo'};
-        `;
-
-        // Test DELETE operation
-        await sql`
-          DELETE FROM "User" WHERE "email" = ${email};
-        `;
-
-        // Test INSERT with RETURNING
-        await sql`
-          INSERT INTO "User" ("email", "name") VALUES (${email}, 'Test User') RETURNING *;
-        `;
-
-        // Test cursor-based queries
-        await sql`SELECT * from generate_series(1,1000) as x `.cursor(10, async rows => {
-          await Promise.all(rows);
-        });
-
-        // Test multiple rows at once
-        await sql`
-          SELECT * FROM "User" LIMIT 10;
-        `;
-
-        await sql`
-          DROP TABLE "User";
-        `;
-
-        // This will be captured as an error as the table no longer exists
-        await sql`
-          SELECT * FROM "User" WHERE "email" = ${email};
-        `;
-      } finally {
-        await sql.end();
-      }
-    },
-  );
-}
-
-run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario.mjs b/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario.mjs
deleted file mode 100644
index 12dafe97300a..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/scenario.mjs
+++ /dev/null
@@ -1,74 +0,0 @@
-import * as Sentry from '@sentry/node';
-import { uuid4 } from '@sentry/core';
-import postgres from 'postgres';
-import { waitForConnection } from '@sentry-internal/node-integration-tests';
-
-const sql = postgres({ port: 5446, user: 'test', password: 'test', database: 'test_db' });
-
-async function run() {
-  await Sentry.startSpan(
-    {
-      name: 'Test Transaction',
-      op: 'transaction',
-    },
-    async () => {
-      try {
-        await waitForConnection(() => sql`SELECT 1`);
-        await sql`
-          CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"));
-        `;
-
-        const email = `${uuid4()}@domain.com`;
-        await sql`
-          INSERT INTO "User" ("email", "name") VALUES (${email}, 'tim');
-        `;
-
-        await sql`
-          UPDATE "User" SET "name" = 'Foo' WHERE "email" = ${email};
-        `;
-
-        await sql`
-          SELECT * FROM "User" WHERE "email" = ${email};
-        `;
-
-        // Test parameterized queries
-        await sql`
-          SELECT * FROM "User" WHERE "email" = ${email} AND "name" = ${'Foo'};
-        `;
-
-        // Test DELETE operation
-        await sql`
-          DELETE FROM "User" WHERE "email" = ${email};
-        `;
-
-        // Test INSERT with RETURNING
-        await sql`
-          INSERT INTO "User" ("email", "name") VALUES (${email}, 'Test User') RETURNING *;
-        `;
-
-        // Test cursor-based queries
-        await sql`SELECT * from generate_series(1,1000) as x `.cursor(10, async rows => {
-          await Promise.all(rows);
-        });
-
-        // Test multiple rows at once
-        await sql`
-          SELECT * FROM "User" LIMIT 10;
-        `;
-
-        await sql`
-          DROP TABLE "User";
-        `;
-
-        // This will be captured as an error as the table no longer exists
-        await sql`
-          SELECT * FROM "User" WHERE "email" = ${email};
-        `;
-      } finally {
-        await sql.end();
-      }
-    },
-  );
-}
-
-run();
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/test.ts b/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/test.ts
deleted file mode 100644
index 5acbaba41e8f..000000000000
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs-streamed/test.ts
+++ /dev/null
@@ -1,325 +0,0 @@
-import type { SerializedStreamedSpanContainer } from '@sentry/core';
-import { afterAll, describe, expect } from 'vitest';
-import { RUNTIME } from '../../../utils';
-import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
-
-// On Bun, `postgres` resolves to its ESM build through the `bun` export condition, so
-// `require('postgres')` returns the module namespace instead of the `postgres` function.
-
-/**
- * Streamed span attributes are `{ value, type }` objects, unlike transaction span `data`,
- * which stores values directly.
- */
-function attr(value: unknown): unknown {
-  return expect.objectContaining({ value });
-}
-
-/**
- * The attributes every query span carries, regardless of the statement.
- */
-const COMMON_DB_ATTRIBUTES = {
-  'db.namespace': attr('test_db'),
-  'db.system.name': attr('postgres'),
-  'sentry.op': attr('db'),
-  'sentry.origin': attr('auto.db.postgresjs'),
-  'server.address': attr('localhost'),
-  'server.port': attr(5446),
-};
-
-/**
- * Builds the expectation for one streamed query span.
- *
- * `name` is asserted separately from `db.query.summary` even though the two always match: the point
- * of this suite is that the span name is the summary and never the statement, so both sides of that
- * equality have to be pinned. `statement` is the sanitized `db.query.text`, which does keep the full
- * (parameterized) SQL.
- */
-function expectedQuerySpan({
-  name,
-  statement,
-  operation,
-  extraAttributes = {},
-}: {
-  name: string;
-  statement: string;
-  operation: string;
-  extraAttributes?: Record<string, unknown>;
-}): unknown {
-  return expect.objectContaining({
-    name,
-    is_segment: false,
-    status: 'ok',
-    attributes: expect.objectContaining({
-      ...COMMON_DB_ATTRIBUTES,
-      'db.operation.name': attr(operation),
-      'db.query.text': attr(statement),
-      'db.query.summary': attr(name),
-      ...extraAttributes,
-    }),
-  });
-}
-
-const CREATE_USER_TABLE_STATEMENT =
-  'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))';
-
-function getDbSpans(container: SerializedStreamedSpanContainer): SerializedStreamedSpanContainer['items'] {
-  return container.items.filter(item => item.attributes['sentry.op']?.value === 'db');
-}
-
-describeWithDockerCompose('postgresjs auto instrumentation (streamed)', { workingDirectory: [__dirname] }, () => {
-  afterAll(() => {
-    cleanupChildProcesses();
-  });
-
-  describe('basic', () => {
-    const EXPECTED_SPANS = {
-      items: expect.arrayContaining([
-        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
-        expectedQuerySpan({
-          name: 'CREATE TABLE "User"',
-          statement: CREATE_USER_TABLE_STATEMENT,
-          operation: 'CREATE TABLE',
-        }),
-        expectedQuerySpan({
-          name: 'INSERT "User"',
-          statement: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)',
-          operation: 'INSERT',
-        }),
-        expectedQuerySpan({
-          name: 'UPDATE "User"',
-          statement: 'UPDATE "User" SET "name" = ? WHERE "email" = $1',
-          operation: 'UPDATE',
-        }),
-        expectedQuerySpan({
-          name: 'SELECT "User"',
-          statement: 'SELECT * FROM "User" WHERE "email" = $1',
-          operation: 'SELECT',
-        }),
-        // Parameterized query test - verifies that tagged template queries with interpolations
-        // are properly reconstructed with $1, $2 placeholders which are PRESERVED per OTEL spec
-        // (PostgreSQL $n placeholders indicate parameterized queries that don't leak sensitive data)
-        expectedQuerySpan({
-          name: 'SELECT "User"',
-          statement: 'SELECT * FROM "User" WHERE "email" = $1 AND "name" = $2',
-          operation: 'SELECT',
-        }),
-        expectedQuerySpan({
-          name: 'DELETE "User"',
-          statement: 'DELETE FROM "User" WHERE "email" = $1',
-          operation: 'DELETE',
-        }),
-        expectedQuerySpan({
-          name: 'INSERT "User"',
-          statement: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?) RETURNING *',
-          operation: 'INSERT',
-        }),
-        // The cursor query summarizes to the set-returning function it selects from.
-        expectedQuerySpan({
-          name: 'SELECT generate_series',
-          statement: 'SELECT * from generate_series(?,?) as x',
-          operation: 'SELECT',
-        }),
-        expectedQuerySpan({
-          name: 'DROP TABLE "User"',
-          statement: 'DROP TABLE "User"',
-          operation: 'DROP TABLE',
-        }),
-        // The table is gone by now, so this one fails.
-        expect.objectContaining({
-          name: 'SELECT "User"',
-          is_segment: false,
-          status: 'error',
-          attributes: expect.objectContaining({
-            ...COMMON_DB_ATTRIBUTES,
-            'db.operation.name': attr('SELECT'),
-            'db.query.text': attr('SELECT * FROM "User" WHERE "email" = $1'),
-            'db.query.summary': attr('SELECT "User"'),
-            'db.response.status_code': attr('42P01'),
-            'error.type': attr('PostgresError'),
-            'sentry.status.message': attr('relation "User" does not exist'),
-          }),
-        }),
-      ]),
-    };
-
-    const EXPECTED_ERROR_EVENT = {
-      event_id: expect.any(String),
-      contexts: {
-        trace: {
-          trace_id: expect.any(String),
-          span_id: expect.any(String),
-        },
-      },
-      exception: {
-        values: [
-          {
-            type: 'PostgresError',
-            value: 'relation "User" does not exist',
-            stacktrace: expect.objectContaining({
-              frames: expect.arrayContaining([
-                expect.objectContaining({
-                  function: 'handle',
-                  // Module differs between CJS (`postgres.cjs.src:connection`) and ESM (`postgres.src:connection`)
-                  module: expect.stringMatching(/^postgres(\.cjs)?\.src:connection$/),
-                  filename: expect.any(String),
-                  lineno: expect.any(Number),
-                  colno: expect.any(Number),
-                }),
-              ]),
-            }),
-          },
-        ],
-      },
-    };
-
-    createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
-      test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
-        'should auto-instrument `postgres` package',
-        { timeout: 90_000 },
-        async () => {
-          await createTestRunner()
-            .expect({
-              span: container => {
-                expect(container).toMatchObject(EXPECTED_SPANS);
-
-                // The assertions above only cover the queries the scenario issues itself. postgres.js
-                // also runs internal ones (e.g. the `pg_catalog` type lookup), so guard the invariant
-                // across every query span: the name is the summary, never the statement.
-                const dbSpans = getDbSpans(container);
-                expect(dbSpans.length).toBeGreaterThan(0);
-                for (const span of dbSpans) {
-                  expect(span.name).toBe(span.attributes['db.query.summary']?.value);
-                }
-              },
-            })
-            .expect({ event: EXPECTED_ERROR_EVENT })
-            // The error event is captured via an unhandled rejection processed on a later tick than
-            // the spans, so the two envelopes can reach the transport in either order.
-            .unordered()
-            .start()
-            .completed();
-        },
-      );
-    });
-  });
-
-  describe('requestHook', () => {
-    const EXPECTED_SPANS = {
-      items: expect.arrayContaining(
-        [
-          { name: 'CREATE TABLE "User"', statement: CREATE_USER_TABLE_STATEMENT, operation: 'CREATE TABLE' },
-          {
-            name: 'INSERT "User"',
-            statement: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)',
-            operation: 'INSERT',
-          },
-          { name: 'SELECT "User"', statement: 'SELECT * FROM "User" WHERE "email" = $1', operation: 'SELECT' },
-          { name: 'DROP TABLE "User"', statement: 'DROP TABLE "User"', operation: 'DROP TABLE' },
-        ].map(({ name, statement, operation }) =>
-          expectedQuerySpan({
-            name,
-            statement,
-            operation,
-            extraAttributes: {
-              'custom.requestHook': attr('called'),
-              'custom.requestHook.query': attr(statement),
-              'custom.requestHook.database': attr('test_db'),
-              'custom.requestHook.host': attr('localhost'),
-              'custom.requestHook.port': attr('5446'),
-            },
-          }),
-        ),
-      ),
-    };
-
-    createEsmAndCjsTests(
-      __dirname,
-      'scenario-requestHook.mjs',
-      'instrument-requestHook.mjs',
-      (createTestRunner, test, mode) => {
-        test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
-          'should call requestHook when provided',
-          { timeout: 90_000 },
-          async () => {
-            await createTestRunner().expect({ span: EXPECTED_SPANS }).start().completed();
-          },
-        );
-      },
-    );
-  });
-
-  describe('url initialization', () => {
-    const EXPECTED_SPANS = {
-      items: expect.arrayContaining([
-        expectedQuerySpan({
-          name: 'CREATE TABLE "User"',
-          statement: CREATE_USER_TABLE_STATEMENT,
-          operation: 'CREATE TABLE',
-        }),
-        expectedQuerySpan({
-          name: 'INSERT "User"',
-          statement: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)',
-          operation: 'INSERT',
-        }),
-        expectedQuerySpan({
-          name: 'SELECT "User"',
-          statement: 'SELECT * FROM "User" WHERE "email" = $1',
-          operation: 'SELECT',
-        }),
-        expectedQuerySpan({
-          name: 'DELETE "User"',
-          statement: 'DELETE FROM "User" WHERE "email" = $1',
-          operation: 'DELETE',
-        }),
-      ]),
-    };
-
-    createEsmAndCjsTests(__dirname, 'scenario-url.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
-      test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
-        'should instrument postgres package with URL initialization',
-        { timeout: 90_000 },
-        async () => {
-          await createTestRunner().ignore('event').expect({ span: EXPECTED_SPANS }).start().completed();
-        },
-      );
-    });
-  });
-
-  describe('sql.unsafe()', () => {
-    const EXPECTED_SPANS = {
-      items: expect.arrayContaining([
-        expectedQuerySpan({
-          name: 'CREATE TABLE "User"',
-          statement: 'CREATE TABLE "User" ("id" SERIAL NOT NULL, "email" TEXT NOT NULL, PRIMARY KEY ("id"))',
-          operation: 'CREATE TABLE',
-        }),
-        // sql.unsafe() with $1 placeholders - preserved per OTEL spec
-        expectedQuerySpan({
-          name: 'INSERT "User"',
-          statement: 'INSERT INTO "User" ("email") VALUES ($1)',
-          operation: 'INSERT',
-        }),
-        expectedQuerySpan({
-          name: 'SELECT "User"',
-          statement: 'SELECT * FROM "User" WHERE "email" = $1',
-          operation: 'SELECT',
-        }),
-        expectedQuerySpan({
-          name: 'DROP TABLE "User"',
-          statement: 'DROP TABLE "User"',
-          operation: 'DROP TABLE',
-        }),
-      ]),
-    };
-
-    createEsmAndCjsTests(__dirname, 'scenario-unsafe.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
-      test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
-        'should instrument sql.unsafe() queries',
-        { timeout: 90_000 },
-        async () => {
-          await createTestRunner().ignore('event').expect({ span: EXPECTED_SPANS }).start().completed();
-        },
-      );
-    });
-  });
-});
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs/instrument-requestHook.mjs b/dev-packages/node-integration-tests/suites/tracing/postgresjs/instrument-requestHook.mjs
index 15cbc82e5890..51df71b79dff 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs/instrument-requestHook.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/postgresjs/instrument-requestHook.mjs
@@ -2,22 +2,18 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 const requestHook = (span, sanitizedSqlQuery, connectionContext) => {
-  // Add custom attributes to demonstrate requestHook functionality
-  span.setAttribute('custom.requestHook', 'called');
-
-  // Set context information as extras for test validation
-  Sentry.setExtra('requestHookCalled', {
-    sanitizedQuery: sanitizedSqlQuery,
-    database: connectionContext?.ATTR_DB_NAMESPACE,
-    host: connectionContext?.ATTR_SERVER_ADDRESS,
-    port: connectionContext?.ATTR_SERVER_PORT,
+  span.setAttributes({
+    'custom.requestHook': 'called',
+    'custom.requestHook.query': sanitizedSqlQuery,
+    'custom.requestHook.database': connectionContext?.ATTR_DB_NAMESPACE,
+    'custom.requestHook.host': connectionContext?.ATTR_SERVER_ADDRESS,
+    'custom.requestHook.port': connectionContext?.ATTR_SERVER_PORT,
   });
 };
 
 // `postgresJsIntegration()` is the diagnostics-channel implementation by default; it forwards the
 // `requestHook` to the channel subscriber.
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/postgresjs/instrument.mjs
index 170ad6f6a702..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/postgresjs/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts b/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts
index a0fffe40d453..9677c10f2c7b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts
@@ -1,3 +1,19 @@
+import {
+  DB_NAMESPACE,
+  DB_OPERATION_NAME,
+  DB_QUERY_SUMMARY,
+  DB_QUERY_TEXT,
+  DB_RESPONSE_STATUS_CODE,
+  DB_SYSTEM_NAME,
+  ERROR_TYPE,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_STATUS_MESSAGE,
+  SERVER_ADDRESS,
+  SERVER_PORT,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
+import type { Event, SerializedStreamedSpanContainer } from '@sentry/core';
 import { afterAll, describe, expect } from 'vitest';
 import { RUNTIME } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
@@ -10,189 +26,224 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
     cleanupChildProcesses();
   });
 
-  // Under orchestrion (INJECT_ORCHESTRION), the OTel `PostgresJs` integration is
-  // swapped for the diagnostics-channel one, so query spans carry a different
-  // origin. Every other attribute is identical.
   const ORIGIN = 'auto.db.postgresjs';
 
   describe('basic', () => {
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Transaction',
-      spans: expect.arrayContaining([
+    const EXPECTED_SPANS = {
+      items: expect.arrayContaining([
+        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'CREATE TABLE',
-            'db.query.text':
-              'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'CREATE TABLE' },
+            [DB_QUERY_TEXT]: {
+              type: 'string',
+              value:
+                'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
+            },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'CREATE TABLE "User"' },
           }),
-          description:
-            'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
-          op: 'db',
+          name: 'CREATE TABLE "User"',
           status: 'ok',
-          origin: ORIGIN,
           parent_span_id: expect.any(String),
           span_id: expect.any(String),
           start_timestamp: expect.any(Number),
-          timestamp: expect.any(Number),
+          end_timestamp: expect.any(Number),
           trace_id: expect.any(String),
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'INSERT',
-            'db.query.text': 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)',
-            'sentry.origin': ORIGIN,
-            'sentry.op': 'db',
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'INSERT' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)' },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'INSERT "User"' },
           }),
-          description: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)',
-          op: 'db',
+          name: 'INSERT "User"',
           status: 'ok',
-          origin: ORIGIN,
           parent_span_id: expect.any(String),
           span_id: expect.any(String),
           start_timestamp: expect.any(Number),
-          timestamp: expect.any(Number),
+          end_timestamp: expect.any(Number),
           trace_id: expect.any(String),
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'UPDATE',
-            'db.query.text': 'UPDATE "User" SET "name" = ? WHERE "email" = $1',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'UPDATE' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'UPDATE "User" SET "name" = ? WHERE "email" = $1' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'UPDATE "User"' },
           }),
-          description: 'UPDATE "User" SET "name" = ? WHERE "email" = $1',
-          op: 'db',
+          name: 'UPDATE "User"',
           status: 'ok',
-          origin: ORIGIN,
           parent_span_id: expect.any(String),
           span_id: expect.any(String),
           start_timestamp: expect.any(Number),
-          timestamp: expect.any(Number),
+          end_timestamp: expect.any(Number),
           trace_id: expect.any(String),
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'SELECT',
-            'db.query.text': 'SELECT * FROM "User" WHERE "email" = $1',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'SELECT' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "User" WHERE "email" = $1' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "User"' },
           }),
-          description: 'SELECT * FROM "User" WHERE "email" = $1',
-          op: 'db',
+          name: 'SELECT "User"',
           status: 'ok',
-          origin: ORIGIN,
           parent_span_id: expect.any(String),
           span_id: expect.any(String),
           start_timestamp: expect.any(Number),
-          timestamp: expect.any(Number),
+          end_timestamp: expect.any(Number),
           trace_id: expect.any(String),
+          is_segment: false,
         }),
         // Parameterized query test - verifies that tagged template queries with interpolations
         // are properly reconstructed with $1, $2 placeholders which are PRESERVED per OTEL spec
         // (PostgreSQL $n placeholders indicate parameterized queries that don't leak sensitive data)
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'SELECT',
-            'db.query.text': 'SELECT * FROM "User" WHERE "email" = $1 AND "name" = $2',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'SELECT' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "User" WHERE "email" = $1 AND "name" = $2' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "User"' },
           }),
-          description: 'SELECT * FROM "User" WHERE "email" = $1 AND "name" = $2',
-          op: 'db',
+          name: 'SELECT "User"',
           status: 'ok',
-          origin: ORIGIN,
           parent_span_id: expect.any(String),
           span_id: expect.any(String),
           start_timestamp: expect.any(Number),
-          timestamp: expect.any(Number),
+          end_timestamp: expect.any(Number),
           trace_id: expect.any(String),
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'SELECT',
-            'db.query.text': 'SELECT * from generate_series(?,?) as x',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'SELECT' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * from generate_series(?,?) as x' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT generate_series' },
           }),
-          description: 'SELECT * from generate_series(?,?) as x',
-          op: 'db',
+          name: 'SELECT generate_series',
           status: 'ok',
-          origin: ORIGIN,
           parent_span_id: expect.any(String),
           span_id: expect.any(String),
           start_timestamp: expect.any(Number),
-          timestamp: expect.any(Number),
+          end_timestamp: expect.any(Number),
           trace_id: expect.any(String),
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'DROP TABLE',
-            'db.query.text': 'DROP TABLE "User"',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'DROP TABLE' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'DROP TABLE "User"' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'DROP TABLE "User"' },
           }),
-          description: 'DROP TABLE "User"',
-          op: 'db',
+          name: 'DROP TABLE "User"',
           status: 'ok',
-          origin: ORIGIN,
           parent_span_id: expect.any(String),
           span_id: expect.any(String),
           start_timestamp: expect.any(Number),
-          timestamp: expect.any(Number),
+          end_timestamp: expect.any(Number),
           trace_id: expect.any(String),
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'SELECT',
-            'db.response.status_code': '42P01',
-            'error.type': 'PostgresError',
-            'db.query.text': 'SELECT * FROM "User" WHERE "email" = $1',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'SELECT' },
+            [DB_RESPONSE_STATUS_CODE]: { type: 'string', value: '42P01' },
+            [ERROR_TYPE]: { type: 'string', value: 'PostgresError' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "User" WHERE "email" = $1' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "User"' },
+            [SENTRY_STATUS_MESSAGE]: { type: 'string', value: 'relation "User" does not exist' },
           }),
-          description: 'SELECT * FROM "User" WHERE "email" = $1',
-          op: 'db',
-          status: 'internal_error',
-          origin: ORIGIN,
+          name: 'SELECT "User"',
+          status: 'error',
           parent_span_id: expect.any(String),
           span_id: expect.any(String),
           start_timestamp: expect.any(Number),
-          timestamp: expect.any(Number),
+          end_timestamp: expect.any(Number),
           trace_id: expect.any(String),
+          is_segment: false,
+        }),
+        expect.objectContaining({
+          name: 'DELETE "User"',
+          is_segment: false,
+          status: 'ok',
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'DELETE' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'DELETE FROM "User" WHERE "email" = $1' },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'DELETE "User"' },
+          }),
+        }),
+        expect.objectContaining({
+          name: 'INSERT "User"',
+          is_segment: false,
+          status: 'ok',
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'INSERT' },
+            [DB_QUERY_TEXT]: {
+              type: 'string',
+              value: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?) RETURNING *',
+            },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'INSERT "User"' },
+          }),
         }),
       ]),
     };
@@ -210,7 +261,7 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
           {
             type: 'PostgresError',
             value: 'relation "User" does not exist',
-            stacktrace: expect.objectContaining({
+            stacktrace: {
               frames: expect.arrayContaining([
                 expect.objectContaining({
                   function: 'handle',
@@ -221,7 +272,7 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
                   colno: expect.any(Number),
                 }),
               ]),
-            }),
+            },
           },
         ],
       },
@@ -232,102 +283,135 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
         'should auto-instrument `postgres` package',
         { timeout: 60_000 },
         async () => {
+          let receivedSpans: SerializedStreamedSpanContainer['items'] = [];
+          let errorEvent: Event | undefined;
           await createTestRunner()
-            .expect({ transaction: EXPECTED_TRANSACTION })
-            .expect({ event: EXPECTED_ERROR_EVENT })
+            .expect({
+              span: container => {
+                expect(container.items.find(span => span.is_segment)?.name).toBe('Test Transaction');
+                receivedSpans = container.items;
+              },
+            })
+            .expect({
+              event: event => {
+                errorEvent = event;
+              },
+            })
             // The error event is captured via an unhandled rejection processed on a later tick than
-            // the transaction, so the two envelopes can reach the transport in either order.
+            // the spans, so the two envelopes can reach the transport in either order.
             .unordered()
             .start()
             .completed();
+          expect({ items: receivedSpans }).toMatchObject(EXPECTED_SPANS);
+          for (const span of receivedSpans.filter(span => span.attributes[SENTRY_OP]?.value === DB)) {
+            expect(span.attributes[DB_QUERY_SUMMARY]).toEqual({ type: 'string', value: span.name });
+          }
+          expect(errorEvent).toMatchObject(EXPECTED_ERROR_EVENT);
         },
       );
     });
   });
 
   describe('requestHook', () => {
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Transaction',
-      spans: expect.arrayContaining([
+    const EXPECTED_SPANS = {
+      items: expect.arrayContaining([
+        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'CREATE TABLE',
-            'db.query.text':
-              'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
-            'custom.requestHook': 'called',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'CREATE TABLE' },
+            [DB_QUERY_TEXT]: {
+              type: 'string',
+              value:
+                'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
+            },
+            'custom.requestHook': { type: 'string', value: 'called' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'CREATE TABLE "User"' },
+            'custom.requestHook.query': {
+              type: 'string',
+              value:
+                'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
+            },
+            'custom.requestHook.database': { type: 'string', value: 'test_db' },
+            'custom.requestHook.host': { type: 'string', value: 'localhost' },
+            'custom.requestHook.port': { type: 'string', value: '5444' },
           }),
-          description:
-            'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
-          op: 'db',
+          name: 'CREATE TABLE "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'INSERT',
-            'db.query.text': 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)',
-            'custom.requestHook': 'called',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'INSERT' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)' },
+            'custom.requestHook': { type: 'string', value: 'called' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'INSERT "User"' },
+            'custom.requestHook.query': {
+              type: 'string',
+              value: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)',
+            },
+            'custom.requestHook.database': { type: 'string', value: 'test_db' },
+            'custom.requestHook.host': { type: 'string', value: 'localhost' },
+            'custom.requestHook.port': { type: 'string', value: '5444' },
           }),
-          description: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)',
-          op: 'db',
+          name: 'INSERT "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'SELECT',
-            'db.query.text': 'SELECT * FROM "User" WHERE "email" = $1',
-            'custom.requestHook': 'called',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'SELECT' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "User" WHERE "email" = $1' },
+            'custom.requestHook': { type: 'string', value: 'called' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "User"' },
+            'custom.requestHook.query': { type: 'string', value: 'SELECT * FROM "User" WHERE "email" = $1' },
+            'custom.requestHook.database': { type: 'string', value: 'test_db' },
+            'custom.requestHook.host': { type: 'string', value: 'localhost' },
+            'custom.requestHook.port': { type: 'string', value: '5444' },
           }),
-          description: 'SELECT * FROM "User" WHERE "email" = $1',
-          op: 'db',
+          name: 'SELECT "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'DROP TABLE',
-            'db.query.text': 'DROP TABLE "User"',
-            'custom.requestHook': 'called',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'DROP TABLE' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'DROP TABLE "User"' },
+            'custom.requestHook': { type: 'string', value: 'called' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'DROP TABLE "User"' },
+            'custom.requestHook.query': { type: 'string', value: 'DROP TABLE "User"' },
+            'custom.requestHook.database': { type: 'string', value: 'test_db' },
+            'custom.requestHook.host': { type: 'string', value: 'localhost' },
+            'custom.requestHook.port': { type: 'string', value: '5444' },
           }),
-          description: 'DROP TABLE "User"',
-          op: 'db',
+          name: 'DROP TABLE "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
       ]),
-      extra: expect.objectContaining({
-        requestHookCalled: expect.objectContaining({
-          database: 'test_db',
-          host: 'localhost',
-          port: '5444',
-          sanitizedQuery: expect.any(String),
-        }),
-      }),
     };
 
     createEsmAndCjsTests(
@@ -339,7 +423,7 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
           'should call requestHook when provided',
           { timeout: 60_000 },
           async () => {
-            await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+            await createTestRunner().expect({ span: EXPECTED_SPANS }).start().completed();
           },
         );
       },
@@ -347,74 +431,76 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
   });
 
   describe('url initialization', () => {
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Transaction',
-      spans: expect.arrayContaining([
+    const EXPECTED_SPANS = {
+      items: expect.arrayContaining([
+        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'CREATE TABLE',
-            'db.query.text':
-              'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'CREATE TABLE' },
+            [DB_QUERY_TEXT]: {
+              type: 'string',
+              value:
+                'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
+            },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'CREATE TABLE "User"' },
           }),
-          description:
-            'CREATE TABLE "User" ("id" SERIAL NOT NULL,"createdAt" TIMESTAMP(?) NOT NULL DEFAULT CURRENT_TIMESTAMP,"email" TEXT NOT NULL,"name" TEXT,CONSTRAINT "User_pkey" PRIMARY KEY ("id"))',
-          op: 'db',
+          name: 'CREATE TABLE "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'INSERT',
-            'db.query.text': 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'INSERT' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'INSERT "User"' },
           }),
-          description: 'INSERT INTO "User" ("email", "name") VALUES ($1, ?)',
-          op: 'db',
+          name: 'INSERT "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'SELECT',
-            'db.query.text': 'SELECT * FROM "User" WHERE "email" = $1',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'SELECT' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "User" WHERE "email" = $1' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "User"' },
           }),
-          description: 'SELECT * FROM "User" WHERE "email" = $1',
-          op: 'db',
+          name: 'SELECT "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'DELETE',
-            'db.query.text': 'DELETE FROM "User" WHERE "email" = $1',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'DELETE' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'DELETE FROM "User" WHERE "email" = $1' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'DELETE "User"' },
           }),
-          description: 'DELETE FROM "User" WHERE "email" = $1',
-          op: 'db',
+          name: 'DELETE "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
       ]),
     };
@@ -424,80 +510,83 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
         'should instrument postgres package with URL initialization',
         { timeout: 90_000 },
         async () => {
-          await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+          await createTestRunner().ignore('event').expect({ span: EXPECTED_SPANS }).start().completed();
         },
       );
     });
   });
 
   describe('sql.unsafe()', () => {
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Transaction',
-      spans: expect.arrayContaining([
+    const EXPECTED_SPANS = {
+      items: expect.arrayContaining([
+        expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'CREATE TABLE',
-            'db.query.text': 'CREATE TABLE "User" ("id" SERIAL NOT NULL, "email" TEXT NOT NULL, PRIMARY KEY ("id"))',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'CREATE TABLE' },
+            [DB_QUERY_TEXT]: {
+              type: 'string',
+              value: 'CREATE TABLE "User" ("id" SERIAL NOT NULL, "email" TEXT NOT NULL, PRIMARY KEY ("id"))',
+            },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'CREATE TABLE "User"' },
           }),
-          description: 'CREATE TABLE "User" ("id" SERIAL NOT NULL, "email" TEXT NOT NULL, PRIMARY KEY ("id"))',
-          op: 'db',
+          name: 'CREATE TABLE "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
         // sql.unsafe() with $1 placeholders - preserved per OTEL spec
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'INSERT',
-            'db.query.text': 'INSERT INTO "User" ("email") VALUES ($1)',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'INSERT' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'INSERT INTO "User" ("email") VALUES ($1)' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'INSERT "User"' },
           }),
-          description: 'INSERT INTO "User" ("email") VALUES ($1)',
-          op: 'db',
+          name: 'INSERT "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'SELECT',
-            'db.query.text': 'SELECT * FROM "User" WHERE "email" = $1',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'SELECT' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'SELECT * FROM "User" WHERE "email" = $1' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'SELECT "User"' },
           }),
-          description: 'SELECT * FROM "User" WHERE "email" = $1',
-          op: 'db',
+          name: 'SELECT "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
         expect.objectContaining({
-          data: expect.objectContaining({
-            'db.namespace': 'test_db',
-            'db.system.name': 'postgres',
-            'db.operation.name': 'DROP TABLE',
-            'db.query.text': 'DROP TABLE "User"',
-            'sentry.op': 'db',
-            'sentry.origin': ORIGIN,
-            'server.address': 'localhost',
-            'server.port': 5444,
+          attributes: expect.objectContaining({
+            [DB_NAMESPACE]: { type: 'string', value: 'test_db' },
+            [DB_SYSTEM_NAME]: { type: 'string', value: 'postgres' },
+            [DB_OPERATION_NAME]: { type: 'string', value: 'DROP TABLE' },
+            [DB_QUERY_TEXT]: { type: 'string', value: 'DROP TABLE "User"' },
+            [SENTRY_OP]: { type: 'string', value: DB },
+            [SENTRY_ORIGIN]: { type: 'string', value: ORIGIN },
+            [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+            [SERVER_PORT]: { type: 'integer', value: 5444 },
+            [DB_QUERY_SUMMARY]: { type: 'string', value: 'DROP TABLE "User"' },
           }),
-          description: 'DROP TABLE "User"',
-          op: 'db',
+          name: 'DROP TABLE "User"',
           status: 'ok',
-          origin: ORIGIN,
+          is_segment: false,
         }),
       ]),
     };
@@ -509,7 +598,7 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
         async () => {
           // The last query fails on purpose, and its unhandled rejection also sends an error event, which can
           // arrive before the transaction.
-          await createTestRunner().ignore('event').expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
+          await createTestRunner().ignore('event').expect({ span: EXPECTED_SPANS }).start().completed();
         },
       );
     });

From 7707b3075a5b8489c9efe66f6b60a633bba8d162 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 21:02:51 +0200
Subject: [PATCH 47/84] test(node): Port MongoDB integration tests to span
 streaming (#25150)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Make the MongoDB 3–7 streaming tests the defaults and remove duplicate
transaction cases while preserving assertions.

Part of #24137

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../suites/tracing/mongodb-v4/instrument.mjs  |   1 -
 .../suites/tracing/mongodb-v4/test.ts         |  55 +--
 .../suites/tracing/mongodb-v5/instrument.mjs  |   1 -
 .../suites/tracing/mongodb-v5/test.ts         |  55 +--
 .../suites/tracing/mongodb-v6/instrument.mjs  |   1 -
 .../suites/tracing/mongodb-v6/test.ts         |  49 +--
 .../suites/tracing/mongodb-v7/instrument.mjs  |   1 -
 .../suites/tracing/mongodb-v7/test.ts         |  49 +--
 .../suites/tracing/mongodb/instrument.mjs     |   1 -
 .../suites/tracing/mongodb/test.ts            | 380 +++++-------------
 10 files changed, 129 insertions(+), 464 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/tracing/mongodb-v4/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/mongodb-v4/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongodb-v4/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/mongodb-v4/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongodb-v4/test.ts b/dev-packages/node-integration-tests/suites/tracing/mongodb-v4/test.ts
index 079e8565d3c5..1aa22d8230fe 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongodb-v4/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mongodb-v4/test.ts
@@ -1,5 +1,6 @@
 import {
   DB_COLLECTION_NAME,
+  DB_CONNECTION_STRING,
   DB_NAMESPACE,
   DB_OPERATION_NAME,
   DB_QUERY_TEXT,
@@ -8,7 +9,7 @@ import {
   SENTRY_ORIGIN,
   SENTRY_TRACE_LIFECYCLE,
 } from '@sentry/conventions/attributes';
-import type { SerializedStreamedSpanContainer, TransactionEvent } from '@sentry/core';
+import { DB } from '@sentry/conventions/op';
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
@@ -32,24 +33,6 @@ describe('MongoDB v4 auto-instrumentation', () => {
 
   const origin = 'auto.db.mongo';
 
-  const spanFor = (operation: string): unknown =>
-    expect.objectContaining({
-      data: expect.objectContaining({
-        [SENTRY_ORIGIN]: origin,
-        [SENTRY_OP]: 'db',
-        [DB_SYSTEM_NAME]: 'mongodb',
-        [DB_NAMESPACE]: 'admin',
-        [DB_COLLECTION_NAME]: 'movies',
-        [DB_OPERATION_NAME]: operation,
-        // `db.connection_string` has no `@sentry/conventions` constant — it stays inlined to match
-        // what `@opentelemetry/instrumentation-mongodb` emitted.
-        'db.connection_string': expect.any(String),
-        [DB_QUERY_TEXT]: expect.any(String),
-      }),
-      op: 'db',
-      origin,
-    });
-
   const streamedSpanFor = (operation: string): unknown =>
     expect.objectContaining({
       name: `${operation} movies`,
@@ -58,12 +41,12 @@ describe('MongoDB v4 auto-instrumentation', () => {
       status: 'ok',
       attributes: expect.objectContaining({
         [SENTRY_ORIGIN]: { type: 'string', value: origin },
-        [SENTRY_OP]: { type: 'string', value: 'db' },
+        [SENTRY_OP]: { type: 'string', value: DB },
         [DB_SYSTEM_NAME]: { type: 'string', value: 'mongodb' },
         [DB_NAMESPACE]: { type: 'string', value: 'admin' },
         [DB_COLLECTION_NAME]: { type: 'string', value: 'movies' },
         [DB_OPERATION_NAME]: { type: 'string', value: operation },
-        'db.connection_string': { type: 'string', value: expect.any(String) },
+        [DB_CONNECTION_STRING]: { type: 'string', value: expect.any(String) },
         [DB_QUERY_TEXT]: { type: 'string', value: expect.any(String) },
         [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
       }),
@@ -77,35 +60,7 @@ describe('MongoDB v4 auto-instrumentation', () => {
       test('auto-instruments `mongodb` (>= 4.0 < 6.4 callback command) and parents pooled ops correctly.', async () => {
         await createTestRunner()
           .expect({
-            transaction: (event: TransactionEvent) => {
-              const spans = event.spans || [];
-              expect(spans).toContainEqual(spanFor('insert'));
-              expect(spans).toContainEqual(spanFor('find'));
-              expect(spans).toContainEqual(spanFor('update'));
-
-              // Checkout context propagation: each `op-*` span must be the
-              // parent of its own find command. A lost context would collapse
-              // them onto one parent (or the transaction).
-              const opIds = new Set(spans.filter(s => /^op-[abc]$/.test(s.description ?? '')).map(s => s.span_id));
-              expect(opIds.size).toBe(3);
-              const pooledFinds = spans.filter(
-                s =>
-                  s.origin === origin &&
-                  (s.data as Record<string, unknown>)?.[DB_OPERATION_NAME] === 'find' &&
-                  opIds.has(s.parent_span_id as string),
-              );
-              expect(new Set(pooledFinds.map(s => s.parent_span_id)).size).toBe(3);
-            },
-          })
-          .start()
-          .completed();
-      });
-
-      test('auto-instruments `mongodb` and parents pooled ops correctly with span streaming enabled.', async () => {
-        await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
-          .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
+            span: container => {
               const spans = container.items;
               expect(spans).toContainEqual(streamedSpanFor('insert'));
               expect(spans).toContainEqual(streamedSpanFor('find'));
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongodb-v5/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/mongodb-v5/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongodb-v5/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/mongodb-v5/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongodb-v5/test.ts b/dev-packages/node-integration-tests/suites/tracing/mongodb-v5/test.ts
index c250d3375b04..ac3d08712184 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongodb-v5/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mongodb-v5/test.ts
@@ -1,5 +1,6 @@
 import {
   DB_COLLECTION_NAME,
+  DB_CONNECTION_STRING,
   DB_NAMESPACE,
   DB_OPERATION_NAME,
   DB_QUERY_TEXT,
@@ -8,7 +9,7 @@ import {
   SENTRY_ORIGIN,
   SENTRY_TRACE_LIFECYCLE,
 } from '@sentry/conventions/attributes';
-import type { SerializedStreamedSpanContainer, TransactionEvent } from '@sentry/core';
+import { DB } from '@sentry/conventions/op';
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
@@ -32,24 +33,6 @@ describe('MongoDB v5 auto-instrumentation', () => {
 
   const origin = 'auto.db.mongo';
 
-  const spanFor = (operation: string): unknown =>
-    expect.objectContaining({
-      data: expect.objectContaining({
-        [SENTRY_ORIGIN]: origin,
-        [SENTRY_OP]: 'db',
-        [DB_SYSTEM_NAME]: 'mongodb',
-        [DB_NAMESPACE]: 'admin',
-        [DB_COLLECTION_NAME]: 'movies',
-        [DB_OPERATION_NAME]: operation,
-        // `db.connection_string` has no `@sentry/conventions` constant — it stays inlined to match
-        // what `@opentelemetry/instrumentation-mongodb` emitted.
-        'db.connection_string': expect.any(String),
-        [DB_QUERY_TEXT]: expect.any(String),
-      }),
-      op: 'db',
-      origin,
-    });
-
   const streamedSpanFor = (operation: string): unknown =>
     expect.objectContaining({
       name: `${operation} movies`,
@@ -58,12 +41,12 @@ describe('MongoDB v5 auto-instrumentation', () => {
       status: 'ok',
       attributes: expect.objectContaining({
         [SENTRY_ORIGIN]: { type: 'string', value: origin },
-        [SENTRY_OP]: { type: 'string', value: 'db' },
+        [SENTRY_OP]: { type: 'string', value: DB },
         [DB_SYSTEM_NAME]: { type: 'string', value: 'mongodb' },
         [DB_NAMESPACE]: { type: 'string', value: 'admin' },
         [DB_COLLECTION_NAME]: { type: 'string', value: 'movies' },
         [DB_OPERATION_NAME]: { type: 'string', value: operation },
-        'db.connection_string': { type: 'string', value: expect.any(String) },
+        [DB_CONNECTION_STRING]: { type: 'string', value: expect.any(String) },
         [DB_QUERY_TEXT]: { type: 'string', value: expect.any(String) },
         [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
       }),
@@ -77,35 +60,7 @@ describe('MongoDB v5 auto-instrumentation', () => {
       test('auto-instruments `mongodb` (>= 4.0 < 6.4 callback command) and parents pooled ops correctly.', async () => {
         await createTestRunner()
           .expect({
-            transaction: (event: TransactionEvent) => {
-              const spans = event.spans || [];
-              expect(spans).toContainEqual(spanFor('insert'));
-              expect(spans).toContainEqual(spanFor('find'));
-              expect(spans).toContainEqual(spanFor('update'));
-
-              // Checkout context propagation: each `op-*` span must be the
-              // parent of its own find command. A lost context would collapse
-              // them onto one parent (or the transaction).
-              const opIds = new Set(spans.filter(s => /^op-[abc]$/.test(s.description ?? '')).map(s => s.span_id));
-              expect(opIds.size).toBe(3);
-              const pooledFinds = spans.filter(
-                s =>
-                  s.origin === origin &&
-                  (s.data as Record<string, unknown>)?.[DB_OPERATION_NAME] === 'find' &&
-                  opIds.has(s.parent_span_id as string),
-              );
-              expect(new Set(pooledFinds.map(s => s.parent_span_id)).size).toBe(3);
-            },
-          })
-          .start()
-          .completed();
-      });
-
-      test('auto-instruments `mongodb` and parents pooled ops correctly with span streaming enabled.', async () => {
-        await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
-          .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
+            span: container => {
               const spans = container.items;
               expect(spans).toContainEqual(streamedSpanFor('insert'));
               expect(spans).toContainEqual(streamedSpanFor('find'));
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongodb-v6/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/mongodb-v6/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongodb-v6/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/mongodb-v6/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongodb-v6/test.ts b/dev-packages/node-integration-tests/suites/tracing/mongodb-v6/test.ts
index 32bb93fa4af7..5033b4bbe039 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongodb-v6/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mongodb-v6/test.ts
@@ -1,5 +1,6 @@
 import {
   DB_COLLECTION_NAME,
+  DB_CONNECTION_STRING,
   DB_NAMESPACE,
   DB_OPERATION_NAME,
   DB_QUERY_TEXT,
@@ -8,7 +9,7 @@ import {
   SENTRY_ORIGIN,
   SENTRY_TRACE_LIFECYCLE,
 } from '@sentry/conventions/attributes';
-import type { SerializedStreamedSpanContainer, TransactionEvent } from '@sentry/core';
+import { DB } from '@sentry/conventions/op';
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
@@ -35,24 +36,6 @@ describe('MongoDB v6 auto-instrumentation', () => {
   // `db.statement` (scrubbed full command doc) and `db.connection_string` vary
   // by driver version, so assert their presence rather than exact content;
   // the operation-identifying attributes are exact.
-  const spanFor = (operation: string): unknown =>
-    expect.objectContaining({
-      data: expect.objectContaining({
-        [SENTRY_ORIGIN]: origin,
-        [SENTRY_OP]: 'db',
-        [DB_SYSTEM_NAME]: 'mongodb',
-        [DB_NAMESPACE]: 'admin',
-        [DB_COLLECTION_NAME]: 'movies',
-        [DB_OPERATION_NAME]: operation,
-        // `db.connection_string` has no `@sentry/conventions` constant — it stays inlined to match
-        // what `@opentelemetry/instrumentation-mongodb` emitted.
-        'db.connection_string': expect.any(String),
-        [DB_QUERY_TEXT]: expect.any(String),
-      }),
-      op: 'db',
-      origin,
-    });
-
   const streamedSpanFor = (operation: string): unknown =>
     expect.objectContaining({
       name: `${operation} movies`,
@@ -61,12 +44,12 @@ describe('MongoDB v6 auto-instrumentation', () => {
       status: 'ok',
       attributes: expect.objectContaining({
         [SENTRY_ORIGIN]: { type: 'string', value: origin },
-        [SENTRY_OP]: { type: 'string', value: 'db' },
+        [SENTRY_OP]: { type: 'string', value: DB },
         [DB_SYSTEM_NAME]: { type: 'string', value: 'mongodb' },
         [DB_NAMESPACE]: { type: 'string', value: 'admin' },
         [DB_COLLECTION_NAME]: { type: 'string', value: 'movies' },
         [DB_OPERATION_NAME]: { type: 'string', value: operation },
-        'db.connection_string': { type: 'string', value: expect.any(String) },
+        [DB_CONNECTION_STRING]: { type: 'string', value: expect.any(String) },
         [DB_QUERY_TEXT]: { type: 'string', value: expect.any(String) },
         [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
       }),
@@ -80,29 +63,7 @@ describe('MongoDB v6 auto-instrumentation', () => {
       test('auto-instruments modern `mongodb` (>= 6.4 promise command).', async () => {
         await createTestRunner()
           .expect({
-            transaction: (event: TransactionEvent) => {
-              const spans = event.spans || [];
-              expect(spans).toContainEqual(spanFor('insert'));
-              expect(spans).toContainEqual(spanFor('find'));
-              expect(spans).toContainEqual(spanFor('update'));
-              // No orphaned handshake/heartbeat spans!
-              // every command span has a parent.
-              const mongoSpans = spans.filter(s => s.origin === origin);
-              expect(mongoSpans.length).toBeGreaterThan(0);
-              for (const s of mongoSpans) {
-                expect(s.parent_span_id).toBeTruthy();
-              }
-            },
-          })
-          .start()
-          .completed();
-      });
-
-      test('auto-instruments modern `mongodb` with span streaming enabled.', async () => {
-        await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
-          .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
+            span: container => {
               const spans = container.items;
               expect(spans).toContainEqual(streamedSpanFor('insert'));
               expect(spans).toContainEqual(streamedSpanFor('find'));
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongodb-v7/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/mongodb-v7/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongodb-v7/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/mongodb-v7/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongodb-v7/test.ts b/dev-packages/node-integration-tests/suites/tracing/mongodb-v7/test.ts
index f367ae15ae4c..f38fed0f1692 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongodb-v7/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mongodb-v7/test.ts
@@ -1,5 +1,6 @@
 import {
   DB_COLLECTION_NAME,
+  DB_CONNECTION_STRING,
   DB_NAMESPACE,
   DB_OPERATION_NAME,
   DB_QUERY_TEXT,
@@ -8,7 +9,7 @@ import {
   SENTRY_ORIGIN,
   SENTRY_TRACE_LIFECYCLE,
 } from '@sentry/conventions/attributes';
-import type { SerializedStreamedSpanContainer, TransactionEvent } from '@sentry/core';
+import { DB } from '@sentry/conventions/op';
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
@@ -35,24 +36,6 @@ describe('MongoDB v7 auto-instrumentation', () => {
   // `db.statement` (scrubbed full command doc) and `db.connection_string` vary
   // by driver version, so assert their presence rather than exact content;
   // the operation-identifying attributes are exact.
-  const spanFor = (operation: string): unknown =>
-    expect.objectContaining({
-      data: expect.objectContaining({
-        [SENTRY_ORIGIN]: origin,
-        [SENTRY_OP]: 'db',
-        [DB_SYSTEM_NAME]: 'mongodb',
-        [DB_NAMESPACE]: 'admin',
-        [DB_COLLECTION_NAME]: 'movies',
-        [DB_OPERATION_NAME]: operation,
-        // `db.connection_string` has no `@sentry/conventions` constant — it stays inlined to match
-        // what `@opentelemetry/instrumentation-mongodb` emitted.
-        'db.connection_string': expect.any(String),
-        [DB_QUERY_TEXT]: expect.any(String),
-      }),
-      op: 'db',
-      origin,
-    });
-
   const streamedSpanFor = (operation: string): unknown =>
     expect.objectContaining({
       name: `${operation} movies`,
@@ -61,12 +44,12 @@ describe('MongoDB v7 auto-instrumentation', () => {
       status: 'ok',
       attributes: expect.objectContaining({
         [SENTRY_ORIGIN]: { type: 'string', value: origin },
-        [SENTRY_OP]: { type: 'string', value: 'db' },
+        [SENTRY_OP]: { type: 'string', value: DB },
         [DB_SYSTEM_NAME]: { type: 'string', value: 'mongodb' },
         [DB_NAMESPACE]: { type: 'string', value: 'admin' },
         [DB_COLLECTION_NAME]: { type: 'string', value: 'movies' },
         [DB_OPERATION_NAME]: { type: 'string', value: operation },
-        'db.connection_string': { type: 'string', value: expect.any(String) },
+        [DB_CONNECTION_STRING]: { type: 'string', value: expect.any(String) },
         [DB_QUERY_TEXT]: { type: 'string', value: expect.any(String) },
         [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
       }),
@@ -80,29 +63,7 @@ describe('MongoDB v7 auto-instrumentation', () => {
       test('auto-instruments modern `mongodb` (>= 6.4 promise command).', async () => {
         await createTestRunner()
           .expect({
-            transaction: (event: TransactionEvent) => {
-              const spans = event.spans || [];
-              expect(spans).toContainEqual(spanFor('insert'));
-              expect(spans).toContainEqual(spanFor('find'));
-              expect(spans).toContainEqual(spanFor('update'));
-              // No orphaned handshake/heartbeat spans!
-              // every command span has a parent.
-              const mongoSpans = spans.filter(s => s.origin === origin);
-              expect(mongoSpans.length).toBeGreaterThan(0);
-              for (const s of mongoSpans) {
-                expect(s.parent_span_id).toBeTruthy();
-              }
-            },
-          })
-          .start()
-          .completed();
-      });
-
-      test('auto-instruments modern `mongodb` with span streaming enabled.', async () => {
-        await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
-          .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
+            span: container => {
               const spans = container.items;
               expect(spans).toContainEqual(streamedSpanFor('insert'));
               expect(spans).toContainEqual(streamedSpanFor('find'));
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongodb/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/mongodb/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongodb/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/mongodb/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongodb/test.ts b/dev-packages/node-integration-tests/suites/tracing/mongodb/test.ts
index f0f45e51f35c..c24482f7fa24 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongodb/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mongodb/test.ts
@@ -1,11 +1,13 @@
 import {
   DB_COLLECTION_NAME,
+  DB_CONNECTION_STRING,
   DB_NAMESPACE,
   DB_OPERATION_NAME,
   DB_QUERY_TEXT,
   DB_SYSTEM_NAME,
   ERROR_TYPE,
   SENTRY_ENVIRONMENT,
+  SENTRY_IS_LOCALHOST,
   SENTRY_KIND,
   SENTRY_OP,
   SENTRY_ORIGIN,
@@ -17,11 +19,11 @@ import {
   SENTRY_STATUS_MESSAGE,
   SENTRY_TRACE_LIFECYCLE,
   SERVER_ADDRESS,
+  SERVER_PORT,
 } from '@sentry/conventions/attributes';
-import type { SerializedStreamedSpanContainer, TransactionEvent } from '@sentry/core';
+import { DB } from '@sentry/conventions/op';
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
-import { assertSentryTransaction } from '../../../utils/assertions';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 describe('MongoDB auto-instrumentation', () => {
@@ -40,144 +42,131 @@ describe('MongoDB auto-instrumentation', () => {
     cleanupChildProcesses();
   });
 
-  const SPAN_FIND_MATCHER = expect.objectContaining({
-    data: {
-      'sentry.origin': origin,
-      'sentry.op': 'db',
-      'db.system.name': 'mongodb',
-      'db.namespace': 'admin',
-      'db.collection.name': 'movies',
-      'db.operation.name': 'find',
-      'db.connection_string': expect.any(String),
-      'server.address': expect.any(String),
-      'server.port': expect.any(Number),
-      'db.query.text': '{"title":"?"}',
-      'sentry.kind': 'client',
+  const streamAttributes = (values: Record<string, unknown>): Record<string, unknown> =>
+    Object.fromEntries(Object.entries(values).map(([key, value]) => [key, { type: 'string', value }]));
+
+  function streamedSpan({
+    name,
+    status = 'ok',
+    attributes,
+  }: {
+    name: string;
+    status?: string;
+    attributes: Record<string, unknown>;
+  }): unknown {
+    return {
+      name,
+      attributes: {
+        ...streamAttributes({
+          [DB_CONNECTION_STRING]: expect.any(String),
+          [DB_NAMESPACE]: 'admin',
+          [DB_SYSTEM_NAME]: 'mongodb',
+          [SENTRY_ENVIRONMENT]: 'production',
+          [SENTRY_KIND]: 'client',
+          [SENTRY_OP]: DB,
+          [SENTRY_ORIGIN]: origin,
+          [SENTRY_RELEASE]: '1.0',
+          [SENTRY_SDK_NAME]: 'sentry.javascript.node',
+          [SENTRY_SDK_VERSION]: expect.any(String),
+          [SENTRY_SEGMENT_ID]: expect.stringMatching(/^[\da-f]{16}$/),
+          [SENTRY_SEGMENT_NAME]: 'Test Transaction',
+          [SERVER_ADDRESS]: expect.any(String),
+          [SENTRY_TRACE_LIFECYCLE]: 'stream',
+          ...attributes,
+        }),
+        [SERVER_PORT]: { type: 'integer', value: expect.any(Number) },
+        [SENTRY_IS_LOCALHOST]: { type: 'boolean', value: false },
+      },
+      end_timestamp: expect.any(Number),
+      is_segment: false,
+      parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+      start_timestamp: expect.any(Number),
+      status,
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+    };
+  }
+
+  const STREAMED_FIND_MATCHER = streamedSpan({
+    name: 'find movies',
+    attributes: {
+      [DB_COLLECTION_NAME]: 'movies',
+      [DB_OPERATION_NAME]: 'find',
+      [DB_QUERY_TEXT]: '{"title":"?"}',
     },
-    description: '{"title":"?"}',
-    op: 'db',
-    origin,
   });
 
-  const SPAN_INSERT_MATCHER = expect.objectContaining({
-    data: {
-      'sentry.origin': origin,
-      'sentry.op': 'db',
-      'db.system.name': 'mongodb',
-      'db.namespace': 'admin',
-      'db.collection.name': 'movies',
-      'db.operation.name': 'insert',
-      'db.connection_string': expect.any(String),
-      'server.address': expect.any(String),
-      'server.port': expect.any(Number),
-      'db.query.text': '{"title":"?","_id":{"_bsontype":"?","id":"?"}}',
-      'sentry.kind': 'client',
+  const STREAMED_INSERT_MATCHER = streamedSpan({
+    name: 'insert movies',
+    attributes: {
+      [DB_COLLECTION_NAME]: 'movies',
+      [DB_OPERATION_NAME]: 'insert',
+      [DB_QUERY_TEXT]: '{"title":"?","_id":{"_bsontype":"?","id":"?"}}',
     },
-    description: '{"title":"?","_id":{"_bsontype":"?","id":"?"}}',
-    op: 'db',
-    origin,
   });
 
-  const SPAN_ISMASTER_MATCHER = expect.objectContaining({
-    data: {
-      'sentry.origin': origin,
-      'sentry.op': 'db',
-      'db.system.name': 'mongodb',
-      'db.namespace': 'admin',
-      'db.collection.name': '$cmd',
-      'db.operation.name': 'isMaster',
-      'db.connection_string': expect.any(String),
-      'server.address': expect.any(String),
-      'server.port': expect.any(Number),
-      'db.query.text':
+  const STREAMED_ISMASTER_MATCHER = streamedSpan({
+    name: 'isMaster $cmd',
+    attributes: {
+      [DB_COLLECTION_NAME]: '$cmd',
+      [DB_OPERATION_NAME]: 'isMaster',
+      [DB_QUERY_TEXT]:
         '{"ismaster":"?","client":{"driver":{"name":"?","version":"?"},"os":{"type":"?","name":"?","architecture":"?","version":"?"},"platform":"?"},"compression":[],"helloOk":"?"}',
-      'sentry.kind': 'client',
     },
-    description:
-      '{"ismaster":"?","client":{"driver":{"name":"?","version":"?"},"os":{"type":"?","name":"?","architecture":"?","version":"?"},"platform":"?"},"compression":[],"helloOk":"?"}',
-    op: 'db',
-    origin,
   });
 
-  const SPAN_UPDATE_MATCHER = expect.objectContaining({
-    data: {
-      'sentry.origin': origin,
-      'sentry.op': 'db',
-      'db.system.name': 'mongodb',
-      'db.namespace': 'admin',
-      'db.collection.name': 'movies',
-      'db.operation.name': 'update',
-      'db.connection_string': expect.any(String),
-      'server.address': expect.any(String),
-      'server.port': expect.any(Number),
-      'db.query.text': '{"title":"?"}',
-      'sentry.kind': 'client',
+  const STREAMED_UPDATE_MATCHER = streamedSpan({
+    name: 'update movies',
+    attributes: {
+      [DB_COLLECTION_NAME]: 'movies',
+      [DB_OPERATION_NAME]: 'update',
+      [DB_QUERY_TEXT]: '{"title":"?"}',
     },
-    description: '{"title":"?"}',
-    op: 'db',
-    origin,
   });
 
   // A query the server rejects: same attributes as a successful find, but with an error status.
-  const SPAN_FIND_ERROR_MATCHER = expect.objectContaining({
-    data: expect.objectContaining({
-      'sentry.origin': origin,
-      'sentry.op': 'db',
-      'db.system.name': 'mongodb',
-      'db.operation.name': 'find',
-      'db.query.text': '{"$thisOperatorDoesNotExist":"?"}',
-      'sentry.kind': 'client',
-    }),
-    description: '{"$thisOperatorDoesNotExist":"?"}',
-    op: 'db',
-    origin,
-    status: 'internal_error',
+  const STREAMED_FIND_ERROR_MATCHER = streamedSpan({
+    name: 'find movies',
+    status: 'error',
+    attributes: {
+      [DB_COLLECTION_NAME]: 'movies',
+      [DB_OPERATION_NAME]: 'find',
+      [DB_QUERY_TEXT]: '{"$thisOperatorDoesNotExist":"?"}',
+      [ERROR_TYPE]: 'MongoError',
+      [SENTRY_STATUS_MESSAGE]: expect.any(String),
+    },
   });
 
-  const SPAN_ENDSESSIONS_MATCHER = expect.objectContaining({
-    data: {
-      'sentry.origin': origin,
-      'sentry.op': 'db',
-      'db.system.name': 'mongodb',
-      'db.namespace': 'admin',
-      'db.collection.name': '$cmd',
-      'db.connection_string': expect.any(String),
-      'server.address': expect.any(String),
-      'server.port': expect.any(Number),
-      'db.query.text': '{"endSessions":[{"id":{"_bsontype":"?","sub_type":"?","position":"?","buffer":"?"}}]}',
-      'sentry.kind': 'client',
+  // `endSessions` exposes no operation name, so the span falls back to the collection alone.
+  const STREAMED_ENDSESSIONS_MATCHER = streamedSpan({
+    name: '$cmd',
+    attributes: {
+      [DB_COLLECTION_NAME]: '$cmd',
+      [DB_QUERY_TEXT]: '{"endSessions":[{"id":{"_bsontype":"?","sub_type":"?","position":"?","buffer":"?"}}]}',
     },
-    description: '{"endSessions":[{"id":{"_bsontype":"?","sub_type":"?","position":"?","buffer":"?"}}]}',
-    op: 'db',
-    origin,
   });
 
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createTestRunner, test) => {
     test('should auto-instrument `mongodb` package.', async () => {
       await createTestRunner()
         .expect({
-          transaction: (txn: TransactionEvent) => {
-            assertSentryTransaction(txn, { transaction: 'Test Transaction' });
-            const spans = txn.spans || [];
+          span: container => {
+            expect(container.items.find(item => item.is_segment)).toMatchObject({
+              name: 'Test Transaction',
+              span_id: expect.any(String),
+              start_timestamp: expect.anything(),
+              end_timestamp: expect.anything(),
+            });
+
+            const spans = container.items.filter(item => !item.is_segment);
 
-            // Assert the per-operation breakdown rather than just a total span
-            // count. When the driver occasionally emits an extra command
-            // (e.g. a stray `isMaster` from a reconnect, a `ping`, or a
-            // heartbeat), `toEqual` shows a clear per-operation diff like
-            // "isMaster: 2 → 3" instead of an opaque "8 vs 9" length
-            // mismatch — making future flakes self-diagnosing.
-            //
-            // `db.operation` isn't set on every span — the `endSessions`
-            // command exposes its name only via `db.statement` — so derive
-            // the operation by parsing the leading command name out of
-            // `db.statement` as a fallback.
+            // Count by operation so an extra driver command produces a readable diff.
             const operationCounts = spans.reduce<Record<string, number>>((acc, span) => {
-              const data = (span.data ?? {}) as Record<string, unknown>;
-              let op =
-                typeof data['db.operation.name'] === 'string' ? (data['db.operation.name'] as string) : undefined;
+              const operation = span.attributes[DB_OPERATION_NAME]?.value;
+              let op = typeof operation === 'string' ? operation : undefined;
               if (!op) {
-                const stmt = data['db.query.text'];
-                const match = typeof stmt === 'string' ? stmt.match(/^\{"(\w+)"/) : null;
+                const statement = span.attributes[DB_QUERY_TEXT]?.value;
+                const match = typeof statement === 'string' ? statement.match(/^\{"(\w+)"/) : null;
                 op = match ? match[1] : 'unknown';
               }
               acc[op] = (acc[op] || 0) + 1;
@@ -192,167 +181,16 @@ describe('MongoDB auto-instrumentation', () => {
               endSessions: 1,
             });
 
-            expect(spans).toContainEqual(SPAN_FIND_MATCHER);
-            expect(spans).toContainEqual(SPAN_INSERT_MATCHER);
-            expect(spans).toContainEqual(SPAN_ISMASTER_MATCHER);
-            expect(spans).toContainEqual(SPAN_UPDATE_MATCHER);
-            expect(spans).toContainEqual(SPAN_FIND_ERROR_MATCHER);
-            expect(spans).toContainEqual(SPAN_ENDSESSIONS_MATCHER);
+            expect(spans).toContainEqual(STREAMED_FIND_MATCHER);
+            expect(spans).toContainEqual(STREAMED_INSERT_MATCHER);
+            expect(spans).toContainEqual(STREAMED_ISMASTER_MATCHER);
+            expect(spans).toContainEqual(STREAMED_UPDATE_MATCHER);
+            expect(spans).toContainEqual(STREAMED_FIND_ERROR_MATCHER);
+            expect(spans).toContainEqual(STREAMED_ENDSESSIONS_MATCHER);
           },
         })
         .start()
         .completed();
     });
   });
-
-  describe('streamed', () => {
-    const streamAttributes = (values: Record<string, unknown>): Record<string, unknown> =>
-      Object.fromEntries(Object.entries(values).map(([key, value]) => [key, { type: 'string', value }]));
-
-    function streamedSpan({
-      name,
-      status = 'ok',
-      attributes,
-    }: {
-      name: string;
-      status?: string;
-      attributes: Record<string, unknown>;
-    }): unknown {
-      return {
-        name,
-        attributes: {
-          ...streamAttributes({
-            'db.connection_string': expect.any(String),
-            [DB_NAMESPACE]: 'admin',
-            [DB_SYSTEM_NAME]: 'mongodb',
-            [SENTRY_ENVIRONMENT]: 'production',
-            [SENTRY_KIND]: 'client',
-            [SENTRY_OP]: 'db',
-            [SENTRY_ORIGIN]: origin,
-            [SENTRY_RELEASE]: '1.0',
-            [SENTRY_SDK_NAME]: 'sentry.javascript.node',
-            [SENTRY_SDK_VERSION]: expect.any(String),
-            [SENTRY_SEGMENT_ID]: expect.stringMatching(/^[\da-f]{16}$/),
-            [SENTRY_SEGMENT_NAME]: 'Test Transaction',
-            [SERVER_ADDRESS]: expect.any(String),
-            [SENTRY_TRACE_LIFECYCLE]: 'stream',
-            ...attributes,
-          }),
-          'server.port': { type: 'integer', value: expect.any(Number) },
-          'sentry.is_localhost': { type: 'boolean', value: false },
-        },
-        end_timestamp: expect.any(Number),
-        is_segment: false,
-        parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
-        span_id: expect.stringMatching(/^[\da-f]{16}$/),
-        start_timestamp: expect.any(Number),
-        status,
-        trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      };
-    }
-
-    const STREAMED_FIND_MATCHER = streamedSpan({
-      name: 'find movies',
-      attributes: {
-        [DB_COLLECTION_NAME]: 'movies',
-        [DB_OPERATION_NAME]: 'find',
-        [DB_QUERY_TEXT]: '{"title":"?"}',
-      },
-    });
-
-    const STREAMED_INSERT_MATCHER = streamedSpan({
-      name: 'insert movies',
-      attributes: {
-        [DB_COLLECTION_NAME]: 'movies',
-        [DB_OPERATION_NAME]: 'insert',
-        [DB_QUERY_TEXT]: '{"title":"?","_id":{"_bsontype":"?","id":"?"}}',
-      },
-    });
-
-    const STREAMED_ISMASTER_MATCHER = streamedSpan({
-      name: 'isMaster $cmd',
-      attributes: {
-        [DB_COLLECTION_NAME]: '$cmd',
-        [DB_OPERATION_NAME]: 'isMaster',
-        [DB_QUERY_TEXT]:
-          '{"ismaster":"?","client":{"driver":{"name":"?","version":"?"},"os":{"type":"?","name":"?","architecture":"?","version":"?"},"platform":"?"},"compression":[],"helloOk":"?"}',
-      },
-    });
-
-    const STREAMED_UPDATE_MATCHER = streamedSpan({
-      name: 'update movies',
-      attributes: {
-        [DB_COLLECTION_NAME]: 'movies',
-        [DB_OPERATION_NAME]: 'update',
-        [DB_QUERY_TEXT]: '{"title":"?"}',
-      },
-    });
-
-    // A query the server rejects: same attributes as a successful find, but with an error status.
-    const STREAMED_FIND_ERROR_MATCHER = streamedSpan({
-      name: 'find movies',
-      status: 'error',
-      attributes: {
-        [DB_COLLECTION_NAME]: 'movies',
-        [DB_OPERATION_NAME]: 'find',
-        [DB_QUERY_TEXT]: '{"$thisOperatorDoesNotExist":"?"}',
-        [ERROR_TYPE]: 'MongoError',
-        [SENTRY_STATUS_MESSAGE]: expect.any(String),
-      },
-    });
-
-    // `endSessions` exposes no operation name, so the span falls back to the collection alone.
-    const STREAMED_ENDSESSIONS_MATCHER = streamedSpan({
-      name: '$cmd',
-      attributes: {
-        [DB_COLLECTION_NAME]: '$cmd',
-        [DB_QUERY_TEXT]: '{"endSessions":[{"id":{"_bsontype":"?","sub_type":"?","position":"?","buffer":"?"}}]}',
-      },
-    });
-
-    createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createTestRunner, test) => {
-      test('should auto-instrument `mongodb` package with span streaming enabled.', async () => {
-        await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
-          .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
-              expect(container.items.find(item => item.is_segment)?.name).toBe('Test Transaction');
-
-              const spans = container.items.filter(item => !item.is_segment);
-
-              // Same per-operation breakdown as the transaction-based test above, so an extra
-              // driver command shows up as a readable per-operation diff.
-              const operationCounts = spans.reduce<Record<string, number>>((acc, span) => {
-                const operation = span.attributes['db.operation.name']?.value;
-                let op = typeof operation === 'string' ? operation : undefined;
-                if (!op) {
-                  const statement = span.attributes['db.query.text']?.value;
-                  const match = typeof statement === 'string' ? statement.match(/^\{"(\w+)"/) : null;
-                  op = match ? match[1] : 'unknown';
-                }
-                acc[op] = (acc[op] || 0) + 1;
-                return acc;
-              }, {});
-
-              expect(operationCounts).toEqual({
-                find: 4,
-                isMaster: 2,
-                insert: 1,
-                update: 1,
-                endSessions: 1,
-              });
-
-              expect(spans).toContainEqual(STREAMED_FIND_MATCHER);
-              expect(spans).toContainEqual(STREAMED_INSERT_MATCHER);
-              expect(spans).toContainEqual(STREAMED_ISMASTER_MATCHER);
-              expect(spans).toContainEqual(STREAMED_UPDATE_MATCHER);
-              expect(spans).toContainEqual(STREAMED_FIND_ERROR_MATCHER);
-              expect(spans).toContainEqual(STREAMED_ENDSESSIONS_MATCHER);
-            },
-          })
-          .start()
-          .completed();
-      });
-    });
-  });
 });

From a9dd5d5bc1470770e89569599ad3c93dc6173b61 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 21:03:21 +0200
Subject: [PATCH 48/84] test(node): Port Redis integration tests to span
 streaming (#25153)

Make the Redis/cache streaming tests the defaults while retaining the
original ioredis cache transaction test in its existing suite.

Part of #24137

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../suites/tracing/ioredis-dc/instrument.mjs  |   1 -
 .../suites/tracing/ioredis-dc/test.ts         | 349 +++----
 .../redis-cache/instrument-redis-4.mjs        |   1 -
 .../redis-cache/instrument-redis-5.mjs        |   1 -
 .../suites/tracing/redis-cache/test.ts        | 922 ++++--------------
 .../suites/tracing/redis-dc/instrument.mjs    |   1 -
 .../suites/tracing/redis-dc/test.ts           | 413 +++-----
 .../suites/tracing/redis/instrument.mjs       |   1 -
 .../suites/tracing/redis/test.ts              | 189 ++--
 9 files changed, 561 insertions(+), 1317 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/instrument.mjs
index c0a1998369a5..db5276b8c536 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/test.ts b/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/test.ts
index e6866955ca5c..d854e0386637 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/ioredis-dc/test.ts
@@ -1,6 +1,28 @@
-import { SENTRY_TRACE_LIFECYCLE } from '@sentry/conventions/attributes';
-import type { SerializedStreamedSpanContainer } from '@sentry/core';
-import { afterAll, describe, expect } from 'vitest';
+import {
+  CACHE_HIT,
+  CACHE_ITEM_SIZE,
+  CACHE_KEY,
+  CACHE_OPERATION,
+  DB_OPERATION_NAME,
+  DB_QUERY_TEXT,
+  DB_SYSTEM_NAME,
+  NETWORK_PEER_ADDRESS,
+  NETWORK_PEER_PORT,
+  SENTRY_ENVIRONMENT,
+  SENTRY_IS_LOCALHOST,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_RELEASE,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SEGMENT_NAME,
+  SENTRY_TRACE_LIFECYCLE,
+  SERVER_ADDRESS,
+  SERVER_PORT,
+} from '@sentry/conventions/attributes';
+import { CACHE_GET, CACHE_PUT, type CACHE_REMOVE, DB_QUERY } from '@sentry/conventions/op';
+import { afterAll, expect } from 'vitest';
 import { EXPECTED_SDK_NAME } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
@@ -12,228 +34,123 @@ describeWithDockerCompose(
       cleanupChildProcesses();
     });
 
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Span IORedis 5.11 DC',
-      spans: expect.arrayContaining([
-        expect.objectContaining({
-          op: 'db.query',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.op': 'db.query',
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.system.name': 'redis',
-            'db.query.text': 'set dc-test-key ?',
-          }),
-        }),
-        expect.objectContaining({
-          description: 'dc-cache:test-key',
-          op: 'cache.put',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.query.text': 'set dc-cache:test-key ?',
-            'cache.key': ['dc-cache:test-key'],
-            'cache.item_size': 2,
-          }),
-        }),
-        expect.objectContaining({
-          description: 'dc-cache:test-key-ex',
-          op: 'cache.put',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.query.text': 'set dc-cache:test-key-ex ? ? ?',
-            'cache.key': ['dc-cache:test-key-ex'],
-            'cache.item_size': 2,
-          }),
-        }),
-        expect.objectContaining({
-          op: 'db.query',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.op': 'db.query',
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.system.name': 'redis',
-            'db.query.text': 'get dc-test-key',
-          }),
-        }),
-        expect.objectContaining({
-          description: 'dc-cache:test-key',
-          op: 'cache.get',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.query.text': 'get dc-cache:test-key',
-            'cache.hit': true,
-            'cache.key': ['dc-cache:test-key'],
-            'cache.item_size': 10,
-          }),
-        }),
-        expect.objectContaining({
-          description: 'dc-cache:unavailable-data',
-          op: 'cache.get',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.query.text': 'get dc-cache:unavailable-data',
-            'cache.hit': false,
-            'cache.key': ['dc-cache:unavailable-data'],
-          }),
-        }),
-        expect.objectContaining({
-          op: 'db.query',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.op': 'db.query',
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.system.name': 'redis',
-            'db.query.text': 'mget ? ? ?',
-          }),
-        }),
-      ]),
-    };
-
-    const EXPECTED_CONNECT = {
-      transaction: 'redis-connect',
-    };
+    const ORIGIN = 'auto.db.redis.diagnostic_channel';
+    const SEGMENT_NAME = 'Test Span IORedis 5.11 DC';
+    const HOST = '127.0.0.1';
+    const PORT = 6382;
 
-    createEsmAndCjsTests(__dirname, 'scenario-ioredis-5-11.mjs', 'instrument.mjs', (createTestRunner, test) => {
-      test('creates spans for ioredis v5.11 commands via diagnostics_channel', { timeout: 75_000 }, async () => {
-        await createTestRunner()
-          .expect({ transaction: EXPECTED_CONNECT })
-          .expect({ transaction: EXPECTED_TRANSACTION })
-          .start()
-          .completed();
-      });
+    const streamAttribute = (value: unknown): { type: string; value: unknown } => ({
+      type: Array.isArray(value) ? 'array' : Number.isInteger(value) ? 'integer' : typeof value,
+      value,
     });
 
-    // The same commands as above, asserted on the streamed span container. With span streaming the
-    // db spans are named `{db.operation.name} {server.address}:{server.port}` instead of
-    // `redis-{command}`. ioredis reports its commands lowercase, so the name follows suit.
-    describe('streamed', () => {
-      const ORIGIN = 'auto.db.redis.diagnostic_channel';
-      const SEGMENT_NAME = 'Test Span IORedis 5.11 DC';
-      const HOST = '127.0.0.1';
-      const PORT = 6382;
-
-      const streamAttribute = (value: unknown): { type: string; value: unknown } => ({
-        type: Array.isArray(value) ? 'array' : Number.isInteger(value) ? 'integer' : typeof value,
-        value,
-      });
-
-      // Streamed spans carry `{ type, value }` attribute pairs; the expectations below are written
-      // as plain values and wrapped here.
-      const streamAttributes = (values: Record<string, unknown>): Record<string, unknown> =>
-        Object.fromEntries(Object.entries(values).map(([key, value]) => [key, streamAttribute(value)]));
+    // Streamed spans carry `{ type, value }` attribute pairs; the expectations below are written
+    // as plain values and wrapped here.
+    const streamAttributes = (values: Record<string, unknown>): Record<string, unknown> =>
+      Object.fromEntries(Object.entries(values).map(([key, value]) => [key, streamAttribute(value)]));
 
-      function streamedSpan(name: string, op: string, attributes: Record<string, unknown>): unknown {
-        return {
-          name,
-          attributes: {
-            ...streamAttributes({
-              'db.system.name': 'redis',
-              'sentry.environment': 'production',
-              'sentry.op': op,
-              'sentry.origin': ORIGIN,
-              'sentry.release': '1.0',
-              'sentry.sdk.name': EXPECTED_SDK_NAME,
-              'sentry.segment.name': SEGMENT_NAME,
-              'server.address': HOST,
-              'server.port': PORT,
-              [SENTRY_TRACE_LIFECYCLE]: 'stream',
-              ...attributes,
-            }),
-            'sentry.sdk.version': { type: 'string', value: expect.any(String) },
-            'sentry.segment.id': { type: 'string', value: expect.stringMatching(/^[\da-f]{16}$/) },
-            'sentry.is_localhost': { type: 'boolean', value: false },
-          },
-          end_timestamp: expect.any(Number),
-          is_segment: false,
-          parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
-          span_id: expect.stringMatching(/^[\da-f]{16}$/),
-          start_timestamp: expect.any(Number),
-          status: 'ok',
-          trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-        };
-      }
+    function streamedSpan(name: string, op: string, attributes: Record<string, unknown>): unknown {
+      return {
+        name,
+        attributes: {
+          ...streamAttributes({
+            [DB_SYSTEM_NAME]: 'redis',
+            [SENTRY_ENVIRONMENT]: 'production',
+            [SENTRY_OP]: op,
+            [SENTRY_ORIGIN]: ORIGIN,
+            [SENTRY_RELEASE]: '1.0',
+            [SENTRY_SDK_NAME]: EXPECTED_SDK_NAME,
+            [SENTRY_SEGMENT_NAME]: SEGMENT_NAME,
+            [SERVER_ADDRESS]: HOST,
+            [SERVER_PORT]: PORT,
+            [SENTRY_TRACE_LIFECYCLE]: 'stream',
+            ...attributes,
+          }),
+          [SENTRY_SDK_VERSION]: { type: 'string', value: expect.any(String) },
+          [SENTRY_SEGMENT_ID]: { type: 'string', value: expect.stringMatching(/^[\da-f]{16}$/) },
+          [SENTRY_IS_LOCALHOST]: { type: 'boolean', value: false },
+        },
+        end_timestamp: expect.any(Number),
+        is_segment: false,
+        parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
+        span_id: expect.stringMatching(/^[\da-f]{16}$/),
+        start_timestamp: expect.any(Number),
+        status: 'ok',
+        trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      };
+    }
 
-      const PEER = { 'network.peer.address': HOST, 'network.peer.port': PORT };
+    const PEER = { [NETWORK_PEER_ADDRESS]: HOST, [NETWORK_PEER_PORT]: PORT };
 
-      // A cache span is a db span the cache hook took over: it is renamed to its cache operation
-      // and reports the connection it inherited as peer attributes too.
-      const cacheSpan = (
-        op: 'cache.get' | 'cache.put' | 'cache.remove',
-        attributes: Record<string, unknown>,
-      ): unknown => streamedSpan(op, op, { ...PEER, 'cache.operation': op.slice('cache.'.length), ...attributes });
+    // A cache span is a db span the cache hook took over: it is renamed to its cache operation
+    // and reports the connection it inherited as peer attributes too.
+    const cacheSpan = (
+      op: typeof CACHE_GET | typeof CACHE_PUT | typeof CACHE_REMOVE,
+      attributes: Record<string, unknown>,
+    ): unknown => streamedSpan(op, op, { ...PEER, [CACHE_OPERATION]: op.slice('cache.'.length), ...attributes });
 
-      createEsmAndCjsTests(__dirname, 'scenario-ioredis-5-11.mjs', 'instrument.mjs', (createTestRunner, test) => {
-        test(
-          'creates streamed spans for ioredis v5.11 commands via diagnostics_channel',
-          { timeout: 75_000 },
-          async () => {
-            await createTestRunner()
-              .withEnv({ STREAMED: 'true' })
-              .expect({
-                span: (container: SerializedStreamedSpanContainer) => {
-                  // The connect span opens its own segment but shares the trace with the test span,
-                  // so both segments arrive in the same container.
-                  expect(container.items.filter(item => item.is_segment).map(item => item.name)).toEqual([
-                    'redis-connect',
-                    SEGMENT_NAME,
-                  ]);
+    createEsmAndCjsTests(__dirname, 'scenario-ioredis-5-11.mjs', 'instrument.mjs', (createTestRunner, test) => {
+      test('creates spans for ioredis v5.11 commands via diagnostics_channel', { timeout: 75_000 }, async () => {
+        await createTestRunner()
+          .expect({
+            span: container => {
+              // The connect span opens its own segment but shares the trace with the test span,
+              // so both segments arrive in the same container.
+              expect(container.items.filter(item => item.is_segment).map(item => item.name)).toEqual([
+                'redis-connect',
+                SEGMENT_NAME,
+              ]);
 
-                  // ioredis' own handshake commands (`client SETINFO`, `info`) are emitted on the
-                  // channel too, but belong to the connect segment — the test span's children are the
-                  // commands the scenario issues.
-                  const spans = container.items.filter(
-                    item => !item.is_segment && item.attributes['sentry.segment.name']?.value === SEGMENT_NAME,
-                  );
+              // ioredis' own handshake commands (`client SETINFO`, `info`) are emitted on the
+              // channel too, but belong to the connect segment — the test span's children are the
+              // commands the scenario issues.
+              const spans = container.items.filter(
+                item => !item.is_segment && item.attributes[SENTRY_SEGMENT_NAME]?.value === SEGMENT_NAME,
+              );
 
-                  expect(spans).toEqual([
-                    streamedSpan(`set ${HOST}:${PORT}`, 'db.query', {
-                      'db.operation.name': 'set',
-                      'db.query.text': 'set dc-test-key ?',
-                    }),
-                    cacheSpan('cache.put', {
-                      'db.operation.name': 'set',
-                      'db.query.text': 'set dc-cache:test-key ?',
-                      'cache.key': ['dc-cache:test-key'],
-                      'cache.item_size': 2,
-                    }),
-                    cacheSpan('cache.put', {
-                      'db.operation.name': 'set',
-                      'db.query.text': 'set dc-cache:test-key-ex ? ? ?',
-                      'cache.key': ['dc-cache:test-key-ex'],
-                      'cache.item_size': 2,
-                    }),
-                    streamedSpan(`get ${HOST}:${PORT}`, 'db.query', {
-                      'db.operation.name': 'get',
-                      'db.query.text': 'get dc-test-key',
-                    }),
-                    cacheSpan('cache.get', {
-                      'db.operation.name': 'get',
-                      'db.query.text': 'get dc-cache:test-key',
-                      'cache.key': ['dc-cache:test-key'],
-                      'cache.hit': true,
-                      'cache.item_size': 10,
-                    }),
-                    cacheSpan('cache.get', {
-                      'db.operation.name': 'get',
-                      'db.query.text': 'get dc-cache:unavailable-data',
-                      'cache.key': ['dc-cache:unavailable-data'],
-                      'cache.hit': false,
-                    }),
-                    streamedSpan(`mget ${HOST}:${PORT}`, 'db.query', {
-                      'db.operation.name': 'mget',
-                      'db.query.text': 'mget ? ? ?',
-                    }),
-                  ]);
-                },
-              })
-              .start()
-              .completed();
-          },
-        );
+              expect(spans).toEqual([
+                streamedSpan(`set ${HOST}:${PORT}`, DB_QUERY, {
+                  [DB_OPERATION_NAME]: 'set',
+                  [DB_QUERY_TEXT]: 'set dc-test-key ?',
+                }),
+                cacheSpan(CACHE_PUT, {
+                  [DB_OPERATION_NAME]: 'set',
+                  [DB_QUERY_TEXT]: 'set dc-cache:test-key ?',
+                  [CACHE_KEY]: ['dc-cache:test-key'],
+                  [CACHE_ITEM_SIZE]: 2,
+                }),
+                cacheSpan(CACHE_PUT, {
+                  [DB_OPERATION_NAME]: 'set',
+                  [DB_QUERY_TEXT]: 'set dc-cache:test-key-ex ? ? ?',
+                  [CACHE_KEY]: ['dc-cache:test-key-ex'],
+                  [CACHE_ITEM_SIZE]: 2,
+                }),
+                streamedSpan(`get ${HOST}:${PORT}`, DB_QUERY, {
+                  [DB_OPERATION_NAME]: 'get',
+                  [DB_QUERY_TEXT]: 'get dc-test-key',
+                }),
+                cacheSpan(CACHE_GET, {
+                  [DB_OPERATION_NAME]: 'get',
+                  [DB_QUERY_TEXT]: 'get dc-cache:test-key',
+                  [CACHE_KEY]: ['dc-cache:test-key'],
+                  [CACHE_HIT]: true,
+                  [CACHE_ITEM_SIZE]: 10,
+                }),
+                cacheSpan(CACHE_GET, {
+                  [DB_OPERATION_NAME]: 'get',
+                  [DB_QUERY_TEXT]: 'get dc-cache:unavailable-data',
+                  [CACHE_KEY]: ['dc-cache:unavailable-data'],
+                  [CACHE_HIT]: false,
+                }),
+                streamedSpan(`mget ${HOST}:${PORT}`, DB_QUERY, {
+                  [DB_OPERATION_NAME]: 'mget',
+                  [DB_QUERY_TEXT]: 'mget ? ? ?',
+                }),
+              ]);
+            },
+          })
+          .start()
+          .completed();
       });
     });
   },
diff --git a/dev-packages/node-integration-tests/suites/tracing/redis-cache/instrument-redis-4.mjs b/dev-packages/node-integration-tests/suites/tracing/redis-cache/instrument-redis-4.mjs
index 9b24191fd0a1..df9d0ca876df 100644
--- a/dev-packages/node-integration-tests/suites/tracing/redis-cache/instrument-redis-4.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/redis-cache/instrument-redis-4.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/redis-cache/instrument-redis-5.mjs b/dev-packages/node-integration-tests/suites/tracing/redis-cache/instrument-redis-5.mjs
index 58f4a0875acd..285078fd57e7 100644
--- a/dev-packages/node-integration-tests/suites/tracing/redis-cache/instrument-redis-5.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/redis-cache/instrument-redis-5.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/redis-cache/test.ts b/dev-packages/node-integration-tests/suites/tracing/redis-cache/test.ts
index 2e8de3443a55..a6f3271d2356 100644
--- a/dev-packages/node-integration-tests/suites/tracing/redis-cache/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/redis-cache/test.ts
@@ -1,4 +1,31 @@
-import { SENTRY_TRACE_LIFECYCLE } from '@sentry/conventions/attributes';
+import {
+  CACHE_HIT,
+  CACHE_ITEM_SIZE,
+  CACHE_KEY,
+  CACHE_OPERATION,
+  DB_OPERATION_BATCH_SIZE,
+  DB_OPERATION_NAME,
+  DB_QUERY_TEXT,
+  DB_SYSTEM_NAME,
+  ERROR_TYPE,
+  NETWORK_PEER_ADDRESS,
+  NETWORK_PEER_PORT,
+  SENTRY_ENVIRONMENT,
+  SENTRY_IS_LOCALHOST,
+  SENTRY_KIND,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_RELEASE,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SEGMENT_NAME,
+  SENTRY_STATUS_MESSAGE,
+  SENTRY_TRACE_LIFECYCLE,
+  SERVER_ADDRESS,
+  SERVER_PORT,
+} from '@sentry/conventions/attributes';
+import { CACHE_GET, CACHE_PUT, CACHE_REMOVE, DB_QUERY } from '@sentry/conventions/op';
 import type { SerializedStreamedSpanContainer } from '@sentry/core';
 import { afterAll, describe, expect } from 'vitest';
 import { EXPECTED_SDK_NAME } from '../../../utils';
@@ -10,45 +37,7 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
   });
 
   const redisOrigin = 'auto.db.redis';
-  const redisSpanOp = 'db.query';
-
-  describe('ioredis non-cache keys', () => {
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Span',
-      spans: expect.arrayContaining([
-        expect.objectContaining({
-          description: 'set test-key [1 other arguments]',
-          op: redisSpanOp,
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.op': redisSpanOp,
-            'db.system.name': 'redis',
-            'server.address': 'localhost',
-            'server.port': 6383,
-            'db.query.text': 'set test-key [1 other arguments]',
-          }),
-        }),
-        expect.objectContaining({
-          description: 'get test-key',
-          op: redisSpanOp,
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.op': redisSpanOp,
-            'db.system.name': 'redis',
-            'server.address': 'localhost',
-            'server.port': 6383,
-            'db.query.text': 'get test-key',
-          }),
-        }),
-      ]),
-    };
-
-    createEsmAndCjsTests(__dirname, 'scenario-ioredis.mjs', 'instrument-ioredis.mjs', (createTestRunner, test) => {
-      test('should not add cache spans when key is not prefixed', { timeout: 60_000 }, async () => {
-        await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
-      });
-    });
-  });
+  const redisSpanOp = DB_QUERY;
 
   describe('ioredis cache keys', () => {
     const EXPECTED_TRANSACTION = {
@@ -57,7 +46,7 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
         // SET
         expect.objectContaining({
           description: 'ioredis-cache:test-key',
-          op: 'cache.put',
+          op: CACHE_PUT,
           origin: redisOrigin,
           data: expect.objectContaining({
             'sentry.origin': redisOrigin,
@@ -72,7 +61,7 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
         // SET (with EX)
         expect.objectContaining({
           description: 'ioredis-cache:test-key-set-EX',
-          op: 'cache.put',
+          op: CACHE_PUT,
           origin: redisOrigin,
           data: expect.objectContaining({
             'sentry.origin': redisOrigin,
@@ -87,7 +76,7 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
         // SETEX
         expect.objectContaining({
           description: 'ioredis-cache:test-key-setex',
-          op: 'cache.put',
+          op: CACHE_PUT,
           origin: redisOrigin,
           data: expect.objectContaining({
             'sentry.origin': redisOrigin,
@@ -102,7 +91,7 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
         // GET
         expect.objectContaining({
           description: 'ioredis-cache:test-key',
-          op: 'cache.get',
+          op: CACHE_GET,
           origin: redisOrigin,
           data: expect.objectContaining({
             'sentry.origin': redisOrigin,
@@ -118,7 +107,7 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
         // GET (unavailable - no cache hit)
         expect.objectContaining({
           description: 'ioredis-cache:unavailable-data',
-          op: 'cache.get',
+          op: CACHE_GET,
           origin: redisOrigin,
           data: expect.objectContaining({
             'sentry.origin': redisOrigin,
@@ -133,7 +122,7 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
         // MGET
         expect.objectContaining({
           description: 'test-key, ioredis-cache:test-key, ioredis-cache:unavailable-data',
-          op: 'cache.get',
+          op: CACHE_GET,
           origin: redisOrigin,
           data: expect.objectContaining({
             'sentry.origin': redisOrigin,
@@ -148,7 +137,7 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
         // DEL
         expect.objectContaining({
           description: 'ioredis-cache:test-key',
-          op: 'cache.remove',
+          op: CACHE_REMOVE,
           origin: redisOrigin,
           data: expect.objectContaining({
             'sentry.origin': redisOrigin,
@@ -162,533 +151,14 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
       ]),
     };
 
-    // Same commands as above, but streamed: the cache key is gone from the span name and only
-    // `cache.key` still holds it.
-    const EXPECTED_STREAMED_SPANS = expect.arrayContaining([
-      // SET
-      expect.objectContaining({
-        name: 'cache.put',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.origin': { type: 'string', value: redisOrigin },
-          'sentry.op': { type: 'string', value: 'cache.put' },
-          'db.query.text': { type: 'string', value: 'set ioredis-cache:test-key [1 other arguments]' },
-          'cache.operation': { type: 'string', value: 'put' },
-          'cache.key': { type: 'array', value: ['ioredis-cache:test-key'] },
-          'cache.item_size': { type: 'integer', value: 2 },
-        }),
-      }),
-      // SETEX
-      expect.objectContaining({
-        name: 'cache.put',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.op': { type: 'string', value: 'cache.put' },
-          'db.query.text': { type: 'string', value: 'setex ioredis-cache:test-key-setex [2 other arguments]' },
-          'cache.operation': { type: 'string', value: 'put' },
-          'cache.key': { type: 'array', value: ['ioredis-cache:test-key-setex'] },
-        }),
-      }),
-      // GET
-      expect.objectContaining({
-        name: 'cache.get',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.origin': { type: 'string', value: redisOrigin },
-          'sentry.op': { type: 'string', value: 'cache.get' },
-          'db.query.text': { type: 'string', value: 'get ioredis-cache:test-key' },
-          'cache.operation': { type: 'string', value: 'get' },
-          'cache.hit': { type: 'boolean', value: true },
-          'cache.key': { type: 'array', value: ['ioredis-cache:test-key'] },
-          'cache.item_size': { type: 'integer', value: 10 },
-        }),
-      }),
-      // MGET
-      expect.objectContaining({
-        name: 'cache.get',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.op': { type: 'string', value: 'cache.get' },
-          'db.query.text': { type: 'string', value: 'mget [3 other arguments]' },
-          'cache.operation': { type: 'string', value: 'get' },
-          'cache.key': {
-            type: 'array',
-            value: ['test-key', 'ioredis-cache:test-key', 'ioredis-cache:unavailable-data'],
-          },
-        }),
-      }),
-      // DEL
-      expect.objectContaining({
-        name: 'cache.remove',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.origin': { type: 'string', value: redisOrigin },
-          'sentry.op': { type: 'string', value: 'cache.remove' },
-          'db.query.text': { type: 'string', value: 'del ioredis-cache:test-key' },
-          'cache.operation': { type: 'string', value: 'remove' },
-          'cache.key': { type: 'array', value: ['ioredis-cache:test-key'] },
-        }),
-      }),
-    ]);
-
     createEsmAndCjsTests(__dirname, 'scenario-ioredis.mjs', 'instrument-ioredis.mjs', (createTestRunner, test) => {
       test('should create cache spans for prefixed keys (ioredis)', { timeout: 60_000 }, async () => {
         await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
       });
-
-      test('should name cache spans after the cache operation when streamed (ioredis)', async () => {
-        await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
-          .expect({ span: { items: EXPECTED_STREAMED_SPANS } })
-          .start()
-          .completed();
-      });
-    });
-  });
-
-  describe('redis-4 cache keys', () => {
-    const EXPECTED_REDIS_CONNECT = {
-      transaction: 'redis-connect',
-    };
-
-    const batchSpans = [
-      expect.objectContaining({
-        description: 'MULTI',
-        op: 'db.query',
-        origin: redisOrigin,
-        data: expect.objectContaining({
-          'sentry.origin': redisOrigin,
-          'db.system.name': 'redis',
-          'db.operation.batch.size': 2,
-        }),
-      }),
-    ];
-
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Span Redis 4',
-      spans: expect.arrayContaining([
-        // SET
-        expect.objectContaining({
-          description: 'redis-cache:test-key',
-          op: 'cache.put',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'SET redis-cache:test-key [1 other arguments]',
-            'cache.operation': 'put',
-            'cache.key': ['redis-cache:test-key'],
-            'cache.item_size': 2,
-          }),
-        }),
-        // SET (with EX)
-        expect.objectContaining({
-          description: 'redis-cache:test-key-set-EX',
-          op: 'cache.put',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'SET redis-cache:test-key-set-EX [3 other arguments]',
-            'cache.operation': 'put',
-            'cache.key': ['redis-cache:test-key-set-EX'],
-            'cache.item_size': 2,
-          }),
-        }),
-        // SETEX
-        expect.objectContaining({
-          description: 'redis-cache:test-key-setex',
-          op: 'cache.put',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'SETEX redis-cache:test-key-setex [2 other arguments]',
-            'cache.operation': 'put',
-            'cache.key': ['redis-cache:test-key-setex'],
-            'cache.item_size': 2,
-          }),
-        }),
-        // GET
-        expect.objectContaining({
-          description: 'redis-cache:test-key',
-          op: 'cache.get',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'GET redis-cache:test-key',
-            'cache.operation': 'get',
-            'cache.hit': true,
-            'cache.key': ['redis-cache:test-key'],
-            'cache.item_size': 10,
-          }),
-        }),
-        // GET (unavailable - no cache hit)
-        expect.objectContaining({
-          description: 'redis-cache:unavailable-data',
-          op: 'cache.get',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'GET redis-cache:unavailable-data',
-            'cache.operation': 'get',
-            'cache.hit': false,
-            'cache.key': ['redis-cache:unavailable-data'],
-          }),
-        }),
-        // MGET
-        expect.objectContaining({
-          description: 'redis-test-key, redis-cache:test-key, redis-cache:unavailable-data',
-          op: 'cache.get',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'MGET [3 other arguments]',
-            'cache.operation': 'get',
-            'cache.hit': true,
-            'cache.key': ['redis-test-key', 'redis-cache:test-key', 'redis-cache:unavailable-data'],
-          }),
-        }),
-        // DEL
-        expect.objectContaining({
-          description: 'redis-cache:test-key',
-          op: 'cache.remove',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'DEL redis-cache:test-key',
-            'cache.operation': 'remove',
-            'cache.key': ['redis-cache:test-key'],
-          }),
-        }),
-        ...batchSpans,
-        // a failing command produces a span with an error status
-        expect.objectContaining({
-          description: 'INCR redis-test-key',
-          op: 'db.query',
-          status: 'internal_error',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.system.name': 'redis',
-            'db.query.text': 'INCR redis-test-key',
-          }),
-        }),
-      ]),
-    };
-
-    const EXPECTED_STREAMED_SPANS = expect.arrayContaining([
-      // SET
-      expect.objectContaining({
-        name: 'cache.put',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.origin': { type: 'string', value: redisOrigin },
-          'sentry.op': { type: 'string', value: 'cache.put' },
-          'db.query.text': { type: 'string', value: 'SET redis-cache:test-key [1 other arguments]' },
-          'cache.operation': { type: 'string', value: 'put' },
-          'cache.key': { type: 'array', value: ['redis-cache:test-key'] },
-          'cache.item_size': { type: 'integer', value: 2 },
-        }),
-      }),
-      // SETEX
-      expect.objectContaining({
-        name: 'cache.put',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.op': { type: 'string', value: 'cache.put' },
-          'db.query.text': { type: 'string', value: 'SETEX redis-cache:test-key-setex [2 other arguments]' },
-          'cache.operation': { type: 'string', value: 'put' },
-          'cache.key': { type: 'array', value: ['redis-cache:test-key-setex'] },
-        }),
-      }),
-      // GET
-      expect.objectContaining({
-        name: 'cache.get',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.origin': { type: 'string', value: redisOrigin },
-          'sentry.op': { type: 'string', value: 'cache.get' },
-          'db.query.text': { type: 'string', value: 'GET redis-cache:test-key' },
-          'cache.operation': { type: 'string', value: 'get' },
-          'cache.hit': { type: 'boolean', value: true },
-          'cache.key': { type: 'array', value: ['redis-cache:test-key'] },
-          'cache.item_size': { type: 'integer', value: 10 },
-        }),
-      }),
-      // MGET
-      expect.objectContaining({
-        name: 'cache.get',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.op': { type: 'string', value: 'cache.get' },
-          'db.query.text': { type: 'string', value: 'MGET [3 other arguments]' },
-          'cache.operation': { type: 'string', value: 'get' },
-          'cache.key': {
-            type: 'array',
-            value: ['redis-test-key', 'redis-cache:test-key', 'redis-cache:unavailable-data'],
-          },
-        }),
-      }),
-      // DEL
-      expect.objectContaining({
-        name: 'cache.remove',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.origin': { type: 'string', value: redisOrigin },
-          'sentry.op': { type: 'string', value: 'cache.remove' },
-          'db.query.text': { type: 'string', value: 'DEL redis-cache:test-key' },
-          'cache.operation': { type: 'string', value: 'remove' },
-          'cache.key': { type: 'array', value: ['redis-cache:test-key'] },
-        }),
-      }),
-    ]);
-
-    createEsmAndCjsTests(__dirname, 'scenario-redis-4.mjs', 'instrument-redis-4.mjs', (createTestRunner, test) => {
-      test('should create cache spans for prefixed keys (redis-4)', async () => {
-        await createTestRunner()
-          .expect({ transaction: EXPECTED_REDIS_CONNECT })
-          .expect({ transaction: EXPECTED_TRANSACTION })
-          .start()
-          .completed();
-      });
-
-      test('should name cache spans after the cache operation when streamed (redis-4)', async () => {
-        await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
-          // The connect span opens its own segment. `unordered` keeps this expectation from
-          // depending on which segment the buffer happens to emit first.
-          .unordered()
-          .expect({ span: { items: EXPECTED_STREAMED_SPANS } })
-          .start()
-          .completed();
-      });
-    });
-  });
-
-  // node-redis 5.0-5.11 still flows through the vendored monkey-patch
-  // instrumentation (diagnostics_channel was only added in 5.12.0), so this
-  // exercises the `>=5.0.0 <5.12.0` branch of the vendored RedisInstrumentation.
-  describe('redis-5 cache keys', () => {
-    const EXPECTED_REDIS_CONNECT = {
-      transaction: 'redis-connect',
-    };
-
-    const batchSpans = [
-      expect.objectContaining({
-        description: 'MULTI',
-        op: 'db.query',
-        origin: redisOrigin,
-        data: expect.objectContaining({
-          'sentry.origin': redisOrigin,
-          'db.system.name': 'redis',
-          'db.operation.batch.size': 2,
-        }),
-      }),
-    ];
-
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Span Redis 5',
-      spans: expect.arrayContaining([
-        // SET
-        expect.objectContaining({
-          description: 'redis-5-cache:test-key',
-          op: 'cache.put',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'SET redis-5-cache:test-key [1 other arguments]',
-            'cache.operation': 'put',
-            'cache.key': ['redis-5-cache:test-key'],
-            'cache.item_size': 2,
-          }),
-        }),
-        // SET (with EX)
-        expect.objectContaining({
-          description: 'redis-5-cache:test-key-set-EX',
-          op: 'cache.put',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'SET redis-5-cache:test-key-set-EX [3 other arguments]',
-            'cache.operation': 'put',
-            'cache.key': ['redis-5-cache:test-key-set-EX'],
-            'cache.item_size': 2,
-          }),
-        }),
-        // SETEX
-        expect.objectContaining({
-          description: 'redis-5-cache:test-key-setex',
-          op: 'cache.put',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'SETEX redis-5-cache:test-key-setex [2 other arguments]',
-            'cache.operation': 'put',
-            'cache.key': ['redis-5-cache:test-key-setex'],
-            'cache.item_size': 2,
-          }),
-        }),
-        // GET
-        expect.objectContaining({
-          description: 'redis-5-cache:test-key',
-          op: 'cache.get',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'GET redis-5-cache:test-key',
-            'cache.operation': 'get',
-            'cache.hit': true,
-            'cache.key': ['redis-5-cache:test-key'],
-            'cache.item_size': 10,
-          }),
-        }),
-        // GET (unavailable - no cache hit)
-        expect.objectContaining({
-          description: 'redis-5-cache:unavailable-data',
-          op: 'cache.get',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'GET redis-5-cache:unavailable-data',
-            'cache.operation': 'get',
-            'cache.hit': false,
-            'cache.key': ['redis-5-cache:unavailable-data'],
-          }),
-        }),
-        // MGET
-        expect.objectContaining({
-          description: 'redis-5-test-key, redis-5-cache:test-key, redis-5-cache:unavailable-data',
-          op: 'cache.get',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'MGET [3 other arguments]',
-            'cache.operation': 'get',
-            'cache.hit': true,
-            'cache.key': ['redis-5-test-key', 'redis-5-cache:test-key', 'redis-5-cache:unavailable-data'],
-          }),
-        }),
-        // DEL
-        expect.objectContaining({
-          description: 'redis-5-cache:test-key',
-          op: 'cache.remove',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.query.text': 'DEL redis-5-cache:test-key',
-            'cache.operation': 'remove',
-            'cache.key': ['redis-5-cache:test-key'],
-          }),
-        }),
-        ...batchSpans,
-        // a failing command produces a span with an error status
-        expect.objectContaining({
-          description: 'INCR redis-5-test-key',
-          op: 'db.query',
-          status: 'internal_error',
-          origin: redisOrigin,
-          data: expect.objectContaining({
-            'sentry.origin': redisOrigin,
-            'db.system.name': 'redis',
-            'db.query.text': 'INCR redis-5-test-key',
-          }),
-        }),
-      ]),
-    };
-
-    const EXPECTED_STREAMED_SPANS = expect.arrayContaining([
-      // SET
-      expect.objectContaining({
-        name: 'cache.put',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.origin': { type: 'string', value: redisOrigin },
-          'sentry.op': { type: 'string', value: 'cache.put' },
-          'db.query.text': { type: 'string', value: 'SET redis-5-cache:test-key [1 other arguments]' },
-          'cache.operation': { type: 'string', value: 'put' },
-          'cache.key': { type: 'array', value: ['redis-5-cache:test-key'] },
-          'cache.item_size': { type: 'integer', value: 2 },
-        }),
-      }),
-      // SETEX
-      expect.objectContaining({
-        name: 'cache.put',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.op': { type: 'string', value: 'cache.put' },
-          'db.query.text': { type: 'string', value: 'SETEX redis-5-cache:test-key-setex [2 other arguments]' },
-          'cache.operation': { type: 'string', value: 'put' },
-          'cache.key': { type: 'array', value: ['redis-5-cache:test-key-setex'] },
-        }),
-      }),
-      // GET
-      expect.objectContaining({
-        name: 'cache.get',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.origin': { type: 'string', value: redisOrigin },
-          'sentry.op': { type: 'string', value: 'cache.get' },
-          'db.query.text': { type: 'string', value: 'GET redis-5-cache:test-key' },
-          'cache.operation': { type: 'string', value: 'get' },
-          'cache.hit': { type: 'boolean', value: true },
-          'cache.key': { type: 'array', value: ['redis-5-cache:test-key'] },
-          'cache.item_size': { type: 'integer', value: 10 },
-        }),
-      }),
-      // MGET
-      expect.objectContaining({
-        name: 'cache.get',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.op': { type: 'string', value: 'cache.get' },
-          'db.query.text': { type: 'string', value: 'MGET [3 other arguments]' },
-          'cache.operation': { type: 'string', value: 'get' },
-          'cache.key': {
-            type: 'array',
-            value: ['redis-5-test-key', 'redis-5-cache:test-key', 'redis-5-cache:unavailable-data'],
-          },
-        }),
-      }),
-      // DEL
-      expect.objectContaining({
-        name: 'cache.remove',
-        is_segment: false,
-        attributes: expect.objectContaining({
-          'sentry.origin': { type: 'string', value: redisOrigin },
-          'sentry.op': { type: 'string', value: 'cache.remove' },
-          'db.query.text': { type: 'string', value: 'DEL redis-5-cache:test-key' },
-          'cache.operation': { type: 'string', value: 'remove' },
-          'cache.key': { type: 'array', value: ['redis-5-cache:test-key'] },
-        }),
-      }),
-    ]);
-
-    createEsmAndCjsTests(__dirname, 'scenario-redis-5.mjs', 'instrument-redis-5.mjs', (createTestRunner, test) => {
-      test('should create cache spans for prefixed keys (redis-5)', async () => {
-        await createTestRunner()
-          .expect({ transaction: EXPECTED_REDIS_CONNECT })
-          .expect({ transaction: EXPECTED_TRANSACTION })
-          .start()
-          .completed();
-      });
-
-      test('should name cache spans after the cache operation when streamed (redis-5)', async () => {
-        await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
-          // The connect span opens its own segment. `unordered` keeps this expectation from
-          // depending on which segment the buffer happens to emit first.
-          .unordered()
-          .expect({ span: { items: EXPECTED_STREAMED_SPANS } })
-          .start()
-          .completed();
-      });
     });
   });
 
   describe('streamed', () => {
-    // The blocks above assert the same commands as transactions. With span streaming, span names
-    // have to be low cardinality, so `db.query` spans drop the serialized statement from their
-    // name — it stays on `db.query.text` — and are named
-    // `{db.operation.name} {server.address}:{server.port}` instead. Cache spans are named after
-    // their cache operation, and batch spans keep their `MULTI`/`PIPELINE` name.
     const streamAttribute = (value: unknown): { type: string; value: unknown } => ({
       type: Array.isArray(value) ? 'array' : Number.isInteger(value) ? 'integer' : typeof value,
       value,
@@ -701,18 +171,18 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
 
     const commonAttributes = (segmentName: string): Record<string, unknown> => ({
       ...streamAttributes({
-        'db.system.name': 'redis',
-        'sentry.environment': 'production',
-        'sentry.kind': 'client',
-        'sentry.origin': redisOrigin,
-        'sentry.release': '1.0',
-        'sentry.sdk.name': EXPECTED_SDK_NAME,
-        'sentry.segment.name': segmentName,
+        [DB_SYSTEM_NAME]: 'redis',
+        [SENTRY_ENVIRONMENT]: 'production',
+        [SENTRY_KIND]: 'client',
+        [SENTRY_ORIGIN]: redisOrigin,
+        [SENTRY_RELEASE]: '1.0',
+        [SENTRY_SDK_NAME]: EXPECTED_SDK_NAME,
+        [SENTRY_SEGMENT_NAME]: segmentName,
         [SENTRY_TRACE_LIFECYCLE]: 'stream',
       }),
-      'sentry.sdk.version': { type: 'string', value: expect.any(String) },
-      'sentry.is_localhost': { type: 'boolean', value: false },
-      'sentry.segment.id': { type: 'string', value: expect.stringMatching(/^[\da-f]{16}$/) },
+      [SENTRY_SDK_VERSION]: { type: 'string', value: expect.any(String) },
+      [SENTRY_IS_LOCALHOST]: { type: 'boolean', value: false },
+      [SENTRY_SEGMENT_ID]: { type: 'string', value: expect.stringMatching(/^[\da-f]{16}$/) },
     });
 
     function streamedSpan({
@@ -732,7 +202,7 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
         name,
         attributes: {
           ...commonAttributes(segmentName),
-          ...streamAttributes({ 'sentry.op': op, ...attributes }),
+          ...streamAttributes({ [SENTRY_OP]: op, ...attributes }),
         },
         end_timestamp: expect.any(Number),
         is_segment: false,
@@ -749,8 +219,8 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
 
     describe('ioredis', () => {
       const segmentName = 'Test Span';
-      const connection = { 'server.address': 'localhost', 'server.port': 6383 };
-      const peer = { 'network.peer.address': 'localhost', 'network.peer.port': 6383 };
+      const connection = { [SERVER_ADDRESS]: 'localhost', [SERVER_PORT]: 6383 };
+      const peer = { [NETWORK_PEER_ADDRESS]: 'localhost', [NETWORK_PEER_PORT]: 6383 };
 
       const span = (name: string, op: string, attributes: Record<string, unknown>, status?: string): unknown =>
         streamedSpan({ name, op, segmentName, status, attributes: { ...connection, ...attributes } });
@@ -758,69 +228,69 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
       // A cache span is a db span the cache hook took over: it is renamed to its cache operation
       // and reports the connection it inherited as peer attributes too.
       const cacheSpan = (
-        op: 'cache.get' | 'cache.put' | 'cache.remove',
+        op: typeof CACHE_GET | typeof CACHE_PUT | typeof CACHE_REMOVE,
         attributes: Record<string, unknown>,
-      ): unknown => span(op, op, { ...peer, 'cache.operation': op.slice('cache.'.length), ...attributes });
+      ): unknown => span(op, op, { ...peer, [CACHE_OPERATION]: op.slice('cache.'.length), ...attributes });
 
       createEsmAndCjsTests(__dirname, 'scenario-ioredis.mjs', 'instrument-ioredis.mjs', (createTestRunner, test) => {
-        test('creates streamed db and cache spans (ioredis)', { timeout: 60_000 }, async () => {
+        test('should create cache spans for prefixed keys (ioredis)', { timeout: 60_000 }, async () => {
           await createTestRunner()
             .withEnv({ STREAMED: 'true' })
             .expect({
-              span: (container: SerializedStreamedSpanContainer) => {
+              span: container => {
                 expect(container.items.find(item => item.is_segment)?.name).toBe(segmentName);
 
                 expect(childSpans(container)).toEqual([
                   span('set localhost:6383', redisSpanOp, {
-                    'db.operation.name': 'set',
-                    'db.query.text': 'set test-key [1 other arguments]',
+                    [DB_OPERATION_NAME]: 'set',
+                    [DB_QUERY_TEXT]: 'set test-key [1 other arguments]',
                   }),
-                  cacheSpan('cache.put', {
-                    'db.operation.name': 'set',
-                    'db.query.text': 'set ioredis-cache:test-key [1 other arguments]',
-                    'cache.key': ['ioredis-cache:test-key'],
-                    'cache.item_size': 2,
+                  cacheSpan(CACHE_PUT, {
+                    [DB_OPERATION_NAME]: 'set',
+                    [DB_QUERY_TEXT]: 'set ioredis-cache:test-key [1 other arguments]',
+                    [CACHE_KEY]: ['ioredis-cache:test-key'],
+                    [CACHE_ITEM_SIZE]: 2,
                   }),
-                  cacheSpan('cache.put', {
-                    'db.operation.name': 'set',
-                    'db.query.text': 'set ioredis-cache:test-key-set-EX [3 other arguments]',
-                    'cache.key': ['ioredis-cache:test-key-set-EX'],
-                    'cache.item_size': 2,
+                  cacheSpan(CACHE_PUT, {
+                    [DB_OPERATION_NAME]: 'set',
+                    [DB_QUERY_TEXT]: 'set ioredis-cache:test-key-set-EX [3 other arguments]',
+                    [CACHE_KEY]: ['ioredis-cache:test-key-set-EX'],
+                    [CACHE_ITEM_SIZE]: 2,
                   }),
-                  cacheSpan('cache.put', {
-                    'db.operation.name': 'setex',
-                    'db.query.text': 'setex ioredis-cache:test-key-setex [2 other arguments]',
-                    'cache.key': ['ioredis-cache:test-key-setex'],
-                    'cache.item_size': 2,
+                  cacheSpan(CACHE_PUT, {
+                    [DB_OPERATION_NAME]: 'setex',
+                    [DB_QUERY_TEXT]: 'setex ioredis-cache:test-key-setex [2 other arguments]',
+                    [CACHE_KEY]: ['ioredis-cache:test-key-setex'],
+                    [CACHE_ITEM_SIZE]: 2,
                   }),
                   span('get localhost:6383', redisSpanOp, {
-                    'db.operation.name': 'get',
-                    'db.query.text': 'get test-key',
+                    [DB_OPERATION_NAME]: 'get',
+                    [DB_QUERY_TEXT]: 'get test-key',
                   }),
-                  cacheSpan('cache.get', {
-                    'db.operation.name': 'get',
-                    'db.query.text': 'get ioredis-cache:test-key',
-                    'cache.key': ['ioredis-cache:test-key'],
-                    'cache.hit': true,
-                    'cache.item_size': 10,
+                  cacheSpan(CACHE_GET, {
+                    [DB_OPERATION_NAME]: 'get',
+                    [DB_QUERY_TEXT]: 'get ioredis-cache:test-key',
+                    [CACHE_KEY]: ['ioredis-cache:test-key'],
+                    [CACHE_HIT]: true,
+                    [CACHE_ITEM_SIZE]: 10,
                   }),
-                  cacheSpan('cache.get', {
-                    'db.operation.name': 'get',
-                    'db.query.text': 'get ioredis-cache:unavailable-data',
-                    'cache.key': ['ioredis-cache:unavailable-data'],
-                    'cache.hit': false,
+                  cacheSpan(CACHE_GET, {
+                    [DB_OPERATION_NAME]: 'get',
+                    [DB_QUERY_TEXT]: 'get ioredis-cache:unavailable-data',
+                    [CACHE_KEY]: ['ioredis-cache:unavailable-data'],
+                    [CACHE_HIT]: false,
                   }),
-                  cacheSpan('cache.get', {
-                    'db.operation.name': 'mget',
-                    'db.query.text': 'mget [3 other arguments]',
-                    'cache.key': ['test-key', 'ioredis-cache:test-key', 'ioredis-cache:unavailable-data'],
-                    'cache.hit': true,
-                    'cache.item_size': 20,
+                  cacheSpan(CACHE_GET, {
+                    [DB_OPERATION_NAME]: 'mget',
+                    [DB_QUERY_TEXT]: 'mget [3 other arguments]',
+                    [CACHE_KEY]: ['test-key', 'ioredis-cache:test-key', 'ioredis-cache:unavailable-data'],
+                    [CACHE_HIT]: true,
+                    [CACHE_ITEM_SIZE]: 20,
                   }),
-                  cacheSpan('cache.remove', {
-                    'db.operation.name': 'del',
-                    'db.query.text': 'del ioredis-cache:test-key',
-                    'cache.key': ['ioredis-cache:test-key'],
+                  cacheSpan(CACHE_REMOVE, {
+                    [DB_OPERATION_NAME]: 'del',
+                    [DB_QUERY_TEXT]: 'del ioredis-cache:test-key',
+                    [CACHE_KEY]: ['ioredis-cache:test-key'],
                   }),
                 ]);
               },
@@ -835,8 +305,8 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
     // `{db.operation.name} {server.address}:{server.port}` name.
     describe('redis-4', () => {
       const segmentName = 'Test Span Redis 4';
-      const connection = { 'server.address': 'localhost', 'server.port': 6383 };
-      const peer = { 'network.peer.address': 'localhost', 'network.peer.port': 6383 };
+      const connection = { [SERVER_ADDRESS]: 'localhost', [SERVER_PORT]: 6383 };
+      const peer = { [NETWORK_PEER_ADDRESS]: 'localhost', [NETWORK_PEER_PORT]: 6383 };
 
       const span = (name: string, op: string, attributes: Record<string, unknown>, status?: string): unknown =>
         streamedSpan({ name, op, segmentName, status, attributes: { ...connection, ...attributes } });
@@ -844,16 +314,15 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
       // A cache span is a db span the cache hook took over: it is renamed to its cache operation
       // and reports the connection it inherited as peer attributes too.
       const cacheSpan = (
-        op: 'cache.get' | 'cache.put' | 'cache.remove',
+        op: typeof CACHE_GET | typeof CACHE_PUT | typeof CACHE_REMOVE,
         attributes: Record<string, unknown>,
-      ): unknown => span(op, op, { ...peer, 'cache.operation': op.slice('cache.'.length), ...attributes });
+      ): unknown => span(op, op, { ...peer, [CACHE_OPERATION]: op.slice('cache.'.length), ...attributes });
 
       createEsmAndCjsTests(__dirname, 'scenario-redis-4.mjs', 'instrument-redis-4.mjs', (createTestRunner, test) => {
-        test('creates streamed db and cache spans (redis-4)', { timeout: 60_000 }, async () => {
+        test('should create cache spans for prefixed keys (redis-4)', { timeout: 60_000 }, async () => {
           await createTestRunner()
-            .withEnv({ STREAMED: 'true' })
             .expect({
-              span: (container: SerializedStreamedSpanContainer) => {
+              span: container => {
                 // The connect span opens its own segment, but shares the trace with the test span,
                 // so both segments arrive in the same container.
                 expect(container.items.filter(item => item.is_segment).map(item => item.name)).toEqual([
@@ -863,66 +332,66 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
 
                 expect(childSpans(container)).toEqual([
                   span('SET localhost:6383', redisSpanOp, {
-                    'db.operation.name': 'SET',
-                    'db.query.text': 'SET redis-test-key [1 other arguments]',
+                    [DB_OPERATION_NAME]: 'SET',
+                    [DB_QUERY_TEXT]: 'SET redis-test-key [1 other arguments]',
                   }),
-                  cacheSpan('cache.put', {
-                    'db.operation.name': 'SET',
-                    'db.query.text': 'SET redis-cache:test-key [1 other arguments]',
-                    'cache.key': ['redis-cache:test-key'],
-                    'cache.item_size': 2,
+                  cacheSpan(CACHE_PUT, {
+                    [DB_OPERATION_NAME]: 'SET',
+                    [DB_QUERY_TEXT]: 'SET redis-cache:test-key [1 other arguments]',
+                    [CACHE_KEY]: ['redis-cache:test-key'],
+                    [CACHE_ITEM_SIZE]: 2,
                   }),
-                  cacheSpan('cache.put', {
-                    'db.operation.name': 'SET',
-                    'db.query.text': 'SET redis-cache:test-key-set-EX [3 other arguments]',
-                    'cache.key': ['redis-cache:test-key-set-EX'],
-                    'cache.item_size': 2,
+                  cacheSpan(CACHE_PUT, {
+                    [DB_OPERATION_NAME]: 'SET',
+                    [DB_QUERY_TEXT]: 'SET redis-cache:test-key-set-EX [3 other arguments]',
+                    [CACHE_KEY]: ['redis-cache:test-key-set-EX'],
+                    [CACHE_ITEM_SIZE]: 2,
                   }),
-                  cacheSpan('cache.put', {
-                    'db.operation.name': 'SETEX',
-                    'db.query.text': 'SETEX redis-cache:test-key-setex [2 other arguments]',
-                    'cache.key': ['redis-cache:test-key-setex'],
-                    'cache.item_size': 2,
+                  cacheSpan(CACHE_PUT, {
+                    [DB_OPERATION_NAME]: 'SETEX',
+                    [DB_QUERY_TEXT]: 'SETEX redis-cache:test-key-setex [2 other arguments]',
+                    [CACHE_KEY]: ['redis-cache:test-key-setex'],
+                    [CACHE_ITEM_SIZE]: 2,
                   }),
                   span('GET localhost:6383', redisSpanOp, {
-                    'db.operation.name': 'GET',
-                    'db.query.text': 'GET redis-test-key',
+                    [DB_OPERATION_NAME]: 'GET',
+                    [DB_QUERY_TEXT]: 'GET redis-test-key',
                   }),
-                  cacheSpan('cache.get', {
-                    'db.operation.name': 'GET',
-                    'db.query.text': 'GET redis-cache:test-key',
-                    'cache.key': ['redis-cache:test-key'],
-                    'cache.hit': true,
-                    'cache.item_size': 10,
+                  cacheSpan(CACHE_GET, {
+                    [DB_OPERATION_NAME]: 'GET',
+                    [DB_QUERY_TEXT]: 'GET redis-cache:test-key',
+                    [CACHE_KEY]: ['redis-cache:test-key'],
+                    [CACHE_HIT]: true,
+                    [CACHE_ITEM_SIZE]: 10,
                   }),
-                  cacheSpan('cache.get', {
-                    'db.operation.name': 'GET',
-                    'db.query.text': 'GET redis-cache:unavailable-data',
-                    'cache.key': ['redis-cache:unavailable-data'],
-                    'cache.hit': false,
+                  cacheSpan(CACHE_GET, {
+                    [DB_OPERATION_NAME]: 'GET',
+                    [DB_QUERY_TEXT]: 'GET redis-cache:unavailable-data',
+                    [CACHE_KEY]: ['redis-cache:unavailable-data'],
+                    [CACHE_HIT]: false,
                   }),
-                  cacheSpan('cache.get', {
-                    'db.operation.name': 'MGET',
-                    'db.query.text': 'MGET [3 other arguments]',
-                    'cache.key': ['redis-test-key', 'redis-cache:test-key', 'redis-cache:unavailable-data'],
-                    'cache.hit': true,
-                    'cache.item_size': 20,
+                  cacheSpan(CACHE_GET, {
+                    [DB_OPERATION_NAME]: 'MGET',
+                    [DB_QUERY_TEXT]: 'MGET [3 other arguments]',
+                    [CACHE_KEY]: ['redis-test-key', 'redis-cache:test-key', 'redis-cache:unavailable-data'],
+                    [CACHE_HIT]: true,
+                    [CACHE_ITEM_SIZE]: 20,
                   }),
-                  cacheSpan('cache.remove', {
-                    'db.operation.name': 'DEL',
-                    'db.query.text': 'DEL redis-cache:test-key',
-                    'cache.key': ['redis-cache:test-key'],
+                  cacheSpan(CACHE_REMOVE, {
+                    [DB_OPERATION_NAME]: 'DEL',
+                    [DB_QUERY_TEXT]: 'DEL redis-cache:test-key',
+                    [CACHE_KEY]: ['redis-cache:test-key'],
                   }),
                   // Batch spans are named after the batch operation, which is already low cardinality.
-                  span('MULTI', redisSpanOp, { 'db.operation.name': 'MULTI', 'db.operation.batch.size': 2 }),
+                  span('MULTI', redisSpanOp, { [DB_OPERATION_NAME]: 'MULTI', [DB_OPERATION_BATCH_SIZE]: 2 }),
                   span(
                     'INCR localhost:6383',
                     redisSpanOp,
                     {
-                      'db.operation.name': 'INCR',
-                      'db.query.text': 'INCR redis-test-key',
-                      'error.type': 'Error',
-                      'sentry.status.message': 'ERR value is not an integer or out of range',
+                      [DB_OPERATION_NAME]: 'INCR',
+                      [DB_QUERY_TEXT]: 'INCR redis-test-key',
+                      [ERROR_TYPE]: 'Error',
+                      [SENTRY_STATUS_MESSAGE]: 'ERR value is not an integer or out of range',
                     },
                     'error',
                   ),
@@ -940,8 +409,8 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
     // connection and get the same span name.
     describe('redis-5', () => {
       const segmentName = 'Test Span Redis 5';
-      const connection = { 'server.address': 'localhost', 'server.port': 6383 };
-      const peer = { 'network.peer.address': 'localhost', 'network.peer.port': 6383 };
+      const connection = { [SERVER_ADDRESS]: 'localhost', [SERVER_PORT]: 6383 };
+      const peer = { [NETWORK_PEER_ADDRESS]: 'localhost', [NETWORK_PEER_PORT]: 6383 };
 
       const span = (name: string, op: string, attributes: Record<string, unknown>, status?: string): unknown =>
         streamedSpan({ name, op, segmentName, status, attributes: { ...connection, ...attributes } });
@@ -949,16 +418,15 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
       // A cache span is a db span the cache hook took over: it is renamed to its cache operation
       // and reports the connection it inherited as peer attributes too.
       const cacheSpan = (
-        op: 'cache.get' | 'cache.put' | 'cache.remove',
+        op: typeof CACHE_GET | typeof CACHE_PUT | typeof CACHE_REMOVE,
         attributes: Record<string, unknown>,
-      ): unknown => span(op, op, { ...peer, 'cache.operation': op.slice('cache.'.length), ...attributes });
+      ): unknown => span(op, op, { ...peer, [CACHE_OPERATION]: op.slice('cache.'.length), ...attributes });
 
       createEsmAndCjsTests(__dirname, 'scenario-redis-5.mjs', 'instrument-redis-5.mjs', (createTestRunner, test) => {
-        test('creates streamed db and cache spans (redis-5)', { timeout: 60_000 }, async () => {
+        test('should create cache spans for prefixed keys (redis-5)', { timeout: 60_000 }, async () => {
           await createTestRunner()
-            .withEnv({ STREAMED: 'true' })
             .expect({
-              span: (container: SerializedStreamedSpanContainer) => {
+              span: container => {
                 expect(container.items.filter(item => item.is_segment).map(item => item.name)).toEqual([
                   'redis-connect',
                   segmentName,
@@ -966,65 +434,65 @@ describeWithDockerCompose('redis cache auto instrumentation', { workingDirectory
 
                 expect(childSpans(container)).toEqual([
                   span('SET localhost:6383', redisSpanOp, {
-                    'db.operation.name': 'SET',
-                    'db.query.text': 'SET redis-5-test-key [1 other arguments]',
+                    [DB_OPERATION_NAME]: 'SET',
+                    [DB_QUERY_TEXT]: 'SET redis-5-test-key [1 other arguments]',
                   }),
-                  cacheSpan('cache.put', {
-                    'db.operation.name': 'SET',
-                    'db.query.text': 'SET redis-5-cache:test-key [1 other arguments]',
-                    'cache.key': ['redis-5-cache:test-key'],
-                    'cache.item_size': 2,
+                  cacheSpan(CACHE_PUT, {
+                    [DB_OPERATION_NAME]: 'SET',
+                    [DB_QUERY_TEXT]: 'SET redis-5-cache:test-key [1 other arguments]',
+                    [CACHE_KEY]: ['redis-5-cache:test-key'],
+                    [CACHE_ITEM_SIZE]: 2,
                   }),
-                  cacheSpan('cache.put', {
-                    'db.operation.name': 'SET',
-                    'db.query.text': 'SET redis-5-cache:test-key-set-EX [3 other arguments]',
-                    'cache.key': ['redis-5-cache:test-key-set-EX'],
-                    'cache.item_size': 2,
+                  cacheSpan(CACHE_PUT, {
+                    [DB_OPERATION_NAME]: 'SET',
+                    [DB_QUERY_TEXT]: 'SET redis-5-cache:test-key-set-EX [3 other arguments]',
+                    [CACHE_KEY]: ['redis-5-cache:test-key-set-EX'],
+                    [CACHE_ITEM_SIZE]: 2,
                   }),
-                  cacheSpan('cache.put', {
-                    'db.operation.name': 'SETEX',
-                    'db.query.text': 'SETEX redis-5-cache:test-key-setex [2 other arguments]',
-                    'cache.key': ['redis-5-cache:test-key-setex'],
-                    'cache.item_size': 2,
+                  cacheSpan(CACHE_PUT, {
+                    [DB_OPERATION_NAME]: 'SETEX',
+                    [DB_QUERY_TEXT]: 'SETEX redis-5-cache:test-key-setex [2 other arguments]',
+                    [CACHE_KEY]: ['redis-5-cache:test-key-setex'],
+                    [CACHE_ITEM_SIZE]: 2,
                   }),
                   span('GET localhost:6383', redisSpanOp, {
-                    'db.operation.name': 'GET',
-                    'db.query.text': 'GET redis-5-test-key',
+                    [DB_OPERATION_NAME]: 'GET',
+                    [DB_QUERY_TEXT]: 'GET redis-5-test-key',
                   }),
-                  cacheSpan('cache.get', {
-                    'db.operation.name': 'GET',
-                    'db.query.text': 'GET redis-5-cache:test-key',
-                    'cache.key': ['redis-5-cache:test-key'],
-                    'cache.hit': true,
-                    'cache.item_size': 10,
+                  cacheSpan(CACHE_GET, {
+                    [DB_OPERATION_NAME]: 'GET',
+                    [DB_QUERY_TEXT]: 'GET redis-5-cache:test-key',
+                    [CACHE_KEY]: ['redis-5-cache:test-key'],
+                    [CACHE_HIT]: true,
+                    [CACHE_ITEM_SIZE]: 10,
                   }),
-                  cacheSpan('cache.get', {
-                    'db.operation.name': 'GET',
-                    'db.query.text': 'GET redis-5-cache:unavailable-data',
-                    'cache.key': ['redis-5-cache:unavailable-data'],
-                    'cache.hit': false,
+                  cacheSpan(CACHE_GET, {
+                    [DB_OPERATION_NAME]: 'GET',
+                    [DB_QUERY_TEXT]: 'GET redis-5-cache:unavailable-data',
+                    [CACHE_KEY]: ['redis-5-cache:unavailable-data'],
+                    [CACHE_HIT]: false,
                   }),
-                  cacheSpan('cache.get', {
-                    'db.operation.name': 'MGET',
-                    'db.query.text': 'MGET [3 other arguments]',
-                    'cache.key': ['redis-5-test-key', 'redis-5-cache:test-key', 'redis-5-cache:unavailable-data'],
-                    'cache.hit': true,
-                    'cache.item_size': 20,
+                  cacheSpan(CACHE_GET, {
+                    [DB_OPERATION_NAME]: 'MGET',
+                    [DB_QUERY_TEXT]: 'MGET [3 other arguments]',
+                    [CACHE_KEY]: ['redis-5-test-key', 'redis-5-cache:test-key', 'redis-5-cache:unavailable-data'],
+                    [CACHE_HIT]: true,
+                    [CACHE_ITEM_SIZE]: 20,
                   }),
-                  cacheSpan('cache.remove', {
-                    'db.operation.name': 'DEL',
-                    'db.query.text': 'DEL redis-5-cache:test-key',
-                    'cache.key': ['redis-5-cache:test-key'],
+                  cacheSpan(CACHE_REMOVE, {
+                    [DB_OPERATION_NAME]: 'DEL',
+                    [DB_QUERY_TEXT]: 'DEL redis-5-cache:test-key',
+                    [CACHE_KEY]: ['redis-5-cache:test-key'],
                   }),
-                  span('MULTI', redisSpanOp, { 'db.operation.name': 'MULTI', 'db.operation.batch.size': 2 }),
+                  span('MULTI', redisSpanOp, { [DB_OPERATION_NAME]: 'MULTI', [DB_OPERATION_BATCH_SIZE]: 2 }),
                   span(
                     'INCR localhost:6383',
                     redisSpanOp,
                     {
-                      'db.operation.name': 'INCR',
-                      'db.query.text': 'INCR redis-5-test-key',
-                      'error.type': 'Error',
-                      'sentry.status.message': 'ERR value is not an integer or out of range',
+                      [DB_OPERATION_NAME]: 'INCR',
+                      [DB_QUERY_TEXT]: 'INCR redis-5-test-key',
+                      [ERROR_TYPE]: 'Error',
+                      [SENTRY_STATUS_MESSAGE]: 'ERR value is not an integer or out of range',
                     },
                     'error',
                   ),
diff --git a/dev-packages/node-integration-tests/suites/tracing/redis-dc/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/redis-dc/instrument.mjs
index d4f8cc7801fc..28e109af9952 100644
--- a/dev-packages/node-integration-tests/suites/tracing/redis-dc/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/redis-dc/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/redis-dc/test.ts b/dev-packages/node-integration-tests/suites/tracing/redis-dc/test.ts
index 06d8cac5a465..a5bf7450724d 100644
--- a/dev-packages/node-integration-tests/suites/tracing/redis-dc/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/redis-dc/test.ts
@@ -1,6 +1,30 @@
-import { SENTRY_TRACE_LIFECYCLE } from '@sentry/conventions/attributes';
-import type { SerializedStreamedSpanContainer } from '@sentry/core';
-import { afterAll, describe, expect } from 'vitest';
+import {
+  CACHE_HIT,
+  CACHE_ITEM_SIZE,
+  CACHE_KEY,
+  CACHE_OPERATION,
+  DB_OPERATION_NAME,
+  DB_QUERY_TEXT,
+  DB_SYSTEM_NAME,
+  ERROR_TYPE,
+  NETWORK_PEER_ADDRESS,
+  NETWORK_PEER_PORT,
+  SENTRY_ENVIRONMENT,
+  SENTRY_IS_LOCALHOST,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_RELEASE,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SEGMENT_NAME,
+  SENTRY_STATUS_MESSAGE,
+  SENTRY_TRACE_LIFECYCLE,
+  SERVER_ADDRESS,
+  SERVER_PORT,
+} from '@sentry/conventions/attributes';
+import { CACHE_GET, CACHE_PUT, type CACHE_REMOVE, DB_QUERY } from '@sentry/conventions/op';
+import { afterAll, expect } from 'vitest';
 import { EXPECTED_SDK_NAME } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
@@ -12,134 +36,21 @@ describeWithDockerCompose(
       cleanupChildProcesses();
     });
 
-    const EXPECTED_TRANSACTION = {
-      transaction: 'Test Span Redis 5 DC',
-      spans: expect.arrayContaining([
-        expect.objectContaining({
-          op: 'db.query',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.op': 'db.query',
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.system.name': 'redis',
-            'db.query.text': 'SET dc-test-key ?',
-          }),
-        }),
-        // cache SET: starts as a cache span, named by its key in the static lifecycle
-        expect.objectContaining({
-          description: 'dc-cache:test-key',
-          op: 'cache.put',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.query.text': 'SET dc-cache:test-key ?',
-            'cache.key': ['dc-cache:test-key'],
-            'cache.item_size': 2,
-          }),
-        }),
-        // cache SET with EX option: redis v5 sends SET key value EX 10 as the command
-        expect.objectContaining({
-          description: 'dc-cache:test-key-ex',
-          op: 'cache.put',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.query.text': 'SET dc-cache:test-key-ex ? ? ?',
-            'cache.key': ['dc-cache:test-key-ex'],
-            'cache.item_size': 2,
-          }),
-        }),
-        expect.objectContaining({
-          op: 'db.query',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.op': 'db.query',
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.system.name': 'redis',
-            'db.query.text': 'GET dc-test-key',
-          }),
-        }),
-        // cache GET (hit)
-        expect.objectContaining({
-          description: 'dc-cache:test-key',
-          op: 'cache.get',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.query.text': 'GET dc-cache:test-key',
-            'cache.hit': true,
-            'cache.key': ['dc-cache:test-key'],
-            'cache.item_size': 10,
-          }),
-        }),
-        // cache GET (miss)
-        expect.objectContaining({
-          description: 'dc-cache:unavailable-data',
-          op: 'cache.get',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.query.text': 'GET dc-cache:unavailable-data',
-            'cache.hit': false,
-            'cache.key': ['dc-cache:unavailable-data'],
-          }),
-        }),
-        // MGET: node-redis sanitizes args for diagnostics_channel (keys become '?'),
-        // so cache detection cannot match prefixes — remains a plain db.query span.
-        expect.objectContaining({
-          op: 'db.query',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'sentry.op': 'db.query',
-            'sentry.origin': 'auto.db.redis.diagnostic_channel',
-            'db.system.name': 'redis',
-            'db.query.text': 'MGET ? ? ?',
-          }),
-        }),
-        // a failing command on a cache key reports as an errored cache span:
-        // the span starts as a cache span, so the classification survives the error
-        expect.objectContaining({
-          description: 'dc-cache:list-key',
-          op: 'cache.get',
-          status: 'internal_error',
-          origin: 'auto.db.redis.diagnostic_channel',
-          data: expect.objectContaining({
-            'cache.operation': 'get',
-            'cache.key': ['dc-cache:list-key'],
-          }),
-        }),
-      ]),
-    };
-
-    // node-redis emits a node-redis:connect DC event for the initial connection.
-    // That fires before startSpan so it arrives as the first envelope.
-    const EXPECTED_CONNECT = {
-      transaction: 'redis-connect',
-    };
-
     createEsmAndCjsTests(__dirname, 'scenario-redis-5-tracing.mjs', 'instrument.mjs', (createTestRunner, test) => {
-      test('should create spans for redis v5 commands via diagnostics_channel', { timeout: 60_000 }, async () => {
-        await createTestRunner()
-          .expect({ transaction: EXPECTED_CONNECT })
-          .expect({ transaction: EXPECTED_TRANSACTION })
-          .start()
-          .completed();
-      });
-
       // `ignoreSpans` is evaluated at span start under streaming, so this only passes because the
       // span starts as a cache span — a db span renamed at response time would slip through.
       test('drops cache spans matching an ignoreSpans op filter at span start', { timeout: 60_000 }, async () => {
         await createTestRunner()
-          .withEnv({ STREAMED: 'true', IGNORE_CACHE_GET: 'true' })
+          .withEnv({ IGNORE_CACHE_GET: 'true' })
           .unignore('client_report')
           // The span container and the client report flush on independent timers, so they can
           // arrive in either order.
           .unordered()
           .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
+            span: container => {
               const names = container.items.map(item => item.name);
-              expect(names).toContain('cache.put');
-              expect(names).not.toContain('cache.get');
+              expect(names).toContain(CACHE_PUT);
+              expect(names).not.toContain(CACHE_GET);
             },
           })
           .expect({
@@ -155,148 +66,142 @@ describeWithDockerCompose(
       });
     });
 
-    // The same commands as above, asserted on the streamed span container. With span streaming the
-    // db spans are named `{db.operation.name} {server.address}:{server.port}` instead of
-    // `redis-{command}`.
-    describe('streamed', () => {
-      const ORIGIN = 'auto.db.redis.diagnostic_channel';
-      const SEGMENT_NAME = 'Test Span Redis 5 DC';
-      const HOST = '127.0.0.1';
-      const PORT = 6381;
+    const ORIGIN = 'auto.db.redis.diagnostic_channel';
+    const SEGMENT_NAME = 'Test Span Redis 5 DC';
+    const HOST = '127.0.0.1';
+    const PORT = 6381;
 
-      const streamAttribute = (value: unknown): { type: string; value: unknown } => ({
-        type: Array.isArray(value) ? 'array' : Number.isInteger(value) ? 'integer' : typeof value,
-        value,
-      });
+    const streamAttribute = (value: unknown): { type: string; value: unknown } => ({
+      type: Array.isArray(value) ? 'array' : Number.isInteger(value) ? 'integer' : typeof value,
+      value,
+    });
 
-      // Streamed spans carry `{ type, value }` attribute pairs; the expectations below are written
-      // as plain values and wrapped here.
-      const streamAttributes = (values: Record<string, unknown>): Record<string, unknown> =>
-        Object.fromEntries(Object.entries(values).map(([key, value]) => [key, streamAttribute(value)]));
+    // Streamed spans carry `{ type, value }` attribute pairs; the expectations below are written
+    // as plain values and wrapped here.
+    const streamAttributes = (values: Record<string, unknown>): Record<string, unknown> =>
+      Object.fromEntries(Object.entries(values).map(([key, value]) => [key, streamAttribute(value)]));
 
-      function streamedSpan(name: string, op: string, attributes: Record<string, unknown>): unknown {
-        return {
-          name,
-          attributes: {
-            ...streamAttributes({
-              'db.system.name': 'redis',
-              'sentry.environment': 'production',
-              'sentry.op': op,
-              'sentry.origin': ORIGIN,
-              'sentry.release': '1.0',
-              'sentry.sdk.name': EXPECTED_SDK_NAME,
-              'sentry.segment.name': SEGMENT_NAME,
-              'server.address': HOST,
-              'server.port': PORT,
-              [SENTRY_TRACE_LIFECYCLE]: 'stream',
-              ...attributes,
-            }),
-            'sentry.sdk.version': { type: 'string', value: expect.any(String) },
-            'sentry.segment.id': { type: 'string', value: expect.stringMatching(/^[\da-f]{16}$/) },
-            'sentry.is_localhost': { type: 'boolean', value: false },
-          },
-          end_timestamp: expect.any(Number),
-          is_segment: false,
-          parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
-          span_id: expect.stringMatching(/^[\da-f]{16}$/),
-          start_timestamp: expect.any(Number),
-          status: 'ok',
-          trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-        };
-      }
+    function streamedSpan(name: string, op: string, attributes: Record<string, unknown>): unknown {
+      return {
+        name,
+        attributes: {
+          ...streamAttributes({
+            [DB_SYSTEM_NAME]: 'redis',
+            [SENTRY_ENVIRONMENT]: 'production',
+            [SENTRY_OP]: op,
+            [SENTRY_ORIGIN]: ORIGIN,
+            [SENTRY_RELEASE]: '1.0',
+            [SENTRY_SDK_NAME]: EXPECTED_SDK_NAME,
+            [SENTRY_SEGMENT_NAME]: SEGMENT_NAME,
+            [SERVER_ADDRESS]: HOST,
+            [SERVER_PORT]: PORT,
+            [SENTRY_TRACE_LIFECYCLE]: 'stream',
+            ...attributes,
+          }),
+          [SENTRY_SDK_VERSION]: { type: 'string', value: expect.any(String) },
+          [SENTRY_SEGMENT_ID]: { type: 'string', value: expect.stringMatching(/^[\da-f]{16}$/) },
+          [SENTRY_IS_LOCALHOST]: { type: 'boolean', value: false },
+        },
+        end_timestamp: expect.any(Number),
+        is_segment: false,
+        parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
+        span_id: expect.stringMatching(/^[\da-f]{16}$/),
+        start_timestamp: expect.any(Number),
+        status: 'ok',
+        trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+      };
+    }
 
-      const PEER = { 'network.peer.address': HOST, 'network.peer.port': PORT };
+    const PEER = { [NETWORK_PEER_ADDRESS]: HOST, [NETWORK_PEER_PORT]: PORT };
 
-      // A cache span is a db span whose key matched a cache prefix: it starts named after its
-      // cache operation and reports the connection as peer attributes too.
-      const cacheSpan = (
-        op: 'cache.get' | 'cache.put' | 'cache.remove',
-        attributes: Record<string, unknown>,
-      ): unknown => streamedSpan(op, op, { ...PEER, 'cache.operation': op.slice('cache.'.length), ...attributes });
+    // A cache span is a db span whose key matched a cache prefix: it starts named after its
+    // cache operation and reports the connection as peer attributes too.
+    const cacheSpan = (
+      op: typeof CACHE_GET | typeof CACHE_PUT | typeof CACHE_REMOVE,
+      attributes: Record<string, unknown>,
+    ): unknown => streamedSpan(op, op, { ...PEER, [CACHE_OPERATION]: op.slice('cache.'.length), ...attributes });
 
-      createEsmAndCjsTests(__dirname, 'scenario-redis-5-tracing.mjs', 'instrument.mjs', (createTestRunner, test) => {
-        test('creates streamed spans for redis v5 commands via diagnostics_channel', { timeout: 60_000 }, async () => {
-          await createTestRunner()
-            .withEnv({ STREAMED: 'true' })
-            .expect({
-              span: (container: SerializedStreamedSpanContainer) => {
-                // The connect span opens its own segment but shares the trace with the test span,
-                // so both segments arrive in the same container.
-                expect(container.items.filter(item => item.is_segment).map(item => item.name)).toEqual([
-                  'redis-connect',
-                  SEGMENT_NAME,
-                ]);
+    createEsmAndCjsTests(__dirname, 'scenario-redis-5-tracing.mjs', 'instrument.mjs', (createTestRunner, test) => {
+      test('should create spans for redis v5 commands via diagnostics_channel', { timeout: 60_000 }, async () => {
+        await createTestRunner()
+          .expect({
+            span: container => {
+              // The connect span opens its own segment but shares the trace with the test span,
+              // so both segments arrive in the same container.
+              expect(container.items.filter(item => item.is_segment).map(item => item.name)).toEqual([
+                'redis-connect',
+                SEGMENT_NAME,
+              ]);
 
-                const spans = container.items.filter(
-                  item => !item.is_segment && item.attributes['sentry.segment.name']?.value === SEGMENT_NAME,
-                );
+              const spans = container.items.filter(
+                item => !item.is_segment && item.attributes[SENTRY_SEGMENT_NAME]?.value === SEGMENT_NAME,
+              );
 
-                expect(spans).toEqual([
-                  streamedSpan(`SET ${HOST}:${PORT}`, 'db.query', {
-                    'db.operation.name': 'SET',
-                    'db.query.text': 'SET dc-test-key ?',
-                  }),
-                  // cache SET: starts as a cache span
-                  cacheSpan('cache.put', {
-                    'db.operation.name': 'SET',
-                    'db.query.text': 'SET dc-cache:test-key ?',
-                    'cache.key': ['dc-cache:test-key'],
-                    'cache.item_size': 2,
-                  }),
-                  // cache SET with EX option: redis v5 sends SET key value EX 10 as the command
-                  cacheSpan('cache.put', {
-                    'db.operation.name': 'SET',
-                    'db.query.text': 'SET dc-cache:test-key-ex ? ? ?',
-                    'cache.key': ['dc-cache:test-key-ex'],
-                    'cache.item_size': 2,
-                  }),
-                  streamedSpan(`GET ${HOST}:${PORT}`, 'db.query', {
-                    'db.operation.name': 'GET',
-                    'db.query.text': 'GET dc-test-key',
-                  }),
-                  // cache GET (hit)
-                  cacheSpan('cache.get', {
-                    'db.operation.name': 'GET',
-                    'db.query.text': 'GET dc-cache:test-key',
-                    'cache.key': ['dc-cache:test-key'],
-                    'cache.hit': true,
-                    'cache.item_size': 10,
-                  }),
-                  // cache GET (miss)
-                  cacheSpan('cache.get', {
-                    'db.operation.name': 'GET',
-                    'db.query.text': 'GET dc-cache:unavailable-data',
-                    'cache.key': ['dc-cache:unavailable-data'],
-                    'cache.hit': false,
-                  }),
-                  // MGET: node-redis sanitizes args for diagnostics_channel (keys become '?'),
-                  // so cache detection cannot match prefixes — remains a plain db.query span.
-                  streamedSpan(`MGET ${HOST}:${PORT}`, 'db.query', {
-                    'db.operation.name': 'MGET',
-                    'db.query.text': 'MGET ? ? ?',
-                  }),
-                  streamedSpan(`LPUSH ${HOST}:${PORT}`, 'db.query', {
-                    'db.operation.name': 'LPUSH',
-                    'db.query.text': 'LPUSH dc-cache:list-key ?',
-                  }),
-                  // a failing command on a cache key reports as an errored cache span:
-                  // the span starts as a cache span, so the classification survives the error
-                  {
-                    ...(cacheSpan('cache.get', {
-                      'db.operation.name': 'GET',
-                      'db.query.text': 'GET dc-cache:list-key',
-                      'cache.key': ['dc-cache:list-key'],
-                      'error.type': 'Error',
-                      'sentry.status.message': 'WRONGTYPE Operation against a key holding the wrong kind of value',
-                    }) as Record<string, unknown>),
-                    status: 'error',
-                  },
-                ]);
-              },
-            })
-            .start()
-            .completed();
-        });
+              expect(spans).toEqual([
+                streamedSpan(`SET ${HOST}:${PORT}`, DB_QUERY, {
+                  [DB_OPERATION_NAME]: 'SET',
+                  [DB_QUERY_TEXT]: 'SET dc-test-key ?',
+                }),
+                // cache SET: starts as a cache span
+                cacheSpan(CACHE_PUT, {
+                  [DB_OPERATION_NAME]: 'SET',
+                  [DB_QUERY_TEXT]: 'SET dc-cache:test-key ?',
+                  [CACHE_KEY]: ['dc-cache:test-key'],
+                  [CACHE_ITEM_SIZE]: 2,
+                }),
+                // cache SET with EX option: redis v5 sends SET key value EX 10 as the command
+                cacheSpan(CACHE_PUT, {
+                  [DB_OPERATION_NAME]: 'SET',
+                  [DB_QUERY_TEXT]: 'SET dc-cache:test-key-ex ? ? ?',
+                  [CACHE_KEY]: ['dc-cache:test-key-ex'],
+                  [CACHE_ITEM_SIZE]: 2,
+                }),
+                streamedSpan(`GET ${HOST}:${PORT}`, DB_QUERY, {
+                  [DB_OPERATION_NAME]: 'GET',
+                  [DB_QUERY_TEXT]: 'GET dc-test-key',
+                }),
+                // cache GET (hit)
+                cacheSpan(CACHE_GET, {
+                  [DB_OPERATION_NAME]: 'GET',
+                  [DB_QUERY_TEXT]: 'GET dc-cache:test-key',
+                  [CACHE_KEY]: ['dc-cache:test-key'],
+                  [CACHE_HIT]: true,
+                  [CACHE_ITEM_SIZE]: 10,
+                }),
+                // cache GET (miss)
+                cacheSpan(CACHE_GET, {
+                  [DB_OPERATION_NAME]: 'GET',
+                  [DB_QUERY_TEXT]: 'GET dc-cache:unavailable-data',
+                  [CACHE_KEY]: ['dc-cache:unavailable-data'],
+                  [CACHE_HIT]: false,
+                }),
+                // MGET: node-redis sanitizes args for diagnostics_channel (keys become '?'),
+                // so cache detection cannot match prefixes — remains a plain db.query span.
+                streamedSpan(`MGET ${HOST}:${PORT}`, DB_QUERY, {
+                  [DB_OPERATION_NAME]: 'MGET',
+                  [DB_QUERY_TEXT]: 'MGET ? ? ?',
+                }),
+                streamedSpan(`LPUSH ${HOST}:${PORT}`, DB_QUERY, {
+                  [DB_OPERATION_NAME]: 'LPUSH',
+                  [DB_QUERY_TEXT]: 'LPUSH dc-cache:list-key ?',
+                }),
+                // a failing command on a cache key reports as an errored cache span:
+                // the span starts as a cache span, so the classification survives the error
+                {
+                  ...(cacheSpan(CACHE_GET, {
+                    [DB_OPERATION_NAME]: 'GET',
+                    [DB_QUERY_TEXT]: 'GET dc-cache:list-key',
+                    [CACHE_KEY]: ['dc-cache:list-key'],
+                    [ERROR_TYPE]: 'Error',
+                    [SENTRY_STATUS_MESSAGE]: 'WRONGTYPE Operation against a key holding the wrong kind of value',
+                  }) as Record<string, unknown>),
+                  status: 'error',
+                },
+              ]);
+            },
+          })
+          .start()
+          .completed();
       });
     });
   },
diff --git a/dev-packages/node-integration-tests/suites/tracing/redis/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/redis/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/redis/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/redis/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/redis/test.ts b/dev-packages/node-integration-tests/suites/tracing/redis/test.ts
index d8b8b728a2af..36decf4b6001 100644
--- a/dev-packages/node-integration-tests/suites/tracing/redis/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/redis/test.ts
@@ -1,6 +1,25 @@
-import { SENTRY_TRACE_LIFECYCLE, SENTRY_OP } from '@sentry/conventions/attributes';
-import { type SerializedStreamedSpanContainer } from '@sentry/core';
-import { afterAll, describe, expect } from 'vitest';
+import {
+  DB_OPERATION_NAME,
+  DB_QUERY_TEXT,
+  DB_SYSTEM_NAME,
+  ERROR_TYPE,
+  SENTRY_ENVIRONMENT,
+  SENTRY_IS_LOCALHOST,
+  SENTRY_KIND,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_RELEASE,
+  SENTRY_SDK_NAME,
+  SENTRY_SDK_VERSION,
+  SENTRY_SEGMENT_ID,
+  SENTRY_SEGMENT_NAME,
+  SENTRY_STATUS_MESSAGE,
+  SENTRY_TRACE_LIFECYCLE,
+  SERVER_ADDRESS,
+  SERVER_PORT,
+} from '@sentry/conventions/attributes';
+import { DB_QUERY } from '@sentry/conventions/op';
+import { afterAll, expect } from 'vitest';
 import { EXPECTED_SDK_NAME } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
@@ -13,126 +32,66 @@ describeWithDockerCompose('redis auto instrumentation', { workingDirectory: [__d
   // subscriber instead of the OTel monkey-patch, so the span origin differs. All
   // other attributes are identical.
   const origin = 'auto.db.redis';
-  const redisSpanOp = 'db.query';
-  const redisData = {
-    'db.system.name': 'redis',
-    'server.address': 'localhost',
-    'server.port': 6380,
+  const redisSpanOp = DB_QUERY;
+  const COMMON_ATTRIBUTES = {
+    [SENTRY_IS_LOCALHOST]: { type: 'boolean', value: false },
+    [DB_SYSTEM_NAME]: { type: 'string', value: 'redis' },
+    [SERVER_ADDRESS]: { type: 'string', value: 'localhost' },
+    [SERVER_PORT]: { type: 'integer', value: 6380 },
+    [SENTRY_KIND]: { type: 'string', value: 'client' },
+    [SENTRY_ENVIRONMENT]: { type: 'string', value: 'production' },
+    [SENTRY_OP]: { type: 'string', value: redisSpanOp },
+    [SENTRY_ORIGIN]: { type: 'string', value: origin },
+    [SENTRY_RELEASE]: { type: 'string', value: '1.0' },
+    [SENTRY_SDK_NAME]: { type: 'string', value: EXPECTED_SDK_NAME },
+    [SENTRY_SDK_VERSION]: { type: 'string', value: expect.any(String) },
+    [SENTRY_SEGMENT_ID]: { type: 'string', value: expect.stringMatching(/^[\da-f]{16}$/) },
+    [SENTRY_SEGMENT_NAME]: { type: 'string', value: 'Test Span' },
+    [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
   };
 
-  const EXPECTED_TRANSACTION = {
-    transaction: 'Test Span',
-    spans: expect.arrayContaining([
-      expect.objectContaining({
-        description: 'set test-key [1 other arguments]',
-        op: redisSpanOp,
-        origin,
-        data: expect.objectContaining({
-          'sentry.op': redisSpanOp,
-          'sentry.origin': origin,
-          ...redisData,
-          'db.query.text': 'set test-key [1 other arguments]',
-        }),
-      }),
-      expect.objectContaining({
-        description: 'get test-key',
-        op: redisSpanOp,
-        origin,
-        data: expect.objectContaining({
-          'sentry.op': redisSpanOp,
-          'sentry.origin': origin,
-          ...redisData,
-          'db.query.text': 'get test-key',
-        }),
-      }),
-      // a failing command produces a span with an error status
-      expect.objectContaining({
-        description: 'incr test-key',
-        op: redisSpanOp,
-        status: 'internal_error',
-        origin,
-        data: expect.objectContaining({
-          'sentry.op': redisSpanOp,
-          'sentry.origin': origin,
-          ...redisData,
-          'db.query.text': 'incr test-key',
-        }),
-      }),
-    ]),
-  };
+  function expectedDbSpan({
+    operation,
+    statement,
+    status = 'ok',
+    errorMessage,
+  }: {
+    operation: string;
+    statement: string;
+    status?: string;
+    errorMessage?: string;
+  }): unknown {
+    return {
+      attributes: {
+        ...COMMON_ATTRIBUTES,
+        [DB_OPERATION_NAME]: { type: 'string', value: operation },
+        [DB_QUERY_TEXT]: { type: 'string', value: statement },
+        ...(errorMessage
+          ? {
+              [ERROR_TYPE]: { type: 'string', value: 'ReplyError' },
+              [SENTRY_STATUS_MESSAGE]: { type: 'string', value: errorMessage },
+            }
+          : {}),
+      },
+      name: `${operation} localhost:6380`,
+      end_timestamp: expect.any(Number),
+      is_segment: false,
+      parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
+      span_id: expect.stringMatching(/^[\da-f]{16}$/),
+      start_timestamp: expect.any(Number),
+      status,
+      trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+    };
+  }
 
   createEsmAndCjsTests(__dirname, 'scenario-ioredis.mjs', 'instrument.mjs', (createTestRunner, test) => {
     test(
       'should auto-instrument `ioredis` package when using redis.set() and redis.get()',
       { timeout: 75_000 },
       async () => {
-        await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
-      },
-    );
-  });
-
-  describe('streamed', () => {
-    // The same three commands as above, asserted on the streamed span container. Only the span
-    // name differs: with span streaming names have to be low cardinality, so the serialized
-    // statement is reported through `db.query.text` alone and the name becomes
-    // `{db.operation.name} {server.address}:{server.port}`.
-    const COMMON_ATTRIBUTES = {
-      'sentry.is_localhost': { type: 'boolean', value: false },
-      'db.system.name': { type: 'string', value: 'redis' },
-      'server.address': { type: 'string', value: 'localhost' },
-      'server.port': { type: 'integer', value: 6380 },
-      'sentry.kind': { type: 'string', value: 'client' },
-      'sentry.environment': { type: 'string', value: 'production' },
-      'sentry.op': { type: 'string', value: redisSpanOp },
-      'sentry.origin': { type: 'string', value: origin },
-      'sentry.release': { type: 'string', value: '1.0' },
-      'sentry.sdk.name': { type: 'string', value: EXPECTED_SDK_NAME },
-      'sentry.sdk.version': { type: 'string', value: expect.any(String) },
-      'sentry.segment.id': { type: 'string', value: expect.stringMatching(/^[\da-f]{16}$/) },
-      'sentry.segment.name': { type: 'string', value: 'Test Span' },
-      [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
-    };
-
-    function expectedDbSpan({
-      operation,
-      statement,
-      status = 'ok',
-      errorMessage,
-    }: {
-      operation: string;
-      statement: string;
-      status?: string;
-      errorMessage?: string;
-    }): unknown {
-      return {
-        attributes: {
-          ...COMMON_ATTRIBUTES,
-          'db.operation.name': { type: 'string', value: operation },
-          'db.query.text': { type: 'string', value: statement },
-          ...(errorMessage
-            ? {
-                'error.type': { type: 'string', value: 'ReplyError' },
-                'sentry.status.message': { type: 'string', value: errorMessage },
-              }
-            : {}),
-        },
-        name: `${operation} localhost:6380`,
-        end_timestamp: expect.any(Number),
-        is_segment: false,
-        parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
-        span_id: expect.stringMatching(/^[\da-f]{16}$/),
-        start_timestamp: expect.any(Number),
-        status,
-        trace_id: expect.stringMatching(/^[\da-f]{32}$/),
-      };
-    }
-
-    createEsmAndCjsTests(__dirname, 'scenario-ioredis.mjs', 'instrument.mjs', (createTestRunner, test) => {
-      test('should auto-instrument `ioredis` package with span streaming enabled', { timeout: 75_000 }, async () => {
         await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
           .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
+            span: container => {
               const segmentSpan = container.items.find(item => item.is_segment);
               expect(segmentSpan?.name).toBe('Test Span');
 
@@ -153,7 +112,7 @@ describeWithDockerCompose('redis auto instrumentation', { workingDirectory: [__d
           })
           .start()
           .completed();
-      });
-    });
+      },
+    );
   });
 });

From 2c26a4a69d3947cf900d67d76c5815d7da6425b2 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Fri, 9 Oct 2026 21:03:36 +0200
Subject: [PATCH 49/84] test(node): Port Mongoose integration tests to span
 streaming (#25151)

Port the Mongoose suites to default span streaming, preserving
assertions and removing duplicate cases.

Part of #24137

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../mongoose-tracing-channel/instrument.mjs   |   1 -
 .../tracing/mongoose-tracing-channel/test.ts  | 145 +++++++---------
 .../suites/tracing/mongoose-v5/instrument.mjs |   1 -
 .../suites/tracing/mongoose-v5/test.ts        |  52 ++----
 .../suites/tracing/mongoose-v7/instrument.mjs |   1 -
 .../suites/tracing/mongoose-v7/test.ts        |  52 ++----
 .../suites/tracing/mongoose-v8/instrument.mjs |   1 -
 .../suites/tracing/mongoose-v8/test.ts        |  65 ++-----
 .../suites/tracing/mongoose-v9/instrument.mjs |   1 -
 .../suites/tracing/mongoose-v9/test.ts        |  55 ++----
 .../suites/tracing/mongoose/instrument.mjs    |   1 -
 .../suites/tracing/mongoose/test.ts           | 164 +++++-------------
 12 files changed, 171 insertions(+), 368 deletions(-)

diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose-tracing-channel/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/mongoose-tracing-channel/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose-tracing-channel/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose-tracing-channel/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose-tracing-channel/test.ts b/dev-packages/node-integration-tests/suites/tracing/mongoose-tracing-channel/test.ts
index 2a0cd427a3bb..5795d880503b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose-tracing-channel/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose-tracing-channel/test.ts
@@ -1,4 +1,17 @@
-import type { SerializedStreamedSpanContainer } from '@sentry/core';
+import {
+  DB_COLLECTION_NAME,
+  DB_NAMESPACE,
+  DB_OPERATION_BATCH_SIZE,
+  DB_OPERATION_NAME,
+  DB_QUERY_TEXT,
+  DB_SYSTEM_NAME,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_TRACE_LIFECYCLE,
+  SERVER_ADDRESS,
+  SERVER_PORT,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
@@ -24,83 +37,50 @@ describe('Mongoose tracing channel Test', () => {
     cleanupChildProcesses();
   });
 
-  const expectedSpan = (operation: string, extraData: Record<string, unknown> = {}) =>
-    expect.objectContaining({
-      data: expect.objectContaining({
-        'db.system.name': 'mongodb',
-        'db.namespace': 'test',
-        'db.collection.name': 'blogposts',
-        'db.operation.name': operation,
-        'server.address': expect.any(String),
-        'server.port': expect.any(Number),
-        ...extraData,
-      }),
-      description: `mongoose.blogposts.${operation}`,
-      op: 'db',
-      origin: 'auto.db.mongoose.diagnostic_channel',
-    });
-
   const expectedStreamedSpan = (operation: string, extraAttributes: Record<string, unknown> = {}) =>
     expect.objectContaining({
       name: `${operation} blogposts`,
       is_segment: false,
       parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
       attributes: expect.objectContaining({
-        'db.collection.name': { type: 'string', value: 'blogposts' },
-        'db.namespace': { type: 'string', value: 'test' },
-        'db.operation.name': { type: 'string', value: operation },
-        'db.system.name': { type: 'string', value: 'mongodb' },
-        'sentry.op': { type: 'string', value: 'db' },
-        'sentry.origin': { type: 'string', value: 'auto.db.mongoose.diagnostic_channel' },
-        'sentry.trace_lifecycle': { type: 'string', value: 'stream' },
+        [DB_COLLECTION_NAME]: { type: 'string', value: 'blogposts' },
+        [DB_NAMESPACE]: { type: 'string', value: 'test' },
+        [DB_OPERATION_NAME]: { type: 'string', value: operation },
+        [DB_SYSTEM_NAME]: { type: 'string', value: 'mongodb' },
+        [SENTRY_OP]: { type: 'string', value: DB },
+        [SENTRY_ORIGIN]: { type: 'string', value: 'auto.db.mongoose.diagnostic_channel' },
+        [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
+        [SERVER_ADDRESS]: { type: 'string', value: expect.any(String) },
+        [SERVER_PORT]: { type: 'integer', value: expect.any(Number) },
         ...extraAttributes,
       }),
     });
 
-  const EXPECTED_TRANSACTION = {
-    transaction: 'Test Transaction',
-    spans: expect.arrayContaining([
-      expectedSpan('save'),
-      // filter values are redacted out of `db.query.text`
-      expectedSpan('findOne', { 'db.query.text': '{"title":"?"}' }),
-      expectedSpan('aggregate', { 'db.query.text': '[{"$match":{"title":"?"}}]' }),
-      expectedSpan('insertMany', { 'db.operation.batch.size': 2 }),
-      expectedSpan('bulkWrite', { 'db.operation.batch.size': 2 }),
-      // a cursor iteration emits a span per `.next()` via the `mongoose:cursor:next` channel
-      expectedSpan('find'),
-    ]),
-  };
-
   createEsmAndCjsTests(
     __dirname,
     'scenario.mjs',
     'instrument.mjs',
     (createTestRunner, test) => {
       test('subscribes to mongoose >= 9.7 diagnostics channels with stable semconv attributes', async () => {
-        await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
-      });
-
-      test('names channel spans after the operation and collection with span streaming enabled', async () => {
         await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
           .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
+            span: container => {
               expect(container.items.find(item => item.is_segment)?.name).toBe('Test Transaction');
 
               expect(container.items).toContainEqual(expectedStreamedSpan('save'));
               expect(container.items).toContainEqual(
-                expectedStreamedSpan('findOne', { 'db.query.text': { type: 'string', value: '{"title":"?"}' } }),
+                expectedStreamedSpan('findOne', { [DB_QUERY_TEXT]: { type: 'string', value: '{"title":"?"}' } }),
               );
               expect(container.items).toContainEqual(
                 expectedStreamedSpan('aggregate', {
-                  'db.query.text': { type: 'string', value: '[{"$match":{"title":"?"}}]' },
+                  [DB_QUERY_TEXT]: { type: 'string', value: '[{"$match":{"title":"?"}}]' },
                 }),
               );
               expect(container.items).toContainEqual(
-                expectedStreamedSpan('insertMany', { 'db.operation.batch.size': { type: 'integer', value: 2 } }),
+                expectedStreamedSpan('insertMany', { [DB_OPERATION_BATCH_SIZE]: { type: 'integer', value: 2 } }),
               );
               expect(container.items).toContainEqual(
-                expectedStreamedSpan('bulkWrite', { 'db.operation.batch.size': { type: 'integer', value: 2 } }),
+                expectedStreamedSpan('bulkWrite', { [DB_OPERATION_BATCH_SIZE]: { type: 'integer', value: 2 } }),
               );
               expect(container.items).toContainEqual(expectedStreamedSpan('find'));
             },
@@ -112,12 +92,14 @@ describe('Mongoose tracing channel Test', () => {
       test('does not double-instrument: the legacy IITM mongoose patcher does not fire on 9.7', async () => {
         await createTestRunner()
           .expect({
-            transaction: event => {
-              const spans = event.spans || [];
+            span: container => {
+              const spans = container.items;
               // The monkey-patch path (origin `auto.db.mongoose`) must be inactive on 9.7+.
-              expect(spans.find(span => span.origin === 'auto.db.mongoose')).toBeUndefined();
+              expect(spans.find(span => span.attributes[SENTRY_ORIGIN]?.value === 'auto.db.mongoose')).toBeUndefined();
               // ...while the diagnostics-channel path is active.
-              expect(spans.find(span => span.origin === 'auto.db.mongoose.diagnostic_channel')).toBeDefined();
+              expect(
+                spans.find(span => span.attributes[SENTRY_ORIGIN]?.value === 'auto.db.mongoose.diagnostic_channel'),
+              ).toBeDefined();
             },
           })
           .start()
@@ -127,10 +109,10 @@ describe('Mongoose tracing channel Test', () => {
       test('never leaks raw filter values into db.query.text', async () => {
         await createTestRunner()
           .expect({
-            transaction: event => {
-              const spans = event.spans || [];
+            span: container => {
+              const spans = container.items;
               for (const span of spans) {
-                const queryText = span.data?.['db.query.text'];
+                const queryText = span.attributes[DB_QUERY_TEXT]?.value;
                 if (typeof queryText === 'string') {
                   expect(queryText).not.toContain('Test');
                 }
@@ -144,14 +126,20 @@ describe('Mongoose tracing channel Test', () => {
       test('nests the mongodb driver span under the mongoose channel span', async () => {
         await createTestRunner()
           .expect({
-            transaction: event => {
-              const spans = event.spans || [];
-              const mongooseSave = spans.find(span => span.description === 'mongoose.blogposts.save');
+            span: container => {
+              const spans = container.items;
+              const mongooseSave = spans.find(
+                span =>
+                  span.name === 'save blogposts' &&
+                  span.attributes[SENTRY_ORIGIN]?.value === 'auto.db.mongoose.diagnostic_channel',
+              );
               expect(mongooseSave).toBeDefined();
               // the underlying mongodb driver span must parent to the mongoose channel span,
               // proving the channel span is the active async context for the traced operation
               const driverChild = spans.find(
-                span => span.parent_span_id === mongooseSave?.span_id && span.origin === driverOrigin,
+                span =>
+                  span.parent_span_id === mongooseSave?.span_id &&
+                  span.attributes[SENTRY_ORIGIN]?.value === driverOrigin,
               );
               expect(driverChild).toBeDefined();
             },
@@ -163,14 +151,18 @@ describe('Mongoose tracing channel Test', () => {
       test('omits db.query.text for the empty-filter cursor and does not treat the cursor batchSize as a batch', async () => {
         await createTestRunner()
           .expect({
-            transaction: event => {
-              const spans = event.spans || [];
+            span: container => {
+              const spans = container.items;
               // the `.find().cursor()` iteration runs with no filter, so there is no query text to emit
-              const cursorFind = spans.find(span => span.description === 'mongoose.blogposts.find');
+              const cursorFind = spans.find(
+                span =>
+                  span.name === 'find blogposts' &&
+                  span.attributes[SENTRY_ORIGIN]?.value === 'auto.db.mongoose.diagnostic_channel',
+              );
               expect(cursorFind).toBeDefined();
-              expect(cursorFind?.data?.['db.query.text']).toBeUndefined();
+              expect(cursorFind?.attributes[DB_QUERY_TEXT]).toBeUndefined();
               // a cursor's `batchSize` is a fetch-tuning option, not a batch-operation size
-              expect(cursorFind?.data?.['db.operation.batch.size']).toBeUndefined();
+              expect(cursorFind?.attributes[DB_OPERATION_BATCH_SIZE]).toBeUndefined();
             },
           })
           .start()
@@ -180,8 +172,6 @@ describe('Mongoose tracing channel Test', () => {
     { additionalDependencies: { mongoose: '^9.7' } },
   );
 
-  // A failed operation must flag the mongoose channel span as errored. mongodb error statuses map to
-  // `internal_error` through the OTel pipeline (same as the postgres/redis suites).
   createEsmAndCjsTests(
     __dirname,
     'scenario-error.mjs',
@@ -190,23 +180,12 @@ describe('Mongoose tracing channel Test', () => {
       test('flags the mongoose channel span as errored when the operation fails', async () => {
         await createTestRunner()
           .expect({
-            transaction: event => {
-              const spans = event.spans || [];
-              const aggregateSpan = spans.find(span => span.description === 'mongoose.blogposts.aggregate');
-              expect(aggregateSpan).toBeDefined();
-              expect(aggregateSpan?.status).toBe('internal_error');
-            },
-          })
-          .start()
-          .completed();
-      });
-
-      test('flags the streamed mongoose channel span as errored when the operation fails', async () => {
-        await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
-          .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
-              const aggregateSpan = container.items.find(item => item.name === 'aggregate blogposts');
+            span: container => {
+              const aggregateSpan = container.items.find(
+                item =>
+                  item.name === 'aggregate blogposts' &&
+                  item.attributes[SENTRY_ORIGIN]?.value === 'auto.db.mongoose.diagnostic_channel',
+              );
               expect(aggregateSpan).toBeDefined();
               expect(aggregateSpan?.status).toBe('error');
             },
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose-v5/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/mongoose-v5/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose-v5/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose-v5/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose-v5/test.ts b/dev-packages/node-integration-tests/suites/tracing/mongoose-v5/test.ts
index 987f278f8d7e..4071fdbdf533 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose-v5/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose-v5/test.ts
@@ -1,4 +1,12 @@
-import type { SerializedStreamedSpanContainer } from '@sentry/core';
+import {
+  DB_COLLECTION_NAME,
+  DB_OPERATION_NAME,
+  DB_SYSTEM_NAME,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_TRACE_LIFECYCLE,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
@@ -22,41 +30,18 @@ describe('Mongoose v5 Test', () => {
     cleanupChildProcesses();
   });
 
-  const expectedSpan = (operation: string) =>
-    expect.objectContaining({
-      data: expect.objectContaining({
-        'db.collection.name': 'blogposts',
-        'db.operation.name': operation,
-        'db.system.name': 'mongodb',
-      }),
-      description: `mongoose.BlogPost.${operation}`,
-      op: 'db',
-      origin,
-    });
-
-  const EXPECTED_TRANSACTION = {
-    transaction: 'Test Transaction',
-    spans: expect.arrayContaining([
-      expectedSpan('save'),
-      expectedSpan('findOne'),
-      expectedSpan('aggregate'),
-      expectedSpan('insertMany'),
-      expectedSpan('bulkWrite'),
-    ]),
-  };
-
   const expectedStreamedSpan = (operation: string) =>
     expect.objectContaining({
       name: `${operation} blogposts`,
       is_segment: false,
       parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
       attributes: expect.objectContaining({
-        'db.collection.name': { type: 'string', value: 'blogposts' },
-        'db.operation.name': { type: 'string', value: operation },
-        'db.system.name': { type: 'string', value: 'mongodb' },
-        'sentry.op': { type: 'string', value: 'db' },
-        'sentry.origin': { type: 'string', value: origin },
-        'sentry.trace_lifecycle': { type: 'string', value: 'stream' },
+        [DB_COLLECTION_NAME]: { type: 'string', value: 'blogposts' },
+        [DB_OPERATION_NAME]: { type: 'string', value: operation },
+        [DB_SYSTEM_NAME]: { type: 'string', value: 'mongodb' },
+        [SENTRY_OP]: { type: 'string', value: DB },
+        [SENTRY_ORIGIN]: { type: 'string', value: origin },
+        [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
       }),
     });
 
@@ -68,14 +53,9 @@ describe('Mongoose v5 Test', () => {
     'instrument.mjs',
     (createTestRunner, test) => {
       test('auto-instruments `mongoose` v5.', async () => {
-        await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
-      });
-
-      test('auto-instruments `mongoose` v5 with span streaming enabled.', async () => {
         await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
           .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
+            span: container => {
               expect(container.items.find(item => item.is_segment)?.name).toBe('Test Transaction');
 
               for (const operation of STREAMED_OPERATIONS) {
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose-v7/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/mongoose-v7/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose-v7/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose-v7/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose-v7/test.ts b/dev-packages/node-integration-tests/suites/tracing/mongoose-v7/test.ts
index 97c253d412ac..42ff84c6dd25 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose-v7/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose-v7/test.ts
@@ -1,4 +1,12 @@
-import type { SerializedStreamedSpanContainer } from '@sentry/core';
+import {
+  DB_COLLECTION_NAME,
+  DB_OPERATION_NAME,
+  DB_SYSTEM_NAME,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_TRACE_LIFECYCLE,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
@@ -20,41 +28,18 @@ describe('Mongoose v7 Test', () => {
     cleanupChildProcesses();
   });
 
-  const expectedSpan = (operation: string) =>
-    expect.objectContaining({
-      data: expect.objectContaining({
-        'db.collection.name': 'blogposts',
-        'db.operation.name': operation,
-        'db.system.name': 'mongodb',
-      }),
-      description: `mongoose.BlogPost.${operation}`,
-      op: 'db',
-      origin,
-    });
-
-  const EXPECTED_TRANSACTION = {
-    transaction: 'Test Transaction',
-    spans: expect.arrayContaining([
-      expectedSpan('save'),
-      expectedSpan('findOne'),
-      expectedSpan('aggregate'),
-      expectedSpan('insertMany'),
-      expectedSpan('bulkWrite'),
-    ]),
-  };
-
   const expectedStreamedSpan = (operation: string) =>
     expect.objectContaining({
       name: `${operation} blogposts`,
       is_segment: false,
       parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
       attributes: expect.objectContaining({
-        'db.collection.name': { type: 'string', value: 'blogposts' },
-        'db.operation.name': { type: 'string', value: operation },
-        'db.system.name': { type: 'string', value: 'mongodb' },
-        'sentry.op': { type: 'string', value: 'db' },
-        'sentry.origin': { type: 'string', value: origin },
-        'sentry.trace_lifecycle': { type: 'string', value: 'stream' },
+        [DB_COLLECTION_NAME]: { type: 'string', value: 'blogposts' },
+        [DB_OPERATION_NAME]: { type: 'string', value: operation },
+        [DB_SYSTEM_NAME]: { type: 'string', value: 'mongodb' },
+        [SENTRY_OP]: { type: 'string', value: DB },
+        [SENTRY_ORIGIN]: { type: 'string', value: origin },
+        [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
       }),
     });
 
@@ -66,14 +51,9 @@ describe('Mongoose v7 Test', () => {
     'instrument.mjs',
     (createTestRunner, test) => {
       test('auto-instruments `mongoose` v7.', async () => {
-        await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
-      });
-
-      test('auto-instruments `mongoose` v7 with span streaming enabled.', async () => {
         await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
           .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
+            span: container => {
               expect(container.items.find(item => item.is_segment)?.name).toBe('Test Transaction');
 
               for (const operation of STREAMED_OPERATIONS) {
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose-v8/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/mongoose-v8/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose-v8/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose-v8/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose-v8/test.ts b/dev-packages/node-integration-tests/suites/tracing/mongoose-v8/test.ts
index 4109d26a70f4..cb3756e4e723 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose-v8/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose-v8/test.ts
@@ -1,4 +1,12 @@
-import type { SerializedStreamedSpanContainer } from '@sentry/core';
+import {
+  DB_COLLECTION_NAME,
+  DB_OPERATION_NAME,
+  DB_SYSTEM_NAME,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_TRACE_LIFECYCLE,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
@@ -21,54 +29,18 @@ describe('Mongoose v8 Test', () => {
     cleanupChildProcesses();
   });
 
-  const EXPECTED_TRANSACTION = {
-    transaction: 'Test Transaction',
-    spans: expect.arrayContaining([
-      expect.objectContaining({
-        data: expect.objectContaining({
-          'db.collection.name': 'blogposts',
-          'db.operation.name': 'save',
-          'db.system.name': 'mongodb',
-        }),
-        description: 'mongoose.BlogPost.save',
-        op: 'db',
-        origin,
-      }),
-      expect.objectContaining({
-        data: expect.objectContaining({
-          'db.collection.name': 'blogposts',
-          'db.operation.name': 'updateOne',
-          'db.system.name': 'mongodb',
-        }),
-        description: 'mongoose.BlogPost.updateOne',
-        op: 'db',
-        origin,
-      }),
-      expect.objectContaining({
-        data: expect.objectContaining({
-          'db.collection.name': 'blogposts',
-          'db.operation.name': 'deleteOne',
-          'db.system.name': 'mongodb',
-        }),
-        description: 'mongoose.BlogPost.deleteOne',
-        op: 'db',
-        origin,
-      }),
-    ]),
-  };
-
   const expectedStreamedSpan = (operation: string) =>
     expect.objectContaining({
       name: `${operation} blogposts`,
       is_segment: false,
       parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
       attributes: expect.objectContaining({
-        'db.collection.name': { type: 'string', value: 'blogposts' },
-        'db.operation.name': { type: 'string', value: operation },
-        'db.system.name': { type: 'string', value: 'mongodb' },
-        'sentry.op': { type: 'string', value: 'db' },
-        'sentry.origin': { type: 'string', value: origin },
-        'sentry.trace_lifecycle': { type: 'string', value: 'stream' },
+        [DB_COLLECTION_NAME]: { type: 'string', value: 'blogposts' },
+        [DB_OPERATION_NAME]: { type: 'string', value: operation },
+        [DB_SYSTEM_NAME]: { type: 'string', value: 'mongodb' },
+        [SENTRY_OP]: { type: 'string', value: DB },
+        [SENTRY_ORIGIN]: { type: 'string', value: origin },
+        [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
       }),
     });
 
@@ -78,14 +50,9 @@ describe('Mongoose v8 Test', () => {
     'instrument.mjs',
     (createTestRunner, test) => {
       test('auto-instruments `mongoose` v8 document methods.', async () => {
-        await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
-      });
-
-      test('auto-instruments `mongoose` v8 document methods with span streaming enabled.', async () => {
         await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
           .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
+            span: container => {
               expect(container.items.find(item => item.is_segment)?.name).toBe('Test Transaction');
 
               for (const operation of ['save', 'updateOne', 'deleteOne']) {
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose-v9/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/mongoose-v9/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose-v9/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose-v9/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose-v9/test.ts b/dev-packages/node-integration-tests/suites/tracing/mongoose-v9/test.ts
index 55a80b82e9b9..abfba23f1f5c 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose-v9/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose-v9/test.ts
@@ -1,4 +1,12 @@
-import type { SerializedStreamedSpanContainer } from '@sentry/core';
+import {
+  DB_COLLECTION_NAME,
+  DB_OPERATION_NAME,
+  DB_SYSTEM_NAME,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_TRACE_LIFECYCLE,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
@@ -22,44 +30,18 @@ describe('Mongoose v9 Test', () => {
     cleanupChildProcesses();
   });
 
-  const expectedSpan = (operation: string) =>
-    expect.objectContaining({
-      data: expect.objectContaining({
-        'db.collection.name': 'blogposts',
-        'db.operation.name': operation,
-        'db.system.name': 'mongodb',
-      }),
-      description: `mongoose.BlogPost.${operation}`,
-      op: 'db',
-      origin,
-    });
-
-  const EXPECTED_TRANSACTION = {
-    transaction: 'Test Transaction',
-    spans: expect.arrayContaining([
-      expectedSpan('save'),
-      expectedSpan('findOne'),
-      expectedSpan('aggregate'),
-      expectedSpan('insertMany'),
-      expectedSpan('bulkWrite'),
-      // Document instance methods are instrumented via Query.exec on v9 (no doc-method patch).
-      expectedSpan('updateOne'),
-      expectedSpan('deleteOne'),
-    ]),
-  };
-
   const expectedStreamedSpan = (operation: string) =>
     expect.objectContaining({
       name: `${operation} blogposts`,
       is_segment: false,
       parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
       attributes: expect.objectContaining({
-        'db.collection.name': { type: 'string', value: 'blogposts' },
-        'db.operation.name': { type: 'string', value: operation },
-        'db.system.name': { type: 'string', value: 'mongodb' },
-        'sentry.op': { type: 'string', value: 'db' },
-        'sentry.origin': { type: 'string', value: origin },
-        'sentry.trace_lifecycle': { type: 'string', value: 'stream' },
+        [DB_COLLECTION_NAME]: { type: 'string', value: 'blogposts' },
+        [DB_OPERATION_NAME]: { type: 'string', value: operation },
+        [DB_SYSTEM_NAME]: { type: 'string', value: 'mongodb' },
+        [SENTRY_OP]: { type: 'string', value: DB },
+        [SENTRY_ORIGIN]: { type: 'string', value: origin },
+        [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
       }),
     });
 
@@ -71,14 +53,9 @@ describe('Mongoose v9 Test', () => {
     'instrument.mjs',
     (createTestRunner, test) => {
       test('auto-instruments `mongoose` v9.', async () => {
-        await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
-      });
-
-      test('auto-instruments `mongoose` v9 with span streaming enabled.', async () => {
         await createTestRunner()
-          .withEnv({ STREAMED: 'true' })
           .expect({
-            span: (container: SerializedStreamedSpanContainer) => {
+            span: container => {
               expect(container.items.find(item => item.is_segment)?.name).toBe('Test Transaction');
 
               for (const operation of STREAMED_OPERATIONS) {
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose/instrument.mjs b/dev-packages/node-integration-tests/suites/tracing/mongoose/instrument.mjs
index 22bf57f14364..46a27dd03b74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose/instrument.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose/instrument.mjs
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: process.env.STREAMED === 'true' ? 'stream' : 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/tracing/mongoose/test.ts b/dev-packages/node-integration-tests/suites/tracing/mongoose/test.ts
index cb3012ede40a..beeb52aa100d 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mongoose/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mongoose/test.ts
@@ -1,4 +1,13 @@
-import type { SerializedStreamedSpanContainer } from '@sentry/core';
+import {
+  DB_COLLECTION_NAME,
+  DB_NAMESPACE,
+  DB_OPERATION_NAME,
+  DB_SYSTEM_NAME,
+  SENTRY_OP,
+  SENTRY_ORIGIN,
+  SENTRY_TRACE_LIFECYCLE,
+} from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
 import { MongoMemoryServer } from 'mongodb-memory-server-global';
 import { afterAll, beforeAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
@@ -20,90 +29,6 @@ describe('Mongoose experimental Test', () => {
     cleanupChildProcesses();
   });
 
-  const EXPECTED_TRANSACTION = {
-    transaction: 'Test Transaction',
-    spans: expect.arrayContaining([
-      expect.objectContaining({
-        data: expect.objectContaining({
-          'db.collection.name': 'blogposts',
-          'db.namespace': 'test',
-          'db.operation.name': 'save',
-          'db.system.name': 'mongodb',
-        }),
-        description: 'mongoose.BlogPost.save',
-        op: 'db',
-        origin,
-      }),
-      expect.objectContaining({
-        data: expect.objectContaining({
-          'db.collection.name': 'blogposts',
-          'db.namespace': 'test',
-          'db.operation.name': 'findOne',
-          'db.system.name': 'mongodb',
-        }),
-        description: 'mongoose.BlogPost.findOne',
-        op: 'db',
-        origin,
-      }),
-      expect.objectContaining({
-        data: expect.objectContaining({
-          'db.collection.name': 'blogposts',
-          'db.namespace': 'test',
-          'db.operation.name': 'aggregate',
-          'db.system.name': 'mongodb',
-        }),
-        description: 'mongoose.BlogPost.aggregate',
-        op: 'db',
-        origin,
-      }),
-      expect.objectContaining({
-        data: expect.objectContaining({
-          'db.collection.name': 'blogposts',
-          'db.namespace': 'test',
-          'db.operation.name': 'insertMany',
-          'db.system.name': 'mongodb',
-        }),
-        description: 'mongoose.BlogPost.insertMany',
-        op: 'db',
-        origin,
-      }),
-      expect.objectContaining({
-        data: expect.objectContaining({
-          'db.collection.name': 'blogposts',
-          'db.namespace': 'test',
-          'db.operation.name': 'bulkWrite',
-          'db.system.name': 'mongodb',
-        }),
-        description: 'mongoose.BlogPost.bulkWrite',
-        op: 'db',
-        origin,
-      }),
-      // `remove` is patched only on mongoose 5/6.
-      expect.objectContaining({
-        data: expect.objectContaining({
-          'db.collection.name': 'blogposts',
-          'db.namespace': 'test',
-          'db.operation.name': 'remove',
-          'db.system.name': 'mongodb',
-        }),
-        description: 'mongoose.BlogPost.remove',
-        op: 'db',
-        origin,
-      }),
-      // A failing operation still produces a span, marked with an error status.
-      expect.objectContaining({
-        data: expect.objectContaining({
-          'db.operation.name': 'save',
-          'db.system.name': 'mongodb',
-        }),
-        description: 'mongoose.RequiredDoc.save',
-        op: 'db',
-        origin,
-        status: 'internal_error',
-      }),
-    ]),
-  };
-
   const expectedStreamedSpan = (operation: string, collection = 'blogposts', status = 'ok') =>
     expect.objectContaining({
       name: `${operation} ${collection}`,
@@ -111,51 +36,49 @@ describe('Mongoose experimental Test', () => {
       parent_span_id: expect.stringMatching(/^[\da-f]{16}$/),
       status,
       attributes: expect.objectContaining({
-        'db.collection.name': { type: 'string', value: collection },
-        'db.namespace': { type: 'string', value: 'test' },
-        'db.operation.name': { type: 'string', value: operation },
-        'db.system.name': { type: 'string', value: 'mongodb' },
-        'sentry.op': { type: 'string', value: 'db' },
-        'sentry.origin': { type: 'string', value: origin },
-        'sentry.trace_lifecycle': { type: 'string', value: 'stream' },
+        [DB_COLLECTION_NAME]: { type: 'string', value: collection },
+        [DB_NAMESPACE]: { type: 'string', value: 'test' },
+        [DB_OPERATION_NAME]: { type: 'string', value: operation },
+        [DB_SYSTEM_NAME]: { type: 'string', value: 'mongodb' },
+        [SENTRY_OP]: { type: 'string', value: DB },
+        [SENTRY_ORIGIN]: { type: 'string', value: origin },
+        [SENTRY_TRACE_LIFECYCLE]: { type: 'string', value: 'stream' },
       }),
     });
 
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createTestRunner, test) => {
     test('should auto-instrument `mongoose` package.', async () => {
-      await createTestRunner().expect({ transaction: EXPECTED_TRANSACTION }).start().completed();
-    });
-
-    test('nests the mongodb driver span under the mongoose span', async () => {
       await createTestRunner()
         .expect({
-          transaction: event => {
-            const spans = event.spans || [];
-            const mongooseSave = spans.find(span => span.description === 'mongoose.BlogPost.save');
-            expect(mongooseSave).toBeDefined();
-            // the underlying mongodb driver span must be parented to the mongoose span
-            const driverChild = spans.find(
-              span => span.parent_span_id === mongooseSave?.span_id && span.origin === driverOrigin,
-            );
-            expect(driverChild).toBeDefined();
+          span: container => {
+            expect(container.items.find(item => item.is_segment)?.name).toBe('Test Transaction');
+
+            for (const operation of ['save', 'findOne', 'aggregate', 'insertMany', 'bulkWrite', 'remove']) {
+              expect(container.items).toContainEqual(expectedStreamedSpan(operation));
+            }
+
+            expect(container.items).toContainEqual(expectedStreamedSpan('save', 'requireddocs', 'error'));
           },
         })
         .start()
         .completed();
     });
 
-    test('should auto-instrument `mongoose` package with span streaming enabled.', async () => {
+    test('nests the mongodb driver span under the mongoose span', async () => {
       await createTestRunner()
-        .withEnv({ STREAMED: 'true' })
         .expect({
-          span: (container: SerializedStreamedSpanContainer) => {
-            expect(container.items.find(item => item.is_segment)?.name).toBe('Test Transaction');
-
-            for (const operation of ['save', 'findOne', 'aggregate', 'insertMany', 'bulkWrite', 'remove']) {
-              expect(container.items).toContainEqual(expectedStreamedSpan(operation));
-            }
-
-            expect(container.items).toContainEqual(expectedStreamedSpan('save', 'requireddocs', 'error'));
+          span: container => {
+            const spans = container.items;
+            const mongooseSave = spans.find(
+              span => span.name === 'save blogposts' && span.attributes[SENTRY_ORIGIN]?.value === origin,
+            );
+            expect(mongooseSave).toBeDefined();
+            // the underlying mongodb driver span must be parented to the mongoose span
+            const driverChild = spans.find(
+              span =>
+                span.parent_span_id === mongooseSave?.span_id && span.attributes[SENTRY_ORIGIN]?.value === driverOrigin,
+            );
+            expect(driverChild).toBeDefined();
           },
         })
         .start()
@@ -165,14 +88,17 @@ describe('Mongoose experimental Test', () => {
     test('parents a query to the span it was built in, not where it executes', async () => {
       await createTestRunner()
         .expect({
-          transaction: event => {
-            const spans = event.spans || [];
-            const builder = spans.find(span => span.description === 'query-builder');
+          span: container => {
+            const spans = container.items;
+            const builder = spans.find(span => span.name === 'query-builder');
             expect(builder).toBeDefined();
             // the query was built inside `query-builder` but awaited after it ended, so its exec
             // span must parent to `query-builder` rather than the active span at exec time
             const findExec = spans.find(
-              span => span.description === 'mongoose.BlogPost.findOne' && span.parent_span_id === builder?.span_id,
+              span =>
+                span.name === 'findOne blogposts' &&
+                span.attributes[SENTRY_ORIGIN]?.value === origin &&
+                span.parent_span_id === builder?.span_id,
             );
             expect(findExec).toBeDefined();
           },

From ccd77cb80a35aac28e6a11402a55b2adbab20254 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 9 Oct 2026 21:06:14 +0200
Subject: [PATCH 50/84] feat(deps): Bump reflect-metadata from 0.2.1 to 0.2.2
 (#25239)

Bumps [reflect-metadata](https://github.com/rbuckton/reflect-metadata)
from 0.2.1 to 0.2.2.
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a
href="https://github.com/rbuckton/reflect-metadata/commits">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=reflect-metadata&package-manager=npm_and_yarn&previous-version=0.2.1&new-version=0.2.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 dev-packages/node-integration-tests/package.json |  2 +-
 yarn.lock                                        | 13 ++++---------
 2 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/dev-packages/node-integration-tests/package.json b/dev-packages/node-integration-tests/package.json
index 2495dcc2c794..bceba2da19d0 100644
--- a/dev-packages/node-integration-tests/package.json
+++ b/dev-packages/node-integration-tests/package.json
@@ -99,7 +99,7 @@
     "redis-4": "npm:redis@^4.6.14",
     "redis-5": "npm:redis@~5.11.0",
     "redis-5-tracing": "npm:redis@^5.12.0",
-    "reflect-metadata": "0.2.1",
+    "reflect-metadata": "0.2.2",
     "together-ai": "0.54.0",
     "rxjs": "^7.8.2",
     "tedious": "^19.2.1",
diff --git a/yarn.lock b/yarn.lock
index 1b17dca8b628..27703748ebd4 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -23833,21 +23833,16 @@ refa@^0.12.0, refa@^0.12.1:
   dependencies:
     "@eslint-community/regexpp" "^4.8.0"
 
-reflect-metadata@0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/reflect-metadata/-/reflect-metadata-0.2.1.tgz#8d5513c0f5ef2b4b9c3865287f3c0940c1f67f74"
-  integrity sha512-i5lLI6iw9AU3Uu4szRNPPEkomnkjRTaVt9hy/bn5g/oSzekBSMeLZblcjP74AW0vBabqERLLIrz+gR8QYR54Tw==
+reflect-metadata@0.2.2, reflect-metadata@^0.2.2:
+  version "0.2.2"
+  resolved "https://registry.yarnpkg.com/reflect-metadata/-/reflect-metadata-0.2.2.tgz#400c845b6cba87a21f2c65c4aeb158f4fa4d9c5b"
+  integrity sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==
 
 reflect-metadata@^0.1.2:
   version "0.1.13"
   resolved "https://registry.yarnpkg.com/reflect-metadata/-/reflect-metadata-0.1.13.tgz#67ae3ca57c972a2aa1642b10fe363fe32d49dc08"
   integrity sha512-Ts1Y/anZELhSsjMcU605fU9RE4Oi3p5ORujwbIKXfWa+0Zxs510Qrmrce5/Jowq3cHSZSJqBjypxmHarc+vEWg==
 
-reflect-metadata@^0.2.2:
-  version "0.2.2"
-  resolved "https://registry.yarnpkg.com/reflect-metadata/-/reflect-metadata-0.2.2.tgz#400c845b6cba87a21f2c65c4aeb158f4fa4d9c5b"
-  integrity sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==
-
 reflect.getprototypeof@^1.0.6, reflect.getprototypeof@^1.0.9:
   version "1.0.10"
   resolved "https://registry.yarnpkg.com/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz#c629219e78a3316d8b604c765ef68996964e7bf9"

From a86403ae656e7436bbb8ffb4a2cd6e5686337973 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 9 Oct 2026 21:07:13 +0200
Subject: [PATCH 51/84] chore(deps-dev): Bump oxlint-tsgolint from 7.0.2001 to
 7.0.2003 (#25237)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [oxlint-tsgolint](https://github.com/oxc-project/tsgolint) from
7.0.2001 to 7.0.2003.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a
href="https://github.com/oxc-project/tsgolint/releases">oxlint-tsgolint's
releases</a>.</em></p>
<blockquote>
<h2>v7.0.2003</h2>
<h2>What's Changed</h2>
<ul>
<li>docs: update agent development instructions by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1210">oxc-project/tsgolint#1210</a></li>
<li>docs: refresh README benchmarks and wording by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1208">oxc-project/tsgolint#1208</a></li>
<li>chore(deps): update crate-ci/typos action to v1.50.2 by <a
href="https://github.com/renovate"><code>@​renovate</code></a>[bot] in
<a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1213">oxc-project/tsgolint#1213</a></li>
<li>chore(deps): update taiki-e/install-action action to v2.87.14 by <a
href="https://github.com/renovate"><code>@​renovate</code></a>[bot] in
<a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1216">oxc-project/tsgolint#1216</a></li>
<li>chore(deps): update dependency dprint-json to v0.24.0 by <a
href="https://github.com/renovate"><code>@​renovate</code></a>[bot] in
<a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1217">oxc-project/tsgolint#1217</a></li>
<li>feat(no-unnecessary-condition): implement suggestion by <a
href="https://github.com/baevm"><code>@​baevm</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1218">oxc-project/tsgolint#1218</a></li>
<li>fix(require-array-sort-compare): resolve string element constraints
by <a href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1219">oxc-project/tsgolint#1219</a></li>
<li>fix(no-duplicate-type-constituents): allow undefined on optional
parameter properties by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1222">oxc-project/tsgolint#1222</a></li>
<li>test(no-unnecessary-type-assertion): cover Record alias assertions
by <a href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1226">oxc-project/tsgolint#1226</a></li>
<li>fix(no-misused-spread): omit invalid WeakMap suggestions by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1227">oxc-project/tsgolint#1227</a></li>
<li>fix(no-meaningless-void-operator): allow void on assignments by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1228">oxc-project/tsgolint#1228</a></li>
<li>feat: add no-generated-empty-object-type rule by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1229">oxc-project/tsgolint#1229</a></li>
<li>fix(no-useless-default-assignment): use suggestions for undefined
defaults by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1231">oxc-project/tsgolint#1231</a></li>
<li>fix(unbound-method): treat Intl.Collator compare as bound by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1224">oxc-project/tsgolint#1224</a></li>
<li>fix(no-unnecessary-type-parameters): preserve suggestion type
precedence by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1232">oxc-project/tsgolint#1232</a></li>
<li>fix(no-unnecessary-condition): handle union keys in nullish
assignment by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1230">oxc-project/tsgolint#1230</a></li>
<li>fix: preserve expression syntax when removing await by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1233">oxc-project/tsgolint#1233</a></li>
<li>fix: match package specifiers on whole path components by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1225">oxc-project/tsgolint#1225</a></li>
<li>fix(no-useless-default-assignment): handle tuples with rest elements
by <a href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1223">oxc-project/tsgolint#1223</a></li>
<li>fix(no-deprecated): detect deprecated aliases in object shorthand by
<a href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1235">oxc-project/tsgolint#1235</a></li>
<li>fix(no-unnecessary-condition): check nested logical expressions in
truthiness contexts by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1236">oxc-project/tsgolint#1236</a></li>
<li>perf: avoid singleton union type allocations in hot rules by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1237">oxc-project/tsgolint#1237</a></li>
<li>perf: speed up headless file-to-program assignment by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1239">oxc-project/tsgolint#1239</a></li>
<li>perf(no-unnecessary-type-assertion): reject incompatible types first
by <a href="https://github.com/tony-scio"><code>@​tony-scio</code></a>
in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1181">oxc-project/tsgolint#1181</a></li>
<li>refactor: extract checker workload scheduling by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1241">oxc-project/tsgolint#1241</a></li>
<li>perf: add experimental checker scheduling modes by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1240">oxc-project/tsgolint#1240</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/baevm"><code>@​baevm</code></a> made
their first contribution in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1218">oxc-project/tsgolint#1218</a></li>
<li><a href="https://github.com/tony-scio"><code>@​tony-scio</code></a>
made their first contribution in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1181">oxc-project/tsgolint#1181</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a
href="https://github.com/oxc-project/tsgolint/compare/v7.0.2002...v7.0.2003">https://github.com/oxc-project/tsgolint/compare/v7.0.2002...v7.0.2003</a></p>
<h2>v7.0.2002</h2>
<h2>What's Changed</h2>
<ul>
<li>feat(no-misused-promises): improve diagnostics by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1101">oxc-project/tsgolint#1101</a></li>
<li>docs: update benchmarks by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1102">oxc-project/tsgolint#1102</a></li>
<li>docs: declare tsgolint stable by <a
href="https://github.com/Boshen"><code>@​Boshen</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1106">oxc-project/tsgolint#1106</a></li>
<li>ci(semgrep): add scan workflow by <a
href="https://github.com/Boshen"><code>@​Boshen</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1107">oxc-project/tsgolint#1107</a></li>
<li>fix(no-unnecessary-template-expression): preserve expression
precedence by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1108">oxc-project/tsgolint#1108</a></li>
<li>feat(no-unsafe-assignment): improve diagnostics by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1105">oxc-project/tsgolint#1105</a></li>
<li>feat(no-unsafe-return): improve diagnostics by <a
href="https://github.com/camc314"><code>@​camc314</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1110">oxc-project/tsgolint#1110</a></li>
<li>chore: disable typescript-go renovate updates by <a
href="https://github.com/Boshen"><code>@​Boshen</code></a> in <a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1116">oxc-project/tsgolint#1116</a></li>
<li>chore(deps): update github actions by <a
href="https://github.com/renovate"><code>@​renovate</code></a>[bot] in
<a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1117">oxc-project/tsgolint#1117</a></li>
<li>chore(deps): update actions/setup-go action to v7 by <a
href="https://github.com/renovate"><code>@​renovate</code></a>[bot] in
<a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1118">oxc-project/tsgolint#1118</a></li>
<li>chore(deps): update dependency typescript to v7 by <a
href="https://github.com/renovate"><code>@​renovate</code></a>[bot] in
<a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1119">oxc-project/tsgolint#1119</a></li>
<li>chore(deps): update pnpm to v11.17.0 by <a
href="https://github.com/renovate"><code>@​renovate</code></a>[bot] in
<a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1123">oxc-project/tsgolint#1123</a></li>
<li>chore(deps): update github actions by <a
href="https://github.com/renovate"><code>@​renovate</code></a>[bot] in
<a
href="https://redirect.github.com/oxc-project/tsgolint/pull/1124">oxc-project/tsgolint#1124</a></li>
</ul>
<!-- raw HTML omitted -->
</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/oxc-project/tsgolint/commit/eb9339115edde6811ca94c3433adf69ea9852880"><code>eb93391</code></a>
perf: add experimental checker scheduling modes (<a
href="https://redirect.github.com/oxc-project/tsgolint/issues/1240">#1240</a>)</li>
<li><a
href="https://github.com/oxc-project/tsgolint/commit/e3a79a5e04df2400066bbf3abcb707443652e5b1"><code>e3a79a5</code></a>
refactor: extract checker workload scheduling (<a
href="https://redirect.github.com/oxc-project/tsgolint/issues/1241">#1241</a>)</li>
<li><a
href="https://github.com/oxc-project/tsgolint/commit/1fdaa0db360f7e29209805389cd81fd11e56d74f"><code>1fdaa0d</code></a>
perf(no-unnecessary-type-assertion): reject incompatible types first (<a
href="https://redirect.github.com/oxc-project/tsgolint/issues/1181">#1181</a>)</li>
<li><a
href="https://github.com/oxc-project/tsgolint/commit/364b23979e1189a760799738dadc59212e35e899"><code>364b239</code></a>
perf: speed up headless file-to-program assignment (<a
href="https://redirect.github.com/oxc-project/tsgolint/issues/1239">#1239</a>)</li>
<li><a
href="https://github.com/oxc-project/tsgolint/commit/52500be212366860eb56155f6c3b7448feb4c140"><code>52500be</code></a>
perf: avoid singleton union type allocations in hot rules (<a
href="https://redirect.github.com/oxc-project/tsgolint/issues/1237">#1237</a>)</li>
<li><a
href="https://github.com/oxc-project/tsgolint/commit/22b148ad8f78fa2e444bdd6553ae251c6b7d2f6b"><code>22b148a</code></a>
fix(no-unnecessary-condition): check nested logical expressions in
truthiness...</li>
<li><a
href="https://github.com/oxc-project/tsgolint/commit/356609fdb6c2f118b6e4be22728505631deee5e2"><code>356609f</code></a>
fix(no-deprecated): detect deprecated aliases in object shorthand (<a
href="https://redirect.github.com/oxc-project/tsgolint/issues/1235">#1235</a>)</li>
<li><a
href="https://github.com/oxc-project/tsgolint/commit/cbf39090fe63bed4a7283989995ea4fbf478ee46"><code>cbf3909</code></a>
fix(no-useless-default-assignment): handle tuples with rest elements (<a
href="https://redirect.github.com/oxc-project/tsgolint/issues/1223">#1223</a>)</li>
<li><a
href="https://github.com/oxc-project/tsgolint/commit/7bd5c1180dd1d0ab13b7ed8a5dc5064bba204724"><code>7bd5c11</code></a>
fix: match package specifiers on whole path components (<a
href="https://redirect.github.com/oxc-project/tsgolint/issues/1225">#1225</a>)</li>
<li><a
href="https://github.com/oxc-project/tsgolint/commit/6f2588382b3f039a6a020020c282117260938e44"><code>6f25883</code></a>
fix: preserve expression syntax when removing await (<a
href="https://redirect.github.com/oxc-project/tsgolint/issues/1233">#1233</a>)</li>
<li>Additional commits viewable in <a
href="https://github.com/oxc-project/tsgolint/compare/v7.0.2001...v7.0.2003">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=oxlint-tsgolint&package-manager=npm_and_yarn&previous-version=7.0.2001&new-version=7.0.2003)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 yarn.lock | 76 +++++++++++++++++++++++++++----------------------------
 1 file changed, 38 insertions(+), 38 deletions(-)

diff --git a/yarn.lock b/yarn.lock
index 27703748ebd4..e3968f4c67fe 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -6958,35 +6958,35 @@
   resolved "https://registry.yarnpkg.com/@oxfmt/binding-win32-x64-msvc/-/binding-win32-x64-msvc-0.70.0.tgz#6d8d33d38063498ad9ead3b3f9f1dd2aa6ce03be"
   integrity sha512-HlIZEn+WzLQL0DszNzldiRl/DPRCX5R0Vkt6qeUPR1YHwy52hZZo4x6HoTOVmKRP2wUiwPGtKsihNY/f8KRaBg==
 
-"@oxlint-tsgolint/darwin-arm64@7.0.2001":
-  version "7.0.2001"
-  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/darwin-arm64/-/darwin-arm64-7.0.2001.tgz#a270683cda2f012d0d5011370bd06384c6bee900"
-  integrity sha512-CUJEdbSZ54+Xy9OXqOhWLTKZKV0BBiV7C2i/ygyVmXtkUNXx5YCzN8DpSSshTAKktoL7S+tnQ/ftFG/i7X896w==
-
-"@oxlint-tsgolint/darwin-x64@7.0.2001":
-  version "7.0.2001"
-  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/darwin-x64/-/darwin-x64-7.0.2001.tgz#3e93bdf6c8b6668d45c098983f71e269f171cd75"
-  integrity sha512-pXfBb5BqONCcgrXQNUZWXgiYmRSWJzd97S8i41VVOh6ut0tyo+cJ5FKFpczDHxiVNfj/3e7c9B4MtztNdpIVCw==
-
-"@oxlint-tsgolint/linux-arm64@7.0.2001":
-  version "7.0.2001"
-  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/linux-arm64/-/linux-arm64-7.0.2001.tgz#7f335b178f011ba30da27f44e743613d5fd6cc20"
-  integrity sha512-roP7zujb/QDPzDwEKsFFpzNHHy91/Y7oX9vQXk78ekyZtcQj1QXDIMH33gjDdHBfRl4K9pZ36xhRgrP4Zr+R8A==
-
-"@oxlint-tsgolint/linux-x64@7.0.2001":
-  version "7.0.2001"
-  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/linux-x64/-/linux-x64-7.0.2001.tgz#2805be8c183283994436a156c7961c4f5d490990"
-  integrity sha512-UDezNqdECVmngu2TPnjaS1YoAmcTaBoI5lV9vk3VahBxoi+I5r9k3iJTT7qZoYWOXTD/7T7bNcwRgrocR6BscQ==
-
-"@oxlint-tsgolint/win32-arm64@7.0.2001":
-  version "7.0.2001"
-  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/win32-arm64/-/win32-arm64-7.0.2001.tgz#226c7779b0e1bfe970746e8d479a18fabc2f915e"
-  integrity sha512-uJZhqB6pdXLuN+AD1F5082byyQti/NPmJA77GtcFlmT2HzRelqbNls3SaIqxpjdFgvSBF9g0yOKGBkGFg7kX8Q==
-
-"@oxlint-tsgolint/win32-x64@7.0.2001":
-  version "7.0.2001"
-  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/win32-x64/-/win32-x64-7.0.2001.tgz#814bcdd2707fa8ab1ae0f0b51a7243b034d2833a"
-  integrity sha512-FkDRm8hx9OwzGQqyWG1tO5QrTLRApff9DzSgpz9QZau37BR8d1VYKOxMLGf6shPZntJFoTwIIJYT68VndYDCog==
+"@oxlint-tsgolint/darwin-arm64@7.0.2003":
+  version "7.0.2003"
+  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/darwin-arm64/-/darwin-arm64-7.0.2003.tgz#a9048bb88e36fb7d3523d4c444509d96e06d5d46"
+  integrity sha512-TgV33rXr6ueXBwvc+0nssUkTBSXHJxv77I8p4RCjDjCnvexHtmoPiudVRDfj3S3puMDdeQdHW6jdUgUPy3nr/w==
+
+"@oxlint-tsgolint/darwin-x64@7.0.2003":
+  version "7.0.2003"
+  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/darwin-x64/-/darwin-x64-7.0.2003.tgz#34933fbc2f36c418591808a75a4a164eb83afdf0"
+  integrity sha512-hY3FMAjIaPDdK3FNxyRXRfHPOFeoBn6dmnLyKZgQ2IbTTD1adXhl6PfCIqHhCPvurigv7nf7mYuWZZ19MmJzmg==
+
+"@oxlint-tsgolint/linux-arm64@7.0.2003":
+  version "7.0.2003"
+  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/linux-arm64/-/linux-arm64-7.0.2003.tgz#b222cb1f8366ea7de441551268301efa82efc379"
+  integrity sha512-eAET4JpyfBbg8SO0K74o4R55tEjVC292pIyxGOw2XGf8x/HrPNyxwQ478jMYOM54FIVOHc8sJ6VRHxluy6lucw==
+
+"@oxlint-tsgolint/linux-x64@7.0.2003":
+  version "7.0.2003"
+  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/linux-x64/-/linux-x64-7.0.2003.tgz#1e1339078dd464757f543eca9a60dc9d86ad6e75"
+  integrity sha512-GXdyO/XyqDJ3s/llR/oOktLsYNjZtWSQBy0JMc+/0gsNPvTcseKPhn9c6KcFyWmnr6H4vljYALbujonqSzzEGw==
+
+"@oxlint-tsgolint/win32-arm64@7.0.2003":
+  version "7.0.2003"
+  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/win32-arm64/-/win32-arm64-7.0.2003.tgz#b4d0e6c6e7c0212be92c447e64b49f0d8d8173db"
+  integrity sha512-TWauXnPfet0VgpmrstoAK58eJ4gbuwPUuUTQmYQAzE/RG1CpnxXtrKUJULf6lyerPE4KN3gM+DflIA1hOH+38Q==
+
+"@oxlint-tsgolint/win32-x64@7.0.2003":
+  version "7.0.2003"
+  resolved "https://registry.yarnpkg.com/@oxlint-tsgolint/win32-x64/-/win32-x64-7.0.2003.tgz#08d5ae59e655e32d332ec1a74190b8009754d176"
+  integrity sha512-DoRmfe7j8VqNlukp8liRVW45GQDhzRccNenjD/pdzelgtffW47pCMd1xbJLkPaPbKnTwID3onn3VZlL7JbebEA==
 
 "@oxlint/binding-android-arm-eabi@1.75.0":
   version "1.75.0"
@@ -21727,16 +21727,16 @@ oxfmt@^0.70.0:
     "@oxfmt/binding-win32-x64-msvc" "0.70.0"
 
 oxlint-tsgolint@7:
-  version "7.0.2001"
-  resolved "https://registry.yarnpkg.com/oxlint-tsgolint/-/oxlint-tsgolint-7.0.2001.tgz#19e17beda6c9d25d5ac6a1681bfece0502039311"
-  integrity sha512-KjK/XLcXr1DSyonKhsuFqJRiuKqcyG9j3LJ8nkOsrLzGvodBPqzHOKauy10asLMDI0sUpvb+1sxlzff3udZvfg==
+  version "7.0.2003"
+  resolved "https://registry.yarnpkg.com/oxlint-tsgolint/-/oxlint-tsgolint-7.0.2003.tgz#ad35592d0fde9ffd279c9befe3275a81a787573f"
+  integrity sha512-VnK4zlqgmgq/7ZcjzCk/WpN8kKFsYGcB85Io9qT3wL4K8Un3RKmJkp793crNETieMusPMKOA4a+Mw2wbteI6TQ==
   optionalDependencies:
-    "@oxlint-tsgolint/darwin-arm64" "7.0.2001"
-    "@oxlint-tsgolint/darwin-x64" "7.0.2001"
-    "@oxlint-tsgolint/linux-arm64" "7.0.2001"
-    "@oxlint-tsgolint/linux-x64" "7.0.2001"
-    "@oxlint-tsgolint/win32-arm64" "7.0.2001"
-    "@oxlint-tsgolint/win32-x64" "7.0.2001"
+    "@oxlint-tsgolint/darwin-arm64" "7.0.2003"
+    "@oxlint-tsgolint/darwin-x64" "7.0.2003"
+    "@oxlint-tsgolint/linux-arm64" "7.0.2003"
+    "@oxlint-tsgolint/linux-x64" "7.0.2003"
+    "@oxlint-tsgolint/win32-arm64" "7.0.2003"
+    "@oxlint-tsgolint/win32-x64" "7.0.2003"
 
 oxlint@^1.75.0:
   version "1.75.0"

From b4bbe14db49060a9ab6824eaa3d1758ee36cf796 Mon Sep 17 00:00:00 2001
From: Charly Gomez <charly.gomez1310@gmail.com>
Date: Mon, 12 Oct 2026 10:19:28 +0200
Subject: [PATCH 52/84] fix(server-utils): End Express layer spans when the
 client aborts (#25209)

Express layer spans only ended on the response's `finish` event. When
the client aborts, `finish` never fires, so the request handler span
never ended. Static transactions were sent without it and everything
under it, and with span streaming its children were orphaned.

Layer spans now also end on `close`, which is when the `http.server`
span ends, and are marked as `cancelled`. Work that is still running
when the client aborts ends after the transaction has been sent, so it
is not part of the static transaction.

Fixes #25183

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../express/client-abort/instrument.mjs       |  9 +++++
 .../suites/express/client-abort/scenario.mjs  | 12 +++++++
 .../suites/express/client-abort/test.ts       | 36 +++++++++++++++++++
 .../utils/runner/createRunner.ts              | 16 +++++++--
 .../integrations/express/instrumentation.ts   | 19 ++++++++--
 .../src/integrations/express/types.ts         |  2 +-
 6 files changed, 88 insertions(+), 6 deletions(-)
 create mode 100644 dev-packages/node-integration-tests/suites/express/client-abort/instrument.mjs
 create mode 100644 dev-packages/node-integration-tests/suites/express/client-abort/scenario.mjs
 create mode 100644 dev-packages/node-integration-tests/suites/express/client-abort/test.ts

diff --git a/dev-packages/node-integration-tests/suites/express/client-abort/instrument.mjs b/dev-packages/node-integration-tests/suites/express/client-abort/instrument.mjs
new file mode 100644
index 000000000000..46a27dd03b74
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/client-abort/instrument.mjs
@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
diff --git a/dev-packages/node-integration-tests/suites/express/client-abort/scenario.mjs b/dev-packages/node-integration-tests/suites/express/client-abort/scenario.mjs
new file mode 100644
index 000000000000..8461cf662cb5
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/client-abort/scenario.mjs
@@ -0,0 +1,12 @@
+import * as Sentry from '@sentry/node';
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import express from 'express';
+
+const app = express();
+
+app.get('/test/slow', async (_req, res) => {
+  await Sentry.startSpan({ name: 'slow-work', op: 'function' }, () => new Promise(resolve => setTimeout(resolve, 500)));
+  res.send('ok');
+});
+
+startExpressServerAndSendPortToRunner(app);
diff --git a/dev-packages/node-integration-tests/suites/express/client-abort/test.ts b/dev-packages/node-integration-tests/suites/express/client-abort/test.ts
new file mode 100644
index 000000000000..b9cac9af42d8
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/express/client-abort/test.ts
@@ -0,0 +1,36 @@
+import { afterAll, describe, expect } from 'vitest';
+import { RUNTIME } from '../../../utils';
+import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
+
+describe('express client abort', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
+    // Bun 1.3.14 emits no `close` on the response when the client aborts, so the `http.server`
+    // span never ends either. Bun 1.4.0 emits it.
+    test.skipIf(RUNTIME === 'bun')('ends the request handler span when the client aborts', async () => {
+      const runner = createRunner()
+        .unordered()
+        .expect({
+          span: container => {
+            const segmentSpan = container.items.find(item => item.is_segment);
+            const handlerSpan = container.items.find(
+              item => item.attributes['express.type']?.value === 'request_handler',
+            );
+
+            expect(segmentSpan?.name).toBe('GET /test/slow');
+            expect(handlerSpan).toBeDefined();
+            expect(handlerSpan!.parent_span_id).toBe(segmentSpan!.span_id);
+            // Ends when the client aborts, not when the handler's 500ms of work finishes.
+            expect(handlerSpan!.end_timestamp - handlerSpan!.start_timestamp).toBeLessThan(0.4);
+          },
+        })
+        .start();
+
+      await runner.makeRequest('get', '/test/slow', { timeout: 100, expectError: true });
+      await runner.completed();
+    });
+  });
+});
diff --git a/dev-packages/node-integration-tests/utils/runner/createRunner.ts b/dev-packages/node-integration-tests/utils/runner/createRunner.ts
index de845c3063ac..9a1dcf8ba4a0 100644
--- a/dev-packages/node-integration-tests/utils/runner/createRunner.ts
+++ b/dev-packages/node-integration-tests/utils/runner/createRunner.ts
@@ -105,7 +105,7 @@ type StartResult = {
   makeRequest<T>(
     method: 'get' | 'post' | 'put' | 'delete' | 'patch',
     path: string,
-    options?: { headers?: Record<string, string>; data?: BodyInit; expectError?: boolean },
+    options?: { headers?: Record<string, string>; data?: BodyInit; expectError?: boolean; timeout?: number },
   ): Promise<T | undefined>;
 };
 
@@ -774,7 +774,12 @@ export function createRunner(...paths: string[]) {
         makeRequest: async function <T>(
           method: 'get' | 'post' | 'put' | 'delete' | 'patch',
           path: string,
-          options: { headers?: Record<string, string>; data?: BodyInit; expectError?: boolean } = {},
+          options: {
+            headers?: Record<string, string>;
+            data?: BodyInit;
+            expectError?: boolean;
+            timeout?: number;
+          } = {},
         ): Promise<T | undefined> {
           try {
             await waitForEvent(portReady.promise, PORT_TIMEOUT, 'Timed out waiting for server port');
@@ -791,7 +796,12 @@ export function createRunner(...paths: string[]) {
           if (process.env.DEBUG) log('making request', method, url, headers, body);
 
           try {
-            const res = await fetch(url, { headers, method: method.toUpperCase(), body });
+            const res = await fetch(url, {
+              headers,
+              method: method.toUpperCase(),
+              body,
+              signal: options.timeout !== undefined ? AbortSignal.timeout(options.timeout) : undefined,
+            });
 
             if (!res.ok) {
               if (!expectError) {
diff --git a/packages/server-utils/src/integrations/express/instrumentation.ts b/packages/server-utils/src/integrations/express/instrumentation.ts
index 753ebbc90660..a3d079c6bd2b 100644
--- a/packages/server-utils/src/integrations/express/instrumentation.ts
+++ b/packages/server-utils/src/integrations/express/instrumentation.ts
@@ -12,6 +12,7 @@ import {
   hasSpanStreamingEnabled,
   REQUEST_HANDLER_SPAN_NAME_FALLBACK,
   ROUTER_SPAN_NAME_FALLBACK,
+  SPAN_STATUS_ERROR,
   startInactiveSpan,
   stringMatchesSomePattern,
   withActiveSpan,
@@ -350,13 +351,27 @@ function getSpanForLayer(data: HandleChannelContext, options: ExpressIntegration
   // A layer that sends the response (route handlers, typically) never calls
   // `next`, so the channel's `asyncStart` never fires. End on the response's
   // `finish` in that case. When `next` *is* called, `endLayerSpanOnNext` ends
-  // the span and removes this now-redundant listener.
+  // the span and removes these now-redundant listeners.
+  // `finish` never fires when the client aborts, so also end on `close`, which
+  // is when the `http.server` span ends. Otherwise the span and its subtree
+  // would be dropped from the transaction.
   if (res && typeof res.once === 'function') {
+    const cleanup = (): void => {
+      res.removeListener('finish', onFinish);
+      res.removeListener('close', onClose);
+    };
     const onFinish = (): void => {
+      cleanup();
+      span.end();
+    };
+    const onClose = (): void => {
+      cleanup();
+      span.setStatus({ code: SPAN_STATUS_ERROR, message: 'cancelled' });
       span.end();
     };
     res.once('finish', onFinish);
-    data._sentryCleanup = () => res.removeListener('finish', onFinish);
+    res.once('close', onClose);
+    data._sentryCleanup = cleanup;
   }
 
   return span;
diff --git a/packages/server-utils/src/integrations/express/types.ts b/packages/server-utils/src/integrations/express/types.ts
index ea1d979a18af..acffe0c9900c 100644
--- a/packages/server-utils/src/integrations/express/types.ts
+++ b/packages/server-utils/src/integrations/express/types.ts
@@ -34,7 +34,7 @@ export interface ExpressResponse {
  * object for `Layer.prototype.handle_request`/`handleRequest`: `self` is the
  * Layer the method was invoked on and `arguments` are `[req, res, next]`.
  *
- * `_sentryCleanup` is ours: a teardown for the `res.on('finish')` listener we
+ * `_sentryCleanup` is ours: a teardown for the `res` `finish`/`close` listeners we
  * register, invoked from `beforeSpanEnd` when the span ends via `next()`.
  * `_sentryStoredLayer` marks that this invocation pushed a layer path (so the
  * matching pop on `asyncStart` stays symmetric). `_sentrySpan` is the span bound

From 153f4f8799c5888608a0fe11aa38224bd08006d1 Mon Sep 17 00:00:00 2001
From: Martin Sonnberger <martin.sonnberger@sentry.io>
Date: Mon, 12 Oct 2026 10:50:47 +0200
Subject: [PATCH 53/84] fix(server-utils): avoid quadratic SQL summary regex
 backtracking (#25255)

The SQL summary SELECT regex could backtrack quadratically on long
whitespace prefixes before non-SELECT statements. Grouping the optional
opening parenthesis with its following whitespace removes the
overlapping matches while preserving accepted queries. Regression
coverage reproduces the slowdown and checks parenthesized SELECTs.

Fixes [code-scanning alert
#524](https://github.com/getsentry/sentry-javascript/security/code-scanning/524).

Co-authored-by: GPT-6 <codex@openai.com>
---
 packages/server-utils/src/utils/sql.ts       |  2 +-
 packages/server-utils/test/utils/sql.test.ts | 13 +++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/packages/server-utils/src/utils/sql.ts b/packages/server-utils/src/utils/sql.ts
index 25caaa4df01f..f8ecdb4a9078 100644
--- a/packages/server-utils/src/utils/sql.ts
+++ b/packages/server-utils/src/utils/sql.ts
@@ -28,7 +28,7 @@ const UPDATE_RE = new RegExp(
 );
 const DELETE_RE = new RegExp(`^\\s*(?<operation>DELETE)\\s+FROM\\s+(?<table>${TABLE_NAME})`, 'i');
 
-const SELECT_RE = /^\s*\(?\s*(?<operation>SELECT)\b/i;
+const SELECT_RE = /^\s*(?:\(\s*)?(?<operation>SELECT)\b/i;
 
 const PRAGMA_RE = /^\s*(?<operation>PRAGMA)\s+(?<command>\S+)/i;
 
diff --git a/packages/server-utils/test/utils/sql.test.ts b/packages/server-utils/test/utils/sql.test.ts
index 500644753568..50ed62d4a50e 100644
--- a/packages/server-utils/test/utils/sql.test.ts
+++ b/packages/server-utils/test/utils/sql.test.ts
@@ -12,6 +12,8 @@ describe('getSqlQuerySummary', () => {
       ['select count(*) from orders', 'select orders'],
       ['SELECT DISTINCT email FROM subscribers WHERE active = ?', 'SELECT subscribers'],
       ['  SELECT * FROM users', 'SELECT users'],
+      ['(SELECT * FROM users)', 'SELECT users'],
+      [' \t( \nselect * from users)', 'select users'],
     ])('%j => %j', (input, expected) => {
       expect(getSqlQuerySummary(input)).toBe(expected);
     });
@@ -165,6 +167,17 @@ describe('getSqlQuerySummary', () => {
     it('handles leading whitespace in fallback', () => {
       expect(getSqlQuerySummary('  VACUUM')).toBe('VACUUM');
     });
+
+    it('handles long leading whitespace without excessive backtracking', () => {
+      const query = `${' '.repeat(100_000)}VACUUM`;
+      const start = performance.now();
+
+      const summary = getSqlQuerySummary(query);
+      const duration = performance.now() - start;
+
+      expect(summary).toBe('VACUUM');
+      expect(duration).toBeLessThan(1_000);
+    });
   });
 
   describe('set operations', () => {

From 1f95be21fbc2b4e87e7766e18e5026cf185896b0 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Mon, 12 Oct 2026 11:05:51 +0200
Subject: [PATCH 54/84] fix(core): Record `span` client report outcomes when
 discarding transactions (#25006)

The [client report
spec](https://develop.sentry.dev/sdk/telemetry/client-reports/#span-outcomes)
calls for recording category `span` client outcomes, also if streaming
is disabled. This PR makes the change to record outcomes for each span,
including one for the transaction itself when a transaction is sampled
negatively, as well as when it's dropped.

The transaction/event processing pipeline had a bunch of holes for
discarded span counts, since any combination of `ignoreSpans`, event
processors and `beforeSendTransaction` could drop child spans in any of
those callbacks. So for example, a transaction that originally had 10
child spans and drops

- 2 spans in ignoreSpans
- 1 span in an event processor
- the whole transaction in beforeSendTransaction

now all together reports 11 `span`s and 1 `transaction` outcome, with
the correct reasons. No span drops are double-counted.

Related bugfix: Spans dropped by `ignoreSpans` without span streaming
are now recorded as `ignored` instead of `before_send`.

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 .../consistent-sampling/meta-negative/test.ts |   5 +
 .../meta-precedence/test.ts                   |   5 +
 .../tracesSampler-precedence/test.ts          |  10 +
 .../suites/tracing/sampling-static/test.ts    |  29 +-
 packages/core/src/client.ts                   |  70 ++--
 packages/core/src/scope.ts                    |   3 +
 packages/core/src/tracing/sentrySpan.ts       |   2 -
 packages/core/src/tracing/trace.ts            |  22 +-
 packages/core/src/utils/prepareEvent.ts       |  15 +-
 packages/core/test/lib/client.test.ts         | 379 +++++++++++++++++-
 .../core/test/lib/tracing/idleSpan.test.ts    |   2 +
 packages/core/test/lib/tracing/trace.test.ts  |  72 +++-
 12 files changed, 555 insertions(+), 59 deletions(-)

diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/test.ts
index c4eae38fbd89..d8d76a903cf3 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-negative/test.ts
@@ -91,6 +91,11 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
               quantity: 4,
               reason: 'sample_rate',
             },
+            {
+              category: 'span',
+              quantity: expect.any(Number),
+              reason: 'sample_rate',
+            },
           ],
         });
       });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/test.ts
index 3dab9594ba7c..65ad74b214f6 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/meta-precedence/test.ts
@@ -75,6 +75,11 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
               quantity: 2,
               reason: 'sample_rate',
             },
+            {
+              category: 'span',
+              quantity: expect.any(Number),
+              reason: 'sample_rate',
+            },
           ],
         });
       });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/test.ts
index a61043dfc109..247bd05503f8 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-static/consistent-sampling/tracesSampler-precedence/test.ts
@@ -59,6 +59,11 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
             quantity: 1,
             reason: 'sample_rate',
           },
+          {
+            category: 'span',
+            quantity: expect.any(Number),
+            reason: 'sample_rate',
+          },
         ],
       });
     });
@@ -80,6 +85,11 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
             quantity: 1,
             reason: 'sample_rate',
           },
+          {
+            category: 'span',
+            quantity: expect.any(Number),
+            reason: 'sample_rate',
+          },
         ],
       });
     });
diff --git a/dev-packages/node-integration-tests/suites/tracing/sampling-static/test.ts b/dev-packages/node-integration-tests/suites/tracing/sampling-static/test.ts
index 0746817a92cc..83e83a46251e 100644
--- a/dev-packages/node-integration-tests/suites/tracing/sampling-static/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/sampling-static/test.ts
@@ -7,7 +7,13 @@ describe('negative sampling (static)', () => {
   });
 
   createEsmAndCjsTests(__dirname, 'server.mjs', 'instrument.mjs', (createRunner, test) => {
-    test('records sample_rate outcome for root span/transaction', async () => {
+    test('records sample_rate outcomes for the transaction and all of its spans', async () => {
+      // `/health` and `/ok` go through the same middleware, so the `/ok` transaction tells us how many
+      // spans the dropped `/health` transaction would have had. The count differs per runtime (e.g. Bun creates
+      // no Express spans), so we derive it instead of hardcoding it.
+      let okSpanCount: number | undefined;
+      let droppedSpanCount: number | undefined;
+
       const runner = createRunner()
         .unignore('client_report')
         // The `GET /ok` transaction is sent as soon as its span ends, while the negatively-sampled
@@ -16,19 +22,18 @@ describe('negative sampling (static)', () => {
         // match unordered instead of asserting a fixed sequence.
         .unordered()
         .expect({
-          transaction: {
-            transaction: 'GET /ok',
+          transaction: transaction => {
+            expect(transaction.transaction).toBe('GET /ok');
+            okSpanCount = 1 + (transaction.spans?.length ?? 0);
           },
         })
         .expect({
-          client_report: {
-            discarded_events: [
-              {
-                category: 'transaction',
-                quantity: 1,
-                reason: 'sample_rate',
-              },
-            ],
+          client_report: clientReport => {
+            expect(clientReport.discarded_events).toEqual([
+              { category: 'transaction', quantity: 1, reason: 'sample_rate' },
+              { category: 'span', quantity: expect.any(Number), reason: 'sample_rate' },
+            ]);
+            droppedSpanCount = clientReport.discarded_events[1]!.quantity;
           },
         })
         .start();
@@ -40,6 +45,8 @@ describe('negative sampling (static)', () => {
       expect((res2 as { status: string }).status).toBe('ok');
 
       await runner.completed();
+
+      expect(droppedSpanCount).toBe(okSpanCount);
     });
   });
 });
diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
index b56b35b49ab2..99939a127fa6 100644
--- a/packages/core/src/client.ts
+++ b/packages/core/src/client.ts
@@ -1532,13 +1532,17 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
     const isError = isErrorEvent(event);
     const eventType = event.type || 'error';
     const beforeSendLabel = `before send for type \`${eventType}\``;
-    let beforeSendDropReason: 'before_send' | 'callback_error' = 'before_send';
+    let beforeSendDropReason: BeforeSendDropReason = 'before_send';
+    let ignoredSpanCount = 0;
 
     // 1.0 === 100% events are sent
     // 0.0 === 0% events are sent
     // Sampling for transaction happens somewhere else
     const parsedSampleRate = typeof sampleRate === 'undefined' ? undefined : parseSampleRate(sampleRate);
     const dataCategory = getDataCategoryByType(event.type);
+    // Spans that event processors removed are already recorded in `prepareEvent`, so all later
+    // span outcomes are relative to the span count of the prepared event.
+    let preparedSpanCount = 0;
 
     return this._prepareEvent(event, hint, currentScope, isolationScope)
       .then(prepared => {
@@ -1546,25 +1550,41 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
           throw _makeDoNotSendEventError('An event processor returned `null`, will not send event.');
         }
 
+        preparedSpanCount = prepared.spans?.length || 0;
+
         if (isInternalException(hint)) {
           return prepared;
         }
 
-        const result = processBeforeSend(this, options, prepared, hint, () => {
-          beforeSendDropReason = 'callback_error';
-        });
+        const result = processBeforeSend(
+          options,
+          prepared,
+          hint,
+          reason => {
+            beforeSendDropReason = reason;
+          },
+          count => {
+            ignoredSpanCount = count;
+          },
+        );
         return _validateBeforeSendResult(result, beforeSendLabel);
       })
       .then(processedEvent => {
+        if (ignoredSpanCount) {
+          this.recordDroppedEvent('ignored', 'span', ignoredSpanCount);
+        }
+
         if (processedEvent === null) {
           this.recordDroppedEvent(beforeSendDropReason, dataCategory);
           if (isTransaction) {
-            const spans = event.spans || [];
-            // the transaction itself counts as one span, plus all the child spans that are added
-            this.recordDroppedEvent(beforeSendDropReason, 'span', 1 + spans.length);
+            // the transaction itself counts as one span, plus all the child spans that weren't ignored before
+            this.recordDroppedEvent(beforeSendDropReason, 'span', 1 + preparedSpanCount - ignoredSpanCount);
           }
-          const dropMessage = beforeSendDropReason === 'callback_error' ? 'threw an error' : 'returned `null`';
-          throw _makeDoNotSendEventError(`${beforeSendLabel} ${dropMessage}, will not send event.`);
+          const dropMessage =
+            beforeSendDropReason === 'ignored'
+              ? 'Transaction matched `ignoreSpans`'
+              : `${beforeSendLabel} ${beforeSendDropReason === 'callback_error' ? 'threw an error' : 'returned `null`'}`;
+          throw _makeDoNotSendEventError(`${dropMessage}, will not send event.`);
         }
 
         const session = currentScope.getSession() || isolationScope.getSession();
@@ -1580,10 +1600,7 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
         }
 
         if (isTransaction) {
-          const spanCountBefore = processedEvent.sdkProcessingMetadata?.spanCountBeforeProcessing || 0;
-          const spanCountAfter = processedEvent.spans ? processedEvent.spans.length : 0;
-
-          const droppedSpanCount = spanCountBefore - spanCountAfter;
+          const droppedSpanCount = preparedSpanCount - ignoredSpanCount - (processedEvent.spans?.length || 0);
           if (droppedSpanCount > 0) {
             this.recordDroppedEvent('before_send', 'span', droppedSpanCount);
           }
@@ -1733,15 +1750,17 @@ function _validateBeforeSendResult(
   return beforeSendResult;
 }
 
+type BeforeSendDropReason = 'before_send' | 'callback_error' | 'ignored';
+
 /**
  * Process the matching `beforeSendXXX` callback.
  */
 function processBeforeSend(
-  client: Client,
   options: ClientOptions,
   event: Event,
   hint: EventHint,
-  onCallbackError: () => void,
+  onDrop: (reason: Exclude<BeforeSendDropReason, 'before_send'>) => void,
+  onIgnoredSpans: (count: number) => void,
 ): PromiseLike<Event | null> | Event | null {
   const {
     beforeSend,
@@ -1759,7 +1778,7 @@ function processBeforeSend(
       DEBUG_BUILD ? 'The `beforeSend` callback threw an error, dropping the event:' : '',
       () => beforeSend(errorEvent, hint),
       () => {
-        onCallbackError();
+        onDrop('callback_error');
         return null;
       },
     );
@@ -1779,7 +1798,7 @@ function processBeforeSend(
           ignoreSpans,
         )
       ) {
-        // dropping the whole transaction!
+        onDrop('ignored');
         return null;
       }
 
@@ -1814,30 +1833,17 @@ function processBeforeSend(
           }
         }
 
-        const droppedSpans = processedEvent.spans.length - processedSpans.length;
-        if (droppedSpans) {
-          client.recordDroppedEvent('before_send', 'span', droppedSpans);
-        }
-
+        onIgnoredSpans(initialSpans.length - processedSpans.length);
         processedEvent.spans = processedSpans;
       }
     }
 
     if (beforeSendTransaction) {
-      if (processedEvent.spans) {
-        // We store the # of spans before processing in SDK metadata,
-        // so we can compare it afterwards to determine how many spans were dropped
-        const spanCountBefore = processedEvent.spans.length;
-        processedEvent.sdkProcessingMetadata = {
-          ...event.sdkProcessingMetadata,
-          spanCountBeforeProcessing: spanCountBefore,
-        };
-      }
       return safeCallback(
         DEBUG_BUILD ? 'The `beforeSendTransaction` callback threw an error, dropping the event:' : '',
         () => beforeSendTransaction(processedEvent as TransactionEvent, hint),
         () => {
-          onCallbackError();
+          onDrop('callback_error');
           return null;
         },
       );
diff --git a/packages/core/src/scope.ts b/packages/core/src/scope.ts
index d2fba52a8fc0..1a2a1761854a 100644
--- a/packages/core/src/scope.ts
+++ b/packages/core/src/scope.ts
@@ -62,6 +62,9 @@ export interface SdkProcessingMetadata {
   dynamicSamplingContext?: Partial<DynamicSamplingContext>;
   capturedSpanScope?: Scope;
   capturedSpanIsolationScope?: Scope;
+  /**
+   * @deprecated This is no longer set or read by the SDK and will be removed in the next major version.
+   */
   spanCountBeforeProcessing?: number;
   ipAddress?: string;
 }
diff --git a/packages/core/src/tracing/sentrySpan.ts b/packages/core/src/tracing/sentrySpan.ts
index d9646e6b7078..878cd9d86195 100644
--- a/packages/core/src/tracing/sentrySpan.ts
+++ b/packages/core/src/tracing/sentrySpan.ts
@@ -392,8 +392,6 @@ export class SentrySpan implements Span {
       }
 
       DEBUG_BUILD && debug.log('[Tracing] Discarding standalone span because its trace was not chosen to be sampled.');
-      client.recordDroppedEvent('sample_rate', 'span');
-
       return;
     }
 
diff --git a/packages/core/src/tracing/trace.ts b/packages/core/src/tracing/trace.ts
index ff312712ee46..cb6f9f853184 100644
--- a/packages/core/src/tracing/trace.ts
+++ b/packages/core/src/tracing/trace.ts
@@ -308,7 +308,11 @@ export function startNewTrace<T>(callback: () => T): T {
  */
 function startMissingRequiredParentSpan(scope: Scope, client: Client | undefined): SentryNonRecordingSpan {
   client?.recordDroppedEvent('no_parent_span', 'span');
-  const span = new SentryNonRecordingSpan({ traceId: scope.getPropagationContext().traceId });
+  // Spans nested inside the placeholder inherit its drop reason in `_startChildSpan`
+  const span = new SentryNonRecordingSpan({
+    dropReason: 'no_parent_span',
+    traceId: scope.getPropagationContext().traceId,
+  });
   setCapturedScopesOnSpan(span, scope, getIsolationScope());
   return span;
 }
@@ -523,7 +527,14 @@ function _startRootSpan(
 
   if (!sampled && client && !_isTracingSuppressed) {
     DEBUG_BUILD && debug.log('[Tracing] Discarding root span because its trace was not chosen to be sampled.');
-    client.recordDroppedEvent(dropReason || 'sample_rate', hasSpanStreamingEnabled(client) ? 'span' : 'transaction');
+    const outcomeReason = dropReason || 'sample_rate';
+    // A standalone span is sent on its own and never becomes a transaction.
+    // TODO(v12): Drop the `isStandalone` check once the static trace lifecycle is gone.
+    if (!hasSpanStreamingEnabled(client) && !spanArguments.isStandalone) {
+      client.recordDroppedEvent(outcomeReason, 'transaction');
+    }
+    // Child spans of this root record their own `span` outcome in `_startChildSpan`.
+    client.recordDroppedEvent(outcomeReason, 'span');
   }
 
   setCapturedScopesOnSpan(rootSpan, scope, isolationScope);
@@ -568,11 +579,10 @@ function _startChildSpan(
     return childSpan;
   }
 
-  if (hasSpanStreamingEnabled(client) && spanIsNonRecordingSpan(childSpan)) {
+  if (spanIsNonRecordingSpan(childSpan)) {
     if (spanIsNonRecordingSpan(parentSpan) && parentSpan.dropReason) {
-      // We land here if the parent span was a segment span that was ignored (`ignoreSpans`).
-      // In this case, the child was also ignored (see `sampled` above) but we need to
-      // record a client outcome for the child.
+      // The parent was dropped for a reason other than sampling (e.g. an ignored segment span or
+      // an `onlyIfParent` placeholder), so the child is dropped for the same reason.
       childSpan.dropReason = parentSpan.dropReason;
       client.recordDroppedEvent(parentSpan.dropReason, 'span');
     } else if (!_isTracingSuppressed) {
diff --git a/packages/core/src/utils/prepareEvent.ts b/packages/core/src/utils/prepareEvent.ts
index 456ef4b72596..f63e320e4a31 100644
--- a/packages/core/src/utils/prepareEvent.ts
+++ b/packages/core/src/utils/prepareEvent.ts
@@ -109,6 +109,10 @@ export function prepareEvent(
   ];
 
   // Skip event processors for internal exceptions to prevent recursion
+  const isTransaction = event.type === 'transaction';
+  // Snapshot the count rather than reading `event.spans` later: processors get a shallow copy of the
+  // event, so one that mutates `spans` in place also mutates the original array.
+  const spanCountBeforeProcessing = event.spans?.length || 0;
   const result: PromiseLike<Event | null> = isInternalException(hint)
     ? resolvedSyncPromise(prepared)
     : notifyEventProcessors(eventProcessors, prepared, hint, 0, reason => {
@@ -117,8 +121,8 @@ export function prepareEvent(
         }
 
         client.recordDroppedEvent(reason, getDataCategoryByType(event.type));
-        if (event.type === 'transaction') {
-          client.recordDroppedEvent(reason, 'span', 1 + (event.spans || []).length);
+        if (isTransaction) {
+          client.recordDroppedEvent(reason, 'span', 1 + spanCountBeforeProcessing);
         }
       });
 
@@ -127,6 +131,13 @@ export function prepareEvent(
       return null;
     }
 
+    if (isTransaction && client) {
+      const droppedSpanCount = spanCountBeforeProcessing - (evt.spans?.length || 0);
+      if (droppedSpanCount > 0) {
+        client.recordDroppedEvent('event_processor', 'span', droppedSpanCount);
+      }
+    }
+
     // We apply the debug_meta field only after all event processors have ran, so that if any event processors modified
     // file names (e.g.the RewriteFrames integration) the filename -> debug ID relationship isn't destroyed.
     // This should not cause any PII issues, since we're only moving data that is already on the event and not adding
diff --git a/packages/core/test/lib/client.test.ts b/packages/core/test/lib/client.test.ts
index fd77aa7f3254..1f5891f4860f 100644
--- a/packages/core/test/lib/client.test.ts
+++ b/packages/core/test/lib/client.test.ts
@@ -22,6 +22,7 @@ import { _INTERNAL_captureMetric } from '../../src/metrics/internal';
 import * as traceModule from '../../src/tracing/trace';
 import { DEFAULT_TRANSPORT_BUFFER_SIZE } from '../../src/transports/base';
 import type { Envelope } from '../../src/types/envelope';
+import type { Outcome } from '../../src/types/clientreport';
 import type { ErrorEvent, Event, EventHint, TransactionEvent } from '../../src/types/event';
 import type { SpanJSON } from '../../src/types/span';
 import type { Transport } from '../../src/types/transport';
@@ -1336,6 +1337,7 @@ describe('Client', () => {
 
       const captureExceptionSpy = vi.spyOn(client, 'captureException');
       const loggerLogSpy = vi.spyOn(debugLoggerModule.debug, 'log');
+      const recordDroppedEventSpy = vi.spyOn(client, 'recordDroppedEvent');
 
       const transaction: Event = {
         transaction: 'root span',
@@ -1365,7 +1367,10 @@ describe('Client', () => {
       // This proves that the reason the event didn't send/didn't get set on the test client is not because there was an
       // error, but because the event processor returned `null`
       expect(captureExceptionSpy).not.toBeCalled();
-      expect(loggerLogSpy).toBeCalledWith('before send for type `transaction` returned `null`, will not send event.');
+      expect(loggerLogSpy).toBeCalledWith('Transaction matched `ignoreSpans`, will not send event.');
+      expect(recordDroppedEventSpy).toHaveBeenCalledTimes(2);
+      expect(recordDroppedEventSpy).toHaveBeenCalledWith('ignored', 'transaction');
+      expect(recordDroppedEventSpy).toHaveBeenCalledWith('ignored', 'span', 3);
     });
 
     test('uses `ignoreSpans` to drop child spans', () => {
@@ -1435,7 +1440,8 @@ describe('Client', () => {
           status: 'ok',
         },
       ]);
-      expect(recordDroppedEventSpy).toBeCalledWith('before_send', 'span', 1);
+      expect(recordDroppedEventSpy).toHaveBeenCalledTimes(1);
+      expect(recordDroppedEventSpy).toHaveBeenCalledWith('ignored', 'span', 1);
     });
 
     test('uses complex `ignoreSpans` to drop child spans', () => {
@@ -1511,7 +1517,8 @@ describe('Client', () => {
           status: 'ok',
         },
       ]);
-      expect(recordDroppedEventSpy).toBeCalledWith('before_send', 'span', 2);
+      expect(recordDroppedEventSpy).toHaveBeenCalledTimes(1);
+      expect(recordDroppedEventSpy).toHaveBeenCalledWith('ignored', 'span', 2);
     });
 
     test('does not modify existing contexts for root span in `beforeSendSpan`', () => {
@@ -2118,6 +2125,372 @@ describe('Client', () => {
       expect(recordLostEventSpy).toHaveBeenCalledWith('event_processor', 'span', 2);
     });
 
+    test('event processor records spans it removes from a sent transaction', () => {
+      const client = new TestClient(getDefaultTestClientOptions({ dsn: PUBLIC_DSN }));
+      const recordLostEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+
+      const spans = [
+        {
+          span_id: 'aaaaaaaaaaaaaaaa',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'bbbbbbbbbbbbbbbb',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'cccccccccccccccc',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+      ];
+
+      const scope = new Scope();
+      scope.addEventProcessor(event => ({ ...event, spans: event.spans?.slice(0, 1) }));
+
+      client.captureEvent({ transaction: '/dogs/are/great', type: 'transaction', spans }, {}, scope);
+
+      expect(TestClient.instance!.event?.spans).toHaveLength(1);
+      expect(recordLostEventSpy).toHaveBeenCalledTimes(1);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('event_processor', 'span', 2);
+    });
+
+    test('event processor counts spans removed in place before a later processor drops the transaction', () => {
+      const client = new TestClient(getDefaultTestClientOptions({ dsn: PUBLIC_DSN }));
+      const recordLostEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+
+      const spans = [
+        {
+          span_id: 'aaaaaaaaaaaaaaaa',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'bbbbbbbbbbbbbbbb',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'cccccccccccccccc',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+      ];
+
+      const scope = new Scope();
+      scope.addEventProcessor(event => {
+        event.spans?.splice(0, 2);
+        return event;
+      });
+      scope.addEventProcessor(() => null);
+
+      client.captureEvent({ transaction: '/dogs/are/great', type: 'transaction', spans }, {}, scope);
+
+      expect(recordLostEventSpy).toHaveBeenCalledTimes(2);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('event_processor', 'transaction');
+      expect(recordLostEventSpy).toHaveBeenCalledWith('event_processor', 'span', 4);
+    });
+
+    test('spans removed by event processors and `beforeSendTransaction` are each counted once', () => {
+      const beforeSendTransaction = vi.fn(event => ({ ...event, spans: [] }));
+      const client = new TestClient(getDefaultTestClientOptions({ dsn: PUBLIC_DSN, beforeSendTransaction }));
+      const recordLostEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+
+      const spans = [
+        {
+          span_id: 'aaaaaaaaaaaaaaaa',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'bbbbbbbbbbbbbbbb',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'cccccccccccccccc',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+      ];
+
+      const scope = new Scope();
+      scope.addEventProcessor(event => ({ ...event, spans: event.spans?.slice(0, 1) }));
+
+      client.captureEvent({ transaction: '/dogs/are/great', type: 'transaction', spans }, {}, scope);
+
+      expect(TestClient.instance!.event?.type).toBe('transaction');
+      expect(TestClient.instance!.event?.spans).toEqual([]);
+      expect(recordLostEventSpy).toHaveBeenCalledTimes(2);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('event_processor', 'span', 2);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('before_send', 'span', 1);
+    });
+
+    test('spans removed by event processors are not counted again when `beforeSendTransaction` drops the transaction', () => {
+      const client = new TestClient(
+        getDefaultTestClientOptions({ dsn: PUBLIC_DSN, beforeSendTransaction: () => null }),
+      );
+      const recordLostEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+
+      const spans = [
+        {
+          span_id: 'aaaaaaaaaaaaaaaa',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'bbbbbbbbbbbbbbbb',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'cccccccccccccccc',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+      ];
+
+      const scope = new Scope();
+      scope.addEventProcessor(event => ({ ...event, spans: event.spans?.slice(0, 1) }));
+
+      client.captureEvent({ transaction: '/dogs/are/great', type: 'transaction', spans }, {}, scope);
+
+      expect(TestClient.instance!.event).toBeUndefined();
+      expect(recordLostEventSpy).toHaveBeenCalledTimes(3);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('event_processor', 'span', 2);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('before_send', 'transaction');
+      expect(recordLostEventSpy).toHaveBeenCalledWith('before_send', 'span', 2);
+    });
+
+    test('spans removed by event processors are not counted again when `ignoreSpans` drops the root span', () => {
+      const client = new TestClient(getDefaultTestClientOptions({ dsn: PUBLIC_DSN, ignoreSpans: ['/dogs/are/great'] }));
+      const recordLostEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+
+      const spans = [
+        {
+          span_id: 'aaaaaaaaaaaaaaaa',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'bbbbbbbbbbbbbbbb',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'cccccccccccccccc',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+      ];
+
+      const scope = new Scope();
+      scope.addEventProcessor(event => ({ ...event, spans: event.spans?.slice(0, 1) }));
+
+      client.captureEvent({ transaction: '/dogs/are/great', type: 'transaction', spans }, {}, scope);
+
+      expect(TestClient.instance!.event).toBeUndefined();
+      expect(recordLostEventSpy).toHaveBeenCalledTimes(3);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('event_processor', 'span', 2);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('ignored', 'transaction');
+      expect(recordLostEventSpy).toHaveBeenCalledWith('ignored', 'span', 2);
+    });
+
+    test('child spans dropped by `ignoreSpans` are counted as ignored when `beforeSendTransaction` drops the transaction', () => {
+      const client = new TestClient(
+        getDefaultTestClientOptions({
+          dsn: PUBLIC_DSN,
+          ignoreSpans: ['ignored-child'],
+          beforeSendTransaction: () => null,
+        }),
+      );
+      const recordLostEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+
+      const spans = [
+        {
+          span_id: 'aaaaaaaaaaaaaaaa',
+          description: 'ignored-child',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'bbbbbbbbbbbbbbbb',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+      ];
+
+      client.captureEvent({ transaction: '/dogs/are/great', type: 'transaction', spans });
+
+      expect(TestClient.instance!.event).toBeUndefined();
+      expect(recordLostEventSpy).toHaveBeenCalledTimes(3);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('ignored', 'span', 1);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('before_send', 'transaction');
+      expect(recordLostEventSpy).toHaveBeenCalledWith('before_send', 'span', 2);
+    });
+
+    test('child spans dropped by `ignoreSpans` and removed by `beforeSendTransaction` are counted once with their reason', () => {
+      const client = new TestClient(
+        getDefaultTestClientOptions({
+          dsn: PUBLIC_DSN,
+          ignoreSpans: ['ignored-child'],
+          beforeSendTransaction: event => ({ ...event, spans: [] }),
+        }),
+      );
+      const recordLostEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+
+      const spans = [
+        {
+          span_id: 'aaaaaaaaaaaaaaaa',
+          description: 'ignored-child',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+        {
+          span_id: 'bbbbbbbbbbbbbbbb',
+          start_timestamp: 1,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        },
+      ];
+
+      client.captureEvent({ transaction: '/dogs/are/great', type: 'transaction', spans });
+
+      expect(TestClient.instance!.event?.spans).toEqual([]);
+      expect(recordLostEventSpy).toHaveBeenCalledTimes(2);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('ignored', 'span', 1);
+      expect(recordLostEventSpy).toHaveBeenCalledWith('before_send', 'span', 1);
+    });
+
+    describe('span outcomes when all span drop mechanisms apply to the same transaction', () => {
+      const childSpanDescriptions = [
+        'removed-by-event-processor-1',
+        'removed-by-event-processor-2',
+        'ignored-child',
+        'removed-by-before-send-transaction',
+        'kept-1',
+        'kept-2',
+      ];
+
+      function captureTransaction(
+        beforeSendTransaction: (event: TransactionEvent) => TransactionEvent | null,
+      ): TestClient {
+        const client = new TestClient(
+          getDefaultTestClientOptions({
+            dsn: PUBLIC_DSN,
+            ignoreSpans: ['ignored-child'],
+            beforeSendSpan: withStaticSpan(span => ({ ...span, data: { ...span.data, scrubbed: true } })),
+            beforeSendTransaction,
+          }),
+        );
+
+        const scope = new Scope();
+        scope.addEventProcessor(event => ({
+          ...event,
+          spans: event.spans?.filter(span => !span.description?.startsWith('removed-by-event-processor')),
+        }));
+
+        client.captureEvent(
+          {
+            transaction: '/dogs/are/great',
+            type: 'transaction',
+            spans: childSpanDescriptions.map((description, i) => ({
+              description,
+              span_id: `${i}`.padStart(16, '0'),
+              start_timestamp: 1,
+              trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+              data: {},
+              status: 'ok',
+            })),
+          },
+          {},
+          scope,
+        );
+
+        return client;
+      }
+
+      function getOutcomes(client: TestClient): { outcomes: Outcome[]; spanOutcomeTotal: number } {
+        const outcomes = client._clearOutcomes();
+        const spanOutcomeTotal = outcomes.filter(o => o.category === 'span').reduce((sum, o) => sum + o.quantity, 0);
+        return { outcomes, spanOutcomeTotal };
+      }
+
+      test('counts each dropped span exactly once when the transaction is sent', () => {
+        const client = captureTransaction(event => ({
+          ...event,
+          spans: event.spans?.filter(span => span.description !== 'removed-by-before-send-transaction'),
+        }));
+
+        const sentSpans = TestClient.instance!.event!.spans!;
+        expect(sentSpans.map(span => span.description)).toEqual(['kept-1', 'kept-2']);
+
+        const { outcomes, spanOutcomeTotal } = getOutcomes(client);
+        expect(outcomes).toEqual([
+          { reason: 'event_processor', category: 'span', quantity: 2 },
+          { reason: 'ignored', category: 'span', quantity: 1 },
+          { reason: 'before_send', category: 'span', quantity: 1 },
+        ]);
+        // every child span is either sent or counted once; the root span is sent as the transaction
+        expect(spanOutcomeTotal + sentSpans.length).toBe(childSpanDescriptions.length);
+      });
+
+      test('counts each span exactly once when `beforeSendTransaction` drops the transaction', () => {
+        const client = captureTransaction(() => null);
+
+        expect(TestClient.instance!.event).toBeUndefined();
+
+        const { outcomes, spanOutcomeTotal } = getOutcomes(client);
+        expect(outcomes).toEqual([
+          { reason: 'event_processor', category: 'span', quantity: 2 },
+          { reason: 'ignored', category: 'span', quantity: 1 },
+          { reason: 'before_send', category: 'transaction', quantity: 1 },
+          { reason: 'before_send', category: 'span', quantity: 4 },
+        ]);
+        // all child spans plus the root span are counted once
+        expect(spanOutcomeTotal).toBe(childSpanDescriptions.length + 1);
+      });
+    });
+
     test('mutating transaction name with event processors sets transaction-name-change metadata', () => {
       const options = getDefaultTestClientOptions({ dsn: PUBLIC_DSN, enableSend: true });
       const client = new TestClient(options);
diff --git a/packages/core/test/lib/tracing/idleSpan.test.ts b/packages/core/test/lib/tracing/idleSpan.test.ts
index 3809db713668..a129c35e6a13 100644
--- a/packages/core/test/lib/tracing/idleSpan.test.ts
+++ b/packages/core/test/lib/tracing/idleSpan.test.ts
@@ -501,7 +501,9 @@ describe('startIdleSpan', () => {
 
     idleSpan.end();
 
+    expect(recordDroppedEventSpy).toHaveBeenCalledTimes(2);
     expect(recordDroppedEventSpy).toHaveBeenCalledWith('sample_rate', 'transaction');
+    expect(recordDroppedEventSpy).toHaveBeenCalledWith('sample_rate', 'span');
   });
 
   it('sets finish reason when span is ended manually', () => {
diff --git a/packages/core/test/lib/tracing/trace.test.ts b/packages/core/test/lib/tracing/trace.test.ts
index 5d7ab473b1b8..f59946d50c10 100644
--- a/packages/core/test/lib/tracing/trace.test.ts
+++ b/packages/core/test/lib/tracing/trace.test.ts
@@ -642,6 +642,21 @@ describe('startSpan', () => {
       expect(spyOnDroppedEvent).toHaveBeenCalledTimes(1);
     });
 
+    it('records no_parent_span client reports for spans nested in a span without parent', () => {
+      const spyOnDroppedEvent = vi.spyOn(client, 'recordDroppedEvent');
+
+      startSpan({ name: 'test span', onlyIfParent: true }, () => {
+        startSpan({ name: 'child span' }, () => {
+          startInactiveSpan({ name: 'grandchild span' }).end();
+        });
+      });
+
+      expect(spyOnDroppedEvent).toHaveBeenCalledTimes(3);
+      expect(spyOnDroppedEvent).toHaveBeenNthCalledWith(1, 'no_parent_span', 'span');
+      expect(spyOnDroppedEvent).toHaveBeenNthCalledWith(2, 'no_parent_span', 'span');
+      expect(spyOnDroppedEvent).toHaveBeenNthCalledWith(3, 'no_parent_span', 'span');
+    });
+
     it('creates a span if there is a parent', () => {
       const spyOnDroppedEvent = vi.spyOn(client, 'recordDroppedEvent');
 
@@ -2773,7 +2788,7 @@ describe('ignoreSpans (core path, streaming)', () => {
     expect(spyOnDroppedEvent).toHaveBeenNthCalledWith(2, 'sample_rate', 'span');
   });
 
-  it('records sample_rate/transaction for unsampled root span on static path', () => {
+  it('records sample_rate outcomes for the transaction and all of its spans on static path', () => {
     const options = getDefaultTestClientOptions({
       tracesSampleRate: 0,
     });
@@ -2783,11 +2798,62 @@ describe('ignoreSpans (core path, streaming)', () => {
     const spyOnDroppedEvent = vi.spyOn(client, 'recordDroppedEvent');
 
     startSpan({ name: 'GET /foo' }, () => {
-      startSpan({ name: 'db.query' }, () => {});
+      startSpan({ name: 'db.query' }, () => {
+        startSpan({ name: 'cache.lookup' }, () => {});
+      });
+      startInactiveSpan({ name: 'http.client' }).end();
     });
 
+    expect(spyOnDroppedEvent).toHaveBeenCalledTimes(5);
+    expect(spyOnDroppedEvent).toHaveBeenNthCalledWith(1, 'sample_rate', 'transaction');
+    expect(spyOnDroppedEvent).toHaveBeenNthCalledWith(2, 'sample_rate', 'span');
+    expect(spyOnDroppedEvent).toHaveBeenNthCalledWith(3, 'sample_rate', 'span');
+    expect(spyOnDroppedEvent).toHaveBeenNthCalledWith(4, 'sample_rate', 'span');
+    expect(spyOnDroppedEvent).toHaveBeenNthCalledWith(5, 'sample_rate', 'span');
+  });
+
+  it('records a single sample_rate/span outcome for an unsampled standalone root span on static path', () => {
+    const options = getDefaultTestClientOptions({
+      tracesSampleRate: 0,
+    });
+    client = new TestClient(options);
+    setCurrentClient(client);
+    client.init();
+    const spyOnDroppedEvent = vi.spyOn(client, 'recordDroppedEvent');
+
+    // oxlint-disable-next-line typescript/no-deprecated
+    startInactiveSpan({ name: 'inp', experimental: { standalone: true } }).end();
+
     expect(spyOnDroppedEvent).toHaveBeenCalledTimes(1);
-    expect(spyOnDroppedEvent).toHaveBeenCalledWith('sample_rate', 'transaction');
+    expect(spyOnDroppedEvent).toHaveBeenCalledWith('sample_rate', 'span');
+  });
+
+  // Unsampled spans are counted when they start, so this also counts spans a sampled
+  // transaction would never contain (here: a child that never ends).
+  it('records sample_rate outcomes for unsampled spans that a sampled transaction would not contain', () => {
+    const runScenario = (tracesSampleRate: number): ReturnType<typeof vi.spyOn> => {
+      client = new TestClient(getDefaultTestClientOptions({ tracesSampleRate }));
+      setCurrentClient(client);
+      client.init();
+      const spyOnDroppedEvent = vi.spyOn(client, 'recordDroppedEvent');
+
+      startSpan({ name: 'GET /foo' }, () => {
+        startInactiveSpan({ name: 'never ended' });
+      });
+
+      return spyOnDroppedEvent;
+    };
+
+    const sampledSpy = vi.spyOn(TestClient.prototype, 'sendEvent');
+    runScenario(1);
+    expect(sampledSpy).toHaveBeenCalledWith(expect.objectContaining({ spans: [] }), expect.anything());
+    sampledSpy.mockRestore();
+
+    const unsampledDroppedEventSpy = runScenario(0);
+    expect(unsampledDroppedEventSpy).toHaveBeenCalledTimes(3);
+    expect(unsampledDroppedEventSpy).toHaveBeenNthCalledWith(1, 'sample_rate', 'transaction');
+    expect(unsampledDroppedEventSpy).toHaveBeenNthCalledWith(2, 'sample_rate', 'span');
+    expect(unsampledDroppedEventSpy).toHaveBeenNthCalledWith(3, 'sample_rate', 'span');
   });
 
   it('records only one ignored outcome for directly ignored child span', () => {

From 2af75e43f218ec63eba9cca337a27e7128b4e254 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Mon, 12 Oct 2026 11:05:51 +0200
Subject: [PATCH 55/84] fix(core): Record client outcomes when beforeSend
 callbacks return invalid values (#25049)

When `beforeSend` or `beforeSendTransaction` returns something other
than an event or `null` (often `undefined` from a forgotten `return`),
the event is dropped but no client outcome is recorded. It now records a
`before_send` outcome for the event's category and, for transactions,
the root `span` plus all child spans that weren't already recorded as
`ignored`.

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 packages/core/src/client.ts           |  38 ++-------
 packages/core/test/lib/client.test.ts | 107 ++++++++++++++++++++++++++
 2 files changed, 115 insertions(+), 30 deletions(-)

diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
index 99939a127fa6..29f24f0795c1 100644
--- a/packages/core/src/client.ts
+++ b/packages/core/src/client.ts
@@ -43,7 +43,7 @@ import { consoleSandbox, debug } from './utils/debug-logger';
 import { dsnToString, makeDsn } from './utils/dsn';
 import { addItemToEnvelope, createAttachmentEnvelopeItem, getDataCategoryByType } from './utils/envelope';
 import { getPossibleEventMessages, isInternalException } from './utils/eventUtils';
-import { isObjectLike, isParameterizedString, isPlainObject, isPrimitive, isThenable } from './utils/is';
+import { isObjectLike, isParameterizedString, isPlainObject, isPrimitive } from './utils/is';
 import { merge } from './utils/merge';
 import { checkOrSetAlreadyCaught, uuid4 } from './utils/misc';
 import { parseSampleRate } from './utils/parseSampleRate';
@@ -1556,7 +1556,7 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
           return prepared;
         }
 
-        const result = processBeforeSend(
+        return processBeforeSend(
           options,
           prepared,
           hint,
@@ -1567,19 +1567,23 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
             ignoredSpanCount = count;
           },
         );
-        return _validateBeforeSendResult(result, beforeSendLabel);
       })
       .then(processedEvent => {
         if (ignoredSpanCount) {
           this.recordDroppedEvent('ignored', 'span', ignoredSpanCount);
         }
 
-        if (processedEvent === null) {
+        // An annotated boolean keeps `isPlainObject` from narrowing `processedEvent` to a plain record
+        const isValidEvent: boolean = isPlainObject(processedEvent);
+        if (!isValidEvent || processedEvent === null) {
           this.recordDroppedEvent(beforeSendDropReason, dataCategory);
           if (isTransaction) {
             // the transaction itself counts as one span, plus all the child spans that weren't ignored before
             this.recordDroppedEvent(beforeSendDropReason, 'span', 1 + preparedSpanCount - ignoredSpanCount);
           }
+          if (processedEvent !== null) {
+            throw _makeInternalError(`${beforeSendLabel} must return \`null\` or a valid event.`);
+          }
           const dropMessage =
             beforeSendDropReason === 'ignored'
               ? 'Transaction matched `ignoreSpans`'
@@ -1724,32 +1728,6 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
   ): PromiseLike<Event>;
 }
 
-/**
- * Verifies that return value of configured `beforeSend` or `beforeSendTransaction` is of expected type, and returns the value if so.
- */
-function _validateBeforeSendResult(
-  beforeSendResult: PromiseLike<Event | null> | Event | null,
-  beforeSendLabel: string,
-): PromiseLike<Event | null> | Event | null {
-  const invalidValueError = `${beforeSendLabel} must return \`null\` or a valid event.`;
-  if (isThenable(beforeSendResult)) {
-    return beforeSendResult.then(
-      event => {
-        if (!isPlainObject(event) && event !== null) {
-          throw _makeInternalError(invalidValueError);
-        }
-        return event;
-      },
-      e => {
-        throw _makeInternalError(`${beforeSendLabel} rejected with ${e}`);
-      },
-    );
-  } else if (!isPlainObject(beforeSendResult) && beforeSendResult !== null) {
-    throw _makeInternalError(invalidValueError);
-  }
-  return beforeSendResult;
-}
-
 type BeforeSendDropReason = 'before_send' | 'callback_error' | 'ignored';
 
 /**
diff --git a/packages/core/test/lib/client.test.ts b/packages/core/test/lib/client.test.ts
index 1f5891f4860f..9dcfe95fd34a 100644
--- a/packages/core/test/lib/client.test.ts
+++ b/packages/core/test/lib/client.test.ts
@@ -2759,6 +2759,113 @@ describe('Client', () => {
       );
     });
 
+    test('drops the transaction and its non-ignored spans when `beforeSendTransaction` rejects', async () => {
+      vi.useFakeTimers();
+
+      const exception = new Error('beforeSendTransaction failed');
+      const beforeSendTransaction = vi.fn(() => Promise.reject(exception));
+      const options = getDefaultTestClientOptions({
+        dsn: PUBLIC_DSN,
+        beforeSendTransaction,
+        ignoreSpans: ['ignored span'],
+      });
+      const client = new TestClient(options);
+      const captureExceptionSpy = vi.spyOn(client, 'captureException');
+      const recordDroppedEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+      const debugErrorSpy = vi.spyOn(debugLoggerModule.debug, 'error');
+
+      client.captureEvent({
+        transaction: '/dogs/are/great',
+        type: 'transaction',
+        spans: ['first span', 'ignored span', 'second span'].map((description, i) => ({
+          description,
+          span_id: `${i}`.padStart(16, '0'),
+          start_timestamp: 1591603196.637835,
+          trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+          data: {},
+          status: 'ok',
+        })),
+      });
+      await vi.runOnlyPendingTimersAsync();
+
+      expect(TestClient.instance!.event).toBeUndefined();
+      expect(captureExceptionSpy).not.toHaveBeenCalled();
+      expect(recordDroppedEventSpy).toHaveBeenCalledTimes(3);
+      expect(recordDroppedEventSpy).toHaveBeenCalledWith('ignored', 'span', 1);
+      expect(recordDroppedEventSpy).toHaveBeenCalledWith('callback_error', 'transaction');
+      expect(recordDroppedEventSpy).toHaveBeenCalledWith('callback_error', 'span', 3);
+      expect(debugErrorSpy).toHaveBeenCalledWith(
+        'The `beforeSendTransaction` callback threw an error, dropping the event:',
+        exception,
+      );
+    });
+
+    test.each([
+      ['sync', () => undefined],
+      ['async', () => Promise.resolve(undefined)],
+    ])('records a `before_send` outcome when `beforeSend` returns an invalid value (%s)', async (_, beforeSend) => {
+      vi.useFakeTimers();
+
+      // @ts-expect-error we need to test regular-js behavior
+      const options = getDefaultTestClientOptions({ dsn: PUBLIC_DSN, beforeSend });
+      const client = new TestClient(options);
+      const captureExceptionSpy = vi.spyOn(client, 'captureException');
+      const recordDroppedEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+      const loggerWarnSpy = vi.spyOn(debugLoggerModule.debug, 'warn');
+
+      client.captureEvent({ message: 'hello' });
+      await vi.runOnlyPendingTimersAsync();
+
+      expect(TestClient.instance!.event).toBeUndefined();
+      expect(captureExceptionSpy).not.toHaveBeenCalled();
+      expect(recordDroppedEventSpy).toHaveBeenCalledTimes(1);
+      expect(recordDroppedEventSpy).toHaveBeenCalledWith('before_send', 'error');
+      expect(loggerWarnSpy).toHaveBeenCalledWith('before send for type `error` must return `null` or a valid event.');
+    });
+
+    test.each([
+      ['sync', () => undefined],
+      ['async', () => Promise.resolve(undefined)],
+    ])(
+      'records `before_send` outcomes for the transaction and its spans when `beforeSendTransaction` returns an invalid value (%s)',
+      async (_, beforeSendTransaction) => {
+        vi.useFakeTimers();
+
+        const options = getDefaultTestClientOptions({
+          dsn: PUBLIC_DSN,
+          // @ts-expect-error we need to test regular-js behavior
+          beforeSendTransaction,
+          ignoreSpans: ['ignored span'],
+        });
+        const client = new TestClient(options);
+        const recordDroppedEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+        const loggerWarnSpy = vi.spyOn(debugLoggerModule.debug, 'warn');
+
+        client.captureEvent({
+          transaction: '/dogs/are/great',
+          type: 'transaction',
+          spans: ['first span', 'ignored span'].map((description, i) => ({
+            description,
+            span_id: `${i}`.padStart(16, '0'),
+            start_timestamp: 1591603196.637835,
+            trace_id: '86f39e84263a4de99c326acab3bfe3bd',
+            data: {},
+            status: 'ok',
+          })),
+        });
+        await vi.runOnlyPendingTimersAsync();
+
+        expect(TestClient.instance!.event).toBeUndefined();
+        expect(recordDroppedEventSpy).toHaveBeenCalledTimes(3);
+        expect(recordDroppedEventSpy).toHaveBeenCalledWith('ignored', 'span', 1);
+        expect(recordDroppedEventSpy).toHaveBeenCalledWith('before_send', 'transaction');
+        expect(recordDroppedEventSpy).toHaveBeenCalledWith('before_send', 'span', 2);
+        expect(loggerWarnSpy).toHaveBeenCalledWith(
+          'before send for type `transaction` must return `null` or a valid event.',
+        );
+      },
+    );
+
     test('captures an internal event when the event processing pipeline itself throws', async () => {
       vi.useFakeTimers();
 

From 4aa5981a8420fed4043824fcddd3d5546daf75a2 Mon Sep 17 00:00:00 2001
From: Andrei <168741329+andreiborza@users.noreply.github.com>
Date: Mon, 12 Oct 2026 11:12:11 +0200
Subject: [PATCH 56/84] fix(nextjs): Apply top-level `bundleSizeOptimizations`
 to webpack and Turbopack builds (#24818)

## What

The top-level `bundleSizeOptimizations` option now removes unused SDK
code in both webpack and Turbopack builds. `webpack.treeshake` is
deprecated. It still works, but `bundleSizeOptimizations` wins when you
set both.

## Why

On Turbopack, the tree-shaking options did nothing and gave no warning.
The old option also lived under `webpack`, which is wrong for an option
that works with both bundlers.

Closes: #24795

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 packages/nextjs/src/client/index.ts           |  3 +-
 packages/nextjs/src/config/types.ts           |  8 ++-
 packages/nextjs/src/config/webpack.ts         | 41 ++++++++-----
 .../withSentryConfig/getFinalConfigObject.ts  |  2 +
 .../getFinalConfigObjectBundlerUtils.ts       | 31 +++++++++-
 packages/nextjs/src/edge/index.ts             |  3 +-
 packages/nextjs/src/server/index.ts           |  3 +-
 .../webpack/constructWebpackConfig.test.ts    | 35 +++++++++++
 .../test/config/withSentryConfig.test.ts      | 59 +++++++++++++++++++
 9 files changed, 163 insertions(+), 22 deletions(-)

diff --git a/packages/nextjs/src/client/index.ts b/packages/nextjs/src/client/index.ts
index 6f43a282df11..d5c7e11a1d06 100644
--- a/packages/nextjs/src/client/index.ts
+++ b/packages/nextjs/src/client/index.ts
@@ -37,9 +37,10 @@ declare const __SENTRY_TRACING__: boolean;
 export function init(options: BrowserOptions): Client | undefined {
   if (!DEBUG_BUILD && options.debug) {
     consoleSandbox(() => {
+      // TODO(v12): Remove the `webpack.treeshake` mention together with that option
       // eslint-disable-next-line no-console
       console.warn(
-        '[@sentry/nextjs] You have enabled `debug: true`, but Sentry debug logging was removed from your bundle (likely via `webpack.treeshake.removeDebugLogging: true`). Set that option to `false` to see Sentry debug output.',
+        '[@sentry/nextjs] You have enabled `debug: true`, but Sentry debug logging was removed from your bundle (likely via `bundleSizeOptimizations.excludeDebugStatements: true` or `webpack.treeshake.removeDebugLogging: true`). Set that option to `false` to see Sentry debug output.',
       );
     });
   }
diff --git a/packages/nextjs/src/config/types.ts b/packages/nextjs/src/config/types.ts
index 2ad05c994433..f1d3a8441bcb 100644
--- a/packages/nextjs/src/config/types.ts
+++ b/packages/nextjs/src/config/types.ts
@@ -60,6 +60,7 @@ export type NextConfigObject = {
   serverExternalPackages?: string[]; // next >= v15.0.0
   turbopack?: TurbopackOptions;
   compiler?: {
+    define?: Record<string, string | boolean>;
     runAfterProductionCompile?: (context: { distDir: string; projectDir: string }) => Promise<void> | void;
   };
 };
@@ -113,6 +114,9 @@ export type SentryBuildWebpackOptions = {
 
   /**
    * Tree-shaking options to help reduce the size of the Sentry SDK bundle.
+   *
+   * Prefer the top-level `bundleSizeOptimizations` option, which works for both webpack and Turbopack builds.
+   * If both are set, `bundleSizeOptimizations` takes precedence.
    */
   treeshake?: {
     /**
@@ -149,7 +153,7 @@ export type SentryBuildWebpackOptions = {
      * This has no effect if you did not add `replayIntegration`.
      */
     excludeReplayCompressionWorker?: boolean;
-  };
+  }; // TODO: Deprecate this option and its nested options in favor of `bundleSizeOptimizations` closer to v12
 
   /**
    * Options related to react component name annotations.
@@ -393,7 +397,7 @@ export type SentryBuildOptions = Omit<
        * @deprecated Use the top-level `reactComponentAnnotation` option instead, which works for both webpack and Turbopack builds.
        */
       ignoredComponents?: string[];
-    }; // TODO(v12): remove this option
+    }; // TODO: Deprecate this option and its nested options in favor of `bundleSizeOptimizations` closer to v12
   }>;
 
   /**
diff --git a/packages/nextjs/src/config/webpack.ts b/packages/nextjs/src/config/webpack.ts
index 9f594973b41c..833965b69518 100644
--- a/packages/nextjs/src/config/webpack.ts
+++ b/packages/nextjs/src/config/webpack.ts
@@ -419,9 +419,7 @@ export function constructWebpackConfigFunction({
       }
     }
 
-    if (userSentryOptions.webpack?.treeshake) {
-      setupTreeshakingFromConfig(userSentryOptions, newConfig, buildContext);
-    }
+    setupTreeshakingFromConfig(userSentryOptions, newConfig, buildContext);
 
     // We inject a map of dependencies that the nextjs app has, as we cannot reliably extract them at runtime, sadly
     newConfig.plugins = newConfig.plugins || [];
@@ -888,38 +886,49 @@ function prependOrchestrionRuntimeExternals(newConfig: WebpackConfigObjectWithMo
 }
 
 /**
- * Sets up the tree-shaking flags based on the user's configuration.
+ * Returns the tree-shaking flags to define, based on the user's configuration.
  * https://docs.sentry.io/platforms/javascript/guides/nextjs/configuration/tree-shaking/
  */
-function setupTreeshakingFromConfig(
-  userSentryOptions: SentryBuildOptions,
-  newConfig: WebpackConfigObjectWithModuleRules,
-  buildContext: BuildContext,
-): void {
+export function getTreeshakeDefines(userSentryOptions: SentryBuildOptions): Record<string, boolean> {
   const defines: Record<string, boolean> = {};
+  const bundleSizeOptimizations = userSentryOptions.bundleSizeOptimizations;
+  const treeshake = userSentryOptions.webpack?.treeshake;
 
-  newConfig.plugins = newConfig.plugins || [];
-
-  if (userSentryOptions.webpack?.treeshake?.removeDebugLogging) {
+  if (bundleSizeOptimizations?.excludeDebugStatements ?? treeshake?.removeDebugLogging) {
     defines.__SENTRY_DEBUG__ = false;
   }
 
-  if (userSentryOptions.webpack?.treeshake?.removeTracing) {
+  if (bundleSizeOptimizations?.excludeTracing ?? treeshake?.removeTracing) {
     defines.__SENTRY_TRACING__ = false;
   }
 
-  if (userSentryOptions.webpack?.treeshake?.excludeReplayIframe) {
+  if (bundleSizeOptimizations?.excludeReplayIframe ?? treeshake?.excludeReplayIframe) {
     defines.__RRWEB_EXCLUDE_IFRAME__ = true;
   }
 
-  if (userSentryOptions.webpack?.treeshake?.excludeReplayShadowDOM) {
+  if (bundleSizeOptimizations?.excludeReplayShadowDom ?? treeshake?.excludeReplayShadowDOM) {
     defines.__RRWEB_EXCLUDE_SHADOW_DOM__ = true;
   }
 
-  if (userSentryOptions.webpack?.treeshake?.excludeReplayCompressionWorker) {
+  if (bundleSizeOptimizations?.excludeReplayWorker ?? treeshake?.excludeReplayCompressionWorker) {
     defines.__SENTRY_EXCLUDE_REPLAY_WORKER__ = true;
   }
 
+  return defines;
+}
+
+/**
+ * Sets up the tree-shaking flags based on the user's configuration.
+ */
+function setupTreeshakingFromConfig(
+  userSentryOptions: SentryBuildOptions,
+  newConfig: WebpackConfigObjectWithModuleRules,
+  buildContext: BuildContext,
+): void {
+  const defines = getTreeshakeDefines(userSentryOptions);
+
+  newConfig.plugins = newConfig.plugins || [];
+
   // Only add DefinePlugin if there are actual defines to set
   if (Object.keys(defines).length > 0) {
     newConfig.plugins.push(new buildContext.webpack.DefinePlugin(defines));
diff --git a/packages/nextjs/src/config/withSentryConfig/getFinalConfigObject.ts b/packages/nextjs/src/config/withSentryConfig/getFinalConfigObject.ts
index 7e6e33682af8..fb1b9f616aeb 100644
--- a/packages/nextjs/src/config/withSentryConfig/getFinalConfigObject.ts
+++ b/packages/nextjs/src/config/withSentryConfig/getFinalConfigObject.ts
@@ -8,6 +8,7 @@ import {
   getWebpackPatch,
   maybeConstructTurbopackConfig,
   maybeEnableTurbopackSourcemaps,
+  maybeSetTurbopackTreeshakeDefines,
   maybeSetUpRunAfterProductionCompileHook,
   maybeWarnAboutUnsupportedRunAfterProductionCompileHook,
   maybeWarnAboutTurbopackModuleMetadata,
@@ -85,6 +86,7 @@ export function getFinalConfigObject(
   });
 
   maybeEnableTurbopackSourcemaps(incomingUserNextConfigObject, userSentryOptions, bundlerInfo);
+  maybeSetTurbopackTreeshakeDefines(incomingUserNextConfigObject, userSentryOptions, bundlerInfo);
 
   const buildTimeInstrumentation = resolveBuildTimeInstrumentationOption(userSentryOptions, bundlerInfo, nextJsVersion);
 
diff --git a/packages/nextjs/src/config/withSentryConfig/getFinalConfigObjectBundlerUtils.ts b/packages/nextjs/src/config/withSentryConfig/getFinalConfigObjectBundlerUtils.ts
index 76432027ae56..3e266a8fccb8 100644
--- a/packages/nextjs/src/config/withSentryConfig/getFinalConfigObjectBundlerUtils.ts
+++ b/packages/nextjs/src/config/withSentryConfig/getFinalConfigObjectBundlerUtils.ts
@@ -9,7 +9,7 @@ import type { RouteManifest } from '../manifest/types';
 import { constructTurbopackConfig } from '../turbopack';
 import type { NextConfigObject, SentryBuildOptions, TurbopackOptions } from '../types';
 import { detectActiveBundler, supportsProductionCompileHook, supportsTurbopackRuleCondition } from '../util';
-import { constructWebpackConfigFunction } from '../webpack';
+import { constructWebpackConfigFunction, getTreeshakeDefines } from '../webpack';
 import { DEFAULT_SERVER_EXTERNAL_PACKAGES } from './constants';
 import type { VercelCronsConfigResult } from './getFinalConfigObjectUtils';
 
@@ -353,6 +353,35 @@ export function getWebpackPatch({
   };
 }
 
+/**
+ * Applies the `bundleSizeOptimizations` flags to Turbopack builds through `compiler.define`.
+ *
+ * Note: this mutates `incomingUserNextConfigObject`.
+ */
+export function maybeSetTurbopackTreeshakeDefines(
+  incomingUserNextConfigObject: NextConfigObject,
+  userSentryOptions: SentryBuildOptions,
+  bundlerInfo: BundlerInfo,
+): void {
+  if (!bundlerInfo.isTurbopackSupported || !bundlerInfo.isTurbopack) {
+    return;
+  }
+
+  const defines = getTreeshakeDefines(userSentryOptions);
+  if (Object.keys(defines).length === 0) {
+    return;
+  }
+
+  incomingUserNextConfigObject.compiler = {
+    ...incomingUserNextConfigObject.compiler,
+    define: {
+      // Must stay booleans: Turbopack injects string values as string literals, so `'false'` would be truthy.
+      ...defines,
+      ...incomingUserNextConfigObject.compiler?.define,
+    },
+  };
+}
+
 /**
  * Returns the patch for adding turbopack config (if enabled and supported).
  */
diff --git a/packages/nextjs/src/edge/index.ts b/packages/nextjs/src/edge/index.ts
index 5e8fd6d3826b..b073b4822453 100644
--- a/packages/nextjs/src/edge/index.ts
+++ b/packages/nextjs/src/edge/index.ts
@@ -78,9 +78,10 @@ export function init(options: VercelEdgeOptions = {}): void {
   }
 
   if (!DEBUG_BUILD && options.debug) {
+    // TODO(v12): Remove the `webpack.treeshake` mention together with that option
     // eslint-disable-next-line no-console
     console.warn(
-      '[@sentry/nextjs] You have enabled `debug: true`, but Sentry debug logging was removed from your bundle (likely via `webpack.treeshake.removeDebugLogging: true`). Set that option to `false` to see Sentry debug output.',
+      '[@sentry/nextjs] You have enabled `debug: true`, but Sentry debug logging was removed from your bundle (likely via `bundleSizeOptimizations.excludeDebugStatements: true` or `webpack.treeshake.removeDebugLogging: true`). Set that option to `false` to see Sentry debug output.',
     );
   }
 
diff --git a/packages/nextjs/src/server/index.ts b/packages/nextjs/src/server/index.ts
index 856be94c7363..6dea488a7d9d 100644
--- a/packages/nextjs/src/server/index.ts
+++ b/packages/nextjs/src/server/index.ts
@@ -108,9 +108,10 @@ export function init(options: NodeOptions): NodeClient | undefined {
   }
 
   if (!DEBUG_BUILD && options.debug) {
+    // TODO(v12): Remove the `webpack.treeshake` mention together with that option
     // eslint-disable-next-line no-console
     console.warn(
-      '[@sentry/nextjs] You have enabled `debug: true`, but Sentry debug logging was removed from your bundle (likely via `webpack.treeshake.removeDebugLogging: true`). Set that option to `false` to see Sentry debug output.',
+      '[@sentry/nextjs] You have enabled `debug: true`, but Sentry debug logging was removed from your bundle (likely via `bundleSizeOptimizations.excludeDebugStatements: true` or `webpack.treeshake.removeDebugLogging: true`). Set that option to `false` to see Sentry debug output.',
     );
   }
 
diff --git a/packages/nextjs/test/config/webpack/constructWebpackConfig.test.ts b/packages/nextjs/test/config/webpack/constructWebpackConfig.test.ts
index 3e224c76947f..bab62624c86a 100644
--- a/packages/nextjs/test/config/webpack/constructWebpackConfig.test.ts
+++ b/packages/nextjs/test/config/webpack/constructWebpackConfig.test.ts
@@ -543,6 +543,41 @@ describe('constructWebpackConfigFunction()', () => {
       expect(treeshakePlugin.definitions.__SENTRY_EXCLUDE_REPLAY_WORKER__).toBe(true);
     });
 
+    it('adds flags from the top-level bundleSizeOptimizations option', async () => {
+      vi.spyOn(coreServer, 'loadModule').mockImplementation(() => ({
+        sentryWebpackPlugin: () => ({
+          _name: 'sentry-webpack-plugin',
+        }),
+      }));
+
+      const finalWebpackConfig = await materializeFinalWebpackConfig({
+        exportedNextConfig,
+        incomingWebpackConfig: serverWebpackConfig,
+        incomingWebpackBuildContext: serverBuildContext,
+        sentryBuildTimeOptions: {
+          bundleSizeOptimizations: {
+            excludeDebugStatements: true,
+            excludeTracing: true,
+            excludeReplayIframe: true,
+            excludeReplayShadowDom: true,
+            excludeReplayWorker: true,
+          },
+        },
+      });
+
+      const definePlugin = finalWebpackConfig.plugins?.find(
+        plugin => plugin.constructor.name === 'DefinePlugin' && plugin.definitions?.__SENTRY_TRACING__ !== undefined,
+      ) as any;
+
+      expect(definePlugin.definitions).toEqual({
+        __SENTRY_DEBUG__: false,
+        __SENTRY_TRACING__: false,
+        __RRWEB_EXCLUDE_IFRAME__: true,
+        __RRWEB_EXCLUDE_SHADOW_DOM__: true,
+        __SENTRY_EXCLUDE_REPLAY_WORKER__: true,
+      });
+    });
+
     it('does not add flags when treeshake options are false', async () => {
       vi.spyOn(coreServer, 'loadModule').mockImplementation(() => ({
         sentryWebpackPlugin: () => ({
diff --git a/packages/nextjs/test/config/withSentryConfig.test.ts b/packages/nextjs/test/config/withSentryConfig.test.ts
index 977bd4ae72ed..cc749732eb35 100644
--- a/packages/nextjs/test/config/withSentryConfig.test.ts
+++ b/packages/nextjs/test/config/withSentryConfig.test.ts
@@ -481,6 +481,65 @@ describe('withSentryConfig', () => {
     });
   });
 
+  describe('turbopack treeshake configuration', () => {
+    const originalTurbopack = process.env.TURBOPACK;
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+      process.env.TURBOPACK = originalTurbopack;
+    });
+
+    it('sets treeshake flags as boolean defines and keeps user defines', () => {
+      process.env.TURBOPACK = '1';
+      vi.spyOn(util, 'getNextjsVersion').mockReturnValue('16.0.0');
+
+      const finalConfig = materializeFinalNextConfig(
+        { ...exportedNextConfig, compiler: { define: { __SENTRY_DEBUG__: true, USER_FLAG: 'x' } } },
+        undefined,
+        { bundleSizeOptimizations: { excludeTracing: true, excludeDebugStatements: true } },
+      );
+
+      expect(finalConfig.compiler?.define).toEqual({
+        __SENTRY_TRACING__: false,
+        __SENTRY_DEBUG__: true,
+        USER_FLAG: 'x',
+      });
+    });
+
+    it('supports the webpack.treeshake option', () => {
+      process.env.TURBOPACK = '1';
+      vi.spyOn(util, 'getNextjsVersion').mockReturnValue('16.0.0');
+
+      const finalConfig = materializeFinalNextConfig({ ...exportedNextConfig }, undefined, {
+        webpack: { treeshake: { removeTracing: true } },
+      });
+
+      expect(finalConfig.compiler?.define).toEqual({ __SENTRY_TRACING__: false });
+    });
+
+    it('prefers bundleSizeOptimizations over the webpack.treeshake option', () => {
+      process.env.TURBOPACK = '1';
+      vi.spyOn(util, 'getNextjsVersion').mockReturnValue('16.0.0');
+
+      const finalConfig = materializeFinalNextConfig({ ...exportedNextConfig }, undefined, {
+        bundleSizeOptimizations: { excludeTracing: false },
+        webpack: { treeshake: { removeTracing: true } },
+      });
+
+      expect(finalConfig.compiler?.define).toBeUndefined();
+    });
+
+    it('does not set defines on webpack builds', () => {
+      delete process.env.TURBOPACK;
+
+      const finalConfig = materializeFinalNextConfig({ ...exportedNextConfig }, undefined, {
+        bundleSizeOptimizations: { excludeTracing: true },
+      });
+
+      expect(finalConfig.compiler?.define).toBeUndefined();
+    });
+  });
+
   describe('turbopack sourcemap configuration', () => {
     const originalTurbopack = process.env.TURBOPACK;
 

From d5c211d6fdc19e061b928cadb13b978e93675314 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Mon, 12 Oct 2026 11:26:07 +0200
Subject: [PATCH 57/84] fix(react-router): Respect custom default integrations
 (#25259)

The React Router Node SDK overwrites `defaultIntegrations`, so `false`,
`[]`, and custom arrays are ignored. Only generate the framework
defaults when the option is unset, matching the underlying Node SDK's
behavior.

Co-authored-by: Codex <codex@openai.com>
---
 packages/react-router/src/server/sdk.ts       |  2 +-
 packages/react-router/test/server/sdk.test.ts | 20 +++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/packages/react-router/src/server/sdk.ts b/packages/react-router/src/server/sdk.ts
index 63e77a1c7901..83ccc776348a 100644
--- a/packages/react-router/src/server/sdk.ts
+++ b/packages/react-router/src/server/sdk.ts
@@ -24,7 +24,7 @@ export function getDefaultReactRouterServerIntegrations(options: NodeOptions): I
 export function init(options: NodeOptions): NodeClient | undefined {
   const opts: NodeOptions = {
     ...options,
-    defaultIntegrations: getDefaultReactRouterServerIntegrations(options),
+    defaultIntegrations: options.defaultIntegrations ?? getDefaultReactRouterServerIntegrations(options),
   };
 
   DEBUG_BUILD && debug.log('Initializing SDK...');
diff --git a/packages/react-router/test/server/sdk.test.ts b/packages/react-router/test/server/sdk.test.ts
index 4489490dce0b..acc4edd8ad2a 100644
--- a/packages/react-router/test/server/sdk.test.ts
+++ b/packages/react-router/test/server/sdk.test.ts
@@ -46,6 +46,26 @@ describe('React Router server SDK', () => {
       expect(client).not.toBeUndefined();
     });
 
+    it.each([
+      { value: 'false', defaultIntegrations: false as const },
+      { value: 'an empty array', defaultIntegrations: [] },
+    ])('disables default integrations when set to $value', ({ defaultIntegrations }) => {
+      const client = reactRouterInit({ defaultIntegrations });
+
+      expect(client?.getOptions().integrations.map(integration => integration.name)).toEqual(['SpanStreaming']);
+    });
+
+    it('replaces default integrations with a custom array', () => {
+      const integration = { name: 'CustomIntegration' };
+
+      const client = reactRouterInit({ defaultIntegrations: [integration] });
+
+      expect(client?.getOptions().integrations.map(integration => integration.name)).toEqual([
+        'CustomIntegration',
+        'SpanStreaming',
+      ]);
+    });
+
     it('adds the low quality transactions filter integration by default', () => {
       const filterSpy = vi.spyOn(LowQualityModule, 'lowQualityTransactionsFilterIntegration');
 

From 37f012bdbbd9780e8b9b1edaf1fcb361fb8232f8 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Mon, 12 Oct 2026 11:34:38 +0200
Subject: [PATCH 58/84] fix(remix): Respect custom default integrations
 (#25258)

The Remix Node SDK overwrites `defaultIntegrations`, so `false`, `[]`,
and custom arrays are ignored. Only generate the framework defaults when
the option is unset, matching the underlying Node SDK's behavior.

Co-authored-by: Codex <codex@openai.com>
---
 packages/remix/src/server/sdk.ts         |  2 +-
 packages/remix/test/index.server.test.ts | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/packages/remix/src/server/sdk.ts b/packages/remix/src/server/sdk.ts
index 95b2922ddd96..a51f4dd21aba 100644
--- a/packages/remix/src/server/sdk.ts
+++ b/packages/remix/src/server/sdk.ts
@@ -32,7 +32,7 @@ export function init(options: RemixOptions): NodeClient | undefined {
     return existingClient;
   }
 
-  options.defaultIntegrations = getRemixDefaultIntegrations(options);
+  options.defaultIntegrations ??= getRemixDefaultIntegrations(options);
 
   const client = nodeInit(options);
 
diff --git a/packages/remix/test/index.server.test.ts b/packages/remix/test/index.server.test.ts
index dabba59e4956..7232dc355540 100644
--- a/packages/remix/test/index.server.test.ts
+++ b/packages/remix/test/index.server.test.ts
@@ -69,4 +69,24 @@ describe('Server init()', () => {
   it('returns client from init', () => {
     expect(init({})).not.toBeUndefined();
   });
+
+  it.each([
+    { value: 'false', defaultIntegrations: false as const },
+    { value: 'an empty array', defaultIntegrations: [] },
+  ])('disables default integrations when set to $value', ({ defaultIntegrations }) => {
+    const client = init({ defaultIntegrations });
+
+    expect(client?.getOptions().integrations.map(integration => integration.name)).toEqual(['SpanStreaming']);
+  });
+
+  it('replaces default integrations with a custom array', () => {
+    const integration = { name: 'CustomIntegration' };
+
+    const client = init({ defaultIntegrations: [integration] });
+
+    expect(client?.getOptions().integrations.map(integration => integration.name)).toEqual([
+      'CustomIntegration',
+      'SpanStreaming',
+    ]);
+  });
 });

From 0f33366db7917768a9ffdcbd8d64757a149c2f00 Mon Sep 17 00:00:00 2001
From: Nicolas Hrubec <nicolas.hrubec@outlook.com>
Date: Mon, 12 Oct 2026 12:46:32 +0200
Subject: [PATCH 59/84] test(node): Port basic and nested startSpan tests to
 streaming (#25214)

Exercise basic and nested span creation with the default streaming
lifecycle. Keep static counterparts for every suite, including basic
usage with children, to preserve transaction coverage.

Part of #24140

---------

Co-authored-by: GPT-6 <codex@openai.com>
---
 .../startSpan/basic-usage-static/scenario.ts  |  12 ++
 .../startSpan/basic-usage-static/test.ts      |  26 +++++
 .../with-children/scenario.ts                 |  29 +++++
 .../basic-usage-static/with-children/test.ts  | 108 ++++++++++++++++++
 .../startSpan/basic-usage/scenario.ts         |   1 -
 .../public-api/startSpan/basic-usage/test.ts  |  37 ++----
 .../with-children}/scenario.ts                |   1 -
 .../with-children}/test.ts                    |   4 +-
 .../with-nested-spans-static/scenario.ts      |  34 ++++++
 .../with-nested-spans-static/test.ts          |  47 ++++++++
 .../startSpan/with-nested-spans/scenario.ts   |   1 -
 .../startSpan/with-nested-spans/test.ts       |  57 ++++-----
 12 files changed, 295 insertions(+), 62 deletions(-)
 create mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/with-children/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/with-children/test.ts
 rename dev-packages/node-integration-tests/suites/public-api/startSpan/{basic-usage-streamed => basic-usage/with-children}/scenario.ts (96%)
 rename dev-packages/node-integration-tests/suites/public-api/startSpan/{basic-usage-streamed => basic-usage/with-children}/test.ts (98%)
 create mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans-static/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans-static/test.ts

diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/scenario.ts
new file mode 100644
index 000000000000..af9609ab863b
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/scenario.ts
@@ -0,0 +1,12 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
+
+Sentry.startSpan({ name: 'test_span' }, () => undefined);
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/test.ts
new file mode 100644
index 000000000000..d0b64a9393bb
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/test.ts
@@ -0,0 +1,26 @@
+import { SENTRY_SEGMENT_NAME_SOURCE } from '@sentry/conventions/attributes';
+import { afterAll, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('sends a manually started root span with source custom', async () => {
+  await createRunner(__dirname, 'scenario.ts')
+    .expect({
+      transaction: {
+        transaction: 'test_span',
+        transaction_info: { source: 'custom' },
+        contexts: {
+          trace: {
+            span_id: expect.any(String),
+            trace_id: expect.any(String),
+            data: { [SENTRY_SEGMENT_NAME_SOURCE]: 'custom' },
+          },
+        },
+      },
+    })
+    .start()
+    .completed();
+});
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/with-children/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/with-children/scenario.ts
new file mode 100644
index 000000000000..3e43091b62c8
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/with-children/scenario.ts
@@ -0,0 +1,29 @@
+import * as Sentry from '@sentry/node';
+import { SENTRY_LINK_TYPE } from '@sentry/conventions/attributes';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+  release: '1.0.0',
+});
+
+Sentry.startSpan({ name: 'test-span', op: 'test' }, segmentSpan => {
+  Sentry.startSpan({ name: 'test-child-span', op: 'test-child' }, () => {
+    // noop
+  });
+
+  const inactiveSpan = Sentry.startInactiveSpan({
+    name: 'test-inactive-span',
+    links: [{ context: segmentSpan.spanContext(), attributes: { [SENTRY_LINK_TYPE]: 'some_relation' } }],
+  });
+  inactiveSpan.end();
+
+  Sentry.startSpanManual({ name: 'test-manual-span' }, span => {
+    span.end();
+  });
+});
+
+void Sentry.flush();
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/with-children/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/with-children/test.ts
new file mode 100644
index 000000000000..9ddbf4f7e629
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-static/with-children/test.ts
@@ -0,0 +1,108 @@
+import { SDK_VERSION, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '@sentry/core';
+import { SENTRY_LINK_TYPE, SENTRY_OP, SENTRY_ORIGIN, SENTRY_SEGMENT_NAME_SOURCE } from '@sentry/conventions/attributes';
+import { expect, test } from 'vitest';
+import { EXPECTED_SDK_NAME } from '../../../../../utils';
+import { assertSentryTransaction } from '../../../../../utils/assertions';
+import { createRunner } from '../../../../../utils/runner';
+
+test('sends a transaction envelope with correct envelope header', async () => {
+  await createRunner(__dirname, 'scenario.ts')
+    .expectHeader({
+      transaction: {
+        sent_at: expect.any(String),
+        sdk: {
+          name: EXPECTED_SDK_NAME,
+          version: SDK_VERSION,
+        },
+        trace: expect.objectContaining({
+          public_key: 'public',
+          sample_rate: '1',
+          sampled: 'true',
+          trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+          transaction: 'test-span',
+        }),
+      },
+    })
+    .start()
+    .completed();
+});
+
+test('sends a transaction with correct spans for a manually started span with children', async () => {
+  await createRunner(__dirname, 'scenario.ts')
+    .expect({
+      transaction: transaction => {
+        const rootSpanId = transaction.contexts?.trace?.span_id;
+        const traceId = transaction.contexts?.trace?.trace_id;
+
+        assertSentryTransaction(transaction, {
+          transaction: 'test-span',
+          transaction_info: { source: 'custom' },
+          release: '1.0.0',
+          environment: 'production',
+          sdk: { name: EXPECTED_SDK_NAME, version: SDK_VERSION },
+          contexts: {
+            trace: {
+              span_id: expect.stringMatching(/^[\da-f]{16}$/),
+              trace_id: expect.stringMatching(/^[\da-f]{32}$/),
+              op: 'test',
+              origin: 'manual',
+              status: 'ok',
+              data: {
+                [SENTRY_OP]: 'test',
+                [SENTRY_ORIGIN]: 'manual',
+                [SENTRY_SEGMENT_NAME_SOURCE]: 'custom',
+                [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
+              },
+            },
+          },
+        });
+
+        expect(transaction.spans).toEqual([
+          {
+            description: 'test-child-span',
+            op: 'test-child',
+            origin: 'manual',
+            data: { [SENTRY_OP]: 'test-child', [SENTRY_ORIGIN]: 'manual' },
+            parent_span_id: rootSpanId,
+            trace_id: traceId,
+            span_id: expect.stringMatching(/^[\da-f]{16}$/),
+            start_timestamp: expect.any(Number),
+            timestamp: expect.any(Number),
+            status: 'ok',
+          },
+          {
+            description: 'test-inactive-span',
+            origin: 'manual',
+            data: { [SENTRY_ORIGIN]: 'manual' },
+            parent_span_id: rootSpanId,
+            trace_id: traceId,
+            span_id: expect.stringMatching(/^[\da-f]{16}$/),
+            start_timestamp: expect.any(Number),
+            timestamp: expect.any(Number),
+            status: 'ok',
+            links: [
+              {
+                attributes: { [SENTRY_LINK_TYPE]: 'some_relation' },
+                sampled: true,
+                span_id: rootSpanId,
+                trace_id: traceId,
+              },
+            ],
+          },
+          {
+            description: 'test-manual-span',
+            origin: 'manual',
+            data: { [SENTRY_ORIGIN]: 'manual' },
+            parent_span_id: rootSpanId,
+            trace_id: traceId,
+            span_id: expect.stringMatching(/^[\da-f]{16}$/),
+            start_timestamp: expect.any(Number),
+            timestamp: expect.any(Number),
+            status: 'ok',
+          },
+        ]);
+      },
+    })
+    .start()
+    .completed();
+});
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/scenario.ts
index af9609ab863b..c2186df94b7f 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/scenario.ts
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/test.ts
index d616c04c457d..ad5143480748 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/test.ts
@@ -9,35 +9,14 @@ afterAll(() => {
 test('sends a manually started root span with source custom', async () => {
   await createRunner(__dirname, 'scenario.ts')
     .expect({
-      transaction: {
-        transaction: 'test_span',
-        transaction_info: { source: 'custom' },
-        contexts: {
-          trace: {
-            span_id: expect.any(String),
-            trace_id: expect.any(String),
-            data: { [SENTRY_SEGMENT_NAME_SOURCE]: 'custom' },
-          },
-        },
-      },
-    })
-    .start()
-    .completed();
-});
-
-test("doesn't change the name for manually started spans even if attributes triggering inference are set", async () => {
-  await createRunner(__dirname, 'scenario.ts')
-    .expect({
-      transaction: {
-        transaction: 'test_span',
-        transaction_info: { source: 'custom' },
-        contexts: {
-          trace: {
-            span_id: expect.any(String),
-            trace_id: expect.any(String),
-            data: { [SENTRY_SEGMENT_NAME_SOURCE]: 'custom' },
-          },
-        },
+      span: container => {
+        const segment = container.items.find(span => span.is_segment);
+        expect(segment?.name).toBe('test_span');
+        expect(segment?.span_id).toEqual(expect.any(String));
+        expect(segment?.trace_id).toEqual(expect.any(String));
+        expect(segment?.start_timestamp).toEqual(expect.any(Number));
+        expect(segment?.end_timestamp).toEqual(expect.any(Number));
+        expect(segment?.attributes[SENTRY_SEGMENT_NAME_SOURCE]).toEqual({ type: 'string', value: 'custom' });
       },
     })
     .start()
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-streamed/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/with-children/scenario.ts
similarity index 96%
rename from dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-streamed/scenario.ts
rename to dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/with-children/scenario.ts
index ce3f914d51b8..f84a5df779dd 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-streamed/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/with-children/scenario.ts
@@ -4,7 +4,6 @@ import { loggingTransport } from '@sentry-internal/node-integration-tests';
 Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   tracesSampleRate: 1.0,
-  traceLifecycle: 'stream',
   integrations: [Sentry.spanStreamingIntegration()],
   transport: loggingTransport,
   release: '1.0.0',
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-streamed/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/with-children/test.ts
similarity index 98%
rename from dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-streamed/test.ts
rename to dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/with-children/test.ts
index 87a40fa69b3f..f873cb97a41b 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage-streamed/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/basic-usage/with-children/test.ts
@@ -13,8 +13,8 @@ import {
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
 import { expect, test } from 'vitest';
-import { createRunner } from '../../../../utils/runner';
-import { EXPECTED_SDK_NAME } from '../../../../utils';
+import { createRunner } from '../../../../../utils/runner';
+import { EXPECTED_SDK_NAME } from '../../../../../utils';
 
 test('sends a streamed span envelope with correct envelope header', async () => {
   await createRunner(__dirname, 'scenario.ts')
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans-static/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans-static/scenario.ts
new file mode 100644
index 000000000000..c372394e37e5
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans-static/scenario.ts
@@ -0,0 +1,34 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+});
+
+Sentry.startSpan({ name: 'root_span' }, () => {
+  Sentry.startSpan(
+    {
+      name: 'span_1',
+      attributes: {
+        foo: 'bar',
+        baz: [1, 2, 3],
+      },
+    },
+    () => undefined,
+  );
+
+  // span_2 doesn't finish
+  Sentry.startInactiveSpan({ name: 'span_2' });
+
+  Sentry.startSpan({ name: 'span_3' }, () => {
+    // span_4 is the child of span_3 but doesn't finish.
+    Sentry.startInactiveSpan({ name: 'span_4', attributes: { qux: 'quux' } });
+
+    // span_5 is another child of span_3 but finishes.
+    Sentry.startSpan({ name: 'span_5' }, () => undefined);
+  });
+});
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans-static/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans-static/test.ts
new file mode 100644
index 000000000000..c01b837db5f7
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans-static/test.ts
@@ -0,0 +1,47 @@
+import type { SpanJSON } from '@sentry/core';
+import { afterAll, expect, test } from 'vitest';
+import { assertSentryTransaction } from '../../../../utils/assertions';
+import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('should report finished spans as children of the root transaction.', async () => {
+  await createRunner(__dirname, 'scenario.ts')
+    .expect({
+      transaction: transaction => {
+        const rootSpanId = transaction.contexts?.trace?.span_id;
+        const span3Id = transaction.spans?.[1]?.span_id;
+
+        expect(rootSpanId).toEqual(expect.any(String));
+        expect(span3Id).toEqual(expect.any(String));
+
+        assertSentryTransaction(transaction, {
+          transaction: 'root_span',
+          spans: [
+            {
+              description: 'span_1',
+              data: {
+                foo: 'bar',
+                baz: [1, 2, 3],
+              },
+              parent_span_id: rootSpanId,
+            },
+            {
+              description: 'span_3',
+              parent_span_id: rootSpanId,
+              data: {},
+            },
+            {
+              description: 'span_5',
+              parent_span_id: span3Id,
+              data: {},
+            },
+          ] as SpanJSON[],
+        });
+      },
+    })
+    .start()
+    .completed();
+});
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans/scenario.ts
index c372394e37e5..ce103213161b 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans/scenario.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans/scenario.ts
@@ -2,7 +2,6 @@ import * as Sentry from '@sentry/node';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({
-  traceLifecycle: 'static',
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   release: '1.0',
   tracesSampleRate: 1.0,
diff --git a/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans/test.ts b/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans/test.ts
index c01b837db5f7..2fe870bfba64 100644
--- a/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/startSpan/with-nested-spans/test.ts
@@ -1,45 +1,46 @@
-import type { SpanJSON } from '@sentry/core';
 import { afterAll, expect, test } from 'vitest';
-import { assertSentryTransaction } from '../../../../utils/assertions';
 import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
 
 afterAll(() => {
   cleanupChildProcesses();
 });
 
-test('should report finished spans as children of the root transaction.', async () => {
+test('should report finished spans as children of the root span.', async () => {
   await createRunner(__dirname, 'scenario.ts')
     .expect({
-      transaction: transaction => {
-        const rootSpanId = transaction.contexts?.trace?.span_id;
-        const span3Id = transaction.spans?.[1]?.span_id;
+      span: container => {
+        const segment = container.items.find(span => span.is_segment);
+        // Streamed spans arrive in completion order; compare the original creation order.
+        const spans = container.items
+          .filter(span => !span.is_segment)
+          .sort((a, b) => a.start_timestamp - b.start_timestamp);
+        const rootSpanId = segment?.span_id;
+        const span3Id = spans.find(span => span.name === 'span_3')?.span_id;
 
         expect(rootSpanId).toEqual(expect.any(String));
         expect(span3Id).toEqual(expect.any(String));
 
-        assertSentryTransaction(transaction, {
-          transaction: 'root_span',
-          spans: [
-            {
-              description: 'span_1',
-              data: {
-                foo: 'bar',
-                baz: [1, 2, 3],
-              },
-              parent_span_id: rootSpanId,
+        expect(segment?.name).toBe('root_span');
+        expect(segment?.start_timestamp).toEqual(expect.any(Number));
+        expect(segment?.end_timestamp).toEqual(expect.any(Number));
+        expect(spans).toMatchObject([
+          {
+            name: 'span_1',
+            attributes: {
+              foo: { type: 'string', value: 'bar' },
+              baz: { type: 'array', value: [1, 2, 3] },
             },
-            {
-              description: 'span_3',
-              parent_span_id: rootSpanId,
-              data: {},
-            },
-            {
-              description: 'span_5',
-              parent_span_id: span3Id,
-              data: {},
-            },
-          ] as SpanJSON[],
-        });
+            parent_span_id: rootSpanId,
+          },
+          {
+            name: 'span_3',
+            parent_span_id: rootSpanId,
+          },
+          {
+            name: 'span_5',
+            parent_span_id: span3Id,
+          },
+        ]);
       },
     })
     .start()

From b5a707da0808044c504cb4a53d3999c03a59988a Mon Sep 17 00:00:00 2001
From: Andrei <168741329+andreiborza@users.noreply.github.com>
Date: Mon, 12 Oct 2026 12:53:17 +0200
Subject: [PATCH 60/84] fix(core): Don't mark http client spans as errors when
 the caller aborts (#25260)

## What

Outgoing `node:http` spans no longer get an error status when the caller
aborts the request (for example with `AbortController.abort()`). If a
response already arrived, the span keeps the status of that response.

## Why

A caller abort is not a request failure, and it showed false
`http.client` errors (for example for axios cancellation). This matches
the fetch fix in #25129.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../integrations/http/client-subscriptions.ts | 16 +++-
 .../http/client-subscriptions.test.ts         | 84 ++++++++++++++++++-
 2 files changed, 98 insertions(+), 2 deletions(-)

diff --git a/packages/core/src/integrations/http/client-subscriptions.ts b/packages/core/src/integrations/http/client-subscriptions.ts
index e91da7a55ad0..554445eb8053 100644
--- a/packages/core/src/integrations/http/client-subscriptions.ts
+++ b/packages/core/src/integrations/http/client-subscriptions.ts
@@ -25,6 +25,7 @@ import {
 } from '../../tracing';
 import { startInactiveSpan } from '../../tracing/trace';
 import { debug } from '../../utils/debug-logger';
+import { isError } from '../../utils/is';
 import { LRUMap } from '../../utils/lru';
 import { getOutgoingRequestSpanData, setIncomingResponseSpanData } from './get-outgoing-span-data';
 import { getRequestUrlFromClientRequest } from './get-request-url';
@@ -141,18 +142,31 @@ export function getHttpClientSubscriptions(options: HttpInstrumentationOptions):
     const requestOnClose = () => endSpan({ code: SPAN_STATUS_UNSET });
     request.on('close', requestOnClose);
 
+    let responseStatusCode: number | undefined;
+
     request.on(errorMonitor, error => {
       DEBUG_BUILD && debug.log(LOG_PREFIX, 'outgoingRequest on request error()', error);
       if (breadcrumbs) {
         addBreadcrumbs(request, undefined);
       }
-      endSpan({ code: SPAN_STATUS_ERROR });
+      // An abort by the caller (e.g. `AbortController.abort()`) is not a failure of the request,
+      // so keep the status of the response if one arrived already.
+      if (isError(error) && error.name === 'AbortError') {
+        endSpan(
+          typeof responseStatusCode === 'number'
+            ? getSpanStatusFromHttpCode(responseStatusCode)
+            : { code: SPAN_STATUS_UNSET },
+        );
+      } else {
+        endSpan({ code: SPAN_STATUS_ERROR });
+      }
     });
 
     request.prependListener('response', response => {
       // no longer need this, listen on response now.
       // do not end the span until the response finishes
       request.removeListener('close', requestOnClose);
+      responseStatusCode = response.statusCode;
       if (request.listenerCount('response') <= 1) {
         response.resume();
       }
diff --git a/packages/core/test/lib/integrations/http/client-subscriptions.test.ts b/packages/core/test/lib/integrations/http/client-subscriptions.test.ts
index 62428d171605..74cf76467586 100644
--- a/packages/core/test/lib/integrations/http/client-subscriptions.test.ts
+++ b/packages/core/test/lib/integrations/http/client-subscriptions.test.ts
@@ -1,10 +1,17 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import * as http from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
 import * as breadcrumbModule from '../../../../src/integrations/http/add-outgoing-request-breadcrumb';
 import { HTTP_ON_CLIENT_REQUEST } from '../../../../src/integrations/http/constants';
 import { getHttpClientSubscriptions } from '../../../../src/integrations/http/client-subscriptions';
 import type { HttpClientRequest, HttpIncomingMessage } from '../../../../src/integrations/http/types';
 import { SUPPRESS_TRACING_KEY } from '../../../../src/tracing/constants';
 import { getCurrentScope, withScope } from '../../../../src/currentScopes';
+import { setCurrentClient } from '../../../../src/sdk';
+import { startSpan } from '../../../../src/tracing/trace';
+import { spanToJSON } from '../../../../src/utils/spanUtils';
+import type { SpanJSON } from '../../../../src/types/span';
+import { getDefaultTestClientOptions, TestClient } from '../../../mocks/client';
 
 function makeMockRequest(): HttpClientRequest & {
   _responseListeners: ((res: HttpIncomingMessage) => void)[];
@@ -109,4 +116,79 @@ describe('getHttpClientSubscriptions', () => {
       expect(spy).toHaveBeenCalledOnce();
     });
   });
+
+  describe('request errors', () => {
+    let server: http.Server;
+    let port: number;
+
+    beforeAll(async () => {
+      server = http.createServer((req, res) => {
+        res.writeHead(req.url === '/not-found' ? 404 : 200);
+        // Keep the body open so that the request can be aborted after the response arrived.
+        res.write('x');
+      });
+      await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+      port = (server.address() as AddressInfo).port;
+    });
+
+    afterAll(() => {
+      server.closeAllConnections();
+      server.close();
+    });
+
+    function makeRequest(
+      path: string,
+      abortAt: 'beforeResponse' | 'afterResponse' | 'destroyWithError',
+    ): Promise<SpanJSON> {
+      const client = new TestClient(getDefaultTestClientOptions({ tracesSampleRate: 1 }));
+      setCurrentClient(client);
+      client.init();
+
+      return new Promise(resolve => {
+        client.on('spanEnd', span => {
+          if (!spanToJSON(span).is_segment) {
+            resolve(spanToJSON(span));
+          }
+        });
+
+        const controller = new AbortController();
+        const request = http.request({ host: '127.0.0.1', port, path, signal: controller.signal });
+        startSpan({ name: 'parent' }, () => {
+          getHttpClientSubscriptions({})[HTTP_ON_CLIENT_REQUEST]({ request }, HTTP_ON_CLIENT_REQUEST);
+        });
+        request.on('error', () => {});
+        request.on('response', response => {
+          response.on('error', () => {});
+          response.once('data', () => {
+            if (abortAt === 'destroyWithError') {
+              request.destroy(new Error('boom'));
+            } else {
+              controller.abort();
+            }
+          });
+        });
+        if (abortAt === 'beforeResponse') {
+          controller.abort();
+        }
+        request.end();
+      });
+    }
+
+    it('does not set an error status when the request is aborted before the response', async () => {
+      const span = await makeRequest('/', 'beforeResponse');
+
+      expect(span.status).toBe('ok');
+    });
+
+    it('keeps the response status when the request is aborted after the response', async () => {
+      expect((await makeRequest('/', 'afterResponse')).status).toBe('ok');
+      expect((await makeRequest('/not-found', 'afterResponse')).status).toBe('error');
+    });
+
+    it('sets an error status when the request fails for another reason', async () => {
+      const span = await makeRequest('/', 'destroyWithError');
+
+      expect(span.status).toBe('error');
+    });
+  });
 });

From 15539092edb5a15ffad34e44a7a9d9a963855172 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Peer=20St=C3=B6cklmair?= <jan.peer@sentry.io>
Date: Mon, 12 Oct 2026 13:18:21 +0200
Subject: [PATCH 61/84] test(nextjs): Add vinext e2e tests (#25001)

part of #19514
part of JS-1803

This adds e2e tests for vinext. `nextjs-16` gets the optional variants
`nextjs-16 (vinext)` and `nextjs-16 (vinext, bun)`, which build the same
app with vinext and run the same suite. The new app `vinext-cf-workers`
covers vinext on Workers through the Vite plugin of
`@sentry/cloudflare`.

## Known issues

- No `openai` and `ioredis` spans: vinext does not run the build-time
loader of webpack or Turbopack.
- No component annotation and no third-party filter: vinext runs no
Sentry build plugin.
- No `fetch` spans on Bun: vinext keeps the `fetch` from before
`Sentry.init`.
- No Deno variant: on Deno, the `node:http` server of vinext leaks the
AsyncLocalStorage store between requests, also without Sentry.

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 dev-packages/e2e-tests/README.md              |  7 +-
 .../test-applications/nextjs-16/package.json  | 24 +++++-
 .../nextjs-16/playwright.config.mjs           |  8 +-
 .../nextjs-16/tests/auth-interrupts.test.ts   |  6 +-
 .../nextjs-16/tests/build-output.test.ts      |  3 +
 .../tests/component-annotation.test.ts        |  2 +
 .../nextjs-16/tests/db-page.test.ts           |  3 +
 .../nextjs-16/tests/isVinext.ts               |  1 +
 .../nextjs-16/tests/middleware.test.ts        |  5 ++
 .../nextjs-16/tests/openai.test.ts            |  3 +
 .../nextjs-16/tests/propagation.test.ts       | 13 ++-
 .../tests/server-action-redirect.test.ts      |  8 +-
 .../tests/third-party-filter.test.ts          |  2 +
 .../nextjs-16/vite.config.mts                 | 12 +++
 ...wrangler.jsonc => wrangler.opennext.jsonc} |  2 +
 .../vinext-cf-workers/.gitignore              |  4 +
 .../vinext-cf-workers/next.config.ts          |  5 ++
 .../vinext-cf-workers/package.json            | 38 +++++++++
 .../vinext-cf-workers/playwright.config.mjs   |  6 ++
 .../vinext-cf-workers/sentry.server.config.ts | 10 +++
 .../src/app/api/hello/route.ts                |  5 ++
 .../src/app/api/throw/route.ts                |  5 ++
 .../vinext-cf-workers/src/app/layout.tsx      |  7 ++
 .../vinext-cf-workers/src/app/page.tsx        |  3 +
 .../src/app/parameterized/[id]/page.tsx       |  6 ++
 .../vinext-cf-workers/src/instrumentation.ts  |  9 +++
 .../vinext-cf-workers/start-event-proxy.mjs   |  6 ++
 .../vinext-cf-workers/tests/errors.test.ts    | 27 +++++++
 .../tests/server-spans.test.ts                | 80 +++++++++++++++++++
 .../vinext-cf-workers/tsconfig.json           | 15 ++++
 .../vinext-cf-workers/vite.config.ts          | 14 ++++
 .../vinext-cf-workers/worker/index.ts         |  3 +
 .../worker/instrument.server.ts               |  7 ++
 .../vinext-cf-workers/wrangler.jsonc          | 12 +++
 34 files changed, 352 insertions(+), 9 deletions(-)
 create mode 100644 dev-packages/e2e-tests/test-applications/nextjs-16/tests/isVinext.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/nextjs-16/vite.config.mts
 rename dev-packages/e2e-tests/test-applications/nextjs-16/{wrangler.jsonc => wrangler.opennext.jsonc} (84%)
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/.gitignore
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/next.config.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/package.json
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/playwright.config.mjs
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/sentry.server.config.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/api/hello/route.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/api/throw/route.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/layout.tsx
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/page.tsx
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/parameterized/[id]/page.tsx
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/instrumentation.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/start-event-proxy.mjs
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/tests/errors.test.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/tests/server-spans.test.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/tsconfig.json
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/vite.config.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/worker/index.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/worker/instrument.server.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/vinext-cf-workers/wrangler.jsonc

diff --git a/dev-packages/e2e-tests/README.md b/dev-packages/e2e-tests/README.md
index 096dfa4f1b91..824784c63492 100644
--- a/dev-packages/e2e-tests/README.md
+++ b/dev-packages/e2e-tests/README.md
@@ -172,8 +172,11 @@ is the reference setup.
   `withSentry` and reads the init options from `instrument.server.ts` next to the entry. The start command runs
   `wrangler dev` on the build output. Code at module scope must not do I/O (for example open a database connection),
   because workerd does not allow it. `nextjs-16` has no Vite build: its Cloudflare variant builds with
-  `opennextjs-cloudflare build` and wraps the generated Worker in `worker.ts` with `withSentry` from
-  `@sentry/nextjs/cloudflare`.
+  `opennextjs-cloudflare build --config wrangler.opennext.jsonc` and wraps the generated Worker in `worker.ts` with
+  `withSentry` from `@sentry/nextjs/cloudflare`.
+- **Build flavors**: a variant can also build the same app with another tool, for example `nextjs-16 (vinext)` builds
+  `nextjs-16` with vinext. A build flavor is not a runtime: its assert script sets its own env var (`VINEXT=1`, read by
+  `tests/isVinext.ts`). It sets `runtime` only to run on another runtime, for example `nextjs-16 (vinext, bun)`.
 - **Runtime-specific files**: a file that has the runtime as a part of its name replaces the existing file without that
   part, for example `app/entry.server.cloudflare.tsx` replaces `app/entry.server.tsx` and `vite.cloudflare.config.ts`
   replaces `vite.config.ts`. For a variant with `runtime`, the runner copies these files over the others in the
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/package.json b/dev-packages/e2e-tests/test-applications/nextjs-16/package.json
index 3bb7511d8197..0415c053a37e 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/package.json
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/package.json
@@ -21,9 +21,11 @@
     "test:build-canary-webpack": "pnpm install && pnpm add next@canary && pnpm build-webpack",
     "test:assert": "pnpm test:prod && pnpm test:dev",
     "test:assert-webpack": "pnpm test:prod && pnpm test:dev-webpack",
-    "test:build:cloudflare": "pnpm install && opennextjs-cloudflare build",
-    "test:build-latest:cloudflare": "pnpm install && pnpm add next@16.3 && opennextjs-cloudflare build",
-    "start:cloudflare": "opennextjs-cloudflare preview --var \"E2E_TEST_DSN:$E2E_TEST_DSN\""
+    "test:build:cloudflare": "pnpm install && opennextjs-cloudflare build --config wrangler.opennext.jsonc",
+    "test:build-latest:cloudflare": "pnpm install && pnpm add next@16.3 && opennextjs-cloudflare build --config wrangler.opennext.jsonc",
+    "start:cloudflare": "opennextjs-cloudflare preview --config wrangler.opennext.jsonc --var \"E2E_TEST_DSN:$E2E_TEST_DSN\"",
+    "test:build:vinext": "pnpm install && pnpm add react@19.3.0 react-dom@19.3.0 && npm pkg set type=module && vinext build",
+    "test:assert:vinext": "VINEXT=1 pnpm test:prod"
   },
   "//": "Pin `ioredis` to 5.10.1: it's the last version before the driver publishes its own native diagnostics channels; orchestrion's config covers `ioredis <5.11.0`.",
   "dependencies": {
@@ -53,7 +55,12 @@
     "@types/react-dom": "^19",
     "eslint": "^9",
     "eslint-config-next": "^16",
+    "@vitejs/plugin-react": "^6.1.1",
+    "@vitejs/plugin-rsc": "^0.5.35",
+    "react-server-dom-webpack": "^19.3.0",
     "typescript": "^5",
+    "vinext": "^1.0.1",
+    "vite": "^8.3.0",
     "wrangler": "^4.61.0"
   },
   "volta": {
@@ -109,6 +116,17 @@
         "assert-command": "pnpm test:prod",
         "deno-version": "v2.9.0",
         "label": "nextjs-16 (deno)"
+      },
+      {
+        "build-command": "pnpm test:build:vinext",
+        "assert-command": "pnpm test:assert:vinext",
+        "label": "nextjs-16 (vinext)"
+      },
+      {
+        "runtime": "bun",
+        "build-command": "pnpm test:build:vinext",
+        "assert-command": "pnpm test:assert:vinext",
+        "label": "nextjs-16 (vinext, bun)"
       }
     ]
   }
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/playwright.config.mjs b/dev-packages/e2e-tests/test-applications/nextjs-16/playwright.config.mjs
index 7e356d81488b..0d18ae12efc4 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/playwright.config.mjs
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/playwright.config.mjs
@@ -12,6 +12,12 @@ const productionStartCommands = {
   cloudflare: 'pnpm start:cloudflare --port 3030',
 };
 
+// The `nextjs-16 (vinext)` variants build the app with vinext instead of Next.js.
+const vinextStartCommands = {
+  node: 'node ./node_modules/vinext/dist/cli.js start --port 3030',
+  bun: 'bun --bun ./node_modules/vinext/dist/cli.js start --port 3030',
+};
+
 const getStartCommand = () => {
   if (testEnv === 'development-webpack') {
     return 'pnpm next dev -p 3030 --webpack 2>&1 | tee .tmp_dev_server_logs';
@@ -22,7 +28,7 @@ const getStartCommand = () => {
   }
 
   if (testEnv === 'production') {
-    return productionStartCommands[getRuntime()];
+    return (process.env.VINEXT ? vinextStartCommands : productionStartCommands)[getRuntime()];
   }
 
   throw new Error(`Unknown test env: ${testEnv}`);
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/auth-interrupts.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/auth-interrupts.test.ts
index a24f6e2c7108..67a72a799522 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/auth-interrupts.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/auth-interrupts.test.ts
@@ -1,5 +1,6 @@
 import { expect, test } from '@playwright/test';
 import { collectStreamedSpansUntilSegment, waitForError, waitForStreamedSpan } from '@sentry-internal/test-utils';
+import { isVinext } from './isVinext';
 
 const cases = [
   { kind: 'forbidden', label: 'Forbidden', status: 403, statusMessage: 'permission_denied' },
@@ -35,7 +36,8 @@ for (const { kind, label, status, statusMessage } of cases) {
     expect(segmentSpan.attributes['http.response.status_code']?.value).toBe(status);
 
     // Server components are only wrapped by our webpack loader, so only webpack builds set a status on the render span.
-    if (!segmentSpan.attributes['turbopack']) {
+    // vinext builds with neither webpack nor Turbopack.
+    if (!segmentSpan.attributes['turbopack'] && !isVinext) {
       expect(spans).toContainEqual(
         expect.objectContaining({
           name: `render route (app) /auth-interrupts/${kind}`,
@@ -51,6 +53,8 @@ for (const { kind, label, status, statusMessage } of cases) {
   });
 
   test(`Does not capture ${kind}() in a server action and marks the action span`, async ({ page }) => {
+    test.skip(isVinext, `vinext rethrows ${kind}() of a server action in the browser, where it is an uncaught error`);
+
     const errorPromise = waitForAuthInterruptError(status);
     const spanPromise = waitForStreamedSpan('nextjs-16', span => {
       return span.name === `${kind}ServerAction` && span.is_segment;
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/build-output.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/build-output.test.ts
index 8c8ed57fc7f9..cc3dfde118af 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/build-output.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/build-output.test.ts
@@ -3,6 +3,9 @@ import { findAbsolutePathImports } from '@sentry-internal/test-utils';
 import * as fs from 'fs';
 import * as path from 'path';
 import { isDevMode } from './isDevMode';
+import { isVinext } from './isVinext';
+
+test.skip(isVinext, 'Checks the build output of Next.js');
 
 test('emits no absolute-path imports into the server output', () => {
   const leaks = findAbsolutePathImports({ outputDir: path.join(process.cwd(), '.next', 'server') });
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/component-annotation.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/component-annotation.test.ts
index 02e3a006bfdc..f32e7c5a1036 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/component-annotation.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/component-annotation.test.ts
@@ -1,9 +1,11 @@
 import { expect, test } from '@playwright/test';
 import { waitForError } from '@sentry-internal/test-utils';
+import { isVinext } from './isVinext';
 
 const isWebpackDev = process.env.TEST_ENV === 'development-webpack';
 
 test('React component annotation adds data-sentry-component attributes (Turbopack)', async ({ page }) => {
+  test.skip(isVinext, 'vinext runs no Sentry build plugin, so components get no annotation');
   test.skip(isWebpackDev, 'Only relevant for Turbopack builds');
 
   await page.goto('/component-annotation');
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/db-page.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/db-page.test.ts
index e155b1bed5a1..6a64528b3fc4 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/db-page.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/db-page.test.ts
@@ -1,5 +1,6 @@
 import { expect, test } from '@playwright/test';
 import { collectStreamedSpansUntilSegment, getRuntime } from '@sentry-internal/test-utils';
+import { isVinext } from './isVinext';
 
 // pg is externalized, so the runtime module hook instruments it.
 test('Instruments pg calls made during server-side rendering of a page', async ({ page }) => {
@@ -29,6 +30,8 @@ test('Instruments pg calls made during server-side rendering of a page', async (
 
 // ioredis is bundle-safe and allowlisted, so the build-time loader instruments it.
 test('Instruments ioredis calls made during server-side rendering of a page', async ({ page }) => {
+  test.skip(isVinext, 'vinext does not run the build-time loader of webpack or Turbopack');
+
   // The db spans are children of the segment span, which ends last.
   const spansPromise = collectStreamedSpansUntilSegment('nextjs-16', 'GET /db-page');
 
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/isVinext.ts b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/isVinext.ts
new file mode 100644
index 000000000000..5ae7f7a2fa79
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/isVinext.ts
@@ -0,0 +1 @@
+export const isVinext = !!process.env.VINEXT;
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/middleware.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/middleware.test.ts
index d3b3b3dcd05c..b4063c5be7dd 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/middleware.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/middleware.test.ts
@@ -7,6 +7,7 @@ import {
   waitForStreamedSpan,
 } from '@sentry-internal/test-utils';
 import { isDevMode } from './isDevMode';
+import { isVinext } from './isVinext';
 
 test('Should create a span for middleware', async ({ request }) => {
   test.skip(getRuntime() === 'cloudflare', 'On Workers the middleware span is a child of the request span');
@@ -121,6 +122,10 @@ test('Faulty middlewares inside the request segment of the Worker', async ({ req
 
 test('Should trace outgoing fetch requests inside middleware', async ({ request }) => {
   test.skip(isDevMode, 'The fetch requests ends up in a separate tx in dev atm');
+  test.skip(
+    isVinext && getRuntime() === 'bun',
+    'vinext replaces `globalThis.fetch` with a wrapper of the `fetch` from before `Sentry.init`, so `@sentry/bun` creates no fetch spans',
+  );
 
   // Only Node.js has the undici diagnostics channel. On the other runtimes the fetch integration of the runtime
   // SDK creates this span, which has no `sentry.kind`, `url.path` and `url.scheme`.
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/openai.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/openai.test.ts
index 1ebc4f6db104..0ea958dfa173 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/openai.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/openai.test.ts
@@ -1,5 +1,8 @@
 import { expect, test } from '@playwright/test';
 import { waitForStreamedSpans } from '@sentry-internal/test-utils';
+import { isVinext } from './isVinext';
+
+test.skip(isVinext, 'vinext does not run the webpack or Turbopack loader that injects the OpenAI channel');
 
 // gen_ai spans are emitted as a separate span-v2 envelope item (not inline on the transaction), so we
 // assert on the streamed spans. Attribute values are wrapped as `{ value, type }` in the v2 format.
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/propagation.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/propagation.test.ts
index e758cd769551..1dbf47a45b10 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/propagation.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/propagation.test.ts
@@ -1,7 +1,13 @@
 import { expect, test } from '@playwright/test';
-import { collectStreamedSpans, getSpanOp, waitForStreamedSpan } from '@sentry-internal/test-utils';
+import { collectStreamedSpans, getRuntime, getSpanOp, waitForStreamedSpan } from '@sentry-internal/test-utils';
+import { isVinext } from './isVinext';
 
 test('Propagates trace for outgoing fetch requests', async ({ baseURL, request }) => {
+  test.skip(
+    isVinext && getRuntime() === 'bun',
+    'vinext replaces `globalThis.fetch` with a wrapper of the `fetch` from before `Sentry.init`, so `@sentry/bun` creates no fetch spans',
+  );
+
   // Inbound span, outbound span and the http.client span in between all share one trace, and
   // `collectStreamedSpans` evaluates a single trace at a time, so requiring all three together
   // keeps them paired.
@@ -47,6 +53,11 @@ test('Does not propagate outgoing fetch requests not covered by tracePropagation
   baseURL,
   request,
 }) => {
+  test.skip(
+    isVinext && getRuntime() === 'bun',
+    'vinext replaces `globalThis.fetch` with a wrapper of the `fetch` from before `Sentry.init`, so nothing propagates and the test would check nothing',
+  );
+
   // These two spans are deliberately in different traces, so they are matched by their unique names.
   const inboundSpanPromise = waitForStreamedSpan('nextjs-16', span => {
     return span.name === 'GET /propagation/test-outgoing-fetch-external-disallowed/check' && span.is_segment;
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/server-action-redirect.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/server-action-redirect.test.ts
index 3ebe985701f4..0f87aa1e33fe 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/server-action-redirect.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/server-action-redirect.test.ts
@@ -1,7 +1,13 @@
 import { expect, test } from '@playwright/test';
-import { waitForError, waitForStreamedSpan } from '@sentry-internal/test-utils';
+import { getRuntime, waitForError, waitForStreamedSpan } from '@sentry-internal/test-utils';
+import { isVinext } from './isVinext';
 
 test('Should handle server action redirect without capturing errors', async ({ page, request }) => {
+  test.skip(
+    isVinext && getRuntime() === 'bun',
+    'Server actions of vinext fail on Bun 1.3.14 with `ReadableStream is locked`, also without Sentry',
+  );
+
   // Wait for the initial pageload span
   const pageLoadSpanPromise = waitForStreamedSpan('nextjs-16', span => {
     return span.name === '/redirect/origin' && span.is_segment;
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/third-party-filter.test.ts b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/third-party-filter.test.ts
index faa081a43765..a89a8cf6645d 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/tests/third-party-filter.test.ts
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/tests/third-party-filter.test.ts
@@ -1,9 +1,11 @@
 import test, { expect } from '@playwright/test';
 import { waitForError } from '@sentry-internal/test-utils';
+import { isVinext } from './isVinext';
 
 const isWebpackDev = process.env.TEST_ENV === 'development-webpack';
 
 test('First-party error with React frames should not be tagged as third-party code', async ({ page }) => {
+  test.skip(isVinext, 'vinext runs no Sentry build plugin, so the filter has no module metadata of first-party frames');
   test.skip(isWebpackDev, 'Only relevant for Turbopack builds');
 
   const errorPromise = waitForError('nextjs-16', errorEvent => {
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/vite.config.mts b/dev-packages/e2e-tests/test-applications/nextjs-16/vite.config.mts
new file mode 100644
index 000000000000..06fc7d855003
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/vite.config.mts
@@ -0,0 +1,12 @@
+import vinext from 'vinext';
+import { defineConfig } from 'vite';
+
+// Only for the `nextjs-16 (vinext)` variants, which build this app with vinext instead of Next.js. Their build command
+// sets `"type": "module"`, because `vinext start` does not find the `.mjs` server files that Vite writes otherwise, and
+// React 19.3, because vinext needs React 19.2.6 or newer.
+export default defineConfig({
+  plugins: [vinext()],
+  // `app/api/d1` imports `@opennextjs/cloudflare` for the OpenNext variants. Its `import()` of a computed specifier can
+  // not be bundled.
+  environments: { rsc: { resolve: { external: ['@opennextjs/cloudflare'] } } },
+});
diff --git a/dev-packages/e2e-tests/test-applications/nextjs-16/wrangler.jsonc b/dev-packages/e2e-tests/test-applications/nextjs-16/wrangler.opennext.jsonc
similarity index 84%
rename from dev-packages/e2e-tests/test-applications/nextjs-16/wrangler.jsonc
rename to dev-packages/e2e-tests/test-applications/nextjs-16/wrangler.opennext.jsonc
index f6bfe6a4ec38..1ecc0cf8aa24 100644
--- a/dev-packages/e2e-tests/test-applications/nextjs-16/wrangler.jsonc
+++ b/dev-packages/e2e-tests/test-applications/nextjs-16/wrangler.opennext.jsonc
@@ -1,3 +1,5 @@
+// Not `wrangler.jsonc`: vinext refuses to build without the Cloudflare plugin when the project root has a wrangler
+// config, and the `nextjs-16 (vinext)` variants build this app for Node.js and Bun.
 {
   "$schema": "node_modules/wrangler/config-schema.json",
   "name": "nextjs-16",
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/.gitignore b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/.gitignore
new file mode 100644
index 000000000000..3f64191fe034
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/.gitignore
@@ -0,0 +1,4 @@
+dist
+.wrangler
+test-results
+pnpm-lock.yaml
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/next.config.ts b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/next.config.ts
new file mode 100644
index 000000000000..b22af960af49
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/next.config.ts
@@ -0,0 +1,5 @@
+import type { NextConfig } from 'next';
+
+const nextConfig: NextConfig = {};
+
+export default nextConfig;
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/package.json b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/package.json
new file mode 100644
index 000000000000..e86b3a9e72cc
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/package.json
@@ -0,0 +1,38 @@
+{
+  "name": "vinext-cf-workers",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "vinext build",
+    "preview": "wrangler dev --config dist/server/wrangler.json --port 3030 --var \"E2E_TEST_DSN:$E2E_TEST_DSN\" --log-level=$(test $CI && echo 'none' || echo 'log')",
+    "test": "playwright test",
+    "test:build": "pnpm install && pnpm build",
+    "test:assert": "pnpm test"
+  },
+  "dependencies": {
+    "@sentry/cloudflare": "file:../../packed/sentry-cloudflare-packed.tgz",
+    "@sentry/nextjs": "file:../../packed/sentry-nextjs-packed.tgz",
+    "next": "16.3.8",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0"
+  },
+  "devDependencies": {
+    "@cloudflare/vite-plugin": "^1.56.0",
+    "@playwright/test": "~1.63.0",
+    "@sentry-internal/test-utils": "link:../../../test-utils",
+    "@types/node": "^26.1.2",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.1.1",
+    "@vitejs/plugin-rsc": "^0.5.35",
+    "react-server-dom-webpack": "^19.3.0",
+    "typescript": "~6.0.3",
+    "vinext": "^1.0.1",
+    "vite": "^8.3.0",
+    "wrangler": "^4.135.0"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  }
+}
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/playwright.config.mjs b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/playwright.config.mjs
new file mode 100644
index 000000000000..3dfd688a7130
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/playwright.config.mjs
@@ -0,0 +1,6 @@
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+
+export default getPlaywrightConfig({
+  startCommand: 'pnpm preview',
+  port: 3030,
+});
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/sentry.server.config.ts b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/sentry.server.config.ts
new file mode 100644
index 000000000000..99a220fa3b4e
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/sentry.server.config.ts
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/nextjs';
+
+// The server config of a Next.js app. vinext runs it in the Worker too, where this `init` creates no client, because
+// `withSentry` from `@sentry/nextjs/cloudflare` (added by the Vite plugin) already handles the request. The tests
+// check that no event carries this environment.
+Sentry.init({
+  dsn: process.env.E2E_TEST_DSN,
+  environment: 'init-must-not-run',
+  tracesSampleRate: 1.0,
+});
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/api/hello/route.ts b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/api/hello/route.ts
new file mode 100644
index 000000000000..ba30786d3857
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/api/hello/route.ts
@@ -0,0 +1,5 @@
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+  return Response.json({ message: 'Hello from vinext' });
+}
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/api/throw/route.ts b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/api/throw/route.ts
new file mode 100644
index 000000000000..7ffd4bcd0bf1
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/api/throw/route.ts
@@ -0,0 +1,5 @@
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+  throw new Error('Route handler error from vinext');
+}
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/layout.tsx b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/layout.tsx
new file mode 100644
index 000000000000..f3ef34cd8b91
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/layout.tsx
@@ -0,0 +1,7 @@
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/page.tsx b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/page.tsx
new file mode 100644
index 000000000000..6c121ed6c135
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/page.tsx
@@ -0,0 +1,3 @@
+export default function Page() {
+  return <p>vinext on Cloudflare Workers</p>;
+}
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/parameterized/[id]/page.tsx b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/parameterized/[id]/page.tsx
new file mode 100644
index 000000000000..52149eaba2ec
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/app/parameterized/[id]/page.tsx
@@ -0,0 +1,6 @@
+export const dynamic = 'force-dynamic';
+
+export default async function Page({ params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return <p>Parameterized page {id}</p>;
+}
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/instrumentation.ts b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/instrumentation.ts
new file mode 100644
index 000000000000..39f8e4ef935c
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/src/instrumentation.ts
@@ -0,0 +1,9 @@
+import * as Sentry from '@sentry/nextjs';
+
+export async function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    await import('../sentry.server.config');
+  }
+}
+
+export const onRequestError = Sentry.captureRequestError;
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/start-event-proxy.mjs b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/start-event-proxy.mjs
new file mode 100644
index 000000000000..1c2735871430
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/start-event-proxy.mjs
@@ -0,0 +1,6 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+  port: 3031,
+  proxyServerName: 'vinext-cf-workers',
+});
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/tests/errors.test.ts b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/tests/errors.test.ts
new file mode 100644
index 000000000000..388585d84e26
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/tests/errors.test.ts
@@ -0,0 +1,27 @@
+import { expect, test } from '@playwright/test';
+import { collectStreamedSpansUntilSegment, waitForError } from '@sentry-internal/test-utils';
+
+test('Captures a route handler error in the trace of the request', async ({ request }) => {
+  const errorPromise = waitForError('vinext-cf-workers', event => {
+    return event.exception?.values?.[0]?.value === 'Route handler error from vinext';
+  });
+  const spansPromise = collectStreamedSpansUntilSegment('vinext-cf-workers', 'GET /api/throw');
+
+  const response = await request.get('/api/throw');
+  expect(response.status()).toBe(500);
+
+  const errorEvent = await errorPromise;
+  const spans = await spansPromise;
+  const segmentSpan = spans.find(span => span.is_segment)!;
+
+  expect(errorEvent.sdk?.name).toBe('sentry.javascript.nextjs');
+  // `sentry.server.config.ts` sets another environment, so the client of `withSentry` sent the event.
+  expect(errorEvent.environment).toBe('qa');
+  expect(errorEvent.transaction).toBe('GET /api/throw');
+  expect(errorEvent.exception?.values?.[0]?.mechanism).toEqual({
+    handled: false,
+    type: 'auto.function.nextjs.on_request_error',
+  });
+  expect(errorEvent.contexts?.trace?.trace_id).toBe(segmentSpan.trace_id);
+  expect(segmentSpan.status).toBe('error');
+});
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/tests/server-spans.test.ts b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/tests/server-spans.test.ts
new file mode 100644
index 000000000000..4251dbc7656f
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/tests/server-spans.test.ts
@@ -0,0 +1,80 @@
+import { expect, test } from '@playwright/test';
+import { collectStreamedSpans, getSpanOp } from '@sentry-internal/test-utils';
+
+test('Sends the Next.js spans of a page in the request span of the Worker', async ({ request }) => {
+  const spansPromise = collectStreamedSpans(
+    'vinext-cf-workers',
+    spans =>
+      spans.some(span => span.is_segment && span.name === 'GET /parameterized/[id]') &&
+      spans.some(span => span.name === 'render route (app) /parameterized/[id]'),
+  );
+
+  await request.get('/parameterized/42');
+
+  const spans = await spansPromise;
+  const segmentSpan = spans.find(span => span.is_segment)!;
+  const renderSpan = spans.find(span => span.name === 'render route (app) /parameterized/[id]')!;
+
+  expect(spans.filter(span => span.is_segment)).toEqual([segmentSpan]);
+  expect(spans.filter(span => getSpanOp(span) === 'http.server')).toEqual([segmentSpan]);
+  expect(segmentSpan.name).toBe('GET /parameterized/[id]');
+  expect(segmentSpan.attributes['sentry.op']?.value).toBe('http.server');
+  expect(segmentSpan.attributes['sentry.origin']?.value).toBe('auto.http.cloudflare');
+  expect(segmentSpan.attributes['sentry.segment.name.source']?.value).toBe('route');
+  expect(segmentSpan.attributes['http.route']?.value).toBe('/parameterized/[id]');
+  expect(segmentSpan.attributes['http.response.status_code']?.value).toBe(200);
+  expect(renderSpan.attributes['sentry.segment.id']?.value).toBe(segmentSpan.span_id);
+});
+
+test('Sends the Next.js spans of a route handler in the request span of the Worker', async ({ request }) => {
+  const spansPromise = collectStreamedSpans(
+    'vinext-cf-workers',
+    spans =>
+      spans.some(span => span.is_segment && span.name === 'GET /api/hello') &&
+      spans.some(span => span.name === 'executing api route (app) /api/hello'),
+  );
+
+  await request.get('/api/hello');
+
+  const spans = await spansPromise;
+  const segmentSpan = spans.find(span => span.is_segment)!;
+  const handlerSpan = spans.find(span => span.name === 'executing api route (app) /api/hello')!;
+
+  expect(spans.filter(span => span.is_segment)).toEqual([segmentSpan]);
+  expect(spans.filter(span => getSpanOp(span) === 'http.server')).toEqual([segmentSpan]);
+  expect(segmentSpan.name).toBe('GET /api/hello');
+  expect(segmentSpan.attributes['sentry.origin']?.value).toBe('auto.http.cloudflare');
+  expect(segmentSpan.attributes['http.route']?.value).toBe('/api/hello');
+  expect(segmentSpan.attributes['http.response.status_code']?.value).toBe(200);
+  expect(handlerSpan.attributes['sentry.segment.id']?.value).toBe(segmentSpan.span_id);
+});
+
+test('Continues an incoming trace in the request span of the Worker', async ({ request }) => {
+  const traceId = crypto.randomUUID().replace(/-/g, '');
+  const parentSpanId = traceId.slice(0, 16);
+
+  const spansPromise = collectStreamedSpans(
+    'vinext-cf-workers',
+    spans =>
+      spans.some(span => span.trace_id === traceId && span.is_segment) &&
+      spans.some(span => span.trace_id === traceId && span.name === 'render route (app) /parameterized/[id]'),
+  );
+
+  await request.get('/parameterized/42', {
+    headers: {
+      'sentry-trace': `${traceId}-${parentSpanId}-1`,
+      baggage: `sentry-trace_id=${traceId},sentry-sample_rate=1,sentry-sampled=true`,
+    },
+  });
+
+  const spans = await spansPromise;
+  const segmentSpan = spans.find(span => span.trace_id === traceId && span.is_segment)!;
+  const renderSpan = spans.find(
+    span => span.trace_id === traceId && span.name === 'render route (app) /parameterized/[id]',
+  )!;
+
+  expect(spans.filter(span => span.trace_id === traceId && span.is_segment)).toEqual([segmentSpan]);
+  expect(segmentSpan.parent_span_id).toBe(parentSpanId);
+  expect(segmentSpan.attributes['sentry.origin']?.value).toBe('auto.http.cloudflare');
+  expect(renderSpan.attributes['sentry.segment.id']?.value).toBe(segmentSpan.span_id);
+});
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/tsconfig.json b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/tsconfig.json
new file mode 100644
index 000000000000..dfca71828f01
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/tsconfig.json
@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "worker/**/*", "vite.config.ts", "next.config.ts", "sentry.server.config.ts"]
+}
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/vite.config.ts b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/vite.config.ts
new file mode 100644
index 000000000000..6bab8f3b5d74
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/vite.config.ts
@@ -0,0 +1,14 @@
+import { cloudflare } from '@cloudflare/vite-plugin';
+import { sentryCloudflareVitePlugin } from '@sentry/cloudflare/vite';
+import vinext from 'vinext';
+import { defineConfig } from 'vite';
+
+// `worker/index.ts` contains no Sentry calls: in a vinext build the plugin wraps it with `withSentry` from
+// `@sentry/nextjs/cloudflare`.
+export default defineConfig({
+  plugins: [
+    vinext(),
+    cloudflare({ viteEnvironment: { name: 'rsc', childEnvironments: ['ssr'] } }),
+    sentryCloudflareVitePlugin(),
+  ],
+});
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/worker/index.ts b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/worker/index.ts
new file mode 100644
index 000000000000..7b164a4bf115
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/worker/index.ts
@@ -0,0 +1,3 @@
+import handler from 'vinext/server/fetch-handler';
+
+export default handler;
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/worker/instrument.server.ts b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/worker/instrument.server.ts
new file mode 100644
index 000000000000..dbae8f3fa0b7
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/worker/instrument.server.ts
@@ -0,0 +1,7 @@
+// The Vite plugin uses the default export of this file, next to the Worker entry, as the options callback.
+export default (env: { E2E_TEST_DSN: string }) => ({
+  dsn: env.E2E_TEST_DSN,
+  environment: 'qa',
+  tunnel: 'http://localhost:3031/',
+  tracesSampleRate: 1.0,
+});
diff --git a/dev-packages/e2e-tests/test-applications/vinext-cf-workers/wrangler.jsonc b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/wrangler.jsonc
new file mode 100644
index 000000000000..6e2a5b691e8d
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/vinext-cf-workers/wrangler.jsonc
@@ -0,0 +1,12 @@
+{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "vinext-cf-workers",
+  "main": "./worker/index.ts",
+  "compatibility_date": "2026-09-19",
+  "compatibility_flags": ["nodejs_compat"],
+  "assets": {
+    "directory": "dist/client",
+    "not_found_handling": "none",
+    "binding": "ASSETS",
+  },
+}

From 12a84a9504a51bea00edaf22907ab3bed41191c3 Mon Sep 17 00:00:00 2001
From: Andrei <168741329+andreiborza@users.noreply.github.com>
Date: Mon, 12 Oct 2026 13:27:48 +0200
Subject: [PATCH 62/84] chore(deps): Bump `@sentry/conventions` to 0.27.0
 (#25264)

## What

Bumps `@sentry/conventions` to 0.27.0 in all packages. Span data does
not change. The SDK still sends `gen_ai.evaluate`.

## Why

0.27.0 adds `gen_ai.decide` and deprecates `gen_ai.evaluate`. The
integration rename tickets need this release.

Closes: #25248

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 dev-packages/browser-integration-tests/package.json       | 2 +-
 dev-packages/cloudflare-integration-tests/package.json    | 2 +-
 .../e2e-tests/test-applications/angular-19/package.json   | 2 +-
 .../test-applications/cloudflare-pi-durable/package.json  | 2 +-
 .../e2e-tests/test-applications/node-mastra/package.json  | 2 +-
 .../test-applications/node-pi-durable/package.json        | 2 +-
 .../test-applications/nuxt-4-static/package.json          | 2 +-
 .../test-applications/solidstart-static/package.json      | 2 +-
 dev-packages/node-integration-tests/package.json          | 2 +-
 packages/angular/package.json                             | 2 +-
 packages/astro/package.json                               | 2 +-
 packages/aws-serverless/package.json                      | 2 +-
 packages/browser-utils/package.json                       | 2 +-
 packages/browser/package.json                             | 2 +-
 packages/bun/package.json                                 | 2 +-
 packages/cloudflare/package.json                          | 2 +-
 packages/core/package.json                                | 2 +-
 packages/deno/package.json                                | 2 +-
 packages/effect/package.json                              | 2 +-
 packages/elysia/package.json                              | 2 +-
 packages/ember/package.json                               | 2 +-
 packages/google-cloud-serverless/package.json             | 2 +-
 packages/hono/package.json                                | 2 +-
 packages/nestjs/package.json                              | 2 +-
 packages/nextjs/package.json                              | 2 +-
 packages/nitro/package.json                               | 2 +-
 packages/node/package.json                                | 2 +-
 packages/nuxt/package.json                                | 2 +-
 packages/opentelemetry/package.json                       | 2 +-
 packages/react-router/package.json                        | 2 +-
 packages/react/package.json                               | 2 +-
 packages/remix/package.json                               | 2 +-
 packages/server-utils/package.json                        | 2 +-
 packages/server-utils/src/ai/mastra/constants.ts          | 1 +
 packages/server-utils/src/ai/typesafe/index.ts            | 1 +
 .../src/integrations/vercel-ai/vercel-ai-dc-subscriber.ts | 1 +
 packages/solid/package.json                               | 2 +-
 packages/solidstart/package.json                          | 2 +-
 packages/svelte/package.json                              | 2 +-
 packages/sveltekit/package.json                           | 2 +-
 packages/tanstackstart-react/package.json                 | 2 +-
 packages/vue/package.json                                 | 2 +-
 yarn.lock                                                 | 8 ++++----
 43 files changed, 46 insertions(+), 43 deletions(-)

diff --git a/dev-packages/browser-integration-tests/package.json b/dev-packages/browser-integration-tests/package.json
index 6259df274c7d..febc4eb2057e 100644
--- a/dev-packages/browser-integration-tests/package.json
+++ b/dev-packages/browser-integration-tests/package.json
@@ -63,7 +63,7 @@
     "@sentry/browser": "11.6.0",
     "@sentry/replay": "11.6.0",
     "@sentry/opentelemetry": "11.6.0",
-    "@sentry/conventions": "0.26.0",
+    "@sentry/conventions": "0.27.0",
     "@supabase/supabase-js": "2.109.0",
     "axios": "1.20.0",
     "babel-loader": "^10.1.1",
diff --git a/dev-packages/cloudflare-integration-tests/package.json b/dev-packages/cloudflare-integration-tests/package.json
index e23bcc9abcf6..60680efc8d12 100644
--- a/dev-packages/cloudflare-integration-tests/package.json
+++ b/dev-packages/cloudflare-integration-tests/package.json
@@ -35,7 +35,7 @@
     "@cloudflare/workers-types": "^4.20260426.0",
     "@cloudflare/workers-types-v5": "npm:@cloudflare/workers-types@5.20260710.1",
     "@sentry-internal/test-utils": "11.6.0",
-    "@sentry/conventions": "0.26.0",
+    "@sentry/conventions": "0.27.0",
     "eslint-plugin-regexp": "^3.1.0",
     "prisma": "6.15.0",
     "vite": "^8.3.1",
diff --git a/dev-packages/e2e-tests/test-applications/angular-19/package.json b/dev-packages/e2e-tests/test-applications/angular-19/package.json
index 04bef8b8f52d..7300ee33c2ee 100644
--- a/dev-packages/e2e-tests/test-applications/angular-19/package.json
+++ b/dev-packages/e2e-tests/test-applications/angular-19/package.json
@@ -36,7 +36,7 @@
     "@angular/cli": "^19.0.0",
     "@angular/compiler-cli": "^19.0.0",
     "@playwright/test": "~1.63.0",
-    "@sentry/conventions": "0.26.0",
+    "@sentry/conventions": "0.27.0",
     "@sentry-internal/test-utils": "link:../../../test-utils",
     "@sentry/core": "file:../../packed/sentry-core-packed.tgz",
     "@types/jasmine": "~5.1.0",
diff --git a/dev-packages/e2e-tests/test-applications/cloudflare-pi-durable/package.json b/dev-packages/e2e-tests/test-applications/cloudflare-pi-durable/package.json
index 5f172858bcf4..6699912023e6 100644
--- a/dev-packages/e2e-tests/test-applications/cloudflare-pi-durable/package.json
+++ b/dev-packages/e2e-tests/test-applications/cloudflare-pi-durable/package.json
@@ -22,7 +22,7 @@
     "@cloudflare/workers-types": "^4.20260426.0",
     "@playwright/test": "~1.63.0",
     "@sentry-internal/test-utils": "link:../../../test-utils",
-    "@sentry/conventions": "0.26.0",
+    "@sentry/conventions": "0.27.0",
     "typescript": "^5.5.2",
     "vite": "7.3.5",
     "wrangler": "^4.136.2"
diff --git a/dev-packages/e2e-tests/test-applications/node-mastra/package.json b/dev-packages/e2e-tests/test-applications/node-mastra/package.json
index 592a00860591..a00ed28ea209 100644
--- a/dev-packages/e2e-tests/test-applications/node-mastra/package.json
+++ b/dev-packages/e2e-tests/test-applications/node-mastra/package.json
@@ -28,7 +28,7 @@
   "devDependencies": {
     "@playwright/test": "~1.56.0",
     "@sentry-internal/test-utils": "link:../../../test-utils",
-    "@sentry/conventions": "0.26.0",
+    "@sentry/conventions": "0.27.0",
     "@types/node": "24.x",
     "mastra": "~1.28.0",
     "typescript": "~5.9.0"
diff --git a/dev-packages/e2e-tests/test-applications/node-pi-durable/package.json b/dev-packages/e2e-tests/test-applications/node-pi-durable/package.json
index baadb930e355..eb9822667b3a 100644
--- a/dev-packages/e2e-tests/test-applications/node-pi-durable/package.json
+++ b/dev-packages/e2e-tests/test-applications/node-pi-durable/package.json
@@ -19,7 +19,7 @@
   "devDependencies": {
     "@playwright/test": "~1.63.0",
     "@sentry-internal/test-utils": "link:../../../test-utils",
-    "@sentry/conventions": "0.26.0",
+    "@sentry/conventions": "0.27.0",
     "@sentry/core": "file:../../packed/sentry-core-packed.tgz",
     "@types/node": "24.x"
   },
diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4-static/package.json b/dev-packages/e2e-tests/test-applications/nuxt-4-static/package.json
index d1ac621c81c2..9e7ef0d268ca 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-4-static/package.json
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4-static/package.json
@@ -26,7 +26,7 @@
   },
   "devDependencies": {
     "@playwright/test": "~1.63.0",
-    "@sentry/conventions": "0.26.0",
+    "@sentry/conventions": "0.27.0",
     "@sentry-internal/test-utils": "link:../../../test-utils"
   },
   "volta": {
diff --git a/dev-packages/e2e-tests/test-applications/solidstart-static/package.json b/dev-packages/e2e-tests/test-applications/solidstart-static/package.json
index 70257bef6fcc..07a2d29457f8 100644
--- a/dev-packages/e2e-tests/test-applications/solidstart-static/package.json
+++ b/dev-packages/e2e-tests/test-applications/solidstart-static/package.json
@@ -18,7 +18,7 @@
   },
   "devDependencies": {
     "@playwright/test": "~1.63.0",
-    "@sentry/conventions": "0.26.0",
+    "@sentry/conventions": "0.27.0",
     "@sentry-internal/test-utils": "link:../../../test-utils",
     "@solidjs/meta": "^0.29.4",
     "@solidjs/router": "^1.0.0",
diff --git a/dev-packages/node-integration-tests/package.json b/dev-packages/node-integration-tests/package.json
index bceba2da19d0..a8a0a474448a 100644
--- a/dev-packages/node-integration-tests/package.json
+++ b/dev-packages/node-integration-tests/package.json
@@ -110,7 +110,7 @@
   "devDependencies": {
     "@neondatabase/serverless": "1.2.0",
     "@opentelemetry/instrumentation-http": "0.220.0",
-    "@sentry/conventions": "0.26.0",
+    "@sentry/conventions": "0.27.0",
     "@sentry-internal/test-utils": "11.6.0",
     "@types/amqplib": "^0.10.5",
     "@types/node-cron": "^3.0.11",
diff --git a/packages/angular/package.json b/packages/angular/package.json
index 20e25a27ce96..c077d93a73a1 100644
--- a/packages/angular/package.json
+++ b/packages/angular/package.json
@@ -23,7 +23,7 @@
   "dependencies": {
     "@sentry/browser": "11.6.0",
     "@sentry/core": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "tslib": "^2.4.1"
   },
   "devDependencies": {
diff --git a/packages/astro/package.json b/packages/astro/package.json
index e02c63560dd9..c96c3e06914b 100644
--- a/packages/astro/package.json
+++ b/packages/astro/package.json
@@ -53,7 +53,7 @@
   "dependencies": {
     "@sentry/browser": "11.6.0",
     "@sentry/core": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/node": "11.6.0",
     "@sentry/server-runtime-injection": "11.6.0",
     "@sentry/server-utils": "11.6.0",
diff --git a/packages/aws-serverless/package.json b/packages/aws-serverless/package.json
index 196fcea178ea..0cb3571f40cd 100644
--- a/packages/aws-serverless/package.json
+++ b/packages/aws-serverless/package.json
@@ -56,7 +56,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/node": "11.6.0",
     "@sentry/server-runtime-injection": "11.6.0",
diff --git a/packages/browser-utils/package.json b/packages/browser-utils/package.json
index cb071cb94da1..62d898ba4939 100644
--- a/packages/browser-utils/package.json
+++ b/packages/browser-utils/package.json
@@ -34,7 +34,7 @@
   },
   "dependencies": {
     "@sentry/core": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "web-vitals": "^6.2.3"
   },
   "scripts": {
diff --git a/packages/browser/package.json b/packages/browser/package.json
index 2ae998915e74..7906d2e1e2bc 100644
--- a/packages/browser/package.json
+++ b/packages/browser/package.json
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@sentry/browser-utils": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/feedback": "11.6.0",
     "@sentry/replay": "11.6.0",
     "@sentry/replay-canvas": "11.6.0",
diff --git a/packages/bun/package.json b/packages/bun/package.json
index 4953d3803e31..8d11865d2f80 100644
--- a/packages/bun/package.json
+++ b/packages/bun/package.json
@@ -43,7 +43,7 @@
   },
   "dependencies": {
     "@sentry/core": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/node": "11.6.0",
     "@sentry/server-utils": "11.6.0"
   },
diff --git a/packages/cloudflare/package.json b/packages/cloudflare/package.json
index 573610f22421..3de31a5d7c05 100644
--- a/packages/cloudflare/package.json
+++ b/packages/cloudflare/package.json
@@ -53,7 +53,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/opentelemetry": "11.6.0",
     "@sentry/server-utils": "11.6.0",
diff --git a/packages/core/package.json b/packages/core/package.json
index eabf0c88292d..3f698e523e15 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -94,6 +94,6 @@
     "zod": "^3.24.1"
   },
   "dependencies": {
-    "@sentry/conventions": "^0.26.0"
+    "@sentry/conventions": "^0.27.0"
   }
 }
diff --git a/packages/deno/package.json b/packages/deno/package.json
index 99dcec12e7c6..d6dccd25c390 100644
--- a/packages/deno/package.json
+++ b/packages/deno/package.json
@@ -28,7 +28,7 @@
   ],
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/server-runtime-injection": "11.6.0",
     "@sentry/server-utils": "11.6.0"
diff --git a/packages/effect/package.json b/packages/effect/package.json
index 17214f1fabc4..9902b933b1ae 100644
--- a/packages/effect/package.json
+++ b/packages/effect/package.json
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@sentry/browser": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/node": "11.6.0"
   },
diff --git a/packages/elysia/package.json b/packages/elysia/package.json
index f081ee4535b9..6200c9ed8f25 100644
--- a/packages/elysia/package.json
+++ b/packages/elysia/package.json
@@ -34,7 +34,7 @@
   "dependencies": {
     "@sentry/bun": "11.6.0",
     "@sentry/core": "11.6.0",
-    "@sentry/conventions": "^0.26.0"
+    "@sentry/conventions": "^0.27.0"
   },
   "peerDependencies": {
     "elysia": "^1.4.0"
diff --git a/packages/ember/package.json b/packages/ember/package.json
index 56fb955332dd..bba9c6548491 100644
--- a/packages/ember/package.json
+++ b/packages/ember/package.json
@@ -45,7 +45,7 @@
     "@embroider/addon-shim": "^1.10.2",
     "@embroider/macros": "^1.20.2",
     "@sentry/browser": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "decorator-transforms": "^2.3.2"
   },
diff --git a/packages/google-cloud-serverless/package.json b/packages/google-cloud-serverless/package.json
index caebc772ceff..aa87081b11d8 100644
--- a/packages/google-cloud-serverless/package.json
+++ b/packages/google-cloud-serverless/package.json
@@ -36,7 +36,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/node": "11.6.0",
     "@sentry/server-runtime-injection": "11.6.0",
diff --git a/packages/hono/package.json b/packages/hono/package.json
index 7250993bac6c..86fc469730f1 100644
--- a/packages/hono/package.json
+++ b/packages/hono/package.json
@@ -74,7 +74,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@sentry/core": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/server-utils": "11.6.0"
   },
   "peerDependencies": {
diff --git a/packages/nestjs/package.json b/packages/nestjs/package.json
index 85e37778195a..5f03e2bdeae0 100644
--- a/packages/nestjs/package.json
+++ b/packages/nestjs/package.json
@@ -44,7 +44,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/node": "11.6.0",
     "@sentry/server-utils": "11.6.0"
diff --git a/packages/nextjs/package.json b/packages/nextjs/package.json
index 3f556a0e9be7..9ba54ee74bcc 100644
--- a/packages/nextjs/package.json
+++ b/packages/nextjs/package.json
@@ -82,7 +82,7 @@
     "@sentry/browser-utils": "11.6.0",
     "@sentry/bundler-plugins": "11.6.0",
     "@sentry/cloudflare": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/node": "11.6.0",
     "@sentry/opentelemetry": "11.6.0",
diff --git a/packages/nitro/package.json b/packages/nitro/package.json
index 7112e0171ae7..0979cf66edeb 100644
--- a/packages/nitro/package.json
+++ b/packages/nitro/package.json
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@sentry/bundler-plugins": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/node": "11.6.0",
     "@sentry/server-runtime-injection": "11.6.0",
diff --git a/packages/node/package.json b/packages/node/package.json
index ef573c8cb1a6..ac04da1bd6a5 100644
--- a/packages/node/package.json
+++ b/packages/node/package.json
@@ -78,7 +78,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/opentelemetry": "11.6.0",
     "@sentry/server-runtime-injection": "11.6.0",
diff --git a/packages/nuxt/package.json b/packages/nuxt/package.json
index b5b642144827..cec27fc7cd2b 100644
--- a/packages/nuxt/package.json
+++ b/packages/nuxt/package.json
@@ -56,7 +56,7 @@
     "@nuxt/kit": "^4.6.0",
     "@sentry/browser": "11.6.0",
     "@sentry/cloudflare": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/node": "11.6.0",
     "@sentry/bundler-plugins": "11.6.0",
diff --git a/packages/opentelemetry/package.json b/packages/opentelemetry/package.json
index 8267fce22b3f..d36554496b75 100644
--- a/packages/opentelemetry/package.json
+++ b/packages/opentelemetry/package.json
@@ -27,7 +27,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0"
   },
   "peerDependencies": {
diff --git a/packages/react-router/package.json b/packages/react-router/package.json
index 600550bbaeb1..6e0958edb2b9 100644
--- a/packages/react-router/package.json
+++ b/packages/react-router/package.json
@@ -57,7 +57,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@sentry/browser": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/node": "11.6.0",
     "@sentry/react": "11.6.0",
diff --git a/packages/react/package.json b/packages/react/package.json
index 88ea5d38c475..b9dc0f81f1b2 100644
--- a/packages/react/package.json
+++ b/packages/react/package.json
@@ -59,7 +59,7 @@
   "dependencies": {
     "@sentry/browser": "11.6.0",
     "@sentry/core": "11.6.0",
-    "@sentry/conventions": "^0.26.0"
+    "@sentry/conventions": "^0.27.0"
   },
   "peerDependencies": {
     "react": "17.x || 18.x || 19.x",
diff --git a/packages/remix/package.json b/packages/remix/package.json
index 1840e6d97c55..bbc96f694b1e 100644
--- a/packages/remix/package.json
+++ b/packages/remix/package.json
@@ -78,7 +78,7 @@
     "@remix-run/router": "^1.23.4",
     "@sentry/browser": "11.6.0",
     "@sentry/bundler-plugins": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/node": "11.6.0",
     "@sentry/react": "11.6.0",
diff --git a/packages/server-utils/package.json b/packages/server-utils/package.json
index 92ccae7b686b..272fea7321b3 100644
--- a/packages/server-utils/package.json
+++ b/packages/server-utils/package.json
@@ -97,7 +97,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0"
   },
   "devDependencies": {
diff --git a/packages/server-utils/src/ai/mastra/constants.ts b/packages/server-utils/src/ai/mastra/constants.ts
index ab55142a2bf5..4873ca830cd4 100644
--- a/packages/server-utils/src/ai/mastra/constants.ts
+++ b/packages/server-utils/src/ai/mastra/constants.ts
@@ -42,6 +42,7 @@ export const SPAN_TYPE_OPS: Readonly<Record<string, { op: string; operationName:
   provider_tool_call: { op: GEN_AI_EXECUTE_TOOL, operationName: 'execute_tool' },
   client_tool_call: { op: GEN_AI_EXECUTE_TOOL, operationName: 'execute_tool' },
   rag_embedding: { op: GEN_AI_EMBEDDINGS, operationName: 'embeddings' },
+  // oxlint-disable-next-line typescript/no-deprecated -- the rename to `gen_ai.decide` comes in a follow-up
   classifier_evaluation: { op: GEN_AI_EVALUATE, operationName: 'evaluate' },
 };
 
diff --git a/packages/server-utils/src/ai/typesafe/index.ts b/packages/server-utils/src/ai/typesafe/index.ts
index 99280c6843ad..81dbdd666cd0 100644
--- a/packages/server-utils/src/ai/typesafe/index.ts
+++ b/packages/server-utils/src/ai/typesafe/index.ts
@@ -34,6 +34,7 @@ export function startEvaluateSpan(
 
   return startInactiveSpan({
     name: model ? `evaluate ${model}` : 'evaluate',
+    // oxlint-disable-next-line typescript/no-deprecated -- the rename to `gen_ai.decide` comes in a follow-up
     op: GEN_AI_EVALUATE,
     // Extra attributes (e.g. another integration's origin) are set at start, so samplers see them.
     attributes: { ...getRequestAttributes(params, model, recordInputs), ...attributes },
diff --git a/packages/server-utils/src/integrations/vercel-ai/vercel-ai-dc-subscriber.ts b/packages/server-utils/src/integrations/vercel-ai/vercel-ai-dc-subscriber.ts
index e9a75ade26b6..f28a718b88af 100644
--- a/packages/server-utils/src/integrations/vercel-ai/vercel-ai-dc-subscriber.ts
+++ b/packages/server-utils/src/integrations/vercel-ai/vercel-ai-dc-subscriber.ts
@@ -71,6 +71,7 @@ const ORIGIN = 'auto.vercelai.channel';
 const GEN_AI_OPERATION_SPAN_OPS = {
   embeddings: GEN_AI_EMBEDDINGS,
   rerank: GEN_AI_RERANK,
+  // oxlint-disable-next-line typescript/no-deprecated -- the rename to `gen_ai.decide` comes in a follow-up
   evaluate: GEN_AI_EVALUATE,
   invoke_agent: GEN_AI_INVOKE_AGENT,
   execute_tool: GEN_AI_EXECUTE_TOOL,
diff --git a/packages/solid/package.json b/packages/solid/package.json
index 188a9bb37fec..322700d1f0d1 100644
--- a/packages/solid/package.json
+++ b/packages/solid/package.json
@@ -56,7 +56,7 @@
   "dependencies": {
     "@sentry/browser": "11.6.0",
     "@sentry/core": "11.6.0",
-    "@sentry/conventions": "^0.26.0"
+    "@sentry/conventions": "^0.27.0"
   },
   "peerDependencies": {
     "@solidjs/router": ">=0.13.4 <2.0.0-0",
diff --git a/packages/solidstart/package.json b/packages/solidstart/package.json
index 3342b27bdaec..4bbf60109b7b 100644
--- a/packages/solidstart/package.json
+++ b/packages/solidstart/package.json
@@ -87,7 +87,7 @@
     "@sentry/server-utils": "11.6.0",
     "@sentry/solid": "11.6.0",
     "@sentry/bundler-plugins": "11.6.0",
-    "@sentry/conventions": "0.26.0"
+    "@sentry/conventions": "0.27.0"
   },
   "devDependencies": {
     "@solidjs/router": "^1.0.0",
diff --git a/packages/svelte/package.json b/packages/svelte/package.json
index c363e0597acd..4a12cda519ee 100644
--- a/packages/svelte/package.json
+++ b/packages/svelte/package.json
@@ -33,7 +33,7 @@
   },
   "dependencies": {
     "@sentry/browser": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "magic-string": "~0.30.0"
   },
diff --git a/packages/sveltekit/package.json b/packages/sveltekit/package.json
index 9fcd03d0779a..1cdb210a203f 100644
--- a/packages/sveltekit/package.json
+++ b/packages/sveltekit/package.json
@@ -73,7 +73,7 @@
     "@opentelemetry/api": "^1.9.1",
     "@sentry/cloudflare": "11.6.0",
     "@sentry/core": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/node": "11.6.0",
     "@sentry/server-runtime-injection": "11.6.0",
     "@sentry/server-utils": "11.6.0",
diff --git a/packages/tanstackstart-react/package.json b/packages/tanstackstart-react/package.json
index 14468c1b9525..9a695bba1656 100644
--- a/packages/tanstackstart-react/package.json
+++ b/packages/tanstackstart-react/package.json
@@ -53,7 +53,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@sentry/browser-utils": "11.6.0",
-    "@sentry/conventions": "^0.26.0",
+    "@sentry/conventions": "^0.27.0",
     "@sentry/core": "11.6.0",
     "@sentry/node": "11.6.0",
     "@sentry/react": "11.6.0",
diff --git a/packages/vue/package.json b/packages/vue/package.json
index 3840ccd0fa41..014ac2d16c46 100644
--- a/packages/vue/package.json
+++ b/packages/vue/package.json
@@ -46,7 +46,7 @@
   "dependencies": {
     "@sentry/browser": "11.6.0",
     "@sentry/core": "11.6.0",
-    "@sentry/conventions": "^0.26.0"
+    "@sentry/conventions": "^0.27.0"
   },
   "peerDependencies": {
     "@tanstack/vue-router": "^1.64.0",
diff --git a/yarn.lock b/yarn.lock
index e3968f4c67fe..0fb72c08a93a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -8024,10 +8024,10 @@
     "@angular-devkit/schematics" "14.2.13"
     jsonc-parser "3.1.0"
 
-"@sentry/conventions@0.26.0", "@sentry/conventions@^0.26.0":
-  version "0.26.0"
-  resolved "https://sfw.security.sentry.io/npm/@sentry/conventions/-/conventions-0.26.0.tgz#3da6c91e1c4e570914b998f8b4f97ab7e5144a23"
-  integrity sha512-ttSRcoLf2kIENDIFzH12aJaVMdxnidMYLvVNwEX/JjXfXaQot8u5M47QmgAFOOhVJ4nQ2uU8wTCh+fwSPrrCfg==
+"@sentry/conventions@0.27.0", "@sentry/conventions@^0.27.0":
+  version "0.27.0"
+  resolved "https://sfw.security.sentry.io/npm/@sentry/conventions/-/conventions-0.27.0.tgz#10a6a112d58347dfcf70d85d7a01e86f45a0ba2c"
+  integrity sha512-Mrqd/o7n/z7qWSYfQQA7x4fFTA0IqOG6JNsbBpnC97khPwZk7n6DPtOO7YgaYplSl8R8QLRbBz9Xv2lVhToSAg==
 
 "@sentry/node-cpu-profiler@^2.4.4":
   version "2.4.4"

From 203765ab514e7abf13bbf185bece79a1debb0f81 Mon Sep 17 00:00:00 2001
From: Charly Gomez <charly.gomez1310@gmail.com>
Date: Mon, 12 Oct 2026 13:31:43 +0200
Subject: [PATCH 63/84] test(browser): Register the LCP handlers in the bundle
 of the SDK (#25263)

Fixes a flaky test. The `handlers-lcp` test registered its LCP handlers
in a separate bundle, so they watched LCP through their own observer and
sometimes saw a different element than the SDK did on Linux CI. Now the
handlers are registered in the same bundle as the SDK, so they see
exactly what the SDK sees.

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../tracing/metrics/handlers-lcp/init.js      | 30 +++++++++++++++++++
 .../tracing/metrics/handlers-lcp/subject.js   | 19 +-----------
 2 files changed, 31 insertions(+), 18 deletions(-)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/init.js

diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/init.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/init.js
new file mode 100644
index 000000000000..05b690d85393
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/init.js
@@ -0,0 +1,30 @@
+import * as Sentry from '@sentry/browser';
+import { addLcpInstrumentationHandler } from '@sentry/browser-utils';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracesSampleRate: 1,
+});
+
+// Registered in the bundle of the SDK, so the handlers share its LCP observer. A second bundle gets
+// a copy of the instrumentation with an observer of its own, whose view of the LCP candidates can
+// differ from the SDK's (e.g. a different first-hidden time), which made this test flaky.
+addLcpInstrumentationHandler(({ metric }) => {
+  const entry = metric.entries[metric.entries.length - 1];
+  window._LCP = entry.size;
+});
+
+addLcpInstrumentationHandler(({ metric }) => {
+  const entry = metric.entries[metric.entries.length - 1];
+  window._LCP2 = entry.size;
+});
+
+window.ADD_HANDLER = () => {
+  addLcpInstrumentationHandler(({ metric }) => {
+    const entry = metric.entries[metric.entries.length - 1];
+    window._LCP3 = entry.size;
+  });
+};
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/subject.js b/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/subject.js
index 838e6e864414..d57faa5bc8b1 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/subject.js
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/handlers-lcp/subject.js
@@ -1,18 +1 @@
-import { addLcpInstrumentationHandler } from '@sentry/browser-utils';
-
-addLcpInstrumentationHandler(({ metric }) => {
-  const entry = metric.entries[metric.entries.length - 1];
-  window._LCP = entry.size;
-});
-
-addLcpInstrumentationHandler(({ metric }) => {
-  const entry = metric.entries[metric.entries.length - 1];
-  window._LCP2 = entry.size;
-});
-
-window.ADD_HANDLER = () => {
-  addLcpInstrumentationHandler(({ metric }) => {
-    const entry = metric.entries[metric.entries.length - 1];
-    window._LCP3 = entry.size;
-  });
-};
+// The handlers live in `init.js`, see there.

From 20c26f2e158af750cf67c7a921d840c4594d797b Mon Sep 17 00:00:00 2001
From: Henos D <henosd19@gmail.com>
Date: Mon, 12 Oct 2026 14:34:28 +0300
Subject: [PATCH 64/84] fix(node): Don't mark fetch spans as errors when the
 caller aborts (#25129)

A `fetch()` span that already got a 200 response ends up with `status:
error` when the caller cancels the body stream (`reader.cancel()`) or
calls `AbortController.abort()` after the headers arrived. undici
reports that as `undici:request:error` with an `AbortError` instead of
`undici:request:trailers`, and `onError` in the undici instrumentation
sets `SPAN_STATUS_ERROR` for every error.

This ports the check from upstream OpenTelemetry
(open-telemetry/opentelemetry-js-contrib#3488, "do not record aborted
requests as errors"): if the error is an `AbortError`, or a
`DOMException` with `ABORT_ERR`, the span is ended without touching its
status. Other errors (connection reset, `TypeError: fetch failed`, ...)
still set the error status as before. I updated the NOTE comment above
`onError` to say so.

This matters for clients that read a stream and then close it as part of
normal operation. For example the MCP TypeScript SDK closes its event
stream on client close, so every healthy session showed `http.client`
error spans.

## Repro

```js
import * as Sentry from "@sentry/node";
import { createServer } from "node:http";

Sentry.init({ dsn: "http://key@127.0.0.1:9/1", tracesSampleRate: 1,
  beforeSendSpan(s) { console.log(s.name ?? s.description, s.status); return s; } });

const srv = createServer((req, res) => {
  if (req.url === "/stream") { res.writeHead(200, { "content-type": "text/event-stream" }); res.write("data: 1\n\n"); return; }
  res.writeHead(200); res.end("ok");
});
await new Promise((r) => srv.listen(0, "127.0.0.1", r));
const base = `http://127.0.0.1:${srv.address().port}`;

await Sentry.startSpan({ name: "root" }, async () => {
  await (await fetch(base + "/plain")).text();                    // ok
  const r = (await fetch(base + "/stream")).body.getReader();
  await r.read(); await r.cancel();                                // error, although the response was 200
});
await Sentry.flush(2000); srv.closeAllConnections(); srv.close();
```

Before (11.4.0): the fully read request is `ok`, the cancelled one is
`error` with `http.response.status_code` 200. Same with
`AbortController.abort()` after the headers arrive.
After (this branch, built with `yarn build:dev:filter @sentry/node`):
both are `ok`.

## Tests

Added unit tests to `packages/node/test/integrations/undici.test.ts`
that publish the `undici:request:create`, `undici:request:headers` (200)
and `undici:request:error` diagnostics channel messages:

- abort errors (`AbortError`, `DOMException` named `AbortError`,
`DOMException` with only the `ABORT_ERR` code) end the span without an
error status
- control: a `TypeError` and an `ECONNRESET` error still set the error
status

`cd packages/node && yarn vitest run test/integrations/undici.test.ts`:
without the fix 3 of 10 fail (the abort cases), with the fix 10 of 10
pass. `oxfmt --check` and `oxlint --type-aware` are clean on both files.

- [x] If you've added code that should be tested, please add tests.
- [ ] Ensure your code lints and the test suite passes (`yarn lint`) &
(`yarn test`). (Ran the changed test file, oxfmt and oxlint on the
changed files; not the full suite.)
- [ ] Link an issue if there is one related to your pull request. (There
is none; this PR has the repro.)

Co-authored-by: Andrei <168741329+andreiborza@users.noreply.github.com>
---
 .../node-fetch/undici-instrumentation.ts      | 16 +++++-
 .../node/test/integrations/undici.test.ts     | 49 +++++++++++++++++++
 2 files changed, 63 insertions(+), 2 deletions(-)

diff --git a/packages/node/src/integrations/node-fetch/undici-instrumentation.ts b/packages/node/src/integrations/node-fetch/undici-instrumentation.ts
index 4b9f9f82324c..9d1617bbac9e 100644
--- a/packages/node/src/integrations/node-fetch/undici-instrumentation.ts
+++ b/packages/node/src/integrations/node-fetch/undici-instrumentation.ts
@@ -414,9 +414,10 @@ function onDone({ request }: RequestTrailersMessage): void {
 // This is the event we get when something is wrong in the request like
 // - invalid options when calling `fetch` global API or any undici method for request
 // - connectivity errors such as unreachable host
-// - requests aborted through an `AbortController.signal`
+// - requests aborted through an `AbortController.signal`, or a response body cancelled by the caller
 // NOTE: server errors are considered valid responses and it's the lib consumer
-// who should deal with that.
+// who should deal with that. Aborts initiated by the caller are not errors either, so they end the
+// span without an error status.
 function onError({ request, error }: RequestErrorMessage): void {
   const span = spanFromReq.get(request);
 
@@ -424,6 +425,17 @@ function onError({ request, error }: RequestErrorMessage): void {
     return;
   }
 
+  // An intentional cancellation (`AbortController.abort()` or cancelling the response body) is not
+  // a failure of the request, so don't flip the span (which may already carry a 2xx status) to error.
+  const isAbort =
+    error.name === 'AbortError' ||
+    (typeof DOMException !== 'undefined' && error instanceof DOMException && error.code === DOMException.ABORT_ERR);
+  if (isAbort) {
+    span.end();
+    spanFromReq.delete(request);
+    return;
+  }
+
   // NOTE: in `undici@6.3.0` when request aborted the error type changes from
   // a custom error (`RequestAbortedError`) to a built-in `DOMException` carrying
   // some differences:
diff --git a/packages/node/test/integrations/undici.test.ts b/packages/node/test/integrations/undici.test.ts
index 807b16ac5468..a387cec9b6f1 100644
--- a/packages/node/test/integrations/undici.test.ts
+++ b/packages/node/test/integrations/undici.test.ts
@@ -12,8 +12,10 @@ import {
   URL_SCHEME,
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
+import { SPAN_STATUS_ERROR } from '@sentry/core';
 import { channel } from 'node:diagnostics_channel';
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Mock } from 'vitest';
 import type { UndiciRequest } from '../../src/integrations/node-fetch/types';
 
 const { span, startInactiveSpan, getClient } = vi.hoisted(() => ({
@@ -109,4 +111,51 @@ describe('instrumentUndici', () => {
       expect.objectContaining({ name: 'QUERY api.example.com', onlyIfParent: false }),
     );
   });
+
+  describe('request errors', () => {
+    function startRequest(): { request: UndiciRequest; testSpan: { setStatus: Mock; setAttributes: Mock; end: Mock } } {
+      const testSpan = { setStatus: vi.fn(), setAttributes: vi.fn(), end: vi.fn() };
+      startInactiveSpan.mockReturnValueOnce(testSpan);
+      const request = {
+        method: 'GET',
+        origin: 'https://api.example.com',
+        path: '/stream',
+        headers: [],
+      } as unknown as UndiciRequest;
+      channel('undici:request:create').publish({ request });
+      channel('undici:request:headers').publish({
+        request,
+        response: { statusCode: 200, statusText: 'OK', headers: [] },
+      });
+      return { request, testSpan };
+    }
+
+    it.each([
+      ['an AbortError', () => Object.assign(new Error('aborted'), { name: 'AbortError' })],
+      ['a DOMException named AbortError', () => new DOMException('This operation was aborted', 'AbortError')],
+      [
+        'a DOMException with only the ABORT_ERR code',
+        () => Object.defineProperty(new DOMException('aborted', 'Other'), 'code', { value: DOMException.ABORT_ERR }),
+      ],
+    ])('ends the span without an error status when the request is aborted (%s)', (_name, makeError) => {
+      const { request, testSpan } = startRequest();
+
+      channel('undici:request:error').publish({ request, error: makeError() });
+
+      expect(testSpan.setStatus).not.toHaveBeenCalledWith(expect.objectContaining({ code: SPAN_STATUS_ERROR }));
+      expect(testSpan.end).toHaveBeenCalledTimes(1);
+    });
+
+    it.each([
+      ['a TypeError', () => new TypeError('fetch failed')],
+      ['ECONNRESET', () => Object.assign(new Error('read ECONNRESET'), { code: 'ECONNRESET' })],
+    ])('still sets an error status for a non-abort error (%s)', (_name, makeError) => {
+      const { request, testSpan } = startRequest();
+
+      channel('undici:request:error').publish({ request, error: makeError() });
+
+      expect(testSpan.setStatus).toHaveBeenCalledWith({ code: SPAN_STATUS_ERROR, message: expect.any(String) });
+      expect(testSpan.end).toHaveBeenCalledTimes(1);
+    });
+  });
 });

From beda27f1e9773101cb7725a4131a3a1c7466d466 Mon Sep 17 00:00:00 2001
From: "javascript-sdk-gitflow[bot]"
 <255134079+javascript-sdk-gitflow[bot]@users.noreply.github.com>
Date: Mon, 12 Oct 2026 13:41:42 +0200
Subject: [PATCH 65/84] chore: Add external contributor to CHANGELOG.md
 (#25271)

This PR adds the external contributor to the CHANGELOG.md file, so that
they are credited for their contribution. See #25129

Co-authored-by: andreiborza <168741329+andreiborza@users.noreply.github.com>
---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ee97ad9d225e..608afb690471 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,7 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
-Work in this release was contributed by @Philip-Nwabuwa. Thank you for your contribution!
+Work in this release was contributed by @Philip-Nwabuwa and @4ktLuffy. Thank you for your contributions!
 
 ## 11.6.0
 

From c20e4f2a27feb8390014d178cc0bde289cd03b42 Mon Sep 17 00:00:00 2001
From: Andrei <168741329+andreiborza@users.noreply.github.com>
Date: Mon, 12 Oct 2026 13:58:22 +0200
Subject: [PATCH 66/84] feat(server-utils): Record Workers AI Jev and Clef
 calls as gen_ai.decide spans (#25272)

## What

Workers AI calls to TypeSafe Jev and Cloudflare Clef models now create
`decide <model>` spans with op `gen_ai.decide`, instead of
`gen_ai.evaluate`.

## Why

`gen_ai.evaluate` is deprecated in favor of `gen_ai.decide`
(getsentry/sentry-conventions#696), to match the Vercel AI rename to
`experimental_decide`.

Closes: #25250

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../suites/tracing/workers-ai/test.ts         | 13 ++++++-----
 .../tests/send-to-sentry.test.ts              | 16 +++++++-------
 .../server-utils/src/ai/workers-ai/utils.ts   | 22 +++++++++----------
 .../test/ai/lib/tracing/workers-ai.test.ts    |  9 ++++----
 .../ai/lib/utils/workers-ai-utils.test.ts     | 18 +++++++--------
 5 files changed, 40 insertions(+), 38 deletions(-)

diff --git a/dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts b/dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts
index 600062d6eb0a..aca3281b19c2 100644
--- a/dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts
+++ b/dev-packages/cloudflare-integration-tests/suites/tracing/workers-ai/test.ts
@@ -21,6 +21,7 @@ import {
   SENTRY_OP,
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
+import { GEN_AI_DECIDE } from '@sentry/conventions/op';
 import { SDK_VERSION } from '@sentry/core';
 import { expect, it } from 'vitest';
 import { GEN_AI_REQUEST_STREAM_ATTRIBUTE } from '../../../../../packages/server-utils/src/ai/core/gen-ai-attributes';
@@ -149,14 +150,14 @@ it('traces a TypeSafe Jev evaluation like the TypeSafe integration', async ({ si
 
       expect(genAiSpans[0]).toEqual(
         expect.objectContaining({
-          name: 'evaluate typesafe/jev',
+          name: 'decide typesafe/jev',
           status: 'ok',
           is_segment: false,
           attributes: {
             [SENTRY_ORIGIN]: { value: 'auto.ai.cloudflare.workers_ai', type: 'string' },
-            [SENTRY_OP]: { value: 'gen_ai.evaluate', type: 'string' },
+            [SENTRY_OP]: { value: GEN_AI_DECIDE, type: 'string' },
             [GEN_AI_PROVIDER_NAME]: { value: 'cloudflare.workers_ai', type: 'string' },
-            [GEN_AI_OPERATION_NAME]: { value: 'evaluate', type: 'string' },
+            [GEN_AI_OPERATION_NAME]: { value: 'decide', type: 'string' },
             [GEN_AI_REQUEST_MODEL]: { value: 'typesafe/jev', type: 'string' },
             [GEN_AI_RESPONSE_MODEL]: { value: 'jev-1.13.0', type: 'string' },
             [GEN_AI_USAGE_INPUT_TOKENS]: { value: 426, type: 'integer' },
@@ -195,14 +196,14 @@ it('traces a Clef evaluation like a TypeSafe Jev evaluation', async ({ signal })
 
       expect(genAiSpans[0]).toEqual(
         expect.objectContaining({
-          name: 'evaluate @cf/cloudflare/clef',
+          name: 'decide @cf/cloudflare/clef',
           status: 'ok',
           is_segment: false,
           attributes: {
             [SENTRY_ORIGIN]: { value: 'auto.ai.cloudflare.workers_ai', type: 'string' },
-            [SENTRY_OP]: { value: 'gen_ai.evaluate', type: 'string' },
+            [SENTRY_OP]: { value: GEN_AI_DECIDE, type: 'string' },
             [GEN_AI_PROVIDER_NAME]: { value: 'cloudflare.workers_ai', type: 'string' },
-            [GEN_AI_OPERATION_NAME]: { value: 'evaluate', type: 'string' },
+            [GEN_AI_OPERATION_NAME]: { value: 'decide', type: 'string' },
             [GEN_AI_REQUEST_MODEL]: { value: '@cf/cloudflare/clef', type: 'string' },
             [GEN_AI_RESPONSE_MODEL]: { value: 'clef', type: 'string' },
             [GEN_AI_USAGE_INPUT_TOKENS]: { value: 412, type: 'integer' },
diff --git a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tests/send-to-sentry.test.ts b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tests/send-to-sentry.test.ts
index f5ce99ab2a0f..fd79fa5b7743 100644
--- a/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tests/send-to-sentry.test.ts
+++ b/dev-packages/e2e-tests/test-applications/cloudflare-workers-send-to-sentry/tests/send-to-sentry.test.ts
@@ -94,20 +94,20 @@ test('Sends a Workers AI gen_ai span to Sentry', async () => {
     });
 });
 
-test('Sends a Workers AI gen_ai.evaluate span for a TypeSafe Jev call to Sentry', async () => {
+test('Sends a Workers AI gen_ai.decide span for a TypeSafe Jev call to Sentry', async () => {
   const { traceId }: { traceId: string } = JSON.parse(await fetchFromWorker(`${workerUrl}/test-workers-ai-jev`, 200));
 
-  console.log(`Polling for gen_ai.evaluate span: sentry trace view ${traceTarget(traceId)}`);
+  console.log(`Polling for gen_ai.decide span: sentry trace view ${traceTarget(traceId)}`);
 
   let spanId: string | undefined;
   await expect
-    .poll(() => (spanId = findSpanInTrace(traceId, 'gen_ai.evaluate')?.event_id), EVENT_POLLING_OPTIONS)
+    .poll(() => (spanId = findSpanInTrace(traceId, 'gen_ai.decide')?.event_id), EVENT_POLLING_OPTIONS)
     .toBeDefined();
 
   await expect
     .poll(() => fetchSpanAttributes(traceId, spanId!), EVENT_POLLING_OPTIONS)
     .toMatchObject({
-      'gen_ai.operation.name': 'evaluate',
+      'gen_ai.operation.name': 'decide',
       'gen_ai.request.model': 'typesafe/jev',
       'gen_ai.response.model': expect.stringMatching(/^jev-/),
       'gen_ai.input.messages': expect.stringContaining('My payouts have been failing'),
@@ -115,20 +115,20 @@ test('Sends a Workers AI gen_ai.evaluate span for a TypeSafe Jev call to Sentry'
     });
 });
 
-test('Sends a Workers AI gen_ai.evaluate span for a Clef call to Sentry', async () => {
+test('Sends a Workers AI gen_ai.decide span for a Clef call to Sentry', async () => {
   const { traceId }: { traceId: string } = JSON.parse(await fetchFromWorker(`${workerUrl}/test-workers-ai-clef`, 200));
 
-  console.log(`Polling for gen_ai.evaluate span: sentry trace view ${traceTarget(traceId)}`);
+  console.log(`Polling for gen_ai.decide span: sentry trace view ${traceTarget(traceId)}`);
 
   let spanId: string | undefined;
   await expect
-    .poll(() => (spanId = findSpanInTrace(traceId, 'gen_ai.evaluate')?.event_id), EVENT_POLLING_OPTIONS)
+    .poll(() => (spanId = findSpanInTrace(traceId, 'gen_ai.decide')?.event_id), EVENT_POLLING_OPTIONS)
     .toBeDefined();
 
   await expect
     .poll(() => fetchSpanAttributes(traceId, spanId!), EVENT_POLLING_OPTIONS)
     .toMatchObject({
-      'gen_ai.operation.name': 'evaluate',
+      'gen_ai.operation.name': 'decide',
       'gen_ai.request.model': '@cf/cloudflare/clef',
       'gen_ai.response.model': expect.stringContaining('clef'),
       'gen_ai.input.messages': expect.stringContaining('Checkout has been failing'),
diff --git a/packages/server-utils/src/ai/workers-ai/utils.ts b/packages/server-utils/src/ai/workers-ai/utils.ts
index 73da7883b12e..29db4d2cd136 100644
--- a/packages/server-utils/src/ai/workers-ai/utils.ts
+++ b/packages/server-utils/src/ai/workers-ai/utils.ts
@@ -16,7 +16,7 @@ import {
   GEN_AI_SYSTEM_INSTRUCTIONS,
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
-import { GEN_AI_CHAT, GEN_AI_EMBEDDINGS, GEN_AI_EVALUATE } from '@sentry/conventions/op';
+import { GEN_AI_CHAT, GEN_AI_EMBEDDINGS, GEN_AI_DECIDE } from '@sentry/conventions/op';
 import { isObjectLike, stringify } from '@sentry/core';
 import type { Span, SpanAttributeValue } from '@sentry/core';
 import { GEN_AI_REQUEST_STREAM_ATTRIBUTE } from '../core/gen-ai-attributes';
@@ -26,32 +26,32 @@ import {
   getTokenUsageAttributes,
   setOutputMessagesAttribute,
 } from '../core/utils';
-import { addResponseAttributes as addEvaluateResponseAttributes } from '../typesafe';
+import { addResponseAttributes as addDecideResponseAttributes } from '../typesafe';
 // Re-exported so `workers-ai/streaming.ts` keeps importing it from this module.
 export { setOutputMessagesAttribute };
 import { WORKERS_AI_ORIGIN, WORKERS_AI_PROVIDER_NAME } from './constants';
 import type { WorkersAiInput, WorkersAiOutput } from './types';
 
-export type WorkersAiOperationName = 'chat' | 'embeddings' | 'evaluate';
+export type WorkersAiOperationName = 'chat' | 'embeddings' | 'decide';
 
 export const WORKERS_AI_OPERATION_SPAN_OPS: Record<WorkersAiOperationName, string> = {
   chat: GEN_AI_CHAT,
   embeddings: GEN_AI_EMBEDDINGS,
-  evaluate: GEN_AI_EVALUATE,
+  decide: GEN_AI_DECIDE,
 };
 
 /**
- * Model ID prefixes of the evaluation models (TypeSafe Jev and Cloudflare Clef), traced as `evaluate` spans.
+ * Model ID prefixes of the evaluation models (TypeSafe Jev and Cloudflare Clef), traced as `decide` spans.
  */
-const EVALUATE_MODEL_PREFIXES = ['typesafe/jev', '@cf/cloudflare/clef'];
+const DECIDE_MODEL_PREFIXES = ['typesafe/jev', '@cf/cloudflare/clef'];
 
 /**
  * Determine the gen_ai operation name from the model and inputs passed to `AI.run`.
  * Workers AI exposes a single `run` method, so we infer the operation from the model ID and the input shape.
  */
 export function getOperationName(model: unknown, inputs: unknown): WorkersAiOperationName {
-  if (typeof model === 'string' && EVALUATE_MODEL_PREFIXES.some(prefix => model.startsWith(prefix))) {
-    return 'evaluate';
+  if (typeof model === 'string' && DECIDE_MODEL_PREFIXES.some(prefix => model.startsWith(prefix))) {
+    return 'decide';
   }
   if (inputs && typeof inputs === 'object') {
     if ('messages' in inputs || 'prompt' in inputs) {
@@ -118,7 +118,7 @@ export function addRequestAttributes(span: Span, inputs: unknown, operationName:
   }
   const params = inputs as WorkersAiInput;
 
-  if (operationName === 'evaluate') {
+  if (operationName === 'decide') {
     span.setAttribute(GEN_AI_INPUT_MESSAGES, getEvaluationInputMessages(inputs as Record<string, unknown>));
     return;
   }
@@ -159,10 +159,10 @@ export function addResponseAttributes(
   recordOutputs: boolean,
   operationName?: WorkersAiOperationName,
 ): void {
-  if (operationName === 'evaluate') {
+  if (operationName === 'decide') {
     // The binding wraps the TypeSafe response as `{ state, result }`, but the docs show it unwrapped.
     const body = isObjectLike(result) && isObjectLike(result.result) ? result.result : result;
-    addEvaluateResponseAttributes(span, body, recordOutputs);
+    addDecideResponseAttributes(span, body, recordOutputs);
     return;
   }
 
diff --git a/packages/server-utils/test/ai/lib/tracing/workers-ai.test.ts b/packages/server-utils/test/ai/lib/tracing/workers-ai.test.ts
index f2784635c5f2..5b1f8738b7a3 100644
--- a/packages/server-utils/test/ai/lib/tracing/workers-ai.test.ts
+++ b/packages/server-utils/test/ai/lib/tracing/workers-ai.test.ts
@@ -14,6 +14,7 @@ import {
   SENTRY_OP,
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
+import { GEN_AI_DECIDE } from '@sentry/conventions/op';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   getMainCarrier,
@@ -164,7 +165,7 @@ describe('instrumentWorkersAiClient', () => {
     });
   });
 
-  it('records TypeSafe models as evaluate spans, like the TypeSafe integration', async () => {
+  it('records TypeSafe models as decide spans, like the TypeSafe integration', async () => {
     const client = new TestClient(
       getDefaultTestClientOptions({ dsn: 'https://public@dsn.ingest.sentry.io/1337', tracesSampleRate: 1 }),
     );
@@ -185,14 +186,14 @@ describe('instrumentWorkersAiClient', () => {
     await instrumentWorkersAiClient(ai).run('typesafe/jev', { state: 'Help!', questions });
 
     const span = spanToStaticSpanJSON(endedSpans[0]!);
-    expect(span.description).toBe('evaluate typesafe/jev');
+    expect(span.description).toBe('decide typesafe/jev');
     expect(span.data).toEqual({
       [SENTRY_ORIGIN]: 'auto.ai.cloudflare.workers_ai',
-      [SENTRY_OP]: 'gen_ai.evaluate',
+      [SENTRY_OP]: GEN_AI_DECIDE,
       [SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: 1,
       [SENTRY_SEGMENT_NAME_SOURCE]: 'custom',
       [GEN_AI_PROVIDER_NAME]: 'cloudflare.workers_ai',
-      [GEN_AI_OPERATION_NAME]: 'evaluate',
+      [GEN_AI_OPERATION_NAME]: 'decide',
       [GEN_AI_REQUEST_MODEL]: 'typesafe/jev',
       [GEN_AI_RESPONSE_MODEL]: 'jev-1.13.0',
       [GEN_AI_USAGE_INPUT_TOKENS]: 426,
diff --git a/packages/server-utils/test/ai/lib/utils/workers-ai-utils.test.ts b/packages/server-utils/test/ai/lib/utils/workers-ai-utils.test.ts
index 40abfadf8f2f..85d690e01421 100644
--- a/packages/server-utils/test/ai/lib/utils/workers-ai-utils.test.ts
+++ b/packages/server-utils/test/ai/lib/utils/workers-ai-utils.test.ts
@@ -60,20 +60,20 @@ describe('workers-ai utils', () => {
       expect(getOperationName(MODEL, { text: 'embed me' })).toBe('embeddings');
     });
 
-    it('returns "evaluate" for TypeSafe Jev models', () => {
-      expect(getOperationName('typesafe/jev', { state: 'Help!', questions: {} })).toBe('evaluate');
-      expect(getOperationName('typesafe/jev-1.13', { state: 'Help!', questions: {} })).toBe('evaluate');
+    it('returns "decide" for TypeSafe Jev models', () => {
+      expect(getOperationName('typesafe/jev', { state: 'Help!', questions: {} })).toBe('decide');
+      expect(getOperationName('typesafe/jev-1.13', { state: 'Help!', questions: {} })).toBe('decide');
     });
 
-    it('returns "evaluate" for Cloudflare Clef models', () => {
-      expect(getOperationName('@cf/cloudflare/clef', { state: 'Help!', questions: {} })).toBe('evaluate');
+    it('returns "decide" for Cloudflare Clef models', () => {
+      expect(getOperationName('@cf/cloudflare/clef', { state: 'Help!', questions: {} })).toBe('decide');
     });
 
-    it('does not return "evaluate" for other TypeSafe models', () => {
+    it('does not return "decide" for other TypeSafe models', () => {
       expect(getOperationName('typesafe/other', { prompt: 'Hello' })).toBe('chat');
     });
 
-    it('does not return "evaluate" for other models with state and questions inputs', () => {
+    it('does not return "decide" for other models with state and questions inputs', () => {
       expect(getOperationName(MODEL, { state: 'Help!', questions: {} })).toBe('chat');
     });
 
@@ -206,7 +206,7 @@ describe('workers-ai utils', () => {
     it.each([
       { name: 'wrapped in { state, result }', wrap: (body: object) => ({ state: 'Completed', result: body }) },
       { name: 'unwrapped', wrap: (body: object) => body },
-    ])('records evaluate responses $name', ({ wrap }) => {
+    ])('records decide responses $name', ({ wrap }) => {
       const { span, attributes } = createMockSpan();
       const answers = { is_urgent: { type: 'noul', noul: 0.95 } };
 
@@ -214,7 +214,7 @@ describe('workers-ai utils', () => {
         span,
         wrap({ model: 'jev-1.13.0', answers, usage: { input_tokens: 366, output_tokens: 50 } }),
         true,
-        'evaluate',
+        'decide',
       );
 
       expect(attributes).toEqual({

From 6aa337aa33733eedcd0c4073c2aae866b19794ba Mon Sep 17 00:00:00 2001
From: Andrei <168741329+andreiborza@users.noreply.github.com>
Date: Mon, 12 Oct 2026 14:12:12 +0200
Subject: [PATCH 67/84] feat(server-utils): Record TypeSafe and LangChain Jev
 calls as gen_ai.decide spans (#25270)

## What

Jev calls from the TypeSafe and LangChain integrations now create
`decide <model>` spans with op `gen_ai.decide`, instead of
`gen_ai.evaluate`.

## Why

`gen_ai.evaluate` is deprecated in favor of `gen_ai.decide`
(getsentry/sentry-conventions#696), to match the Vercel AI rename to
`experimental_decide`.

Closes: #25249

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../langchain-typesafe-classifier/test.ts     | 20 ++++----
 .../suites/tracing/langchain/v1/test.ts       | 50 +++++++++----------
 .../suites/tracing/langgraph/v1/test.ts       | 24 ++++-----
 .../suites/tracing/typesafe/test.ts           | 31 ++++++------
 .../server-utils/src/ai/langchain/index.ts    |  8 +--
 .../src/ai/langchain/typesafe-classifier.ts   |  6 +--
 .../server-utils/src/ai/typesafe/index.ts     | 12 ++---
 .../server-utils/src/integrations/typesafe.ts |  4 +-
 .../tracing/langchain-invoke-agent.test.ts    |  6 +--
 9 files changed, 79 insertions(+), 82 deletions(-)

diff --git a/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/test.ts b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/test.ts
index b5681919fe82..347f79787c80 100644
--- a/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/test.ts
+++ b/dev-packages/cloudflare-integration-tests/suites/tracing/langchain-typesafe-classifier/test.ts
@@ -10,7 +10,7 @@ import {
   SENTRY_OP,
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
-import { GEN_AI_EVALUATE } from '@sentry/conventions/op';
+import { GEN_AI_DECIDE } from '@sentry/conventions/op';
 import { expect, it } from 'vitest';
 import { createRunner } from '../../../runner';
 import { getSpanOp, getSpansFromEnvelope } from '../../../spanUtils';
@@ -29,28 +29,28 @@ it('traces a TypeSafeClassifier call through the Vite plugin instrumentation', a
 
       expect(genAiSpans).toHaveLength(1);
 
-      const evaluateSpan = genAiSpans[0]!;
-      expect(evaluateSpan.name).toBe('evaluate jev-latest');
-      expect(evaluateSpan.parent_span_id).toBe(segmentSpan?.span_id);
-      expect(evaluateSpan.status).toBe('ok');
-      expect(evaluateSpan.attributes).toMatchObject({
-        [SENTRY_OP]: { value: GEN_AI_EVALUATE, type: 'string' },
+      const decideSpan = genAiSpans[0]!;
+      expect(decideSpan.name).toBe('decide jev-latest');
+      expect(decideSpan.parent_span_id).toBe(segmentSpan?.span_id);
+      expect(decideSpan.status).toBe('ok');
+      expect(decideSpan.attributes).toMatchObject({
+        [SENTRY_OP]: { value: GEN_AI_DECIDE, type: 'string' },
         [SENTRY_ORIGIN]: { value: 'auto.ai.langchain', type: 'string' },
-        [GEN_AI_OPERATION_NAME]: { value: 'evaluate', type: 'string' },
+        [GEN_AI_OPERATION_NAME]: { value: 'decide', type: 'string' },
         [GEN_AI_PROVIDER_NAME]: { value: 'typesafe', type: 'string' },
         [GEN_AI_REQUEST_MODEL]: { value: 'jev-latest', type: 'string' },
         [GEN_AI_RESPONSE_MODEL]: { value: 'jev-1.13', type: 'string' },
         [GEN_AI_USAGE_INPUT_TOKENS]: { value: 30, type: 'integer' },
         [GEN_AI_USAGE_OUTPUT_TOKENS]: { value: 2, type: 'integer' },
       });
-      expect(JSON.parse(evaluateSpan.attributes[GEN_AI_INPUT_MESSAGES]!.value as string)).toEqual([
+      expect(JSON.parse(decideSpan.attributes[GEN_AI_INPUT_MESSAGES]!.value as string)).toEqual([
         {
           type: 'evaluation',
           state: ['user: My payouts have been failing.'],
           questions: { urgent: { type: 'noul', instructions: 'Is this urgent?' } },
         },
       ]);
-      expect(JSON.parse(evaluateSpan.attributes[GEN_AI_OUTPUT_MESSAGES]!.value as string)).toEqual([
+      expect(JSON.parse(decideSpan.attributes[GEN_AI_OUTPUT_MESSAGES]!.value as string)).toEqual([
         { type: 'evaluation', answers: { urgent: { type: 'noul', noul: 0.9 } } },
       ]);
     })
diff --git a/dev-packages/node-integration-tests/suites/tracing/langchain/v1/test.ts b/dev-packages/node-integration-tests/suites/tracing/langchain/v1/test.ts
index f14ccb93169d..f6de0aecca94 100644
--- a/dev-packages/node-integration-tests/suites/tracing/langchain/v1/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/langchain/v1/test.ts
@@ -20,7 +20,7 @@ import {
   SENTRY_OP,
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
-import { GEN_AI_EVALUATE } from '@sentry/conventions/op';
+import { GEN_AI_DECIDE } from '@sentry/conventions/op';
 import { GEN_AI_RESPONSE_STOP_REASON_ATTRIBUTE } from '../../../../../../packages/server-utils/src/ai/core/gen-ai-attributes';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
 import { createEsmTests } from '../../../../utils/runner/createEsmAndCjsTests';
@@ -241,7 +241,7 @@ describe('LangChain integration (v1)', () => {
     'scenario-typesafe-classifier.mjs',
     'instrument-with-pii.mjs',
     (createRunner, test) => {
-      test('records a TypeSafeClassifier run as a gen_ai.evaluate span', async () => {
+      test('records a TypeSafeClassifier run as a gen_ai.decide span', async () => {
         const runner = createRunner().ignore('event');
         const spansPromise = runner.collectStreamedSpansUntilSegment('main');
 
@@ -250,19 +250,19 @@ describe('LangChain integration (v1)', () => {
         const spans = (await spansPromise).filter(
           span => span.attributes[SENTRY_ORIGIN]?.value === 'auto.ai.langchain',
         );
-        expect(spans.map(span => span.name)).toEqual(['evaluate jev-latest', 'evaluate jev-latest']);
-
-        const [evaluateSpan, messageEvaluateSpan] = spans.sort((a, b) => a.start_timestamp - b.start_timestamp);
-        expect(evaluateSpan.attributes[SENTRY_OP].value).toBe(GEN_AI_EVALUATE);
-        expect(evaluateSpan.attributes[SENTRY_ORIGIN].value).toBe('auto.ai.langchain');
-        expect(evaluateSpan.attributes[GEN_AI_OPERATION_NAME].value).toBe('evaluate');
-        expect(evaluateSpan.attributes[GEN_AI_PROVIDER_NAME].value).toBe('typesafe');
-        expect(evaluateSpan.attributes[GEN_AI_REQUEST_MODEL].value).toBe('jev-latest');
-        expect(evaluateSpan.attributes[GEN_AI_RESPONSE_MODEL].value).toBe('jev-1.13');
-        expect(evaluateSpan.attributes[GEN_AI_USAGE_INPUT_TOKENS].value).toBe(30);
-        expect(evaluateSpan.attributes[GEN_AI_USAGE_OUTPUT_TOKENS].value).toBe(2);
-        expect(evaluateSpan.attributes[GEN_AI_USAGE_TOTAL_TOKENS].value).toBe(32);
-        expect(JSON.parse(evaluateSpan.attributes[GEN_AI_INPUT_MESSAGES].value)).toEqual([
+        expect(spans.map(span => span.name)).toEqual(['decide jev-latest', 'decide jev-latest']);
+
+        const [decideSpan, messageDecideSpan] = spans.sort((a, b) => a.start_timestamp - b.start_timestamp);
+        expect(decideSpan.attributes[SENTRY_OP].value).toBe(GEN_AI_DECIDE);
+        expect(decideSpan.attributes[SENTRY_ORIGIN].value).toBe('auto.ai.langchain');
+        expect(decideSpan.attributes[GEN_AI_OPERATION_NAME].value).toBe('decide');
+        expect(decideSpan.attributes[GEN_AI_PROVIDER_NAME].value).toBe('typesafe');
+        expect(decideSpan.attributes[GEN_AI_REQUEST_MODEL].value).toBe('jev-latest');
+        expect(decideSpan.attributes[GEN_AI_RESPONSE_MODEL].value).toBe('jev-1.13');
+        expect(decideSpan.attributes[GEN_AI_USAGE_INPUT_TOKENS].value).toBe(30);
+        expect(decideSpan.attributes[GEN_AI_USAGE_OUTPUT_TOKENS].value).toBe(2);
+        expect(decideSpan.attributes[GEN_AI_USAGE_TOTAL_TOKENS].value).toBe(32);
+        expect(JSON.parse(decideSpan.attributes[GEN_AI_INPUT_MESSAGES].value)).toEqual([
           {
             type: 'evaluation',
             state: 'My payouts have been failing.',
@@ -270,14 +270,14 @@ describe('LangChain integration (v1)', () => {
           },
         ]);
         // A message is recorded as the transcript line the classifier sends, not as LangChain's serialized form.
-        expect(JSON.parse(messageEvaluateSpan!.attributes[GEN_AI_INPUT_MESSAGES].value)).toEqual([
+        expect(JSON.parse(messageDecideSpan!.attributes[GEN_AI_INPUT_MESSAGES].value)).toEqual([
           {
             type: 'evaluation',
             state: 'user: My card was charged twice.',
             questions: { urgent: { type: 'noul', instructions: 'Is this urgent?' } },
           },
         ]);
-        expect(JSON.parse(evaluateSpan.attributes[GEN_AI_OUTPUT_MESSAGES].value)).toEqual([
+        expect(JSON.parse(decideSpan.attributes[GEN_AI_OUTPUT_MESSAGES].value)).toEqual([
           { type: 'evaluation', answers: { urgent: { type: 'noul', noul: 0.9 } } },
         ]);
       });
@@ -305,7 +305,7 @@ describe('LangChain integration (v1)', () => {
         const spans = await spansPromise;
         const segment = spans.find(span => span.is_segment && span.name === 'main');
         expect(segment!.attributes['test.recorded_runs'].value).toBe('RunnableLambda:root,TypeSafeClassifier:child');
-        expect(spans.filter(span => span.attributes[SENTRY_OP]?.value === GEN_AI_EVALUATE)).toHaveLength(1);
+        expect(spans.filter(span => span.attributes[SENTRY_OP]?.value === GEN_AI_DECIDE)).toHaveLength(1);
       });
     },
     {
@@ -330,15 +330,15 @@ describe('LangChain integration (v1)', () => {
         await runner.start().completed();
 
         const spans = await spansPromise;
-        const evaluateSpan = spans.find(span => span.attributes[SENTRY_OP]?.value === GEN_AI_EVALUATE)!;
+        const decideSpan = spans.find(span => span.attributes[SENTRY_OP]?.value === GEN_AI_DECIDE)!;
         const chatSpan = spans.find(span => span.name === 'chat claude-3-5-haiku-20241022')!;
 
         // The router classifies in `beforeAgent`, inside the agent run, where other chain steps are skipped.
-        expect(evaluateSpan.name).toBe('evaluate jev-latest');
-        expect(evaluateSpan.attributes[SENTRY_ORIGIN].value).toBe('auto.ai.langchain');
-        expect(evaluateSpan.attributes[GEN_AI_AGENT_NAME].value).toBe('support_agent');
-        expect(evaluateSpan.parent_span_id).toBe(chatSpan.parent_span_id);
-        expect(JSON.parse(evaluateSpan.attributes[GEN_AI_INPUT_MESSAGES].value)).toEqual([
+        expect(decideSpan.name).toBe('decide jev-latest');
+        expect(decideSpan.attributes[SENTRY_ORIGIN].value).toBe('auto.ai.langchain');
+        expect(decideSpan.attributes[GEN_AI_AGENT_NAME].value).toBe('support_agent');
+        expect(decideSpan.parent_span_id).toBe(chatSpan.parent_span_id);
+        expect(JSON.parse(decideSpan.attributes[GEN_AI_INPUT_MESSAGES].value)).toEqual([
           {
             type: 'evaluation',
             // The router passes the latest human message, which the classifier sends as a transcript line.
@@ -352,7 +352,7 @@ describe('LangChain integration (v1)', () => {
             },
           },
         ]);
-        expect(JSON.parse(evaluateSpan.attributes[GEN_AI_OUTPUT_MESSAGES].value)).toEqual([
+        expect(JSON.parse(decideSpan.attributes[GEN_AI_OUTPUT_MESSAGES].value)).toEqual([
           {
             type: 'evaluation',
             answers: {
diff --git a/dev-packages/node-integration-tests/suites/tracing/langgraph/v1/test.ts b/dev-packages/node-integration-tests/suites/tracing/langgraph/v1/test.ts
index c6a71539de1a..b09261efc29e 100644
--- a/dev-packages/node-integration-tests/suites/tracing/langgraph/v1/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/langgraph/v1/test.ts
@@ -6,7 +6,7 @@ import {
   SENTRY_OP,
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
-import { GEN_AI_EVALUATE } from '@sentry/conventions/op';
+import { GEN_AI_DECIDE } from '@sentry/conventions/op';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
 
 describe('LangGraph integration (v1)', () => {
@@ -28,21 +28,21 @@ describe('LangGraph integration (v1)', () => {
         const spans = await spansPromise;
         const rootSpan = spans.find(span => span.is_segment && span.name === 'main')!;
         const agentSpan = spans.find(span => span.name === 'invoke_agent triage_graph')!;
-        const evaluateSpan = spans.find(span => span.name === 'evaluate jev-latest')!;
+        const decideSpan = spans.find(span => span.name === 'decide jev-latest')!;
 
         expect(agentSpan.parent_span_id).toBe(rootSpan.span_id);
-        expect(evaluateSpan.parent_span_id).toBe(agentSpan.span_id);
-        expect(evaluateSpan.attributes[SENTRY_OP].value).toBe(GEN_AI_EVALUATE);
-        expect(evaluateSpan.attributes[SENTRY_ORIGIN].value).toBe('auto.ai.langchain');
-        expect(evaluateSpan.attributes[GEN_AI_AGENT_NAME].value).toBe('triage_graph');
-        expect(JSON.parse(evaluateSpan.attributes[GEN_AI_INPUT_MESSAGES].value)).toEqual([
+        expect(decideSpan.parent_span_id).toBe(agentSpan.span_id);
+        expect(decideSpan.attributes[SENTRY_OP].value).toBe(GEN_AI_DECIDE);
+        expect(decideSpan.attributes[SENTRY_ORIGIN].value).toBe('auto.ai.langchain');
+        expect(decideSpan.attributes[GEN_AI_AGENT_NAME].value).toBe('triage_graph');
+        expect(JSON.parse(decideSpan.attributes[GEN_AI_INPUT_MESSAGES].value)).toEqual([
           {
             type: 'evaluation',
             state: 'My payouts have been failing.',
             questions: { urgent: { type: 'noul', instructions: 'Is this urgent?' } },
           },
         ]);
-        expect(JSON.parse(evaluateSpan.attributes[GEN_AI_OUTPUT_MESSAGES].value)).toEqual([
+        expect(JSON.parse(decideSpan.attributes[GEN_AI_OUTPUT_MESSAGES].value)).toEqual([
           { type: 'evaluation', answers: { urgent: { type: 'noul', noul: 0.9 } } },
         ]);
       });
@@ -69,11 +69,11 @@ describe('LangGraph integration (v1)', () => {
         await runner.start().completed();
 
         const spans = await spansPromise;
-        const evaluateSpan = spans.find(span => span.name === 'evaluate jev-latest')!;
+        const decideSpan = spans.find(span => span.name === 'decide jev-latest')!;
 
-        expect(evaluateSpan.attributes[SENTRY_OP].value).toBe(GEN_AI_EVALUATE);
-        expect(evaluateSpan.attributes[GEN_AI_INPUT_MESSAGES]).toBeUndefined();
-        expect(evaluateSpan.attributes[GEN_AI_OUTPUT_MESSAGES]).toBeUndefined();
+        expect(decideSpan.attributes[SENTRY_OP].value).toBe(GEN_AI_DECIDE);
+        expect(decideSpan.attributes[GEN_AI_INPUT_MESSAGES]).toBeUndefined();
+        expect(decideSpan.attributes[GEN_AI_OUTPUT_MESSAGES]).toBeUndefined();
       });
     },
     {
diff --git a/dev-packages/node-integration-tests/suites/tracing/typesafe/test.ts b/dev-packages/node-integration-tests/suites/tracing/typesafe/test.ts
index e5feb8919745..0640f7282c7d 100644
--- a/dev-packages/node-integration-tests/suites/tracing/typesafe/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/typesafe/test.ts
@@ -11,6 +11,7 @@ import {
   SENTRY_OP,
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
+import { GEN_AI_DECIDE } from '@sentry/conventions/op';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
@@ -28,22 +29,20 @@ describe('TypeSafe integration', () => {
       scenarioFile,
       instrumentFile,
       (createRunner, test) => {
-        test('creates evaluate spans for systemOne', async () => {
+        test('creates decide spans for systemOne', async () => {
           await createRunner()
             .unordered()
             .expect({
               span: container => {
-                const evaluateSpans = container.items.filter(
-                  span => span.attributes[SENTRY_OP]?.value === 'gen_ai.evaluate',
-                );
-                expect(evaluateSpans).toHaveLength(4);
-                for (const span of evaluateSpans) {
+                const decideSpans = container.items.filter(span => span.attributes[SENTRY_OP]?.value === GEN_AI_DECIDE);
+                expect(decideSpans).toHaveLength(4);
+                for (const span of decideSpans) {
                   expect(span.attributes[SENTRY_ORIGIN]?.value).toBe('auto.ai.typesafe');
-                  expect(span.attributes[GEN_AI_OPERATION_NAME]?.value).toBe('evaluate');
+                  expect(span.attributes[GEN_AI_OPERATION_NAME]?.value).toBe('decide');
                   expect(span.attributes[GEN_AI_PROVIDER_NAME]?.value).toBe('typesafe');
                 }
 
-                const defaultModelSpan = evaluateSpans.find(span => span.name === 'evaluate jev-latest')!;
+                const defaultModelSpan = decideSpans.find(span => span.name === 'decide jev-latest')!;
                 expect(defaultModelSpan).toBeDefined();
                 expect(defaultModelSpan.status).toBe('ok');
                 expect(defaultModelSpan.attributes[GEN_AI_REQUEST_MODEL]?.value).toBe('jev-latest');
@@ -92,18 +91,18 @@ describe('TypeSafe integration', () => {
                   },
                 ]);
 
-                const asResponseSpan = evaluateSpans.find(span => span.name === 'evaluate jev-1.13')!;
+                const asResponseSpan = decideSpans.find(span => span.name === 'decide jev-1.13')!;
                 expect(asResponseSpan).toBeDefined();
                 expect(asResponseSpan.status).toBe('ok');
                 expect(asResponseSpan.attributes[GEN_AI_RESPONSE_MODEL]?.value).toBe('jev-1.13.0');
 
-                const errorSpan = evaluateSpans.find(span => span.name === 'evaluate error-model')!;
+                const errorSpan = decideSpans.find(span => span.name === 'decide error-model')!;
                 expect(errorSpan).toBeDefined();
                 expect(errorSpan.status).toBe('error');
                 expect(errorSpan.attributes[GEN_AI_RESPONSE_MODEL]).toBeUndefined();
                 expect(errorSpan.attributes[GEN_AI_OUTPUT_MESSAGES]).toBeUndefined();
 
-                const validationErrorSpan = evaluateSpans.find(span => span.name === 'evaluate validation-error')!;
+                const validationErrorSpan = decideSpans.find(span => span.name === 'decide validation-error')!;
                 expect(validationErrorSpan).toBeDefined();
                 expect(validationErrorSpan.status).toBe('error');
                 expect(validationErrorSpan.attributes[GEN_AI_OUTPUT_MESSAGES]).toBeUndefined();
@@ -130,12 +129,10 @@ describe('TypeSafe integration', () => {
             .unordered()
             .expect({
               span: container => {
-                const evaluateSpans = container.items.filter(
-                  span => span.attributes[SENTRY_OP]?.value === 'gen_ai.evaluate',
-                );
-                expect(evaluateSpans).toHaveLength(4);
-                expect(evaluateSpans.filter(span => span.status === 'error')).toHaveLength(2);
-                for (const span of evaluateSpans) {
+                const decideSpans = container.items.filter(span => span.attributes[SENTRY_OP]?.value === GEN_AI_DECIDE);
+                expect(decideSpans).toHaveLength(4);
+                expect(decideSpans.filter(span => span.status === 'error')).toHaveLength(2);
+                for (const span of decideSpans) {
                   expect(span.attributes[GEN_AI_INPUT_MESSAGES]).toBeUndefined();
                   expect(span.attributes[GEN_AI_OUTPUT_MESSAGES]).toBeUndefined();
                   // State, questions and answers must not come back through another attribute (e.g. an error message).
diff --git a/packages/server-utils/src/ai/langchain/index.ts b/packages/server-utils/src/ai/langchain/index.ts
index f7b5408d1d59..11a1afb7d391 100644
--- a/packages/server-utils/src/ai/langchain/index.ts
+++ b/packages/server-utils/src/ai/langchain/index.ts
@@ -48,7 +48,7 @@ export function createLangChainCallbackHandler(options: LangChainOptions = {}):
 
   // Internal state - single instance tracks all spans
   const spanMap = new Map<string, Span>();
-  const evaluateRunIds = new Set<string>();
+  const decideRunIds = new Set<string>();
 
   /**
    * Exit a span and clean up
@@ -59,7 +59,7 @@ export function createLangChainCallbackHandler(options: LangChainOptions = {}):
       span.end();
     }
     spanMap.delete(runId);
-    evaluateRunIds.delete(runId);
+    decideRunIds.delete(runId);
   };
 
   /**
@@ -225,7 +225,7 @@ export function createLangChainCallbackHandler(options: LangChainOptions = {}):
       // A Jev call is a real model call, so it is recorded inside an agent too.
       if (isTypeSafeClassifier(chain)) {
         spanMap.set(runId, startTypeSafeClassifierSpan(chain, inputs, metadata, recordInputs));
-        evaluateRunIds.add(runId);
+        decideRunIds.add(runId);
         return;
       }
 
@@ -278,7 +278,7 @@ export function createLangChainCallbackHandler(options: LangChainOptions = {}):
     handleChainEnd(outputs: unknown, runId: string) {
       const span = spanMap.get(runId);
       if (span?.isRecording()) {
-        if (evaluateRunIds.has(runId)) {
+        if (decideRunIds.has(runId)) {
           addTypeSafeClassifierResponseAttributes(span, outputs, recordOutputs);
         } else if (recordOutputs) {
           span.setAttributes({
diff --git a/packages/server-utils/src/ai/langchain/typesafe-classifier.ts b/packages/server-utils/src/ai/langchain/typesafe-classifier.ts
index e254685a4561..0167e60f2c22 100644
--- a/packages/server-utils/src/ai/langchain/typesafe-classifier.ts
+++ b/packages/server-utils/src/ai/langchain/typesafe-classifier.ts
@@ -1,7 +1,7 @@
 import { SENTRY_ORIGIN } from '@sentry/conventions/attributes';
 import type { Span } from '@sentry/core';
 import { isObjectLike } from '@sentry/core';
-import { addResponseAttributes, startEvaluateSpan } from '../typesafe';
+import { addResponseAttributes, startDecideSpan } from '../typesafe';
 import { LANGCHAIN_ORIGIN } from './constants';
 import { getAgentNameFromMetadata, getConversationIdFromMetadata } from './utils';
 
@@ -40,7 +40,7 @@ export function isTypeSafeClassifier(chain: unknown): boolean {
   return isObjectLike(chain) && Array.isArray(chain.id) && chain.id[chain.id.length - 1] === TYPESAFE_CLASSIFIER_NAME;
 }
 
-/** Start an `evaluate` span for a `TypeSafeClassifier` run, from its serialized constructor arguments. */
+/** Start a `decide` span for a `TypeSafeClassifier` run, from its serialized constructor arguments. */
 export function startTypeSafeClassifierSpan(
   chain: unknown,
   inputs: Record<string, unknown>,
@@ -50,7 +50,7 @@ export function startTypeSafeClassifierSpan(
   const kwargs = isObjectLike(chain) && isObjectLike(chain.kwargs) ? chain.kwargs : {};
   const model = typeof kwargs.model === 'string' ? kwargs.model : DEFAULT_TYPESAFE_CLASSIFIER_MODEL;
 
-  return startEvaluateSpan({ model, state: getState(inputs), questions: kwargs.questions }, undefined, recordInputs, {
+  return startDecideSpan({ model, state: getState(inputs), questions: kwargs.questions }, undefined, recordInputs, {
     [SENTRY_ORIGIN]: LANGCHAIN_ORIGIN,
     ...getAgentNameFromMetadata(metadata),
     ...getConversationIdFromMetadata(metadata),
diff --git a/packages/server-utils/src/ai/typesafe/index.ts b/packages/server-utils/src/ai/typesafe/index.ts
index 81dbdd666cd0..65d24e6fc3f8 100644
--- a/packages/server-utils/src/ai/typesafe/index.ts
+++ b/packages/server-utils/src/ai/typesafe/index.ts
@@ -10,7 +10,7 @@ import {
   GEN_AI_USAGE_TOTAL_TOKENS,
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
-import { GEN_AI_EVALUATE } from '@sentry/conventions/op';
+import { GEN_AI_DECIDE } from '@sentry/conventions/op';
 import type { Span, SpanAttributes } from '@sentry/core';
 import { isObjectLike, SPAN_STATUS_ERROR, startInactiveSpan, withActiveSpan } from '@sentry/core';
 import type { GenAiOptions } from '../core/utils';
@@ -21,7 +21,7 @@ import { TYPESAFE_ORIGIN, TYPESAFE_PROVIDER_NAME } from './constants';
  * Start the span for a `systemOne(request)` call. The request model falls back to the client's
  * `defaultModel`, the same way the SDK resolves it.
  */
-export function startEvaluateSpan(
+export function startDecideSpan(
   request: unknown,
   client: unknown,
   recordInputs: boolean,
@@ -33,9 +33,9 @@ export function startEvaluateSpan(
     typeof params.model === 'string' ? params.model : typeof defaultModel === 'string' ? defaultModel : undefined;
 
   return startInactiveSpan({
-    name: model ? `evaluate ${model}` : 'evaluate',
+    name: model ? `decide ${model}` : 'decide',
     // oxlint-disable-next-line typescript/no-deprecated -- the rename to `gen_ai.decide` comes in a follow-up
-    op: GEN_AI_EVALUATE,
+    op: GEN_AI_DECIDE,
     // Extra attributes (e.g. another integration's origin) are set at start, so samplers see them.
     attributes: { ...getRequestAttributes(params, model, recordInputs), ...attributes },
   });
@@ -48,7 +48,7 @@ function getRequestAttributes(
 ): SpanAttributes {
   return {
     [SENTRY_ORIGIN]: TYPESAFE_ORIGIN,
-    [GEN_AI_OPERATION_NAME]: 'evaluate',
+    [GEN_AI_OPERATION_NAME]: 'decide',
     [GEN_AI_PROVIDER_NAME]: TYPESAFE_PROVIDER_NAME,
     ...(model ? { [GEN_AI_REQUEST_MODEL]: model } : {}),
     ...(recordInputs ? { [GEN_AI_INPUT_MESSAGES]: getEvaluationInputMessages(request) } : {}),
@@ -143,7 +143,7 @@ function instrumentSystemOne(
   options: GenAiOptions | undefined,
 ): unknown {
   const { recordInputs, recordOutputs } = resolveAIRecordingOptions(options);
-  const span = startEvaluateSpan(args[0], client, recordInputs);
+  const span = startDecideSpan(args[0], client, recordInputs);
   const endWithError = (): void => {
     span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });
     span.end();
diff --git a/packages/server-utils/src/integrations/typesafe.ts b/packages/server-utils/src/integrations/typesafe.ts
index 9575e1206435..70f2b39c020b 100644
--- a/packages/server-utils/src/integrations/typesafe.ts
+++ b/packages/server-utils/src/integrations/typesafe.ts
@@ -3,7 +3,7 @@ import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
 import type { GenAiOptions } from '../ai/core/utils';
 import { resolveAIRecordingOptions } from '../ai/core/utils';
-import { addResponseAttributes, onSystemOneResponse, startEvaluateSpan } from '../ai/typesafe';
+import { addResponseAttributes, onSystemOneResponse, startDecideSpan } from '../ai/typesafe';
 import { TYPESAFE_INTEGRATION_NAME } from '../ai/typesafe/constants';
 import type { OrchestrionChannelContext } from '../orchestrion/types';
 import { CHANNELS } from '../orchestrion/channels';
@@ -23,7 +23,7 @@ const _typesafeIntegration = ((options: GenAiOptions = {}) => {
 function instrumentTypeSafe(options: GenAiOptions): void {
   bindTracingChannelToSpan(
     diagnosticsChannel.tracingChannel<OrchestrionChannelContext>(CHANNELS.TYPESAFE_SYSTEM_ONE),
-    data => startEvaluateSpan(data.arguments?.[0], data.self, resolveAIRecordingOptions(options).recordInputs),
+    data => startDecideSpan(data.arguments?.[0], data.self, resolveAIRecordingOptions(options).recordInputs),
     {
       beforeSpanEnd: (span, data) => {
         if (!('error' in data)) {
diff --git a/packages/server-utils/test/ai/lib/tracing/langchain-invoke-agent.test.ts b/packages/server-utils/test/ai/lib/tracing/langchain-invoke-agent.test.ts
index 3a36432167ea..592a9aa9f362 100644
--- a/packages/server-utils/test/ai/lib/tracing/langchain-invoke-agent.test.ts
+++ b/packages/server-utils/test/ai/lib/tracing/langchain-invoke-agent.test.ts
@@ -6,7 +6,7 @@ import {
   SENTRY_OP,
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
-import { GEN_AI_EVALUATE } from '@sentry/conventions/op';
+import { GEN_AI_DECIDE } from '@sentry/conventions/op';
 import { getClient, getMainCarrier, setCurrentClient, spanToStaticSpanJSON } from '@sentry/core';
 import type { Span } from '@sentry/core';
 import { createLangChainCallbackHandler } from '../../../../src/ai/langchain';
@@ -120,11 +120,11 @@ describe('LangChain invoke_agent span names', () => {
 
     expect(startAttributes).toEqual([
       expect.objectContaining({
-        [SENTRY_OP]: GEN_AI_EVALUATE,
+        [SENTRY_OP]: GEN_AI_DECIDE,
         [SENTRY_ORIGIN]: 'auto.ai.langchain',
         [GEN_AI_AGENT_NAME]: 'support_agent',
       }),
     ]);
-    expect(endedSpans.map(span => spanToStaticSpanJSON(span).description)).toEqual(['evaluate jev-latest']);
+    expect(endedSpans.map(span => spanToStaticSpanJSON(span).description)).toEqual(['decide jev-latest']);
   });
 });

From 36fdc3f273841be909f3eecf911025dfdd6fed2a Mon Sep 17 00:00:00 2001
From: Sigrid <32902192+s1gr1d@users.noreply.github.com>
Date: Mon, 12 Oct 2026 14:13:07 +0200
Subject: [PATCH 68/84] fix(nuxt): Delete public source maps before Nitro lists
 its public assets (#25267)

Nitro lists the files in its public dir when it bundles the server. The
SDK deleted the client source maps later, in `close`, so requests for
them returned 500 instead of 404.

Now a plugin on Nitro's build deletes them in `buildStart`. It deletes
only matching files in the public dir. Other matches, like server maps,
are still deleted in `close`: the default glob also matches the SSR
build's maps, which Nitro needs during its build.

Fixes #25242
---
 .../nuxt-4-sourcemaps/assert-build.ts         |  50 ++++++++
 dev-packages/test-utils/src/index.ts          |   3 +
 dev-packages/test-utils/src/node-server.ts    |  55 +++++++++
 packages/nuxt/src/vite/sourceMapDeletion.ts   |  44 ++++++-
 packages/nuxt/src/vite/sourceMaps.ts          |  20 +++-
 .../nuxt/test/vite/sourceMapDeletion.test.ts  |  95 ++++++++++++++++
 .../test/vite/sourceMaps-nuxtHooks.test.ts    | 107 +++++++++++++++++-
 7 files changed, 370 insertions(+), 4 deletions(-)
 create mode 100644 dev-packages/test-utils/src/node-server.ts
 create mode 100644 packages/nuxt/test/vite/sourceMapDeletion.test.ts

diff --git a/dev-packages/e2e-tests/test-applications/nuxt-4-sourcemaps/assert-build.ts b/dev-packages/e2e-tests/test-applications/nuxt-4-sourcemaps/assert-build.ts
index 49b9839d98ba..671ec4526a7a 100644
--- a/dev-packages/e2e-tests/test-applications/nuxt-4-sourcemaps/assert-build.ts
+++ b/dev-packages/e2e-tests/test-applications/nuxt-4-sourcemaps/assert-build.ts
@@ -15,6 +15,7 @@ import {
   getSourcemapSources,
   getSourcemaps,
   loadMockServerResults,
+  startNodeServer,
 } from '@sentry-internal/test-utils';
 
 /** This variant omits `sourcemaps.filesToDeleteAfterUpload`, so Sentry must upload but not delete. */
@@ -170,6 +171,11 @@ const debugIdsWithoutSourceMap = debugIdsOfChunksWithoutSourceMap(CLIENT_BUILD_O
 for (const outputDir of isStaticBuild ? [CLIENT_OUTPUT] : [CLIENT_OUTPUT, SERVER_OUTPUT]) {
   const injectedDebugIds = findInjectedDebugIds({ outputDir });
   assert.ok(injectedDebugIds.length > 0, `Expected debug IDs to be injected into ${outputDir}`);
+  // The exemption for chunks without a source map must not let a build without any uploaded map pass.
+  assert.ok(
+    injectedDebugIds.some(debugId => uploadedDebugIds.has(debugId)),
+    `Expected at least one debug ID in ${outputDir} to have an uploaded sourcemap`,
+  );
 
   const unuploaded = injectedDebugIds.filter(
     debugId => !uploadedDebugIds.has(debugId) && !debugIdsWithoutSourceMap.has(debugId),
@@ -232,4 +238,48 @@ if (keepClientSourceMaps) {
   console.log(`  ${CLIENT_OUTPUT} is free of source maps, sourceMappingURL comments and original source\n`);
 }
 
+// --- What the built server answers for the client source maps ---
+
+// `nuxt generate` emits no server, and a static host serves only the files that exist.
+if (!isStaticBuild) {
+  const clientChunkUrls = fs
+    .readdirSync(CLIENT_OUTPUT, { recursive: true, withFileTypes: true })
+    .filter(entry => entry.isFile() && entry.name.endsWith('.js'))
+    .map(
+      entry => `/${path.relative(CLIENT_OUTPUT, path.join(entry.parentPath, entry.name)).split(path.sep).join('/')}`,
+    );
+  assert.ok(clientChunkUrls.length > 0, `Expected client chunks in ${CLIENT_OUTPUT}`);
+
+  const server = await startNodeServer({ entry: path.join(SERVER_OUTPUT, 'index.mjs'), port: 3030 });
+
+  try {
+    // Without this, a server that serves no public files at all would pass the 404 checks.
+    const chunkStatus = (await fetch(`${server.baseUrl}${clientChunkUrls[0]}`)).status;
+    assert.equal(chunkStatus, 200, `Expected the server to serve the client chunk ${clientChunkUrls[0]}`);
+
+    // Nitro serves public files from a list it writes into the server bundle. A map deleted after that
+    // stays on the list, and Nitro answers its request with a 500 instead of a 404.
+    const responses = await Promise.all(
+      clientChunkUrls.map(async chunkUrl => {
+        const mapUrl = `${chunkUrl}.map`;
+        const expectedStatus = fs.existsSync(path.join(CLIENT_OUTPUT, mapUrl)) ? 200 : 404;
+        const { status } = await fetch(`${server.baseUrl}${mapUrl}`);
+        return { mapUrl, status, expectedStatus };
+      }),
+    );
+    const unexpectedStatuses = responses
+      .filter(({ status, expectedStatus }) => status !== expectedStatus)
+      .map(({ mapUrl, status, expectedStatus }) => `${mapUrl} → ${status}, expected ${expectedStatus}`);
+    assert.deepEqual(
+      unexpectedStatuses,
+      [],
+      'Expected the server to answer each client source map URL with 200 if the map is in the output, else 404',
+    );
+
+    console.log(`  The server answers all ${clientChunkUrls.length} client source map URL(s) as expected\n`);
+  } finally {
+    await server.close();
+  }
+}
+
 console.log('All sourcemap assertions passed!');
diff --git a/dev-packages/test-utils/src/index.ts b/dev-packages/test-utils/src/index.ts
index 9b245bd74ee5..bb70d9382f9e 100644
--- a/dev-packages/test-utils/src/index.ts
+++ b/dev-packages/test-utils/src/index.ts
@@ -38,6 +38,9 @@ export { getRuntime } from './runtime';
 export type { Runtime } from './runtime';
 export { createBasicSentryServer, createTestServer } from './server';
 
+export { startNodeServer } from './node-server';
+export type { NodeServerOptions, NodeServer } from './node-server';
+
 export { startMockSentryServer } from './mock-sentry-server';
 export type { MockSentryServerOptions, MockSentryServer } from './mock-sentry-server';
 export * from './sourcemap-upload-utils';
diff --git a/dev-packages/test-utils/src/node-server.ts b/dev-packages/test-utils/src/node-server.ts
new file mode 100644
index 000000000000..c2bf6791af29
--- /dev/null
+++ b/dev-packages/test-utils/src/node-server.ts
@@ -0,0 +1,55 @@
+import { spawn } from 'node:child_process';
+
+export interface NodeServerOptions {
+  /** Path to the server entry, e.g. `.output/server/index.mjs`. */
+  entry: string;
+  port: number;
+  /** How long to wait for the first response. Defaults to 30 seconds. */
+  timeoutMs?: number;
+}
+
+export interface NodeServer {
+  baseUrl: string;
+  /** Stops the server and resolves once its process has exited. */
+  close: () => Promise<void>;
+}
+
+/**
+ * Starts a built Node server and resolves once it answers HTTP requests. The server gets the port via `PORT`.
+ *
+ * Rejects if the server exits or does not answer before the timeout. Its output is printed only then.
+ */
+export async function startNodeServer({ entry, port, timeoutMs = 30_000 }: NodeServerOptions): Promise<NodeServer> {
+  const baseUrl = `http://localhost:${port}`;
+  const child = spawn(process.execPath, [entry], { env: { ...process.env, PORT: String(port) } });
+
+  let output = '';
+  child.stdout.on('data', chunk => (output += chunk));
+  child.stderr.on('data', chunk => (output += chunk));
+
+  const close = async (): Promise<void> => {
+    if (child.exitCode !== null || child.signalCode !== null) {
+      return;
+    }
+    const exited = new Promise(resolve => child.once('exit', resolve));
+    child.kill();
+    await exited;
+  };
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (child.exitCode !== null) {
+      throw new Error(`Server ${entry} exited with code ${child.exitCode} before it answered:\n${output}`);
+    }
+
+    try {
+      await fetch(baseUrl);
+      return { baseUrl, close };
+    } catch {
+      await new Promise(resolve => setTimeout(resolve, 250));
+    }
+  }
+
+  await close();
+  throw new Error(`Server ${entry} did not answer on ${baseUrl} within ${timeoutMs}ms:\n${output}`);
+}
diff --git a/packages/nuxt/src/vite/sourceMapDeletion.ts b/packages/nuxt/src/vite/sourceMapDeletion.ts
index dc23fcf7c5f5..01b4d21daecf 100644
--- a/packages/nuxt/src/vite/sourceMapDeletion.ts
+++ b/packages/nuxt/src/vite/sourceMapDeletion.ts
@@ -1,4 +1,6 @@
-import { createSentryBuildPluginManager, type Options } from '@sentry/bundler-plugins/core';
+import { createSentryBuildPluginManager, globFiles, type Options } from '@sentry/bundler-plugins/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 
 export function withoutSourceMapDeletion(options: Options): Options {
   return {
@@ -32,3 +34,43 @@ export async function deleteSourceMapsAfterBuild(options: Options): Promise<void
 
   await sentryBuildPluginManager.deleteArtifacts();
 }
+
+/**
+ * Deletes the files in `publicDir` that match `filesToDeleteAfterUpload`. Nitro answers a request for a file it
+ * listed at build time but cannot read with a 500. Files outside `publicDir` are deleted in `close`.
+ */
+export async function deletePublicSourceMaps(options: Options, publicDir: string): Promise<void> {
+  const filesToDeleteAfterUpload = await options.sourcemaps?.filesToDeleteAfterUpload;
+
+  if (filesToDeleteAfterUpload === undefined) {
+    return;
+  }
+
+  const files = await globFiles(filesToDeleteAfterUpload);
+  const publicFiles = files.filter(file => isInDirectory(file, publicDir));
+
+  await Promise.all(
+    publicFiles.map(async file => {
+      logDebug(options, `Deleting ${file} before Nitro bundles the server.`);
+      // `deleteSourceMapsAfterBuild` tries again in `close`.
+      await fs.promises.rm(file, { force: true }).catch(error => logDebug(options, `Could not delete ${file}.`, error));
+    }),
+  );
+}
+
+function logDebug(options: Options, ...messages: unknown[]): void {
+  if (options.debug) {
+    // eslint-disable-next-line no-console
+    console.log('[Sentry]', ...messages);
+  }
+}
+
+function isInDirectory(file: string, directory: string): boolean {
+  const relativePath = path.relative(directory, file);
+  return (
+    relativePath !== '' &&
+    relativePath !== '..' &&
+    !relativePath.startsWith(`..${path.sep}`) &&
+    !path.isAbsolute(relativePath)
+  );
+}
diff --git a/packages/nuxt/src/vite/sourceMaps.ts b/packages/nuxt/src/vite/sourceMaps.ts
index d03c725e6c8c..5d0f634fac59 100644
--- a/packages/nuxt/src/vite/sourceMaps.ts
+++ b/packages/nuxt/src/vite/sourceMaps.ts
@@ -5,7 +5,7 @@ import { warnOnRemovedBuildOptions } from '@sentry/core';
 import type { NitroConfig } from 'nitropack';
 import type { Plugin } from 'vite';
 import type { SentryNuxtModuleOptions } from '../common/types';
-import { deleteSourceMapsAfterBuild, withoutSourceMapDeletion } from './sourceMapDeletion';
+import { deletePublicSourceMaps, deleteSourceMapsAfterBuild, withoutSourceMapDeletion } from './sourceMapDeletion';
 import { validateSourceMapsOptionsPlugin } from './sentryVitePlugin';
 
 /**
@@ -112,6 +112,24 @@ export function setupSourceMaps(
     }
   });
 
+  nuxt.hook('nitro:init', nitro => {
+    if (sourceMapsEnabled && !nitro.options.dev && !nuxt.options?._prepare) {
+      const publicDir = nitro.options.output.publicDir;
+      const rollupConfig = (nitro.options.rollupConfig ??= { output: {} });
+
+      rollupConfig.plugins = [
+        rollupConfig.plugins,
+        {
+          name: 'sentry-nuxt-public-source-map-deletion',
+          // By now the client build is in the public dir, and Nitro has not yet listed its files.
+          async buildStart() {
+            await deletePublicSourceMaps(getPluginOptions(moduleOptions, shouldDeleteFilesFallback), publicDir);
+          },
+        },
+      ];
+    }
+  });
+
   nuxt.hook('close', async () => {
     if (sourceMapsEnabled && !nuxt.options.dev && !nuxt.options?._prepare) {
       await deleteSourceMapsAfterBuild(getPluginOptions(moduleOptions, shouldDeleteFilesFallback));
diff --git a/packages/nuxt/test/vite/sourceMapDeletion.test.ts b/packages/nuxt/test/vite/sourceMapDeletion.test.ts
new file mode 100644
index 000000000000..1599aebcdf9f
--- /dev/null
+++ b/packages/nuxt/test/vite/sourceMapDeletion.test.ts
@@ -0,0 +1,95 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { deletePublicSourceMaps } from '../../src/vite/sourceMapDeletion';
+
+const BUILD_FILES = [
+  '.output/public/_nuxt/entry.DxB3kLmA.js',
+  '.output/public/_nuxt/entry.DxB3kLmA.js.map',
+  '.output/public/_nuxt/pages/products.Cq81zR4t.js.map',
+  '.output/public-assets/_nuxt/entry.DxB3kLmA.js.map',
+  '.output/server/chunks/nitro/nitro.mjs.map',
+  '.nuxt/dist/server/_nuxt/index-B2kR7mXp.mjs.map',
+];
+
+let rootDir: string;
+let publicDir: string;
+
+/** Glob patterns need forward slashes, also on Windows. */
+function toGlob(relativePattern: string): string {
+  return path.join(rootDir, relativePattern).split(path.sep).join('/');
+}
+
+function remainingFiles(): string[] {
+  return BUILD_FILES.filter(file => fs.existsSync(path.join(rootDir, file)));
+}
+
+describe('deletePublicSourceMaps', () => {
+  beforeEach(() => {
+    rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sentry-nuxt-source-map-deletion-'));
+    publicDir = path.join(rootDir, '.output', 'public');
+
+    for (const file of BUILD_FILES) {
+      fs.mkdirSync(path.dirname(path.join(rootDir, file)), { recursive: true });
+      fs.writeFileSync(path.join(rootDir, file), '');
+    }
+  });
+
+  afterEach(() => {
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  });
+
+  it('deletes the matched files in the public dir and keeps the matched files outside of it', async () => {
+    await deletePublicSourceMaps(
+      {
+        sourcemaps: {
+          filesToDeleteAfterUpload: [toGlob('.*/**/public*/**/*.map'), toGlob('.*/**/server/**/*.map')],
+        },
+      },
+      publicDir,
+    );
+
+    expect(remainingFiles()).toEqual([
+      '.output/public/_nuxt/entry.DxB3kLmA.js',
+      '.output/public-assets/_nuxt/entry.DxB3kLmA.js.map',
+      '.output/server/chunks/nitro/nitro.mjs.map',
+      '.nuxt/dist/server/_nuxt/index-B2kR7mXp.mjs.map',
+    ]);
+  });
+
+  it('keeps the files in the public dir that no pattern matches', async () => {
+    await deletePublicSourceMaps(
+      { sourcemaps: { filesToDeleteAfterUpload: toGlob('.output/public/_nuxt/pages/*.map') } },
+      publicDir,
+    );
+
+    expect(remainingFiles()).toEqual([
+      '.output/public/_nuxt/entry.DxB3kLmA.js',
+      '.output/public/_nuxt/entry.DxB3kLmA.js.map',
+      '.output/public-assets/_nuxt/entry.DxB3kLmA.js.map',
+      '.output/server/chunks/nitro/nitro.mjs.map',
+      '.nuxt/dist/server/_nuxt/index-B2kR7mXp.mjs.map',
+    ]);
+  });
+
+  it('resolves a promised list of patterns', async () => {
+    await deletePublicSourceMaps(
+      { sourcemaps: { filesToDeleteAfterUpload: Promise.resolve([toGlob('.output/public/**/*.map')]) } },
+      publicDir,
+    );
+
+    expect(remainingFiles()).toEqual([
+      '.output/public/_nuxt/entry.DxB3kLmA.js',
+      '.output/public-assets/_nuxt/entry.DxB3kLmA.js.map',
+      '.output/server/chunks/nitro/nitro.mjs.map',
+      '.nuxt/dist/server/_nuxt/index-B2kR7mXp.mjs.map',
+    ]);
+  });
+
+  it('deletes nothing when no deletion patterns are set', async () => {
+    await deletePublicSourceMaps({ sourcemaps: {} }, publicDir);
+
+    expect(remainingFiles()).toEqual(BUILD_FILES);
+  });
+});
diff --git a/packages/nuxt/test/vite/sourceMaps-nuxtHooks.test.ts b/packages/nuxt/test/vite/sourceMaps-nuxtHooks.test.ts
index 18f67df7ab40..2059462d1490 100644
--- a/packages/nuxt/test/vite/sourceMaps-nuxtHooks.test.ts
+++ b/packages/nuxt/test/vite/sourceMaps-nuxtHooks.test.ts
@@ -1,6 +1,10 @@
 import type { Nuxt } from '@nuxt/schema';
+import type * as BundlerPluginsCore from '@sentry/bundler-plugins/core';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
 import type { ConfigEnv, Plugin, UserConfig } from 'vite';
-import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterAll, afterEach, beforeEach, describe, expect, it, type MockInstance, vi } from 'vitest';
 import { setupSourceMaps, type SourceMapSetting } from '../../src/vite/sourceMaps';
 
 const { mockSentryVitePlugin, mockSentryRollupPlugin, mockDeleteArtifacts, mockCreateSentryBuildPluginManager } =
@@ -15,7 +19,8 @@ const { mockSentryVitePlugin, mockSentryRollupPlugin, mockDeleteArtifacts, mockC
     };
   });
 
-vi.mock('@sentry/bundler-plugins/core', () => ({
+vi.mock('@sentry/bundler-plugins/core', async importOriginal => ({
+  ...(await importOriginal<typeof BundlerPluginsCore>()),
   createSentryBuildPluginManager: mockCreateSentryBuildPluginManager,
 }));
 vi.mock('@sentry/bundler-plugins/vite', () => ({ sentryVitePlugin: mockSentryVitePlugin }));
@@ -369,6 +374,104 @@ describe('setupSourceMaps hooks', () => {
     });
   });
 
+  describe('nitro:init hook', () => {
+    const PUBLIC_MAP = '.output/public/_nuxt/entry.DxB3kLmA.js.map';
+    const PUBLIC_CHUNK = '.output/public/_nuxt/entry.DxB3kLmA.js';
+    const SSR_BUILD_MAP = '.nuxt/dist/server/_nuxt/index-B2kR7mXp.mjs.map';
+
+    let rootDir: string;
+    let cwdSpy: MockInstance<typeof process.cwd>;
+
+    beforeEach(() => {
+      rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sentry-nuxt-root-'));
+      // The fallback deletion patterns are relative to the working directory.
+      cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(rootDir);
+      for (const file of [PUBLIC_MAP, PUBLIC_CHUNK, SSR_BUILD_MAP]) {
+        fs.mkdirSync(path.dirname(path.join(rootDir, file)), { recursive: true });
+        fs.writeFileSync(path.join(rootDir, file), '');
+      }
+    });
+
+    afterEach(() => {
+      cwdSpy.mockRestore();
+      fs.rmSync(rootDir, { recursive: true, force: true });
+    });
+
+    function createMockNitro(options: { dev?: boolean } = {}) {
+      return {
+        options: {
+          dev: options.dev ?? false,
+          output: { publicDir: path.join(rootDir, '.output', 'public') },
+          rollupConfig: { plugins: [{ name: 'sentry-rollup-plugin' }] as unknown },
+        },
+      };
+    }
+
+    function findDeletionPlugin(nitro: ReturnType<typeof createMockNitro>) {
+      return [nitro.options.rollupConfig.plugins]
+        .flat(2)
+        .find(
+          (plugin): plugin is { name: string; buildStart: () => Promise<void> } =>
+            typeof plugin === 'object' &&
+            plugin !== null &&
+            'name' in plugin &&
+            plugin.name === 'sentry-nuxt-public-source-map-deletion' &&
+            'buildStart' in plugin &&
+            typeof plugin.buildStart === 'function',
+        );
+    }
+
+    function remainingFiles(): string[] {
+      return [PUBLIC_MAP, PUBLIC_CHUNK, SSR_BUILD_MAP].filter(file => fs.existsSync(path.join(rootDir, file)));
+    }
+
+    it('deletes the source maps in the Nitro public dir when Nitro starts to bundle the server', async () => {
+      const mockNuxt = createMockNuxt({ sourcemap: { client: 'hidden', server: true } });
+      const nitro = createMockNitro();
+      const filesToDeleteAfterUpload = [`${rootDir.split(path.sep).join('/')}/.output/public/**/*.map`];
+
+      setupSourceMaps({ sourcemaps: { filesToDeleteAfterUpload } }, mockNuxt as unknown as Nuxt, vi.fn());
+      await mockNuxt.triggerHook('modules:done');
+      await mockNuxt.triggerHook('nitro:init', nitro);
+      const deletionPlugin = findDeletionPlugin(nitro);
+      await deletionPlugin?.buildStart();
+
+      expect(deletionPlugin).toBeDefined();
+      expect(remainingFiles()).toEqual([PUBLIC_CHUNK, SSR_BUILD_MAP]);
+    });
+
+    it('deletes only the public source maps with the fallback patterns and keeps the SSR build maps', async () => {
+      const mockNuxt = createMockNuxt({ sourcemap: { client: undefined, server: undefined } });
+      const nitro = createMockNitro();
+
+      setupSourceMaps({}, mockNuxt as unknown as Nuxt, vi.fn());
+      await mockNuxt.triggerHook('modules:done');
+      await mockNuxt.triggerHook('nitro:init', nitro);
+      const deletionPlugin = findDeletionPlugin(nitro);
+      await deletionPlugin?.buildStart();
+
+      expect(deletionPlugin).toBeDefined();
+      expect(remainingFiles()).toEqual([PUBLIC_CHUNK, SSR_BUILD_MAP]);
+    });
+
+    it.each([
+      { label: 'prepare mode', nuxtOptions: { _prepare: true }, nitroOptions: {} },
+      { label: 'dev mode', nuxtOptions: { dev: true }, nitroOptions: { dev: true } },
+    ])('does not add the deletion plugin in $label', async ({ nuxtOptions, nitroOptions }) => {
+      const mockNuxt = createMockNuxt(nuxtOptions);
+      const nitro = createMockNitro(nitroOptions);
+
+      setupSourceMaps(
+        { sourcemaps: { filesToDeleteAfterUpload: ['.output/**/*.map'] } },
+        mockNuxt as unknown as Nuxt,
+        vi.fn(),
+      );
+      await mockNuxt.triggerHook('nitro:init', nitro);
+
+      expect(findDeletionPlugin(nitro)).toBeUndefined();
+    });
+  });
+
   describe('debug logging', () => {
     it('logs a [Sentry] message in production mode', async () => {
       const mockNuxt = createMockNuxt({ _prepare: false, dev: false });

From 938c7ea1eb4267672312073781d032aa10013c3a Mon Sep 17 00:00:00 2001
From: Charly Gomez <charly.gomez1310@gmail.com>
Date: Mon, 12 Oct 2026 14:55:18 +0200
Subject: [PATCH 69/84] fix(sveltekit): Read load event pathname untracked
 (#25235)

The `url.path` attribute added in #24341 made the load wrappers read
`event.url.pathname` outside `untrack`. SvelteKit took that as the load
depending on the URL, so every wrapped load reran on each navigation.
With auto-instrumentation on, that's every load in the app.

The pathname is now read through `event.untrack`, the same way
`getRouteId` already reads `route.id`. On SvelteKit 2 versions that
don't have `untrack` yet, it calls the native `URL.prototype` getter
instead. SvelteKit's tracking getter is an own property on `event.url`,
so the native getter skips it.

Fixes #25231

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../load-dependencies/+layout.server.ts       |  7 ++++
 .../routes/load-dependencies/+layout.svelte   |  6 +++
 .../routes/load-dependencies/a/+page.svelte   |  2 +
 .../routes/load-dependencies/b/+page.svelte   |  1 +
 .../tests/load-dependencies.test.ts           | 20 ++++++++++
 packages/sveltekit/src/client/load.ts         |  7 ++--
 packages/sveltekit/src/common/utils.ts        | 13 +++++++
 packages/sveltekit/src/server-common/load.ts  | 12 +++---
 packages/sveltekit/test/client/load.test.ts   | 25 +++++++++++-
 packages/sveltekit/test/common/utils.test.ts  | 31 ++++++++++++++-
 .../sveltekit/test/server-common/load.test.ts | 36 +++++++++++++++--
 packages/sveltekit/test/utils.ts              | 39 +++++++++++++++++++
 12 files changed, 185 insertions(+), 14 deletions(-)
 create mode 100644 dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/+layout.server.ts
 create mode 100644 dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/+layout.svelte
 create mode 100644 dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/a/+page.svelte
 create mode 100644 dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/b/+page.svelte
 create mode 100644 dev-packages/e2e-tests/test-applications/sveltekit-2/tests/load-dependencies.test.ts

diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/+layout.server.ts b/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/+layout.server.ts
new file mode 100644
index 000000000000..dc09d4b51030
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/+layout.server.ts
@@ -0,0 +1,7 @@
+let layoutLoadCount = 0;
+
+// Doesn't read `url`, so SvelteKit should only run it once across child navigations.
+export const load = async () => {
+  layoutLoadCount++;
+  return { layoutLoadCount };
+};
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/+layout.svelte b/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/+layout.svelte
new file mode 100644
index 000000000000..44e7f425d54b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/+layout.svelte
@@ -0,0 +1,6 @@
+<script lang="ts">
+  export let data;
+</script>
+
+<p id="layout-load-count">Layout loads: {data.layoutLoadCount}</p>
+<slot></slot>
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/a/+page.svelte b/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/a/+page.svelte
new file mode 100644
index 000000000000..6039c292a519
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/a/+page.svelte
@@ -0,0 +1,2 @@
+<h2>Page A</h2>
+<a href="/load-dependencies/b">Go to B</a>
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/b/+page.svelte b/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/b/+page.svelte
new file mode 100644
index 000000000000..f298fcc8d37b
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-2/src/routes/load-dependencies/b/+page.svelte
@@ -0,0 +1 @@
+<h2>Page B</h2>
diff --git a/dev-packages/e2e-tests/test-applications/sveltekit-2/tests/load-dependencies.test.ts b/dev-packages/e2e-tests/test-applications/sveltekit-2/tests/load-dependencies.test.ts
new file mode 100644
index 000000000000..1d1cf49de0f0
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/sveltekit-2/tests/load-dependencies.test.ts
@@ -0,0 +1,20 @@
+import { expect, test } from '@playwright/test';
+import { getSpanOp, waitForStreamedSpan } from '@sentry-internal/test-utils';
+import { waitForInitialPageload } from './utils';
+
+test("doesn't rerun a wrapped layout server load that doesn't depend on the url", async ({ page }) => {
+  await waitForInitialPageload(page, { route: '/load-dependencies/a' });
+
+  const layoutLoadCount = page.locator('#layout-load-count');
+  const initialText = await layoutLoadCount.textContent();
+
+  const navigationSpanPromise = waitForStreamedSpan('sveltekit-2', span => {
+    return span.name === '/load-dependencies/b' && getSpanOp(span) === 'navigation' && span.is_segment;
+  });
+
+  await page.getByText('Go to B').click();
+  await expect(page.getByText('Page B')).toBeVisible();
+  await navigationSpanPromise;
+
+  await expect(layoutLoadCount).toHaveText(initialText!);
+});
diff --git a/packages/sveltekit/src/client/load.ts b/packages/sveltekit/src/client/load.ts
index a1a78995ce0e..a96634963899 100644
--- a/packages/sveltekit/src/client/load.ts
+++ b/packages/sveltekit/src/client/load.ts
@@ -19,7 +19,7 @@ import { FUNCTION } from '@sentry/conventions/op';
 import { captureException } from '@sentry/svelte';
 import type { LoadEvent } from '@sveltejs/kit';
 import type { SentryWrappedFlag } from '../common/utils';
-import { getRouteId, isHttpError, isRedirect } from '../common/utils';
+import { getPathname, getRouteId, isHttpError, isRedirect } from '../common/utils';
 
 type PatchedLoadEvent = LoadEvent & Partial<SentryWrappedFlag>;
 
@@ -83,7 +83,8 @@ export function wrapLoadWithSentry<T extends (...args: any) => any>(origLoad: T)
       addNonEnumerableProperty(patchedEvent, '__sentry_wrapped__', true);
 
       const routeId = getRouteId(event);
-      const routeOrPathname = routeId ? routeId : event.url.pathname;
+      const pathname = getPathname(event);
+      const routeOrPathname = routeId ? routeId : pathname;
 
       const client = getClient();
       const hasSpanStreaming = !!client && hasSpanStreamingEnabled(client);
@@ -97,7 +98,7 @@ export function wrapLoadWithSentry<T extends (...args: any) => any>(origLoad: T)
             [CODE_FUNCTION_NAME]: 'load',
             [SENTRY_ORIGIN]: 'auto.function.sveltekit',
             [SENTRY_SEGMENT_NAME_SOURCE]: routeId ? 'route' : 'url',
-            [URL_PATH]: event.url.pathname,
+            [URL_PATH]: pathname,
             ...(routeId && { [URL_TEMPLATE]: routeId }),
             // Relay infers the description from `code.function.name`, which would drop the route.
             ...(hasSpanStreaming && { [SENTRY_DESCRIPTION]: routeOrPathname }),
diff --git a/packages/sveltekit/src/common/utils.ts b/packages/sveltekit/src/common/utils.ts
index b5621cddd059..73326f81e146 100644
--- a/packages/sveltekit/src/common/utils.ts
+++ b/packages/sveltekit/src/common/utils.ts
@@ -15,6 +15,7 @@ interface EventLike {
   route?: {
     id?: string | null;
   };
+  url: URL;
   untrack<T>(fn: () => T): T;
 }
 
@@ -43,6 +44,18 @@ export function getRouteId(event: EventLike): string | void {
   return;
 }
 
+/**
+ * Get url.pathname from a load event without making the load depend on the URL.
+ * Without `untrack`, calls the native getter to skip SvelteKit's tracking getter on `event.url`.
+ */
+export function getPathname(event: EventLike): string {
+  if (typeof event.untrack === 'function') {
+    return event.untrack(() => event.url.pathname);
+  }
+
+  return Reflect.get(URL.prototype, 'pathname', event.url);
+}
+
 /**
  * Determines if a thrown "error" is a Redirect object which SvelteKit users can throw to redirect to another route
  * see: https://kit.svelte.dev/docs/modules#sveltejs-kit-redirect
diff --git a/packages/sveltekit/src/server-common/load.ts b/packages/sveltekit/src/server-common/load.ts
index 5a6dfd93100b..cfad7bcf9621 100644
--- a/packages/sveltekit/src/server-common/load.ts
+++ b/packages/sveltekit/src/server-common/load.ts
@@ -13,7 +13,7 @@ import {
 import { FUNCTION } from '@sentry/conventions/op';
 import type { LoadEvent, ServerLoadEvent } from '@sveltejs/kit';
 import type { SentryWrappedFlag } from '../common/utils';
-import { getRouteId } from '../common/utils';
+import { getPathname, getRouteId } from '../common/utils';
 import { sendErrorToSentry } from './utils';
 
 type PatchedLoadEvent = LoadEvent & SentryWrappedFlag;
@@ -41,7 +41,8 @@ export function wrapLoadWithSentry<T extends (...args: any) => any>(origLoad: T)
       addNonEnumerableProperty(event, '__sentry_wrapped__', true);
 
       const routeId = getRouteId(event) ?? undefined;
-      const routeOrPathname = routeId ? routeId : event.url.pathname;
+      const pathname = getPathname(event);
+      const routeOrPathname = routeId ? routeId : pathname;
 
       const client = getClient();
       const hasSpanStreaming = !!client && hasSpanStreamingEnabled(client);
@@ -56,7 +57,7 @@ export function wrapLoadWithSentry<T extends (...args: any) => any>(origLoad: T)
               [CODE_FUNCTION_NAME]: 'load',
               [SENTRY_ORIGIN]: 'auto.function.sveltekit',
               [SENTRY_SEGMENT_NAME_SOURCE]: routeId ? 'route' : 'url',
-              [URL_PATH]: event.url.pathname,
+              [URL_PATH]: pathname,
               [HTTP_ROUTE]: routeId,
               // Relay infers the description from `code.function.name`, which would drop the route.
               ...(hasSpanStreaming && { [SENTRY_DESCRIPTION]: routeOrPathname }),
@@ -113,7 +114,8 @@ export function wrapServerLoadWithSentry<T extends (...args: any) => any>(origSe
       // server `load` function's data on every route change. We use `getRouteId` which uses
       // SvelteKit 2's `untrack` when available, otherwise getOwnPropertyDescriptor for 1.x.
       const routeId = getRouteId(event) ?? undefined;
-      const routeOrPathname = routeId ? routeId : event.url.pathname;
+      const pathname = getPathname(event);
+      const routeOrPathname = routeId ? routeId : pathname;
 
       const client = getClient();
       const hasSpanStreaming = !!client && hasSpanStreamingEnabled(client);
@@ -128,7 +130,7 @@ export function wrapServerLoadWithSentry<T extends (...args: any) => any>(origSe
               [SENTRY_ORIGIN]: 'auto.function.sveltekit.server',
               [SENTRY_SEGMENT_NAME_SOURCE]: routeId ? 'route' : 'url',
               [HTTP_REQUEST_METHOD]: event.request.method,
-              [URL_PATH]: event.url.pathname,
+              [URL_PATH]: pathname,
               [HTTP_ROUTE]: routeId,
               // Relay infers the description from `code.function.name`, which would drop the route.
               ...(hasSpanStreaming && { [SENTRY_DESCRIPTION]: routeOrPathname }),
diff --git a/packages/sveltekit/test/client/load.test.ts b/packages/sveltekit/test/client/load.test.ts
index 5978a2bffc01..c975b7e9fcd9 100644
--- a/packages/sveltekit/test/client/load.test.ts
+++ b/packages/sveltekit/test/client/load.test.ts
@@ -1,4 +1,4 @@
-import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN, URL_PATH } from '@sentry/conventions/attributes';
 import type { Client } from '@sentry/core';
 import * as SentryCore from '@sentry/core';
 import * as SentrySvelte from '@sentry/svelte';
@@ -6,6 +6,7 @@ import type { Load } from '@sveltejs/kit';
 import { redirect } from '@sveltejs/kit';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { wrapLoadWithSentry } from '../../src/client/load';
+import { createTrackedLoadEvent } from '../utils';
 
 const mockCaptureException = vi.spyOn(SentrySvelte, 'captureException').mockImplementation(() => 'xx');
 
@@ -164,7 +165,7 @@ describe('wrapLoadWithSentry', () => {
       const wrappedLoad = wrapLoadWithSentry(load);
       await wrappedLoad(eventWithUntrack);
 
-      expect(untrack).toHaveBeenCalledTimes(1);
+      expect(untrack).toHaveBeenCalledTimes(2);
       expect(mockStartSpan).toHaveBeenCalledWith(
         expect.objectContaining({
           name: routeIdFromUntrack,
@@ -176,6 +177,26 @@ describe('wrapLoadWithSentry', () => {
       );
     });
 
+    it("doesn't add route or url dependencies to the load function when untrack is present", async () => {
+      const { event, trackedReads } = createTrackedLoadEvent({
+        params: { id: '123' },
+        route: { id: '/users/[id]' },
+        url: new URL('http://localhost:3000/users/123'),
+      });
+
+      const wrappedLoad = wrapLoadWithSentry(async () => ({}));
+      await wrappedLoad(event);
+
+      expect(trackedReads).toEqual([]);
+      expect(mockStartSpan).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: '/users/[id]',
+          attributes: expect.objectContaining({ [URL_PATH]: '/users/123' }),
+        }),
+        expect.any(Function),
+      );
+    });
+
     describe('with span streaming enabled', () => {
       beforeEach(() => {
         vi.spyOn(SentryCore, 'getClient').mockImplementation(
diff --git a/packages/sveltekit/test/common/utils.test.ts b/packages/sveltekit/test/common/utils.test.ts
index 6650a491c80f..015f6b8ac573 100644
--- a/packages/sveltekit/test/common/utils.test.ts
+++ b/packages/sveltekit/test/common/utils.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { getRouteId, isHttpError, isRedirect } from '../../src/common/utils';
+import { getPathname, getRouteId, isHttpError, isRedirect } from '../../src/common/utils';
 
 describe('isRedirect', () => {
   it.each([
@@ -102,3 +102,32 @@ describe('getRouteId', () => {
     expect(getRouteId({ route: null })).toBeUndefined();
   });
 });
+
+describe('getPathname', () => {
+  it('reads url.pathname through untrack when available (SvelteKit 2+)', () => {
+    const untrack = vi.fn(<T>(fn: () => T) => fn());
+    const event = {
+      url: new URL('http://localhost:3000/users/123'),
+      untrack,
+    };
+
+    // @ts-expect-error - only passing a partial load event here
+    expect(getPathname(event)).toBe('/users/123');
+    expect(untrack).toHaveBeenCalledTimes(1);
+  });
+
+  it('bypasses tracked url getters without untrack', () => {
+    const tracked = vi.fn();
+    const url = new URL('http://localhost:3000/users/123');
+    Object.defineProperty(url, 'pathname', {
+      get() {
+        tracked();
+        return '/tracked';
+      },
+    });
+
+    // @ts-expect-error - only passing a partial load event here
+    expect(getPathname({ url })).toBe('/users/123');
+    expect(tracked).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/sveltekit/test/server-common/load.test.ts b/packages/sveltekit/test/server-common/load.test.ts
index 97b3a6390c08..9758c4852903 100644
--- a/packages/sveltekit/test/server-common/load.test.ts
+++ b/packages/sveltekit/test/server-common/load.test.ts
@@ -1,4 +1,4 @@
-import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes';
+import { SENTRY_SEGMENT_NAME_SOURCE, SENTRY_OP, SENTRY_ORIGIN, URL_PATH } from '@sentry/conventions/attributes';
 import type { Client, Event } from '@sentry/core';
 import * as SentryCore from '@sentry/core';
 import { NodeClient, setCurrentClient } from '@sentry/node';
@@ -6,7 +6,7 @@ import type { Load, ServerLoad } from '@sveltejs/kit';
 import { error, redirect } from '@sveltejs/kit';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { wrapLoadWithSentry, wrapServerLoadWithSentry } from '../../src/server-common/load';
-import { getDefaultNodeClientOptions } from '../utils';
+import { createTrackedLoadEvent, getDefaultNodeClientOptions } from '../utils';
 
 const mockCaptureException = vi.spyOn(SentryCore, 'captureException').mockImplementation(() => 'xx');
 
@@ -320,7 +320,7 @@ describe('wrapServerLoadWithSentry calls `startSpan`', () => {
     const wrappedLoad = wrapServerLoadWithSentry(serverLoad);
     await wrappedLoad(eventWithUntrack);
 
-    expect(untrack).toHaveBeenCalledTimes(1);
+    expect(untrack).toHaveBeenCalledTimes(2);
     expect(mockStartSpan).toHaveBeenCalledWith(
       expect.objectContaining({
         name: '/users/[id]',
@@ -333,6 +333,36 @@ describe('wrapServerLoadWithSentry calls `startSpan`', () => {
   });
 });
 
+describe.each([
+  ['wrapLoadWithSentry', wrapLoadWithSentry],
+  ['wrapServerLoadWithSentry', wrapServerLoadWithSentry],
+])('%s with untrack (SvelteKit 2+)', (_, sentryLoadWrapperFn) => {
+  it("doesn't add route or url dependencies to the load function", async () => {
+    const { event, trackedReads } = createTrackedLoadEvent(getServerOnlyArgs());
+
+    const wrappedLoad = sentryLoadWrapperFn(() => ({}));
+    await wrappedLoad(event);
+
+    expect(trackedReads).toEqual([]);
+    expect(mockStartSpan).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: '/users/[id]',
+        attributes: expect.objectContaining({ [URL_PATH]: '/users/123' }),
+      }),
+      expect.any(Function),
+    );
+  });
+
+  it('still tracks url reads made by the load function itself', async () => {
+    const { event, trackedReads } = createTrackedLoadEvent(getServerOnlyArgs());
+
+    const wrappedLoad = sentryLoadWrapperFn(({ url }: { url: URL }) => ({ path: url.pathname }));
+    await wrappedLoad(event);
+
+    expect(trackedReads).toEqual(['url.pathname']);
+  });
+});
+
 describe('with span streaming enabled', () => {
   beforeEach(() => {
     vi.spyOn(SentryCore, 'getClient').mockImplementation(
diff --git a/packages/sveltekit/test/utils.ts b/packages/sveltekit/test/utils.ts
index 29d32e8df2c7..3f8e0deca433 100644
--- a/packages/sveltekit/test/utils.ts
+++ b/packages/sveltekit/test/utils.ts
@@ -11,3 +11,42 @@ export function getDefaultNodeClientOptions(options: Partial<ClientOptions> = {}
     ...options,
   };
 }
+
+/**
+ * Mimics SvelteKit's dependency tracking: reads of `url` and `route` members are recorded
+ * unless they happen inside `untrack`.
+ */
+export function createTrackedLoadEvent<T extends object>(
+  event: T & { url: URL; route: { id: string | null } },
+): { event: T & { untrack: <R>(fn: () => R) => R }; trackedReads: string[] } {
+  const trackedReads: string[] = [];
+  let tracking = true;
+
+  const track = <O extends object>(target: O, name: string): O =>
+    new Proxy(target, {
+      get(target, prop) {
+        if (tracking && typeof prop === 'string') {
+          trackedReads.push(`${name}.${prop}`);
+        }
+        const value = Reflect.get(target, prop);
+        return typeof value === 'function' ? value.bind(target) : value;
+      },
+    });
+
+  return {
+    event: {
+      ...event,
+      url: track(event.url, 'url'),
+      route: track(event.route, 'route'),
+      untrack: <R>(fn: () => R): R => {
+        tracking = false;
+        try {
+          return fn();
+        } finally {
+          tracking = true;
+        }
+      },
+    },
+    trackedReads,
+  };
+}

From 7ceed2fbeee5e9519c545627fdce9066e149de59 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 12 Oct 2026 15:07:12 +0200
Subject: [PATCH 70/84] feat(deps): Bump pino from 9.10.0 to 10.4.0 (#25238)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [pino](https://github.com/pinojs/pino) from 9.10.0 to 10.4.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a
href="https://github.com/pinojs/pino/releases">pino's
releases</a>.</em></p>
<blockquote>
<h2>v10.4.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Add warning on incompatible formatters.level with multi-target
transports by <a
href="https://github.com/lraveri"><code>@​lraveri</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2381">pinojs/pino#2381</a></li>
<li>chore: use TSTyche for type testing by <a
href="https://github.com/mrazauskas"><code>@​mrazauskas</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2376">pinojs/pino#2376</a></li>
<li>Add Sentry Native Integration Docs by <a
href="https://github.com/KyleTryon"><code>@​KyleTryon</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2394">pinojs/pino#2394</a></li>
<li>docs: add flush limitation warning for pino-pretty, fix <a
href="https://redirect.github.com/pinojs/pino/issues/1015">#1015</a> by
<a href="https://github.com/mcollina"><code>@​mcollina</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2402">pinojs/pino#2402</a></li>
<li>feat(browser): add redaction support by <a
href="https://github.com/abhu85"><code>@​abhu85</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2396">pinojs/pino#2396</a></li>
<li>chore: lint the type declaration file by <a
href="https://github.com/mrazauskas"><code>@​mrazauskas</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2408">pinojs/pino#2408</a></li>
<li>chore: remove TSTyche config file by <a
href="https://github.com/mrazauskas"><code>@​mrazauskas</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2409">pinojs/pino#2409</a></li>
<li>docs: clarify multi-target formatter limitation by <a
href="https://github.com/mcollina"><code>@​mcollina</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2410">pinojs/pino#2410</a></li>
<li>No bots allowed by <a
href="https://github.com/mcollina"><code>@​mcollina</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2412">pinojs/pino#2412</a></li>
<li>build(deps): bump real-require from 0.2.0 to 1.0.0 by <a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2414">pinojs/pino#2414</a></li>
<li>build(deps-dev): bump neostandard from 0.12.2 to 0.13.0 by <a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2418">pinojs/pino#2418</a></li>
<li>fix: use util.getCallSites when able to allow frozen intrinsics by
<a href="https://github.com/CarlOlson"><code>@​CarlOlson</code></a> in
<a
href="https://redirect.github.com/pinojs/pino/pull/2294">pinojs/pino#2294</a></li>
<li>Update AWS Lambda reference in asynchronous docs by <a
href="https://github.com/urbanautomaton"><code>@​urbanautomaton</code></a>
in <a
href="https://redirect.github.com/pinojs/pino/pull/2413">pinojs/pino#2413</a></li>
<li>chore: update license by <a
href="https://github.com/Tony133"><code>@​Tony133</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2375">pinojs/pino#2375</a></li>
<li>fix: add named <code>default</code> export by <a
href="https://github.com/mrazauskas"><code>@​mrazauskas</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2421">pinojs/pino#2421</a></li>
<li>Update contrib doc by <a
href="https://github.com/jsumners"><code>@​jsumners</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2424">pinojs/pino#2424</a></li>
<li>docs: use <code>@​hono/structured-logger</code> for Pino with Hono
by <a
href="https://github.com/brunorodmoreira"><code>@​brunorodmoreira</code></a>
in <a
href="https://redirect.github.com/pinojs/pino/pull/2425">pinojs/pino#2425</a></li>
<li>chore(deps): remove <code>pre-commit</code> by <a
href="https://github.com/kshitijanurag"><code>@​kshitijanurag</code></a>
in <a
href="https://redirect.github.com/pinojs/pino/pull/2423">pinojs/pino#2423</a></li>
<li>build(deps): bump actions/github-script from 8 to 9 by <a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2427">pinojs/pino#2427</a></li>
<li>build(deps-dev): bump eslint-plugin-promise from 6.6.0 to 7.3.0 by
<a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2428">pinojs/pino#2428</a></li>
<li>build(deps-dev): bump tstyche from 6.2.0 to 7.1.0 by <a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2429">pinojs/pino#2429</a></li>
<li>test: fix flaky transport config test by <a
href="https://github.com/mcollina"><code>@​mcollina</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2434">pinojs/pino#2434</a></li>
<li>chore: upgrade typescript to v6.0.2 by <a
href="https://github.com/Tony133"><code>@​Tony133</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2419">pinojs/pino#2419</a></li>
<li>docs: fix typo &quot;compatability&quot; → &quot;compatibility&quot;
in README by <a
href="https://github.com/premsreelathasugeendran"><code>@​premsreelathasugeendran</code></a>
in <a
href="https://redirect.github.com/pinojs/pino/pull/2435">pinojs/pino#2435</a></li>
<li>docs: warn against untrusted top-level log keys by <a
href="https://github.com/mcollina"><code>@​mcollina</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2450">pinojs/pino#2450</a></li>
<li>test(transport): keep event loop alive while awaiting async flush by
<a href="https://github.com/YBJ0000"><code>@​YBJ0000</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2470">pinojs/pino#2470</a></li>
<li>docs: clarify Node.js version support policy in LTS doc by <a
href="https://github.com/youdie006"><code>@​youdie006</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2472">pinojs/pino#2472</a></li>
<li>fix: honor per-target level filter on single-element
<code>targets</code> array by <a
href="https://github.com/mcollina"><code>@​mcollina</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2432">pinojs/pino#2432</a></li>
<li>fix(multistream): resolve string level labels in write() by <a
href="https://github.com/xianjianlf2"><code>@​xianjianlf2</code></a> in
<a
href="https://redirect.github.com/pinojs/pino/pull/2474">pinojs/pino#2474</a></li>
<li>fix: escape child binding keys by <a
href="https://github.com/mcollina"><code>@​mcollina</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2452">pinojs/pino#2452</a></li>
<li>docs: clarify stringification limits by <a
href="https://github.com/mcollina"><code>@​mcollina</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2475">pinojs/pino#2475</a></li>
<li>fix: add setBindings to the browser logger by <a
href="https://github.com/ankit1324"><code>@​ankit1324</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2471">pinojs/pino#2471</a></li>
<li>build(deps): bump actions/setup-node from 6 to 7 by <a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2486">pinojs/pino#2486</a></li>
<li>build(deps-dev): bump through2 from 4.0.2 to 5.0.10 by <a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2488">pinojs/pino#2488</a></li>
<li>build(deps-dev): bump bole from 5.0.29 to 6.0.7 by <a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2489">pinojs/pino#2489</a></li>
<li>build(deps-dev): bump eslint-plugin-n from 17.23.2 to 18.2.2 by <a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2492">pinojs/pino#2492</a></li>
<li>build(deps): bump actions/checkout from 6.0.2 to 7.0.1 by <a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2485">pinojs/pino#2485</a></li>
<li>fix: log objects with an own <strong>proto</strong> key instead of
crashing by <a
href="https://github.com/spokodev"><code>@​spokodev</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2457">pinojs/pino#2457</a></li>
<li>fix: build the redaction shape without Object.prototype by <a
href="https://github.com/luantaraschi"><code>@​luantaraschi</code></a>
in <a
href="https://redirect.github.com/pinojs/pino/pull/2495">pinojs/pino#2495</a></li>
<li>ci: add Node.js 26 to test matrix by <a
href="https://github.com/aquie00t"><code>@​aquie00t</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2480">pinojs/pino#2480</a></li>
<li>fix(multistream): fix clone add crash and missing end/remove methods
by <a href="https://github.com/spellsaif"><code>@​spellsaif</code></a>
in <a
href="https://redirect.github.com/pinojs/pino/pull/2493">pinojs/pino#2493</a></li>
<li>ci: check pull requests target main by <a
href="https://github.com/marktran0710"><code>@​marktran0710</code></a>
in <a
href="https://redirect.github.com/pinojs/pino/pull/2500">pinojs/pino#2500</a></li>
<li>build(deps-dev): bump docsify-cli from 4.4.4 to 5.0.0 by <a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2513">pinojs/pino#2513</a></li>
<li>build(deps-dev): bump eslint-plugin-n from 18.2.2 to 18.3.0 by <a
href="https://github.com/dependabot"><code>@​dependabot</code></a>[bot]
in <a
href="https://redirect.github.com/pinojs/pino/pull/2515">pinojs/pino#2515</a></li>
<li>Delete .github/dependabot.yml by <a
href="https://github.com/jsumners"><code>@​jsumners</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2517">pinojs/pino#2517</a></li>
<li>docs: document the APIs that are unavailable in the browser by <a
href="https://github.com/kavish-19"><code>@​kavish-19</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2521">pinojs/pino#2521</a></li>
<li>ci: pin lock-threads to upstream v6.0.2 to fix token validation
failure by <a
href="https://github.com/simpleqt"><code>@​simpleqt</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2525">pinojs/pino#2525</a></li>
<li>Add bindings() method to browser logger by <a
href="https://github.com/RT1811"><code>@​RT1811</code></a> in <a
href="https://redirect.github.com/pinojs/pino/pull/2504">pinojs/pino#2504</a></li>
</ul>
<!-- raw HTML omitted -->
</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/pinojs/pino/commit/b29dbe97820630e7128e464c50263b427965ec99"><code>b29dbe9</code></a>
Bumped v10.4.0</li>
<li><a
href="https://github.com/pinojs/pino/commit/6ba157b1a6727399f9dc01a584d2e08d5094ea57"><code>6ba157b</code></a>
docs: fix the pino-pretty flush explanation after thread-stream#198 (<a
href="https://redirect.github.com/pinojs/pino/issues/2524">#2524</a>)</li>
<li><a
href="https://github.com/pinojs/pino/commit/6429c14b02ca0253a3a961cfc34ab96790d504f7"><code>6429c14</code></a>
docs: Note that serializers run on child bindings at creation time (<a
href="https://redirect.github.com/pinojs/pino/issues/2518">#2518</a>)</li>
<li><a
href="https://github.com/pinojs/pino/commit/6c71bc98ff17dfb7b12de18c6b48cd465acfa6fc"><code>6c71bc9</code></a>
Add bindings method to browser logger (<a
href="https://redirect.github.com/pinojs/pino/issues/2504">#2504</a>)</li>
<li><a
href="https://github.com/pinojs/pino/commit/b557f727237ddc4c246b1798c543c35f7bf21ac1"><code>b557f72</code></a>
ci: pin lock-threads to upstream v6.0.2 to fix token validation failure
(<a
href="https://redirect.github.com/pinojs/pino/issues/2525">#2525</a>)</li>
<li><a
href="https://github.com/pinojs/pino/commit/1de1212b31f569c50bb14ca11e13a8f8bb2b2407"><code>1de1212</code></a>
docs: document the APIs that are unavailable in the browser (<a
href="https://redirect.github.com/pinojs/pino/issues/2521">#2521</a>)</li>
<li><a
href="https://github.com/pinojs/pino/commit/af2fe10c73182d63310c61393ecd7ed4031ad1d7"><code>af2fe10</code></a>
Delete .github/dependabot.yml (<a
href="https://redirect.github.com/pinojs/pino/issues/2517">#2517</a>)</li>
<li><a
href="https://github.com/pinojs/pino/commit/5aa62305c57709ebd6f6b7c328e8830eeb29b297"><code>5aa6230</code></a>
build(deps-dev): bump eslint-plugin-n from 18.2.2 to 18.3.0 (<a
href="https://redirect.github.com/pinojs/pino/issues/2515">#2515</a>)</li>
<li><a
href="https://github.com/pinojs/pino/commit/6f5af07f122a74044afb50b208491b79255a0ef2"><code>6f5af07</code></a>
build(deps-dev): bump docsify-cli from 4.4.4 to 5.0.0 (<a
href="https://redirect.github.com/pinojs/pino/issues/2513">#2513</a>)</li>
<li><a
href="https://github.com/pinojs/pino/commit/2ffe576ab7f3a48d80bd59b6177b790c53840606"><code>2ffe576</code></a>
ci: check pull requests target main (<a
href="https://redirect.github.com/pinojs/pino/issues/2500">#2500</a>)</li>
<li>Additional commits viewable in <a
href="https://github.com/pinojs/pino/compare/v9.10.0...v10.4.0">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=pino&package-manager=npm_and_yarn&previous-version=9.10.0&new-version=10.4.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../node-integration-tests/package.json       |  2 +-
 yarn.lock                                     | 32 +++----------------
 2 files changed, 6 insertions(+), 28 deletions(-)

diff --git a/dev-packages/node-integration-tests/package.json b/dev-packages/node-integration-tests/package.json
index a8a0a474448a..e7d9dface49b 100644
--- a/dev-packages/node-integration-tests/package.json
+++ b/dev-packages/node-integration-tests/package.json
@@ -91,7 +91,7 @@
     "node-schedule": "^2.1.1",
     "openai": "5.18.1",
     "pg": "8.20.0",
-    "pino": "9.10.0",
+    "pino": "10.4.0",
     "pino-next": "npm:pino@^9.12.0",
     "postgres": "^3.4.7",
     "prisma": "6.15.0",
diff --git a/yarn.lock b/yarn.lock
index 0fb72c08a93a..fa2ba2499ab2 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -15731,11 +15731,6 @@ fast-querystring@^1.0.0:
   dependencies:
     fast-decode-uri-component "^1.0.1"
 
-fast-redact@^3.1.1:
-  version "3.5.0"
-  resolved "https://registry.yarnpkg.com/fast-redact/-/fast-redact-3.5.0.tgz#e9ea02f7e57d0cd8438180083e93077e496285e4"
-  integrity sha512-dwsoQlS7h9hMeYUq1W++23NDcBLV4KqONnITDV9DjfS3q1SgDGVrBdvvTLUotWtPSD7asWDV9/CmsZPy8Hf70A==
-
 fast-safe-stringify@2.1.1:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/fast-safe-stringify/-/fast-safe-stringify-2.1.1.tgz#c406a83b6e70d9e35ce3b30a81141df30aeba884"
@@ -22359,27 +22354,10 @@ pino-std-serializers@^7.0.0:
   resolved "https://registry.yarnpkg.com/pino-std-serializers/-/pino-std-serializers-7.0.0.tgz#7c625038b13718dbbd84ab446bd673dc52259e3b"
   integrity sha512-e906FRY0+tV27iq4juKzSYPbUj2do2X2JX4EzSca1631EB2QJQUqGbDuERal7LCtOpxl6x3+nvo9NPZcmjkiFA==
 
-pino@9.10.0:
-  version "9.10.0"
-  resolved "https://registry.yarnpkg.com/pino/-/pino-9.10.0.tgz#b78555637605ef6f4287e51a89b2087d66da4859"
-  integrity sha512-VOFxoNnxICtxaN8S3E73pR66c5MTFC+rwRcNRyHV/bV/c90dXvJqMfjkeRFsGBDXmlUN3LccJQPqGIufnaJePA==
-  dependencies:
-    atomic-sleep "^1.0.0"
-    fast-redact "^3.1.1"
-    on-exit-leak-free "^2.1.0"
-    pino-abstract-transport "^2.0.0"
-    pino-std-serializers "^7.0.0"
-    process-warning "^5.0.0"
-    quick-format-unescaped "^4.0.3"
-    real-require "^0.2.0"
-    safe-stable-stringify "^2.3.1"
-    sonic-boom "^4.0.1"
-    thread-stream "^3.0.0"
-
-"pino@^9.14.0 || ^10.1.0":
-  version "10.3.1"
-  resolved "https://registry.yarnpkg.com/pino/-/pino-10.3.1.tgz#6552c8f8d8481844c9e452e7bf0be90bff1939ce"
-  integrity sha512-r34yH/GlQpKZbU1BvFFqOjhISRo1MNx1tWYsYvmj6KIRHSPMT2+yHOEb1SG6NMvRoHRF0a07kCOox/9yakl1vg==
+pino@10.4.0, "pino@^9.14.0 || ^10.1.0":
+  version "10.4.0"
+  resolved "https://registry.yarnpkg.com/pino/-/pino-10.4.0.tgz#8371a2633094100be30b6bf73fd69e29749588d5"
+  integrity sha512-bk1ZMTwG/Vymx+zPoa28MhNzucFvXJWp3csrSuxuHPSMeUettaCoQ5Jvg07mtC4JGNpcfTwz41oVCnNgBK9+vA==
   dependencies:
     "@pinojs/redact" "^0.4.0"
     atomic-sleep "^1.0.0"
@@ -22388,7 +22366,7 @@ pino@9.10.0:
     pino-std-serializers "^7.0.0"
     process-warning "^5.0.0"
     quick-format-unescaped "^4.0.3"
-    real-require "^0.2.0"
+    real-require "^1.0.0"
     safe-stable-stringify "^2.3.1"
     sonic-boom "^4.0.1"
     thread-stream "^4.0.0"

From 96dfcc05e78c969872d48348bd481faf5316b4a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Peer=20St=C3=B6cklmair?= <jan.peer@sentry.io>
Date: Mon, 12 Oct 2026 15:10:12 +0200
Subject: [PATCH 71/84] test(node-integration): Replace `conditionalTest` with
 a `supports` helper (#25202)

> *Pro Tip*: It is better to review it with the option "Hide
whitespaces":
https://github.com/getsentry/sentry-javascript/pull/25202/changes?w=1

This replaces `conditionalTest` with a `supports(requirements)` helper
that returns a boolean, so blocks and single tests use the same
requirements with Vitest's `runIf`. The `RUNTIME` checks in `skipIf` use
it too, and `skipRuntimes` becomes `runtimes`, the runtimes that run the
tests.

```ts
describe.runIf(supports({ min: 22 }))('OpenAI integration (V7)', () => {
  test.runIf(supports({ runtimes: ['node'] }))('...', async () => {});
});
```

Most of the diff is new indentation. Hide whitespace to review.

## Why

Blocks used `conditionalTest(options)` and single tests used `skipIf`
with a `RUNTIME` check, so one condition had two forms. With one helper,
a new requirement, for example a minimum Bun version, works for both.

## API decisions

The helper goes with `runIf`, not `skipIf`, so each requirement says
where the tests run, and a call does not read as `skipIf(shouldSkip({
skipRuntimes }))`. `runIf` cannot take the requirements object directly,
because Vitest only checks if the value is truthy. Wrapping Vitest's
`test` and `describe` would allow it, but then an object passed to
Vitest's own functions would always run.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../node-suites/excludes.ts                   |  3 +-
 .../node-suites/excludes.ts                   |  3 +-
 dev-packages/node-integration-tests/README.md |  4 +-
 .../suites/express/client-abort/test.ts       | 45 +++++----
 .../suites/public-api/LocalVariables/test.ts  | 96 +++++++++++--------
 .../public-api/OnUncaughtException/test.ts    |  4 +-
 .../onUnhandledRejectionIntegration/test.ts   | 53 +++++-----
 .../suites/tracing/flue/test.ts               |  6 +-
 .../graphql-tracing-channel/resolvers/test.ts |  6 +-
 .../tracing/graphql-tracing-channel/test.ts   |  6 +-
 .../useOperationNameForRootSpan/test.ts       |  6 +-
 .../suites/tracing/httpIntegration/test.ts    |  4 +-
 .../continued-trace-segment/test.ts           |  7 +-
 .../suites/tracing/mastra/test.ts             |  6 +-
 .../suites/tracing/neon/test.ts               |  4 +-
 .../no-parent-span-client-report/test.ts      |  4 +-
 .../suites/tracing/openai/v7/test.ts          |  6 +-
 .../suites/tracing/pi-durable/test.ts         |  8 +-
 .../suites/tracing/postgres/test.ts           |  4 +-
 .../suites/tracing/postgresjs/test.ts         | 10 +-
 .../suites/tracing/prisma-orm-v8/test.ts      |  9 +-
 .../tracing/requests/traceparent/test.ts      | 47 ++++-----
 .../suites/tracing/tedious/test.ts            |  6 +-
 .../node-integration-tests/utils/index.ts     | 41 ++++----
 24 files changed, 207 insertions(+), 181 deletions(-)

diff --git a/dev-packages/bun-integration-tests/node-suites/excludes.ts b/dev-packages/bun-integration-tests/node-suites/excludes.ts
index a883dbf49870..86aa8f9a65e1 100644
--- a/dev-packages/bun-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/bun-integration-tests/node-suites/excludes.ts
@@ -1,5 +1,6 @@
 // Node suites that do not run on Bun, relative to `node-integration-tests`. A single test that
-// fails on Bun is skipped with `test.skipIf` on `RUNTIME` in the Node suite, not listed here.
+// fails on Bun runs only on the other runtimes, with `test.runIf(supports({ runtimes }))` in the
+// Node suite, and is not listed here.
 
 // Node-only features: ANR and native thread watchdogs, child processes, the AWS Lambda Node runtime,
 // `node:sqlite`, which `flue` needs, and the Vercel keep-alive, which needs `http.server.response.finish`.
diff --git a/dev-packages/deno-integration-tests/node-suites/excludes.ts b/dev-packages/deno-integration-tests/node-suites/excludes.ts
index 14205893d332..b2a6b1b851a8 100644
--- a/dev-packages/deno-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/deno-integration-tests/node-suites/excludes.ts
@@ -1,5 +1,6 @@
 // Node suites that do not run on Deno, relative to `node-integration-tests`. A single test that
-// fails on Deno is skipped with `test.skipIf` on `RUNTIME` in the Node suite, not listed here.
+// fails on Deno runs only on the other runtimes, with `test.runIf(supports({ runtimes }))` in the
+// Node suite, and is not listed here.
 
 // Node-only features: ANR and native thread watchdogs, child process and worker thread breadcrumbs.
 const NODE_ONLY = ['suites/anr/test.ts', 'suites/breadcrumbs/**', 'suites/thread-blocked-native/test.ts'];
diff --git a/dev-packages/node-integration-tests/README.md b/dev-packages/node-integration-tests/README.md
index ac35f0ea54c0..67272bf5f6b0 100644
--- a/dev-packages/node-integration-tests/README.md
+++ b/dev-packages/node-integration-tests/README.md
@@ -67,8 +67,8 @@ arriving after its condition is satisfied.
 
 `dev-packages/bun-integration-tests` and `dev-packages/deno-integration-tests` run every suite of this package on Bun
 and Deno as well. When you add a suite, check that it passes on both. If it cannot, add it to
-`node-suites/excludes.ts` of the runtime's package with the reason, or skip the single tests that fail with
-`test.skipIf(RUNTIME === 'bun')` or `test.skipIf(RUNTIME === 'deno')`.
+`node-suites/excludes.ts` of the runtime's package with the reason, or run the single tests that fail only on the
+other runtimes, for example `test.runIf(supports({ runtimes: ['node', 'deno'] }))` for a test that fails on Bun.
 
 ## Running Tests Locally
 
diff --git a/dev-packages/node-integration-tests/suites/express/client-abort/test.ts b/dev-packages/node-integration-tests/suites/express/client-abort/test.ts
index b9cac9af42d8..5206399712ac 100644
--- a/dev-packages/node-integration-tests/suites/express/client-abort/test.ts
+++ b/dev-packages/node-integration-tests/suites/express/client-abort/test.ts
@@ -1,5 +1,5 @@
 import { afterAll, describe, expect } from 'vitest';
-import { RUNTIME } from '../../../utils';
+import { supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 describe('express client abort', () => {
@@ -10,27 +10,30 @@ describe('express client abort', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     // Bun 1.3.14 emits no `close` on the response when the client aborts, so the `http.server`
     // span never ends either. Bun 1.4.0 emits it.
-    test.skipIf(RUNTIME === 'bun')('ends the request handler span when the client aborts', async () => {
-      const runner = createRunner()
-        .unordered()
-        .expect({
-          span: container => {
-            const segmentSpan = container.items.find(item => item.is_segment);
-            const handlerSpan = container.items.find(
-              item => item.attributes['express.type']?.value === 'request_handler',
-            );
+    test.runIf(supports({ runtimes: ['node', 'deno'] }))(
+      'ends the request handler span when the client aborts',
+      async () => {
+        const runner = createRunner()
+          .unordered()
+          .expect({
+            span: container => {
+              const segmentSpan = container.items.find(item => item.is_segment);
+              const handlerSpan = container.items.find(
+                item => item.attributes['express.type']?.value === 'request_handler',
+              );
 
-            expect(segmentSpan?.name).toBe('GET /test/slow');
-            expect(handlerSpan).toBeDefined();
-            expect(handlerSpan!.parent_span_id).toBe(segmentSpan!.span_id);
-            // Ends when the client aborts, not when the handler's 500ms of work finishes.
-            expect(handlerSpan!.end_timestamp - handlerSpan!.start_timestamp).toBeLessThan(0.4);
-          },
-        })
-        .start();
+              expect(segmentSpan?.name).toBe('GET /test/slow');
+              expect(handlerSpan).toBeDefined();
+              expect(handlerSpan!.parent_span_id).toBe(segmentSpan!.span_id);
+              // Ends when the client aborts, not when the handler's 500ms of work finishes.
+              expect(handlerSpan!.end_timestamp - handlerSpan!.start_timestamp).toBeLessThan(0.4);
+            },
+          })
+          .start();
 
-      await runner.makeRequest('get', '/test/slow', { timeout: 100, expectError: true });
-      await runner.completed();
-    });
+        await runner.makeRequest('get', '/test/slow', { timeout: 100, expectError: true });
+        await runner.completed();
+      },
+    );
   });
 });
diff --git a/dev-packages/node-integration-tests/suites/public-api/LocalVariables/test.ts b/dev-packages/node-integration-tests/suites/public-api/LocalVariables/test.ts
index 8873d746159a..a078bfed26a2 100644
--- a/dev-packages/node-integration-tests/suites/public-api/LocalVariables/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/LocalVariables/test.ts
@@ -2,7 +2,7 @@ import { mkdirSync, rmdirSync, unlinkSync, writeFileSync } from 'fs';
 import * as path from 'path';
 import { afterAll, beforeAll, describe, expect, test } from 'vitest';
 import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
-import { RUNTIME } from '../../../utils';
+import { supports } from '../../../utils';
 
 const EXPECTED_LOCAL_VARIABLES_EVENT = {
   exception: {
@@ -81,24 +81,27 @@ module.exports = { out_of_app_function };`,
   });
 
   // Bun and Deno: the error events have no local variables.
-  test.skipIf(RUNTIME !== 'node')('Should include local variables when enabled', async () => {
+  test.runIf(supports({ runtimes: ['node'] }))('Should include local variables when enabled', async () => {
     await createRunner(__dirname, 'local-variables.js')
       .expect({ event: EXPECTED_LOCAL_VARIABLES_EVENT })
       .start()
       .completed();
   });
 
-  test.skipIf(RUNTIME !== 'node')('Should include local variables when instrumenting via --import', async () => {
-    const instrumentPath = path.resolve(__dirname, 'local-variables-instrument.cjs');
+  test.runIf(supports({ runtimes: ['node'] }))(
+    'Should include local variables when instrumenting via --import',
+    async () => {
+      const instrumentPath = path.resolve(__dirname, 'local-variables-instrument.cjs');
 
-    await createRunner(__dirname, 'local-variables-no-sentry.js')
-      .withFlags(`--import=${instrumentPath}`)
-      .expect({ event: EXPECTED_LOCAL_VARIABLES_EVENT })
-      .start()
-      .completed();
-  });
+      await createRunner(__dirname, 'local-variables-no-sentry.js')
+        .withFlags(`--import=${instrumentPath}`)
+        .expect({ event: EXPECTED_LOCAL_VARIABLES_EVENT })
+        .start()
+        .completed();
+    },
+  );
 
-  test.skipIf(RUNTIME !== 'node')('Should include local variables with ESM', async () => {
+  test.runIf(supports({ runtimes: ['node'] }))('Should include local variables with ESM', async () => {
     await createRunner(__dirname, 'local-variables-caught.mjs')
       .expect({ event: EXPECTED_LOCAL_VARIABLES_EVENT })
       .start()
@@ -109,21 +112,27 @@ module.exports = { out_of_app_function };`,
     await createRunner(__dirname, 'deny-inspector.mjs').ensureNoErrorOutput().start().completed();
   });
 
-  test.skipIf(RUNTIME !== 'node')('Should retain original local variables when error is re-thrown', async () => {
-    await createRunner(__dirname, 'local-variables-rethrow.js')
-      .expect({ event: EXPECTED_LOCAL_VARIABLES_EVENT })
-      .start()
-      .completed();
-  });
+  test.runIf(supports({ runtimes: ['node'] }))(
+    'Should retain original local variables when error is re-thrown',
+    async () => {
+      await createRunner(__dirname, 'local-variables-rethrow.js')
+        .expect({ event: EXPECTED_LOCAL_VARIABLES_EVENT })
+        .start()
+        .completed();
+    },
+  );
 
-  test.skipIf(RUNTIME !== 'node')('Includes local variables for caught exceptions when enabled', async () => {
-    await createRunner(__dirname, 'local-variables-caught.js')
-      .expect({ event: EXPECTED_LOCAL_VARIABLES_EVENT })
-      .start()
-      .completed();
-  });
+  test.runIf(supports({ runtimes: ['node'] }))(
+    'Includes local variables for caught exceptions when enabled',
+    async () => {
+      await createRunner(__dirname, 'local-variables-caught.js')
+        .expect({ event: EXPECTED_LOCAL_VARIABLES_EVENT })
+        .start()
+        .completed();
+    },
+  );
 
-  test.skipIf(RUNTIME !== 'node')(
+  test.runIf(supports({ runtimes: ['node'] }))(
     'Filters local variables by name via dataCollection.stackFrameVariables',
     async () => {
       await createRunner(__dirname, 'local-variables-filtered.js')
@@ -156,7 +165,7 @@ module.exports = { out_of_app_function };`,
       .completed();
   });
 
-  test.skipIf(RUNTIME !== 'node')('Should handle different function name formats', async () => {
+  test.runIf(supports({ runtimes: ['node'] }))('Should handle different function name formats', async () => {
     await createRunner(__dirname, 'local-variables-name-matching.js')
       .expect({
         event: {
@@ -182,7 +191,7 @@ module.exports = { out_of_app_function };`,
       .completed();
   });
 
-  test.skipIf(RUNTIME !== 'node')(
+  test.runIf(supports({ runtimes: ['node'] }))(
     'adds local variables to out of app frames when includeOutOfAppFrames is true',
     async () => {
       await createRunner(__dirname, 'local-variables-out-of-app.js')
@@ -208,23 +217,26 @@ module.exports = { out_of_app_function };`,
     },
   );
 
-  test.skipIf(RUNTIME !== 'node')('does not add local variables to out of app frames by default', async () => {
-    await createRunner(__dirname, 'local-variables-out-of-app-default.js')
-      .expect({
-        event: event => {
-          const frames = event.exception?.values?.[0]?.stacktrace?.frames || [];
+  test.runIf(supports({ runtimes: ['node'] }))(
+    'does not add local variables to out of app frames by default',
+    async () => {
+      await createRunner(__dirname, 'local-variables-out-of-app-default.js')
+        .expect({
+          event: event => {
+            const frames = event.exception?.values?.[0]?.stacktrace?.frames || [];
 
-          const inAppFrame = frames.find(frame => frame.function === 'in_app_function');
-          const outOfAppFrame = frames.find(frame => frame.function === 'out_of_app_function');
+            const inAppFrame = frames.find(frame => frame.function === 'in_app_function');
+            const outOfAppFrame = frames.find(frame => frame.function === 'out_of_app_function');
 
-          expect(inAppFrame?.vars).toEqual({ inAppVar: 'in app value' });
-          expect(inAppFrame?.in_app).toEqual(true);
+            expect(inAppFrame?.vars).toEqual({ inAppVar: 'in app value' });
+            expect(inAppFrame?.in_app).toEqual(true);
 
-          expect(outOfAppFrame?.vars).toBeUndefined();
-          expect(outOfAppFrame?.in_app).toEqual(false);
-        },
-      })
-      .start()
-      .completed();
-  });
+            expect(outOfAppFrame?.vars).toBeUndefined();
+            expect(outOfAppFrame?.in_app).toEqual(false);
+          },
+        })
+        .start()
+        .completed();
+    },
+  );
 });
diff --git a/dev-packages/node-integration-tests/suites/public-api/OnUncaughtException/test.ts b/dev-packages/node-integration-tests/suites/public-api/OnUncaughtException/test.ts
index ef52edf7059d..4d9c312ad5ad 100644
--- a/dev-packages/node-integration-tests/suites/public-api/OnUncaughtException/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/OnUncaughtException/test.ts
@@ -2,7 +2,7 @@ import * as childProcess from 'child_process';
 import * as path from 'path';
 import { describe, expect, test } from 'vitest';
 import { createRunner } from '../../../utils/runner';
-import { RUNTIME } from '../../../utils';
+import { supports } from '../../../utils';
 
 describe('OnUncaughtException integration', () => {
   test('should close process on uncaught error with no additional listeners registered', () =>
@@ -124,7 +124,7 @@ describe('OnUncaughtException integration', () => {
   });
 
   // Bun and Deno: the worker thread errors are not handled as on Node.
-  describe.skipIf(RUNTIME !== 'node')('Worker thread error handling', () => {
+  describe.runIf(supports({ runtimes: ['node'] }))('Worker thread error handling', () => {
     test.each(['mjs', 'js'])('should not interfere with worker thread error handling ".%s"', async extension => {
       const runner = createRunner(__dirname, `worker-thread/caught-worker.${extension}`)
         .withFlags('--import', path.join(__dirname, `worker-thread/instrument.${extension}`))
diff --git a/dev-packages/node-integration-tests/suites/public-api/onUnhandledRejectionIntegration/test.ts b/dev-packages/node-integration-tests/suites/public-api/onUnhandledRejectionIntegration/test.ts
index 199f3dffe5aa..3f8599756958 100644
--- a/dev-packages/node-integration-tests/suites/public-api/onUnhandledRejectionIntegration/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/onUnhandledRejectionIntegration/test.ts
@@ -3,7 +3,7 @@ import * as childProcess from 'child_process';
 import * as path from 'path';
 import { afterAll, describe, expect, test } from 'vitest';
 import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
-import { RUNTIME } from '../../../utils';
+import { supports } from '../../../utils';
 
 describe('onUnhandledRejectionIntegration', () => {
   afterAll(() => {
@@ -170,32 +170,35 @@ test rejection`);
   });
 
   // Bun: the rejection event's span ID differs from the already-ended span's ID.
-  test.skipIf(RUNTIME === 'bun')('handles unhandled rejection in spans that are ended early', async () => {
-    let segment: SerializedStreamedSpanContainer['items'][number] | undefined;
-    let errorEvent: Event | undefined;
-
-    await createRunner(__dirname, 'scenario-with-span-ended.ts')
-      .unordered()
-      .expect({
-        span: container => {
-          segment = container.items.find(span => span.is_segment);
-          expect(segment?.name).toBe('test-span');
-        },
-      })
-      .expect({
-        event: event => {
-          errorEvent = event;
-        },
-      })
-      .start()
-      .completed();
+  test.runIf(supports({ runtimes: ['node', 'deno'] }))(
+    'handles unhandled rejection in spans that are ended early',
+    async () => {
+      let segment: SerializedStreamedSpanContainer['items'][number] | undefined;
+      let errorEvent: Event | undefined;
+
+      await createRunner(__dirname, 'scenario-with-span-ended.ts')
+        .unordered()
+        .expect({
+          span: container => {
+            segment = container.items.find(span => span.is_segment);
+            expect(segment?.name).toBe('test-span');
+          },
+        })
+        .expect({
+          event: event => {
+            errorEvent = event;
+          },
+        })
+        .start()
+        .completed();
 
-    expect(segment).toBeDefined();
-    expect(errorEvent).toBeDefined();
+      expect(segment).toBeDefined();
+      expect(errorEvent).toBeDefined();
 
-    expect(segment!.trace_id).toBe(errorEvent!.contexts!.trace!.trace_id);
-    expect(segment!.span_id).toBe(errorEvent!.contexts!.trace!.span_id);
-  });
+      expect(segment!.trace_id).toBe(errorEvent!.contexts!.trace!.trace_id);
+      expect(segment!.span_id).toBe(errorEvent!.contexts!.trace!.span_id);
+    },
+  );
 
   test('should not warn when AI_NoOutputGeneratedError or AbortError is rejected (default ignore)', () =>
     new Promise<void>(done => {
diff --git a/dev-packages/node-integration-tests/suites/tracing/flue/test.ts b/dev-packages/node-integration-tests/suites/tracing/flue/test.ts
index f4cf35579ae4..5d3b6fe6cc0e 100644
--- a/dev-packages/node-integration-tests/suites/tracing/flue/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/flue/test.ts
@@ -14,8 +14,8 @@ import {
   GEN_AI_USAGE_OUTPUT_TOKENS,
   GEN_AI_USAGE_TOTAL_TOKENS,
 } from '@sentry/conventions/attributes';
-import { afterAll, expect } from 'vitest';
-import { conditionalTest } from '../../../utils';
+import { afterAll, describe, expect } from 'vitest';
+import { supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 // `@flue/runtime` declares `engines.node >= 22.19`, so it can't live in the package's root
@@ -29,7 +29,7 @@ const FLUE_DEPENDENCIES = {
   },
 };
 
-conditionalTest({ min: 22 })('Flue integration', () => {
+describe.runIf(supports({ min: 22 }))('Flue integration', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/resolvers/test.ts b/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/resolvers/test.ts
index 911971abf5f9..430b0ebfda3a 100644
--- a/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/resolvers/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/resolvers/test.ts
@@ -1,11 +1,11 @@
-import { afterAll, expect } from 'vitest';
-import { conditionalTest } from '../../../../utils';
+import { afterAll, describe, expect } from 'vitest';
+import { supports } from '../../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
 
 // With `ignoreResolveSpans: false`, the channel path also subscribes `graphql:resolve` and emits a
 // span per non-trivial field resolver. `ignoreTrivialResolveSpans` defaults to true, so graphql's
 // default property resolver (the `name` field) is skipped. graphql 17 requires Node >= 22.
-conditionalTest({ min: 22 })('GraphQL tracing channel Test > resolve spans', () => {
+describe.runIf(supports({ min: 22 }))('GraphQL tracing channel Test > resolve spans', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/test.ts b/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/test.ts
index e1ea0083877a..c41add10805e 100644
--- a/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/test.ts
@@ -1,9 +1,9 @@
-import { afterAll, expect } from 'vitest';
-import { conditionalTest } from '../../../utils';
+import { afterAll, describe, expect } from 'vitest';
+import { supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 // GraphQL 17 requires Node >= 22, so this suite is skipped on older Node.
-conditionalTest({ min: 22 })('GraphQL tracing channel Test', () => {
+describe.runIf(supports({ min: 22 }))('GraphQL tracing channel Test', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/useOperationNameForRootSpan/test.ts b/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/useOperationNameForRootSpan/test.ts
index 1739309f1e1b..4b1cdb001c10 100644
--- a/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/useOperationNameForRootSpan/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/graphql-tracing-channel/useOperationNameForRootSpan/test.ts
@@ -1,9 +1,9 @@
-import { afterAll, expect } from 'vitest';
-import { conditionalTest } from '../../../../utils';
+import { afterAll, describe, expect } from 'vitest';
+import { supports } from '../../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
 
 // graphql 17 requires Node >= 22, so this suite is skipped on older Node.
-conditionalTest({ min: 22 })('GraphQL tracing channel Test > useOperationNameForRootSpan', () => {
+describe.runIf(supports({ min: 22 }))('GraphQL tracing channel Test > useOperationNameForRootSpan', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts
index d0508d189bb3..32f8f7ff9eed 100644
--- a/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/httpIntegration/test.ts
@@ -3,7 +3,7 @@ import { createTestServer } from '@sentry-internal/test-utils';
 import { HTTP_RESPONSE_STATUS_CODE, SENTRY_OP, URL_FULL, URL_PATH } from '@sentry/conventions/attributes';
 import { afterAll, describe, expect, test } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests, createRunner } from '../../../utils/runner';
-import { RUNTIME } from '../../../utils';
+import { supports } from '../../../utils';
 
 function getCommonHttpRequestHeaders(): Record<string, unknown> {
   return {
@@ -194,7 +194,7 @@ describe('httpIntegration', () => {
     });
 
     // Deno: the requests sometimes get a 500 response when `server.emit` is overwritten.
-    describe.skipIf(RUNTIME === 'deno')('custom server.emit', () => {
+    describe.runIf(supports({ runtimes: ['node', 'bun'] }))('custom server.emit', () => {
       createEsmAndCjsTests(
         __dirname,
         'scenario-overwrite-server-emit.mjs',
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts
index afc8eb2158ba..69c9874cd27f 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts
@@ -1,6 +1,6 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { afterAll, describe, expect } from 'vitest';
-import { RUNTIME } from '../../../../utils';
+import { supports } from '../../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
 
 describe('ignoring a continued server segment', () => {
@@ -43,8 +43,9 @@ describe('ignoring a continued server segment', () => {
     test('propagates a negative sampling decision to outgoing fetch requests', () => testPropagation('/ignored'));
     // Bun 1.3.14 does not instrument outgoing `node:http` requests.
     // See https://github.com/getsentry/sentry-javascript/issues/23881
-    test.skipIf(RUNTIME === 'bun')('propagates a negative sampling decision to outgoing node:http requests', () =>
-      testPropagation('/ignored-http'),
+    test.runIf(supports({ runtimes: ['node', 'deno'] }))(
+      'propagates a negative sampling decision to outgoing node:http requests',
+      () => testPropagation('/ignored-http'),
     );
   });
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/mastra/test.ts b/dev-packages/node-integration-tests/suites/tracing/mastra/test.ts
index d26ea2281428..d1e4309ebded 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mastra/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mastra/test.ts
@@ -21,8 +21,8 @@ import {
   URL_FULL,
 } from '@sentry/conventions/attributes';
 import { GEN_AI_CHAT, GEN_AI_EVALUATE, GEN_AI_EXECUTE_TOOL, GEN_AI_INVOKE_AGENT } from '@sentry/conventions/op';
-import { afterAll, expect } from 'vitest';
-import { conditionalTest } from '../../../utils';
+import { afterAll, describe, expect } from 'vitest';
+import { supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 // `@mastra/core` declares `engines.node >= 22.13`, so it can't live in the package's root
@@ -52,7 +52,7 @@ const MASTRA_CLASSIFIER_DEPENDENCIES = {
   },
 };
 
-conditionalTest({ min: 22 })('Mastra integration', () => {
+describe.runIf(supports({ min: 22 }))('Mastra integration', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/neon/test.ts b/dev-packages/node-integration-tests/suites/tracing/neon/test.ts
index e1310a6ff703..485e6dbfac26 100644
--- a/dev-packages/node-integration-tests/suites/tracing/neon/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/neon/test.ts
@@ -14,7 +14,7 @@ import {
 } from '@sentry/conventions/attributes';
 import { DB } from '@sentry/conventions/op';
 import { afterAll, describe, expect } from 'vitest';
-import { RUNTIME, streamedAttribute as attr } from '../../../utils';
+import { streamedAttribute as attr, supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
 const ORIGIN = 'auto.db.neon';
@@ -139,7 +139,7 @@ describeWithDockerCompose('neon auto instrumentation', { workingDirectory: [__di
     createEsmAndCjsTests(__dirname, 'scenario-pool.mjs', 'instrument.mjs', (createTestRunner, test) => {
       // On Bun and Deno the pool's connect callback runs outside the segment's async context, so
       // the queries it issues have no parent span.
-      test.skipIf(RUNTIME !== 'node')('instruments `Pool` queries', { timeout: 90_000 }, async () => {
+      test.runIf(supports({ runtimes: ['node'] }))('instruments `Pool` queries', { timeout: 90_000 }, async () => {
         const runner = createTestRunner();
         const spansPromise = runner.collectStreamedSpansUntilSegment('Test Span');
 
diff --git a/dev-packages/node-integration-tests/suites/tracing/no-parent-span-client-report/test.ts b/dev-packages/node-integration-tests/suites/tracing/no-parent-span-client-report/test.ts
index e0b7c43abb1d..86702f80ee20 100644
--- a/dev-packages/node-integration-tests/suites/tracing/no-parent-span-client-report/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/no-parent-span-client-report/test.ts
@@ -1,5 +1,5 @@
 import { afterAll, describe, expect } from 'vitest';
-import { RUNTIME } from '../../../utils';
+import { supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 describe('no_parent_span client report', () => {
@@ -10,7 +10,7 @@ describe('no_parent_span client report', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     // Bun 1.3.14 does not instrument outgoing `node:http` requests.
     // See https://github.com/getsentry/sentry-javascript/issues/23881
-    test.skipIf(RUNTIME === 'bun')(
+    test.runIf(supports({ runtimes: ['node', 'deno'] }))(
       'records no_parent_span outcome for an outgoing http request without a local parent',
       async () => {
         const runner = createRunner()
diff --git a/dev-packages/node-integration-tests/suites/tracing/openai/v7/test.ts b/dev-packages/node-integration-tests/suites/tracing/openai/v7/test.ts
index 34199f155036..d24c08130d84 100644
--- a/dev-packages/node-integration-tests/suites/tracing/openai/v7/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/openai/v7/test.ts
@@ -1,5 +1,5 @@
 import type { SerializedStreamedSpanContainer } from '@sentry/core';
-import { afterAll, expect } from 'vitest';
+import { afterAll, describe, expect } from 'vitest';
 import {
   GEN_AI_OPERATION_NAME,
   GEN_AI_PROVIDER_NAME,
@@ -15,11 +15,11 @@ import {
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
-import { conditionalTest } from '../../../../utils/index';
+import { supports } from '../../../../utils/index';
 
 // openai 7 requires Node.js 22 — its only breaking change over v6 — so this suite is skipped on the
 // Node 20 CI leg rather than pinning the whole matrix to the newer runtime.
-conditionalTest({ min: 22 })('OpenAI integration (V7)', () => {
+describe.runIf(supports({ min: 22 }))('OpenAI integration (V7)', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/pi-durable/test.ts b/dev-packages/node-integration-tests/suites/tracing/pi-durable/test.ts
index be521b3d3d98..4333c9e0f415 100644
--- a/dev-packages/node-integration-tests/suites/tracing/pi-durable/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/pi-durable/test.ts
@@ -20,9 +20,9 @@ import {
   SENTRY_STATUS_MESSAGE,
 } from '@sentry/conventions/attributes';
 import { GEN_AI_CHAT, GEN_AI_EXECUTE_TOOL, GEN_AI_INVOKE_AGENT } from '@sentry/conventions/op';
-import { afterAll, expect } from 'vitest';
+import { afterAll, describe, expect } from 'vitest';
 import { GEN_AI_TOOL_CALL_ID_ATTRIBUTE } from '../../../../../packages/server-utils/src/ai/core/gen-ai-attributes';
-import { conditionalTest, RUNTIME } from '../../../utils';
+import { supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
 
 // The pi packages declare `engines.node >= 22.19`, so they can't live in the package's root
@@ -45,7 +45,7 @@ const CONTENT_ATTRIBUTES = [
   GEN_AI_TOOL_CALL_RESULT,
 ];
 
-conditionalTest({ min: 22 })('pi-durable integration', () => {
+describe.runIf(supports({ min: 22 }))('pi-durable integration', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
@@ -481,7 +481,7 @@ conditionalTest({ min: 22 })('pi-durable integration', () => {
       }
 
       // Bun does not implement `v8.setFlagsFromString`, which the scenario needs to force GC.
-      test.skipIf(RUNTIME === 'bun')(
+      test.runIf(supports({ runtimes: ['node', 'deno'] }))(
         'does not keep the traces of tool calls alive for subagent conversations that never run',
         async () => {
           await createRunner()
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts b/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts
index 0d4fa1212fc8..4dd383254d1f 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/postgres/test.ts
@@ -21,7 +21,7 @@ import {
 } from '@sentry/conventions/attributes';
 import { DB } from '@sentry/conventions/op';
 import { afterAll, describe, expect } from 'vitest';
-import { conditionalTest, EXPECTED_SDK_NAME } from '../../../utils';
+import { EXPECTED_SDK_NAME, supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
 const COMMON_DB_ATTRIBUTES = {
@@ -413,7 +413,7 @@ describeWithDockerCompose('postgres auto instrumentation', { workingDirectory: [
 
   // Deno: with a module load hook installed, Deno compiles a native addon (`libpq`) as JavaScript.
   // Bun: the `libpq` addon needs the Node symbol `node::EmitAsyncInit`, which Bun does not provide.
-  conditionalTest({ max: 25, skipRuntimes: ['bun', 'deno'] })('pg-native', () => {
+  describe.runIf(supports({ max: 25, runtimes: ['node'] }))('pg-native', () => {
     const EXPECTED_SPANS = {
       items: expect.arrayContaining([
         expect.objectContaining({ name: 'Test Transaction', is_segment: true }),
diff --git a/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts b/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts
index 9677c10f2c7b..8467dbfdaba1 100644
--- a/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/postgresjs/test.ts
@@ -15,7 +15,7 @@ import {
 import { DB } from '@sentry/conventions/op';
 import type { Event, SerializedStreamedSpanContainer } from '@sentry/core';
 import { afterAll, describe, expect } from 'vitest';
-import { RUNTIME } from '../../../utils';
+import { supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
 // On Bun, `postgres` resolves to its ESM build through the `bun` export condition, so
@@ -279,7 +279,7 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
     };
 
     createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
-      test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+      test.runIf(mode === 'esm' || supports({ runtimes: ['node', 'deno'] }))(
         'should auto-instrument `postgres` package',
         { timeout: 60_000 },
         async () => {
@@ -419,7 +419,7 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
       'scenario-requestHook.mjs',
       'instrument-requestHook.mjs',
       (createTestRunner, test, mode) => {
-        test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+        test.runIf(mode === 'esm' || supports({ runtimes: ['node', 'deno'] }))(
           'should call requestHook when provided',
           { timeout: 60_000 },
           async () => {
@@ -506,7 +506,7 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
     };
 
     createEsmAndCjsTests(__dirname, 'scenario-url.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
-      test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+      test.runIf(mode === 'esm' || supports({ runtimes: ['node', 'deno'] }))(
         'should instrument postgres package with URL initialization',
         { timeout: 90_000 },
         async () => {
@@ -592,7 +592,7 @@ describeWithDockerCompose('postgresjs auto instrumentation', { workingDirectory:
     };
 
     createEsmAndCjsTests(__dirname, 'scenario-unsafe.mjs', 'instrument.mjs', (createTestRunner, test, mode) => {
-      test.skipIf(RUNTIME === 'bun' && mode === 'cjs')(
+      test.runIf(mode === 'esm' || supports({ runtimes: ['node', 'deno'] }))(
         'should instrument sql.unsafe() queries',
         { timeout: 90_000 },
         async () => {
diff --git a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v8/test.ts b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v8/test.ts
index 0604374c83d6..e27358581b28 100644
--- a/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v8/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/prisma-orm-v8/test.ts
@@ -1,6 +1,6 @@
 import type { SerializedStreamedSpan, SerializedStreamedSpanContainer } from '@sentry/core';
 import { afterAll, describe, expect } from 'vitest';
-import { conditionalTest } from '../../../utils';
+import { supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
 afterAll(() => {
@@ -103,9 +103,12 @@ describe('Prisma ORM v8 Tests', () => {
 
         // The CJS scenario loads the ESM-only package via `require(esm)`, which Node's module hooks only see
         // from Node 22 on; on Node 20 the ORM terminals load uninstrumented.
-        conditionalTest({ min: 22 })('with require(esm) reaching the module hooks', testInstrumentedOperations);
+        describe.runIf(supports({ min: 22 }))(
+          'with require(esm) reaching the module hooks',
+          testInstrumentedOperations,
+        );
 
-        conditionalTest({ max: 21 })('with require(esm) bypassing the module hooks', () => {
+        describe.runIf(supports({ max: 21 }))('with require(esm) bypassing the module hooks', () => {
           test('should keep the pg spans on the transaction', { timeout: 75_000 }, async () => {
             await createRunner()
               .unordered()
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts
index 32c7204baeb2..4443209e17aa 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts
@@ -2,7 +2,7 @@ import { SENTRY_OP } from '@sentry/conventions/attributes';
 import { HTTP_CLIENT } from '@sentry/conventions/op';
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
-import { RUNTIME } from '../../../../utils';
+import { supports } from '../../../../utils';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
 
 describe('outgoing traceparent', () => {
@@ -44,28 +44,31 @@ describe('outgoing traceparent', () => {
   createEsmAndCjsTests(__dirname, 'scenario-http.mjs', 'instrument.mjs', (createRunner, test) => {
     // Bun 1.3.14 does not instrument outgoing `node:http` requests.
     // See https://github.com/getsentry/sentry-javascript/issues/23881
-    test.skipIf(RUNTIME === 'bun')('outgoing http requests should get traceparent headers', async () => {
-      expect.assertions(5);
+    test.runIf(supports({ runtimes: ['node', 'deno'] }))(
+      'outgoing http requests should get traceparent headers',
+      async () => {
+        expect.assertions(5);
 
-      const [SERVER_URL, closeTestServer] = await createTestServer()
-        .get('/api/v1', headers => {
-          expect(headers['baggage']).toEqual(expect.any(String));
-          expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/));
-          expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
-          expect(headers['traceparent']).toEqual(expect.stringMatching(/^00-([a-f\d]{32})-([a-f\d]{16})-01$/));
-        })
-        .start();
+        const [SERVER_URL, closeTestServer] = await createTestServer()
+          .get('/api/v1', headers => {
+            expect(headers['baggage']).toEqual(expect.any(String));
+            expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/));
+            expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+            expect(headers['traceparent']).toEqual(expect.stringMatching(/^00-([a-f\d]{32})-([a-f\d]{16})-01$/));
+          })
+          .start();
 
-      await createRunner()
-        .withEnv({ SERVER_URL })
-        .expect({
-          span: {
-            // Span contents are tested elsewhere.
-          },
-        })
-        .start()
-        .completed();
-      closeTestServer();
-    });
+        await createRunner()
+          .withEnv({ SERVER_URL })
+          .expect({
+            span: {
+              // Span contents are tested elsewhere.
+            },
+          })
+          .start()
+          .completed();
+        closeTestServer();
+      },
+    );
   });
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/tedious/test.ts b/dev-packages/node-integration-tests/suites/tracing/tedious/test.ts
index 1d24ab0e7041..31dd20a0c712 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tedious/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tedious/test.ts
@@ -10,8 +10,8 @@ import {
   SERVER_PORT,
 } from '@sentry/conventions/attributes';
 import { DB } from '@sentry/conventions/op';
-import { afterAll, expect } from 'vitest';
-import { conditionalTest } from '../../../utils';
+import { afterAll, describe, expect } from 'vitest';
+import { supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
 describeWithDockerCompose('tedious auto instrumentation', { workingDirectory: [__dirname] }, () => {
@@ -123,7 +123,7 @@ describeWithDockerCompose('tedious auto instrumentation', { workingDirectory: [_
   });
 
   // tedious 20 requires Node >= 22.
-  conditionalTest({ min: 22 })('tedious v20', () => {
+  describe.runIf(supports({ min: 22 }))('tedious v20', () => {
     createEsmAndCjsTests(
       __dirname,
       'scenario.mjs',
diff --git a/dev-packages/node-integration-tests/utils/index.ts b/dev-packages/node-integration-tests/utils/index.ts
index 0849c4464bfc..4a6b9a4dde96 100644
--- a/dev-packages/node-integration-tests/utils/index.ts
+++ b/dev-packages/node-integration-tests/utils/index.ts
@@ -1,13 +1,11 @@
 import type { EnvelopeItemType } from '@sentry/core';
 import { parseSemver } from '@sentry/core';
 import type * as http from 'http';
-import { describe } from 'vitest';
 
 export const NODE_VERSION = parseSemver(process.versions.node).major || 0;
 
 /**
  * The runtime that runs the scenarios (`node`, `bun` or `deno`), from the `RUNTIME` env var.
- * Tests use it in `test.skipIf` for behavior that a runtime does not support.
  */
 export type Runtime = 'cloudflare' | 'node' | 'bun' | 'deno';
 export const RUNTIME = (process.env.RUNTIME || 'node') as Runtime;
@@ -41,33 +39,34 @@ export type DataCollectorOptions = {
   envelopeType?: EnvelopeItemType | EnvelopeItemType[];
 };
 
+export type Requirements = {
+  /** Lowest Node major version that runs the tests. */
+  min?: number;
+  /** Highest Node major version that runs the tests. */
+  max?: number;
+  /** Runtimes that run the tests. All runtimes run them when this is not set. */
+  runtimes?: Runtime[];
+};
+
 /**
- * Returns`describe` or `describe.skip` depending on allowed major versions of Node and on the
- * runtime that runs the scenarios.
+ * Whether the Node version and the runtime that runs the scenarios meet the requirements of the
+ * tests, for use in `test.runIf` and `describe.runIf`.
  *
- * On Bun and Deno the version gate does not apply and the block always runs. A suite that the gate
- * keeps off a Node version because it cannot run there must also be excluded for these runtimes,
- * in `dev-packages/bun-integration-tests/node-suites/excludes.ts` and
- * `dev-packages/deno-integration-tests/node-suites/excludes.ts`, or skipped with `skipRuntimes`.
- *
- * @param options.min Lowest Node major version that runs the block.
- * @param options.max Highest Node major version that runs the block.
- * @param options.skipRuntimes Runtimes that skip the block, for a block that cannot run there.
+ * On Bun and Deno the Node version requirement does not apply. A suite that cannot run on a Node
+ * version must also be excluded for these runtimes, in
+ * `dev-packages/bun-integration-tests/node-suites/excludes.ts` and
+ * `dev-packages/deno-integration-tests/node-suites/excludes.ts`, or limited with `runtimes`.
  */
-export function conditionalTest(options: {
-  min?: number;
-  max?: number;
-  skipRuntimes?: Runtime[];
-}): typeof describe | typeof describe.skip {
-  if (options.skipRuntimes?.includes(RUNTIME)) {
-    return describe.skip;
+export function supports(requirements: Requirements): boolean {
+  if (requirements.runtimes && !requirements.runtimes.includes(RUNTIME)) {
+    return false;
   }
   // Vitest always runs on Node, so its Node version says nothing about Bun or Deno running the
   // scenario. Those runtimes list the suites they cannot run in their own exclude lists.
   if (RUNTIME !== 'node') {
-    return describe;
+    return true;
   }
-  return describe.skipIf(!matchesNodeVersion(options));
+  return matchesNodeVersion(requirements);
 }
 
 function matchesNodeVersion({ min, max }: { min?: number; max?: number }): boolean {

From f04b11ed14e7b477ce468faa43c369abde9dabd3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Peer=20St=C3=B6cklmair?= <jan.peer@sentry.io>
Date: Mon, 12 Oct 2026 15:10:13 +0200
Subject: [PATCH 72/84] ci(bun): Test the oldest supported Bun version and the
 newest 1.4 (#25203)

closes #23890
closes
[JS-3516](https://linear.app/getsentry/issue/JS-3516/bun-ci-pins-a-single-bun-version)

## Description

This runs the Bun unit and integration tests on Bun 1.3.14 and on `1.4`.
`setup-bun` resolves `1.4` to the newest 1.4.x release on each run.

## Version decisions

CI pinned 1.3.14 before, and it stays the oldest version that CI tests,
because older releases fail tests. On 1.3.4 to 1.3.13, an Anthropic
stream that fails midway records its response text twice, and before
1.3.4, `bun:test` has no `jest.advanceTimersByTime`. `1.4` floats and
blocks merges, so a broken Bun patch fails CI; the issue suggested a
non-blocking `latest` leg instead, which would run 1.4.2 twice until Bun
1.5 comes out.

## Known issues

- A new Bun minor version (1.5) needs a manual change of the matrix.
- The docs do not state the minimum Bun version yet.

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/build.yml | 15 +++++++++++----
 MIGRATION.md                |  2 ++
 packages/bun/package.json   |  3 ++-
 3 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 658fd862749c..bfe174349582 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -503,11 +503,16 @@ jobs:
         if: github.event_name != 'pull_request'
 
   job_bun_unit_tests:
-    name: Bun Unit Tests
+    name: Bun (${{ matrix.bun }}) Unit Tests
     needs: [job_get_metadata, job_build]
     if: needs.job_build.outputs.changed_bun == 'true' || github.event_name != 'pull_request'
     timeout-minutes: 10
     runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        # 1.3.14 is the oldest supported Bun version
+        bun: ['1.3.14', '1.4']
     steps:
       - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
         uses: actions/checkout@v7
@@ -520,7 +525,7 @@ jobs:
       - name: Set up Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: '1.3.14'
+          bun-version: ${{ matrix.bun }}
       - name: Restore caches
         uses: ./.github/actions/restore-cache
         with:
@@ -904,7 +909,7 @@ jobs:
         run: yarn test
 
   job_bun_integration_tests:
-    name: Bun Integration Tests (${{ matrix.shard }}/2)
+    name: Bun (${{ matrix.bun }}) Integration Tests (${{ matrix.shard }}/2)
     needs: [job_get_metadata, job_build]
     if: needs.job_build.outputs.changed_bun_integration == 'true' || github.event_name != 'pull_request'
     runs-on: ubuntu-24.04
@@ -912,6 +917,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
+        # 1.3.14 is the oldest supported Bun version
+        bun: ['1.3.14', '1.4']
         shard: [1, 2]
     steps:
       - name: Check out current commit (${{ needs.job_get_metadata.outputs.commit_label }})
@@ -925,7 +932,7 @@ jobs:
       - name: Set up Bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: '1.3.14'
+          bun-version: ${{ matrix.bun }}
       - name: Restore caches
         uses: ./.github/actions/restore-cache
         with:
diff --git a/MIGRATION.md b/MIGRATION.md
index 55be1d869f77..9785e86fd6a8 100644
--- a/MIGRATION.md
+++ b/MIGRATION.md
@@ -37,6 +37,8 @@ Version 11 of the Sentry SDK has new compatibility ranges for runtimes and frame
 
 **Deno:** The minimum supported Deno version is now **2.8.3**.
 
+**Bun:** The minimum supported Bun version is now **1.3.14**.
+
 **Browsers:** Support for **Safari 14** was dropped. Sentry now requires Safari 15 or higher. For the rest of the browser support matrix, refer to the [Sentry docs](https://docs.sentry.io/platforms/javascript/#browser-support).
 
 ### TypeScript Version Policy
diff --git a/packages/bun/package.json b/packages/bun/package.json
index 8d11865d2f80..b87c8af7bb59 100644
--- a/packages/bun/package.json
+++ b/packages/bun/package.json
@@ -7,7 +7,8 @@
   "author": "Sentry",
   "license": "MIT",
   "engines": {
-    "node": ">=20.19.0 <22.0.0 || >=22.12.0 <23.0.0 || >=23.2.0"
+    "node": ">=20.19.0 <22.0.0 || >=22.12.0 <23.0.0 || >=23.2.0",
+    "bun": ">=1.3.14"
   },
   "files": [
     "/build"

From a11af3ef9c30999a9bf901c6885c7902d5954d57 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Peer=20St=C3=B6cklmair?= <jan.peer@sentry.io>
Date: Mon, 12 Oct 2026 15:10:13 +0200
Subject: [PATCH 73/84] test(bun): Run the Node suites that need Bun 1.4 on the
 Bun 1.4 job (#25204)

> *Pro Tip*: It is better to review it with the option "Hide
whitespaces":
https://github.com/getsentry/sentry-javascript/pull/25204/changes?w=1

follow up to #25203

## Description

This adds a `bunMin` requirement to `supports` and moves the Node suites
that pass only on Bun 1.4 from the Bun exclude lists to
`runIf(supports({ bunMin: '1.4.0' }))`. The Bun 1.4 job now runs them,
and the 1.3.14 job skips them. These are the outgoing `node:http` suites
(#23881), `system-error` and `tracer-start-active-span-error`.

```ts
describe.runIf(supports({ bunMin: '1.4.0' }))('outgoing http', () => {});
```

Most of the diff is new indentation. Hide whitespace to review.

## Known issues

- `system-error` stays excluded in the `@sentry/bun` project, because
`@sentry/bun` does not include `nodeSystemErrorIntegration`.
- `tracer-start-active-span-error` passed on Bun 1.3.14 on macOS, but
the old exclude comment says that it fails there, so it keeps the 1.4
minimum.

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../node-suites/excludes.ts                   |  40 ++-----
 .../node-suites/excludes.ts                   |   2 +-
 dev-packages/node-integration-tests/README.md |   3 +-
 .../suites/system-error/test.ts               |   4 +-
 .../tracing/dsc-txn-name-update/test.ts       | 110 +++++++++---------
 .../http-client-spans/http-basic/test.ts      |   5 +-
 .../http-strip-query/test.ts                  |   5 +-
 .../continued-trace-segment/test.ts           |   4 +-
 .../no-parent-span-client-report/test.ts      |   4 +-
 .../tracing/requests/http-breadcrumbs/test.ts |   5 +-
 .../requests/http-maxed-out-sockets/test.ts   |   5 +-
 .../http-no-trace-propagation/test.ts         |   5 +-
 .../requests/http-no-tracing-no-spans/test.ts |   5 +-
 .../tracing/requests/http-no-tracing/test.ts  |   5 +-
 .../http-sampled-no-active-span/test.ts       |   5 +-
 .../tracing/requests/http-sampled/test.ts     |   5 +-
 .../tracing/requests/http-unsampled/test.ts   |   5 +-
 .../tracing/requests/traceparent/test.ts      |  47 ++++----
 .../baggage-org-id/test.ts                    |  47 ++++----
 .../case-insensitive/test.ts                  |   5 +-
 .../tracing/tracePropagationTargets/test.ts   |  72 ++++++------
 .../tracer-start-active-span-error/test.ts    |   4 +-
 .../node-integration-tests/utils/index.ts     |  28 ++++-
 23 files changed, 237 insertions(+), 183 deletions(-)

diff --git a/dev-packages/bun-integration-tests/node-suites/excludes.ts b/dev-packages/bun-integration-tests/node-suites/excludes.ts
index 86aa8f9a65e1..94f084f717d8 100644
--- a/dev-packages/bun-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/bun-integration-tests/node-suites/excludes.ts
@@ -1,6 +1,7 @@
 // Node suites that do not run on Bun, relative to `node-integration-tests`. A single test that
 // fails on Bun runs only on the other runtimes, with `test.runIf(supports({ runtimes }))` in the
-// Node suite, and is not listed here.
+// Node suite, and a suite or test that fails only on older Bun versions runs with
+// `supports({ bunMin })`. Neither is listed here.
 
 // Node-only features: ANR and native thread watchdogs, child processes, the AWS Lambda Node runtime,
 // `node:sqlite`, which `flue` needs, and the Vercel keep-alive, which needs `http.server.response.finish`.
@@ -57,23 +58,6 @@ const NO_FETCH_INSTRUMENTATION = [
   'suites/tracing/requests/traceparent/test.ts',
 ];
 
-// Bun 1.3.14 (the CI version) does not instrument outgoing `node:http` requests. These suites pass
-// on Bun 1.4.2. See https://github.com/getsentry/sentry-javascript/issues/23881
-const NO_OUTGOING_HTTP_INSTRUMENTATION = [
-  'suites/tracing/dsc-txn-name-update/test.ts',
-  'suites/tracing/http-client-spans/http-basic/test.ts',
-  'suites/tracing/http-client-spans/http-strip-query/test.ts',
-  'suites/tracing/requests/http-breadcrumbs/test.ts',
-  'suites/tracing/requests/http-maxed-out-sockets/test.ts',
-  'suites/tracing/requests/http-no-trace-propagation/test.ts',
-  'suites/tracing/requests/http-no-tracing-no-spans/test.ts',
-  'suites/tracing/requests/http-no-tracing/test.ts',
-  'suites/tracing/requests/http-sampled-no-active-span/test.ts',
-  'suites/tracing/requests/http-sampled/test.ts',
-  'suites/tracing/requests/http-unsampled/test.ts',
-  'suites/tracing/tracePropagationTargets/**',
-];
-
 // `bun run` cannot inject the diagnostics channels into libraries, so framework, database and AI
 // instrumentation creates no spans. Apps must be built with `@sentry/bun/plugin`.
 // See https://github.com/getsentry/sentry-javascript/issues/23882
@@ -142,17 +126,16 @@ export const NO_AUTO_INSTRUMENTATION = [
   'suites/tracing/vercelai/**',
 ];
 
-// Fail on Bun, cause not investigated yet. `system-error` and `tracer-start-active-span-error`
-// fail on Bun 1.3.14 and pass on Bun 1.4.2. With the `@sentry/bun` alias, `system-error` also
-// fails because `@sentry/bun` does not include `nodeSystemErrorIntegration`.
+// Fail on Bun. The cause is not investigated yet.
 const NOT_TRIAGED = [
   'suites/contextLines/filename-with-spaces/test.ts',
   'suites/modules/test.ts',
   'suites/proxy/test.ts',
-  'suites/system-error/test.ts',
-  'suites/tracing/tracer-start-active-span-error/test.ts',
 ];
 
+// The suite expects the events of `nodeSystemErrorIntegration`, which `@sentry/bun` does not include.
+const NO_SYSTEM_ERROR_INTEGRATION = ['suites/system-error/test.ts'];
+
 // The scenario configures `nativeNodeFetchIntegration`, which `@sentry/bun` does not export.
 const NO_NATIVE_NODE_FETCH_INTEGRATION = [
   'suites/tracing/http-client-spans/fetch-forward-request-hook/test.ts',
@@ -202,13 +185,7 @@ const NO_EXPRESS_INSTRUMENTATION = [
   'suites/tracing/traceid-recycling-with-spans/test.ts',
 ];
 
-export const NODE_SUITES_EXCLUDE = [
-  '**/node_modules/**',
-  ...NODE_ONLY,
-  ...NO_OUTGOING_HTTP_INSTRUMENTATION,
-  ...NO_AUTO_INSTRUMENTATION,
-  ...NOT_TRIAGED,
-];
+export const NODE_SUITES_EXCLUDE = ['**/node_modules/**', ...NODE_ONLY, ...NO_AUTO_INSTRUMENTATION, ...NOT_TRIAGED];
 
 // Excluded only in the `node-suites` project, which runs the suites with `@sentry/node`.
 export const SENTRY_NODE_EXCLUDE = [...NO_HTTP_SERVER_SPANS, ...NO_FETCH_INSTRUMENTATION];
@@ -217,6 +194,7 @@ export const SENTRY_NODE_EXCLUDE = [...NO_HTTP_SERVER_SPANS, ...NO_FETCH_INSTRUM
 export const SENTRY_BUN_EXCLUDE = [
   ...HTTP_SERVER_OPTIONS_IGNORED,
   ...NO_EXPRESS_INSTRUMENTATION,
+  ...NO_SYSTEM_ERROR_INTEGRATION,
   ...NO_NATIVE_NODE_FETCH_INTEGRATION,
   ...FETCH_INTEGRATION_DIFFERS,
 ];
@@ -233,7 +211,7 @@ const BUN_BUILD_EAGER_SUBSCRIPTION = ['suites/tracing/orchestrion-lazy-registrat
 // `http.server.request.start`.
 const BUN_BUILD_NO_HTTP_SERVER_INTEGRATION = ['suites/express/multiple-init/test.ts'];
 
-// Some or all tests fail with the bundled scenarios, cause not investigated yet. In
+// Some or all tests fail with the bundled scenarios. The cause is not investigated yet. In
 // `express/tracing` only the request data tests fail: they set `httpIntegration` options, and with
 // `@sentry/bun` the request body comes from `bunHttpServerIntegration`.
 const BUN_BUILD_NOT_TRIAGED = [
diff --git a/dev-packages/deno-integration-tests/node-suites/excludes.ts b/dev-packages/deno-integration-tests/node-suites/excludes.ts
index b2a6b1b851a8..a6ad2a290f16 100644
--- a/dev-packages/deno-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/deno-integration-tests/node-suites/excludes.ts
@@ -45,7 +45,7 @@ const REQUIRE_OF_ESM_ONLY_DEPENDENCY = [
   'suites/tracing/prisma-orm-v8/test.ts',
 ];
 
-// Some or all tests fail on Deno, cause not investigated yet. In most AI suites the span
+// Some or all tests fail on Deno. The cause is not investigated yet. In most AI suites the span
 // streaming test fails. `apollo-graphql` (CJS tests only) and `mongodb` fail on Deno 2.8.3 (the CI
 // version) and pass on Deno 2.9.0.
 const NOT_TRIAGED = [
diff --git a/dev-packages/node-integration-tests/README.md b/dev-packages/node-integration-tests/README.md
index 67272bf5f6b0..bfdbc2a63957 100644
--- a/dev-packages/node-integration-tests/README.md
+++ b/dev-packages/node-integration-tests/README.md
@@ -68,7 +68,8 @@ arriving after its condition is satisfied.
 `dev-packages/bun-integration-tests` and `dev-packages/deno-integration-tests` run every suite of this package on Bun
 and Deno as well. When you add a suite, check that it passes on both. If it cannot, add it to
 `node-suites/excludes.ts` of the runtime's package with the reason, or run the single tests that fail only on the
-other runtimes, for example `test.runIf(supports({ runtimes: ['node', 'deno'] }))` for a test that fails on Bun.
+other runtimes, for example `test.runIf(supports({ runtimes: ['node', 'deno'] }))` for a test that fails on Bun. A
+suite or test that fails only on Bun versions older than a given one runs with `supports({ bunMin: '1.4.0' })`.
 
 ## Running Tests Locally
 
diff --git a/dev-packages/node-integration-tests/suites/system-error/test.ts b/dev-packages/node-integration-tests/suites/system-error/test.ts
index e04fef7afec9..2b5f8f1ccf96 100644
--- a/dev-packages/node-integration-tests/suites/system-error/test.ts
+++ b/dev-packages/node-integration-tests/suites/system-error/test.ts
@@ -1,11 +1,13 @@
 import { afterAll, describe, test } from 'vitest';
 import { cleanupChildProcesses, createRunner } from '../../utils/runner';
+import { supports } from '../../utils';
 
 afterAll(() => {
   cleanupChildProcesses();
 });
 
-describe('SystemError integration', () => {
+// Fails on Bun before 1.4. The cause is not investigated yet.
+describe.runIf(supports({ bunMin: '1.4.0' }))('SystemError integration', () => {
   test('userInfo: false', async () => {
     await createRunner(__dirname, 'basic.mjs')
       .expect({
diff --git a/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/test.ts b/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/test.ts
index 821662369b80..01dc6a8effd6 100644
--- a/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/dsc-txn-name-update/test.ts
@@ -1,64 +1,70 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { expect, test } from 'vitest';
 import { createRunner } from '../../../utils/runner';
+import { supports } from '../../../utils';
 
-test('adds current transaction name to baggage when the txn name is high-quality', async () => {
-  expect.assertions(5);
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+test.runIf(supports({ bunMin: '1.4.0' }))(
+  'adds current transaction name to baggage when the txn name is high-quality',
+  async () => {
+    expect.assertions(5);
 
-  let traceId: string | undefined;
+    let traceId: string | undefined;
 
-  const [SERVER_URL, closeTestServer] = await createTestServer()
-    .get('/api/v0', headers => {
-      const baggageItems = getBaggageHeaderItems(headers);
-      traceId = baggageItems.find(item => item.startsWith('sentry-trace_id='))?.split('=')[1] as string;
+    const [SERVER_URL, closeTestServer] = await createTestServer()
+      .get('/api/v0', headers => {
+        const baggageItems = getBaggageHeaderItems(headers);
+        traceId = baggageItems.find(item => item.startsWith('sentry-trace_id='))?.split('=')[1] as string;
 
-      expect(traceId).toMatch(/^[\da-f]{32}$/);
+        expect(traceId).toMatch(/^[\da-f]{32}$/);
 
-      expect(baggageItems).toEqual([
-        'sentry-environment=production',
-        'sentry-public_key=public',
-        'sentry-release=1.0',
-        expect.stringMatching(/sentry-sample_rand=0\.\d+/),
-        'sentry-sample_rate=1',
-        'sentry-sampled=true',
-        `sentry-trace_id=${traceId}`,
-      ]);
-    })
-    .get('/api/v1', headers => {
-      expect(getBaggageHeaderItems(headers)).toEqual([
-        'sentry-environment=production',
-        'sentry-public_key=public',
-        'sentry-release=1.0',
-        expect.stringMatching(/sentry-sample_rand=0\.\d+/),
-        'sentry-sample_rate=1',
-        'sentry-sampled=true',
-        `sentry-trace_id=${traceId}`,
-        'sentry-transaction=updated-name-1',
-      ]);
-    })
-    .get('/api/v2', headers => {
-      expect(getBaggageHeaderItems(headers)).toEqual([
-        'sentry-environment=production',
-        'sentry-public_key=public',
-        'sentry-release=1.0',
-        expect.stringMatching(/sentry-sample_rand=0\.\d+/),
-        'sentry-sample_rate=1',
-        'sentry-sampled=true',
-        `sentry-trace_id=${traceId}`,
-        'sentry-transaction=updated-name-2',
-      ]);
-    })
-    .start();
+        expect(baggageItems).toEqual([
+          'sentry-environment=production',
+          'sentry-public_key=public',
+          'sentry-release=1.0',
+          expect.stringMatching(/sentry-sample_rand=0\.\d+/),
+          'sentry-sample_rate=1',
+          'sentry-sampled=true',
+          `sentry-trace_id=${traceId}`,
+        ]);
+      })
+      .get('/api/v1', headers => {
+        expect(getBaggageHeaderItems(headers)).toEqual([
+          'sentry-environment=production',
+          'sentry-public_key=public',
+          'sentry-release=1.0',
+          expect.stringMatching(/sentry-sample_rand=0\.\d+/),
+          'sentry-sample_rate=1',
+          'sentry-sampled=true',
+          `sentry-trace_id=${traceId}`,
+          'sentry-transaction=updated-name-1',
+        ]);
+      })
+      .get('/api/v2', headers => {
+        expect(getBaggageHeaderItems(headers)).toEqual([
+          'sentry-environment=production',
+          'sentry-public_key=public',
+          'sentry-release=1.0',
+          expect.stringMatching(/sentry-sample_rand=0\.\d+/),
+          'sentry-sample_rate=1',
+          'sentry-sampled=true',
+          `sentry-trace_id=${traceId}`,
+          'sentry-transaction=updated-name-2',
+        ]);
+      })
+      .start();
 
-  await createRunner(__dirname, 'scenario-headers.ts')
-    .withEnv({ SERVER_URL })
-    .expect({
-      span: {},
-    })
-    .start()
-    .completed();
-  closeTestServer();
-});
+    await createRunner(__dirname, 'scenario-headers.ts')
+      .withEnv({ SERVER_URL })
+      .expect({
+        span: {},
+      })
+      .start()
+      .completed();
+    closeTestServer();
+  },
+);
 
 test('adds current transaction name to trace envelope header when the txn name is high-quality', async () => {
   expect.assertions(4);
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-basic/test.ts b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-basic/test.ts
index 8d10084ce45e..7540e4df4c74 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-basic/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-basic/test.ts
@@ -1,8 +1,11 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createCjsTests } from '../../../../utils/runner';
+import { supports } from '../../../../utils';
 
-describe('outgoing http spans', () => {
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+describe.runIf(supports({ bunMin: '1.4.0' }))('outgoing http spans', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/test.ts b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/test.ts
index e018a905ba28..ea01d0e2d6ce 100644
--- a/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/http-client-spans/http-strip-query/test.ts
@@ -17,8 +17,11 @@ import {
 import { createTestServer } from '@sentry-internal/test-utils';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createCjsTests } from '../../../../utils/runner';
+import { supports } from '../../../../utils';
 
-describe('outgoing http spans - strip query', () => {
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+describe.runIf(supports({ bunMin: '1.4.0' }))('outgoing http spans - strip query', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts
index 69c9874cd27f..cca3404c8c77 100644
--- a/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/ignoreSpans/continued-trace-segment/test.ts
@@ -41,9 +41,9 @@ describe('ignoring a continued server segment', () => {
     };
 
     test('propagates a negative sampling decision to outgoing fetch requests', () => testPropagation('/ignored'));
-    // Bun 1.3.14 does not instrument outgoing `node:http` requests.
+    // Bun before 1.4 does not instrument outgoing `node:http` requests.
     // See https://github.com/getsentry/sentry-javascript/issues/23881
-    test.runIf(supports({ runtimes: ['node', 'deno'] }))(
+    test.runIf(supports({ bunMin: '1.4.0' }))(
       'propagates a negative sampling decision to outgoing node:http requests',
       () => testPropagation('/ignored-http'),
     );
diff --git a/dev-packages/node-integration-tests/suites/tracing/no-parent-span-client-report/test.ts b/dev-packages/node-integration-tests/suites/tracing/no-parent-span-client-report/test.ts
index 86702f80ee20..7119c19386ca 100644
--- a/dev-packages/node-integration-tests/suites/tracing/no-parent-span-client-report/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/no-parent-span-client-report/test.ts
@@ -8,9 +8,9 @@ describe('no_parent_span client report', () => {
   });
 
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
-    // Bun 1.3.14 does not instrument outgoing `node:http` requests.
+    // Bun before 1.4 does not instrument outgoing `node:http` requests.
     // See https://github.com/getsentry/sentry-javascript/issues/23881
-    test.runIf(supports({ runtimes: ['node', 'deno'] }))(
+    test.runIf(supports({ bunMin: '1.4.0' }))(
       'records no_parent_span outcome for an outgoing http request without a local parent',
       async () => {
         const runner = createRunner()
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-breadcrumbs/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-breadcrumbs/test.ts
index adf08ca19664..b11a2b17af8d 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-breadcrumbs/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-breadcrumbs/test.ts
@@ -1,8 +1,11 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
+import { supports } from '../../../../utils';
 
-describe('outgoing http', () => {
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+describe.runIf(supports({ bunMin: '1.4.0' }))('outgoing http', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     test('outgoing http requests create breadcrumbs', async () => {
       const [SERVER_URL, closeTestServer] = await createTestServer().start();
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/test.ts
index 1f3f507c699f..dea41c1e52b0 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-maxed-out-sockets/test.ts
@@ -1,8 +1,11 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
+import { supports } from '../../../../utils';
 
-describe('outgoing http with maxed-out agent sockets', () => {
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+describe.runIf(supports({ bunMin: '1.4.0' }))('outgoing http with maxed-out agent sockets', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     test('injects trace headers into requests queued behind a busy socket', async () => {
       expect.assertions(5);
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-trace-propagation/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-trace-propagation/test.ts
index e4a592e5b571..e8c9f713943b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-trace-propagation/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-trace-propagation/test.ts
@@ -1,8 +1,11 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
+import { supports } from '../../../../utils';
 
-describe('outgoing http with tracePropagation disabled', () => {
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+describe.runIf(supports({ bunMin: '1.4.0' }))('outgoing http with tracePropagation disabled', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     test('does not inject trace headers but still creates breadcrumbs', async () => {
       expect.assertions(5);
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing-no-spans/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing-no-spans/test.ts
index df073d2c7ef0..8b63c5f18139 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing-no-spans/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing-no-spans/test.ts
@@ -1,8 +1,11 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
+import { supports } from '../../../../utils';
 
-describe('outgoing http requests with tracing & spans disabled', () => {
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+describe.runIf(supports({ bunMin: '1.4.0' }))('outgoing http requests with tracing & spans disabled', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     test('outgoing http requests are correctly instrumented with tracing & spans disabled', async () => {
       expect.assertions(11);
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing/test.ts
index 6bc9f3f06c6a..f28e25d77fb0 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-no-tracing/test.ts
@@ -1,8 +1,11 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
+import { supports } from '../../../../utils';
 
-describe('outgoing http', () => {
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+describe.runIf(supports({ bunMin: '1.4.0' }))('outgoing http', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     test('outgoing http requests are correctly instrumented with tracing disabled', async () => {
       expect.assertions(11);
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/test.ts
index b00148c26142..b1dec11ae4ae 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled-no-active-span/test.ts
@@ -1,8 +1,11 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
+import { supports } from '../../../../utils';
 
-describe('outgoing http', () => {
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+describe.runIf(supports({ bunMin: '1.4.0' }))('outgoing http', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     test('outgoing sampled http requests without active span are correctly instrumented', async () => {
       expect.assertions(11);
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts
index fe3621236b80..5be9793baae3 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-sampled/test.ts
@@ -1,8 +1,11 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
+import { supports } from '../../../../utils';
 
-describe('outgoing http', () => {
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+describe.runIf(supports({ bunMin: '1.4.0' }))('outgoing http', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     test('outgoing sampled http requests are correctly instrumented', async () => {
       expect.assertions(11);
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/test.ts
index 1b40af0b6ec3..357fd39cf28c 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/http-unsampled/test.ts
@@ -1,8 +1,11 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { describe, expect } from 'vitest';
 import { createEsmAndCjsTests } from '../../../../utils/runner';
+import { supports } from '../../../../utils';
 
-describe('outgoing http', () => {
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+describe.runIf(supports({ bunMin: '1.4.0' }))('outgoing http', () => {
   createEsmAndCjsTests(__dirname, 'scenario.mjs', 'instrument.mjs', (createRunner, test) => {
     test('outgoing http requests are correctly instrumented when not sampled', async () => {
       expect.assertions(11);
diff --git a/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts b/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts
index 4443209e17aa..642f6bcf407e 100644
--- a/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/requests/traceparent/test.ts
@@ -42,33 +42,30 @@ describe('outgoing traceparent', () => {
   });
 
   createEsmAndCjsTests(__dirname, 'scenario-http.mjs', 'instrument.mjs', (createRunner, test) => {
-    // Bun 1.3.14 does not instrument outgoing `node:http` requests.
+    // Bun before 1.4 does not instrument outgoing `node:http` requests.
     // See https://github.com/getsentry/sentry-javascript/issues/23881
-    test.runIf(supports({ runtimes: ['node', 'deno'] }))(
-      'outgoing http requests should get traceparent headers',
-      async () => {
-        expect.assertions(5);
+    test.runIf(supports({ bunMin: '1.4.0' }))('outgoing http requests should get traceparent headers', async () => {
+      expect.assertions(5);
 
-        const [SERVER_URL, closeTestServer] = await createTestServer()
-          .get('/api/v1', headers => {
-            expect(headers['baggage']).toEqual(expect.any(String));
-            expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/));
-            expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
-            expect(headers['traceparent']).toEqual(expect.stringMatching(/^00-([a-f\d]{32})-([a-f\d]{16})-01$/));
-          })
-          .start();
+      const [SERVER_URL, closeTestServer] = await createTestServer()
+        .get('/api/v1', headers => {
+          expect(headers['baggage']).toEqual(expect.any(String));
+          expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/));
+          expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+          expect(headers['traceparent']).toEqual(expect.stringMatching(/^00-([a-f\d]{32})-([a-f\d]{16})-01$/));
+        })
+        .start();
 
-        await createRunner()
-          .withEnv({ SERVER_URL })
-          .expect({
-            span: {
-              // Span contents are tested elsewhere.
-            },
-          })
-          .start()
-          .completed();
-        closeTestServer();
-      },
-    );
+      await createRunner()
+        .withEnv({ SERVER_URL })
+        .expect({
+          span: {
+            // Span contents are tested elsewhere.
+          },
+        })
+        .start()
+        .completed();
+      closeTestServer();
+    });
   });
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/test.ts b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/test.ts
index 732473ac4880..19991857bfcb 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/baggage-org-id/test.ts
@@ -1,37 +1,42 @@
-import { afterAll, expect, test } from 'vitest';
+import { afterAll, describe, expect, test } from 'vitest';
 import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
 import type { TestAPIResponse } from './server';
+import { supports } from '../../../../utils';
 
 afterAll(() => {
   cleanupChildProcesses();
 });
 
-test('should include explicitly set org_id in the baggage header', async () => {
-  const runner = createRunner(__dirname, 'server.ts').start();
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+describe.runIf(supports({ bunMin: '1.4.0' }))('baggage org_id', () => {
+  test('should include explicitly set org_id in the baggage header', async () => {
+    const runner = createRunner(__dirname, 'server.ts').start();
 
-  const response = await runner.makeRequest<TestAPIResponse>('get', '/test/express');
-  expect(response).toBeDefined();
+    const response = await runner.makeRequest<TestAPIResponse>('get', '/test/express');
+    expect(response).toBeDefined();
 
-  const baggage = response?.test_data.baggage;
-  expect(baggage).toContain('sentry-org_id=01234987');
-});
+    const baggage = response?.test_data.baggage;
+    expect(baggage).toContain('sentry-org_id=01234987');
+  });
 
-test('should extract org_id from DSN host when not explicitly set', async () => {
-  const runner = createRunner(__dirname, 'server-no-explicit-org-id.ts').start();
+  test('should extract org_id from DSN host when not explicitly set', async () => {
+    const runner = createRunner(__dirname, 'server-no-explicit-org-id.ts').start();
 
-  const response = await runner.makeRequest<TestAPIResponse>('get', '/test/express');
-  expect(response).toBeDefined();
+    const response = await runner.makeRequest<TestAPIResponse>('get', '/test/express');
+    expect(response).toBeDefined();
 
-  const baggage = response?.test_data.baggage;
-  expect(baggage).toContain('sentry-org_id=01234987');
-});
+    const baggage = response?.test_data.baggage;
+    expect(baggage).toContain('sentry-org_id=01234987');
+  });
 
-test('should set undefined org_id when it cannot be extracted', async () => {
-  const runner = createRunner(__dirname, 'server-no-org-id.ts').start();
+  test('should set undefined org_id when it cannot be extracted', async () => {
+    const runner = createRunner(__dirname, 'server-no-org-id.ts').start();
 
-  const response = await runner.makeRequest<TestAPIResponse>('get', '/test/express');
-  expect(response).toBeDefined();
+    const response = await runner.makeRequest<TestAPIResponse>('get', '/test/express');
+    expect(response).toBeDefined();
 
-  const baggage = response?.test_data.baggage;
-  expect(baggage).not.toContain('sentry-org_id');
+    const baggage = response?.test_data.baggage;
+    expect(baggage).not.toContain('sentry-org_id');
+  });
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/case-insensitive/test.ts b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/case-insensitive/test.ts
index 46eba247aa1b..2a72b31b5c7c 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/case-insensitive/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/case-insensitive/test.ts
@@ -1,8 +1,11 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { expect, test } from 'vitest';
 import { createRunner } from '../../../../utils/runner';
+import { supports } from '../../../../utils';
 
-test('tracePropagationTargets match regardless of casing', async () => {
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+test.runIf(supports({ bunMin: '1.4.0' }))('tracePropagationTargets match regardless of casing', async () => {
   expect.assertions(9);
 
   const [SERVER_URL, closeTestServer] = await createTestServer()
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts
index 4ef1bb6c4bfe..8f212e94e72b 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tracePropagationTargets/test.ts
@@ -1,39 +1,45 @@
 import { createTestServer } from '@sentry-internal/test-utils';
 import { expect, test } from 'vitest';
 import { createRunner } from '../../../utils/runner';
+import { supports } from '../../../utils';
 
-test('HttpIntegration should instrument correct requests when tracePropagationTargets option is provided', async () => {
-  expect.assertions(11);
+// Bun before 1.4 does not instrument outgoing `node:http` requests.
+// See https://github.com/getsentry/sentry-javascript/issues/23881
+test.runIf(supports({ bunMin: '1.4.0' }))(
+  'HttpIntegration should instrument correct requests when tracePropagationTargets option is provided',
+  async () => {
+    expect.assertions(11);
 
-  const [SERVER_URL, closeTestServer] = await createTestServer()
-    .get('/api/v0', headers => {
-      expect(headers['baggage']).toEqual(expect.any(String));
-      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/));
-      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
-    })
-    .get('/api/v1', headers => {
-      expect(headers['baggage']).toEqual(expect.any(String));
-      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/));
-      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
-    })
-    .get('/api/v2', headers => {
-      expect(headers['baggage']).toBeUndefined();
-      expect(headers['sentry-trace']).toBeUndefined();
-    })
-    .get('/api/v3', headers => {
-      expect(headers['baggage']).toBeUndefined();
-      expect(headers['sentry-trace']).toBeUndefined();
-    })
-    .start();
+    const [SERVER_URL, closeTestServer] = await createTestServer()
+      .get('/api/v0', headers => {
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
+      })
+      .get('/api/v1', headers => {
+        expect(headers['baggage']).toEqual(expect.any(String));
+        expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-1$/));
+        expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-1');
+      })
+      .get('/api/v2', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .get('/api/v3', headers => {
+        expect(headers['baggage']).toBeUndefined();
+        expect(headers['sentry-trace']).toBeUndefined();
+      })
+      .start();
 
-  await createRunner(__dirname, 'scenario.ts')
-    .withEnv({ SERVER_URL })
-    .expect({
-      span: {
-        // Span contents are tested elsewhere.
-      },
-    })
-    .start()
-    .completed();
-  closeTestServer();
-});
+    await createRunner(__dirname, 'scenario.ts')
+      .withEnv({ SERVER_URL })
+      .expect({
+        span: {
+          // Span contents are tested elsewhere.
+        },
+      })
+      .start()
+      .completed();
+    closeTestServer();
+  },
+);
diff --git a/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/test.ts b/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/test.ts
index b8d33d7976cf..993777eb2ca2 100644
--- a/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/tracer-start-active-span-error/test.ts
@@ -1,7 +1,9 @@
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
+import { supports } from '../../../utils';
 
-describe('tracer.startActiveSpan errors', () => {
+// Fails on Bun before 1.4. The cause is not investigated yet.
+describe.runIf(supports({ bunMin: '1.4.0' }))('tracer.startActiveSpan errors', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
diff --git a/dev-packages/node-integration-tests/utils/index.ts b/dev-packages/node-integration-tests/utils/index.ts
index 4a6b9a4dde96..b3a1dfd8153d 100644
--- a/dev-packages/node-integration-tests/utils/index.ts
+++ b/dev-packages/node-integration-tests/utils/index.ts
@@ -1,5 +1,6 @@
 import type { EnvelopeItemType } from '@sentry/core';
 import { parseSemver } from '@sentry/core';
+import { execFileSync } from 'child_process';
 import type * as http from 'http';
 
 export const NODE_VERSION = parseSemver(process.versions.node).major || 0;
@@ -10,6 +11,9 @@ export const NODE_VERSION = parseSemver(process.versions.node).major || 0;
 export type Runtime = 'cloudflare' | 'node' | 'bun' | 'deno';
 export const RUNTIME = (process.env.RUNTIME || 'node') as Runtime;
 
+// Vitest runs on Node, so it cannot read `Bun.version` of the `bun` binary that runs the scenarios.
+const BUN_VERSION = RUNTIME === 'bun' ? execFileSync('bun', ['--version'], { encoding: 'utf8' }).trim() : undefined;
+
 /**
  * The `sdk.name` the scenarios send. It is `sentry.javascript.node`, unless a runtime package
  * maps `@sentry/node` to its own SDK and sets the `EXPECTED_SDK_NAME` env var to that SDK's name.
@@ -44,13 +48,15 @@ export type Requirements = {
   min?: number;
   /** Highest Node major version that runs the tests. */
   max?: number;
+  /** Lowest Bun version that runs the tests, for tests that fail on the oldest Bun version in CI. */
+  bunMin?: string;
   /** Runtimes that run the tests. All runtimes run them when this is not set. */
   runtimes?: Runtime[];
 };
 
 /**
- * Whether the Node version and the runtime that runs the scenarios meet the requirements of the
- * tests, for use in `test.runIf` and `describe.runIf`.
+ * Whether the Node version, the runtime and the Bun version that run the scenarios meet the
+ * requirements of the tests, for use in `test.runIf` and `describe.runIf`.
  *
  * On Bun and Deno the Node version requirement does not apply. A suite that cannot run on a Node
  * version must also be excluded for these runtimes, in
@@ -61,6 +67,9 @@ export function supports(requirements: Requirements): boolean {
   if (requirements.runtimes && !requirements.runtimes.includes(RUNTIME)) {
     return false;
   }
+  if (RUNTIME === 'bun') {
+    return !requirements.bunMin || !isBunOlderThan(requirements.bunMin);
+  }
   // Vitest always runs on Node, so its Node version says nothing about Bun or Deno running the
   // scenario. Those runtimes list the suites they cannot run in their own exclude lists.
   if (RUNTIME !== 'node') {
@@ -77,6 +86,21 @@ function matchesNodeVersion({ min, max }: { min?: number; max?: number }): boole
   return !(NODE_VERSION < (min || -Infinity) || NODE_VERSION > (max || Infinity));
 }
 
+function isBunOlderThan(version: string): boolean {
+  if (!BUN_VERSION) {
+    return false;
+  }
+
+  const current = parseSemver(BUN_VERSION);
+  const required = parseSemver(version);
+  const difference =
+    (current.major || 0) - (required.major || 0) ||
+    (current.minor || 0) - (required.minor || 0) ||
+    (current.patch || 0) - (required.patch || 0);
+
+  return difference < 0;
+}
+
 /**
  * Parses response body containing an Envelope
  *

From 81ad409d3f1c880df2e4ed1512a239fcf713512a Mon Sep 17 00:00:00 2001
From: Francesco Gringl-Novy <francesco.novy@sentry.io>
Date: Mon, 12 Oct 2026 15:11:42 +0200
Subject: [PATCH 74/84] feat(node): Stop sending the process session once
 request sessions are tracked (#24915)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A Node server currently reports release health twice: through request
session aggregates, and through the process session started by
`processSessionIntegration`. Request isolation scopes inherit the
process session, so the first error in any request also marks the
process session as errored, which double counts it. No other server SDK
sends a process session alongside request aggregates (Python and Ruby
send aggregates only, Rust makes you pick one mode), and the sessions
spec describes servers as request mode only.

The process session is still useful for processes that don't serve
requests (scripts, CLIs, workers), so instead of removing it we switch
automatically: on the first tracked request session, the process session
is dropped. The process session sends nothing until an error or
`beforeExit`, so in the common case nothing was ever sent for it. If an
update was already sent (an error before the first request), it is
closed as `exited` so it doesn't stay open forever. Servers with
`httpServerIntegration({ sessions: false })` never record request
sessions and keep the process session as before.

Request errors also no longer touch the process session inherited by the
request scope, since the aggregate already counts them.

The process session is now started in `setup` rather than `setupOnce`,
so the request-session hook can be tied to the client and the scope that
holds the session. As a side effect, calling `Sentry.init()` again in
the same process ends the current session and starts a new one, instead
of keeping the first.

This changes release health numbers for Node servers: they lose the one
errored/crashed process-session update they send today.

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

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../node-suites/excludes.ts                   |  1 +
 .../sessions/process-session/instrument.mjs   |  8 +++
 .../sessions/process-session/scenario.mjs     |  3 +
 .../suites/sessions/process-session/test.ts   | 18 ++++++
 .../server-with-startup-error.mjs             | 20 +++++++
 .../server-without-process-session/test.ts    | 56 +++++++++++++++++++
 packages/core/src/client.ts                   | 11 ++++
 .../http/record-request-session.ts            |  4 ++
 .../node/src/integrations/processSession.ts   | 25 ++++++++-
 .../httpServerIntegration.test.ts             | 23 +++++++-
 .../test/integrations/processSession.test.ts  | 54 +++++++++++++++++-
 11 files changed, 218 insertions(+), 5 deletions(-)
 create mode 100644 dev-packages/node-integration-tests/suites/sessions/process-session/instrument.mjs
 create mode 100644 dev-packages/node-integration-tests/suites/sessions/process-session/scenario.mjs
 create mode 100644 dev-packages/node-integration-tests/suites/sessions/process-session/test.ts
 create mode 100644 dev-packages/node-integration-tests/suites/sessions/server-without-process-session/server-with-startup-error.mjs
 create mode 100644 dev-packages/node-integration-tests/suites/sessions/server-without-process-session/test.ts

diff --git a/dev-packages/bun-integration-tests/node-suites/excludes.ts b/dev-packages/bun-integration-tests/node-suites/excludes.ts
index 94f084f717d8..65edcd311712 100644
--- a/dev-packages/bun-integration-tests/node-suites/excludes.ts
+++ b/dev-packages/bun-integration-tests/node-suites/excludes.ts
@@ -166,6 +166,7 @@ const FETCH_INTEGRATION_DIFFERS = [
 // that sets `emit` back to the `emit` it had before its first request gets no spans after that.
 const HTTP_SERVER_OPTIONS_IGNORED = [
   'suites/sessions/exited-session-aggregate/test.ts',
+  'suites/sessions/server-without-process-session/test.ts',
   'suites/tracing/httpIntegration/test.ts',
 ];
 
diff --git a/dev-packages/node-integration-tests/suites/sessions/process-session/instrument.mjs b/dev-packages/node-integration-tests/suites/sessions/process-session/instrument.mjs
new file mode 100644
index 000000000000..9ffde125d498
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/sessions/process-session/instrument.mjs
@@ -0,0 +1,8 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  transport: loggingTransport,
+});
diff --git a/dev-packages/node-integration-tests/suites/sessions/process-session/scenario.mjs b/dev-packages/node-integration-tests/suites/sessions/process-session/scenario.mjs
new file mode 100644
index 000000000000..329cecf7fd16
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/sessions/process-session/scenario.mjs
@@ -0,0 +1,3 @@
+import * as Sentry from '@sentry/node';
+
+Sentry.captureException(new Error('Scenario error'));
diff --git a/dev-packages/node-integration-tests/suites/sessions/process-session/test.ts b/dev-packages/node-integration-tests/suites/sessions/process-session/test.ts
new file mode 100644
index 000000000000..a7e9260bd16c
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/sessions/process-session/test.ts
@@ -0,0 +1,18 @@
+import { afterAll, test } from 'vitest';
+import { join } from 'path';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('sends a process session for a process that does not serve requests', async () => {
+  await createRunner(__dirname, 'scenario.mjs')
+    .withInstrument(join(__dirname, 'instrument.mjs'))
+    .ignore('event')
+    .unignore('session')
+    .expect({ session: { init: true, status: 'ok', errors: 1 } })
+    .expect({ session: { init: false, status: 'exited', errors: 1 } })
+    .start()
+    .completed();
+});
diff --git a/dev-packages/node-integration-tests/suites/sessions/server-without-process-session/server-with-startup-error.mjs b/dev-packages/node-integration-tests/suites/sessions/server-without-process-session/server-with-startup-error.mjs
new file mode 100644
index 000000000000..0eed9d1fe8a5
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/sessions/server-without-process-session/server-with-startup-error.mjs
@@ -0,0 +1,20 @@
+import * as Sentry from '@sentry/node';
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import express from 'express';
+
+Sentry.captureException(new Error('Startup error'));
+// Event processing is async; make sure the error has updated the process session before the first request.
+await Sentry.flush();
+
+const app = express();
+
+app.get('/test/success', (_req, res) => {
+  res.send('Success!');
+});
+
+app.get('/test/error_handled', (_req, res) => {
+  Sentry.captureException(new Error('Request error'));
+  res.send('Handled!');
+});
+
+startExpressServerAndSendPortToRunner(app);
diff --git a/dev-packages/node-integration-tests/suites/sessions/server-without-process-session/test.ts b/dev-packages/node-integration-tests/suites/sessions/server-without-process-session/test.ts
new file mode 100644
index 000000000000..f22ea4c47ad5
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/sessions/server-without-process-session/test.ts
@@ -0,0 +1,56 @@
+import { afterAll, expect, test } from 'vitest';
+import { join } from 'path';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+import type { SessionAggregates } from '@sentry/core';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+function sumAggregates(agg: SessionAggregates): { exited: number; errored: number; crashed: number } {
+  return agg.aggregates.reduce(
+    (acc, b) => ({
+      exited: acc.exited + (b.exited ?? 0),
+      errored: acc.errored + (b.errored ?? 0),
+      crashed: acc.crashed + (b.crashed ?? 0),
+    }),
+    { exited: 0, errored: 0, crashed: 0 },
+  );
+}
+
+test('does not send a process session once requests are tracked as request sessions', async () => {
+  const runner = createRunner(__dirname, '..', 'server.mjs')
+    .withInstrument(join(__dirname, '..', 'instrument.mjs'))
+    .ignore('transaction', 'event')
+    .unignore('session', 'sessions')
+    .expect({
+      sessions: agg => {
+        expect(sumAggregates(agg)).toEqual({ exited: 1, errored: 1, crashed: 1 });
+      },
+    })
+    .start();
+
+  runner.makeRequest('get', '/test/success');
+  runner.makeRequest('get', '/test/error_handled');
+  runner.makeRequest('get', '/test/error_unhandled', { expectError: true });
+  await runner.completed();
+});
+
+test('counts an error before the first request in the process session, and later errors in the aggregate', async () => {
+  const runner = createRunner(__dirname, 'server-with-startup-error.mjs')
+    .withInstrument(join(__dirname, '..', 'instrument.mjs'))
+    .ignore('transaction', 'event')
+    .unignore('session', 'sessions')
+    .expect({ session: { init: true, status: 'ok', errors: 1 } })
+    .expect({ session: { init: false, status: 'exited', errors: 1 } })
+    .expect({
+      sessions: agg => {
+        expect(sumAggregates(agg)).toEqual({ exited: 1, errored: 1, crashed: 0 });
+      },
+    })
+    .start();
+
+  await runner.makeRequest('get', '/test/success');
+  await runner.makeRequest('get', '/test/error_handled');
+  await runner.completed();
+});
diff --git a/packages/core/src/client.ts b/packages/core/src/client.ts
index 29f24f0795c1..c61b3975d41b 100644
--- a/packages/core/src/client.ts
+++ b/packages/core/src/client.ts
@@ -900,6 +900,12 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
     callback: (breadcrumb: Breadcrumb, hint: XhrBreadcrumbHint | FetchBreadcrumbHint) => void,
   ): () => void;
 
+  /**
+   * A hook that is called when an incoming request starts being tracked as a request session.
+   * @returns {() => void} A function that, when executed, removes the registered callback.
+   */
+  public on(hook: 'startRequestSession', callback: () => void): () => void;
+
   /**
    * A hook that is called when the client is flushing
    * @returns {() => void} A function that, when executed, removes the registered callback.
@@ -1211,6 +1217,11 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
     hint: XhrBreadcrumbHint | FetchBreadcrumbHint,
   ): void;
 
+  /**
+   * Emit a hook event when an incoming request starts being tracked as a request session.
+   */
+  public emit(hook: 'startRequestSession'): void;
+
   /**
    * Emit a hook event for client flush
    */
diff --git a/packages/core/src/integrations/http/record-request-session.ts b/packages/core/src/integrations/http/record-request-session.ts
index cdef0538d3ee..4ab0eccb88dd 100644
--- a/packages/core/src/integrations/http/record-request-session.ts
+++ b/packages/core/src/integrations/http/record-request-session.ts
@@ -33,9 +33,13 @@ export function recordRequestSession(
     sessionFlushingDelayMS?: number;
   },
 ): void {
+  // Errors in this request are counted by the request session aggregate, so they must not also
+  // update a process session inherited from the parent isolation scope.
+  requestIsolationScope.setSession();
   requestIsolationScope.setSDKProcessingMetadata({
     requestSession: { status: 'ok' },
   });
+  client.emit('startRequestSession');
 
   response.once('close', () => {
     const requestSession = requestIsolationScope.getScopeData().sdkProcessingMetadata.requestSession;
diff --git a/packages/node/src/integrations/processSession.ts b/packages/node/src/integrations/processSession.ts
index d19948cbe6f9..4e9c23134c8b 100644
--- a/packages/node/src/integrations/processSession.ts
+++ b/packages/node/src/integrations/processSession.ts
@@ -1,15 +1,20 @@
-import { defineIntegration, endSession, getIsolationScope, startSession } from '@sentry/core';
+import { closeSession, defineIntegration, endSession, getIsolationScope, startSession } from '@sentry/core';
 
 const INTEGRATION_NAME = 'ProcessSession' as const;
 
 /**
  * Records a Session for the current process to track release health.
+ *
+ * Once the process starts serving requests that are tracked as request sessions, release health is
+ * reported through session aggregates instead, and the process session is discarded.
+ * This integration exists so that we capture some form of session health data even when the process is not serving requests.
  */
 export const processSessionIntegration = defineIntegration(() => {
   return {
     name: INTEGRATION_NAME,
-    setupOnce() {
+    setup(client) {
       startSession();
+      const processIsolationScope = getIsolationScope();
 
       // Emitted in the case of healthy sessions, error of `mechanism.handled: true` and unhandledrejections because
       // The 'beforeExit' event is not emitted for conditions causing explicit termination,
@@ -26,6 +31,22 @@ export const processSessionIntegration = defineIntegration(() => {
           endSession();
         }
       });
+
+      const unsubscribe = client.on('startRequestSession', () => {
+        unsubscribe();
+
+        const session = processIsolationScope.getSession();
+        if (!session) {
+          return;
+        }
+
+        // A session that was already sent upstream is closed so it does not linger as never-ended.
+        if (!session.init && session.status === 'ok') {
+          closeSession(session);
+          client.captureSession(session);
+        }
+        processIsolationScope.setSession();
+      });
     },
   };
 });
diff --git a/packages/node/test/integrations/httpServerIntegration.test.ts b/packages/node/test/integrations/httpServerIntegration.test.ts
index 0a677246773b..f6b27eb35888 100644
--- a/packages/node/test/integrations/httpServerIntegration.test.ts
+++ b/packages/node/test/integrations/httpServerIntegration.test.ts
@@ -1,5 +1,5 @@
 import type { Client } from '@sentry/core';
-import { createTransport, Scope, withScope } from '@sentry/core';
+import { createTransport, makeSession, Scope, withScope } from '@sentry/core';
 import { ServerRuntimeClient } from '@sentry/core/server';
 import { EventEmitter } from 'stream';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
@@ -125,6 +125,27 @@ describe('recordRequestSession()', () => {
       ],
     });
   });
+
+  it('removes a session inherited from the parent isolation scope', () => {
+    const client = createTestClient();
+    const requestIsolationScope = new Scope();
+    requestIsolationScope.setSession(makeSession());
+
+    recordRequestSession(client, { requestIsolationScope, response: new EventEmitter() });
+
+    expect(requestIsolationScope.getSession()).toBeUndefined();
+  });
+
+  it('emits the "startRequestSession" hook for every recorded request', () => {
+    const client = createTestClient();
+    const onStartRequestSession = vi.fn();
+    client.on('startRequestSession', onStartRequestSession);
+
+    simulateRequest(client, 'ok');
+    simulateRequest(client, 'ok');
+
+    expect(onStartRequestSession).toHaveBeenCalledTimes(2);
+  });
 });
 
 function simulateRequest(client: Client, status: 'ok' | 'errored' | 'crashed') {
diff --git a/packages/node/test/integrations/processSession.test.ts b/packages/node/test/integrations/processSession.test.ts
index 4d511035b8f9..69e8ce19dc68 100644
--- a/packages/node/test/integrations/processSession.test.ts
+++ b/packages/node/test/integrations/processSession.test.ts
@@ -1,4 +1,4 @@
-import { getIsolationScope, setCurrentClient } from '@sentry/core';
+import { getIsolationScope, makeSession, setCurrentClient } from '@sentry/core';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { processSessionIntegration } from '../../src/integrations/processSession';
 import { NodeClient } from '../../src/sdk/client';
@@ -24,7 +24,7 @@ describe('processSessionIntegration', () => {
       return process;
     }) as never);
 
-    processSessionIntegration().setupOnce!();
+    processSessionIntegration().setup!(client);
     processOn.mockRestore();
   });
 
@@ -62,6 +62,56 @@ describe('processSessionIntegration', () => {
     expect(sendSession).not.toHaveBeenCalled();
   });
 
+  describe('when requests start being tracked as request sessions', () => {
+    it('removes a session that was never sent, without sending it', () => {
+      client.emit('startRequestSession');
+
+      expect(getIsolationScope().getSession()).toBeUndefined();
+      expect(sendSession).not.toHaveBeenCalled();
+    });
+
+    it('closes and removes a session that was already sent', () => {
+      const session = getIsolationScope().getSession()!;
+      session.init = false;
+      session.errors = 1;
+
+      client.emit('startRequestSession');
+
+      expect(sendSession).toHaveBeenCalledTimes(1);
+      expect(sendSession).toHaveBeenCalledWith(expect.objectContaining({ status: 'exited', errors: 1 }));
+      expect(getIsolationScope().getSession()).toBeUndefined();
+    });
+
+    it('removes an already-crashed session without updating it', () => {
+      const session = getIsolationScope().getSession()!;
+      session.init = false;
+      session.status = 'crashed';
+
+      client.emit('startRequestSession');
+
+      expect(sendSession).not.toHaveBeenCalled();
+      expect(getIsolationScope().getSession()).toBeUndefined();
+    });
+
+    it('only reacts to the first request session', () => {
+      client.emit('startRequestSession');
+      const laterSession = makeSession();
+      getIsolationScope().setSession(laterSession);
+
+      client.emit('startRequestSession');
+
+      expect(getIsolationScope().getSession()).toBe(laterSession);
+    });
+
+    it('does not send a session on exit afterwards', () => {
+      client.emit('startRequestSession');
+
+      beforeExitHandler();
+
+      expect(sendSession).not.toHaveBeenCalled();
+    });
+  });
+
   it('does nothing when no session is on the scope', () => {
     getIsolationScope().setSession(undefined);
     sendSession.mockClear();

From 1350965696ce29e7ad4db94d2a3cdc3cd7e66ac4 Mon Sep 17 00:00:00 2001
From: Lukas Stracke <lukas.stracke@sentry.io>
Date: Mon, 12 Oct 2026 15:40:51 +0200
Subject: [PATCH 75/84] fix(core): Record span outcomes for spans dropped when
 building a transaction (#25048)

With the static trace lifecycle, building a transaction silently dropped
two kinds of child spans without a client outcome: children that hadn't
finished yet, and spans beyond the 1000 span cap. These are now recorded
as `invalid` (span lacks an end timestamp, so it fails validation) and
`buffer_overflow` (the transaction's fixed-size span buffer overflowed),
so dropped span counts show up in client reports.

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 packages/core/src/tracing/sentrySpan.ts       | 13 ++++
 .../tracing/deferSegmentSpanCapture.test.ts   | 33 +++++++++
 .../core/test/lib/tracing/sentrySpan.test.ts  | 71 +++++++++++++++++++
 3 files changed, 117 insertions(+)

diff --git a/packages/core/src/tracing/sentrySpan.ts b/packages/core/src/tracing/sentrySpan.ts
index 878cd9d86195..42d91f6057d6 100644
--- a/packages/core/src/tracing/sentrySpan.ts
+++ b/packages/core/src/tracing/sentrySpan.ts
@@ -456,18 +456,31 @@ export class SentrySpan implements Span {
     // TODO(standalone): drop the `isStandaloneSpan(descendant)` check once the static trace lifecycle is gone.
     options.onSpanCaptured?.(this);
     const spans: SpanJSON[] = [];
+    let droppedUnfinishedSpanCount = 0;
     for (const descendant of getSpanDescendants(this)) {
       if (descendant === this || isStandaloneSpan(descendant) || options.isSpanAlreadyCaptured?.(descendant)) {
         continue;
       }
       const spanJSON = spanToStaticSpanJSON(descendant);
       if (!isFullFinishedSpan(spanJSON)) {
+        // A strategy tracking captured spans re-emits this child as an orphan transaction once it ends.
+        if (!options.onSpanCaptured) {
+          droppedUnfinishedSpanCount++;
+        }
         continue;
       }
       options.onSpanCaptured?.(descendant);
       spans.push(spanJSON);
     }
 
+    const client = capturedSpanScope?.getClient() || getClient();
+    if (droppedUnfinishedSpanCount) {
+      client?.recordDroppedEvent('invalid', 'span', droppedUnfinishedSpanCount);
+    }
+    if (spans.length > MAX_SPAN_COUNT) {
+      client?.recordDroppedEvent('buffer_overflow', 'span', spans.length - MAX_SPAN_COUNT);
+    }
+
     const source = this._attributes[SENTRY_SEGMENT_NAME_SOURCE];
 
     // remove internal root span attributes we don't need to send.
diff --git a/packages/core/test/lib/tracing/deferSegmentSpanCapture.test.ts b/packages/core/test/lib/tracing/deferSegmentSpanCapture.test.ts
index 445e1294657d..9a4409b9c8f7 100644
--- a/packages/core/test/lib/tracing/deferSegmentSpanCapture.test.ts
+++ b/packages/core/test/lib/tracing/deferSegmentSpanCapture.test.ts
@@ -100,6 +100,39 @@ describe('deferred segment-span capture', () => {
     expect(transactions[1]!.contexts?.trace?.data?.['sentry.parent_span_already_sent']).toBe(true);
   });
 
+  it('does not record a span outcome for a child that is later sent as an orphan transaction', () => {
+    const recordDroppedEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+
+    const root = startInactiveSpan({ name: 'root' });
+    const child = withActiveSpan(root, () => startInactiveSpan({ name: 'child' }));
+
+    root.end();
+    vi.advanceTimersByTime(100);
+    child.end();
+    vi.advanceTimersByTime(100);
+
+    expect(transactions).toHaveLength(2);
+    expect(recordDroppedEventSpy).not.toHaveBeenCalledWith('invalid', 'span', expect.anything());
+  });
+
+  it('records a `buffer_overflow` span outcome for spans beyond the 1000 span limit once', () => {
+    const recordDroppedEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+
+    const root = startInactiveSpan({ name: 'root' });
+    withActiveSpan(root, () => {
+      for (let i = 0; i < 1003; i++) {
+        startInactiveSpan({ name: `child-${i}` }).end();
+      }
+    });
+    root.end();
+    vi.advanceTimersByTime(100);
+
+    expect(transactions).toHaveLength(1);
+    expect(transactions[0]!.spans).toHaveLength(1000);
+    expect(recordDroppedEventSpy).toHaveBeenCalledWith('buffer_overflow', 'span', 3);
+    expect(recordDroppedEventSpy).not.toHaveBeenCalledWith('invalid', 'span', expect.anything());
+  });
+
   it('drains pending captures synchronously on flush', () => {
     const root = startInactiveSpan({ name: 'root' });
     root.end();
diff --git a/packages/core/test/lib/tracing/sentrySpan.test.ts b/packages/core/test/lib/tracing/sentrySpan.test.ts
index 15ebe588d4c1..ad49179d7ce2 100644
--- a/packages/core/test/lib/tracing/sentrySpan.test.ts
+++ b/packages/core/test/lib/tracing/sentrySpan.test.ts
@@ -456,6 +456,77 @@ describe('SentrySpan', () => {
         type: 'transaction',
       });
     });
+
+    test('records an `invalid` span outcome for unfinished child spans', () => {
+      const client = new TestClient(getDefaultTestClientOptions({ tracesSampleRate: 1 }));
+      setCurrentClient(client);
+      const recordDroppedEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+      const captureEventSpy = vi.spyOn(getCurrentScope(), 'captureEvent').mockImplementation(() => 'testId');
+
+      const root = startInactiveSpan({ name: 'root' });
+      withActiveSpan(root, () => {
+        startInactiveSpan({ name: 'unfinished-1' });
+        startInactiveSpan({ name: 'unfinished-2' });
+        startInactiveSpan({ name: 'finished' }).end();
+      });
+      root.end();
+
+      expect(captureEventSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ spans: [expect.objectContaining({ description: 'finished' })] }),
+      );
+      expect(recordDroppedEventSpy).toHaveBeenCalledTimes(1);
+      expect(recordDroppedEventSpy).toHaveBeenCalledWith('invalid', 'span', 2);
+    });
+
+    test('records a `buffer_overflow` span outcome for spans beyond the 1000 span limit', () => {
+      const client = new TestClient(getDefaultTestClientOptions({ tracesSampleRate: 1 }));
+      setCurrentClient(client);
+      const recordDroppedEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+      const captureEventSpy = vi.spyOn(getCurrentScope(), 'captureEvent').mockImplementation(() => 'testId');
+
+      const root = startInactiveSpan({ name: 'root' });
+      withActiveSpan(root, () => {
+        for (let i = 0; i < 1005; i++) {
+          startInactiveSpan({ name: `child-${i}` }).end();
+        }
+      });
+      root.end();
+
+      expect(captureEventSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ spans: expect.objectContaining({ length: 1000 }) }),
+      );
+      expect(recordDroppedEventSpy).toHaveBeenCalledTimes(1);
+      expect(recordDroppedEventSpy).toHaveBeenCalledWith('buffer_overflow', 'span', 5);
+    });
+
+    test('does not record span outcomes for an unsampled root span', () => {
+      const client = new TestClient(getDefaultTestClientOptions({ tracesSampleRate: 1 }));
+      setCurrentClient(client);
+      const recordDroppedEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+
+      const root = new SentrySpan({ name: 'root', sampled: false });
+      withActiveSpan(root, () => {
+        startInactiveSpan({ name: 'unfinished' });
+      });
+      root.end();
+
+      expect(recordDroppedEventSpy).not.toHaveBeenCalledWith('invalid', 'span', expect.anything());
+    });
+
+    test('does not record span outcomes for unfinished standalone child spans', () => {
+      const client = new TestClient(getDefaultTestClientOptions({ tracesSampleRate: 1 }));
+      setCurrentClient(client);
+      const recordDroppedEventSpy = vi.spyOn(client, 'recordDroppedEvent');
+      vi.spyOn(getCurrentScope(), 'captureEvent').mockImplementation(() => 'testId');
+
+      const root = startInactiveSpan({ name: 'root' });
+      withActiveSpan(root, () => {
+        startInactiveSpan({ name: 'inp', experimental: { standalone: true } });
+      });
+      root.end();
+
+      expect(recordDroppedEventSpy).not.toHaveBeenCalled();
+    });
   });
 
   describe('setAttribute', () => {

From 17a8a15c470581782f96568872fe565dc85edb85 Mon Sep 17 00:00:00 2001
From: Andrei <168741329+andreiborza@users.noreply.github.com>
Date: Mon, 12 Oct 2026 15:43:12 +0200
Subject: [PATCH 76/84] feat(server-utils): Record Vercel AI
 experimental_decide calls as gen_ai.decide spans (#25274)

## What

Vercel AI `experimental_decide` calls now create `decide <model>` spans
with op `gen_ai.decide`, instead of `gen_ai.evaluate`.

## Why

`gen_ai.evaluate` is deprecated in favor of `gen_ai.decide`
(getsentry/sentry-conventions#696), to match the Vercel AI rename to
`experimental_decide`.

Closes: #25251

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../node-eve/agent/tools/classify_ticket.ts   | 12 ++--
 .../test-applications/node-eve/package.json   |  1 +
 .../node-eve/tests/eve.test.ts                | 49 ++++++++++-------
 ...mjs => instrument-decide-no-recording.mjs} |  0
 ...ent-evaluate.mjs => instrument-decide.mjs} |  0
 ...nario-evaluate.mjs => scenario-decide.mjs} | 10 ++--
 .../suites/tracing/vercelai/v6_v7/test.ts     | 55 +++++++++----------
 .../vercel-ai/vercel-ai-dc-subscriber.ts      |  9 ++-
 .../{evaluate.test.ts => decide.test.ts}      |  9 +--
 9 files changed, 77 insertions(+), 68 deletions(-)
 rename dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/{instrument-evaluate-no-recording.mjs => instrument-decide-no-recording.mjs} (100%)
 rename dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/{instrument-evaluate.mjs => instrument-decide.mjs} (100%)
 rename dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/{scenario-evaluate.mjs => scenario-decide.mjs} (86%)
 rename packages/server-utils/test/integrations/vercel-ai/{evaluate.test.ts => decide.test.ts} (88%)

diff --git a/dev-packages/e2e-tests/test-applications/node-eve/agent/tools/classify_ticket.ts b/dev-packages/e2e-tests/test-applications/node-eve/agent/tools/classify_ticket.ts
index 9dd65a11fd90..9dbd6c41450e 100644
--- a/dev-packages/e2e-tests/test-applications/node-eve/agent/tools/classify_ticket.ts
+++ b/dev-packages/e2e-tests/test-applications/node-eve/agent/tools/classify_ticket.ts
@@ -1,14 +1,14 @@
-import { experimental_evaluate } from 'ai';
-import { Experimental_EvaluationMockModelV4 } from 'ai/test';
+import { experimental_decide } from 'ai';
+import { Experimental_DecisionMockModelV4 } from 'ai/test';
 import { defineTool } from 'eve/tools';
 import { z } from 'zod';
 
-// Runs a TypeSafe Jev evaluation so the e2e test can assert its `gen_ai.evaluate` span. The model is
+// Runs a TypeSafe Jev evaluation so the e2e test can assert its `gen_ai.decide` span. The model is
 // mocked because the e2e environment has no TypeSafe credentials.
-const jev = new Experimental_EvaluationMockModelV4({
+const jev = new Experimental_DecisionMockModelV4({
   provider: 'gateway',
   modelId: 'typesafe-ai/jev',
-  doEvaluate: async () => ({
+  doDecide: async () => ({
     answers: {
       wantsRefund: { type: 'boolean', probability: 0.99 },
       department: {
@@ -26,7 +26,7 @@ export default defineTool({
   description: 'Classify a support ticket. Call this when asked to classify a ticket.',
   inputSchema: z.object({ ticket: z.string().min(1) }),
   async execute({ ticket }) {
-    const { answers } = await experimental_evaluate({
+    const { answers } = await experimental_decide({
       model: jev,
       state: ticket,
       questions: {
diff --git a/dev-packages/e2e-tests/test-applications/node-eve/package.json b/dev-packages/e2e-tests/test-applications/node-eve/package.json
index f51d32a86a5f..a82ea0bedbbc 100644
--- a/dev-packages/e2e-tests/test-applications/node-eve/package.json
+++ b/dev-packages/e2e-tests/test-applications/node-eve/package.json
@@ -32,6 +32,7 @@
   "devDependencies": {
     "@playwright/test": "~1.56.0",
     "@sentry-internal/test-utils": "link:../../../test-utils",
+    "@sentry/conventions": "0.27.0",
     "@sentry/core": "file:../../packed/sentry-core-packed.tgz",
     "@types/node": "24.x",
     "typescript": "~5.9.0"
diff --git a/dev-packages/e2e-tests/test-applications/node-eve/tests/eve.test.ts b/dev-packages/e2e-tests/test-applications/node-eve/tests/eve.test.ts
index 04ad1e5151f4..de45eacd39d2 100644
--- a/dev-packages/e2e-tests/test-applications/node-eve/tests/eve.test.ts
+++ b/dev-packages/e2e-tests/test-applications/node-eve/tests/eve.test.ts
@@ -1,4 +1,15 @@
 import { expect, test } from '@playwright/test';
+import {
+  GEN_AI_CONVERSATION_ID,
+  GEN_AI_INPUT_MESSAGES,
+  GEN_AI_OPERATION_NAME,
+  GEN_AI_REQUEST_MODEL,
+  GEN_AI_TOOL_NAME,
+  GEN_AI_USAGE_INPUT_TOKENS,
+  GEN_AI_USAGE_OUTPUT_TOKENS,
+  SENTRY_ORIGIN,
+} from '@sentry/conventions/attributes';
+import { GEN_AI_DECIDE, GEN_AI_EXECUTE_TOOL } from '@sentry/conventions/op';
 import { collectStreamedSpans, getSpanOp, waitForError } from '@sentry-internal/test-utils';
 import { runAgentTurn } from './utils';
 
@@ -135,9 +146,9 @@ test('captures errors thrown inside an eve tool', async ({ baseURL }) => {
   });
 });
 
-test('captures a gen_ai.evaluate span for a Jev call inside an eve tool', async ({ baseURL }) => {
+test('captures a gen_ai.decide span for a Jev call inside an eve tool', async ({ baseURL }) => {
   const traceSpansPromise = collectStreamedSpans(APP, spansOfTrace =>
-    ['gen_ai.execute_tool', 'gen_ai.evaluate'].every(op => spansOfTrace.some(span => getSpanOp(span) === op)),
+    [GEN_AI_EXECUTE_TOOL, GEN_AI_DECIDE].every(op => spansOfTrace.some(span => getSpanOp(span) === op)),
   );
 
   const sessionId = await runAgentTurn(
@@ -147,21 +158,21 @@ test('captures a gen_ai.evaluate span for a Jev call inside an eve tool', async
 
   const traceSpans = await traceSpansPromise;
 
-  const executeTool = traceSpans.find(span => getSpanOp(span) === 'gen_ai.execute_tool');
-  const evaluate = traceSpans.find(span => getSpanOp(span) === 'gen_ai.evaluate');
-
-  expect(executeTool?.attributes?.['gen_ai.tool.name']?.value).toBe('classify_ticket');
-
-  expect(evaluate?.name).toBe('evaluate typesafe-ai/jev');
-  expect(evaluate?.status).toBe('ok');
-  expect(evaluate?.attributes?.['sentry.origin']?.value).toBe('auto.vercelai.channel');
-  expect(evaluate?.attributes?.['gen_ai.operation.name']?.value).toBe('evaluate');
-  expect(evaluate?.attributes?.['gen_ai.request.model']?.value).toBe('typesafe-ai/jev');
-  expect(evaluate?.attributes?.['gen_ai.usage.input_tokens']?.value).toBe(275);
-  expect(evaluate?.attributes?.['gen_ai.usage.output_tokens']?.value).toBe(20);
-  expect(evaluate?.attributes?.['gen_ai.input.messages']?.value).toContain('refund for last month');
-  expect(evaluate?.attributes?.['gen_ai.conversation.id']?.value).toBe(sessionId);
-
-  expect(evaluate?.trace_id).toBe(executeTool?.trace_id);
-  expect(evaluate?.parent_span_id).toBe(executeTool?.span_id);
+  const executeTool = traceSpans.find(span => getSpanOp(span) === GEN_AI_EXECUTE_TOOL);
+  const decide = traceSpans.find(span => getSpanOp(span) === GEN_AI_DECIDE);
+
+  expect(executeTool?.attributes?.[GEN_AI_TOOL_NAME]?.value).toBe('classify_ticket');
+
+  expect(decide?.name).toBe('decide typesafe-ai/jev');
+  expect(decide?.status).toBe('ok');
+  expect(decide?.attributes?.[SENTRY_ORIGIN]?.value).toBe('auto.vercelai.channel');
+  expect(decide?.attributes?.[GEN_AI_OPERATION_NAME]?.value).toBe('decide');
+  expect(decide?.attributes?.[GEN_AI_REQUEST_MODEL]?.value).toBe('typesafe-ai/jev');
+  expect(decide?.attributes?.[GEN_AI_USAGE_INPUT_TOKENS]?.value).toBe(275);
+  expect(decide?.attributes?.[GEN_AI_USAGE_OUTPUT_TOKENS]?.value).toBe(20);
+  expect(decide?.attributes?.[GEN_AI_INPUT_MESSAGES]?.value).toContain('refund for last month');
+  expect(decide?.attributes?.[GEN_AI_CONVERSATION_ID]?.value).toBe(sessionId);
+
+  expect(decide?.trace_id).toBe(executeTool?.trace_id);
+  expect(decide?.parent_span_id).toBe(executeTool?.span_id);
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/instrument-evaluate-no-recording.mjs b/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/instrument-decide-no-recording.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/instrument-evaluate-no-recording.mjs
rename to dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/instrument-decide-no-recording.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/instrument-evaluate.mjs b/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/instrument-decide.mjs
similarity index 100%
rename from dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/instrument-evaluate.mjs
rename to dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/instrument-decide.mjs
diff --git a/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/scenario-evaluate.mjs b/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/scenario-decide.mjs
similarity index 86%
rename from dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/scenario-evaluate.mjs
rename to dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/scenario-decide.mjs
index 42fc5ead26c7..84046b90160d 100644
--- a/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/scenario-evaluate.mjs
+++ b/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/scenario-decide.mjs
@@ -1,14 +1,14 @@
 import * as Sentry from '@sentry/node';
-import { experimental_evaluate } from 'ai';
-import { Experimental_EvaluationMockModelV4 } from 'ai/test';
+import { experimental_decide } from 'ai';
+import { Experimental_DecisionMockModelV4 } from 'ai/test';
 
 async function run() {
   await Sentry.startSpan({ op: 'function', name: 'main' }, async () => {
-    await experimental_evaluate({
-      model: new Experimental_EvaluationMockModelV4({
+    await experimental_decide({
+      model: new Experimental_DecisionMockModelV4({
         provider: 'gateway',
         modelId: 'typesafe-ai/jev',
-        doEvaluate: async () => ({
+        doDecide: async () => ({
           answers: {
             authIssue: { type: 'boolean', probability: 0.97 },
             department: {
diff --git a/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/test.ts b/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/test.ts
index 893cea265ebb..077d96e0d9bb 100644
--- a/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/vercelai/v6_v7/test.ts
@@ -26,6 +26,7 @@ import {
   SENTRY_OP,
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
+import { GEN_AI_DECIDE } from '@sentry/conventions/op';
 import { GEN_AI_TOOL_CALL_ID_ATTRIBUTE } from '../../../../../../packages/server-utils/src/ai/core/gen-ai-attributes';
 import { cleanupChildProcesses, createEsmAndCjsTests, createEsmTests } from '../../../../utils/runner';
 
@@ -1275,34 +1276,32 @@ describe.each(matrix)('Vercel AI integration (version %s)', (version, vercelAiVe
   );
 });
 
-describe('Vercel AI integration experimental_evaluate', () => {
+describe('Vercel AI integration experimental_decide', () => {
   afterAll(() => {
     cleanupChildProcesses();
   });
 
   createEsmTests(
     __dirname,
-    'scenario-evaluate.mjs',
-    'instrument-evaluate.mjs',
+    'scenario-decide.mjs',
+    'instrument-decide.mjs',
     (createRunner, test) => {
-      test('creates an evaluate span', async () => {
+      test('creates a decide span', async () => {
         await createRunner()
           .expect({
             span: container => {
-              const evaluateSpan = container.items.find(
-                span => span.attributes[SENTRY_OP]?.value === 'gen_ai.evaluate',
-              )!;
-              expect(evaluateSpan.name).toBe('evaluate typesafe-ai/jev');
-              expect(evaluateSpan.status).toBe('ok');
-              expect(evaluateSpan.attributes[SENTRY_ORIGIN]?.value).toBe('auto.vercelai.channel');
-              expect(evaluateSpan.attributes[GEN_AI_OPERATION_NAME]?.value).toBe('evaluate');
-              expect(evaluateSpan.attributes[GEN_AI_PROVIDER_NAME]?.value).toBe('gateway');
-              expect(evaluateSpan.attributes[GEN_AI_REQUEST_MODEL]?.value).toBe('typesafe-ai/jev');
-              expect(evaluateSpan.attributes[GEN_AI_RESPONSE_MODEL]?.value).toBe('typesafe-ai/jev');
-              expect(evaluateSpan.attributes[GEN_AI_USAGE_INPUT_TOKENS]?.value).toBe(275);
-              expect(evaluateSpan.attributes[GEN_AI_USAGE_OUTPUT_TOKENS]?.value).toBe(20);
-              expect(evaluateSpan.attributes[GEN_AI_USAGE_TOTAL_TOKENS]?.value).toBe(295);
-              expect(JSON.parse(evaluateSpan.attributes[GEN_AI_INPUT_MESSAGES]?.value as string)).toEqual([
+              const decideSpan = container.items.find(span => span.attributes[SENTRY_OP]?.value === GEN_AI_DECIDE)!;
+              expect(decideSpan.name).toBe('decide typesafe-ai/jev');
+              expect(decideSpan.status).toBe('ok');
+              expect(decideSpan.attributes[SENTRY_ORIGIN]?.value).toBe('auto.vercelai.channel');
+              expect(decideSpan.attributes[GEN_AI_OPERATION_NAME]?.value).toBe('decide');
+              expect(decideSpan.attributes[GEN_AI_PROVIDER_NAME]?.value).toBe('gateway');
+              expect(decideSpan.attributes[GEN_AI_REQUEST_MODEL]?.value).toBe('typesafe-ai/jev');
+              expect(decideSpan.attributes[GEN_AI_RESPONSE_MODEL]?.value).toBe('typesafe-ai/jev');
+              expect(decideSpan.attributes[GEN_AI_USAGE_INPUT_TOKENS]?.value).toBe(275);
+              expect(decideSpan.attributes[GEN_AI_USAGE_OUTPUT_TOKENS]?.value).toBe(20);
+              expect(decideSpan.attributes[GEN_AI_USAGE_TOTAL_TOKENS]?.value).toBe(295);
+              expect(JSON.parse(decideSpan.attributes[GEN_AI_INPUT_MESSAGES]?.value as string)).toEqual([
                 {
                   type: 'evaluation',
                   state: 'I cannot log in, and I also want a refund for last month.',
@@ -1322,7 +1321,7 @@ describe('Vercel AI integration experimental_evaluate', () => {
                   },
                 },
               ]);
-              expect(JSON.parse(evaluateSpan.attributes[GEN_AI_OUTPUT_MESSAGES]?.value as string)).toEqual([
+              expect(JSON.parse(decideSpan.attributes[GEN_AI_OUTPUT_MESSAGES]?.value as string)).toEqual([
                 {
                   type: 'evaluation',
                   answers: {
@@ -1346,28 +1345,26 @@ describe('Vercel AI integration experimental_evaluate', () => {
     },
     {
       additionalDependencies: {
-        ai: '^7.0.111',
+        ai: '^7.0.128',
       },
     },
   );
 
   createEsmTests(
     __dirname,
-    'scenario-evaluate.mjs',
-    'instrument-evaluate-no-recording.mjs',
+    'scenario-decide.mjs',
+    'instrument-decide-no-recording.mjs',
     (createRunner, test) => {
       test('does not record inputs or outputs when recording is off', async () => {
         await createRunner()
           .expect({
             span: container => {
-              const evaluateSpan = container.items.find(
-                span => span.attributes[SENTRY_OP]?.value === 'gen_ai.evaluate',
-              )!;
-              expect(evaluateSpan.attributes[GEN_AI_INPUT_MESSAGES]).toBeUndefined();
-              expect(evaluateSpan.attributes[GEN_AI_OUTPUT_MESSAGES]).toBeUndefined();
+              const decideSpan = container.items.find(span => span.attributes[SENTRY_OP]?.value === GEN_AI_DECIDE)!;
+              expect(decideSpan.attributes[GEN_AI_INPUT_MESSAGES]).toBeUndefined();
+              expect(decideSpan.attributes[GEN_AI_OUTPUT_MESSAGES]).toBeUndefined();
               // State, questions and answers must not come back through another attribute. Only the attributes
               // are checked (timestamps could match a number), and `probabilities` only occurs in answers.
-              expect(JSON.stringify(evaluateSpan.attributes)).not.toMatch(
+              expect(JSON.stringify(decideSpan.attributes)).not.toMatch(
                 /cannot log in|Charges and refunds|probabilities/,
               );
             },
@@ -1378,7 +1375,7 @@ describe('Vercel AI integration experimental_evaluate', () => {
     },
     {
       additionalDependencies: {
-        ai: '^7.0.111',
+        ai: '^7.0.128',
       },
     },
   );
diff --git a/packages/server-utils/src/integrations/vercel-ai/vercel-ai-dc-subscriber.ts b/packages/server-utils/src/integrations/vercel-ai/vercel-ai-dc-subscriber.ts
index f28a718b88af..fe102c833e88 100644
--- a/packages/server-utils/src/integrations/vercel-ai/vercel-ai-dc-subscriber.ts
+++ b/packages/server-utils/src/integrations/vercel-ai/vercel-ai-dc-subscriber.ts
@@ -28,8 +28,8 @@ import {
   SENTRY_ORIGIN,
 } from '@sentry/conventions/attributes';
 import {
+  GEN_AI_DECIDE,
   GEN_AI_EMBEDDINGS,
-  GEN_AI_EVALUATE,
   GEN_AI_EXECUTE_TOOL,
   GEN_AI_GENERATE_CONTENT,
   GEN_AI_INVOKE_AGENT,
@@ -71,8 +71,7 @@ const ORIGIN = 'auto.vercelai.channel';
 const GEN_AI_OPERATION_SPAN_OPS = {
   embeddings: GEN_AI_EMBEDDINGS,
   rerank: GEN_AI_RERANK,
-  // oxlint-disable-next-line typescript/no-deprecated -- the rename to `gen_ai.decide` comes in a follow-up
-  evaluate: GEN_AI_EVALUATE,
+  decide: GEN_AI_DECIDE,
   invoke_agent: GEN_AI_INVOKE_AGENT,
   execute_tool: GEN_AI_EXECUTE_TOOL,
   // The model-call op matches the Vercel AI OTel integration (`gen_ai.generate_content`) rather than
@@ -488,7 +487,7 @@ export function createSpanFromMessage(
     // `ai` 7.0.128 renamed `experimental_evaluate` to `experimental_decide`; older 7.x still publishes the old name.
     case 'experimental_evaluate':
     case 'experimental_decide':
-      return startGenAiSpan('evaluate', modelId, {
+      return startGenAiSpan('decide', modelId, {
         ...baseAttributes,
         ...(recordInputs
           ? {
@@ -703,7 +702,7 @@ function getOutputMessages(
 
 /**
  * The AI SDK TypeSafe provider moves each answer's `confidence` out of the answers into
- * `providerMetadata.typesafe.confidence` (keyed by question id). Put it back so evaluate answers keep it.
+ * `providerMetadata.typesafe.confidence` (keyed by question id). Put it back so decide answers keep it.
  */
 function withProviderConfidence(result: Record<string, unknown>): unknown {
   const { answers, providerMetadata } = result;
diff --git a/packages/server-utils/test/integrations/vercel-ai/evaluate.test.ts b/packages/server-utils/test/integrations/vercel-ai/decide.test.ts
similarity index 88%
rename from packages/server-utils/test/integrations/vercel-ai/evaluate.test.ts
rename to packages/server-utils/test/integrations/vercel-ai/decide.test.ts
index 0101b19cf69b..3037a264f092 100644
--- a/packages/server-utils/test/integrations/vercel-ai/evaluate.test.ts
+++ b/packages/server-utils/test/integrations/vercel-ai/decide.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { GEN_AI_DECIDE } from '@sentry/conventions/op';
 import { getMainCarrier, setCurrentClient, spanToStaticSpanJSON } from '@sentry/core';
 import type { Span } from '@sentry/core';
 import { createSpanFromMessage, enrichSpanOnEnd } from '../../../src/integrations/vercel-ai/vercel-ai-dc-subscriber';
@@ -6,7 +7,7 @@ import { getDefaultTestClientOptions, TestClient } from '../../mocks/client';
 
 type Message = Parameters<typeof createSpanFromMessage>[0];
 
-describe('Vercel AI evaluate spans', () => {
+describe('Vercel AI decide spans', () => {
   let endedSpans: Span[];
 
   beforeEach(() => {
@@ -28,7 +29,7 @@ describe('Vercel AI evaluate spans', () => {
   });
 
   // `ai` 7.0.128 renamed the channel event from `experimental_evaluate` to `experimental_decide`.
-  it.each(['experimental_evaluate', 'experimental_decide'] as const)('creates an evaluate span for `%s`', type => {
+  it.each(['experimental_evaluate', 'experimental_decide'] as const)('creates a decide span for `%s`', type => {
     const message = {
       type,
       event: {
@@ -48,8 +49,8 @@ describe('Vercel AI evaluate spans', () => {
     span.end();
 
     const json = spanToStaticSpanJSON(endedSpans[0]!);
-    expect(json.description).toBe('evaluate typesafe-ai/jev');
-    expect(json.op).toBe('gen_ai.evaluate');
+    expect(json.description).toBe('decide typesafe-ai/jev');
+    expect(json.op).toBe(GEN_AI_DECIDE);
     expect(JSON.parse(json.data?.['gen_ai.output.messages'] as string)).toEqual([
       { type: 'evaluation', answers: { wantsRefund: { type: 'boolean', probability: 0.99 } } },
     ]);

From 9f7cbad3bb6129f446e3b1ecfa414395d8364b12 Mon Sep 17 00:00:00 2001
From: Andrei <168741329+andreiborza@users.noreply.github.com>
Date: Mon, 12 Oct 2026 15:48:58 +0200
Subject: [PATCH 77/84] feat(server-utils): Map Mastra classifier evaluations
 to gen_ai.decide spans (#25281)

## What

Mastra classifier evaluations now create `decide <model>` spans with op
`gen_ai.decide`, instead of `gen_ai.evaluate`.

## Why

`gen_ai.evaluate` is deprecated in favor of `gen_ai.decide`
(getsentry/sentry-conventions#696), to match the Vercel AI rename to
`experimental_decide`.

Closes: #25252

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../node-mastra/tests/classifier.test.ts      | 30 ++++++------
 .../suites/tracing/mastra/test.ts             | 46 +++++++++----------
 .../server-utils/src/ai/mastra/constants.ts   |  5 +-
 .../ai/lib/tracing/mastra-exporter.test.ts    | 10 ++--
 4 files changed, 45 insertions(+), 46 deletions(-)

diff --git a/dev-packages/e2e-tests/test-applications/node-mastra/tests/classifier.test.ts b/dev-packages/e2e-tests/test-applications/node-mastra/tests/classifier.test.ts
index 6eee9bb68359..b5e37fdf1856 100644
--- a/dev-packages/e2e-tests/test-applications/node-mastra/tests/classifier.test.ts
+++ b/dev-packages/e2e-tests/test-applications/node-mastra/tests/classifier.test.ts
@@ -9,20 +9,20 @@ import {
   SENTRY_ORIGIN,
   URL_FULL,
 } from '@sentry/conventions/attributes';
-import { GEN_AI_EVALUATE, HTTP_SERVER } from '@sentry/conventions/op';
+import { GEN_AI_DECIDE, HTTP_SERVER } from '@sentry/conventions/op';
 import { collectStreamedSpans, getSpanOp, SerializedStreamedSpan } from '@sentry-internal/test-utils';
 
 const APP = 'node-mastra';
 const TICKET = 'My checkout page shows a blank screen after I click Pay.';
 
-const isEvaluateSpan = (span: SerializedStreamedSpan): boolean => getSpanOp(span) === GEN_AI_EVALUATE;
+const isDecideSpan = (span: SerializedStreamedSpan): boolean => getSpanOp(span) === GEN_AI_DECIDE;
 const isClassifyServerSpan = (span: SerializedStreamedSpan): boolean =>
   getSpanOp(span) === HTTP_SERVER && String(span.attributes?.[URL_FULL]?.value ?? '').includes('/classify');
 
-test('captures a Mastra classifier (Jev) evaluation as a gen_ai.evaluate span', async ({ baseURL }) => {
+test('captures a Mastra classifier (Jev) evaluation as a gen_ai.decide span', async ({ baseURL }) => {
   const spansPromise = collectStreamedSpans(
     APP,
-    spansOfTrace => spansOfTrace.some(isEvaluateSpan) && spansOfTrace.some(isClassifyServerSpan),
+    spansOfTrace => spansOfTrace.some(isDecideSpan) && spansOfTrace.some(isClassifyServerSpan),
   );
 
   const res = await fetch(`${baseURL}/classify`, {
@@ -38,18 +38,18 @@ test('captures a Mastra classifier (Jev) evaluation as a gen_ai.evaluate span',
 
   // Only the Mastra exporter reports the evaluation: `Classifier` calls `doEvaluate()` directly, so the
   // Vercel AI integration does not see it.
-  const evaluateSpans = spans.filter(isEvaluateSpan);
-  expect(evaluateSpans.map(span => ({ name: span.name, origin: span.attributes?.[SENTRY_ORIGIN]?.value }))).toEqual([
-    { name: 'evaluate typesafe/jev-1.13', origin: 'auto.ai.mastra' },
+  const decideSpans = spans.filter(isDecideSpan);
+  expect(decideSpans.map(span => ({ name: span.name, origin: span.attributes?.[SENTRY_ORIGIN]?.value }))).toEqual([
+    { name: 'decide typesafe/jev-1.13', origin: 'auto.ai.mastra' },
   ]);
 
-  const evaluateSpan = evaluateSpans[0]!;
-  expect(evaluateSpan.parent_span_id).toBe(serverSpan.span_id);
-  expect(evaluateSpan.attributes?.[GEN_AI_OPERATION_NAME]?.value).toBe('evaluate');
-  expect(evaluateSpan.attributes?.[GEN_AI_REQUEST_MODEL]?.value).toBe('typesafe/jev-1.13');
-  expect(evaluateSpan.attributes?.[GEN_AI_PROVIDER_NAME]?.value).toBe('openrouter');
-  expect(evaluateSpan.attributes?.[GEN_AI_USAGE_INPUT_TOKENS]?.value).toBeGreaterThan(0);
-  expect(JSON.parse(String(evaluateSpan.attributes?.[GEN_AI_INPUT_MESSAGES]?.value))).toEqual([
+  const decideSpan = decideSpans[0]!;
+  expect(decideSpan.parent_span_id).toBe(serverSpan.span_id);
+  expect(decideSpan.attributes?.[GEN_AI_OPERATION_NAME]?.value).toBe('decide');
+  expect(decideSpan.attributes?.[GEN_AI_REQUEST_MODEL]?.value).toBe('typesafe/jev-1.13');
+  expect(decideSpan.attributes?.[GEN_AI_PROVIDER_NAME]?.value).toBe('openrouter');
+  expect(decideSpan.attributes?.[GEN_AI_USAGE_INPUT_TOKENS]?.value).toBeGreaterThan(0);
+  expect(JSON.parse(String(decideSpan.attributes?.[GEN_AI_INPUT_MESSAGES]?.value))).toEqual([
     {
       type: 'evaluation',
       state: { ticket: TICKET },
@@ -59,7 +59,7 @@ test('captures a Mastra classifier (Jev) evaluation as a gen_ai.evaluate span',
     },
   ]);
   // The probability comes from the live model, so only its shape is stable.
-  expect(JSON.parse(String(evaluateSpan.attributes?.[GEN_AI_OUTPUT_MESSAGES]?.value))).toEqual([
+  expect(JSON.parse(String(decideSpan.attributes?.[GEN_AI_OUTPUT_MESSAGES]?.value))).toEqual([
     { type: 'evaluation', answers: { is_bug: { type: 'boolean', probability: expect.any(Number) } } },
   ]);
 });
diff --git a/dev-packages/node-integration-tests/suites/tracing/mastra/test.ts b/dev-packages/node-integration-tests/suites/tracing/mastra/test.ts
index d1e4309ebded..0c3778daa368 100644
--- a/dev-packages/node-integration-tests/suites/tracing/mastra/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/mastra/test.ts
@@ -20,7 +20,7 @@ import {
   SENTRY_ORIGIN,
   URL_FULL,
 } from '@sentry/conventions/attributes';
-import { GEN_AI_CHAT, GEN_AI_EVALUATE, GEN_AI_EXECUTE_TOOL, GEN_AI_INVOKE_AGENT } from '@sentry/conventions/op';
+import { GEN_AI_CHAT, GEN_AI_DECIDE, GEN_AI_EXECUTE_TOOL, GEN_AI_INVOKE_AGENT } from '@sentry/conventions/op';
 import { afterAll, describe, expect } from 'vitest';
 import { supports } from '../../../utils';
 import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../utils/runner';
@@ -221,25 +221,25 @@ describe.runIf(supports({ min: 22 }))('Mastra integration', () => {
     'scenario-classifier.mjs',
     'instrument.mjs',
     (createRunner, test) => {
-      test('maps a classifier evaluation to a gen_ai.evaluate span', async () => {
+      test('maps a classifier evaluation to a gen_ai.decide span', async () => {
         await createRunner()
           .expect({
             span: container => {
               expect(container.items.find(span => span.is_segment && span.name === 'mastra-test')).toBeDefined();
               const spans = container.items.filter(span => span.attributes[SENTRY_ORIGIN]?.value === 'auto.ai.mastra');
-              expect(spans.map(span => span.name)).toEqual(['evaluate jev-latest']);
-
-              const evaluateSpan = spans[0]!;
-              expect(evaluateSpan.attributes[SENTRY_OP].value).toBe(GEN_AI_EVALUATE);
-              expect(evaluateSpan.attributes[SENTRY_ORIGIN].value).toBe('auto.ai.mastra');
-              expect(evaluateSpan.attributes[GEN_AI_OPERATION_NAME].value).toBe('evaluate');
-              expect(evaluateSpan.attributes[GEN_AI_REQUEST_MODEL].value).toBe('jev-latest');
-              expect(evaluateSpan.attributes[GEN_AI_PROVIDER_NAME].value).toBe('typesafe-ai.evaluation');
-              expect(evaluateSpan.attributes[GEN_AI_USAGE_INPUT_TOKENS].value).toBe(30);
-              expect(evaluateSpan.attributes[GEN_AI_USAGE_OUTPUT_TOKENS].value).toBe(2);
-              expect(evaluateSpan.attributes[GEN_AI_USAGE_TOTAL_TOKENS].value).toBe(32);
-              expect(evaluateSpan.attributes[GEN_AI_INPUT_MESSAGES]).toBeUndefined();
-              expect(evaluateSpan.attributes[GEN_AI_OUTPUT_MESSAGES]).toBeUndefined();
+              expect(spans.map(span => span.name)).toEqual(['decide jev-latest']);
+
+              const decideSpan = spans[0]!;
+              expect(decideSpan.attributes[SENTRY_OP].value).toBe(GEN_AI_DECIDE);
+              expect(decideSpan.attributes[SENTRY_ORIGIN].value).toBe('auto.ai.mastra');
+              expect(decideSpan.attributes[GEN_AI_OPERATION_NAME].value).toBe('decide');
+              expect(decideSpan.attributes[GEN_AI_REQUEST_MODEL].value).toBe('jev-latest');
+              expect(decideSpan.attributes[GEN_AI_PROVIDER_NAME].value).toBe('typesafe-ai.evaluation');
+              expect(decideSpan.attributes[GEN_AI_USAGE_INPUT_TOKENS].value).toBe(30);
+              expect(decideSpan.attributes[GEN_AI_USAGE_OUTPUT_TOKENS].value).toBe(2);
+              expect(decideSpan.attributes[GEN_AI_USAGE_TOTAL_TOKENS].value).toBe(32);
+              expect(decideSpan.attributes[GEN_AI_INPUT_MESSAGES]).toBeUndefined();
+              expect(decideSpan.attributes[GEN_AI_OUTPUT_MESSAGES]).toBeUndefined();
             },
           })
           .start()
@@ -259,8 +259,8 @@ describe.runIf(supports({ min: 22 }))('Mastra integration', () => {
           .expect({
             span: container => {
               expect(container.items.find(span => span.is_segment && span.name === 'mastra-test')).toBeDefined();
-              const evaluateSpan = container.items.find(span => span.name === 'evaluate jev-latest')!;
-              expect(JSON.parse(evaluateSpan.attributes[GEN_AI_INPUT_MESSAGES].value)).toEqual([
+              const decideSpan = container.items.find(span => span.name === 'decide jev-latest')!;
+              expect(JSON.parse(decideSpan.attributes[GEN_AI_INPUT_MESSAGES].value)).toEqual([
                 {
                   type: 'evaluation',
                   state: { message: 'I was charged twice.', apiKey: '[REDACTED]' },
@@ -269,7 +269,7 @@ describe.runIf(supports({ min: 22 }))('Mastra integration', () => {
                   },
                 },
               ]);
-              expect(JSON.parse(evaluateSpan.attributes[GEN_AI_OUTPUT_MESSAGES].value)).toEqual([
+              expect(JSON.parse(decideSpan.attributes[GEN_AI_OUTPUT_MESSAGES].value)).toEqual([
                 { type: 'evaluation', answers: { urgent: { type: 'boolean', probability: 0.9 } } },
               ]);
             },
@@ -293,12 +293,12 @@ describe.runIf(supports({ min: 22 }))('Mastra integration', () => {
             span: container => {
               expect(container.items.find(span => span.is_segment && span.name === 'mastra-test')).toBeDefined();
               const spans = container.items.filter(span => span.attributes[SENTRY_ORIGIN]?.value === 'auto.ai.mastra');
-              expect(spans.map(span => span.name)).toEqual(['evaluate jev-latest']);
+              expect(spans.map(span => span.name)).toEqual(['decide jev-latest']);
 
-              const evaluateSpan = spans[0]!;
-              expect(evaluateSpan.status).toBe('error');
-              expect(evaluateSpan.attributes[GEN_AI_INPUT_MESSAGES].value).toContain('I was charged twice.');
-              expect(evaluateSpan.attributes[GEN_AI_OUTPUT_MESSAGES]).toBeUndefined();
+              const decideSpan = spans[0]!;
+              expect(decideSpan.status).toBe('error');
+              expect(decideSpan.attributes[GEN_AI_INPUT_MESSAGES].value).toContain('I was charged twice.');
+              expect(decideSpan.attributes[GEN_AI_OUTPUT_MESSAGES]).toBeUndefined();
             },
           })
           .start()
diff --git a/packages/server-utils/src/ai/mastra/constants.ts b/packages/server-utils/src/ai/mastra/constants.ts
index 4873ca830cd4..ff875db3b201 100644
--- a/packages/server-utils/src/ai/mastra/constants.ts
+++ b/packages/server-utils/src/ai/mastra/constants.ts
@@ -1,7 +1,7 @@
 import {
   GEN_AI_CHAT,
+  GEN_AI_DECIDE,
   GEN_AI_EMBEDDINGS,
-  GEN_AI_EVALUATE,
   GEN_AI_EXECUTE_TOOL,
   GEN_AI_INVOKE_AGENT,
 } from '@sentry/conventions/op';
@@ -42,8 +42,7 @@ export const SPAN_TYPE_OPS: Readonly<Record<string, { op: string; operationName:
   provider_tool_call: { op: GEN_AI_EXECUTE_TOOL, operationName: 'execute_tool' },
   client_tool_call: { op: GEN_AI_EXECUTE_TOOL, operationName: 'execute_tool' },
   rag_embedding: { op: GEN_AI_EMBEDDINGS, operationName: 'embeddings' },
-  // oxlint-disable-next-line typescript/no-deprecated -- the rename to `gen_ai.decide` comes in a follow-up
-  classifier_evaluation: { op: GEN_AI_EVALUATE, operationName: 'evaluate' },
+  classifier_evaluation: { op: GEN_AI_DECIDE, operationName: 'decide' },
 };
 
 export const TOOL_SPAN_TYPES: ReadonlySet<string> = new Set<MastraSpanType>([
diff --git a/packages/server-utils/test/ai/lib/tracing/mastra-exporter.test.ts b/packages/server-utils/test/ai/lib/tracing/mastra-exporter.test.ts
index 844cc9e82514..d2b897a59a55 100644
--- a/packages/server-utils/test/ai/lib/tracing/mastra-exporter.test.ts
+++ b/packages/server-utils/test/ai/lib/tracing/mastra-exporter.test.ts
@@ -27,8 +27,8 @@ import {
 } from '@sentry/conventions/attributes';
 import {
   GEN_AI_CHAT,
+  GEN_AI_DECIDE,
   GEN_AI_EMBEDDINGS,
-  GEN_AI_EVALUATE,
   GEN_AI_EXECUTE_TOOL,
   GEN_AI_INVOKE_AGENT,
 } from '@sentry/conventions/op';
@@ -165,11 +165,11 @@ describe('SentryMastraExporter', () => {
     );
 
     const json = spanToStaticSpanJSON(endedSpans[0]!);
-    expect(json.description).toBe('evaluate jev-1');
+    expect(json.description).toBe('decide jev-1');
     expect(json.data).toMatchObject({
-      [SENTRY_OP]: GEN_AI_EVALUATE,
+      [SENTRY_OP]: GEN_AI_DECIDE,
       [SENTRY_ORIGIN]: 'auto.ai.mastra',
-      [GEN_AI_OPERATION_NAME]: 'evaluate',
+      [GEN_AI_OPERATION_NAME]: 'decide',
       [GEN_AI_REQUEST_MODEL]: 'jev-1',
       [GEN_AI_PROVIDER_NAME]: 'typesafe.evaluation',
       [GEN_AI_USAGE_INPUT_TOKENS]: 30,
@@ -187,7 +187,7 @@ describe('SentryMastraExporter', () => {
 
     expect(endedSpans).toHaveLength(0);
     expect(call.endTime).toEqual(span.endTime);
-    expect(spanToStaticSpanJSON(call.span!).description).toBe('evaluate jev-1');
+    expect(spanToStaticSpanJSON(call.span!).description).toBe('decide jev-1');
   });
 
   it('passes its own recording options to the classifier evaluation call', async () => {

From 8a6b9cae09670ff92ddc096a9190191ad6361f05 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Peer=20St=C3=B6cklmair?= <jan.peer@sentry.io>
Date: Mon, 12 Oct 2026 15:50:54 +0200
Subject: [PATCH 78/84] test(node-integration): Stop exporting `NODE_VERSION`
 and `RUNTIME` from the test utils (#25292)

follow up to #25202

This stops exporting `NODE_VERSION` and `RUNTIME` from the Node
integration test utils, so suites limit tests with
`test.runIf(supports({ ... }))`. It moves `thread-blocked-native`, the
last suite that checked `NODE_VERSION` itself, to `supports`, and adds a
Bugbot rule that flags suites that check the Node version or the runtime
in other ways, for example with `process.versions`.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .cursor/BUGBOT.md                                        | 1 +
 .../suites/thread-blocked-native/test.ts                 | 9 ++-------
 dev-packages/node-integration-tests/utils/index.ts       | 4 ++--
 3 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/.cursor/BUGBOT.md b/.cursor/BUGBOT.md
index f70b4bc51da0..a394e1130d84 100644
--- a/.cursor/BUGBOT.md
+++ b/.cursor/BUGBOT.md
@@ -93,6 +93,7 @@ Keep reviews high-signal. Prefer actionable, high-confidence findings over specu
 - Flag usage of `expect.objectContaining` and other relaxed assertions, when a test expects something NOT to be included in a payload but there's no respective assertion.
 - Flag usage of conditionals in one test and recommend splitting up the test for the different paths.
 - Flag usage of loops testing multiple scenarios in one test and recommend using `(it)|(test).each` instead.
+- In `dev-packages/node-integration-tests/suites/`, flag tests that check the Node version or the runtime themselves, for example with `process.versions`, `process.env.RUNTIME`, `ctx.skip()`, or a version or runtime condition in `skipIf` / `runIf`. Recommend `test.runIf(supports({ ... }))` or `describe.runIf(supports({ ... }))` from `utils/index.ts` instead.
 - Apply the `@sentry/conventions` constants rule from above to test files too. Test assertions on span attributes and ops must use the constants, not string literals.
 - Flag tests that are likely to introduce flakes. In our case this usually means we wait for some telemetry requests sent from an SDK. Patterns to look out for:
   - Only waiting for a request, after an action is performed. Instead, start waiting, perform action, await request promise.
diff --git a/dev-packages/node-integration-tests/suites/thread-blocked-native/test.ts b/dev-packages/node-integration-tests/suites/thread-blocked-native/test.ts
index a07cc781b3d2..bf39f9d7c1ad 100644
--- a/dev-packages/node-integration-tests/suites/thread-blocked-native/test.ts
+++ b/dev-packages/node-integration-tests/suites/thread-blocked-native/test.ts
@@ -1,7 +1,7 @@
 import { join } from 'node:path';
 import type { Event } from '@sentry/core';
 import { afterAll, describe, expect, test } from 'vitest';
-import { NODE_VERSION } from '../../utils/index';
+import { supports } from '../../utils/index';
 import { cleanupChildProcesses, createRunner } from '../../utils/runner';
 
 function EXCEPTION(thread_id = '0', fn = 'longWork') {
@@ -240,12 +240,7 @@ describe('Thread Blocked Native', { timeout: 30_000 }, () => {
       .completed();
   });
 
-  test('Capture scope via AsyncLocalStorage', async ctx => {
-    if (NODE_VERSION < 24) {
-      ctx.skip();
-      return;
-    }
-
+  test.runIf(supports({ min: 24 }))('Capture scope via AsyncLocalStorage', async () => {
     const instrument = join(__dirname, 'instrument.mjs');
     await createRunner(__dirname, 'isolated.mjs')
       .withMockSentryServer()
diff --git a/dev-packages/node-integration-tests/utils/index.ts b/dev-packages/node-integration-tests/utils/index.ts
index b3a1dfd8153d..01f6f4bf039b 100644
--- a/dev-packages/node-integration-tests/utils/index.ts
+++ b/dev-packages/node-integration-tests/utils/index.ts
@@ -3,13 +3,13 @@ import { parseSemver } from '@sentry/core';
 import { execFileSync } from 'child_process';
 import type * as http from 'http';
 
-export const NODE_VERSION = parseSemver(process.versions.node).major || 0;
+const NODE_VERSION = parseSemver(process.versions.node).major || 0;
 
 /**
  * The runtime that runs the scenarios (`node`, `bun` or `deno`), from the `RUNTIME` env var.
  */
 export type Runtime = 'cloudflare' | 'node' | 'bun' | 'deno';
-export const RUNTIME = (process.env.RUNTIME || 'node') as Runtime;
+const RUNTIME = (process.env.RUNTIME || 'node') as Runtime;
 
 // Vitest runs on Node, so it cannot read `Bun.version` of the `bun` binary that runs the scenarios.
 const BUN_VERSION = RUNTIME === 'bun' ? execFileSync('bun', ['--version'], { encoding: 'utf8' }).trim() : undefined;

From 1e861780b1afd311d87461d1a93c0834ccbc62c4 Mon Sep 17 00:00:00 2001
From: Francesco Gringl-Novy <francesco.novy@sentry.io>
Date: Mon, 12 Oct 2026 16:06:11 +0200
Subject: [PATCH 79/84] fix(nuxt): Keep `@sentry/server-runtime-injection`
 external on Nitro v3 (#24901)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

On Nuxt 5 (Nitro v3) with Node < 24.13, server startup logged `Failed to
register diagnostics-channel injection hooks`. Nitro v3 bundles every
dependency, including `@sentry/server-runtime-injection`. Without
`Module.registerHooks`, it registers its ESM loader hook through
`Module.register`, which needs `hook.js` on disk. The bundled copy has
no such file, and the fallback `@sentry/server-runtime-injection/hook`
specifier can't resolve because the output has no `node_modules`. Node
24.13+ takes the `registerHooks` path and was unaffected, as were Nuxt
3/4, since Nitro v2 keeps dependencies external.

The fix adds the package to Nitro's `traceDeps`, so it ships in
`.output/server/node_modules`. Note that a Nuxt app with a local module
still gets it bundled: Nuxt adds the app root to `build.transpile`,
which Nitro v3 turns into an unanchored `noExternals` pattern. The
traced copy still makes the fallback specifier resolve, so registration
works there too.

The e2e runner uses Node 24, so the nuxt-5 regression test asserts the
hook specifier resolves from the server output rather than checking for
the missing warning. The warning now also includes the underlying error,
which previously only showed with `debug: true`.

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

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../nuxt-5/tests/runtime-injection.test.ts    | 20 +++++++++++++++++++
 packages/nuxt/src/vite/nitroServer.ts         |  3 ++-
 packages/nuxt/src/vite/utils.ts               | 16 +++++++++++++++
 packages/nuxt/test/vite/utils.test.ts         | 19 ++++++++++++++++++
 .../server-runtime-injection/src/register.ts  |  3 ++-
 .../test/register.test.ts                     | 19 ++++++++++++++++++
 6 files changed, 78 insertions(+), 2 deletions(-)
 create mode 100644 dev-packages/e2e-tests/test-applications/nuxt-5/tests/runtime-injection.test.ts

diff --git a/dev-packages/e2e-tests/test-applications/nuxt-5/tests/runtime-injection.test.ts b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/runtime-injection.test.ts
new file mode 100644
index 000000000000..c16c103126d6
--- /dev/null
+++ b/dev-packages/e2e-tests/test-applications/nuxt-5/tests/runtime-injection.test.ts
@@ -0,0 +1,20 @@
+import { execFileSync } from 'node:child_process';
+import { expect, test } from '@playwright/test';
+import { isDevMode } from './isDevMode';
+
+// Nitro v3 bundles every dependency, including the SDK's copy of `@sentry/server-runtime-injection`.
+// On Node versions without `Module.registerHooks` (< 24.13), that bundled copy registers its ESM
+// loader hook through the `@sentry/server-runtime-injection/hook` specifier, which has to resolve
+// from the server output. The runner's Node takes the `registerHooks` path, so assert the
+// resolution directly instead of the missing warning.
+test('keeps the runtime injection loader hook resolvable from the server output', () => {
+  test.skip(isDevMode, 'nuxt dev has no server output');
+
+  const resolved = execFileSync(
+    'node',
+    ['--input-type=module', '-e', "console.log(import.meta.resolve('@sentry/server-runtime-injection/hook'))"],
+    { cwd: '.output/server', encoding: 'utf8' },
+  );
+
+  expect(resolved.trim()).toMatch(/\/\.output\/server\/node_modules\/@sentry\/server-runtime-injection\/.*hook\.js$/);
+});
diff --git a/packages/nuxt/src/vite/nitroServer.ts b/packages/nuxt/src/vite/nitroServer.ts
index c999b29cd186..500e94f1f8f6 100644
--- a/packages/nuxt/src/vite/nitroServer.ts
+++ b/packages/nuxt/src/vite/nitroServer.ts
@@ -13,7 +13,7 @@ import {
 import { addDatabaseInstrumentation } from './databaseConfig';
 import { addMiddlewareImports, addMiddlewareInstrumentation } from './middlewareConfig';
 import { addStorageInstrumentation } from './storageConfig';
-import type { ServerApi } from './utils';
+import { addRuntimeInjectionTraceDep, type ServerApi } from './utils';
 
 type NitroModuleOptions = Omit<SentryNuxtModuleOptions, 'experimental_entrypointWrappedFunctions'> &
   Required<Pick<SentryNuxtModuleOptions, 'experimental_entrypointWrappedFunctions'>>;
@@ -61,6 +61,7 @@ export function setupNitroServer(
   addMiddlewareImports();
   addStorageInstrumentation(nuxt, !isNitroV3);
   addDatabaseInstrumentation(nuxt.options.nitro, !isNitroV3, moduleOptions);
+  addRuntimeInjectionTraceDep(nuxt, isNitroV3);
 
   nuxt.hooks.hook('nitro:init', nitro => {
     if (nuxt.options?._prepare) {
diff --git a/packages/nuxt/src/vite/utils.ts b/packages/nuxt/src/vite/utils.ts
index fc393242b682..ca0e5a761b61 100644
--- a/packages/nuxt/src/vite/utils.ts
+++ b/packages/nuxt/src/vite/utils.ts
@@ -224,3 +224,19 @@ export function toResolvablePath(source: string): { path: string; wasFileUrl: bo
     return undefined;
   }
 }
+
+/**
+ * Nitro v3 bundles every dependency by default, but `@sentry/server-runtime-injection` must load
+ * from `node_modules`: on Node versions without `Module.registerHooks` it registers its ESM loader
+ * hook by file, and that file does not exist next to a bundled copy. Nitro v2 already keeps
+ * dependencies external.
+ */
+export function addRuntimeInjectionTraceDep(nuxt: Nuxt, isNitroV3: boolean): void {
+  if (!isNitroV3) {
+    return;
+  }
+
+  // Nuxt types `nitro` against Nitro v2, which has no `traceDeps`.
+  const nitroOptions = nuxt.options.nitro as { traceDeps?: (string | RegExp)[] };
+  nitroOptions.traceDeps = [...(nitroOptions.traceDeps ?? []), '@sentry/server-runtime-injection'];
+}
diff --git a/packages/nuxt/test/vite/utils.test.ts b/packages/nuxt/test/vite/utils.test.ts
index 7d1213fdc959..fa1673c4dcd3 100644
--- a/packages/nuxt/test/vite/utils.test.ts
+++ b/packages/nuxt/test/vite/utils.test.ts
@@ -3,6 +3,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import {
+  addRuntimeInjectionTraceDep,
   constructFunctionReExport,
   constructWrappedFunctionExportQuery,
   extractFunctionReexportQueryParameters,
@@ -427,3 +428,21 @@ export { foo_sentryWrapped as foo };
     expect(result).toBe('');
   });
 });
+
+describe('addRuntimeInjectionTraceDep', () => {
+  it('keeps `@sentry/server-runtime-injection` out of the Nitro v3 bundle', () => {
+    const nuxtMock = { options: { nitro: { traceDeps: ['sharp'] } } } as unknown as Nuxt;
+
+    addRuntimeInjectionTraceDep(nuxtMock, true);
+
+    expect(nuxtMock.options.nitro).toEqual({ traceDeps: ['sharp', '@sentry/server-runtime-injection'] });
+  });
+
+  it('does not touch the Nitro v2 config', () => {
+    const nuxtMock = { options: { nitro: {} } } as unknown as Nuxt;
+
+    addRuntimeInjectionTraceDep(nuxtMock, false);
+
+    expect(nuxtMock.options.nitro).toEqual({});
+  });
+});
diff --git a/packages/server-runtime-injection/src/register.ts b/packages/server-runtime-injection/src/register.ts
index d84c2d76ec97..fd9289aeb26d 100644
--- a/packages/server-runtime-injection/src/register.ts
+++ b/packages/server-runtime-injection/src/register.ts
@@ -300,8 +300,9 @@ export function registerDiagnosticsChannelInjection(): void {
     }
   } catch (error) {
     marker.runtimeUnavailable = true;
+    const reason = error instanceof Error ? error.message : String(error);
     warnRuntimeUnavailable(
-      'Failed to register diagnostics-channel injection hooks, so channel-based integrations will not record spans.',
+      `Failed to register diagnostics-channel injection hooks (${reason}), so channel-based integrations will not record spans.`,
     );
     debug.warn('Diagnostics-channel injection registration error:', error);
     return;
diff --git a/packages/server-runtime-injection/test/register.test.ts b/packages/server-runtime-injection/test/register.test.ts
index bab7e6c56c8a..f34408f98009 100644
--- a/packages/server-runtime-injection/test/register.test.ts
+++ b/packages/server-runtime-injection/test/register.test.ts
@@ -96,6 +96,25 @@ describe('registerDiagnosticsChannelInjection - bundled/tree-shaken detection',
     warnSpy.mockRestore();
   });
 
+  it('includes the underlying error when registering the hooks fails', () => {
+    // Deno always takes the `Module.registerHooks` path, independent of the Node version running the tests.
+    (globalThis as { Deno?: unknown }).Deno = { version: { deno: '2.8.3' } };
+    registerHooksMock.mockImplementationOnce(() => {
+      throw new Error('boom');
+    });
+
+    try {
+      registerDiagnosticsChannelInjection();
+    } finally {
+      delete (globalThis as { Deno?: unknown }).Deno;
+    }
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to register diagnostics-channel injection hooks (boom)'),
+    );
+    expect(GLOBAL_OBJ.__SENTRY_ORCHESTRION__?.runtimeUnavailable).toBe(true);
+  });
+
   it('warns once when a module fails to transform because the transformer was tree-shaken', () => {
     registerDiagnosticsChannelInjection();
     const onDiagnostics = diagnosticsCallback();

From ee046613aa4eb59b456abd90718a340e9eb010ae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Peer=20St=C3=B6cklmair?= <jan.peer@sentry.io>
Date: Mon, 12 Oct 2026 16:18:15 +0200
Subject: [PATCH 80/84] fix(browser): Apply `urlQueryParams` to event URLs,
 static span names and LCP URLs (#25262)

closes #25247
closes
[JS-3907](https://linear.app/getsentry/issue/JS-3907/sensitive-url-query-params-leak-to-sentry-in-transaction-events)

## Description

This applies `dataCollection.urlQueryParams` to the URLs that the
browser SDK still sent unfiltered: the page URL in `event.request.url`,
the `browser.*` and `resource.*` span names in the static trace
lifecycle, and the LCP URL attributes (`lcp.url`,
`browser.web_vital.lcp.url`). `event.request.url` leaked on error events
with every trace lifecycle, the span names only with `traceLifecycle:
'static'` (the v10 default).

Most of the added lines are tests.

## Sentry traces

Before (11.6.0), `jwt=sensitive-jwt-value` in `request.url` and span
names:
https://sentry-sdks.sentry.io/explore/traces/trace/056ddfee720849c78e4e0b68f9da8c5b/?project=4510555608449024&timestamp=1791796663
After (this PR), `jwt=[Filtered]`:
https://sentry-sdks.sentry.io/explore/traces/trace/ea9fd2cc90de4343bf5bfb6eb0d923ad/?project=4510555608449024&timestamp=1791796677

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../suites/integrations/httpContext/test.ts   | 12 ++++++
 .../init.js                                   | 10 +++++
 .../template.html                             |  9 +++++
 .../test.ts                                   | 32 +++++++++++++++
 .../web-vitals-lcp-static/template.html       |  2 +-
 .../metrics/web-vitals-lcp-static/test.ts     |  5 ++-
 .../utils/fixtures.ts                         |  2 +-
 .../browser-utils/src/performance/entries.ts  | 20 +++++-----
 .../browser-utils/src/web-vitals/spans.ts     |  3 +-
 .../browser-utils/src/web-vitals/tracking.ts  |  4 +-
 .../test/performance/browserMetrics.test.ts   | 40 +++++++++++++++++++
 .../test/web-vitals/spans.test.ts             |  5 ++-
 .../browser/src/integrations/httpcontext.ts   |  3 +-
 .../src/tracing/browserTracingIntegration.ts  |  5 ++-
 .../test/integrations/httpcontext.test.ts     | 23 +++++++++++
 .../pagesRouterInstrumentation.test.ts        |  1 +
 16 files changed, 155 insertions(+), 21 deletions(-)
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/template.html
 create mode 100644 dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/test.ts

diff --git a/dev-packages/browser-integration-tests/suites/integrations/httpContext/test.ts b/dev-packages/browser-integration-tests/suites/integrations/httpContext/test.ts
index db8a384510a4..e50a658b4c9a 100644
--- a/dev-packages/browser-integration-tests/suites/integrations/httpContext/test.ts
+++ b/dev-packages/browser-integration-tests/suites/integrations/httpContext/test.ts
@@ -25,6 +25,18 @@ sentryTest('httpContextIntegration captures user-agent and referrer', async ({ g
   });
 });
 
+sentryTest('httpContextIntegration filters sensitive query params in the URL', async ({ getLocalTestUrl, page }) => {
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const errorEventPromise = waitForErrorRequest(page);
+
+  await page.goto(`${url}?jwt=sensitive-jwt-value&page=1`);
+
+  const errorEvent = envelopeRequestParser(await errorEventPromise);
+
+  expect(errorEvent.request?.url).toBe(`${url}?jwt=[Filtered]&page=1`);
+});
+
 sentryTest('httpContextIntegration captures url, user-agent, and referer', async ({ getLocalTestUrl, page }) => {
   sentryTest.skip(shouldSkipTracingTest());
   const url = await getLocalTestUrl({ testDir: __dirname });
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/init.js b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/init.js
new file mode 100644
index 000000000000..bb6d4918d1bf
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracesSampleRate: 1,
+});
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/template.html b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/template.html
new file mode 100644
index 000000000000..3d3b49a9951f
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/template.html
@@ -0,0 +1,9 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <img src="https://sentry-test-site.example/path/to/image.svg?token=sensitive-token-value&size=2" />
+  </body>
+</html>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/test.ts
new file mode 100644
index 000000000000..8bfc5a6df874
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/pageload-sensitive-query-params-static/test.ts
@@ -0,0 +1,32 @@
+import { BROWSER_REQUEST, PAGELOAD, RESOURCE_IMG } from '@sentry/conventions/op';
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import { envelopeRequestParser, shouldSkipTracingTest, waitForTransactionRequest } from '../../../../utils/helpers';
+
+sentryTest(
+  'filters sensitive query params in the pageload transaction URL and span descriptions',
+  async ({ getLocalTestUrl, page }) => {
+    sentryTest.skip(shouldSkipTracingTest());
+
+    await page.route('https://sentry-test-site.example/path/to/image.svg?*', route =>
+      route.fulfill({ body: '<svg xmlns="http://www.w3.org/2000/svg"/>', contentType: 'image/svg+xml' }),
+    );
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const pageloadRequestPromise = waitForTransactionRequest(page, event => event.contexts?.trace?.op === PAGELOAD);
+    await page.goto(`${url}?jwt=sensitive-jwt-value&page=1`);
+    const eventData = envelopeRequestParser<Event>(await pageloadRequestPromise);
+
+    expect(eventData.request?.url).toBe(`${url}?jwt=[Filtered]&page=1`);
+    expect(eventData.spans?.find(({ op }) => op === BROWSER_REQUEST)?.description).toBe(`${url}?jwt=[Filtered]&page=1`);
+    expect(eventData.spans?.find(({ op }) => op === RESOURCE_IMG)?.description).toBe(
+      'https://sentry-test-site.example/path/to/image.svg?token=[Filtered]&size=2',
+    );
+
+    const serializedEvent = JSON.stringify(eventData);
+    expect(serializedEvent).not.toContain('sensitive-jwt-value');
+    expect(serializedEvent).not.toContain('sensitive-token-value');
+  },
+);
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/template.html b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/template.html
index b613a556aca4..164dbf51f486 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/template.html
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/template.html
@@ -5,6 +5,6 @@
   </head>
   <body>
     <div id="content"></div>
-    <img src="https://sentry-test-site.example/my/image.png" />
+    <img src="https://sentry-test-site.example/my/image.png?token=sensitive-token-value&v=1" />
   </body>
 </html>
diff --git a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/test.ts b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/test.ts
index 3c0b3c5af990..712a06a21b04 100644
--- a/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/test.ts
+++ b/dev-packages/browser-integration-tests/suites/tracing/metrics/web-vitals-lcp-static/test.ts
@@ -16,7 +16,7 @@ sentryTest('captures LCP vitals with element details', async ({ browserName, get
   }
 
   page.route('**', route => route.continue());
-  page.route('**/my/image.png', async (route: Route) => {
+  page.route('**/my/image.png?*', async (route: Route) => {
     return route.fulfill({
       path: `${__dirname}/assets/sentry-logo-600x179.png`,
     });
@@ -36,6 +36,9 @@ sentryTest('captures LCP vitals with element details', async ({ browserName, get
   expect(eventData.contexts?.trace?.data?.['lcp.size']).toBeGreaterThan(0);
   expect(eventData.contexts?.trace?.data?.['lcp.loadTime']).toBeGreaterThan(0);
   expect(eventData.contexts?.trace?.data?.['lcp.renderTime']).toBeGreaterThan(0);
+  expect(eventData.contexts?.trace?.data?.['lcp.url']).toBe(
+    'https://sentry-test-site.example/my/image.png?token=[Filtered]&v=1',
+  );
 
   // The LCP value should be the renderTime because the renderTime is set
   expect(eventData.measurements?.lcp?.value).toBeCloseTo(eventData.contexts?.trace?.data?.['lcp.renderTime']);
diff --git a/dev-packages/browser-integration-tests/utils/fixtures.ts b/dev-packages/browser-integration-tests/utils/fixtures.ts
index f856fa64ce23..7436f2c35d9a 100644
--- a/dev-packages/browser-integration-tests/utils/fixtures.ts
+++ b/dev-packages/browser-integration-tests/utils/fixtures.ts
@@ -90,7 +90,7 @@ const sentryTest = base.extend<TestFixtures>({
         }
 
         await page.route(`${TEST_HOST}/*.*`, route => {
-          const file = route.request().url().split('/').pop();
+          const file = new URL(route.request().url()).pathname.split('/').pop();
           const filePath = path.resolve(tmpDir, `./${file}`);
 
           return fs.existsSync(filePath)
diff --git a/packages/browser-utils/src/performance/entries.ts b/packages/browser-utils/src/performance/entries.ts
index 668a0fb3a077..905fa44426f7 100644
--- a/packages/browser-utils/src/performance/entries.ts
+++ b/packages/browser-utils/src/performance/entries.ts
@@ -360,14 +360,15 @@ function _addPerformanceNavigationTiming(
     return;
   }
   const op = NAVIGATION_TIMING_SPAN_OPS[event];
+  const filteredUrl = filterCollectedUrl(entry.name);
   startAndEndSpan(span, _navigationTimeToSeconds(entry, start), _navigationTimeToSeconds(entry, end), {
     // With span streaming, span names have to be low cardinality, so we can't fall back to the
     // document URL. `url.full` keeps it, and is what Relay derives the description from.
-    name: spanStreamingEnabled ? BROWSER_NAVIGATION_TIMING_SPAN_NAMES[op] : entry.name,
+    name: spanStreamingEnabled ? BROWSER_NAVIGATION_TIMING_SPAN_NAMES[op] : filteredUrl,
     attributes: {
       [SENTRY_OP]: op,
       [SENTRY_ORIGIN]: 'auto.ui.browser.metrics',
-      [URL_FULL]: filterCollectedUrl(entry.name),
+      [URL_FULL]: filteredUrl,
       ...(event === 'redirect' && entry.redirectCount != null ? { 'http.redirect_count': entry.redirectCount } : {}),
     },
   });
@@ -396,23 +397,23 @@ function _addRequest(span: Span, entry: PerformanceNavigationTiming, spanStreami
 
     // With span streaming, span names have to be low cardinality, so we can't fall back to the
     // document URL. `url.full` keeps it, and is what Relay derives the description from.
-    const url = filterCollectedUrl(entry.name);
+    const filteredUrl = filterCollectedUrl(entry.name);
 
     startAndEndSpan(span, requestStartTimestamp, responseEndTimestamp, {
-      name: spanStreamingEnabled ? BROWSER_NAVIGATION_TIMING_SPAN_NAMES[BROWSER_REQUEST] : entry.name,
+      name: spanStreamingEnabled ? BROWSER_NAVIGATION_TIMING_SPAN_NAMES[BROWSER_REQUEST] : filteredUrl,
       attributes: {
         [SENTRY_OP]: BROWSER_REQUEST,
         [SENTRY_ORIGIN]: 'auto.ui.browser.metrics',
-        [URL_FULL]: url,
+        [URL_FULL]: filteredUrl,
       },
     });
 
     startAndEndSpan(span, responseStartTimestamp, responseEndTimestamp, {
-      name: spanStreamingEnabled ? BROWSER_NAVIGATION_TIMING_SPAN_NAMES[BROWSER_RESPONSE] : entry.name,
+      name: spanStreamingEnabled ? BROWSER_NAVIGATION_TIMING_SPAN_NAMES[BROWSER_RESPONSE] : filteredUrl,
       attributes: {
         [SENTRY_OP]: BROWSER_RESPONSE,
         [SENTRY_ORIGIN]: 'auto.ui.browser.metrics',
-        [URL_FULL]: url,
+        [URL_FULL]: filteredUrl,
       },
     });
   }
@@ -468,7 +469,8 @@ export function _addResourceSpans(
 
   attributes[HTTP_REQUEST_SAME_ORIGIN] = resourceUrl.includes(WINDOW.location.origin);
 
-  attributes[URL_FULL] = filterCollectedUrl(resourceUrl);
+  const filteredUrl = filterCollectedUrl(resourceUrl);
+  attributes[URL_FULL] = filteredUrl;
 
   _setResourceRequestAttributes(entry, attributes, [
     // https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/responseStatus
@@ -493,7 +495,7 @@ export function _addResourceSpans(
     // With span streaming, span names have to be low cardinality, so we can't fall back to the URL.
     name: spanStreamingEnabled
       ? domain || RESOURCE_SPAN_NAME_FALLBACK
-      : resourceUrl.replace(WINDOW.location.origin, ''),
+      : filteredUrl.replace(WINDOW.location.origin, ''),
     op,
     attributes: attributesWithResourceTiming,
   });
diff --git a/packages/browser-utils/src/web-vitals/spans.ts b/packages/browser-utils/src/web-vitals/spans.ts
index 5c44ea8d1078..1660a44cf273 100644
--- a/packages/browser-utils/src/web-vitals/spans.ts
+++ b/packages/browser-utils/src/web-vitals/spans.ts
@@ -3,6 +3,7 @@ import type { Client, Span, SpanAttributes } from '@sentry/core';
 import {
   browserPerformanceTimeOrigin,
   debug,
+  filterCollectedUrl,
   getActiveSpan,
   getClient,
   getRootSpan,
@@ -219,7 +220,7 @@ export function _sendLcpSpan(
     attributes[UI_COMPONENT_NAME] = componentName;
   }
   entry?.id && (attributes['browser.web_vital.lcp.id'] = entry.id);
-  entry?.url && (attributes['browser.web_vital.lcp.url'] = entry.url);
+  entry?.url && (attributes['browser.web_vital.lcp.url'] = filterCollectedUrl(entry.url, client));
   entry?.loadTime != null && (attributes['browser.web_vital.lcp.load_time'] = entry.loadTime);
   entry?.renderTime != null && (attributes['browser.web_vital.lcp.render_time'] = entry.renderTime);
   entry?.size != null && (attributes['browser.web_vital.lcp.size'] = entry.size);
diff --git a/packages/browser-utils/src/web-vitals/tracking.ts b/packages/browser-utils/src/web-vitals/tracking.ts
index a8dc27fde867..c83fd40f02f0 100644
--- a/packages/browser-utils/src/web-vitals/tracking.ts
+++ b/packages/browser-utils/src/web-vitals/tracking.ts
@@ -1,5 +1,5 @@
 import type { Client, Measurements, Span } from '@sentry/core';
-import { browserPerformanceTimeOrigin, debug, setMeasurement, spanToJSON } from '@sentry/core';
+import { browserPerformanceTimeOrigin, debug, filterCollectedUrl, setMeasurement, spanToJSON } from '@sentry/core';
 import { BROWSER_NAVIGATION_TYPE, SENTRY_OP } from '@sentry/conventions/attributes';
 import { DEBUG_BUILD } from '../debug-build';
 import { htmlTreeAsString } from '../htmlTreeAsString';
@@ -253,7 +253,7 @@ function _setWebVitalAttributes(span: Span, options: AddWebVitalsToSpanOptions):
 
     if (_lcpEntry.url) {
       // Trim URL to the first 200 characters.
-      span.setAttribute('lcp.url', _lcpEntry.url.trim().slice(0, 200));
+      span.setAttribute('lcp.url', filterCollectedUrl(_lcpEntry.url.trim()).slice(0, 200));
     }
 
     if (_lcpEntry.loadTime != null) {
diff --git a/packages/browser-utils/test/performance/browserMetrics.test.ts b/packages/browser-utils/test/performance/browserMetrics.test.ts
index 7a5455aa491d..6ea603aa6311 100644
--- a/packages/browser-utils/test/performance/browserMetrics.test.ts
+++ b/packages/browser-utils/test/performance/browserMetrics.test.ts
@@ -289,6 +289,26 @@ describe('_addResourceSpans', () => {
     expect(json.attributes['url.full']).toBe('https://example.com/assets/app.js?v=42#main');
   });
 
+  it('filters sensitive query params in the description and url.full', () => {
+    const spans: Span[] = [];
+
+    getClient()?.on('spanEnd', span => {
+      spans.push(span);
+    });
+
+    const entry = mockPerformanceResourceTiming({
+      initiatorType: 'script',
+      nextHopProtocol: 'http/1.1',
+    });
+
+    _addResourceSpans(span, entry, 'https://example.com/assets/app.js?token=abc&v=42', 100, 23);
+
+    expect(spans).toHaveLength(1);
+    const json = spanToJSON(spans[0]!);
+    expect(json.name).toBe('/assets/app.js?token=[Filtered]&v=42');
+    expect(json.attributes['url.full']).toBe('https://example.com/assets/app.js?token=[Filtered]&v=42');
+  });
+
   it('sets url.full to the full cross-origin URL', () => {
     const spans: Span[] = [];
 
@@ -790,6 +810,26 @@ describe('_addNavigationSpans', () => {
     );
   });
 
+  it('filters sensitive query params in span names and url.full', () => {
+    const spans: Span[] = [];
+
+    getClient()?.on('spanEnd', span => {
+      spans.push(span);
+    });
+
+    _addNavigationSpans(pageloadSpan, { ...entry, name: 'https://santry.com/test?jwt=baz&q=1' });
+
+    const filteredUrl = 'https://santry.com/test?jwt=[Filtered]&q=1';
+    expect(spans.map(spanToJSON)).toEqual(
+      Array(9).fill(
+        expect.objectContaining({
+          name: filteredUrl,
+          attributes: expect.objectContaining({ 'url.full': filteredUrl }),
+        }),
+      ),
+    );
+  });
+
   describe('with span streaming enabled', () => {
     it.each([
       ['browser.unload_event', 'Unload event'],
diff --git a/packages/browser-utils/test/web-vitals/spans.test.ts b/packages/browser-utils/test/web-vitals/spans.test.ts
index 05a20d5f2d2d..92c86637cbf2 100644
--- a/packages/browser-utils/test/web-vitals/spans.test.ts
+++ b/packages/browser-utils/test/web-vitals/spans.test.ts
@@ -392,6 +392,7 @@ describe('_sendLcpSpan', () => {
     vi.mocked(SentryCore.getClient).mockReturnValue({
       getOptions: () => ({ traceLifecycle: 'static' }),
       getIntegrationByName: () => undefined,
+      getDataCollectionOptions: () => ({ urlQueryParams: true }),
     } as any);
   });
 
@@ -403,7 +404,7 @@ describe('_sendLcpSpan', () => {
     const mockEntry = {
       element: { tagName: 'img' } as Element,
       id: 'hero',
-      url: 'https://example.com/hero.jpg',
+      url: 'https://example.com/hero.jpg?token=abc&size=2',
       loadTime: 100,
       renderTime: 150,
       size: 50000,
@@ -424,7 +425,7 @@ describe('_sendLcpSpan', () => {
           'sentry.pageload.span_id': 'pageload-123',
           'browser.web_vital.lcp.element': '<img>',
           'browser.web_vital.lcp.id': 'hero',
-          'browser.web_vital.lcp.url': 'https://example.com/hero.jpg',
+          'browser.web_vital.lcp.url': 'https://example.com/hero.jpg?token=[Filtered]&size=2',
           'browser.web_vital.lcp.load_time': 100,
           'browser.web_vital.lcp.render_time': 150,
           'browser.web_vital.lcp.size': 50000,
diff --git a/packages/browser/src/integrations/httpcontext.ts b/packages/browser/src/integrations/httpcontext.ts
index b90c9c44ae2e..45961e307b15 100644
--- a/packages/browser/src/integrations/httpcontext.ts
+++ b/packages/browser/src/integrations/httpcontext.ts
@@ -35,8 +35,7 @@ export const httpContextIntegration = defineIntegration(() => {
       };
 
       event.request = {
-        // The URL isn't gated by `dataCollection`, same as on the server.
-        url,
+        url: filterCollectedUrl(url, client),
         ...event.request,
         ...(Object.keys(headers).length > 0 ? { headers } : { headers: undefined }),
       };
diff --git a/packages/browser/src/tracing/browserTracingIntegration.ts b/packages/browser/src/tracing/browserTracingIntegration.ts
index b791dddecefc..a900309bf992 100644
--- a/packages/browser/src/tracing/browserTracingIntegration.ts
+++ b/packages/browser/src/tracing/browserTracingIntegration.ts
@@ -574,8 +574,9 @@ export const browserTracingIntegration = ((options: Partial<BrowserTracingOption
 
         // We store the normalized request data on the scope, so we get the request data at time of span creation
         // otherwise, the URL etc. may already be of the following navigation, and we'd report the wrong URL
+        const requestData = getHttpRequestData();
         scope.setSDKProcessingMetadata({
-          normalizedRequest: getHttpRequestData(),
+          normalizedRequest: { ...requestData, url: filterCollectedUrl(requestData.url, client) },
         });
 
         _createRouteSpan(client, {
@@ -815,7 +816,7 @@ export function startBrowserTracingNavigationSpan(
     scope.setSDKProcessingMetadata({
       normalizedRequest: {
         ...getHttpRequestData(),
-        url,
+        url: filterCollectedUrl(url, client),
       },
     });
   }
diff --git a/packages/browser/test/integrations/httpcontext.test.ts b/packages/browser/test/integrations/httpcontext.test.ts
index 555b68dd1c05..de5f906a083e 100644
--- a/packages/browser/test/integrations/httpcontext.test.ts
+++ b/packages/browser/test/integrations/httpcontext.test.ts
@@ -142,6 +142,29 @@ describe('httpContextIntegration', () => {
       });
     });
 
+    it('filters sensitive query params in the URL attached to events', () => {
+      const client = new BrowserClient(getDefaultBrowserClientOptions());
+      const event: Event = {};
+
+      document.location.href = 'https://example.com/?jwt=baz&page=1';
+      try {
+        httpContextIntegration().preprocessEvent!(event, {}, client);
+      } finally {
+        document.location.href = 'https://example.com';
+      }
+
+      expect(event.request?.url).toBe('https://example.com/?jwt=[Filtered]&page=1');
+    });
+
+    it('leaves a user-supplied event URL untouched', () => {
+      const client = new BrowserClient(getDefaultBrowserClientOptions());
+      const event: Event = { request: { url: 'https://example.com/?jwt=user-set' } };
+
+      httpContextIntegration().preprocessEvent!(event, {}, client);
+
+      expect(event.request?.url).toBe('https://example.com/?jwt=user-set');
+    });
+
     it('applies an allowlist to event headers', () => {
       const client = new BrowserClient(
         getDefaultBrowserClientOptions({ dataCollection: { httpHeaders: { request: { allow: ['user-agent'] } } } }),
diff --git a/packages/nextjs/test/performance/pagesRouterInstrumentation.test.ts b/packages/nextjs/test/performance/pagesRouterInstrumentation.test.ts
index 55e794dda04e..fb7dc10c3019 100644
--- a/packages/nextjs/test/performance/pagesRouterInstrumentation.test.ts
+++ b/packages/nextjs/test/performance/pagesRouterInstrumentation.test.ts
@@ -320,6 +320,7 @@ describe('pagesRouterInstrumentNavigation', () => {
       const client = {
         emit,
         getOptions: () => ({}),
+        getDataCollectionOptions: () => ({ urlQueryParams: true }),
       } as unknown as Client;
 
       pagesRouterInstrumentNavigation(client);

From 236c0ceb2eb8ff362e664e810b0ae284bd632689 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Peer=20St=C3=B6cklmair?= <jan.peer@sentry.io>
Date: Mon, 12 Oct 2026 16:18:15 +0200
Subject: [PATCH 81/84] fix(browser): Apply `urlQueryParams` to breadcrumb and
 element timing URLs (#25289)

follow up to #25262

This applies `dataCollection.urlQueryParams` to the URLs in the fetch,
XHR and navigation breadcrumbs and to the `ui.element.url` attribute of
`elementTimingIntegration`. These still sent sensitive query values such
as `?jwt=...` to Sentry.

## Sentry events

Before (11.6.0), `jwt=sensitive-jwt-value` in the breadcrumbs:
https://sentry-sdks.sentry.io/issues/7787761489/events/2bfc6630501c4314bf84b884a4afb1e9/
After (this PR), `jwt=[Filtered]`:
https://sentry-sdks.sentry.io/issues/7787761463/events/6ae067a147b84e6eb33553ae7ce217c7/

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../fetch/withSensitiveQuery/subject.js       |  3 ++
 .../fetch/withSensitiveQuery/test.ts          | 25 ++++++++++++++++
 .../history/withSensitiveQuery/subject.js     |  4 +++
 .../history/withSensitiveQuery/test.ts        | 29 +++++++++++++++++++
 .../xhr/withSensitiveQuery/subject.js         | 10 +++++++
 .../xhr/withSensitiveQuery/test.ts            | 25 ++++++++++++++++
 .../src/performance/elementTiming.ts          |  4 +--
 .../test/performance/elementTiming.test.ts    |  4 +--
 .../browser/src/integrations/breadcrumbs.ts   | 10 ++++---
 9 files changed, 106 insertions(+), 8 deletions(-)
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/fetch/withSensitiveQuery/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/fetch/withSensitiveQuery/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/history/withSensitiveQuery/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/history/withSensitiveQuery/test.ts
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/xhr/withSensitiveQuery/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/xhr/withSensitiveQuery/test.ts

diff --git a/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/fetch/withSensitiveQuery/subject.js b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/fetch/withSensitiveQuery/subject.js
new file mode 100644
index 000000000000..e8ce3f2f4d3b
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/fetch/withSensitiveQuery/subject.js
@@ -0,0 +1,3 @@
+fetch('http://sentry-test.io/foo?token=sensitive-token-value&page=1').then(() => {
+  Sentry.captureException('test error');
+});
diff --git a/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/fetch/withSensitiveQuery/test.ts b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/fetch/withSensitiveQuery/test.ts
new file mode 100644
index 000000000000..f4794f772eec
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/fetch/withSensitiveQuery/test.ts
@@ -0,0 +1,25 @@
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest } from '../../../../../utils/helpers';
+
+sentryTest('filters sensitive query params in the fetch breadcrumb URL', async ({ getLocalTestUrl, page }) => {
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.route('**/foo?*', route => route.fulfill({ status: 200, body: '{}' }));
+
+  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+
+  expect(eventData.breadcrumbs).toEqual([
+    {
+      timestamp: expect.any(Number),
+      category: 'fetch',
+      type: 'http',
+      data: {
+        method: 'GET',
+        status_code: 200,
+        url: 'http://sentry-test.io/foo?token=[Filtered]&page=1',
+      },
+    },
+  ]);
+});
diff --git a/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/history/withSensitiveQuery/subject.js b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/history/withSensitiveQuery/subject.js
new file mode 100644
index 000000000000..3a8a0b883ce7
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/history/withSensitiveQuery/subject.js
@@ -0,0 +1,4 @@
+history.pushState({}, '', '/foo?jwt=sensitive-jwt-value&a=1');
+history.pushState({}, '', '/bar');
+
+Sentry.captureException('test exception');
diff --git a/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/history/withSensitiveQuery/test.ts b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/history/withSensitiveQuery/test.ts
new file mode 100644
index 000000000000..95d073806165
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/history/withSensitiveQuery/test.ts
@@ -0,0 +1,29 @@
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/browser';
+import { sentryTest } from '../../../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest } from '../../../../../utils/helpers';
+
+sentryTest('filters sensitive query params in navigation breadcrumbs', async ({ getLocalTestUrl, page }) => {
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+
+  expect(eventData.breadcrumbs).toEqual([
+    {
+      category: 'navigation',
+      data: {
+        from: '/index.html',
+        to: '/foo?jwt=[Filtered]&a=1',
+      },
+      timestamp: expect.any(Number),
+    },
+    {
+      category: 'navigation',
+      data: {
+        from: '/foo?jwt=[Filtered]&a=1',
+        to: '/bar',
+      },
+      timestamp: expect.any(Number),
+    },
+  ]);
+});
diff --git a/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/xhr/withSensitiveQuery/subject.js b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/xhr/withSensitiveQuery/subject.js
new file mode 100644
index 000000000000..4599aa27ad14
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/xhr/withSensitiveQuery/subject.js
@@ -0,0 +1,10 @@
+const xhr = new XMLHttpRequest();
+
+xhr.open('GET', 'http://sentry-test.io/foo?token=sensitive-token-value&page=1');
+xhr.send();
+
+xhr.addEventListener('readystatechange', function () {
+  if (xhr.readyState === 4) {
+    Sentry.captureException('test error');
+  }
+});
diff --git a/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/xhr/withSensitiveQuery/test.ts b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/xhr/withSensitiveQuery/test.ts
new file mode 100644
index 000000000000..ccb4c1206139
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/integrations/Breadcrumbs/xhr/withSensitiveQuery/test.ts
@@ -0,0 +1,25 @@
+import { expect } from '@playwright/test';
+import type { Event } from '@sentry/core';
+import { sentryTest } from '../../../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest } from '../../../../../utils/helpers';
+
+sentryTest('filters sensitive query params in the XHR breadcrumb URL', async ({ getLocalTestUrl, page }) => {
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  await page.route('**/foo?*', route => route.fulfill({ status: 200, body: '{}' }));
+
+  const eventData = await getFirstSentryEnvelopeRequest<Event>(page, url);
+
+  expect(eventData.breadcrumbs).toEqual([
+    {
+      timestamp: expect.any(Number),
+      category: 'xhr',
+      type: 'http',
+      data: {
+        method: 'GET',
+        status_code: 200,
+        url: 'http://sentry-test.io/foo?token=[Filtered]&page=1',
+      },
+    },
+  ]);
+});
diff --git a/packages/browser-utils/src/performance/elementTiming.ts b/packages/browser-utils/src/performance/elementTiming.ts
index 6e2ac6e4e52f..5b8e5f01218e 100644
--- a/packages/browser-utils/src/performance/elementTiming.ts
+++ b/packages/browser-utils/src/performance/elementTiming.ts
@@ -1,5 +1,5 @@
 import type { IntegrationFn } from '@sentry/core';
-import { browserPerformanceTimeOrigin, defineIntegration, metrics } from '@sentry/core';
+import { browserPerformanceTimeOrigin, defineIntegration, filterCollectedUrl, metrics } from '@sentry/core';
 import { addPerformanceInstrumentationHandler } from '../instrumentation/performanceObserver';
 import { getBrowserPerformanceAPI } from './utils';
 
@@ -58,7 +58,7 @@ const _elementTimingIntegration = (() => {
           }
 
           if (elementEntry.url) {
-            metricAttributes['ui.element.url'] = elementEntry.url;
+            metricAttributes['ui.element.url'] = filterCollectedUrl(elementEntry.url);
           }
 
           if (elementEntry.naturalWidth) {
diff --git a/packages/browser-utils/test/performance/elementTiming.test.ts b/packages/browser-utils/test/performance/elementTiming.test.ts
index 26ca3c8ee178..54fc3fba12da 100644
--- a/packages/browser-utils/test/performance/elementTiming.test.ts
+++ b/packages/browser-utils/test/performance/elementTiming.test.ts
@@ -98,7 +98,7 @@ describe('elementTimingIntegration', () => {
           identifier: 'hero-image',
           id: 'img1',
           element: { tagName: 'IMG' },
-          url: 'https://example.com/hero.jpg',
+          url: 'https://example.com/hero.jpg?token=abc&w=1920',
           naturalWidth: 1920,
           naturalHeight: 1080,
         } as unknown as PerformanceEntry,
@@ -112,7 +112,7 @@ describe('elementTimingIntegration', () => {
       'ui.element.paint_type': 'image-paint',
       'ui.element.id': 'img1',
       'ui.element.type': 'img',
-      'ui.element.url': 'https://example.com/hero.jpg',
+      'ui.element.url': 'https://example.com/hero.jpg?token=[Filtered]&w=1920',
       'ui.element.width': 1920,
       'ui.element.height': 1080,
     };
diff --git a/packages/browser/src/integrations/breadcrumbs.ts b/packages/browser/src/integrations/breadcrumbs.ts
index e28f2e0c0d12..aa7f438d770e 100644
--- a/packages/browser/src/integrations/breadcrumbs.ts
+++ b/packages/browser/src/integrations/breadcrumbs.ts
@@ -14,6 +14,7 @@ import {
   addFetchInstrumentationHandler,
   debug,
   defineIntegration,
+  filterCollectedUrl,
   getBreadcrumbLogLevelFromHttpStatusCode,
   getClient,
   getEventDescription,
@@ -192,7 +193,7 @@ function _getXhrBreadcrumbHandler(client: Client): (handlerData: HandlerDataXhr)
 
     const data: XhrBreadcrumbData = {
       method,
-      url,
+      url: filterCollectedUrl(url),
       status_code,
     };
 
@@ -247,7 +248,7 @@ function _getFetchBreadcrumbHandler(client: Client): (handlerData: HandlerDataFe
 
       const breadcrumb = {
         category: 'fetch',
-        data: handlerData.fetchData,
+        data: { ...handlerData.fetchData, url: filterCollectedUrl(handlerData.fetchData.url) },
         level: 'error',
         type: 'http',
       } satisfies Breadcrumb;
@@ -259,6 +260,7 @@ function _getFetchBreadcrumbHandler(client: Client): (handlerData: HandlerDataFe
       const response = handlerData.response as Response | undefined;
       const data: FetchBreadcrumbData = {
         ...handlerData.fetchData,
+        url: filterCollectedUrl(handlerData.fetchData.url),
         status_code: response?.status,
       };
 
@@ -315,8 +317,8 @@ function _getHistoryBreadcrumbHandler(client: Client): (handlerData: HandlerData
     addBreadcrumb({
       category: 'navigation',
       data: {
-        from,
-        to,
+        from: filterCollectedUrl(from),
+        to: filterCollectedUrl(to),
       },
     });
   };

From b80300bd1c05538cda5ae39296a12499a1ac4af7 Mon Sep 17 00:00:00 2001
From: Rola Abuhasna <rola.abuhasna@sentry.io>
Date: Mon, 12 Oct 2026 16:25:54 +0200
Subject: [PATCH 82/84] fix(server-utils): Stop treating previous_response_id
 as the OpenAI conversation id (#25269)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The OpenAI integration filled `gen_ai.conversation.id` from
`previous_response_id`. That id names the previous response, so it
changes on every turn and never groups two spans. Same flaw #24979
removed from Vercel AI, flagged there by isaacs.

The id now comes only from the Conversations API: the `conversation`
request parameter or a `conversations.create()` response. The response's
own id stays on `gen_ai.response.id`.

Part of #24832

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

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../suites/tracing/openai/test.ts             | 49 ++++-------------
 packages/server-utils/src/ai/openai/utils.ts  | 15 ++----
 .../tracing/openai-conversation-id.test.ts    | 52 +++++++++++++++++++
 3 files changed, 67 insertions(+), 49 deletions(-)
 create mode 100644 packages/server-utils/test/ai/lib/tracing/openai-conversation-id.test.ts

diff --git a/dev-packages/node-integration-tests/suites/tracing/openai/test.ts b/dev-packages/node-integration-tests/suites/tracing/openai/test.ts
index 754328af131a..4db70ae10643 100644
--- a/dev-packages/node-integration-tests/suites/tracing/openai/test.ts
+++ b/dev-packages/node-integration-tests/suites/tracing/openai/test.ts
@@ -1371,9 +1371,9 @@ describe('OpenAI integration', () => {
     });
   });
 
-  // Test for conversation ID support (Conversations API and previous_response_id)
+  // Conversation id: read from the Conversations API, not from `previous_response_id` chaining
   createEsmAndCjsTests(__dirname, 'scenario-conversation.mjs', 'instrument.mjs', (createRunner, test) => {
-    test('captures conversation ID from Conversations API and previous_response_id', async () => {
+    test('captures the conversation ID from the Conversations API and ignores previous_response_id', async () => {
       let receivedSpans: SerializedStreamedSpanContainer['items'] = [];
 
       await createRunner()
@@ -1445,47 +1445,20 @@ describe('OpenAI integration', () => {
         value: 'conv_689667905b048191b4740501625afd940c7533ace33a2dab',
       });
 
-      const unlinkedResponseSpan = spans.find(
+      // The unlinked call and the one chained with `previous_response_id` both carry no conversation id:
+      // a response id names one response, not the thread, so chaining does not group spans.
+      const unlinkedResponseSpans = spans.filter(
         span =>
           span.attributes[SENTRY_OP]?.value === 'gen_ai.chat' &&
           span.attributes[GEN_AI_REQUEST_MODEL]?.value === 'gpt-4' &&
           span.attributes[GEN_AI_CONVERSATION_ID] === undefined,
       );
-      expect(unlinkedResponseSpan!.status).toBe('ok');
-      expect(unlinkedResponseSpan!.attributes[SENTRY_OP]).toEqual({
-        type: 'string',
-        value: 'gen_ai.chat',
-      });
-      expect(unlinkedResponseSpan!.attributes[GEN_AI_CONVERSATION_ID]).toBeUndefined();
-
-      const previousResponseSpan = spans.find(
-        span => span.attributes[GEN_AI_CONVERSATION_ID]?.value === 'resp_mock_conv_123',
-      );
-      expect(previousResponseSpan!.status).toBe('ok');
-      expect(previousResponseSpan!.attributes[GEN_AI_OPERATION_NAME]).toEqual({
-        type: 'string',
-        value: 'chat',
-      });
-      expect(previousResponseSpan!.attributes[SENTRY_OP]).toEqual({
-        type: 'string',
-        value: 'gen_ai.chat',
-      });
-      expect(previousResponseSpan!.attributes[SENTRY_ORIGIN]).toEqual({
-        type: 'string',
-        value: 'auto.ai.openai',
-      });
-      expect(previousResponseSpan!.attributes[GEN_AI_PROVIDER_NAME]).toEqual({
-        type: 'string',
-        value: 'openai',
-      });
-      expect(previousResponseSpan!.attributes[GEN_AI_REQUEST_MODEL]).toEqual({
-        type: 'string',
-        value: 'gpt-4',
-      });
-      expect(previousResponseSpan!.attributes[GEN_AI_CONVERSATION_ID]).toEqual({
-        type: 'string',
-        value: 'resp_mock_conv_123',
-      });
+      expect(unlinkedResponseSpans).toHaveLength(2);
+      for (const span of unlinkedResponseSpans) {
+        expect(span.status).toBe('ok');
+        expect(span.attributes[GEN_AI_RESPONSE_ID]).toEqual({ type: 'string', value: 'resp_mock_conv_123' });
+      }
+      expect(spans.some(span => span.attributes[GEN_AI_CONVERSATION_ID]?.value === 'resp_mock_conv_123')).toBe(false);
 
       const rawConversationSpan = spans.find(
         span => span.name === 'chat' && span.attributes[GEN_AI_CONVERSATION_ID] === undefined,
diff --git a/packages/server-utils/src/ai/openai/utils.ts b/packages/server-utils/src/ai/openai/utils.ts
index 49b39eb85013..3f6afeac1c44 100644
--- a/packages/server-utils/src/ai/openai/utils.ts
+++ b/packages/server-utils/src/ai/openai/utils.ts
@@ -166,20 +166,13 @@ export function addResponseAttributes(span: Span, result: unknown, recordOutputs
 }
 
 /**
- * Extract conversation ID from request parameters
- * Supports both Conversations API and previous_response_id chaining
+ * Extract the Conversations API id (`conversation: "conv_..."`) from request parameters.
+ * `previous_response_id` is deliberately not read: it names the previous response, so it changes on
+ * every turn and cannot group a conversation's spans.
  * @see https://platform.openai.com/docs/guides/conversation-state
  */
 function extractConversationId(params: Record<string, unknown>): string | undefined {
-  // Conversations API: conversation parameter (e.g., "conv_...")
-  if ('conversation' in params && typeof params.conversation === 'string') {
-    return params.conversation;
-  }
-  // Responses chaining: previous_response_id links to parent response
-  if ('previous_response_id' in params && typeof params.previous_response_id === 'string') {
-    return params.previous_response_id;
-  }
-  return undefined;
+  return 'conversation' in params && typeof params.conversation === 'string' ? params.conversation : undefined;
 }
 
 /**
diff --git a/packages/server-utils/test/ai/lib/tracing/openai-conversation-id.test.ts b/packages/server-utils/test/ai/lib/tracing/openai-conversation-id.test.ts
new file mode 100644
index 000000000000..b7936ad86a54
--- /dev/null
+++ b/packages/server-utils/test/ai/lib/tracing/openai-conversation-id.test.ts
@@ -0,0 +1,52 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { GEN_AI_CONVERSATION_ID, GEN_AI_RESPONSE_ID } from '@sentry/conventions/attributes';
+import { getMainCarrier, setCurrentClient, spanToStaticSpanJSON } from '@sentry/core';
+import type { Span } from '@sentry/core';
+import { instrumentOpenAiClient } from '../../../../src/ai/openai';
+import { getDefaultTestClientOptions, TestClient } from '../../../mocks/client';
+
+describe('instrumentOpenAiClient conversation id', () => {
+  let endedSpans: Span[];
+
+  beforeEach(() => {
+    getMainCarrier().__SENTRY__ = undefined;
+    const client = new TestClient(
+      getDefaultTestClientOptions({ dsn: 'https://public@dsn.ingest.sentry.io/1337', tracesSampleRate: 1 }),
+    );
+    setCurrentClient(client);
+    client.init();
+    endedSpans = [];
+    client.on('spanEnd', span => endedSpans.push(span));
+  });
+
+  afterEach(() => {
+    getMainCarrier().__SENTRY__ = undefined;
+  });
+
+  function responsesClient(): { responses: { create: ReturnType<typeof vi.fn> } } {
+    return {
+      responses: {
+        create: vi.fn().mockResolvedValue({ id: 'resp_2', object: 'response', model: 'gpt-4', output: [] }),
+      },
+    };
+  }
+
+  function data(): Record<string, unknown> {
+    return spanToStaticSpanJSON(endedSpans[0]!).data ?? {};
+  }
+
+  it('reads the Conversations API id from the `conversation` parameter', async () => {
+    const instrumented = instrumentOpenAiClient(responsesClient());
+    await instrumented.responses.create({ model: 'gpt-4', input: 'hi', conversation: 'conv_abc' });
+
+    expect(data()[GEN_AI_CONVERSATION_ID]).toBe('conv_abc');
+  });
+
+  it('does not treat `previous_response_id` chaining as a conversation id', async () => {
+    const instrumented = instrumentOpenAiClient(responsesClient());
+    await instrumented.responses.create({ model: 'gpt-4', input: 'hi', previous_response_id: 'resp_1' });
+
+    expect(data()[GEN_AI_CONVERSATION_ID]).toBeUndefined();
+    expect(data()[GEN_AI_RESPONSE_ID]).toBe('resp_2');
+  });
+});

From 87bdc84665943aaabade21a1bdc1ba46a6b2d2e6 Mon Sep 17 00:00:00 2001
From: Martin Sonnberger <martin.sonnberger@sentry.io>
Date: Mon, 12 Oct 2026 16:32:35 +0200
Subject: [PATCH 83/84] fix(bundler-plugins): Escape JSON in generated
 injection code (#25265)

`JSON.stringify` leaves HTML script delimiters intact, allowing
attacker-controlled injected values to break out if a consumer inlines
the generated bundle into HTML. Escape `<` in metadata, release names,
and build information so HTML parsing cannot reinterpret those values,
while preserving their exact JavaScript runtime values.

Fixes [code-scanning alert
#467](https://github.com/getsentry/sentry-javascript/security/code-scanning/467).

Co-authored-by: GPT-6 <codex@openai.com>
---
 packages/bundler-plugins/src/core/utils.ts    | 11 +++--
 .../bundler-plugins/test/core/utils.test.ts   | 47 ++++++++++++++++++-
 2 files changed, 54 insertions(+), 4 deletions(-)

diff --git a/packages/bundler-plugins/src/core/utils.ts b/packages/bundler-plugins/src/core/utils.ts
index f0d8952dc131..c8dd57597cc0 100644
--- a/packages/bundler-plugins/src/core/utils.ts
+++ b/packages/bundler-plugins/src/core/utils.ts
@@ -308,6 +308,11 @@ export function determineReleaseName(): string | undefined {
   );
 }
 
+function stringifyForCodeInjection(value: unknown): string | undefined {
+  // Bundles may be inlined in HTML, where JSON quoting does not escape script tags or HTML comments.
+  return JSON.stringify(value)?.replace(/</g, '\\u003c');
+}
+
 /**
  * Generates code for the global injector which is responsible for setting the global
  * `SENTRY_RELEASE` & `SENTRY_BUILD_INFO` variables.
@@ -319,12 +324,12 @@ export function generateReleaseInjectorCode({
   release: string;
   injectBuildInformation: boolean;
 }): CodeInjection {
-  let code = `e.SENTRY_RELEASE={id:${JSON.stringify(release)}};`;
+  let code = `e.SENTRY_RELEASE={id:${stringifyForCodeInjection(release)}};`;
 
   if (injectBuildInformation) {
     const buildInfo = getBuildInformation();
 
-    code += `e.SENTRY_BUILD_INFO=${JSON.stringify(buildInfo)};`;
+    code += `e.SENTRY_BUILD_INFO=${stringifyForCodeInjection(buildInfo)};`;
   }
 
   return new CodeInjection(code);
@@ -335,7 +340,7 @@ export function generateModuleMetadataInjectorCode(metadata: any): CodeInjection
   // We are merging the metadata objects in case modules are bundled twice with the plugin
   // Use try-catch to avoid issues when bundlers rename global variables like 'window' to 'k'
   return new CodeInjection(
-    `e._sentryModuleMetadata=e._sentryModuleMetadata||{},e._sentryModuleMetadata[(new e.Error).stack]=function(e){for(var n=1;n<arguments.length;n++){var a=arguments[n];if(null!=a)for(var t in a)a.hasOwnProperty(t)&&(e[t]=a[t])}return e}({},e._sentryModuleMetadata[(new e.Error).stack],${JSON.stringify(
+    `e._sentryModuleMetadata=e._sentryModuleMetadata||{},e._sentryModuleMetadata[(new e.Error).stack]=function(e){for(var n=1;n<arguments.length;n++){var a=arguments[n];if(null!=a)for(var t in a)a.hasOwnProperty(t)&&(e[t]=a[t])}return e}({},e._sentryModuleMetadata[(new e.Error).stack],${stringifyForCodeInjection(
       metadata,
     )});`,
   );
diff --git a/packages/bundler-plugins/test/core/utils.test.ts b/packages/bundler-plugins/test/core/utils.test.ts
index 73c28e6e646f..426f7c2553c9 100644
--- a/packages/bundler-plugins/test/core/utils.test.ts
+++ b/packages/bundler-plugins/test/core/utils.test.ts
@@ -11,8 +11,10 @@ import {
 
 import childProcess from 'child_process';
 import fs from 'fs';
-import { describe, it, expect, test, vi } from 'vitest';
+import { afterEach, describe, it, expect, test, vi } from 'vitest';
 import path from 'node:path';
+import { runInNewContext } from 'node:vm';
+import { JSDOM } from 'jsdom';
 
 type PackageJson = Record<string, unknown>;
 
@@ -284,6 +286,49 @@ describe('generateModuleMetadataInjectorCode', () => {
   });
 });
 
+describe('code injection in HTML', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it.each([
+    '</script><script>globalThis.injected = true</script>',
+    '</ScRiPt \n><script>globalThis.injected = true</script>',
+    '<!--<script>',
+    'quotes "\' and backslashes \\u003c with whitespace \n\r\t\u2028\u2029 and <>&',
+  ])('preserves injected values containing %j inside one script element', value => {
+    vi.spyOn(fs, 'readFileSync').mockReturnValueOnce(
+      JSON.stringify({ name: 'test-app', dependencies: { [value]: '1.0.0' } }),
+    );
+    const metadata = { [value]: { values: [value] } };
+    const injection = generateReleaseInjectorCode({ release: value, injectBuildInformation: true });
+    injection.append(generateModuleMetadataInjectorCode(metadata));
+    const code = injection.code();
+    const context: {
+      SENTRY_RELEASE?: { id: string };
+      SENTRY_BUILD_INFO?: { deps: string[]; depsVersions: Record<string, number>; nodeVersion: number };
+      _sentryModuleMetadata?: Record<string, unknown>;
+    } = {};
+
+    const dom = new JSDOM(`<script>${code}</script>`);
+    const scripts = dom.window.document.querySelectorAll('script');
+    dom.window.close();
+
+    expect(scripts).toHaveLength(1);
+    expect(scripts[0]?.textContent).toBe(code);
+
+    runInNewContext(code, context);
+
+    expect(context.SENTRY_RELEASE).toEqual({ id: value });
+    expect(context.SENTRY_BUILD_INFO).toEqual({
+      deps: [value],
+      depsVersions: {},
+      nodeVersion: Number(process.versions.node.split('.')[0]),
+    });
+    expect(Object.values(context._sentryModuleMetadata ?? {})).toEqual([metadata]);
+  });
+});
+
 describe('determineReleaseName', () => {
   it('runs `git rev-parse HEAD` with windowsHide so no console window flashes on Windows', () => {
     // Clear env so the function falls through the CI/git-provider checks to the

From 323307a0ca407ac8cdae9ff3e2d3b2f60f4636d6 Mon Sep 17 00:00:00 2001
From: JPeer264 <jan.peer@sentry.io>
Date: Mon, 12 Oct 2026 16:23:16 +0200
Subject: [PATCH 84/84] meta(changelog): Update changelog for 11.7.0

---
 CHANGELOG.md | 149 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 149 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 608afb690471..0727144b61f9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,155 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+## 11.7.0
+
+### Important Changes
+
+- **feat(cloudflare): Add opt-in cron monitoring for Cron Triggers ([#25014](https://github.com/getsentry/sentry-javascript/pull/25014))**
+
+  The new `cronTriggersIntegration` sends check-ins for Cron Triggers. Each check-in includes the schedule from `controller.cron`, so Sentry creates the monitor on the first run. The integration is opt-in, because monitors are billed.
+
+  Cron Triggers have no names, so map each cron expression of your wrangler config to a monitor slug. With the Sentry Cloudflare Vite plugin, add the integration to `src/instrument.server.ts`:
+
+  ```ts
+  // src/monitorSlugs.ts
+  export const monitorSlugs: Record<string, string> = {
+    '30 9 * * MON-FRI': 'daily-report',
+  };
+
+  // src/instrument.server.ts
+  import * as Sentry from '@sentry/cloudflare';
+  import { monitorSlugs } from './monitorSlugs';
+
+  export default Sentry.defineCloudflareOptions(env => ({
+    dsn: env.SENTRY_DSN,
+    integrations: [Sentry.cronTriggersIntegration({ monitorSlug: cron => monitorSlugs[cron] })],
+  }));
+
+  // src/index.ts
+  import { monitorSlugs } from './monitorSlugs';
+
+  export default {
+    async scheduled(controller, env) {
+      switch (monitorSlugs[controller.cron]) {
+        case 'daily-report':
+          // Your daily report job
+          break;
+      }
+    },
+  };
+  ```
+
+  The `monitorSlug` function can also return monitor settings, for example `{ monitorSlug: 'daily-report', maxRuntime: 30 }`, or `undefined` to send no check-ins for a trigger. Without `monitorSlug`, the SDK derives the slug from the cron expression. If you deploy with `wrangler` directly, pass the same integration to `Sentry.withSentry`.
+
+- **feat(node): Add neonIntegration for @neondatabase/serverless ([#25164](https://github.com/getsentry/sentry-javascript/pull/25164), [#25176](https://github.com/getsentry/sentry-javascript/pull/25176))**
+
+  The new `neonIntegration` creates `db` spans for queries of the `@neondatabase/serverless` driver: for the WebSocket `Client` and `Pool`, and for the HTTP `neon()` function. This includes the `neon-http` and `neon-serverless` adapters of Drizzle. The integration is on by default when tracing is enabled.
+
+- **feat(node): Stop sending the process session once request sessions are tracked ([#24915](https://github.com/getsentry/sentry-javascript/pull/24915))**
+
+  Node servers sent release health data two times: as request session aggregates, and as the process session of `processSessionIntegration`. An error in a request also marked the process session as errored, so the SDK counted the error two times. Now the SDK drops the process session when it tracks the first request session. Scripts, CLIs and workers that do not serve requests keep the process session, and so do servers with `httpServerIntegration({ sessions: false })`. This changes the release health numbers of Node servers, because they no longer send the errored or crashed update of the process session.
+
+- **feat(server-utils): Record decide calls as `gen_ai.decide` spans ([#25270](https://github.com/getsentry/sentry-javascript/pull/25270), [#25272](https://github.com/getsentry/sentry-javascript/pull/25272), [#25274](https://github.com/getsentry/sentry-javascript/pull/25274), [#25281](https://github.com/getsentry/sentry-javascript/pull/25281))**
+
+  Vercel AI `experimental_decide` calls, Mastra classifier evaluations, TypeSafe and LangChain Jev calls, and Workers AI calls to TypeSafe Jev and Cloudflare Clef models now create `decide <model>` spans with the op `gen_ai.decide`. Before, these spans had the op `gen_ai.evaluate`, which is now deprecated in the Sentry conventions. If you use `gen_ai.evaluate` in queries, alerts or dashboards, change it to `gen_ai.decide`.
+
+- **fix(browser): Apply `urlQueryParams` to more URLs ([#25262](https://github.com/getsentry/sentry-javascript/pull/25262), [#25289](https://github.com/getsentry/sentry-javascript/pull/25289))**
+
+  The `dataCollection.urlQueryParams` option now also filters the query parameters of these URLs:
+  - the page URL in `event.request.url`
+  - the `browser.*` and `resource.*` span names with `traceLifecycle: 'static'`
+  - the LCP URL attributes `lcp.url` and `browser.web_vital.lcp.url`
+  - the URLs in fetch, XHR and navigation breadcrumbs
+  - the `ui.element.url` attribute of `elementTimingIntegration`
+
+  Before this fix, these URLs could send sensitive query values, for example `?jwt=...`, to Sentry.
+
+- **fix(nextjs): Apply top-level `bundleSizeOptimizations` to webpack and Turbopack builds ([#24818](https://github.com/getsentry/sentry-javascript/pull/24818))**
+
+  The top-level `bundleSizeOptimizations` option now removes unused SDK code in webpack and in Turbopack builds. Before, the tree-shaking options had no effect on Turbopack. The `webpack.treeshake` option is deprecated. It still works, but when you set both options, `bundleSizeOptimizations` takes precedence.
+
+### Other Changes
+
+- feat(nuxt): Detect the server API with `@nuxt/kit` 4.6 ([#25138](https://github.com/getsentry/sentry-javascript/pull/25138))
+- fix(bundler-plugins): Escape JSON in generated injection code ([#25265](https://github.com/getsentry/sentry-javascript/pull/25265))
+- fix(core): Don't mark http client spans as errors when the caller aborts ([#25260](https://github.com/getsentry/sentry-javascript/pull/25260))
+- fix(core): Record `span` client report outcomes when discarding transactions ([#25006](https://github.com/getsentry/sentry-javascript/pull/25006))
+- fix(core): Record client outcomes when beforeSend callbacks return invalid values ([#25049](https://github.com/getsentry/sentry-javascript/pull/25049))
+- fix(core): Record span outcomes for spans dropped when building a transaction ([#25048](https://github.com/getsentry/sentry-javascript/pull/25048))
+- fix(core): Report actual item count in client reports of envelope send failures ([#25185](https://github.com/getsentry/sentry-javascript/pull/25185))
+- fix(core): Strip internal custom span name from streamed spans ([#25212](https://github.com/getsentry/sentry-javascript/pull/25212))
+- fix(nextjs): Filter query parameters in request error context ([#25233](https://github.com/getsentry/sentry-javascript/pull/25233))
+- fix(node): Don't mark fetch spans as errors when the caller aborts ([#25129](https://github.com/getsentry/sentry-javascript/pull/25129))
+- fix(nuxt): Delete public source maps before Nitro lists its public assets ([#25267](https://github.com/getsentry/sentry-javascript/pull/25267))
+- fix(nuxt): Keep `@sentry/server-runtime-injection` external on Nitro v3 ([#24901](https://github.com/getsentry/sentry-javascript/pull/24901))
+- fix(nuxt): Remove @opentelemetry/resources dev alias ([#25216](https://github.com/getsentry/sentry-javascript/pull/25216))
+- fix(profiling-node): Stop the trace lifecycle profiler when spans are unsampled ([#25210](https://github.com/getsentry/sentry-javascript/pull/25210))
+- fix(react-router): Respect custom default integrations ([#25259](https://github.com/getsentry/sentry-javascript/pull/25259))
+- fix(remix): Respect custom default integrations ([#25258](https://github.com/getsentry/sentry-javascript/pull/25258))
+- fix(server-utils): avoid quadratic SQL summary regex backtracking ([#25255](https://github.com/getsentry/sentry-javascript/pull/25255))
+- fix(server-utils): End Express layer spans when the client aborts ([#25209](https://github.com/getsentry/sentry-javascript/pull/25209))
+- fix(server-utils): Record amqplib consumer info before the first delivery and instrument the callback API ([#25047](https://github.com/getsentry/sentry-javascript/pull/25047))
+- fix(server-utils): Stop treating previous_response_id as the OpenAI conversation id ([#25269](https://github.com/getsentry/sentry-javascript/pull/25269))
+- fix(sveltekit): Read load event pathname untracked ([#25235](https://github.com/getsentry/sentry-javascript/pull/25235))
+- fix(sveltekit): Stop adapter-node 6 output dir probe from deleting the build ([#25193](https://github.com/getsentry/sentry-javascript/pull/25193))
+
+<details>
+  <summary> <strong>Internal Changes</strong> </summary>
+
+- chore: Add external contributor to CHANGELOG.md ([#25230](https://github.com/getsentry/sentry-javascript/pull/25230))
+- chore: Add external contributor to CHANGELOG.md ([#25271](https://github.com/getsentry/sentry-javascript/pull/25271))
+- chore(deps-dev): Bump oxlint-tsgolint from 7.0.2001 to 7.0.2003 ([#25237](https://github.com/getsentry/sentry-javascript/pull/25237))
+- chore(deps-dev): Bump rimraf from 5.0.10 to 6.1.3 ([#25241](https://github.com/getsentry/sentry-javascript/pull/25241))
+- chore(deps): Bump `@sentry/conventions` to 0.27.0 ([#25264](https://github.com/getsentry/sentry-javascript/pull/25264))
+- chore(deps): Bump next from 16.2.11 to 16.3.8 in /dev-packages/e2e-tests/test-applications/nextjs-16 ([#25179](https://github.com/getsentry/sentry-javascript/pull/25179))
+- chore(deps): Bump next from 16.2.11 to 16.3.8 in /dev-packages/e2e-tests/test-applications/nextjs-16-tunnel ([#25190](https://github.com/getsentry/sentry-javascript/pull/25190))
+- chore(size-limit): weekly auto-bump ([#25213](https://github.com/getsentry/sentry-javascript/pull/25213))
+- ci: Install Playwright in the background during E2E app builds ([#25207](https://github.com/getsentry/sentry-javascript/pull/25207))
+- ci: Run lint steps in parallel ([#25187](https://github.com/getsentry/sentry-javascript/pull/25187))
+- ci(bun): Test the oldest supported Bun version and the newest 1.4 ([#25203](https://github.com/getsentry/sentry-javascript/pull/25203))
+- docs: Scope pre-PR tests to affected suites ([#25198](https://github.com/getsentry/sentry-javascript/pull/25198))
+- feat(deps): Bump @aws-sdk/client-kinesis from 3.1068.0 to 3.1146.0 ([#25240](https://github.com/getsentry/sentry-javascript/pull/25240))
+- feat(deps): Bump handlebars from 4.7.9 to 4.7.10 ([#25206](https://github.com/getsentry/sentry-javascript/pull/25206))
+- feat(deps): Bump pino from 9.10.0 to 10.4.0 ([#25238](https://github.com/getsentry/sentry-javascript/pull/25238))
+- feat(deps): Bump reflect-metadata from 0.2.1 to 0.2.2 ([#25239](https://github.com/getsentry/sentry-javascript/pull/25239))
+- ref(core): Simplify transport item loss recording ([#25224](https://github.com/getsentry/sentry-javascript/pull/25224))
+- ref(server-utils): Export the pg query span helpers ([#25163](https://github.com/getsentry/sentry-javascript/pull/25163))
+- ref(server-utils): Share Orchestrion channel context ([#25208](https://github.com/getsentry/sentry-javascript/pull/25208))
+- test(browser): migrate trace lifecycle and span API tests to streaming ([#24881](https://github.com/getsentry/sentry-javascript/pull/24881))
+- test(browser): port browser tracing suites to span streaming ([#24888](https://github.com/getsentry/sentry-javascript/pull/24888))
+- test(browser): port requests and web vitals to span streaming ([#24886](https://github.com/getsentry/sentry-javascript/pull/24886))
+- test(browser): Register the LCP handlers in the bundle of the SDK ([#25263](https://github.com/getsentry/sentry-javascript/pull/25263))
+- test(bun): Run the Node suites that need Bun 1.4 on the Bun 1.4 job ([#25204](https://github.com/getsentry/sentry-javascript/pull/25204))
+- test(cloudflare): Add LangChain TypeSafeClassifier integration test ([#25234](https://github.com/getsentry/sentry-javascript/pull/25234))
+- test(core): Fix flaky span end timestamp test ([#25211](https://github.com/getsentry/sentry-javascript/pull/25211))
+- test(deno): Type-check Deno unit tests ([#25227](https://github.com/getsentry/sentry-javascript/pull/25227))
+- test(nextjs): Add vinext e2e tests ([#25001](https://github.com/getsentry/sentry-javascript/pull/25001))
+- test(node-integration): Replace `conditionalTest` with a `supports` helper ([#25202](https://github.com/getsentry/sentry-javascript/pull/25202))
+- test(node-integration): Stop exporting `NODE_VERSION` and `RUNTIME` from the test utils ([#25292](https://github.com/getsentry/sentry-javascript/pull/25292))
+- test(node): Add integration tests for the Neon serverless driver ([#25177](https://github.com/getsentry/sentry-javascript/pull/25177))
+- test(node): Port baggage and metadata tests to span streaming ([#25220](https://github.com/getsentry/sentry-javascript/pull/25220))
+- test(node): Port basic and nested startSpan tests to streaming ([#25214](https://github.com/getsentry/sentry-javascript/pull/25214))
+- test(node): Port fetch request suites to span streaming ([#25189](https://github.com/getsentry/sentry-javascript/pull/25189))
+- test(node): Port HTTP options and hooks to span streaming ([#25195](https://github.com/getsentry/sentry-javascript/pull/25195))
+- test(node): Port HTTP propagation and transport suites to streaming ([#25197](https://github.com/getsentry/sentry-javascript/pull/25197))
+- test(node): Port HTTP request suites to span streaming ([#25191](https://github.com/getsentry/sentry-javascript/pull/25191))
+- test(node): Port incoming HTTP behavior to span streaming ([#25194](https://github.com/getsentry/sentry-javascript/pull/25194))
+- test(node): Port MongoDB integration tests to span streaming ([#25150](https://github.com/getsentry/sentry-javascript/pull/25150))
+- test(node): Port Mongoose integration tests to span streaming ([#25151](https://github.com/getsentry/sentry-javascript/pull/25151))
+- test(node): Port outgoing HTTP client spans to streaming ([#25192](https://github.com/getsentry/sentry-javascript/pull/25192))
+- test(node): Port parallel span and naming tests to streaming ([#25217](https://github.com/getsentry/sentry-javascript/pull/25217))
+- test(node): Port Postgres integration tests to span streaming ([#25140](https://github.com/getsentry/sentry-javascript/pull/25140))
+- test(node): Port Prisma integration tests to span streaming ([#25152](https://github.com/getsentry/sentry-javascript/pull/25152))
+- test(node): Port Redis integration tests to span streaming ([#25153](https://github.com/getsentry/sentry-javascript/pull/25153))
+- test(node): Port span linking and raw OTel tests to streaming ([#25219](https://github.com/getsentry/sentry-javascript/pull/25219))
+- test(node): Port trace context tests to span streaming ([#25218](https://github.com/getsentry/sentry-javascript/pull/25218))
+- test(node): Run sampling propagation tests with default streaming ([#25221](https://github.com/getsentry/sentry-javascript/pull/25221))
+- test(node): Use default streaming in scope and span suites ([#25222](https://github.com/getsentry/sentry-javascript/pull/25222))
+- test(nuxt): Test imports from `nuxt/server` in the nuxt-5 E2E app ([#25232](https://github.com/getsentry/sentry-javascript/pull/25232))
+
+</details>
+
 Work in this release was contributed by @Philip-Nwabuwa and @4ktLuffy. Thank you for your contributions!
 
 ## 11.6.0