Preserve continued trace DSC for onlyIfParent placeholders

Author: andreiborza

packages/core/src/tracing/dynamicSamplingContext.ts

@@ -107,7 +107,7 @@ export function getDynamicSamplingContextFromSpan(span: Span): Readonly<Partial<
   }
 
   // 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
+  // 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)) {
     const capturedScope = getCapturedScopesOnSpan(rootSpan).scope;

packages/core/src/tracing/trace.ts

@@ -71,18 +71,14 @@ export function startSpan<T>(options: StartSpanOptions, callback: (span: Span) =
 
       const missingRequiredParent = options.onlyIfParent && !parentSpan;
       const activeSpan = missingRequiredParent
-        ? new SentryNonRecordingSpan({ traceId: scope.getPropagationContext().traceId })
+        ? startMissingRequiredParentSpan(scope, client)
         : createChildOrRootSpan({
             parentSpan,
             spanArguments,
             forceTransaction,
             scope,
           });
 
-      if (missingRequiredParent) {
-        client?.recordDroppedEvent('no_parent_span', 'span');
-      }
-
       // Ignored root spans still need to be set on scope so that `getActiveSpan()` returns them
       // and descendants are also non-recording. Ignored child spans don't need this because
       // the parent span is already on scope.
@@ -138,18 +134,14 @@ export function startSpanManual<T>(options: StartSpanOptions, callback: (span: S
 
       const missingRequiredParent = options.onlyIfParent && !parentSpan;
       const activeSpan = missingRequiredParent
-        ? new SentryNonRecordingSpan({ traceId: scope.getPropagationContext().traceId })
+        ? startMissingRequiredParentSpan(scope, getClient())
         : createChildOrRootSpan({
             parentSpan,
             spanArguments,
             forceTransaction,
             scope,
           });
 
-      if (missingRequiredParent) {
-        getClient()?.recordDroppedEvent('no_parent_span', 'span');
-      }
-
       // We don't set ignored child spans onto the scope because there likely is an active,
       // unignored span on the scope already.
       if (!_isIgnoredSpan(activeSpan) || !parentSpan) {
@@ -208,8 +200,7 @@ export function startInactiveSpan(options: StartSpanOptions): Span {
     const missingRequiredParent = options.onlyIfParent && !parentSpan;
 
     if (missingRequiredParent) {
-      client?.recordDroppedEvent('no_parent_span', 'span');
-      return new SentryNonRecordingSpan({ traceId: scope.getPropagationContext().traceId });
+      return startMissingRequiredParentSpan(scope, client);
     }
 
     return createChildOrRootSpan({
@@ -332,6 +323,19 @@ export function startNewTrace<T>(callback: () => T): T {
   });
 }
 
+/**
+ * The placeholder returned from `startSpan*` when `onlyIfParent` is set but there is no parent span.
+ * It carries the current trace id and captured scopes so the trace data it propagates (and any nested
+ * span that resolves it as its root via `getRootSpan`) reads its DSC from the scope, preserving a
+ * continued trace's DSC instead of fabricating a fresh client one. Also records the dropped-span outcome.
+ */
+function startMissingRequiredParentSpan(scope: Scope, client: Client | undefined): SentryNonRecordingSpan {
+  client?.recordDroppedEvent('no_parent_span', 'span');
+  const span = new SentryNonRecordingSpan({ traceId: scope.getPropagationContext().traceId });
+  setCapturedScopesOnSpan(span, scope, getIsolationScope());
+  return span;
+}
+
 function createChildOrRootSpan({
   parentSpan,
   spanArguments,

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

@@ -181,6 +181,38 @@ describe('getTraceData', () => {
     });
   });
 
+  it('preserves the continued-trace DSC under (and nested within) an onlyIfParent placeholder', () => {
+    // The placeholder captures the scope, so it (and any nested span that resolves it as its root
+    // via `getRootSpan`) reads the continued trace's DSC from the scope instead of fabricating a
+    // fresh client one.
+    setupClient({ tracesSampleRate: undefined });
+
+    getCurrentScope().setPropagationContext({
+      traceId: '12345678901234567890123456789012',
+      sampleRand: 0.42,
+      sampled: true,
+      dsc: {
+        environment: 'production',
+        public_key: '123',
+        trace_id: '12345678901234567890123456789012',
+        sampled: 'true',
+        sample_rate: '0.5',
+        transaction: 'continued-root-txn',
+      },
+    });
+
+    startSpan({ name: 'parent', onlyIfParent: true }, () => {
+      expect(getTraceData().baggage).toContain('sentry-transaction=continued-root-txn');
+
+      startSpan({ name: 'nested' }, () => {
+        const baggage = getTraceData().baggage;
+        expect(baggage).toContain('sentry-transaction=continued-root-txn');
+        expect(baggage).toContain('sentry-sample_rate=0.5');
+        expect(baggage).toContain('sentry-sampled=true');
+      });
+    });
+  });
+
   it('keeps an explicit negative sampling decision for an active unsampled span', () => {
     setupClient({ tracesSampleRate: 0 });