getsentry · Lms24 · Apr 11, 2025 · Apr 11, 2025 · Apr 11, 2025 · Apr 30, 2025
diff --git a/.size-limit.js b/.size-limit.js
@@ -47,7 +47,7 @@ module.exports = [
     path: 'packages/browser/build/npm/esm/index.js',
     import: createImport('init', 'browserTracingIntegration', 'replayIntegration'),
     gzip: true,
-    limit: '76 KB',
+    limit: '77 KB',
   },
   {
     name: '@sentry/browser (incl. Tracing, Replay) - with treeshaking flags',
@@ -219,7 +219,7 @@ module.exports = [
     import: createImport('init'),
     ignore: ['$app/stores'],
     gzip: true,
-    limit: '38.5 KB',
+    limit: '39 KB',
   },
   // Node SDK (ESM)
   {

diff --git a/...uites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/init.js b/...uites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/init.js
@@ -0,0 +1,21 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [
+    Sentry.browserTracingIntegration({
+      linkPreviousTrace: 'in-memory',
+      consistentTraceSampling: true,
+    }),
+  ],
+  tracePropagationTargets: ['someurl.com'],
+  tracesSampler: ctx => {
+    if (ctx.attributes && ctx.attributes['sentry.origin'] === 'auto.pageload.browser') {
+      return 1;
+    }
+    return ctx.inheritOrSampleWith(0);
+  },
+  debug: true,
+});
diff --git a/...es/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/subject.js b/...es/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/subject.js
@@ -0,0 +1,17 @@
+const btn1 = document.getElementById('btn1');
+
+const btn2 = document.getElementById('btn2');
+
+btn1.addEventListener('click', () => {
+  Sentry.startNewTrace(() => {
+    Sentry.startSpan({ name: 'custom root span 1', op: 'custom' }, () => {});
+  });
+});
+
+btn2.addEventListener('click', () => {
+  Sentry.startNewTrace(() => {
+    Sentry.startSpan({ name: 'custom root span 2', op: 'custom' }, async () => {
+      await fetch('https://someUrl.com');
+    });
+  });
+});
diff --git a/...tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/template.html b/...tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/template.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <button id="btn1">
+  </button>
+  <button id="btn2">
+  </button>
+</html>
diff --git a/...uites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/test.ts b/...uites/tracing/browserTracingIntegration/linked-traces/consistent-sampling/default/test.ts
@@ -0,0 +1,158 @@
+import { expect } from '@playwright/test';
+import {
+  extractTraceparentData,
+  parseBaggageHeader,
+  SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
+  SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE,
+} from '@sentry/core';
+import { sentryTest } from '../../../../../../utils/fixtures';
+import {
+  eventAndTraceHeaderRequestParser,
+  shouldSkipTracingTest,
+  waitForTransactionRequest,
+} from '../../../../../../utils/helpers';
+
+sentryTest.describe('When `consistentTraceSampling` is `true`', () => {
+  sentryTest('Continues sampling decision from initial pageload', async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const { pageloadTraceContext, pageloadSampleRand } = await sentryTest.step('Initial pageload', async () => {
+      const pageloadRequestPromise = waitForTransactionRequest(page, evt => {
+        return evt.contexts?.trace?.op === 'pageload';
+      });
+      await page.goto(url);
+
+      const res = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
+      const pageloadSampleRand = Number(res[1]?.sample_rand);
+      const pageloadTraceContext = res[0].contexts?.trace;
+
+      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
+      expect(pageloadSampleRand).toBeGreaterThanOrEqual(0);
+
+      return { pageloadTraceContext: res[0].contexts?.trace, pageloadSampleRand };
+    });
+
+    const customTraceContext = await sentryTest.step('Custom trace', async () => {
+      const customTrace1RequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+      await page.locator('#btn1').click();
+      const [customTrace1Event, customTraceTraceHeader] = eventAndTraceHeaderRequestParser(
+        await customTrace1RequestPromise,
+      );
+
+      const customTraceContext = customTrace1Event.contexts?.trace;
+
+      expect(customTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+      // although we "continue the trace" from pageload, this is actually a root span,
+      // so there must not be a parent span id
+      expect(customTraceContext?.parent_span_id).toBeUndefined();
+
+      expect(pageloadSampleRand).toEqual(Number(customTraceTraceHeader?.sample_rand));
+
+      return customTraceContext;
+    });
+
+    await sentryTest.step('Navigation', async () => {
+      const navigation1RequestPromise = waitForTransactionRequest(
+        page,
+        evt => evt.contexts?.trace?.op === 'navigation',
+      );
+      await page.goto(`${url}#foo`);
+      const [navigationEvent, navigationTraceHeader] = eventAndTraceHeaderRequestParser(
+        await navigation1RequestPromise,
+      );
+      const navTraceContext = navigationEvent.contexts?.trace;
+
+      expect(navTraceContext?.trace_id).not.toEqual(customTraceContext?.trace_id);
+      expect(navTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+
+      expect(navTraceContext?.links).toEqual([
+        {
+          trace_id: customTraceContext?.trace_id,
+          span_id: customTraceContext?.span_id,
+          sampled: true,
+          attributes: {
+            [SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE]: 'previous_trace',
+          },
+        },
+      ]);
+      expect(navTraceContext?.parent_span_id).toBeUndefined();
+
+      expect(pageloadSampleRand).toEqual(Number(navigationTraceHeader?.sample_rand));
+    });
+  });
+
+  sentryTest('Propagates continued sampling decision to outgoing requests', async ({ page, getLocalTestUrl }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    const { pageloadTraceContext, pageloadSampleRand } = await sentryTest.step('Initial pageload', async () => {
+      const pageloadRequestPromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'pageload');
+      await page.goto(url);
+
+      const res = eventAndTraceHeaderRequestParser(await pageloadRequestPromise);
+      const pageloadSampleRand = Number(res[1]?.sample_rand);
+
+      expect(pageloadSampleRand).toBeGreaterThanOrEqual(0);
+
+      const pageloadTraceContext = res[0].contexts?.trace;
+
+      expect(pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toBe(1);
+
+      return { pageloadTraceContext: pageloadTraceContext, pageloadSampleRand };
+    });
+
+    await sentryTest.step('Make fetch request', async () => {
+      let sentryTrace = undefined;
+      let baggage = undefined;
+
+      await page.route('https://someUrl.com', (route, req) => {
+        baggage = req.headers()['baggage'];
+        sentryTrace = req.headers()['sentry-trace'];
+        return route.fulfill({ status: 200, body: 'ok' });
+      });
+
+      const fetchTracePromise = waitForTransactionRequest(page, evt => evt.contexts?.trace?.op === 'custom');
+
+      await page.locator('#btn2').click();
+
+      const [fetchTraceEvent, fetchTraceTraceHeader] = eventAndTraceHeaderRequestParser(await fetchTracePromise);
+
+      const fetchTraceSampleRand = Number(fetchTraceTraceHeader?.sample_rand);
+      const fetchTraceTraceContext = fetchTraceEvent.contexts?.trace;
+      const httpClientSpan = fetchTraceEvent.spans?.find(span => span.op === 'http.client');
+
+      expect(fetchTraceSampleRand).toEqual(pageloadSampleRand);
+
+      expect(fetchTraceTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]).toEqual(
+        pageloadTraceContext?.data?.[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE],
+      );
+      expect(fetchTraceTraceContext?.trace_id).not.toEqual(pageloadTraceContext?.trace_id);
+
+      expect(sentryTrace).toBeDefined();
+      expect(baggage).toBeDefined();
+
+      expect(extractTraceparentData(sentryTrace)).toEqual({
+        traceId: fetchTraceTraceContext?.trace_id,
+        parentSpanId: httpClientSpan?.span_id,
+        parentSampled: true,
+      });
+
+      expect(parseBaggageHeader(baggage)).toEqual({
+        'sentry-environment': 'production',
+        'sentry-public_key': 'public',
+        'sentry-sample_rand': `${pageloadSampleRand}`,
+        'sentry-sample_rate': '1',
+        'sentry-sampled': 'true',
+        'sentry-trace_id': fetchTraceTraceContext?.trace_id,
+        'sentry-transaction': 'custom root span 2',
+      });
+    });
+  });
+});
diff --git a/...tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/init.js b/...tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/init.js
@@ -0,0 +1,17 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [
+    Sentry.browserTracingIntegration({
+      linkPreviousTrace: 'in-memory',
+      consistentTraceSampling: true,
+    }),
+  ],
+  tracePropagationTargets: ['someurl.com'],
+  tracesSampleRate: 1,
+  debug: true,
+  sendClientReports: true,
+});
diff --git a/...cing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/subject.js b/...cing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/subject.js
@@ -0,0 +1,17 @@
+const btn1 = document.getElementById('btn1');
+
+const btn2 = document.getElementById('btn2');
+
+btn1.addEventListener('click', () => {
+  Sentry.startNewTrace(() => {
+    Sentry.startSpan({ name: 'custom root span 1', op: 'custom' }, () => {});
+  });
+});
+
+btn2.addEventListener('click', () => {
+  Sentry.startNewTrace(() => {
+    Sentry.startSpan({ name: 'custom root span 2', op: 'custom' }, async () => {
+      await fetch('https://someUrl.com');
+    });
+  });
+});
diff --git a/...g/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/template.html b/...g/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/template.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="sentry-trace" content="12345678901234567890123456789012-1234567890123456-0" />
+    <meta
+      name="baggage"
+      content="sentry-trace_id=12345678901234567890123456789012,sentry-sample_rate=0.2,sentry-sampled=false,sentry-transaction=my-transaction,sentry-public_key=public,sentry-release=1.0.0,sentry-environment=prod,sentry-sample_rand=0.9"
+    />
+  </head>
+  <button id="btn1">Custom Trace</button>
+  <button id="btn2">fetch request</button>
+</html>
diff --git a/...tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/test.ts b/...tracing/browserTracingIntegration/linked-traces/consistent-sampling/meta-negative/test.ts
@@ -0,0 +1,105 @@
+import { expect } from '@playwright/test';
+import type { ClientReport } from '@sentry/core';
+import { extractTraceparentData, parseBaggageHeader } from '@sentry/core';
+import { sentryTest } from '../../../../../../utils/fixtures';
+import {
+  envelopeRequestParser,
+  getMultipleSentryEnvelopeRequests,
+  hidePage,
+  shouldSkipTracingTest,
+  waitForClientReportRequest,
+} from '../../../../../../utils/helpers';
+
+const metaTagSampleRand = 0.9;
+const metaTagSampleRate = 0.2;
+const metaTagTraceId = '12345678901234567890123456789012';
+
+sentryTest.describe('When `consistentTraceSampling` is `true` and page contains <meta> tags', () => {
+  sentryTest(
+    'Continues negative sampling decision from meta tag across all traces and downstream propagations',
+    async ({ getLocalTestUrl, page }) => {
+      if (shouldSkipTracingTest()) {
+        sentryTest.skip();
+      }
+
+      const url = await getLocalTestUrl({ testDir: __dirname });
+
+      let txnsReceived = 0;
+      // @ts-expect-error - no need to return something valid here
+      getMultipleSentryEnvelopeRequests<Event>(page, 1, { envelopeType: 'transaction' }, () => {
+        ++txnsReceived;
+        return {};
+      });
+
+      const clientReportPromise = waitForClientReportRequest(page);
+
+      await sentryTest.step('Initial pageload', async () => {
+        await page.goto(url);
+        expect(txnsReceived).toEqual(0);
+      });
+
+      await sentryTest.step('Custom instrumented button click', async () => {
+        await page.locator('#btn1').click();
+        expect(txnsReceived).toEqual(0);
+      });
+
+      await sentryTest.step('Navigation', async () => {
+        await page.goto(`${url}#foo`);
+        expect(txnsReceived).toEqual(0);
+      });
+
+      await sentryTest.step('Make fetch request', async () => {
+        let sentryTrace = undefined;
+        let baggage = undefined;
+
+        await page.route('https://someUrl.com', (route, req) => {
+          baggage = req.headers()['baggage'];
+          sentryTrace = req.headers()['sentry-trace'];
+          return route.fulfill({ status: 200, body: 'ok' });
+        });
+
+        await page.locator('#btn2').click();
+
+        expect(sentryTrace).toBeDefined();
+        expect(baggage).toBeDefined();
+
+        expect(extractTraceparentData(sentryTrace)).toEqual({
+          traceId: expect.not.stringContaining(metaTagTraceId),
+          parentSpanId: expect.stringMatching(/^[0-9a-f]{16}$/),
+          parentSampled: false,
+        });
+
+        expect(parseBaggageHeader(baggage)).toEqual({
+          'sentry-environment': 'production',
+          'sentry-public_key': 'public',
+          'sentry-sample_rand': `${metaTagSampleRand}`,
+          'sentry-sample_rate': `${metaTagSampleRate}`,
+          'sentry-sampled': 'false',
+          'sentry-trace_id': expect.not.stringContaining(metaTagTraceId),
+          'sentry-transaction': 'custom root span 2',
+        });
+      });
+
+      await sentryTest.step('Client report', async () => {
+        await hidePage(page);
+        const clientReport = envelopeRequestParser<ClientReport>(await clientReportPromise);
+        expect(clientReport).toEqual({
+          timestamp: expect.any(Number),
+          discarded_events: [
+            {
+              category: 'transaction',
+              quantity: 4,
+              reason: 'sample_rate',
+            },
+          ],
+        });
+      });
+
+      await sentryTest.step('Wait for transactions to be discarded', async () => {
+        // give it a little longer just in case a txn is pending to be sent
+        await page.waitForTimeout(1000);
+        expect(txnsReceived).toEqual(0);
+      });
+    },
+  );
+});