fix(node): Ensure startNewTrace propagates traceId in OTel environments

packages/core/src/asyncContext/types.ts

@@ -3,6 +3,7 @@ import type { getTraceData } from '../utils/traceData';
 import type {
  continueTrace,
  startInactiveSpan,
+ startNewTrace,
  startSpan,
  startSpanManual,
  suppressTracing,
@@ -76,4 +77,7 @@ export interface AsyncContextStrategy {
  * and `<meta name="baggage">` HTML tags.
  */
  continueTrace?: typeof continueTrace;
+
+ /** Start a new trace, ensuring all spans in the callback share the same traceId. */
+ startNewTrace?: typeof startNewTrace;
 }

packages/core/src/tracing/trace.ts

@@ -291,6 +291,11 @@ export function suppressTracing<T>(callback: () => T): T {
  * or page will automatically create a new trace.
  */
 export function startNewTrace<T>(callback: () => T): T {
+ const acs = getAcs();
+ if (acs.startNewTrace) {
+ return acs.startNewTrace(callback);
+ }
+
  return withScope(scope => {
  scope.setPropagationContext({
  traceId: generateTraceId(),

packages/opentelemetry/src/asyncContextStrategy.ts

@@ -6,7 +6,7 @@ import {
  SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY,
  SENTRY_FORK_SET_SCOPE_CONTEXT_KEY,
 } from './constants';
-import { continueTrace, startInactiveSpan, startSpan, startSpanManual, withActiveSpan } from './trace';
+import { continueTrace, startInactiveSpan, startNewTrace, startSpan, startSpanManual, withActiveSpan } from './trace';
 import type { CurrentScopes } from './types';
 import { getContextFromScope, getScopesFromContext } from './utils/contextData';
 import { getActiveSpan } from './utils/getActiveSpan';
@@ -104,6 +104,7 @@ export function setOpenTelemetryContextAsyncContextStrategy(): void {
  suppressTracing,
  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 as typeof defaultWithActiveSpan,

packages/opentelemetry/src/trace.ts

@@ -10,6 +10,9 @@ import type {
  TraceContext,
 } from '@sentry/core';
 import {
+ _INTERNAL_safeMathRandom,
+ generateSpanId,
+ generateTraceId,
  getClient,
  getCurrentScope,
  getDynamicSamplingContextFromScope,
@@ -291,6 +294,36 @@ export function continueTrace<T>(options: Parameters<typeof baseContinueTrace>[0
  return continueTraceAsRemoteSpan(context.active(), options, callback);
 }
 
+/**
+ * Start a new trace with a unique traceId, ensuring all spans created within the callback
+ * share the same traceId.
+ *
+ * This is a custom version of `startNewTrace` for OTEL-powered environments.
+ * It injects the new traceId as a remote span context into the OTEL context, so that
+ * `startInactiveSpan` and `startSpan` pick it up correctly.
+ */
+export function startNewTrace<T>(callback: () => T): T {
+ const traceId = generateTraceId();
+ const spanId = generateSpanId();
+
+ const spanContext: SpanContext = {
+ traceId,
+ spanId,
+ isRemote: true,
+ traceFlags: TraceFlags.NONE,
+ };
+
+ const ctxWithTrace = trace.setSpanContext(context.active(), spanContext);
+
+ return context.with(ctxWithTrace, () => {
+ getCurrentScope().setPropagationContext({
+ traceId,
+ sampleRand: _INTERNAL_safeMathRandom(),
+ });
+ return callback();
+ });
+}
+
 /**
  * Get the trace context for a given scope.
  * We have a custom implementation here because we need an OTEL-specific way to get the span from a scope.

packages/opentelemetry/test/trace.test.ts

@@ -21,7 +21,7 @@ import {
 } from '@sentry/core';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { getParentSpanId } from '../../../packages/opentelemetry/src/utils/getParentSpanId';
-import { continueTrace, startInactiveSpan, startSpan, startSpanManual } from '../src/trace';
+import { continueTrace, startInactiveSpan, startNewTrace, startSpan, startSpanManual } from '../src/trace';
 import type { AbstractSpan } from '../src/types';
 import { getActiveSpan } from '../src/utils/getActiveSpan';
 import { getSamplingDecision } from '../src/utils/getSamplingDecision';
@@ -2093,6 +2093,99 @@ describe('span.end() timestamp conversion', () => {
  });
 });
 
+describe('startNewTrace', () => {
+ beforeEach(() => {
+ mockSdkInit({ tracesSampleRate: 1 });
+ });
+
+ afterEach(async () => {
+ await cleanupOtel();
+ });
+
+ it('sequential startInactiveSpan calls share the same traceId', () => {
+ startNewTrace(() => {
+ const propagationContext = getCurrentScope().getPropagationContext();
+
+ const span1 = startInactiveSpan({ name: 'span-1' });
+ const span2 = startInactiveSpan({ name: 'span-2' });
+ const span3 = startInactiveSpan({ name: 'span-3' });
+
+ const traceId1 = span1.spanContext().traceId;
+ const traceId2 = span2.spanContext().traceId;
+ const traceId3 = span3.spanContext().traceId;
+
+ expect(traceId1).toBe(propagationContext.traceId);
+ expect(traceId2).toBe(propagationContext.traceId);
+ expect(traceId3).toBe(propagationContext.traceId);
+
+ span1.end();
+ span2.end();
+ span3.end();
+ });
+ });
+
+ it('startSpan inside startNewTrace uses the correct traceId', () => {
+ startNewTrace(() => {
+ const propagationContext = getCurrentScope().getPropagationContext();
+
+ startSpan({ name: 'parent-span' }, parentSpan => {
+ const parentTraceId = parentSpan.spanContext().traceId;
+ expect(parentTraceId).toBe(propagationContext.traceId);
+
+ const child = startInactiveSpan({ name: 'child-span' });
+ expect(child.spanContext().traceId).toBe(propagationContext.traceId);
+ child.end();
+ });
+ });
+ });
+
+ it('generates a different traceId than the outer trace', () => {
+ startSpan({ name: 'outer-span' }, outerSpan => {
+ const outerTraceId = outerSpan.spanContext().traceId;
+
+ startNewTrace(() => {
+ const innerSpan = startInactiveSpan({ name: 'inner-span' });
+ const innerTraceId = innerSpan.spanContext().traceId;
+
+ expect(innerTraceId).not.toBe(outerTraceId);
+
+ const propagationContext = getCurrentScope().getPropagationContext();
+ expect(innerTraceId).toBe(propagationContext.traceId);
+
+ innerSpan.end();
+ });
+ });
+ });
+
+ it('allows spans to be sampled based on tracesSampleRate', () => {
+ startNewTrace(() => {
+ const span = startInactiveSpan({ name: 'sampled-span' });
+ // tracesSampleRate is 1 in mockSdkInit, so spans should be sampled
+ // This verifies that TraceFlags.NONE on the remote span context does not
+ // cause the sampler to inherit a "not sampled" decision from the parent
+ expect(spanIsSampled(span)).toBe(true);
+ span.end();
+ });
+ });
+
+ it('does not leak the new traceId to the outer scope', () => {
+ const outerScope = getCurrentScope();
+ const outerTraceId = outerScope.getPropagationContext().traceId;
+
+ startNewTrace(() => {
+ // Manually set a known traceId on the inner scope to verify it doesn't leak
+ getCurrentScope().setPropagationContext({
+ traceId: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+ sampleRand: 0.5,
+ });
+ });
+
+ const afterTraceId = outerScope.getPropagationContext().traceId;
+ expect(afterTraceId).toBe(outerTraceId);
+ expect(afterTraceId).not.toBe('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
+ });
+});
+
 function getSpanName(span: AbstractSpan): string | undefined {
  return spanHasName(span) ? span.name : undefined;
 }