feat(opentelemetry)!: Simplify propagation and remove custom OTel tracing utils

MIGRATION.md

@@ -479,7 +479,7 @@ Sentry.init({
 
 ### `@sentry/opentelemetry`
 
-- `SentryPropagator` was removed. It is no longer needed now that Sentry does not manage OpenTelemetry trace propagation by default.
+- `getTraceContextForScope` was removed. Scope-to-trace-context resolution now goes through the shared core implementation.
 - `OpenTelemetryServerRuntimeOptions` was removed.
 - The `@opentelemetry/core` peer dependency was removed; its APIs are now vendored internally.
 - OpenTelemetry resources are no longer collected, and `contexts.otel.resource` was dropped from events.

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

@@ -18,11 +18,10 @@ 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';
@@ -144,9 +143,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';

MIGRATION.md

@@ -479,7 +479,7 @@ Sentry.init({
 
 ### `@sentry/opentelemetry`
 
-- `SentryPropagator` was removed. It is no longer needed now that Sentry does not manage OpenTelemetry trace propagation by default.
+- `getTraceContextForScope` was removed. Scope-to-trace-context resolution now goes through the shared core implementation.
 - `OpenTelemetryServerRuntimeOptions` was removed.
 - The `@opentelemetry/core` peer dependency was removed; its APIs are now vendored internally.
 - OpenTelemetry resources are no longer collected, and `contexts.otel.resource` was dropped from events.

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

@@ -18,11 +18,10 @@ 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';
@@ -144,9 +143,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';

MIGRATION.md

@@ -479,7 +479,7 @@ Sentry.init({
 
 ### `@sentry/opentelemetry`
 
-- `SentryPropagator` was removed. It is no longer needed now that Sentry does not manage OpenTelemetry trace propagation by default.
+- `getTraceContextForScope` was removed. Scope-to-trace-context resolution now goes through the shared core implementation.
 - `OpenTelemetryServerRuntimeOptions` was removed.
 - The `@opentelemetry/core` peer dependency was removed; its APIs are now vendored internally.
 - OpenTelemetry resources are no longer collected, and `contexts.otel.resource` was dropped from events.

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

@@ -18,11 +18,10 @@ 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';
@@ -144,9 +143,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';

MIGRATION.md

@@ -479,7 +479,7 @@ Sentry.init({
 
 ### `@sentry/opentelemetry`
 
-- `SentryPropagator` was removed. It is no longer needed now that Sentry does not manage OpenTelemetry trace propagation by default.
+- `getTraceContextForScope` was removed. Scope-to-trace-context resolution now goes through the shared core implementation.
 - `OpenTelemetryServerRuntimeOptions` was removed.
 - The `@opentelemetry/core` peer dependency was removed; its APIs are now vendored internally.
 - OpenTelemetry resources are no longer collected, and `contexts.otel.resource` was dropped from events.

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

@@ -18,11 +18,10 @@ 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';
@@ -144,9 +143,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';

MIGRATION.md

@@ -479,7 +479,7 @@ Sentry.init({
 
 ### `@sentry/opentelemetry`
 
-- `SentryPropagator` was removed. It is no longer needed now that Sentry does not manage OpenTelemetry trace propagation by default.
+- `getTraceContextForScope` was removed. Scope-to-trace-context resolution now goes through the shared core implementation.
 - `OpenTelemetryServerRuntimeOptions` was removed.
 - The `@opentelemetry/core` peer dependency was removed; its APIs are now vendored internally.
 - OpenTelemetry resources are no longer collected, and `contexts.otel.resource` was dropped from events.

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

@@ -18,11 +18,10 @@ 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';
@@ -144,9 +143,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';

MIGRATION.md

@@ -479,7 +479,7 @@ Sentry.init({
 
 ### `@sentry/opentelemetry`
 
-- `SentryPropagator` was removed. It is no longer needed now that Sentry does not manage OpenTelemetry trace propagation by default.
+- `getTraceContextForScope` was removed. Scope-to-trace-context resolution now goes through the shared core implementation.
 - `OpenTelemetryServerRuntimeOptions` was removed.
 - The `@opentelemetry/core` peer dependency was removed; its APIs are now vendored internally.
 - OpenTelemetry resources are no longer collected, and `contexts.otel.resource` was dropped from events.

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

@@ -18,11 +18,10 @@ 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';
@@ -144,9 +143,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';

MIGRATION.md

@@ -479,7 +479,7 @@ Sentry.init({
 
 ### `@sentry/opentelemetry`
 
-- `SentryPropagator` was removed. It is no longer needed now that Sentry does not manage OpenTelemetry trace propagation by default.
+- `getTraceContextForScope` was removed. Scope-to-trace-context resolution now goes through the shared core implementation.
 - `OpenTelemetryServerRuntimeOptions` was removed.
 - The `@opentelemetry/core` peer dependency was removed; its APIs are now vendored internally.
 - OpenTelemetry resources are no longer collected, and `contexts.otel.resource` was dropped from events.

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

@@ -18,11 +18,10 @@ 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';
@@ -144,9 +143,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';

MIGRATION.md

@@ -479,7 +479,7 @@ Sentry.init({
 
 ### `@sentry/opentelemetry`
 
-- `SentryPropagator` was removed. It is no longer needed now that Sentry does not manage OpenTelemetry trace propagation by default.
+- `getTraceContextForScope` was removed. Scope-to-trace-context resolution now goes through the shared core implementation.
 - `OpenTelemetryServerRuntimeOptions` was removed.
 - The `@opentelemetry/core` peer dependency was removed; its APIs are now vendored internally.
 - OpenTelemetry resources are no longer collected, and `contexts.otel.resource` was dropped from events.

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

@@ -18,11 +18,10 @@ 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';
@@ -144,9 +143,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';