ref(opentelemetry): Remove enhanceDscWithOpenTelemetryRootSpanName (#22797)

Stacked on top of #22712.

With the span name/source inference reworked in #22712, core's
`getDynamicSamplingContext` now derives the DSC transaction name from
the root span and applies the `url` source guard itself. That makes the
OpenTelemetry-specific `createDsc` handler
`enhanceDscWithOpenTelemetryRootSpanName` redundant — it was only there
to re-derive the name/source via `parseSpanDescription` before core did
so natively.

This removes the util along with its call sites in `@sentry/node`,
`@sentry/vercel-edge`, and the opentelemetry test helper, and drops it
from the package's public exports.

Since the enhancer is a public export of `@sentry/opentelemetry`, its
removal is technically breaking for anyone importing it directly — which
is why this targets the breaking-change branch #22712.

---------

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

Author: mydea

dev-packages/e2e-tests/test-applications/supabase-nextjs/package.json

@@ -7,7 +7,7 @@
     "build": "next build",
     "start": "next start",
     "clean": "npx rimraf node_modules pnpm-lock.yaml .next",
-    "start-local-supabase": "supabase stop --no-backup 2>/dev/null || true && supabase init --force --workdir . && supabase start -o env && supabase db reset",
+    "start-local-supabase": "supabase stop --no-backup 2>/dev/null || true && supabase start -o env && supabase db reset",
     "test:prod": "TEST_ENV=production playwright test",
     "test:build": "pnpm install && pnpm start-local-supabase && pnpm build",
     "test:assert": "pnpm test:prod"

dev-packages/e2e-tests/test-applications/supabase-nextjs/supabase/config.toml

@@ -288,7 +288,7 @@ inspector_port = 8083
 # secret_key = "env(SECRET_VALUE)"
 
 [analytics]
-enabled = true
+enabled = false
 port = 54327
 # Configure one of the supported backends: `postgres`, `bigquery`.
 backend = "postgres"

dev-packages/node-integration-tests/suites/tracing/envelope-header/error-active-span-unsampled/test.ts

@@ -14,6 +14,7 @@ test('envelope header for error event during active unsampled span is correct',
           sample_rate: '0',
           sampled: 'false',
           sample_rand: expect.any(String),
+          transaction: 'test span',
         },
       },
     })

packages/node/src/sdk/index.ts

@@ -15,11 +15,7 @@ import {
   requestDataIntegration,
   stackParserFromStackParserOptions,
 } from '@sentry/core';
-import {
-  enhanceDscWithOpenTelemetryRootSpanName,
-  setOpenTelemetryContextAsyncContextStrategy,
-  setupEventContextTrace,
-} from '@sentry/opentelemetry';
+import { setOpenTelemetryContextAsyncContextStrategy, setupEventContextTrace } from '@sentry/opentelemetry';
 import { isMainThread, parentPort } from 'node:worker_threads';
 import { detectOrchestrionSetup } from '@sentry/server-utils/orchestrion';
 import { registerDiagnosticsChannelInjection } from '@sentry/server-utils/orchestrion/register';
@@ -206,7 +202,6 @@ function _init(
 
   updateScopeFromEnvVariables();
 
-  enhanceDscWithOpenTelemetryRootSpanName(client);
   setupEventContextTrace(client);
 
   // Ensure we flush events when vercel functions are ended

packages/opentelemetry/src/index.ts

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

packages/opentelemetry/src/propagator.ts

@@ -21,11 +21,17 @@ import {
   shouldPropagateTraceForUrl,
   spanToJSON,
 } from '@sentry/core';
-import { SENTRY_BAGGAGE_HEADER, SENTRY_TRACE_HEADER, SENTRY_TRACE_STATE_URL } from './constants';
+import {
+  SENTRY_BAGGAGE_HEADER,
+  SENTRY_TRACE_HEADER,
+  SENTRY_TRACE_STATE_DSC,
+  SENTRY_TRACE_STATE_URL,
+} from './constants';
 import { DEBUG_BUILD } from './debug-build';
 import { getScopesFromContext, setScopesOnContext } from './utils/contextData';
 import { getSampledForPropagation, getSamplingDecision } from './utils/getSamplingDecision';
 import { makeTraceState } from './utils/makeTraceState';
+import { reconcileDscSampled } from './utils/reconcileDscSampled';
 
 /**
  * Injects and extracts `sentry-trace` and `baggage` headers from carriers.
@@ -149,13 +155,22 @@ export function getInjectionData(
   // Instead, we use a virtual (generated) spanId for propagation
   if (span?.spanContext().isRemote) {
     const spanContext = span.spanContext();
-    const dynamicSamplingContext = getDynamicSamplingContextFromSpan(span);
+    const sampled = getSamplingDecision(spanContext);
+    const dsc = getDynamicSamplingContextFromSpan(span);
+
+    // When the incoming trace froze its DSC on the trace state, `getDynamicSamplingContextFromSpan`
+    // returns that DSC verbatim; per the propagation spec it is immutable, so we must not rewrite
+    // `sampled` or strip `transaction` on it. We only reconcile the DSC that core freshly derives
+    // from the (binary) span trace flags, which is the sole case that can misrepresent a deferred
+    // decision as unsampled.
+    const hasIncomingFrozenDsc = !!spanContext.traceState?.get(SENTRY_TRACE_STATE_DSC);
+    const dynamicSamplingContext = hasIncomingFrozenDsc ? dsc : reconcileDscSampled(dsc, sampled);
 
     return {
       dynamicSamplingContext,
       traceId: spanContext.traceId,
       spanId: undefined,
-      sampled: getSamplingDecision(spanContext), // TODO: Do we need to change something here?
+      sampled,
     };
   }
 

packages/opentelemetry/src/trace.ts

@@ -26,11 +26,13 @@ import {
   spanToJSON,
   spanToTraceContext,
 } from '@sentry/core';
+import { SENTRY_TRACE_STATE_DSC } from './constants';
 import { continueTraceAsRemoteSpan } from './propagator';
 import type { OpenTelemetrySpanContext } from './types';
 import { getContextFromScope } from './utils/contextData';
 import { getSamplingDecision } from './utils/getSamplingDecision';
 import { makeTraceState } from './utils/makeTraceState';
+import { reconcileDscSampled } from './utils/reconcileDscSampled';
 
 /**
  * Internal helper for starting spans and manual spans. See {@link startSpan} and {@link startSpanManual} for the public APIs.
@@ -257,7 +259,15 @@ function getContext(scope: Scope | undefined, forceTransaction: boolean | undefi
   // In this case, when we are forcing a transaction, we want to treat this like continuing an incoming trace
   // so we set the traceState according to the root span
   const rootSpan = getRootSpan(parentSpan);
-  const dsc = getDynamicSamplingContextFromSpan(rootSpan);
+  const rawDsc = getDynamicSamplingContextFromSpan(rootSpan);
+
+  // When the root carried a frozen incoming DSC on its trace state, `getDynamicSamplingContextFromSpan`
+  // returns it verbatim and it is immutable per the propagation spec. Otherwise core freshly derived the
+  // DSC from the root's (binary) trace flags, which cannot tell a deferred decision apart from a
+  // definitive unsampled one — reconcile `sampled` against the authoritative OTel decision so a deferred
+  // parent (e.g. a `startNewTrace` remote parent with `traceFlags: NONE`) does not bake in `sampled=false`.
+  const hasIncomingFrozenDsc = !!rootSpan.spanContext().traceState?.get(SENTRY_TRACE_STATE_DSC);
+  const dsc = hasIncomingFrozenDsc ? rawDsc : reconcileDscSampled(rawDsc, sampled);
 
   const traceState = makeTraceState({
     dsc,

packages/opentelemetry/src/utils/enhanceDscWithOpenTelemetryRootSpanName.ts

@@ -0,0 +1,30 @@
+import type { DynamicSamplingContext } from '@sentry/core';
+
+/**
+ * Reconcile a freshly-derived DSC's `sampled` flag with the OTel sampling decision.
+ *
+ * Only applies to a DSC that core generated from the span's (binary) trace flags — never to a frozen
+ * incoming DSC from the trace state, which the caller leaves untouched per the propagation spec.
+ * Trace flags cannot tell a *deferred* decision (an incoming remote span whose decision lives in the
+ * trace state) apart from a definitive *unsampled* one — both read as `traceFlags: NONE`.
+ * `getSamplingDecision` resolves this via the OTel trace state, so we let it win here: drop `sampled`
+ * when the decision is deferred (`undefined`), and — matching the OTel SDK, whose unsampled spans are
+ * nameless non-recording spans — drop the transaction name when the trace is definitively unsampled.
+ */
+export function reconcileDscSampled(
+  dsc: Partial<DynamicSamplingContext>,
+  sampled: boolean | undefined,
+): Partial<DynamicSamplingContext> {
+  const reconciled = { ...dsc };
+
+  if (sampled === undefined) {
+    delete reconciled.sampled;
+  } else {
+    reconciled.sampled = String(sampled);
+    if (sampled === false) {
+      delete reconciled.transaction;
+    }
+  }
+
+  return reconciled;
+}

packages/opentelemetry/src/utils/reconcileDscSampled.ts

@@ -4,7 +4,6 @@ import { DEBUG_BUILD } from '../../src/debug-build';
 import { SentryPropagator } from '../../src/propagator';
 import { getSentryResource } from '../../src/resource';
 import { setupEventContextTrace } from '../../src/setupEventContextTrace';
-import { enhanceDscWithOpenTelemetryRootSpanName } from '../../src/utils/enhanceDscWithOpenTelemetryRootSpanName';
 import type { TestClient } from './TestClient';
 import { SentryTracerProvider } from '../../src/tracerProvider';
 
@@ -38,7 +37,6 @@ export function initOtel(): void {
   }
 
   setupEventContextTrace(client);
-  enhanceDscWithOpenTelemetryRootSpanName(client);
 
   const provider = new SentryTracerProvider({ resource: getSentryResource('node') });