Merge branch 'develop' into sig/wrap-with-resolver-nuxt

Author: s1gr1d

CHANGELOG.md

@@ -14,6 +14,7 @@ Work in this release was contributed by @psh4607, @thijsw, @trinitiwowka, @nehap
   - `DenoMongoose` => `Mongoose`
   - `DenoMysql` => `Mysql`
   - `DenoPostgres` => `Postgres`
+- feat(node): Add first-party Mastra integration ([#23823](https://github.com/getsentry/sentry-javascript/pull/23823)). Enabled by default; disable with `defaultIntegrations: integrations => integrations.filter(i => i.name !== 'Mastra')`.
 - **feat(browser): Add `bfcacheMetricsIntegration` to track back/forward cache health**
 
   The new opt-in `bfcacheMetricsIntegration` emits metrics about browser back/forward cache (bfcache) navigations, so you can

MIGRATION.md

@@ -246,6 +246,12 @@ User IP address inference, which was previously gated on `sendDefaultPii`, is no
 `dataCollection.userInfo`. An explicit `requestDataIntegration({ include: { ip: true } })` overrides
 `dataCollection.userInfo: false` for data collected by that integration.
 
+#### Astro client IP
+
+`trackClientIp` no longer defaults to `false`. When you leave it unset, `handleRequest` now follows
+`dataCollection.userInfo`, which defaults to `true`, so Astro apps that set neither option start
+reporting `user.ip_address`. Pass `trackClientIp: false` to keep the v10 behaviour.
+
 #### Remix action form data
 
 `captureActionFormDataKeys` is an integration-level override, so it no longer requires
@@ -1303,6 +1309,41 @@ Affected SDKs: `@sentry/remix`.
 
 The plugin now also applies the build-time instrumentation transform. If you added `sentryOrchestrionPlugin()` from `@sentry/server-utils/orchestrion/vite` to your Vite config manually, remove it. Opt out with `sentryRemixVitePlugin({ buildTimeInstrumentation: false })`.
 
+### React: Simpler React Router setup via `@sentry/react/react-router`
+
+Affected SDKs: `@sentry/react`.
+
+`@sentry/react` gained a new `@sentry/react/react-router` entry point that pulls the required React Router hooks (`useLocation`, `useNavigationType`, `matchRoutes`, `createRoutesFromChildren`) from `react-router` for you, so you no longer have to thread them through `reactRouterBrowserTracingIntegration` yourself:
+
+```diff
+- import * as Sentry from '@sentry/react';
+- import { useEffect } from 'react';
+- import { createRoutesFromChildren, matchRoutes, useLocation, useNavigationType } from 'react-router';
++ import * as Sentry from '@sentry/react';
++ import { reactRouterBrowserTracingIntegration } from '@sentry/react/react-router';
+
+  Sentry.init({
+    integrations: [
+-     Sentry.reactRouterBrowserTracingIntegration({
+-       useEffect,
+-       useLocation,
+-       useNavigationType,
+-       createRoutesFromChildren,
+-       matchRoutes,
+-     }),
++     reactRouterBrowserTracingIntegration(),
+    ],
+  });
+```
+
+The `wrapReactRouterRouting`, `wrapUseRoutes`, `wrapCreateBrowserRouter` and `wrapCreateMemoryRouter` helpers are re-exported from `@sentry/react/react-router` as well.
+
+This entry requires `react-router` to be resolvable — it is declared as an optional peer dependency and supports React Router v6, v7 and v8. If you are on React Router v6 with only `react-router-dom` installed, either add `react-router` as a dependency or keep importing `reactRouterBrowserTracingIntegration` from `@sentry/react` and pass the hooks explicitly.
+
+The existing `@sentry/react` API is unchanged and keeps working; passing the hooks there is now optional too (`useEffect` in particular is no longer used and can be omitted).
+
+Additionally — for **every** `@sentry/react` routing setup, not just the new entry — the order in which you add the browser tracing integration and wrap your routes no longer matters.
+
 ## 3. Removed APIs
 
 ### `@sentry/core` / All SDKs
@@ -2133,6 +2174,7 @@ The main entry re-exported the build plugin statically, which pulled the whole b
   `any`.
 - Attribute typing and serialization were unified across the SDK.
 - The `attributes` field on the `ScopeData` type is now required. `Scope.getScopeData()` always returned it, so this only affects code that constructs `ScopeData` objects manually — add `attributes: {}` there.
+- The `attributes` field on the `SamplingContext` passed to `tracesSampler` is now required (previously optional); it is always provided by the SDK, so this only affects code that narrows or constructs `SamplingContext` objects by hand.
 - The `endTimestamp` property was removed from the `SentrySpanArguments` interface. It was never part of
   `StartSpanOptions`, so it could only be passed by ignoring TypeScript, in which case the span ended itself
   during construction. Call `span.end(timestamp)` instead.

dev-packages/browser-integration-tests/suites/wasm/instantiateBufferRegistration/init.js

@@ -0,0 +1,20 @@
+import * as Sentry from '@sentry/browser';
+import { registerWebWorkerWasm } from '@sentry/wasm';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  traceLifecycle: 'static',
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+});
+
+// `registerWebWorkerWasm` installs the same patches a worker would, and reports
+// every registered module to the scope it is given. Collecting them here is the
+// only way to observe registration from the page, since main-thread images stay
+// module-internal until a frame matches one.
+window.registeredImages = [];
+registerWebWorkerWasm({
+  self: {
+    postMessage: message => window.registeredImages.push(...(message._sentryWasmImages || [])),
+  },
+});

dev-packages/browser-integration-tests/suites/wasm/instantiateBufferRegistration/subject.js

@@ -0,0 +1,12 @@
+window.loadWasmFromBuffer = async () => {
+  const response = await fetch('https://localhost:5887/simple.wasm');
+  const buffer = await response.arrayBuffer();
+
+  await WebAssembly.instantiate(new Uint8Array(buffer), {
+    env: {
+      external_func: () => {},
+    },
+  });
+
+  return window.registeredImages;
+};

dev-packages/browser-integration-tests/suites/wasm/instantiateBufferRegistration/test.ts

@@ -0,0 +1,48 @@
+import type { Page, Route } from '@playwright/test';
+import { expect } from '@playwright/test';
+import fs from 'fs';
+import path from 'path';
+import { sentryTest } from '../../../utils/fixtures';
+import { shouldSkipWASMTests } from '../../../utils/wasmHelpers';
+
+function serveWasmFixture(page: Page): Promise<void> {
+  return page.route('**/simple.wasm', (route: Route) => {
+    const wasmModule = fs.readFileSync(path.resolve(__dirname, '..', 'simple.wasm'));
+
+    return route.fulfill({
+      status: 200,
+      body: wasmModule,
+      headers: {
+        'Content-Type': 'application/wasm',
+      },
+    });
+  });
+}
+
+sentryTest(
+  'registers a module loaded via fetch, arrayBuffer and instantiate under its response url',
+  async ({ getLocalTestUrl, page, browserName }) => {
+    if (shouldSkipWASMTests(browserName)) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+    await serveWasmFixture(page);
+    await page.goto(url);
+
+    const images = await page.evaluate(async () => {
+      // @ts-expect-error this function exists
+      return window.loadWasmFromBuffer();
+    });
+
+    expect(images).toEqual([
+      {
+        type: 'wasm',
+        code_file: 'https://localhost:5887/simple.wasm',
+        code_id: '0ba020cdd2444f7eafdd25999a8e9010',
+        debug_file: null,
+        debug_id: '0ba020cdd2444f7eafdd25999a8e90100',
+      },
+    ]);
+  },
+);

dev-packages/cloudflare-integration-tests/runner.ts

@@ -141,6 +141,8 @@ type Expected = Envelope | ((envelope: Envelope) => void);
 
 type StartResult = {
   completed(): Promise<void>;
+  /** Every non-ignored envelope received so far, matched or not, for count assertions. */
+  getReceivedEnvelopes(): Envelope[];
   makeRequest<T>(
     method: 'get' | 'post',
     path: string,
@@ -225,6 +227,7 @@ export function createRunner(...paths: string[]) {
       });
 
       const expectedEnvelopeCount = expectedEnvelopes.length;
+      const receivedEnvelopes: Envelope[] = [];
 
       let envelopeCount = 0;
       let unexpectedEnvelopeError: Error | undefined;
@@ -271,6 +274,8 @@ export function createRunner(...paths: string[]) {
           return;
         }
 
+        receivedEnvelopes.push(envelope);
+
         // Resolve per-request waiters first, matching in any order so a request
         // expecting multiple envelopes isn't sensitive to their arrival order.
         if (envelopeWaiters.length > 0) {
@@ -444,6 +449,9 @@ export function createRunner(...paths: string[]) {
             throw unexpectedEnvelopeError;
           }
         },
+        getReceivedEnvelopes: function (): Envelope[] {
+          return receivedEnvelopes;
+        },
         makeRequest: async function <T>(
           method: 'get' | 'post',
           path: string,

dev-packages/cloudflare-integration-tests/suites/vite-autoinstrument/durableobject-reexport-instrumented/index.ts

@@ -8,10 +8,11 @@ interface Env {
 // `Counter` is imported from another module (`./counter`) where it was already
 // manually wrapped with `instrumentDurableObjectWithSentry`, then re-exported
 // here. The auto-instrument transform runs over this entry and sees
-// `export { Counter }`, but `Counter` is an imported binding — not a local class
-// declaration — so it cannot (and must not) wrap it. The DO stays instrumented
-// solely via the manual wrap in `./counter`, and the plain default export below
-// is still auto-wrapped with `withSentry`.
+// `export { Counter }`, but nothing in this file reveals that the binding is
+// already wrapped, so it emits its wrapper behind a guard
+// (`_INTERNAL_wrapUnlessInstrumented`) that returns the manual wrap unchanged
+// instead of nesting. The plain default export below is still auto-wrapped
+// with `withSentry`.
 export { Counter };
 
 export default {

dev-packages/cloudflare-integration-tests/suites/vite-autoinstrument/durableobject-reexport-instrumented/test.ts

@@ -43,12 +43,13 @@ function expectMainWorkerTransaction(transactionEvent: TransactionEvent): void {
 
 // `Counter` is manually wrapped with `instrumentDurableObjectWithSentry` in a
 // separate module (`./counter`), imported into the entry, and re-exported via a
-// plain `export { Counter }`. Because `Counter` is an imported binding rather
-// than a local class declaration, the transform cannot wrap it in the entry and
-// must leave it alone — no double-wrap, no broken build. The DO stays
-// instrumented via the manual wrap, so we still expect a storage-bearing DO
-// transaction, alongside the auto-wrapped default export's child-less one.
-it('leaves an imported, already-instrumented Durable Object untouched and still wraps the default export', async ({
+// plain `export { Counter }`. The transform sees only the imported binding, so it
+// emits its wrapper behind `_INTERNAL_wrapUnlessInstrumented`, which recognizes
+// the hand-wrapped class and hands it straight back. Without that guard the two
+// wrappers nest and every storage call reports twice, so the exactly-two span
+// assertion below is the real check. The DO stays instrumented via the manual
+// wrap, alongside the auto-wrapped default export's child-less transaction.
+it('does not double-instrument an imported, already-wrapped Durable Object and still wraps the default export', async ({
   signal,
 }) => {
   const runner = createRunner(__dirname)

dev-packages/cloudflare-integration-tests/suites/vite-autoinstrument/workerentrypoint-reexport-instrumented/greeter.ts

@@ -0,0 +1,19 @@
+import * as Sentry from '@sentry/cloudflare';
+import { WorkerEntrypoint } from 'cloudflare:workers';
+
+interface Env {
+  SENTRY_DSN: string;
+}
+
+class GreeterImpl extends WorkerEntrypoint<Env> {
+  async fetch(): Promise<Response> {
+    return new Response('Hello from the entrypoint');
+  }
+}
+
+// Manually instrumented here, in a module separate from the worker entry, which
+// only imports and re-exports the wrapped class.
+export const GreeterEntrypoint = Sentry.withSentry(
+  (env: Env) => ({ dsn: env.SENTRY_DSN, traceLifecycle: 'static', tracesSampleRate: 1.0 }),
+  GreeterImpl,
+);

dev-packages/cloudflare-integration-tests/suites/vite-autoinstrument/workerentrypoint-reexport-instrumented/index.ts

@@ -0,0 +1,25 @@
+import { GreeterEntrypoint } from './greeter';
+
+interface Env {
+  SENTRY_DSN: string;
+  SELF: Fetcher;
+}
+
+// `GreeterEntrypoint` was already wrapped by hand in `./greeter`. The
+// auto-instrument transform cannot see that from this entry (it only knows the
+// class from the self service binding in wrangler.jsonc), so it emits its
+// wrapper behind `_INTERNAL_wrapUnlessInstrumented`, which hands the manual
+// wrap back unchanged instead of nesting a second wrapper around it.
+export { GreeterEntrypoint };
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const url = new URL(request.url);
+
+    if (url.pathname === '/call-entrypoint') {
+      return env.SELF.fetch(new Request('https://self/greet'));
+    }
+
+    return new Response('Not found', { status: 404 });
+  },
+} satisfies ExportedHandler<Env>;