feat(opentelemetry)!: Remove SentryPropagator

dev-packages/node-integration-tests/suites/pino/scenario.mjs

@@ -8,14 +8,15 @@ Sentry.pinoIntegration.untrackLogger(ignoredLogger);
 
 ignoredLogger.info('this will not be tracked');
 
-Sentry.withIsolationScope(() => {
+// Each operation runs in its own trace, so logs emitted within them carry distinct trace ids.
+Sentry.startNewTrace(() => {
   Sentry.startSpan({ name: 'startup' }, () => {
     logger.info({ user: 'user-id', something: { more: 3, complex: 'nope' } }, 'hello world');
   });
 });
 
 setTimeout(() => {
-  Sentry.withIsolationScope(() => {
+  Sentry.startNewTrace(() => {
     Sentry.startSpan({ name: 'later' }, () => {
       const child = logger.child({ module: 'authentication' });
       child.error(new Error('oh no'));

dev-packages/node-integration-tests/suites/public-api/bindScopeToEmitter/test.ts

@@ -34,7 +34,9 @@ test('bindScopeToEmitter preserves the active span for listeners firing in a dif
   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, separate trace.
+  // 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?.trace_id).not.toBe(parentTraceId);
+  expect(childUnbound?.contexts?.trace?.parent_span_id).toBeUndefined();
 });

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans-streamed/test.ts

@@ -6,25 +6,24 @@ afterAll(() => {
 });
 
 test('sends manually started streamed parallel root spans in root context', async () => {
-  expect.assertions(7);
+  expect.assertions(6);
 
   await createRunner(__dirname, 'scenario.ts')
-    .expect({ span: { items: [{ name: 'test_span_1' }] } })
     .expect({
       span: spanContainer => {
         expect(spanContainer).toBeDefined();
-        const traceId = spanContainer.items[0]!.trace_id;
-        expect(traceId).toMatch(/^[0-9a-f]{32}$/);
 
-        // It ignores propagation context of the root context
-        expect(traceId).not.toBe('12345678901234567890123456789012');
-        expect(spanContainer.items[0]!.parent_span_id).toBeUndefined();
+        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();
 
-        // Different trace ID than the first span
-        const trace1Id = spanContainer.items[0]!.attributes.spanIdTraceId?.value;
-        expect(trace1Id).toMatch(/^[0-9a-f]{32}$/);
+        // 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');
 
-        expect(trace1Id).not.toBe(traceId);
+        // Same trace ID for both spans
+        expect(span2!.trace_id).toBe(span1!.trace_id);
       },
     })
     .start()

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-root-spans/test.ts

@@ -6,24 +6,23 @@ afterAll(() => {
 });
 
 test('should send manually started parallel root spans in root context', async () => {
-  expect.assertions(7);
+  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();
 
-        // It ignores propagation context of the root context
-        expect(traceId).not.toBe('12345678901234567890123456789012');
-        expect(transaction.contexts?.trace?.parent_span_id).toBeUndefined();
+        // 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');
 
-        // Different trace ID than the first span
+        // Same trace ID as the first span
         const trace1Id = transaction.contexts?.trace?.data?.spanIdTraceId;
-        expect(trace1Id).toBeDefined();
-        expect(trace1Id).not.toBe(traceId);
+        expect(trace1Id).toBe('12345678901234567890123456789012');
+        expect(trace1Id).toBe(traceId);
       },
     })
     .start()

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-streamed/test.ts

@@ -9,19 +9,20 @@ test('sends manually started streamed parallel root spans outside of root contex
   expect.assertions(6);
 
   await createRunner(__dirname, 'scenario.ts')
-    .expect({ span: { items: [{ name: 'test_span_1' }] } })
     .expect({
       span: spanContainer => {
         expect(spanContainer).toBeDefined();
-        const traceId = spanContainer.items[0]!.trace_id;
-        expect(traceId).toMatch(/^[0-9a-f]{32}$/);
-        expect(spanContainer.items[0]!.parent_span_id).toBeUndefined();
 
-        const trace1Id = spanContainer.items[0]!.attributes.spanIdTraceId?.value;
-        expect(trace1Id).toMatch(/^[0-9a-f]{32}$/);
+        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();
 
-        // Different trace ID as the first span
-        expect(trace1Id).not.toBe(traceId);
+        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()

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId-streamed/test.ts

@@ -9,19 +9,22 @@ test('sends manually started streamed parallel root spans outside of root contex
   expect.assertions(6);
 
   await createRunner(__dirname, 'scenario.ts')
-    .expect({ span: { items: [{ name: 'test_span_1' }] } })
     .expect({
       span: spanContainer => {
         expect(spanContainer).toBeDefined();
-        const traceId = spanContainer.items[0]!.trace_id;
-        expect(traceId).toMatch(/^[0-9a-f]{32}$/);
-        expect(spanContainer.items[0]!.parent_span_id).toBeUndefined();
 
-        const trace1Id = spanContainer.items[0]!.attributes.spanIdTraceId?.value;
-        expect(trace1Id).toMatch(/^[0-9a-f]{32}$/);
+        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();
 
-        // Different trace ID as the first span
-        expect(trace1Id).not.toBe(traceId);
+        // 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()

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope-with-parentSpanId/test.ts

@@ -12,14 +12,15 @@ test('should send manually started parallel root spans outside of root context w
       transaction: transaction => {
         expect(transaction).toBeDefined();
         const traceId = transaction.contexts?.trace?.trace_id;
-        expect(traceId).toBeDefined();
-        expect(transaction.contexts?.trace?.parent_span_id).toBeUndefined();
 
-        const trace1Id = transaction.contexts?.trace?.data?.spanIdTraceId;
-        expect(trace1Id).toBeDefined();
+        // 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');
 
-        // Different trace ID as the first span
-        expect(trace1Id).not.toBe(traceId);
+        // Same trace ID as the first span
+        const trace1Id = transaction.contexts?.trace?.data?.spanIdTraceId;
+        expect(trace1Id).toBe(traceId);
       },
     })
     .start()

dev-packages/node-integration-tests/suites/public-api/startSpan/parallel-spans-in-scope/test.ts

@@ -20,8 +20,8 @@ test('should send manually started parallel root spans outside of root context',
         const trace1Id = transaction.contexts?.trace?.data?.spanIdTraceId;
         expect(trace1Id).toBeDefined();
 
-        // Different trace ID as the first span
-        expect(trace1Id).not.toBe(traceId);
+        // Same trace ID as the first span - both root spans share the scope's propagation context
+        expect(trace1Id).toBe(traceId);
       },
     })
     .start()

dev-packages/node-integration-tests/suites/tracing/requests/fetch-sampled-no-active-span/test.ts

@@ -10,13 +10,13 @@ describe('outgoing fetch', () => {
       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})$/));
-          expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+          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');
         })
         .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})$/));
-          expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000');
+          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');
         })
         .get('/api/v2', headers => {
           expect(headers['baggage']).toBeUndefined();

packages/core/src/tracing/trace.ts

@@ -257,8 +257,7 @@ export const continueTrace = <V>(
   return withScope(scope => {
     const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);
     scope.setPropagationContext(propagationContext);
-    _setSpanForScope(scope, undefined);
-    return callback();
+    return withActiveSpan(null, callback);
   });
 };
 
@@ -330,13 +329,15 @@ export function startNewTrace<T>(callback: () => T): T {
     return acs.startNewTrace(callback);
   }
 
-  return withScope(scope => {
-    scope.setPropagationContext({
-      traceId: generateTraceId(),
-      sampleRand: safeMathRandom(),
+  return withActiveSpan(null, () => {
+    return withScope(scope => {
+      scope.setPropagationContext({
+        traceId: generateTraceId(),
+        sampleRand: safeMathRandom(),
+      });
+      DEBUG_BUILD && debug.log(`Starting a new trace with id ${scope.getPropagationContext().traceId}`);
+      return callback();
     });
-    DEBUG_BUILD && debug.log(`Starting a new trace with id ${scope.getPropagationContext().traceId}`);
-    return withActiveSpan(null, callback);
   });
 }
 

packages/node/src/sdk/client.ts

@@ -1,7 +1,7 @@
 import * as os from 'node:os';
 import type { Tracer } from '@opentelemetry/api';
 import { trace } from '@opentelemetry/api';
-import type { DynamicSamplingContext, Scope, ServerRuntimeClientOptions, TraceContext } from '@sentry/core';
+import type { ServerRuntimeClientOptions } from '@sentry/core';
 import {
   _INTERNAL_clearAiProviderSkips,
   _INTERNAL_flushLogsBuffer,
@@ -11,11 +11,7 @@ import {
   SDK_VERSION,
   ServerRuntimeClient,
 } from '@sentry/core';
-import {
-  type AsyncLocalStorageLookup,
-  getTraceContextForScope,
-  type SentryTracerProvider,
-} from '@sentry/opentelemetry';
+import { type AsyncLocalStorageLookup, type SentryTracerProvider } from '@sentry/opentelemetry';
 import { isMainThread, threadId } from 'worker_threads';
 import { DEBUG_BUILD } from '../debug-build';
 import type { NodeClientOptions } from '../types';
@@ -170,15 +166,4 @@ export class NodeClient extends ServerRuntimeClient<NodeClientOptions> {
     _INTERNAL_clearAiProviderSkips();
     super._setupIntegrations();
   }
-
-  /** Custom implementation for OTEL, so we can handle scope-span linking. */
-  protected _getTraceInfoFromScope(
-    scope: Scope | undefined,
-  ): [dynamicSamplingContext: Partial<DynamicSamplingContext> | undefined, traceContext: TraceContext | undefined] {
-    if (!scope) {
-      return [undefined, undefined];
-    }
-
-    return getTraceContextForScope(this, scope);
-  }
 }

packages/opentelemetry/README.md

@@ -74,7 +74,6 @@ function setupSentry() {
 
   // Initialize the provider
   trace.setGlobalTracerProvider(provider);
-  propagation.setGlobalPropagator(new SentryPropagator());
   context.setGlobalContextManager(new SentryAsyncLocalStorageContextManager());
 
   setOpenTelemetryContextAsyncContextStrategy();

packages/opentelemetry/src/asyncContextStrategy.ts

@@ -13,14 +13,13 @@ import {
   SENTRY_FORK_SET_SCOPE_CONTEXT_KEY,
   SENTRY_TRACE_STATE_CHILD_IGNORED,
 } from './constants';
-import { continueTrace, startInactiveSpan, startNewTrace, startSpan, startSpanManual, withActiveSpan } from './trace';
+import { startInactiveSpan, startSpan, startSpanManual, withActiveSpan } from './trace';
 import type { CurrentScopes } from './types';
 import { getContextFromScope, getScopesFromContext } from './utils/contextData';
 import { getActiveSpan } from './utils/getActiveSpan';
-import { getTraceData } from './utils/getTraceData';
-import { AsyncLocalStorage } from 'node:async_hooks';
 import type { AsyncLocalStorageLookup } from './asyncLocalStorageContextManager';
 import { SentryAsyncLocalStorageContextManager } from './asyncLocalStorageContextManager';
+import { AsyncLocalStorage } from 'node:async_hooks';
 
 /**
  * Sets the async context strategy to use follow the OTEL context under the hood.
@@ -119,9 +118,6 @@ export function setOpenTelemetryContextAsyncContextStrategy(): AsyncLocalStorage
     startSpanManual,
     startInactiveSpan,
     getActiveSpan,
-    getTraceData,
-    continueTrace,
-    startNewTrace,
     // The types here don't fully align, because our own `Span` type is narrower
     // than the OTEL one - but this is OK for here, as we now we'll only have OTEL spans passed around
     withActiveSpan: withActiveSpan,

packages/opentelemetry/src/constants.ts

@@ -5,7 +5,6 @@ export const SENTRY_BAGGAGE_HEADER = 'baggage';
 
 export const SENTRY_TRACE_STATE_DSC = 'sentry.dsc';
 export const SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING = 'sentry.sampled_not_recording';
-export const SENTRY_TRACE_STATE_URL = 'sentry.url';
 
 /**
  *  A flag marking a context as ignored because the span associated with the context

packages/opentelemetry/src/index.ts

@@ -1,7 +1,5 @@
 export { getScopesFromContext } from './utils/contextData';
 
-export { getTraceContextForScope } from './trace';
-
 export { setupEventContextTrace } from './setupEventContextTrace';
 
 export { SentryPropagator } from './propagator';