fix(browser): Propagate trace data from active span if http.client span is non-recording (#22246)

This PR fixes an inconsistency with trace propagation via browser
`http.client` spans: If an `http.client` span was started as a
`NonRecordingSpan` we'd still take it as the span we generate our
tracing headers from (via `getTraceData`). What we should do instead is
to propagate the currently active span, so that span trees from a
downstream service don't become orphaned.

This PR also adds integration tests for 3 scenarios with `ignoreSpans`:
- ignoring a segment span should force a negative sampling decision on
propagation, even if the incoming trace is sampled positively
- ignoring a child span should continue the segment span's sampling
decision on propagation
- akin: ignoring an http.client span should still continue the positive
sampling decision on propagation

ref: #22262

---------

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

Author: Lms24

dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/init.js

@@ -0,0 +1,12 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  ignoreSpans: [/ignored-click-listener/],
+  parentSpanIsAlwaysRootSpan: false,
+  tracePropagationTargets: ['sentry-test-external.io'],
+  tracesSampleRate: 0,
+});

dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/subject.js

@@ -0,0 +1,9 @@
+const fetchButton = document.getElementById('fetch');
+
+fetchButton.addEventListener('click', async () => {
+  await Sentry.startSpan({ name: 'ignored-click-listener', op: 'ui.interaction.click' }, async () => {
+    await fetch('http://sentry-test-external.io');
+  });
+});
+
+fetchButton.click();

dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-child/template.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="sentry-trace" content="12345678901234567890123456789012-1234567890123456-1" />
+    <meta
+      name="baggage"
+      content="sentry-trace_id=12345678901234567890123456789012,sentry-sample_rate=1,sentry-sampled=true,sentry-public_key=public,sentry-sample_rand=0.5"
+    />
+  </head>
+  <body>
+    <button id="fetch">Fetch</button>
+  </body>
+</html>

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

@@ -0,0 +1,46 @@
+import { expect } from '@playwright/test';
+import type { ClientReport } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  hidePage,
+  shouldSkipTracingTest,
+  waitForClientReportRequest,
+  waitForTracingHeadersOnUrl,
+} from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils';
+
+sentryTest(
+  'ignoring a child span preserves the positive sampling decision of a continued trace when propagating it',
+  async ({ getLocalTestUrl, page }) => {
+    sentryTest.skip(shouldSkipTracingTest());
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const clientReportPromise = waitForClientReportRequest(page);
+    const tracingHeadersPromise = waitForTracingHeadersOnUrl(page, 'http://sentry-test-external.io');
+    const spansPromise = waitForStreamedSpans(
+      page,
+      spans =>
+        spans.some(span => getSpanOp(span) === 'pageload') && spans.some(span => getSpanOp(span) === 'http.client'),
+    );
+
+    await page.goto(url);
+
+    const [{ baggage, sentryTrace }, spans] = await Promise.all([tracingHeadersPromise, spansPromise]);
+    const pageloadSpan = spans.find(span => getSpanOp(span) === 'pageload');
+    const httpClientSpan = spans.find(span => getSpanOp(span) === 'http.client');
+
+    expect(pageloadSpan?.is_segment).toBe(true);
+    expect(pageloadSpan?.trace_id).toBe('12345678901234567890123456789012');
+    expect(httpClientSpan?.parent_span_id).toBe(pageloadSpan?.span_id);
+    expect(sentryTrace).toBe(`${pageloadSpan?.trace_id}-${httpClientSpan?.span_id}-1`);
+    expect(baggage).toEqual(
+      'sentry-trace_id=12345678901234567890123456789012,sentry-sample_rate=1,sentry-sampled=true,sentry-public_key=public,sentry-sample_rand=0.5',
+    );
+
+    await hidePage(page);
+    const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
+    expect(clientReport.discarded_events).toEqual([{ category: 'span', quantity: 1, reason: 'ignored' }]);
+  },
+);

dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/init.js

@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  ignoreSpans: [{ attributes: { 'sentry.op': 'http.client' } }],
+  tracePropagationTargets: ['sentry-test-external.io'],
+  tracesSampleRate: 0,
+});

dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/subject.js

@@ -0,0 +1 @@
+setTimeout(() => fetch('http://sentry-test-external.io'));

dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-http-client/template.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="sentry-trace" content="12345678901234567890123456789012-1234567890123456-1" />
+    <meta
+      name="baggage"
+      content="sentry-trace_id=12345678901234567890123456789012,sentry-sample_rate=1,sentry-sampled=true,sentry-public_key=public,sentry-sample_rand=0.5"
+    />
+  </head>
+  <body></body>
+</html>

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

@@ -0,0 +1,37 @@
+import { expect } from '@playwright/test';
+import type { ClientReport } from '@sentry/core';
+import { sentryTest } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  hidePage,
+  shouldSkipTracingTest,
+  waitForClientReportRequest,
+  waitForTracingHeadersOnUrl,
+} from '../../../../utils/helpers';
+import { getSpanOp, waitForStreamedSpan } from '../../../../utils/spanUtils';
+
+sentryTest(
+  'ignoring an outgoing HTTP span preserves the positive sampling decision of a continued trace',
+  async ({ getLocalTestUrl, page }) => {
+    sentryTest.skip(shouldSkipTracingTest());
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    const clientReportPromise = waitForClientReportRequest(page);
+    const tracingHeadersPromise = waitForTracingHeadersOnUrl(page, 'http://sentry-test-external.io');
+    const pageloadSpanPromise = waitForStreamedSpan(page, span => getSpanOp(span) === 'pageload');
+
+    await page.goto(url);
+
+    const [{ baggage, sentryTrace }, pageloadSpan] = await Promise.all([tracingHeadersPromise, pageloadSpanPromise]);
+    expect(pageloadSpan.is_segment).toBe(true);
+    expect(pageloadSpan.trace_id).toBe('12345678901234567890123456789012');
+    expect(sentryTrace).toBe(`12345678901234567890123456789012-${pageloadSpan.span_id}-1`);
+    expect(baggage).toEqual(
+      'sentry-trace_id=12345678901234567890123456789012,sentry-sample_rate=1,sentry-sampled=true,sentry-public_key=public,sentry-sample_rand=0.5',
+    );
+
+    await hidePage(page);
+    const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
+    expect(clientReport.discarded_events).toEqual([{ category: 'span', quantity: 1, reason: 'ignored' }]);
+  },
+);

dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/init.js

@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [Sentry.browserTracingIntegration(), Sentry.spanStreamingIntegration()],
+  ignoreSpans: [{ op: 'pageload' }],
+  tracePropagationTargets: ['sentry-test-external.io'],
+  tracesSampleRate: 0,
+});

dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/continued-trace-segment/subject.js

@@ -0,0 +1,3 @@
+document.getElementById('fetch').addEventListener('click', () => {
+  fetch('http://sentry-test-external.io');
+});