Merge branch 'develop' into beta

Author: billyvg

.github/workflows/build.yml

@@ -921,6 +921,7 @@ jobs:
             'tanstack-router',
             'generic-ts3.8',
             'node-fastify',
+            'node-fastify-5',
             'node-hapi',
             'node-nestjs-basic',
             'node-nestjs-distributed-tracing',

.github/workflows/release-comment-issues.yml

@@ -20,7 +20,12 @@ jobs:
         run: echo "version=${{ github.event.inputs.version || github.event.release.tag_name }}" >> $GITHUB_OUTPUT
 
       - name: Comment on linked issues that are mentioned in release
-        if: steps.get_version.outputs.version != ''
+        if: |
+          steps.get_version.outputs.version != ''
+          && !contains(steps.get_version.outputs.version, '-beta.')
+          && !contains(steps.get_version.outputs.version, '-alpha.')
+          && !contains(steps.get_version.outputs.version, '-rc.')
+
         uses: getsentry/release-comment-issues-gh-action@v1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}

.size-limit.js

@@ -138,7 +138,7 @@ module.exports = [
     import: createImport('init', 'ErrorBoundary', 'reactRouterV6BrowserTracingIntegration'),
     ignore: ['react/jsx-runtime'],
     gzip: true,
-    limit: '39 KB',
+    limit: '39.05 KB',
   },
   // Vue SDK (ESM)
   {

dev-packages/browser-integration-tests/suites/replay/bufferModeManual/test.ts

@@ -287,6 +287,125 @@ sentryTest(
   },
 );
 
+sentryTest(
+  '[buffer-mode] manually starting replay ignores earlier performance entries',
+  async ({ getLocalTestUrl, page, browserName }) => {
+    // This was sometimes flaky on webkit, so skipping for now
+    if (shouldSkipReplayTest() || browserName === 'webkit') {
+      sentryTest.skip();
+    }
+
+    const reqPromise0 = waitForReplayRequest(page, 0);
+
+    await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+      return route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({ id: 'test-id' }),
+      });
+    });
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await page.goto(url);
+
+    // Wait for everything to be initialized - Replay is not running yet
+    await page.waitForFunction('!!window.Replay');
+
+    // Wait for a second, then start replay
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    await page.evaluate('window.Replay.start()');
+
+    const req0 = await reqPromise0;
+
+    const event0 = getReplayEvent(req0);
+    const content0 = getReplayRecordingContent(req0);
+
+    expect(event0).toEqual(
+      getExpectedReplayEvent({
+        replay_type: 'session',
+      }),
+    );
+
+    const { performanceSpans } = content0;
+
+    // Here, we test that this does not contain any web-vital etc. performance spans
+    // as these have been emitted _before_ the replay was manually started
+    expect(performanceSpans).toEqual([
+      {
+        op: 'memory',
+        description: 'memory',
+        startTimestamp: expect.any(Number),
+        endTimestamp: expect.any(Number),
+        data: {
+          memory: {
+            jsHeapSizeLimit: expect.any(Number),
+            totalJSHeapSize: expect.any(Number),
+            usedJSHeapSize: expect.any(Number),
+          },
+        },
+      },
+    ]);
+  },
+);
+
+sentryTest(
+  '[buffer-mode] manually starting replay ignores earlier performance entries when starting immediately',
+  async ({ getLocalTestUrl, page, browserName }) => {
+    // This was sometimes flaky on webkit, so skipping for now
+    if (shouldSkipReplayTest() || browserName === 'webkit') {
+      sentryTest.skip();
+    }
+
+    const reqPromise0 = waitForReplayRequest(page, 0);
+
+    await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+      return route.fulfill({
+        status: 200,
+        contentType: 'application/json',
+        body: JSON.stringify({ id: 'test-id' }),
+      });
+    });
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    page.goto(url);
+
+    // Wait for everything to be initialized, then start replay as soon as possible
+    await page.waitForFunction('!!window.Replay');
+    await page.evaluate('window.Replay.start()');
+
+    const req0 = await reqPromise0;
+
+    const event0 = getReplayEvent(req0);
+    const content0 = getReplayRecordingContent(req0);
+
+    expect(event0).toEqual(
+      getExpectedReplayEvent({
+        replay_type: 'session',
+      }),
+    );
+
+    const { performanceSpans } = content0;
+
+    expect(performanceSpans).toEqual([
+      {
+        op: 'memory',
+        description: 'memory',
+        startTimestamp: expect.any(Number),
+        endTimestamp: expect.any(Number),
+        data: {
+          memory: {
+            jsHeapSizeLimit: expect.any(Number),
+            totalJSHeapSize: expect.any(Number),
+            usedJSHeapSize: expect.any(Number),
+          },
+        },
+      },
+    ]);
+  },
+);
+
 // Doing this in buffer mode to test changing error sample rate after first
 // error happens.
 sentryTest(

dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/trace-header-merging/init.js

@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://[email protected]/1337',
+  integrations: [Sentry.browserTracingIntegration()],
+  tracePropagationTargets: ['http://example.com'],
+  tracesSampleRate: 1,
+});

dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/trace-header-merging/subject.js

@@ -0,0 +1,53 @@
+fetchPojo.addEventListener('click', () => {
+  const fetchOptions = {
+    headers: {
+      'sentry-trace': '12312012123120121231201212312012-1121201211212012-1',
+      baggage: 'sentry-release=4.2.0',
+    },
+  };
+
+  // Make two fetch requests that reuse the same fetch object
+  Sentry.startSpan({ name: 'does-not-matter-1' }, () =>
+    fetch('http://example.com/fetch-pojo', fetchOptions)
+      .then(res => res.text())
+      .then(() =>
+        Sentry.startSpan({ name: 'does-not-matter-2' }, () => fetch('http://example.com/fetch-pojo', fetchOptions)),
+      ),
+  );
+});
+
+fetchArray.addEventListener('click', () => {
+  const fetchOptions = {
+    headers: [
+      ['sentry-trace', '12312012123120121231201212312012-1121201211212012-1'],
+      ['baggage', 'sentry-release=4.2.0'],
+    ],
+  };
+
+  // Make two fetch requests that reuse the same fetch object
+  Sentry.startSpan({ name: 'does-not-matter-1' }, () =>
+    fetch('http://example.com/fetch-array', fetchOptions)
+      .then(res => res.text())
+      .then(() =>
+        Sentry.startSpan({ name: 'does-not-matter-2' }, () => fetch('http://example.com/fetch-array', fetchOptions)),
+      ),
+  );
+});
+
+fetchHeaders.addEventListener('click', () => {
+  const fetchOptions = {
+    headers: new Headers({
+      'sentry-trace': '12312012123120121231201212312012-1121201211212012-1',
+      baggage: 'sentry-release=4.2.0',
+    }),
+  };
+
+  // Make two fetch requests that reuse the same fetch object
+  Sentry.startSpan({ name: 'does-not-matter-1' }, () =>
+    fetch('http://example.com/fetch-headers', fetchOptions)
+      .then(res => res.text())
+      .then(() =>
+        Sentry.startSpan({ name: 'does-not-matter-2' }, () => fetch('http://example.com/fetch-headers', fetchOptions)),
+      ),
+  );
+});

dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/trace-header-merging/template.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+  </head>
+  <body>
+    <button id="fetchPojo">Fetch POJO</button>
+    <button id="fetchArray">Fetch array</button>
+    <button id="fetchHeaders">Fetch Headers</button>
+  </body>
+</html>

dev-packages/browser-integration-tests/suites/tracing/trace-lifetime/trace-header-merging/test.ts

@@ -0,0 +1,64 @@
+import type { Page, Request } from '@playwright/test';
+import { expect } from '@playwright/test';
+import { sentryTest } from '../../../../utils/fixtures';
+import { shouldSkipTracingTest } from '../../../../utils/helpers';
+
+async function assertRequests({
+  page,
+  buttonSelector,
+  requestMatcher,
+}: { page: Page; buttonSelector: string; requestMatcher: string }) {
+  const requests = await new Promise<Request[]>(resolve => {
+    const requests: Request[] = [];
+    page
+      .route(requestMatcher, (route, request) => {
+        requests.push(request);
+        if (requests.length === 2) {
+          resolve(requests);
+        }
+
+        return route.fulfill({
+          status: 200,
+          contentType: 'application/json',
+          body: JSON.stringify({}),
+        });
+      })
+      .then(() => {
+        page.click(buttonSelector);
+      });
+  });
+
+  requests.forEach(request => {
+    const headers = request.headers();
+
+    // No merged sentry trace headers
+    expect(headers['sentry-trace']).not.toContain(',');
+
+    // No multiple baggage entries
+    expect(headers['baggage'].match(/sentry-trace_id/g) ?? []).toHaveLength(1);
+  });
+}
+
+sentryTest(
+  'Ensure the SDK does not infinitely append tracing headers to outgoing requests',
+  async ({ getLocalTestUrl, page }) => {
+    if (shouldSkipTracingTest()) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    await page.goto(url);
+
+    await sentryTest.step('fetch with POJO', () =>
+      assertRequests({ page, buttonSelector: '#fetchPojo', requestMatcher: 'http://example.com/fetch-pojo' }),
+    );
+
+    await sentryTest.step('fetch with array', () =>
+      assertRequests({ page, buttonSelector: '#fetchArray', requestMatcher: 'http://example.com/fetch-array' }),
+    );
+
+    await sentryTest.step('fetch with Headers instance', () =>
+      assertRequests({ page, buttonSelector: '#fetchHeaders', requestMatcher: 'http://example.com/fetch-headers' }),
+    );
+  },
+);

dev-packages/e2e-tests/test-applications/cloudflare-astro/package.json

@@ -19,7 +19,7 @@
   "dependencies": {
     "@astrojs/cloudflare": "8.1.0",
     "@sentry/astro": "latest || *",
-    "astro": "4.1.1"
+    "astro": "4.16.1"
   },
   "volta": {
     "extends": "../../package.json"

dev-packages/e2e-tests/test-applications/nextjs-15/package.json

@@ -9,7 +9,8 @@
     "test:dev": "TEST_ENV=development playwright test",
     "test:build": "pnpm install && npx playwright install && pnpm build",
     "test:build-canary": "pnpm install && pnpm add next@canary && pnpm add react@beta && pnpm add react-dom@beta && npx playwright install && pnpm build",
-    "test:build-latest": "pnpm install && pnpm add next@rc && pnpm add react@beta && pnpm add react-dom@beta && npx playwright install && pnpm build",
+    "//": "15.0.0-canary.194 is the canary release attached to Next.js RC 1. We need to use the canary version instead of the RC because PPR will not work without. The specific react version is also attached to RC 1.",
+    "test:build-latest": "pnpm install && pnpm add [email protected] && pnpm add [email protected] && pnpm add [email protected] && npx playwright install && pnpm build",
     "test:assert": "pnpm test:prod && pnpm test:dev"
   },
   "dependencies": {