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

## Summary

- Add OTel-aware `startNewTrace` implementation that injects the new
traceId as a remote span context into the OTel context
- Add `startNewTrace` to the `AsyncContextStrategy` interface so OTel
can override the default behavior
- Register the new implementation in the OTel async context strategy

### Root Cause

`startNewTrace` set a new `traceId` on the Sentry scope's propagation
context but only called `withActiveSpan(null, callback)`, which in OTel
translates to `trace.deleteSpan(context.active())`. This removed the
active span but did **not** inject the new traceId into the OTel
context. Each subsequent `startInactiveSpan` call created a root span
with a fresh random traceId from OTel's tracer.

The fix follows the same pattern as `continueTrace` — injecting the
traceId as a remote span context via `trace.setSpanContext()` so all
spans in the callback inherit it.

Closes #19952

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: logaretm

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;
 }