Merge branch 'develop' into cg-next-refactor-withsentryconfig

Author: chargome

CHANGELOG.md

@@ -23,6 +23,25 @@
   Sentry.metrics.count('response_time', 283.33, { unit: 'millisecond' });
   ```
 
+- **feat(wasm): Add applicationKey option for third-party error filtering ([#18762])(https://github.com/getsentry/sentry-javascript/pull/18762)**
+
+  Adds support for applying an application key to WASM stack frames that can be then used in the `thirdPartyErrorFilterIntegration` for detection of first-party code.
+
+  Usage:
+
+  ```js
+  Sentry.init({
+    integrations: [
+      // Integration order matters: wasmIntegration needs to be before thirdPartyErrorFilterIntegration
+      wasmIntegration({ applicationKey: 'your-custom-application-key' }), ←───┐
+      thirdPartyErrorFilterIntegration({                                      │
+        behaviour: 'drop-error-if-exclusively-contains-third-party-frames',   ├─ matching keys
+        filterKeys: ['your-custom-application-key'] ←─────────────────────────┘
+      }),
+    ],
+  });
+  ```
+
 - ref(nextjs): Drop `resolve` dependency from the Next.js SDK ([#18618](https://github.com/getsentry/sentry-javascript/pull/18618))
 
 ## 10.32.1

dev-packages/browser-integration-tests/suites/public-api/metrics/simple/test.ts

@@ -136,7 +136,7 @@ sentryTest('should capture all metric types', async ({ getLocalTestUrl, page })
             },
             'sentry.sdk.version': {
               type: 'string',
-              value: '10.32.1',
+              value: expect.any(String),
             },
             'user.email': {
               type: 'string',

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

@@ -0,0 +1,36 @@
+import * as Sentry from '@sentry/browser';
+import { thirdPartyErrorFilterIntegration } from '@sentry/browser';
+import { wasmIntegration } from '@sentry/wasm';
+
+// Simulate what the bundler plugin would inject to mark JS code as first-party
+var _sentryModuleMetadataGlobal =
+  typeof window !== 'undefined'
+    ? window
+    : typeof global !== 'undefined'
+      ? global
+      : typeof self !== 'undefined'
+        ? self
+        : {};
+
+_sentryModuleMetadataGlobal._sentryModuleMetadata = _sentryModuleMetadataGlobal._sentryModuleMetadata || {};
+
+_sentryModuleMetadataGlobal._sentryModuleMetadata[new Error().stack] = Object.assign(
+  {},
+  _sentryModuleMetadataGlobal._sentryModuleMetadata[new Error().stack],
+  {
+    '_sentryBundlerPluginAppKey:wasm-test-app': true,
+  },
+);
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  integrations: [
+    wasmIntegration({ applicationKey: 'wasm-test-app' }),
+    thirdPartyErrorFilterIntegration({
+      behaviour: 'apply-tag-if-contains-third-party-frames',
+      filterKeys: ['wasm-test-app'],
+    }),
+  ],
+});

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

@@ -0,0 +1,35 @@
+// Simulate what the bundler plugin would inject to mark this JS file as first-party
+var _sentryModuleMetadataGlobal =
+  typeof window !== 'undefined'
+    ? window
+    : typeof global !== 'undefined'
+      ? global
+      : typeof self !== 'undefined'
+        ? self
+        : {};
+
+_sentryModuleMetadataGlobal._sentryModuleMetadata = _sentryModuleMetadataGlobal._sentryModuleMetadata || {};
+
+_sentryModuleMetadataGlobal._sentryModuleMetadata[new Error().stack] = Object.assign(
+  {},
+  _sentryModuleMetadataGlobal._sentryModuleMetadata[new Error().stack],
+  {
+    '_sentryBundlerPluginAppKey:wasm-test-app': true,
+  },
+);
+
+async function runWasm() {
+  function crash() {
+    throw new Error('WASM triggered error');
+  }
+
+  const { instance } = await WebAssembly.instantiateStreaming(fetch('https://localhost:5887/simple.wasm'), {
+    env: {
+      external_func: crash,
+    },
+  });
+
+  instance.exports.internal_func();
+}
+
+runWasm();

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

@@ -0,0 +1,56 @@
+import { expect } from '@playwright/test';
+import fs from 'fs';
+import path from 'path';
+import { sentryTest } from '../../../utils/fixtures';
+import { envelopeRequestParser, waitForErrorRequest } from '../../../utils/helpers';
+import { shouldSkipWASMTests } from '../../../utils/wasmHelpers';
+
+const bundle = process.env.PW_BUNDLE || '';
+// We only want to run this in non-CDN bundle mode because both
+// wasmIntegration and thirdPartyErrorFilterIntegration are only available in NPM packages
+if (bundle.startsWith('bundle')) {
+  sentryTest.skip();
+}
+
+sentryTest(
+  'WASM frames should be recognized as first-party when applicationKey is configured',
+  async ({ getLocalTestUrl, page, browserName }) => {
+    if (shouldSkipWASMTests(browserName)) {
+      sentryTest.skip();
+    }
+
+    const url = await getLocalTestUrl({ testDir: __dirname });
+
+    await page.route('**/simple.wasm', route => {
+      const wasmModule = fs.readFileSync(path.resolve(__dirname, '../simple.wasm'));
+
+      return route.fulfill({
+        status: 200,
+        body: wasmModule,
+        headers: {
+          'Content-Type': 'application/wasm',
+        },
+      });
+    });
+
+    const errorEventPromise = waitForErrorRequest(page, e => {
+      return e.exception?.values?.[0]?.value === 'WASM triggered error';
+    });
+
+    await page.goto(url);
+
+    const errorEvent = envelopeRequestParser(await errorEventPromise);
+
+    expect(errorEvent.tags?.third_party_code).toBeUndefined();
+
+    // Verify we have WASM frames in the stacktrace
+    expect(errorEvent.exception?.values?.[0]?.stacktrace?.frames).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          filename: expect.stringMatching(/simple\.wasm$/),
+          platform: 'native',
+        }),
+      ]),
+    );
+  },
+);

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

@@ -67,8 +67,13 @@ export function createRunner(...paths: string[]) {
   const expectedEnvelopes: Expected[] = [];
   // By default, we ignore session & sessions
   const ignored: Set<EnvelopeItemType> = new Set(['session', 'sessions', 'client_report']);
+  let serverUrl: string | undefined;
 
   return {
+    withServerUrl: function (url: string) {
+      serverUrl = url;
+      return this;
+    },
     expect: function (expected: Expected) {
       expectedEnvelopes.push(expected);
       return this;
@@ -186,6 +191,8 @@ export function createRunner(...paths: string[]) {
               'false',
               '--var',
               `SENTRY_DSN:http://public@localhost:${mockServerPort}/1337`,
+              '--var',
+              `SERVER_URL:${serverUrl}`,
             ],
             { stdio, signal },
           );

dev-packages/cloudflare-integration-tests/suites/tracing/headers/index.ts

@@ -0,0 +1,19 @@
+import * as Sentry from '@sentry/cloudflare';
+
+interface Env {
+  SENTRY_DSN: string;
+  SERVER_URL: string;
+}
+
+export default Sentry.withSentry(
+  (env: Env) => ({
+    dsn: env.SENTRY_DSN,
+    propagateTraceparent: true,
+  }),
+  {
+    async fetch(_request, env, _ctx) {
+      await fetch(env.SERVER_URL);
+      throw new Error('Test error to capture trace headers');
+    },
+  },
+);

dev-packages/cloudflare-integration-tests/suites/tracing/headers/test.ts

@@ -0,0 +1,59 @@
+import { createTestServer } from '@sentry-internal/test-utils';
+import { expect, it } from 'vitest';
+import { eventEnvelope } from '../../../expect';
+import { createRunner } from '../../../runner';
+
+it('Tracing headers', async ({ signal }) => {
+  expect.assertions(5);
+
+  const [SERVER_URL, closeTestServer] = await createTestServer()
+    .get('/', headers => {
+      expect(headers['baggage']).toEqual(expect.any(String));
+      expect(headers['sentry-trace']).toEqual(expect.stringMatching(/^([a-f\d]{32})-([a-f\d]{16})-0$/));
+      expect(headers['sentry-trace']).not.toEqual('00000000000000000000000000000000-0000000000000000-0');
+      expect(headers['traceparent']).toEqual(expect.stringMatching(/^00-([a-f\d]{32})-([a-f\d]{16})-00$/));
+    })
+    .start();
+
+  const runner = createRunner(__dirname)
+    .withServerUrl(SERVER_URL)
+    .expect(
+      eventEnvelope({
+        level: 'error',
+        exception: {
+          values: [
+            {
+              type: 'Error',
+              value: 'Test error to capture trace headers',
+              stacktrace: {
+                frames: expect.any(Array),
+              },
+              mechanism: { type: 'auto.http.cloudflare', handled: false },
+            },
+          ],
+        },
+        breadcrumbs: [
+          {
+            category: 'fetch',
+            data: {
+              method: 'GET',
+              status_code: 200,
+              url: expect.stringContaining('http://localhost:'),
+            },
+            timestamp: expect.any(Number),
+            type: 'http',
+          },
+        ],
+        request: {
+          headers: expect.any(Object),
+          method: 'GET',
+          url: expect.any(String),
+        },
+      }),
+    )
+    .start(signal);
+
+  await runner.makeRequest('get', '/');
+  await runner.completed();
+  closeTestServer();
+});

dev-packages/cloudflare-integration-tests/suites/tracing/headers/wrangler.jsonc

@@ -0,0 +1,6 @@
+{
+  "name": "worker-name",
+  "compatibility_date": "2025-06-17",
+  "main": "index.ts",
+  "compatibility_flags": ["nodejs_compat"]
+}

dev-packages/node-core-integration-tests/suites/ipv6/scenario.ts

@@ -1,4 +1,4 @@
-import * as Sentry from '@sentry/node';
+import * as Sentry from '@sentry/node-core';
 import { loggingTransport } from '@sentry-internal/node-integration-tests';
 
 Sentry.init({