handle client reports for core/browser

Author: Lms24

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

@@ -6,5 +6,6 @@ Sentry.init({
   dsn: 'https://public@dsn.ingest.sentry.io/1337',
   integrations: [Sentry.spanStreamingIntegration()],
   ignoreSpans: [/ignore/],
+  parentSpanIsAlwaysRootSpan: false,
   tracesSampleRate: 1,
 });

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

@@ -1,12 +1,23 @@
 Sentry.startSpan({ name: 'parent-span' }, () => {
   Sentry.startSpan({ name: 'keep-me' }, () => {});
 
-  // This child matches ignoreSpans — should be dropped
+  // This child matches ignoreSpans —> dropped
   Sentry.startSpan({ name: 'ignore-child' }, () => {
-    // Grandchild should be reparented to 'parent-span'
-    Sentry.startSpan({ name: 'grandchild-1' }, () => {});
+    // 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' }, () => {});
   });
 
+  // kept
   Sentry.startSpan({ name: 'another-keeper' }, () => {});
 });

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

@@ -9,47 +9,52 @@ import {
 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();
-    }
+sentryTest('ignored child spans are dropped and their children are reparented', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipTracingTest()) {
+    sentryTest.skip();
+  }
 
-    const spansPromise = waitForStreamedSpans(page, spans => !!spans?.find(s => s.name === 'parent-span'));
+  const spansPromise = waitForStreamedSpans(page, spans => !!spans?.find(s => s.name === 'parent-span'));
 
-    const clientReportPromise = waitForClientReportRequest(page);
+  const clientReportPromise = waitForClientReportRequest(page);
 
-    const url = await getLocalTestUrl({ testDir: __dirname });
-    await page.goto(url);
+  const url = await getLocalTestUrl({ testDir: __dirname });
+  await page.goto(url);
 
-    const spans = await spansPromise;
+  const spans = await spansPromise;
 
-    await hidePage(page);
+  await hidePage(page);
 
-    const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
+  const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
 
-    const segmentSpanId = spans.find(s => s.name === 'parent-span')?.span_id;
+  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.length).toBe(6);
 
-    expect(spans.some(s => s.name?.includes('ignore'))).toBe(false);
+  expect(spans.some(s => s.name === 'keep-me')).toBe(true);
+  expect(spans.some(s => s.name === 'another-keeper')).toBe(true);
 
-    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(spans.some(s => s.name?.includes('ignore'))).toBe(false);
 
-    expect(grandchild1?.parent_span_id).toBe(segmentSpanId);
-    expect(grandchild2?.parent_span_id).toBe(segmentSpanId);
+  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(clientReport.discarded_events).toEqual([
-      {
-        category: 'span',
-        quantity: 1,
-        reason: 'ignored',
-      },
-    ]);
-  },
-);
+  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: 3, // 3 ignored child spans
+      reason: 'ignored',
+    },
+  ]);
+});

packages/core/src/tracing/sentryNonRecordingSpan.ts

@@ -1,3 +1,4 @@
+import type { EventDropReason } from '../types-hoist/clientreport';
 import type {
   SentrySpanArguments,
   Span,
@@ -10,16 +11,28 @@ import type { SpanStatus } from '../types-hoist/spanStatus';
 import { generateSpanId, generateTraceId } from '../utils/propagationContext';
 import { TRACE_FLAG_NONE } from '../utils/spanUtils';
 
+interface SentryNonRecordingSpanArguments extends SentrySpanArguments {
+  dropReason?: EventDropReason;
+}
+
 /**
  * A Sentry Span that is non-recording, meaning it will not be sent to Sentry.
  */
 export class SentryNonRecordingSpan implements Span {
   private _traceId: string;
   private _spanId: string;
 
-  public constructor(spanContext: SentrySpanArguments = {}) {
+  /**
+   * Reason why this span was dropped, if applicable ('ignored' or 'sample_rate').
+   * Used to propagate the correct client report outcome to descendant spans
+   * when span streaming is enabled.
+   */
+  public dropReason?: EventDropReason;
+
+  public constructor(spanContext: SentryNonRecordingSpanArguments = {}) {
     this._traceId = spanContext.traceId || generateTraceId();
     this._spanId = spanContext.spanId || generateSpanId();
+    this.dropReason = spanContext.dropReason;
   }
 
   /** @inheritdoc */

packages/core/src/tracing/trace.ts

@@ -20,6 +20,7 @@ import { debug } from '../utils/debug-logger';
 import { handleCallbackErrors } from '../utils/handleCallbackErrors';
 import { hasSpansEnabled } from '../utils/hasSpansEnabled';
 import { shouldIgnoreSpan } from '../utils/should-ignore-span';
+import { hasSpanStreamingEnabled } from './spans/hasSpanStreamingEnabled';
 import { parseSampleRate } from '../utils/parseSampleRate';
 import { generateTraceId } from '../utils/propagationContext';
 import { safeMathRandom } from '../utils/randomSafeContext';
@@ -33,6 +34,7 @@ import { SentryNonRecordingSpan } from './sentryNonRecordingSpan';
 import { SentrySpan } from './sentrySpan';
 import { SPAN_STATUS_ERROR } from './spanstatus';
 import { setCapturedScopesOnSpan } from './utils';
+import type { Client } from '../client';
 
 const SUPPRESS_TRACING_KEY = '__SENTRY_SUPPRESS_TRACING__';
 
@@ -68,22 +70,12 @@ export function startSpan<T>(options: StartSpanOptions, callback: (span: Span) =
       const parentSpan = getParentSpan(scope, customParentSpan);
 
       const client = getClient();
-      const ignoreSpans = client?.getOptions().ignoreSpans;
-      if (ignoreSpans?.length) {
-        const op = spanArguments.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_OP];
-        if (shouldIgnoreSpan({ description: spanArguments.name || '', op }, ignoreSpans)) {
-          client?.recordDroppedEvent('ignored', 'span');
-          const nonRecordingSpan = new SentryNonRecordingSpan();
-          // For root spans, set on scope (like unsampled). For child spans, don't — keep parent active.
-          if (!parentSpan) {
-            _setSpanForScope(scope, nonRecordingSpan);
-          }
-          return handleCallbackErrors(
-            () => callback(nonRecordingSpan),
-            () => {},
-            () => nonRecordingSpan.end(),
-          );
-        }
+      if (_shouldIgnoreStreamedSpan(client, spanArguments)) {
+        return handleCallbackErrors(
+          () => callback(_createIgnoredSpan(client, parentSpan, scope)),
+          () => {},
+          () => {},
+        );
       }
 
       const shouldSkipSpan = options.onlyIfParent && !parentSpan;
@@ -145,20 +137,11 @@ export function startSpanManual<T>(options: StartSpanOptions, callback: (span: S
       const parentSpan = getParentSpan(scope, customParentSpan);
 
       const client = getClient();
-      const ignoreSpans = client?.getOptions().ignoreSpans;
-      if (ignoreSpans?.length) {
-        const op = spanArguments.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_OP];
-        if (shouldIgnoreSpan({ description: spanArguments.name || '', op }, ignoreSpans)) {
-          client?.recordDroppedEvent('ignored', 'span');
-          const nonRecordingSpan = new SentryNonRecordingSpan();
-          if (!parentSpan) {
-            _setSpanForScope(scope, nonRecordingSpan);
-          }
-          return handleCallbackErrors(
-            () => callback(nonRecordingSpan, () => nonRecordingSpan.end()),
-            () => {},
-          );
-        }
+      if (_shouldIgnoreStreamedSpan(client, spanArguments)) {
+        return handleCallbackErrors(
+          () => callback(_createIgnoredSpan(client, parentSpan, scope), () => {}),
+          () => {},
+        );
       }
 
       const shouldSkipSpan = options.onlyIfParent && !parentSpan;
@@ -222,13 +205,8 @@ export function startInactiveSpan(options: StartSpanOptions): Span {
     const parentSpan = getParentSpan(scope, customParentSpan);
 
     const client = getClient();
-    const ignoreSpans = client?.getOptions().ignoreSpans;
-    if (ignoreSpans?.length) {
-      const op = spanArguments.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_OP];
-      if (shouldIgnoreSpan({ description: spanArguments.name || '', op }, ignoreSpans)) {
-        client?.recordDroppedEvent('ignored', 'span');
-        return new SentryNonRecordingSpan();
-      }
+    if (_shouldIgnoreStreamedSpan(client, spanArguments)) {
+      return _createIgnoredSpan(client, parentSpan, scope);
     }
 
     const shouldSkipSpan = options.onlyIfParent && !parentSpan;
@@ -513,7 +491,7 @@ function _startRootSpan(spanArguments: SentrySpanArguments, scope: Scope, parent
 
   if (!sampled && client) {
     DEBUG_BUILD && debug.log('[Tracing] Discarding root span because its trace was not chosen to be sampled.');
-    client.recordDroppedEvent('sample_rate', 'transaction');
+    client.recordDroppedEvent('sample_rate', hasSpanStreamingEnabled(client) ? 'span' : 'transaction');
   }
 
   if (client) {
@@ -543,15 +521,33 @@ function _startChildSpan(parentSpan: Span, scope: Scope, spanArguments: SentrySp
   addChildSpanToSpan(parentSpan, childSpan);
 
   const client = getClient();
-  if (client) {
-    client.emit('spanStart', childSpan);
-    // If it has an endTimestamp, it's already ended
-    if (spanArguments.endTimestamp) {
-      client.emit('spanEnd', childSpan);
-      client.emit('afterSpanEnd', childSpan);
+
+  if (!client) {
+    return childSpan;
+  }
+
+  if (hasSpanStreamingEnabled(client) && childSpan instanceof SentryNonRecordingSpan) {
+    if (parentSpan instanceof SentryNonRecordingSpan && parentSpan.dropReason) {
+      // We land here if the parent span was a segment span that was ignored (`ignoreSpans`).
+      // In this case, the child was also ignored (see `sampled` above) but we need to
+      // record a client outcome for the child.
+      childSpan.dropReason = parentSpan.dropReason;
+      client.recordDroppedEvent(parentSpan.dropReason, 'span');
+    } else {
+      // Otherwise, the child is not sampled due to sampling of the parent span,
+      // hence we record a sample_rate client outcome for the child.
+      childSpan.dropReason = 'sample_rate';
+      client.recordDroppedEvent('sample_rate', 'span');
     }
   }
 
+  client.emit('spanStart', childSpan);
+  // If it has an endTimestamp, it's already ended
+  if (spanArguments.endTimestamp) {
+    client.emit('spanEnd', childSpan);
+    client.emit('afterSpanEnd', childSpan);
+  }
+
   return childSpan;
 }
 
@@ -588,3 +584,34 @@ function getActiveSpanWrapper<T>(parentSpan: Span | undefined | null): (callback
       }
     : (callback: () => T) => callback();
 }
+
+/* Checks if `ignoreSpans` applies (extracted for bundle size)*/
+function _shouldIgnoreStreamedSpan(client: Client | undefined, spanArguments: SentrySpanArguments): boolean {
+  const ignoreSpans = client?.getOptions().ignoreSpans;
+
+  if (!client || !hasSpanStreamingEnabled(client) || !ignoreSpans?.length) {
+    return false;
+  }
+
+  return shouldIgnoreSpan(
+    { description: spanArguments.name || '', op: spanArguments.attributes?.[SEMANTIC_ATTRIBUTE_SENTRY_OP] },
+    ignoreSpans,
+  );
+}
+
+/* creates a non-recording span that is marked as ignored and sets it on the scope if applicable */
+function _createIgnoredSpan(
+  client: Client | undefined,
+  parentSpan: SentrySpan | undefined,
+  scope: Scope,
+): SentryNonRecordingSpan {
+  client?.recordDroppedEvent('ignored', 'span');
+  const nonRecordingSpan = new SentryNonRecordingSpan({ dropReason: 'ignored' });
+  if (!parentSpan) {
+    // Put the ignored non-recording segment span onto the scope so that `getActiveSpan()` returns it
+    // For child spans, we don't do this because there _is_ an active span on the scope. We can change
+    // this if necessary.
+    _setSpanForScope(scope, nonRecordingSpan);
+  }
+  return nonRecordingSpan;
+}