getsentry · Lms24 · Jul 14, 2026 · Jul 15, 2026 · Jul 15, 2026
@@ -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,
+});
@@ -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();
@@ -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>
@@ -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' }]);
+  },
+);
@@ -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,
+});
@@ -0,0 +1 @@
+setTimeout(() => fetch('http://sentry-test-external.io'));
@@ -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>
@@ -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' }]);
+  },
+);
@@ -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,
+});
@@ -0,0 +1,3 @@
+document.getElementById('fetch').addEventListener('click', () => {
+  fetch('http://sentry-test-external.io');
+});
@@ -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>
@@ -0,0 +1,23 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import { shouldSkipTracingTest, waitForTracingHeadersOnUrl } from '../../../../utils/helpers';
+
+sentryTest(
+  'ignoring a trace-continued, positively sampled segment span propagates a negative sampling decision when propagating it',
+  async ({ getLocalTestUrl, page }) => {
+    sentryTest.skip(shouldSkipTracingTest());
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const tracingHeadersPromise = waitForTracingHeadersOnUrl(page, 'http://sentry-test-external.io');
+
+    await page.goto(url);
+    await page.locator('#fetch').click();
+
+    const { baggage, sentryTrace } = await tracingHeadersPromise;
+    expect(sentryTrace).toMatch(/12345678901234567890123456789012-[\da-f]{16}-0/);
+    expect(baggage).toEqual(
+      'sentry-trace_id=12345678901234567890123456789012,sentry-sample_rate=1,sentry-sampled=false,sentry-public_key=public,sentry-sample_rand=0.5',
+    );
+  },
+);
@@ -22,6 +22,7 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SentryNonRecordingSpan,
   setHttpStatus,
+  spanIsIgnored,
   spanToJSON,
   startInactiveSpan,
   stringMatchesSomePattern,
@@ -325,6 +326,7 @@ export function shouldAttachHeaders(
  *
  * @returns Span if a span was created, otherwise void.
  */
+// oxlint-disable-next-line complexity
 function xhrCallback(
   handlerData: HandlerDataXhr,
   shouldCreateSpan: (url: string) => boolean,
@@ -401,6 +403,10 @@ function xhrCallback(
         })
       : new SentryNonRecordingSpan();
 
+  // If the span is ignored, we don't want to continue the trace from it (NonRecordingSpan) but rather
+  // from the active span. Passing `undefined` here will make `getTraceData` use the active span instead.
+  const spanForTraceHeaders = spanIsIgnored(span) && hasParent ? undefined : span;
+
   if (shouldCreateSpanResult && !shouldEmitSpan) {
     client?.recordDroppedEvent('no_parent_span', 'span');
   }
@@ -414,7 +420,7 @@ function xhrCallback(
       // If performance is disabled (TWP) or there's no active root span (pageload/navigation/interaction),
       // we do not want to use the span as base for the trace headers,
       // which means that the headers will be generated from the scope and the sampling decision is deferred
-      hasSpansEnabled() && shouldEmitSpan ? span : undefined,
+      hasSpansEnabled() && shouldEmitSpan ? spanForTraceHeaders : undefined,
       propagateTraceparent,
     );
   }

@@ -16,6 +16,8 @@ class MockClient implements Partial<Client> {
   public getOptions() {
     return {};
   }
+
+  public emit(): void {}
 }
 
 describe('instrumentOutgoingRequests', () => {
@@ -51,6 +53,53 @@ describe('instrumentOutgoingRequests', () => {
 
     expect(addXhrSpy).not.toHaveBeenCalled();
   });
+
+  describe('XHR trace header span', () => {
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('uses the active propagation context for an ignored child span', () => {
+      const activeSpan = new utils.SentryNonRecordingSpan();
+      const ignoredSpan = new utils.SentryNonRecordingSpan({ dropReason: 'ignored' });
+      let xhrHandler: ((data: utils.HandlerDataXhr) => void) | undefined;
+
+      vi.spyOn(browserUtils, 'addXhrInstrumentationHandler').mockImplementation(handler => {
+        xhrHandler = handler;
+      });
+      vi.spyOn(utils, 'getClient').mockReturnValue(client);
+      vi.spyOn(utils, 'getActiveSpan').mockReturnValue(activeSpan);
+      vi.spyOn(utils, 'hasSpansEnabled').mockReturnValue(true);
+      vi.spyOn(utils, 'hasSpanStreamingEnabled').mockReturnValue(true);
+      vi.spyOn(utils, 'startInactiveSpan').mockReturnValue(ignoredSpan);
+      const getTraceDataSpy = vi.spyOn(utils, 'getTraceData').mockReturnValue({
+        'sentry-trace': '12345678901234567890123456789012-1234567890123456-1',
+      });
+
+      instrumentOutgoingRequests(client, {
+        traceFetch: false,
+        tracePropagationTargets: ['example.com'],
+        enableHTTPTimings: false,
+      });
+      xhrHandler?.({
+        xhr: {
+          [browserUtils.SENTRY_XHR_DATA_KEY]: {
+            method: 'GET',
+            url: 'https://example.com/outgoing',
+            request_headers: {},
+          },
+          setRequestHeader: vi.fn(),
+        },
+        startTimestamp: Date.now(),
+      } as utils.HandlerDataXhr);
+
+      expect(xhrHandler).toBeDefined();
+      expect(getTraceDataSpy).toHaveBeenCalledWith({
+        span: undefined,
+        propagateTraceparent: undefined,
+      });
+    });
+  });
 });
 
 describe('shouldAttachHeaders', () => {

diff --git a/packages/core/src/fetch.ts b/packages/core/src/fetch.ts
@@ -1,6 +1,6 @@
 import { getClient } from './currentScopes';
 import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from './semanticAttributes';
-import { setHttpStatus, SPAN_STATUS_ERROR, startInactiveSpan } from './tracing';
+import { setHttpStatus, SPAN_STATUS_ERROR, spanIsIgnored, startInactiveSpan } from './tracing';
 import { SentryNonRecordingSpan } from './tracing/sentryNonRecordingSpan';
 import { hasSpanStreamingEnabled } from './tracing/spans/hasSpanStreamingEnabled';
 import type { FetchBreadcrumbHint } from './types/breadcrumb';
@@ -118,6 +118,7 @@ export function instrumentFetchRequest(
     shouldCreateSpanResult && shouldEmitSpan
       ? startInactiveSpan(getSpanStartOptions(url, method, spanOrigin))
       : new SentryNonRecordingSpan();
+  const spanForTraceHeaders = spanIsIgnored(span) && hasParent ? undefined : span;
 
   if (shouldCreateSpanResult && !shouldEmitSpan) {
     client?.recordDroppedEvent('no_parent_span', 'span');
@@ -139,7 +140,7 @@ export function instrumentFetchRequest(
       // If performance is disabled (TWP) or there's no active root span (pageload/navigation/interaction),
       // we do not want to use the span as base for the trace headers,
       // which means that the headers will be generated from the scope and the sampling decision is deferred
-      hasSpansEnabled() && shouldEmitSpan ? span : undefined,
+      hasSpansEnabled() && shouldEmitSpan ? spanForTraceHeaders : undefined,
       propagateTraceparent,
     );
     if (headers) {

diff --git a/packages/core/test/lib/fetch.test.ts b/packages/core/test/lib/fetch.test.ts
@@ -1,7 +1,11 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { HandlerDataFetch } from '../../src';
 import { _INTERNAL_getTracingHeadersForFetchRequest, instrumentFetchRequest } from '../../src/fetch';
+import { SentryNonRecordingSpan } from '../../src/tracing/sentryNonRecordingSpan';
 import type { Span } from '../../src/types/span';
+import * as tracing from '../../src/tracing';
+import * as spanUtils from '../../src/utils/spanUtils';
+import * as traceData from '../../src/utils/traceData';
 
 const { DEFAULT_SENTRY_TRACE, DEFAULT_BAGGAGE, hasSpansEnabled } = vi.hoisted(() => ({
   DEFAULT_SENTRY_TRACE: 'defaultTraceId-defaultSpanId-1',
@@ -440,6 +444,41 @@ describe('_INTERNAL_getTracingHeadersForFetchRequest', () => {
 });
 
 describe('instrumentFetchRequest', () => {
+  describe('trace header span', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('uses the active propagation context for an ignored child span', () => {
+      const activeSpan = new SentryNonRecordingSpan();
+      hasSpansEnabled.mockReturnValue(true);
+      const ignoredSpan = new SentryNonRecordingSpan({ dropReason: 'ignored' });
+      vi.spyOn(spanUtils, 'getActiveSpan').mockReturnValue(activeSpan);
+      vi.spyOn(tracing, 'startInactiveSpan').mockReturnValue(ignoredSpan);
+
+      instrumentFetchRequest(
+        {
+          fetchData: { url: '/api/test', method: 'GET' },
+          args: ['/api/test'],
+          startTimestamp: Date.now(),
+        },
+        () => true,
+        () => true,
+        {},
+        { spanOrigin: 'auto.http.fetch' },
+      );
+
+      expect(traceData.getTraceData).toHaveBeenCalledWith({
+        span: undefined,
+        propagateTraceparent: false,
+      });
+    });
+  });
+
   describe('span cleanup', () => {
     it.each([
       { name: 'non-recording', hasTracingEnabled: false },
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		setTimeout(() => fetch('http://sentry-test-external.io'));