fix(core): Preserve propagation across ignored spans (#22277)

This PR preserves trace propagation for ignored spans in span streaming
mode:
- When segment spans are ignored, incoming DSC (via baggage) is kept
as-is, but is mutated to carry a negative sampling decision, in line
with the `sentry-trace` header, which already emitted a negative
sampling decision
- ignored child and HTTP client spans propagate from the nearest emitted
parent across fetch, `node:http`
- For Orchestrion/tracing-channel-based instrumentation, we only set a
child span as the active span if it is not ignored. This was already
implemented in the OTel context manager previously but probably didn't
get ported correctly to the new approach.
 
Turns out, the DSC changes are also a requirement for #22246, so I threw
it on top of this PR.

ref #22262

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>

Author: Lms24

dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/instrument.mjs

@@ -0,0 +1,12 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracesSampleRate: 0,
+  transport: loggingTransport,
+  traceLifecycle: 'stream',
+  ignoreSpans: ['ignoredMiddleware'],
+  tracePropagationTargets: [process.env.SERVER_URL],
+  clientReportFlushInterval: 1_000,
+});

dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/server.mjs

@@ -0,0 +1,34 @@
+import * as Sentry from '@sentry/node';
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import express from 'express';
+import * as http from 'http';
+
+const app = express();
+
+app.use(async function ignoredMiddleware(req, _res, next) {
+  if (req.path === '/ignored-child-http') {
+    await makeHttpRequest(`${process.env.SERVER_URL}/outgoing`);
+  } else {
+    await fetch(`${process.env.SERVER_URL}/outgoing`);
+  }
+  next();
+});
+
+app.get(['/ignored-child', '/ignored-child-http'], (_req, res) => {
+  res.send({ status: 'ok' });
+  setTimeout(() => {
+    Sentry.flush();
+  });
+});
+
+startExpressServerAndSendPortToRunner(app);
+
+function makeHttpRequest(url) {
+  return new Promise((resolve, reject) => {
+    const request = http.get(url, httpRes => {
+      httpRes.resume();
+      httpRes.on('end', resolve);
+    });
+    request.on('error', reject);
+  });
+}

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

@@ -0,0 +1,63 @@
+import { createTestServer } from '@sentry-internal/test-utils';
+import { afterAll, describe, expect } from 'vitest';
+import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
+import { SENTRY_OP } from '@sentry/conventions/attributes';
+
+describe('ignoring a child of a continued server segment (streaming)', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  createEsmAndCjsTests(__dirname, 'server.mjs', 'instrument.mjs', (createRunner, test) => {
+    const testPropagation = async (path: string): Promise<void> => {
+      const [SERVER_URL, closeTestServer] = await createTestServer()
+        .get('/outgoing', headers => {
+          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',
+          );
+        })
+        .start();
+      const runner = createRunner()
+        .withEnv({ SERVER_URL })
+        .unignore('client_report')
+        .expect({
+          client_report: {
+            discarded_events: [{ category: 'span', quantity: 1, reason: 'ignored' }],
+          },
+        })
+        .expect({
+          span: container => {
+            const httpServerSpan = container.items.find(item => item.attributes[SENTRY_OP]?.value === 'http.server');
+
+            expect(httpServerSpan?.is_segment).toBe(true);
+            expect(httpServerSpan?.trace_id).toBe('12345678901234567890123456789012');
+            expect(container.items.some(item => item.name === 'ignoredMiddleware')).toBe(false);
+          },
+        })
+        .start();
+
+      try {
+        const response = await runner.makeRequest<{ status: string }>('get', path, {
+          headers: {
+            'sentry-trace': '12345678901234567890123456789012-1234567890123456-1',
+            baggage:
+              'sentry-trace_id=12345678901234567890123456789012,sentry-sample_rate=1,sentry-sampled=true,sentry-public_key=public,sentry-sample_rand=0.5',
+          },
+        });
+
+        expect(response?.status).toBe('ok');
+        await runner.completed();
+      } finally {
+        closeTestServer();
+      }
+    };
+
+    test('preserves the positive sampling decision on outgoing fetch requests', () =>
+      testPropagation('/ignored-child'));
+
+    test('preserves the positive sampling decision on outgoing node:http requests', () =>
+      testPropagation('/ignored-child-http'));
+  });
+});

dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/instrument.mjs

@@ -0,0 +1,12 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracesSampleRate: 0,
+  transport: loggingTransport,
+  traceLifecycle: 'stream',
+  ignoreSpans: [{ attributes: { 'url.path': '/outgoing' } }],
+  tracePropagationTargets: [process.env.SERVER_URL],
+  clientReportFlushInterval: 1_000,
+});

dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/server.mjs

@@ -0,0 +1,34 @@
+import * as Sentry from '@sentry/node';
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import express from 'express';
+import * as http from 'http';
+
+const app = express();
+
+app.get('/ignored-http-client', async (_req, res) => {
+  await fetch(`${process.env.SERVER_URL}/outgoing`);
+  res.send({ status: 'ok' });
+  setTimeout(() => {
+    Sentry.flush();
+  });
+});
+
+app.get('/ignored-node-http-client', async (_req, res) => {
+  await makeHttpRequest(`${process.env.SERVER_URL}/outgoing`);
+  res.send({ status: 'ok' });
+  setTimeout(() => {
+    Sentry.flush();
+  });
+});
+
+startExpressServerAndSendPortToRunner(app);
+
+function makeHttpRequest(url) {
+  return new Promise((resolve, reject) => {
+    const request = http.get(url, httpRes => {
+      httpRes.resume();
+      httpRes.on('end', resolve);
+    });
+    request.on('error', reject);
+  });
+}

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

@@ -0,0 +1,67 @@
+import { createTestServer } from '@sentry-internal/test-utils';
+import { afterAll, describe, expect } from 'vitest';
+import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
+import { SENTRY_OP } from '@sentry/conventions/attributes';
+
+describe('ignoring an HTTP client child of a continued server segment (streaming)', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  createEsmAndCjsTests(__dirname, 'server.mjs', 'instrument.mjs', (createRunner, test) => {
+    const testPropagation = async (path: string): Promise<void> => {
+      const [SERVER_URL, closeTestServer] = await createTestServer()
+        .get('/outgoing', headers => {
+          expect
+            .soft(headers['sentry-trace'])
+            .toEqual(expect.stringMatching(/^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',
+          );
+        })
+        .start();
+
+      const runner = createRunner()
+        .withEnv({ SERVER_URL })
+        .unignore('client_report')
+        .expect({
+          client_report: {
+            discarded_events: [{ category: 'span', quantity: 1, reason: 'ignored' }],
+          },
+        })
+        .expect({
+          span: container => {
+            const httpServerSpan = container.items.find(item => item.attributes[SENTRY_OP]?.value === 'http.server');
+
+            expect(httpServerSpan?.is_segment).toBe(true);
+            expect(httpServerSpan?.trace_id).toBe('12345678901234567890123456789012');
+
+            expect(container.items.some(item => item.attributes[SENTRY_OP]?.value === 'http.client')).toBe(false);
+          },
+        })
+        .start();
+
+      try {
+        const response = await runner.makeRequest<{ status: string }>('get', path, {
+          headers: {
+            'sentry-trace': '12345678901234567890123456789012-1234567890123456-1',
+            baggage:
+              'sentry-trace_id=12345678901234567890123456789012,sentry-sample_rate=1,sentry-sampled=true,sentry-public_key=public,sentry-sample_rand=0.5',
+          },
+        });
+
+        expect(response?.status).toBe('ok');
+        await runner.completed();
+      } finally {
+        closeTestServer();
+      }
+    };
+
+    test('preserves the positive sampling decision on the outgoing fetch request', () =>
+      testPropagation('/ignored-http-client'));
+
+    test('preserves the positive sampling decision on the outgoing node:http request', () =>
+      testPropagation('/ignored-node-http-client'));
+  });
+});

dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/instrument.mjs

@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/node';
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  tracesSampleRate: 0,
+  transport: loggingTransport,
+  traceLifecycle: 'stream',
+  ignoreSpans: [{ op: 'http.server' }],
+  tracePropagationTargets: [process.env.SERVER_URL],
+});

dev-packages/node-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/server.mjs

@@ -0,0 +1,27 @@
+import { startExpressServerAndSendPortToRunner } from '@sentry-internal/node-integration-tests';
+import express from 'express';
+import * as http from 'http';
+
+const app = express();
+
+app.get('/ignored', async (_req, res) => {
+  await fetch(`${process.env.SERVER_URL}/outgoing`);
+  res.send({ status: 'ok' });
+});
+
+app.get('/ignored-http', async (_req, res) => {
+  await makeHttpRequest(`${process.env.SERVER_URL}/outgoing`);
+  res.send({ status: 'ok' });
+});
+
+startExpressServerAndSendPortToRunner(app);
+
+function makeHttpRequest(url) {
+  return new Promise((resolve, reject) => {
+    const request = http.get(url, httpRes => {
+      httpRes.resume();
+      httpRes.on('end', resolve);
+    });
+    request.on('error', reject);
+  });
+}

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

@@ -0,0 +1,46 @@
+import { createTestServer } from '@sentry-internal/test-utils';
+import { afterAll, describe, expect } from 'vitest';
+import { cleanupChildProcesses, createEsmAndCjsTests } from '../../../../utils/runner';
+
+describe('ignoring a continued server segment (streaming)', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  createEsmAndCjsTests(__dirname, 'server.mjs', 'instrument.mjs', (createRunner, test) => {
+    const testPropagation = async (path: string): Promise<void> => {
+      expect.assertions(3);
+
+      const [SERVER_URL, closeTestServer] = await createTestServer()
+        .get('/outgoing', headers => {
+          const sentryTrace = headers['sentry-trace'];
+          const baggage = headers['baggage'];
+
+          expect(sentryTrace).toMatch(/12345678901234567890123456789012-[\da-f]{16}-0/);
+          expect(baggage).toBe(
+            'sentry-trace_id=12345678901234567890123456789012,sentry-sample_rate=1,sentry-sampled=false,sentry-public_key=public,sentry-sample_rand=0.5',
+          );
+        })
+        .start();
+      const runner = createRunner().withEnv({ SERVER_URL }).start();
+
+      try {
+        const response = await runner.makeRequest<{ status: string }>('get', path, {
+          headers: {
+            'sentry-trace': '12345678901234567890123456789012-1234567890123456-1',
+            baggage:
+              'sentry-trace_id=12345678901234567890123456789012,sentry-sample_rate=1,sentry-sampled=true,sentry-public_key=public,sentry-sample_rand=0.5',
+          },
+        });
+
+        expect(response?.status).toBe('ok');
+      } finally {
+        closeTestServer();
+      }
+    };
+
+    test('propagates a negative sampling decision to outgoing fetch requests', () => testPropagation('/ignored'));
+    test('propagates a negative sampling decision to outgoing node:http requests', () =>
+      testPropagation('/ignored-http'));
+  });
+});

packages/core/src/tracing/dynamicSamplingContext.ts

@@ -107,20 +107,26 @@ export function getDynamicSamplingContextFromSpan(span: Span): Readonly<Partial<
     return applyLocalSampleRateToDsc(frozenDsc);
   }
 
-  // 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.
+  // For a non-recording placeholder in Tracing without Performance (TwP) mode or an ignored segment,
+  // the DSC is not carried on the span; the scope is the source of truth. Resolve it from the span's
+  // captured scope so continued traces keep their incoming DSC.
   //
   // 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.
+  // with tracing enabled, other non-recording spans (e.g. an `onlyIfParent` placeholder) keep deriving
+  // their DSC from the span/client. Ignored segments are an explicit exception: they preserve the
+  // incoming DSC but override its sampling decision to agree with the propagated `sentry-trace`.
   //
   // 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 isNonRecordingRoot = spanIsNonRecordingSpan(rootSpan);
+  const isIgnoredRoot = isNonRecordingRoot && rootSpan.dropReason === 'ignored';
+  if (isNonRecordingRoot && (!hasSpansEnabled(client.getOptions()) || isIgnoredRoot)) {
     const capturedScope = getCapturedScopesOnSpan(rootSpan).scope;
     if (capturedScope) {
-      return applyLocalSampleRateToDsc({ ...getDynamicSamplingContextFromScope(client, capturedScope) });
+      const dsc = { ...getDynamicSamplingContextFromScope(client, capturedScope) };
+      if (isIgnoredRoot) {
+        dsc.sampled = 'false';
+      }
+      return applyLocalSampleRateToDsc(dsc);
     }
   }