Align gating of DSC in getDynamicSamplingContextFromSpan with getTraceData

Author: andreiborza

packages/core/src/tracing/dynamicSamplingContext.ts

@@ -106,13 +106,20 @@ export function getDynamicSamplingContextFromSpan(span: Span): Readonly<Partial<
     return applyLocalSampleRateToDsc(frozenDsc);
   }
 
-  // For a non-recording placeholder (Tracing without Performance), the DSC is not carried on the
-  // span; the scope is the source of truth. Resolve it from the span's captured scope: continued
-  // traces keep the incoming DSC, new traces derive it from the client (without a local transaction).
-  if (spanIsNonRecordingSpan(rootSpan)) {
+  // For a non-recording placeholder in Tracing without Performance (TwP) mode, the DSC is not
+  // carried on the span; the scope is the source of truth. Resolve it from the span's captured
+  // scope: continued traces keep the incoming DSC, new traces derive it from the client.
+  //
+  // We gate this on `!hasSpansEnabled()` so it mirrors the `sentry-trace` source in `getTraceData`:
+  // with tracing enabled, a non-recording span (e.g. an `onlyIfParent` placeholder) keeps deriving
+  // its DSC from the span/client so the baggage agrees with the `-0` decision that `spanToTraceHeader`
+  // encodes for `sentry-trace`. Without this guard the two headers can disagree.
+  //
+  // We spread into a new object so applying the local sample rate can't mutate the scope's DSC.
+  if (spanIsNonRecordingSpan(rootSpan) && !hasSpansEnabled(client.getOptions())) {
     const capturedScope = getCapturedScopesOnSpan(rootSpan).scope;
     if (capturedScope) {
-      return applyLocalSampleRateToDsc(getDynamicSamplingContextFromScope(client, capturedScope));
+      return applyLocalSampleRateToDsc({ ...getDynamicSamplingContextFromScope(client, capturedScope) });
     }
   }
 

packages/core/test/lib/utils/traceData.test.ts

@@ -213,6 +213,37 @@ describe('getTraceData', () => {
     });
   });
 
+  it('does not defer DSC to the scope for an onlyIfParent placeholder in tracing mode', () => {
+    // With tracing enabled, an `onlyIfParent` placeholder without a parent is a non-recording span.
+    // Its `sentry-trace` is read from the span (`-0`), so unlike a TwP placeholder its DSC must not
+    // defer to the scope's continued decision (`sampled=true`) — otherwise the two headers disagree.
+    setupClient({ tracesSampleRate: 1 });
+
+    getCurrentScope().setPropagationContext({
+      traceId: '12345678901234567890123456789012',
+      sampleRand: 0.42,
+      sampled: true,
+      dsc: {
+        environment: 'production',
+        public_key: '123',
+        trace_id: '12345678901234567890123456789012',
+        sampled: 'true',
+        transaction: 'continued-root-txn',
+      },
+    });
+
+    startSpan({ name: 'child', onlyIfParent: true }, () => {
+      const data = getTraceData();
+
+      expect(data['sentry-trace']).toMatch(/^12345678901234567890123456789012-[a-f0-9]{16}-0$/);
+      // The baggage agrees with the `-0` decision instead of carrying the upstream `sampled=true`.
+      expect(data.baggage).toContain('sentry-sampled=false');
+      expect(data.baggage).not.toContain('sentry-sampled=true');
+      expect(data.baggage).not.toContain('sentry-transaction=continued-root-txn');
+      expect(data.baggage).toContain('sentry-trace_id=12345678901234567890123456789012');
+    });
+  });
+
   it('keeps an explicit negative sampling decision for an active unsampled span', () => {
     setupClient({ tracesSampleRate: 0 });