feat(core): Apply ignoreSpans to streamed spans (#19934)

This PR Implements applying the `ignoreSpans` option to streamed spans
(previously this option had no effect). It covers both, our
core/browser- as well as the OTel/Node-based implementation.
See PR for details

Author: Lms24

.size-limit.js

@@ -255,7 +255,7 @@ module.exports = [
     path: createCDNPath('bundle.tracing.logs.metrics.min.js'),
     gzip: false,
     brotli: false,
-    limit: '133 KB',
+    limit: '134 KB',
   },
   {
     name: 'CDN Bundle (incl. Replay, Logs, Metrics) - uncompressed',
@@ -356,7 +356,7 @@ module.exports = [
     import: createImport('init'),
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     gzip: true,
-    limit: '116 KB',
+    limit: '117 KB',
   },
 ];
 

dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-negative/test.ts

@@ -83,12 +83,14 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
           timestamp: expect.any(Number),
           discarded_events: [
             {
-              category: 'transaction',
-              quantity: 4,
+              category: 'span',
+              quantity: expect.any(Number),
               reason: 'sample_rate',
             },
           ],
         });
+        // exact number depends on performance observer emissions
+        expect(clientReport.discarded_events[0].quantity).toBeGreaterThanOrEqual(10);
       });
 
       expect(spansReceived).toHaveLength(0);

dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/meta-precedence/test.ts

@@ -69,12 +69,14 @@ sentryTest.describe('When `consistentTraceSampling` is `true` and page contains
           timestamp: expect.any(Number),
           discarded_events: [
             {
-              category: 'transaction',
-              quantity: 2,
+              category: 'span',
+              quantity: expect.any(Number),
               reason: 'sample_rate',
             },
           ],
         });
+        // exact number depends on performance observer emissions
+        expect(clientReport.discarded_events[0].quantity).toBeGreaterThanOrEqual(3);
       });
 
       await sentryTest.step('Navigate to another page with meta tags', async () => {

dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/linked-traces-streamed/consistent-sampling/tracesSampler-precedence/test.ts

@@ -53,7 +53,7 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
         timestamp: expect.any(Number),
         discarded_events: [
           {
-            category: 'transaction',
+            category: 'span',
             quantity: 1,
             reason: 'sample_rate',
           },
@@ -76,7 +76,7 @@ sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
         timestamp: expect.any(Number),
         discarded_events: [
           {
-            category: 'transaction',
+            category: 'span',
             quantity: 1,
             reason: 'sample_rate',
           },

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

@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  integrations: [Sentry.spanStreamingIntegration()],
+  ignoreSpans: [/ignore/, { op: 'ignored-op' }],
+  parentSpanIsAlwaysRootSpan: false,
+  tracesSampleRate: 1,
+});

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

@@ -0,0 +1,31 @@
+Sentry.startSpan({ name: 'parent-span' }, () => {
+  Sentry.startSpan({ name: 'keep-me' }, () => {});
+
+  // This child matches ignoreSpans —> dropped
+  Sentry.startSpan({ name: 'ignore-child' }, () => {
+    // dropped
+    Sentry.startSpan({ name: 'ignore-grandchild-1' }, () => {
+      // kept
+      Sentry.startSpan({ name: 'great-grandchild-1' }, () => {
+        // dropped
+        Sentry.startSpan({ name: 'ignore-great-great-grandchild-1' }, () => {
+          // kept
+          Sentry.startSpan({ name: 'great-great-great-grandchild-1' }, () => {});
+        });
+      });
+    });
+    // Grandchild is reparented to 'parent-span' —> kept
+    Sentry.startSpan({ name: 'grandchild-2' }, () => {});
+  });
+
+  // both dropped
+  Sentry.startSpan({ name: 'name-passes-but-op-not-span-1', op: 'ignored-op' }, () => {});
+  Sentry.startSpan(
+    // sentry.op attribute has precedence over top op argument
+    { name: 'name-passes-but-op-not-span-2', op: 'keep', attributes: { 'sentry.op': 'ignored-op' } },
+    () => {},
+  );
+
+  // kept
+  Sentry.startSpan({ name: 'another-keeper' }, () => {});
+});

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

@@ -0,0 +1,59 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  hidePage,
+  shouldSkipTracingTest,
+  testingCdnBundle,
+  waitForClientReportRequest,
+} from '../../../../utils/helpers';
+import { waitForStreamedSpans } from '../../../../utils/spanUtils';
+import type { ClientReport } from '@sentry/core';
+
+sentryTest('ignored child spans are dropped and their children are reparented', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest() || testingCdnBundle());
+
+  const spansPromise = waitForStreamedSpans(page, spans => !!spans?.find(s => s.name === 'parent-span'));
+
+  const clientReportPromise = waitForClientReportRequest(page);
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
+
+  const spans = await spansPromise;
+
+  await hidePage(page);
+
+  const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
+
+  const segmentSpanId = spans.find(s => s.name === 'parent-span')?.span_id;
+
+  expect(spans.length).toBe(6);
+
+  expect(spans.some(s => s.name === 'keep-me')).toBe(true);
+  expect(spans.some(s => s.name === 'another-keeper')).toBe(true);
+
+  expect(spans.some(s => s.name?.includes('ignore'))).toBe(false);
+
+  const greatGrandChild1 = spans.find(s => s.name === 'great-grandchild-1');
+  const grandchild2 = spans.find(s => s.name === 'grandchild-2');
+  const greatGreatGreatGrandChild1 = spans.find(s => s.name === 'great-great-great-grandchild-1');
+
+  expect(greatGrandChild1).toBeDefined();
+  expect(grandchild2).toBeDefined();
+  expect(greatGreatGreatGrandChild1).toBeDefined();
+
+  expect(greatGrandChild1?.parent_span_id).toBe(segmentSpanId);
+  expect(grandchild2?.parent_span_id).toBe(segmentSpanId);
+  expect(greatGreatGreatGrandChild1?.parent_span_id).toBe(greatGrandChild1?.span_id);
+
+  expect(spans.every(s => s.name === 'parent-span' || !s.is_segment)).toBe(true);
+
+  expect(clientReport.discarded_events).toEqual([
+    {
+      category: 'span',
+      quantity: 5, // 5 ignored child spans
+      reason: 'ignored',
+    },
+  ]);
+});

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

@@ -0,0 +1,11 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  integrations: [Sentry.spanStreamingIntegration()],
+  ignoreSpans: [/ignore/],
+  tracesSampleRate: 1,
+  debug: true,
+});

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

@@ -0,0 +1,11 @@
+// This segment span matches ignoreSpans — should NOT produce a transaction
+Sentry.startSpan({ name: 'ignore-segment' }, () => {
+  Sentry.startSpan({ name: 'child-of-ignored-segment' }, () => {});
+});
+
+setTimeout(() => {
+  // This segment span does NOT match — should produce a transaction
+  Sentry.startSpan({ name: 'normal-segment' }, () => {
+    Sentry.startSpan({ name: 'child-span' }, () => {});
+  });
+}, 1000);

dev-packages/browser-integration-tests/suites/tracing/ignoreSpans-streamed/segment/test.ts

@@ -0,0 +1,44 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  hidePage,
+  shouldSkipTracingTest,
+  testingCdnBundle,
+  waitForClientReportRequest,
+} from '../../../../utils/helpers';
+import { observeStreamedSpan, waitForStreamedSpans } from '../../../../utils/spanUtils';
+import type { ClientReport } from '@sentry/core';
+
+sentryTest('ignored segment span drops entire trace', async ({ getLocalTestUrl, page }) => {
+  sentryTest.skip(shouldSkipTracingTest() || testingCdnBundle());
+
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  observeStreamedSpan(page, span => {
+    if (span.name === 'ignore-segment' || span.name === 'child-of-ignored-segment') {
+      throw new Error('Ignored span found');
+    }
+    return false; // means we keep on looking for unwanted spans
+  });
+
+  const spansPromise = waitForStreamedSpans(page, spans => !!spans?.find(s => s.name === 'normal-segment'));
+
+  const clientReportPromise = waitForClientReportRequest(page);
+
+  await page.goto(url);
+
+  expect((await spansPromise)?.length).toBe(2);
+
+  await hidePage(page);
+
+  const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
+
+  expect(clientReport.discarded_events).toEqual([
+    {
+      category: 'span',
+      quantity: 2, // segment + child span
+      reason: 'ignored',
+    },
+  ]);
+});