feat(core): Apply ignoreSpans when span streaming is enabled

Author: Lms24

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

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

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

@@ -0,0 +1,12 @@
+Sentry.startSpan({ name: 'parent-span' }, () => {
+  Sentry.startSpan({ name: 'keep-me' }, () => {});
+
+  // This child matches ignoreSpans — should be dropped
+  Sentry.startSpan({ name: 'ignore-child' }, () => {
+    // Grandchild should be reparented to 'parent-span'
+    Sentry.startSpan({ name: 'grandchild-1' }, () => {});
+    Sentry.startSpan({ name: 'grandchild-2' }, () => {});
+  });
+
+  Sentry.startSpan({ name: 'another-keeper' }, () => {});
+});

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

@@ -0,0 +1,55 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  hidePage,
+  shouldSkipTracingTest,
+  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 to the grandparent',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    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.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 grandchild1 = spans.find(s => s.name === 'grandchild-1');
+    const grandchild2 = spans.find(s => s.name === 'grandchild-2');
+    expect(grandchild1).toBeDefined();
+    expect(grandchild2).toBeDefined();
+
+    expect(grandchild1?.parent_span_id).toBe(segmentSpanId);
+    expect(grandchild2?.parent_span_id).toBe(segmentSpanId);
+
+    expect(clientReport.discarded_events).toEqual([
+      {
+        category: 'span',
+        quantity: 1,
+        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://public@dsn.ingest.sentry.io/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,12 @@
+// 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,45 @@
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  hidePage,
+  shouldSkipTracingTest,
+  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 }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
+
+  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',
+    },
+  ]);
+});

dev-packages/node-integration-tests/suites/tracing/ignoreSpans/children/server.js

@@ -0,0 +1,38 @@
+const { loggingTransport } = require('@sentry-internal/node-integration-tests');
+const Sentry = require('@sentry/node');
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracePropagationTargets: [/^(?!.*test).*$/],
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+  traceLifecycle: 'stream',
+  ignoreSpans: ['middleware - expressInit', 'custom-to-drop'],
+  clientReportFlushInterval: 1_000,
+});
+
+const express = require('express');
+const cors = require('cors');
+const { startExpressServerAndSendPortToRunner } = require('@sentry-internal/node-integration-tests');
+
+const app = express();
+
+app.use(cors());
+
+app.get('/test/express', (_req, res) => {
+  Sentry.startSpan({
+    name: 'custom-to-drop',
+    op: 'custom',
+  }, () => {
+    Sentry.startSpan({
+      name: 'custom',
+      op: 'custom',
+    }, () => {});
+  });
+  res.send({ response: 'response 1' });
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/tracing/ignoreSpans/children/test.ts

@@ -0,0 +1,70 @@
+import { afterAll, describe, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
+import { SEMANTIC_ATTRIBUTE_SENTRY_OP } from '@sentry/core';
+
+describe('filtering child spans with ignoreSpans (streaming)', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  describe('CJS', () => {
+    test('child spans are dropped and remaining spans correctly parented', async () => {
+      const runner = createRunner(__dirname, 'server.js')
+        .expect({
+          span: container => {
+            // 5 spans: 1 root, 2 middleware, 1 request handler, 1 custom
+            // Would be 7 if we didn't ignore the 'middleware - expressInit' and 'custom-to-drop' spans
+            expect(container.items).toHaveLength(5);
+            const getSpan = (name: string, op: string) =>
+              container.items.find(
+                item => item.name === name && item.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_OP]?.value === op,
+              );
+            const queryMiddlewareSpan = getSpan('query', 'middleware.express');
+            const corsMiddlewareSpan = getSpan('corsMiddleware', 'middleware.express');
+            const requestHandlerSpan = getSpan('/test/express', 'request_handler.express');
+            const httpServerSpan = getSpan('GET /test/express', 'http.server');
+            const customSpan = getSpan('custom', 'custom');
+
+            expect(queryMiddlewareSpan).toBeDefined();
+            expect(corsMiddlewareSpan).toBeDefined();
+            expect(requestHandlerSpan).toBeDefined();
+            expect(httpServerSpan).toBeDefined();
+            expect(customSpan).toBeDefined();
+
+            expect(customSpan?.parent_span_id).toBe(requestHandlerSpan?.span_id);
+            expect(requestHandlerSpan?.parent_span_id).toBe(httpServerSpan?.span_id);
+            expect(queryMiddlewareSpan?.parent_span_id).toBe(httpServerSpan?.span_id);
+            expect(corsMiddlewareSpan?.parent_span_id).toBe(httpServerSpan?.span_id);
+            expect(httpServerSpan?.parent_span_id).toBeUndefined();
+          },
+        })
+        .start();
+
+      runner.makeRequest('get', '/test/express');
+
+      await runner.completed();
+    });
+
+    test('client report contains discarded spans', async () => {
+      const runner = createRunner(__dirname, 'server.js')
+        .ignore('span')
+        .unignore('client_report')
+        .expect({
+          client_report: {
+            discarded_events: [
+              {
+                category: 'span',
+                quantity: 2,
+                reason: 'ignored',
+              },
+            ],
+          },
+        })
+        .start();
+
+      runner.makeRequest('get', '/test/express');
+
+      await runner.completed();
+    });
+  });
+});

dev-packages/node-integration-tests/suites/tracing/ignoreSpans/segments/server.js

@@ -0,0 +1,33 @@
+const { loggingTransport } = require('@sentry-internal/node-integration-tests');
+const Sentry = require('@sentry/node');
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  tracePropagationTargets: [/^(?!.*test).*$/],
+  tracesSampleRate: 1.0,
+  transport: loggingTransport,
+  traceLifecycle: 'stream',
+  ignoreSpans: [/\/health/],
+  clientReportFlushInterval: 1_000,
+});
+
+const express = require('express');
+const cors = require('cors');
+const { startExpressServerAndSendPortToRunner } = require('@sentry-internal/node-integration-tests');
+
+const app = express();
+
+app.use(cors());
+
+app.get('/health', (_req, res) => {
+  res.send({ status: 'ok' });
+});
+
+app.get('/ok', (_req, res) => {
+  res.send({ status: 'ok' });
+});
+
+Sentry.setupExpressErrorHandler(app);
+
+startExpressServerAndSendPortToRunner(app);

dev-packages/node-integration-tests/suites/tracing/ignoreSpans/segments/test.ts

@@ -0,0 +1,48 @@
+import { afterAll, describe, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../../utils/runner';
+import { SEMANTIC_ATTRIBUTE_SENTRY_OP } from '@sentry/core';
+
+describe('filtering segment spans with ignoreSpans (streaming)', () => {
+  afterAll(() => {
+    cleanupChildProcesses();
+  });
+
+  describe('CJS', () => {
+    test('segment spans matching ignoreSpans are dropped including all children', async () => {
+      const runner = createRunner(__dirname, 'server.js')
+        .unignore('client_report')
+        .expect({
+          client_report: {
+            discarded_events: [
+              {
+                category: 'span',
+                quantity: 1,
+                reason: 'ignored',
+              },
+            ],
+          },
+        })
+        .expect({
+          span: {
+            items: expect.arrayContaining([
+              expect.objectContaining({
+                name: 'GET /ok',
+                attributes: expect.objectContaining({
+                  [SEMANTIC_ATTRIBUTE_SENTRY_OP]: {
+                    value: 'http.server',
+                    type: 'string',
+                  },
+                }),
+              }),
+            ]),
+          },
+        })
+        .start();
+
+      runner.makeRequest('get', '/health');
+      runner.makeRequest('get', '/ok');
+
+      await runner.completed();
+    });
+  });
+});