point ignored child span to its parent

Author: Lms24

packages/core/src/tracing/trace.ts

@@ -407,6 +407,11 @@ function createChildOrRootSpan({
       dropReason: 'ignored',
       traceId: parentSpan?.spanContext().traceId ?? scope.getPropagationContext().traceId,
     });
+    if (parentSpan && !forceTransaction) {
+      // Preserve the root relationship so async context strategies can distinguish
+      // ignored children from ignored segments and keep the parent active.
+      addChildSpanToSpan(parentSpan, ignoredSpan);
+    }
     setCapturedScopesOnSpan(ignoredSpan, scope, isolationScope);
 
     return ignoredSpan;

packages/core/test/lib/tracing/trace.test.ts

@@ -2707,9 +2707,16 @@ describe('ignoreSpans (core path, streaming)', () => {
     client.init();
     const spyOnDroppedEvent = vi.spyOn(client, 'recordDroppedEvent');
 
-    startSpan({ name: 'root' }, () => {
-      startSpan({ name: 'ignored-child' }, span => {
-        expect(span).toBeInstanceOf(SentryNonRecordingSpan);
+    startSpan({ name: 'root' }, rootSpan => {
+      startSpan({ name: 'ignored-child' }, ignoredSpan1 => {
+        expect(ignoredSpan1).toBeInstanceOf(SentryNonRecordingSpan);
+        expect(getRootSpan(ignoredSpan1)).toBe(rootSpan);
+
+        startSpan({ name: 'ignored-child' }, ignoredSpan2 => {
+          expect(ignoredSpan2).toBeInstanceOf(SentryNonRecordingSpan);
+          // since ignoredSpan1 is not active, ignoredSpan2 also has root as its parent
+          expect(getRootSpan(ignoredSpan2)).toBe(rootSpan);
+        });
       });
     });
 

packages/opentelemetry/src/nodeAsyncContextStrategy.ts

@@ -1,7 +1,7 @@
 import * as api from '@opentelemetry/api';
 import { setOpenTelemetryContextAsyncContextStrategy } from './asyncContextStrategy';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { spanIsIgnored, type TracingChannelBinding } from '@sentry/core';
+import { getRootSpan, spanIsIgnored, type TracingChannelBinding } from '@sentry/core';
 import { SENTRY_TRACE_STATE_CHILD_IGNORED } from './constants';
 
 interface ContextApi {
@@ -62,12 +62,11 @@ function getCustomAsyncLocalStorageFactory(): () => TracingChannelBinding | unde
 
 function getStoreWithActiveSpan(span: Parameters<TracingChannelBinding['getStoreWithActiveSpan']>[0]): api.Context {
   const activeContext = api.context.active();
-  const activeSpan = api.trace.getSpan(activeContext);
 
   // Tracing channels bind directly to the context manager's AsyncLocalStorage and bypass
   // SentryContextManager.with(), so ignored children must restore their parent here as well.
   const isIgnoredChild =
-    (!!activeSpan && spanIsIgnored(span)) ||
+    (spanIsIgnored(span) && getRootSpan(span) !== span) ||
     span.spanContext().traceState?.get(SENTRY_TRACE_STATE_CHILD_IGNORED) === '1';
 
   return isIgnoredChild ? activeContext : api.trace.setSpan(activeContext, span);

packages/opentelemetry/test/asyncContextStrategy.test.ts

@@ -2,6 +2,7 @@ import { context, trace, TraceFlags, type Context } from '@opentelemetry/api';
 import type { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
 import type { Scope } from '@sentry/core';
 import {
+  addChildSpanToSpan,
   getAsyncContextStrategy,
   getCurrentScope,
   getIsolationScope,
@@ -118,6 +119,7 @@ describe('asyncContextStrategy', () => {
       dropReason: 'ignored',
       traceId: parentSpan.spanContext().traceId,
     });
+    addChildSpanToSpan(parentSpan, ignoredSpan);
 
     context.with(trace.setSpan(context.active(), parentSpan), () => {
       const binding = getAsyncContextStrategy(getMainCarrier()).getTracingChannelBinding?.();
@@ -130,18 +132,28 @@ describe('asyncContextStrategy', () => {
     parentSpan.end();
   });
 
-  test('tracing channel binding activates a native ignored root span', () => {
+  test('tracing channel binding activates a native ignored root span with a remote parent', () => {
     setNodeOpenTelemetryContextAsyncContextStrategy();
 
+    const traceId = '12345678901234567890123456789012';
+    const remoteParent = trace.wrapSpanContext({
+      traceId,
+      spanId: '1234567890123456',
+      traceFlags: TraceFlags.SAMPLED,
+      isRemote: true,
+    });
     const ignoredSpan = new SentryNonRecordingSpan({
       dropReason: 'ignored',
-      traceId: '12345678901234567890123456789012',
+      traceId,
     });
-    const binding = getAsyncContextStrategy(getMainCarrier()).getTracingChannelBinding?.();
-    const store = binding?.getStoreWithActiveSpan(ignoredSpan);
 
-    expect(store).toBeDefined();
-    expect(trace.getSpan(store as Context)).toBe(ignoredSpan);
+    context.with(trace.setSpan(context.active(), remoteParent), () => {
+      const binding = getAsyncContextStrategy(getMainCarrier()).getTracingChannelBinding?.();
+      const store = binding?.getStoreWithActiveSpan(ignoredSpan);
+
+      expect(store).toBeDefined();
+      expect(trace.getSpan(store as Context)).toBe(ignoredSpan);
+    });
   });
 
   test('async scope inheritance', async () => {