ensure ignoring works on orchestrion async context strategy

Author: Lms24

dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/test.ts

@@ -12,9 +12,7 @@ describe('ignoring a child of a continued server segment (streaming)', () => {
     const testPropagation = async (path: string): Promise<void> => {
       const [SERVER_URL, closeTestServer] = await createTestServer()
         .get('/outgoing', headers => {
-          expect(headers['sentry-trace']).toEqual(
-            expect.stringMatching(/^12345678901234567890123456789012-[\da-f]{16}-1$/),
-          );
+          expect(headers['sentry-trace']).toMatch(/^12345678901234567890123456789012-[\da-f]{16}-1$/);
 
           expect(headers['baggage']).toBe(
             'sentry-trace_id=12345678901234567890123456789012,sentry-sample_rate=1,sentry-sampled=true,sentry-public_key=public,sentry-sample_rand=0.5',

packages/opentelemetry/src/nodeAsyncContextStrategy.ts

@@ -1,7 +1,8 @@
 import * as api from '@opentelemetry/api';
 import { setOpenTelemetryContextAsyncContextStrategy } from './asyncContextStrategy';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import type { TracingChannelBinding } from '@sentry/core';
+import { spanIsIgnored, type TracingChannelBinding } from '@sentry/core';
+import { SENTRY_TRACE_STATE_CHILD_IGNORED } from './constants';
 
 interface ContextApi {
   _getContextManager():
@@ -31,7 +32,7 @@ function getDefaultAsyncLocalStorageFactory(): () => TracingChannelBinding {
   return () => {
     return {
       asyncLocalStorage: defaultAsyncLocalStorage,
-      getStoreWithActiveSpan: span => api.trace.setSpan(api.context.active(), span),
+      getStoreWithActiveSpan,
     } satisfies TracingChannelBinding;
   };
 }
@@ -50,11 +51,24 @@ function getCustomAsyncLocalStorageFactory(): () => TracingChannelBinding | unde
       return asyncLocalStorage
         ? ({
             asyncLocalStorage,
-            getStoreWithActiveSpan: span => api.trace.setSpan(api.context.active(), span as api.Span),
+            getStoreWithActiveSpan,
           } satisfies TracingChannelBinding)
         : undefined;
     } catch {
       return undefined;
     }
   };
 }
+
+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)) ||
+    span.spanContext().traceState?.get(SENTRY_TRACE_STATE_CHILD_IGNORED) === '1';
+
+  return isIgnoredChild ? activeContext : api.trace.setSpan(activeContext, span);
+}

packages/opentelemetry/test/asyncContextStrategy.test.ts

@@ -1,15 +1,22 @@
+import { context, trace, TraceFlags, type Context } from '@opentelemetry/api';
 import type { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
 import type { Scope } from '@sentry/core';
 import {
+  getAsyncContextStrategy,
   getCurrentScope,
   getIsolationScope,
+  getMainCarrier,
   Scope as ScopeClass,
+  SentryNonRecordingSpan,
   setAsyncContextStrategy,
   withIsolationScope,
   withScope,
 } from '@sentry/core';
 import { afterAll, afterEach, beforeEach, describe, expect, it, test } from 'vitest';
 import { setOpenTelemetryContextAsyncContextStrategy } from '../src/asyncContextStrategy';
+import { SENTRY_TRACE_STATE_CHILD_IGNORED } from '../src/constants';
+import { setNodeOpenTelemetryContextAsyncContextStrategy } from '../src/nodeAsyncContextStrategy';
+import { TraceState } from '../src/utils/TraceState';
 import { setupOtel } from './helpers/initOtel';
 import { cleanupOtel } from './helpers/mockSdkInit';
 import { getDefaultTestClientOptions, TestClient } from './helpers/TestClient';
@@ -81,6 +88,62 @@ describe('asyncContextStrategy', () => {
     });
   });
 
+  test('tracing channel binding keeps the parent active for an ignored child span', () => {
+    setNodeOpenTelemetryContextAsyncContextStrategy();
+
+    const parentSpan = trace.getTracer('test').startSpan('parent');
+    const ignoredSpan = trace.wrapSpanContext({
+      traceId: parentSpan.spanContext().traceId,
+      spanId: '1234567890123456',
+      traceFlags: TraceFlags.NONE,
+      traceState: new TraceState().set(SENTRY_TRACE_STATE_CHILD_IGNORED, '1'),
+    });
+
+    context.with(trace.setSpan(context.active(), parentSpan), () => {
+      const binding = getAsyncContextStrategy(getMainCarrier()).getTracingChannelBinding?.();
+      const store = binding?.getStoreWithActiveSpan(ignoredSpan);
+
+      expect(store).toBeDefined();
+      expect(trace.getSpan(store as Context)).toBe(parentSpan);
+    });
+
+    parentSpan.end();
+  });
+
+  test('tracing channel binding keeps the parent active for a native ignored child span', () => {
+    setNodeOpenTelemetryContextAsyncContextStrategy();
+
+    const parentSpan = trace.getTracer('test').startSpan('parent');
+    const ignoredSpan = new SentryNonRecordingSpan({
+      dropReason: 'ignored',
+      traceId: parentSpan.spanContext().traceId,
+    });
+
+    context.with(trace.setSpan(context.active(), parentSpan), () => {
+      const binding = getAsyncContextStrategy(getMainCarrier()).getTracingChannelBinding?.();
+      const store = binding?.getStoreWithActiveSpan(ignoredSpan);
+
+      expect(store).toBeDefined();
+      expect(trace.getSpan(store as Context)).toBe(parentSpan);
+    });
+
+    parentSpan.end();
+  });
+
+  test('tracing channel binding activates a native ignored root span', () => {
+    setNodeOpenTelemetryContextAsyncContextStrategy();
+
+    const ignoredSpan = new SentryNonRecordingSpan({
+      dropReason: 'ignored',
+      traceId: '12345678901234567890123456789012',
+    });
+    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 () => {
     const initialScope = getCurrentScope();
     const initialIsolationScope = getIsolationScope();