diff --git a/dev-packages/e2e-tests/test-applications/browser-webworker-vite/index.html b/dev-packages/e2e-tests/test-applications/browser-webworker-vite/index.html index 0ebc79719432..fea43a70c1de 100644 --- a/dev-packages/e2e-tests/test-applications/browser-webworker-vite/index.html +++ b/dev-packages/e2e-tests/test-applications/browser-webworker-vite/index.html @@ -17,5 +17,9 @@ + + diff --git a/dev-packages/e2e-tests/test-applications/browser-webworker-vite/src/main.ts b/dev-packages/e2e-tests/test-applications/browser-webworker-vite/src/main.ts index 238ec062663a..e62becc39603 100644 --- a/dev-packages/e2e-tests/test-applications/browser-webworker-vite/src/main.ts +++ b/dev-packages/e2e-tests/test-applications/browser-webworker-vite/src/main.ts @@ -23,6 +23,14 @@ const worker2 = new MyWorker2(); const webWorkerIntegration = Sentry.webWorkerIntegration({ worker: [worker, worker2] }); Sentry.addIntegration(webWorkerIntegration); +worker.addEventListener('error', event => { + // this is part of the test, do not delete + (window as any).workerErrorEvents = [ + ...((window as any).workerErrorEvents ?? []), + { message: event.message, hasError: !!event.error }, + ]; +}); + worker.addEventListener('message', event => { // this is part of the test, do not delete console.log('received message from worker:', event.data.msg); @@ -34,12 +42,23 @@ document.querySelector('#trigger-error')!.addEventListener('c }); }); +document.querySelector('#trigger-primitive-error')!.addEventListener('click', () => { + worker.postMessage({ + msg: 'TRIGGER_PRIMITIVE_ERROR', + }); +}); + document.querySelector('#trigger-error-2')!.addEventListener('click', () => { worker2.postMessage({ msg: 'TRIGGER_ERROR', }); }); +document.querySelector('#trigger-startup-error')!.addEventListener('click', async () => { + const Worker4 = await import('./worker4.ts?worker'); + webWorkerIntegration.addWorker(new Worker4.default()); +}); + document.querySelector('#trigger-error-3')!.addEventListener('click', async () => { const Worker3 = await import('./worker3.ts?worker'); const worker3 = new Worker3.default(); diff --git a/dev-packages/e2e-tests/test-applications/browser-webworker-vite/src/worker.ts b/dev-packages/e2e-tests/test-applications/browser-webworker-vite/src/worker.ts index 6ed994e9006b..7d37932d7302 100644 --- a/dev-packages/e2e-tests/test-applications/browser-webworker-vite/src/worker.ts +++ b/dev-packages/e2e-tests/test-applications/browser-webworker-vite/src/worker.ts @@ -12,4 +12,9 @@ self.addEventListener('message', event => { // This will throw an uncaught error in the worker throw new Error(`Uncaught error in worker`); } + + if (event.data.msg === 'TRIGGER_PRIMITIVE_ERROR') { + // A thrown primitive has no stack, so only the ErrorEvent knows where it came from + throw 'Primitive thrown in worker'; + } }); diff --git a/dev-packages/e2e-tests/test-applications/browser-webworker-vite/src/worker4.ts b/dev-packages/e2e-tests/test-applications/browser-webworker-vite/src/worker4.ts new file mode 100644 index 000000000000..c3fe81ff33ab --- /dev/null +++ b/dev-packages/e2e-tests/test-applications/browser-webworker-vite/src/worker4.ts @@ -0,0 +1,6 @@ +import * as Sentry from '@sentry/browser'; + +Sentry.registerWebWorker({ self }); + +// Thrown while the worker script first runs, before the page's acknowledgement can arrive +throw new Error('Uncaught error during worker startup'); diff --git a/dev-packages/e2e-tests/test-applications/browser-webworker-vite/tests/errors.test.ts b/dev-packages/e2e-tests/test-applications/browser-webworker-vite/tests/errors.test.ts index a253c5ef4847..d000eb1e128c 100644 --- a/dev-packages/e2e-tests/test-applications/browser-webworker-vite/tests/errors.test.ts +++ b/dev-packages/e2e-tests/test-applications/browser-webworker-vite/tests/errors.test.ts @@ -7,6 +7,11 @@ function waitForPageloadSpan() { }); } +// The throw still bubbles to the page after the worker forwards it, but +// the integration makes globalHandlers skip that frameless copy. So the +// first error event to arrive must be the forwarded one. +const WORKER_MECHANISM = 'auto.browser.web_worker.onerror'; + test('captures an error with debug ids and pageload trace context', async ({ page }) => { const errorEventPromise = waitForError('browser-webworker-vite', async event => { return !event.type && !!event.exception?.values?.[0]; @@ -24,9 +29,16 @@ test('captures an error with debug ids and pageload trace context', async ({ pag const pageloadSpan = await pageloadSpanPromise; expect(errorEvent.exception?.values).toHaveLength(1); - expect(errorEvent.exception?.values?.[0]?.value).toBe('Uncaught Error: Uncaught error in worker'); - expect(errorEvent.exception?.values?.[0]?.stacktrace?.frames).toHaveLength(1); - expect(errorEvent.exception?.values?.[0]?.stacktrace?.frames?.[0]?.filename).toMatch(/worker-.+\.js$/); + expect(errorEvent.exception?.values?.[0]?.mechanism?.type).toBe(WORKER_MECHANISM); + expect(errorEvent.exception?.values?.[0]?.type).toBe('Error'); + expect(errorEvent.exception?.values?.[0]?.value).toBe('Uncaught error in worker'); + expect(errorEvent.exception?.values?.[0]?.stacktrace?.frames).toEqual( + expect.arrayContaining([expect.objectContaining({ filename: expect.stringMatching(/worker-.+\.js$/) })]), + ); + + expect(errorEvent.contexts?.worker).toEqual({ + filename: expect.stringMatching(/worker-.+\.js$/), + }); expect(errorEvent.transaction).toBe('/'); expect(pageloadSpan.name).toBe('Pageload'); @@ -52,6 +64,89 @@ test('captures an error with debug ids and pageload trace context', async ({ pag }); }); +test('emits exactly one event for an uncaught worker error', async ({ page }) => { + const mechanisms: Array = []; + // Records on the same stream it resolves on, since events are not ordered across streams. + const secondErrorPromise = waitForError('browser-webworker-vite', event => { + if (!event.type && event.exception?.values?.[0]) { + mechanisms.push(event.exception.values[0].mechanism?.type); + } + return event.exception?.values?.[0]?.value === 'Uncaught error in worker 2'; + }); + const firstErrorPromise = waitForError('browser-webworker-vite', event => { + return event.exception?.values?.[0]?.value === 'Uncaught error in worker'; + }); + + await page.goto('/'); + + await page.locator('#trigger-error').click(); + await firstErrorPromise; + + // Page listeners on the worker object still get the native event, once. + expect(await page.evaluate(() => (window as any).workerErrorEvents)).toEqual([ + { message: 'Uncaught Error: Uncaught error in worker', hasError: false }, + ]); + + // A bubbled copy of the first throw would have been reported before the + // second worker's event, so its absence here shows it never happened. + await page.locator('#trigger-error-2').click(); + await secondErrorPromise; + + expect(mechanisms).toEqual([WORKER_MECHANISM, WORKER_MECHANISM]); +}); + +test('locates a thrown primitive by its ErrorEvent position', async ({ page }) => { + const errorEventPromise = waitForError('browser-webworker-vite', event => { + return event.exception?.values?.[0]?.value === 'Primitive thrown in worker'; + }); + + await page.goto('/'); + + await page.locator('#trigger-primitive-error').click(); + + const errorEvent = await errorEventPromise; + const exception = errorEvent.exception?.values?.[0]; + + expect(exception?.mechanism?.type).toBe(WORKER_MECHANISM); + expect(exception?.stacktrace?.frames).toEqual([ + { + filename: expect.stringMatching(/worker-.+\.js$/), + lineno: expect.any(Number), + colno: expect.any(Number), + function: '?', + in_app: true, + }, + ]); + expect(exception?.stacktrace?.frames?.[0]?.lineno).toBeGreaterThan(0); + expect(exception?.stacktrace?.frames?.[0]?.colno).toBeGreaterThan(0); +}); + +test('emits exactly one event for an error thrown during worker startup', async ({ page }) => { + const values: Array = []; + // Records on the same stream it resolves on, since events are not ordered across streams. + const laterErrorPromise = waitForError('browser-webworker-vite', event => { + const value = event.exception?.values?.[0]?.value; + if (value?.includes('Uncaught error during worker startup')) { + values.push(value); + } + return value === 'Uncaught error in worker'; + }); + const startupErrorPromise = waitForError('browser-webworker-vite', event => { + return !!event.exception?.values?.[0]?.value?.includes('Uncaught error during worker startup'); + }); + + await page.goto('/'); + + await page.locator('#trigger-startup-error').click(); + await startupErrorPromise; + + // Any duplicate of the startup error is sent long before this later error. + await page.locator('#trigger-error').click(); + await laterErrorPromise; + + expect(values).toHaveLength(1); +}); + test("user worker message handlers don't trigger for sentry messages", async ({ page }) => { const workerReadyPromise = new Promise(resolve => { let workerMessageCount = 0; @@ -90,9 +185,11 @@ test('captures an error from the second eagerly added worker', async ({ page }) const pageloadSpan = await pageloadSpanPromise; expect(errorEvent.exception?.values).toHaveLength(1); - expect(errorEvent.exception?.values?.[0]?.value).toBe('Uncaught Error: Uncaught error in worker 2'); - expect(errorEvent.exception?.values?.[0]?.stacktrace?.frames).toHaveLength(1); - expect(errorEvent.exception?.values?.[0]?.stacktrace?.frames?.[0]?.filename).toMatch(/worker2-.+\.js$/); + expect(errorEvent.exception?.values?.[0]?.mechanism?.type).toBe(WORKER_MECHANISM); + expect(errorEvent.exception?.values?.[0]?.value).toBe('Uncaught error in worker 2'); + expect(errorEvent.exception?.values?.[0]?.stacktrace?.frames).toEqual( + expect.arrayContaining([expect.objectContaining({ filename: expect.stringMatching(/worker2-.+\.js$/) })]), + ); expect(errorEvent.transaction).toBe('/'); expect(pageloadSpan.name).toBe('Pageload'); @@ -135,9 +232,11 @@ test('captures an error from the third lazily added worker', async ({ page }) => const pageloadSpan = await pageloadSpanPromise; expect(errorEvent.exception?.values).toHaveLength(1); - expect(errorEvent.exception?.values?.[0]?.value).toBe('Uncaught Error: Uncaught error in worker 3'); - expect(errorEvent.exception?.values?.[0]?.stacktrace?.frames).toHaveLength(1); - expect(errorEvent.exception?.values?.[0]?.stacktrace?.frames?.[0]?.filename).toMatch(/worker3-.+\.js$/); + expect(errorEvent.exception?.values?.[0]?.mechanism?.type).toBe(WORKER_MECHANISM); + expect(errorEvent.exception?.values?.[0]?.value).toBe('Uncaught error in worker 3'); + expect(errorEvent.exception?.values?.[0]?.stacktrace?.frames).toEqual( + expect.arrayContaining([expect.objectContaining({ filename: expect.stringMatching(/worker3-.+\.js$/) })]), + ); expect(errorEvent.transaction).toBe('/'); expect(pageloadSpan.name).toBe('Pageload'); @@ -165,7 +264,7 @@ test('captures an error from the third lazily added worker', async ({ page }) => test('worker errors are not tagged as third-party when module metadata is present', async ({ page }) => { const errorEventPromise = waitForError('browser-webworker-vite', async event => { - return !event.type && event.exception?.values?.[0]?.value === 'Uncaught Error: Uncaught error in worker'; + return !event.type && event.exception?.values?.[0]?.value === 'Uncaught error in worker'; }); await page.goto('/'); diff --git a/packages/browser/src/helpers.ts b/packages/browser/src/helpers.ts index c961534df2fd..4b060abafc71 100644 --- a/packages/browser/src/helpers.ts +++ b/packages/browser/src/helpers.ts @@ -1,4 +1,4 @@ -import type { Mechanism, WrappedFunction } from '@sentry/core'; +import type { HandlerDataError, Mechanism, WrappedFunction } from '@sentry/core'; import { addExceptionMechanism, addExceptionTypeValue, @@ -15,11 +15,45 @@ export const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window; let ignoreOnError: number = 0; +type ErrorReport = Pick; + +const ignoredErrorReports: ErrorReport[] = []; + /** * @hidden */ -export function shouldIgnoreOnError(): boolean { - return ignoreOnError > 0; +export function shouldIgnoreOnError(data?: HandlerDataError): boolean { + if (ignoreOnError > 0) { + return true; + } + + const index = data ? ignoredErrorReports.findIndex(report => isSameErrorReport(report, data)) : -1; + if (index === -1) { + return false; + } + + ignoredErrorReports.splice(index, 1); + return true; +} + +/** + * Skips the next `onerror` report that matches `report`, once. A report that + * never arrives is forgotten after the current task. + * + * @hidden + */ +export function ignoreNextOnErrorMatching(report: ErrorReport): void { + ignoredErrorReports.push(report); + setTimeout(() => { + const index = ignoredErrorReports.indexOf(report); + if (index !== -1) { + ignoredErrorReports.splice(index, 1); + } + }); +} + +function isSameErrorReport(a: ErrorReport, b: ErrorReport): boolean { + return a.msg === b.msg && a.url === b.url && a.line === b.line && a.column === b.column; } /** diff --git a/packages/browser/src/integrations/globalhandlers.ts b/packages/browser/src/integrations/globalhandlers.ts index 0dbeb46a0fce..c3515a77275a 100644 --- a/packages/browser/src/integrations/globalhandlers.ts +++ b/packages/browser/src/integrations/globalhandlers.ts @@ -54,7 +54,7 @@ function _installGlobalOnErrorHandler(client: Client): void { addGlobalErrorInstrumentationHandler(data => { const { stackParser, attachStacktrace } = getOptions(); - if (getClient() !== client || shouldIgnoreOnError()) { + if (getClient() !== client || shouldIgnoreOnError(data)) { return; } @@ -156,7 +156,10 @@ export function _eventFromRejectionWithPrimitive(reason: Primitive): Event { }; } -function _enhanceEventWithInitialFrame( +/** + * Adds a frame built from the error location when the event has none. + */ +export function _enhanceEventWithInitialFrame( event: Event, url: string | undefined, lineno: number | undefined, diff --git a/packages/browser/src/integrations/webWorker.ts b/packages/browser/src/integrations/webWorker.ts index e9a8e338d287..41420d49acc0 100644 --- a/packages/browser/src/integrations/webWorker.ts +++ b/packages/browser/src/integrations/webWorker.ts @@ -1,12 +1,28 @@ import type { DebugImage, Integration, IntegrationFn } from '@sentry/core'; -import { captureEvent, debug, defineIntegration, getClient, isPlainObject, isPrimitive } from '@sentry/core'; +import { + addNonEnumerableProperty, + captureEvent, + debug, + defineIntegration, + getClient, + isError, + isPlainObject, + isPrimitive, + normalize, +} from '@sentry/core'; import { DEBUG_BUILD } from '../debug-build'; -import { eventFromUnknownInput } from '../eventbuilder'; -import { WINDOW } from '../helpers'; -import { _eventFromRejectionWithPrimitive, _getUnhandledRejectionError } from './globalhandlers'; +import { eventFromUnknownInput, extractMessage, extractType } from '../eventbuilder'; +import { ignoreNextOnErrorMatching, WINDOW } from '../helpers'; +import { + _enhanceEventWithInitialFrame, + _eventFromRejectionWithPrimitive, + _getUnhandledRejectionError, +} from './globalhandlers'; export const INTEGRATION_NAME = 'WebWorker' as const; +const MAX_FORWARDED_ERRORS = 20; + interface WebWorkerMessage { _sentryMessage: boolean; _sentryDebugIds?: Record; @@ -15,9 +31,23 @@ interface WebWorkerMessage { _sentryWasmImages?: Array; } +type WorkerErrorKind = 'error' | 'unhandledrejection'; + interface SerializedWorkerError { reason: unknown; filename?: string; + /** Absent on workers registered by an SDK version that only forwarded rejections. */ + kind?: WorkerErrorKind; + /** Structured clone resets any name outside the built-in set to `Error`. */ + name?: string; + /** The `ErrorEvent` message, matched against the copy that bubbles to `window.onerror`. */ + message?: string; + /** Script the error was thrown in, which can differ from the worker script. */ + url?: string; + lineno?: number; + colno?: number; + /** Set when `reason` is a plain `{ message, stack }` copy of an error that did not clone. */ + plainError?: boolean; } interface WebWorkerIntegrationOptions { @@ -110,6 +140,23 @@ export const webWorkerIntegration = defineIntegration(({ worker }: WebWorkerInte })) as IntegrationFn; function listenForSentryMessages(worker: Worker): void { + // Forwarded errors whose message-only copy has yet to bubble to the page. + const forwardedErrors: Array> = []; + + // The bubbled copy fires `error` on the worker object and then `window.onerror` in the same task, after the + // forward arrived. Skipping only copies of errors we actually received means a missing forward can at worst + // cause a duplicate, never a lost error. + worker.addEventListener('error', ({ message, filename, lineno, colno }) => { + const index = forwardedErrors.findIndex( + e => e.message === message && e.url === filename && e.lineno === lineno && e.colno === colno, + ); + if (index !== -1) { + // Earlier entries were cancelled inside the worker and will never bubble. + forwardedErrors.splice(0, index + 1); + ignoreNextOnErrorMatching({ msg: message, url: filename, line: lineno, column: colno }); + } + }); + worker.addEventListener('message', event => { if (isSentryMessage(event.data)) { event.stopImmediatePropagation(); // other listeners should not receive this message @@ -153,40 +200,60 @@ function listenForSentryMessages(worker: Worker): void { ]; } - // Handle unhandled rejections forwarded from worker + // Handle errors and unhandled rejections forwarded from worker if (event.data._sentryWorkerError) { - DEBUG_BUILD && debug.log('Sentry worker rejection message received', event.data._sentryWorkerError); - handleForwardedWorkerRejection(event.data._sentryWorkerError); + DEBUG_BUILD && debug.log('Sentry worker error message received', event.data._sentryWorkerError); + const { kind, message, url, lineno, colno } = event.data._sentryWorkerError; + if (kind === 'error') { + // Bounded because a worker that cancels its own errors never bubbles them. + if (forwardedErrors.push({ message, url, lineno, colno }) > MAX_FORWARDED_ERRORS) { + forwardedErrors.shift(); + } + } + handleForwardedWorkerError(event.data._sentryWorkerError); } } }); } -function handleForwardedWorkerRejection(workerError: SerializedWorkerError): void { +function handleForwardedWorkerError(workerError: SerializedWorkerError): void { + const { reason, kind, name, filename, url, lineno, colno, plainError } = workerError; + // Older workers only ever forwarded rejections and send no `kind`. + const isUnhandledRejection = kind !== 'error'; + + const error = plainError && isPlainObject(reason) ? errorFromPlain(reason) : reason; + + if (name && isError(error) && error.name !== name) { + addNonEnumerableProperty(error, 'name', name); + } + const client = getClient(); if (!client) { return; } - const stackParser = client.getOptions().stackParser; - const attachStacktrace = client.getOptions().attachStacktrace; + const { stackParser, attachStacktrace } = client.getOptions(); - const error = workerError.reason; + // Follow same pattern as globalHandlers for each source. + // A thrown primitive is not a rejection, so the rejection-specific wording must not apply to it. + const event = + isUnhandledRejection && isPrimitive(error) + ? _eventFromRejectionWithPrimitive(error) + : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, isUnhandledRejection); - // Follow same pattern as globalHandlers for unhandledrejection - // Handle both primitives and errors the same way - const event = isPrimitive(error) - ? _eventFromRejectionWithPrimitive(error) - : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true); + if (!isUnhandledRejection) { + // An ErrorEvent reports an unknown script as an empty string. + _enhanceEventWithInitialFrame(event, url || filename, lineno, colno); + } event.level = 'error'; // Add worker-specific context - if (workerError.filename) { + if (filename) { event.contexts = { ...event.contexts, worker: { - filename: workerError.filename, + filename, }, }; } @@ -195,11 +262,11 @@ function handleForwardedWorkerRejection(workerError: SerializedWorkerError): voi originalException: error, mechanism: { handled: false, - type: 'auto.browser.web_worker.onunhandledrejection', + type: isUnhandledRejection ? 'auto.browser.web_worker.onunhandledrejection' : 'auto.browser.web_worker.onerror', }, }); - DEBUG_BUILD && debug.log('Captured worker unhandled rejection', error); + DEBUG_BUILD && debug.log(`Captured worker ${isUnhandledRejection ? 'unhandled rejection' : 'error'}`, error); } /** @@ -230,11 +297,12 @@ interface RegisterWebWorkerOptions { * This function will: * - Send debug IDs to the parent thread * - Send module metadata to the parent thread (for thirdPartyErrorFilterIntegration) - * - Set up a handler for unhandled rejections in the worker - * - Forward unhandled rejections to the parent thread for capture + * - Set up handlers for uncaught errors and unhandled rejections in the worker + * - Forward both to the parent thread for capture * - * Note: Synchronous errors in workers are already captured by globalHandlers. - * This only handles unhandled promise rejections which don't bubble to the parent. + * Note: uncaught errors do bubble to the parent, but the propagated `ErrorEvent` carries + * no `error` object, so globalHandlers can only build an event from the message string. + * Forwarding them here preserves the real stack, which matters most for wasm frames. * * @example * ```ts filename={worker.js} @@ -250,6 +318,10 @@ interface RegisterWebWorkerOptions { * - `self`: The worker instance you're calling this function from (self). */ export function registerWebWorker({ self }: RegisterWebWorkerOptions): void { + // Mirrors globalHandlersIntegration. The worker has no client of its own, so without this + // V8's default of 10 truncates stacks before this code forwards them. + Error.stackTraceLimit = 50; + // Send debug IDs and raw module metadata to parent thread // The metadata will be parsed lazily on the main thread when needed self.postMessage({ @@ -258,29 +330,78 @@ export function registerWebWorker({ self }: RegisterWebWorkerOptions): void { _sentryModuleMetadata: self._sentryModuleMetadata ?? undefined, }); - // Set up unhandledrejection handler inside the worker - // Following the same pattern as globalHandlers - // unhandled rejections don't bubble to the parent thread, so we need to handle them here - self.addEventListener('unhandledrejection', (event: unknown) => { - const reason = _getUnhandledRejectionError(event); + const forward = (serializedError: Omit): void => { + const { reason } = serializedError; + + DEBUG_BUILD && debug.log(`[Sentry Worker] Forwarding ${serializedError.kind} to parent`, serializedError); - // Forward the raw reason to parent thread - // The parent will handle primitives vs errors the same way globalHandlers does - const serializedError: SerializedWorkerError = { - reason: reason, + postSerializedWorkerError(self, { + ...serializedError, filename: self.location?.href, + name: isError(reason) ? extractType(reason) : undefined, + }); + }; + + // Uncaught errors bubble to the parent, but the propagated ErrorEvent + // carries no error object. Forwarding the object keeps the real stack. + self.addEventListener('error', (event: unknown) => { + const { error, message, filename, lineno, colno } = event as { + error?: unknown; + message?: string; + filename?: string; + lineno?: number; + colno?: number; }; - // Forward to parent thread + forward({ kind: 'error', reason: error ?? message, message, url: filename, lineno, colno }); + }); + + // Unhandled rejections do not bubble to the parent thread at all. + self.addEventListener('unhandledrejection', (event: unknown) => { + forward({ kind: 'unhandledrejection', reason: _getUnhandledRejectionError(event) }); + }); + + DEBUG_BUILD && debug.log('[Sentry Worker] Registered worker with error and unhandled rejection handling'); +} + +/** + * `postMessage` structured-clones the reason. A `DataCloneError` must never + * escape the worker's own error handler, so the forward is retried with + * plain data that clones in every browser, including ones that cannot clone + * `Error` at all. + */ +function postSerializedWorkerError( + self: MinimalDedicatedWorkerGlobalScope, + serializedError: SerializedWorkerError, +): void { + try { self.postMessage({ _sentryMessage: true, _sentryWorkerError: serializedError, }); + return; + } catch { + // Not cloneable, fall through and send plain data instead. + } - DEBUG_BUILD && debug.log('[Sentry Worker] Forwarding unhandled rejection to parent', serializedError); - }); + const { reason } = serializedError; + const plainError = isError(reason); + const plainReason = plainError ? { message: extractMessage(reason), stack: reason.stack } : normalize(reason); + + try { + self.postMessage({ + _sentryMessage: true, + _sentryWorkerError: { ...serializedError, reason: plainReason, plainError }, + }); + } catch { + // Dropping the forward is better than throwing out of the worker's error handler. + } +} - DEBUG_BUILD && debug.log('[Sentry Worker] Registered worker with unhandled rejection handling'); +function errorFromPlain(plain: Record): Error { + const error = new Error(String(plain.message)); + error.stack = typeof plain.stack === 'string' ? plain.stack : undefined; + return error; } function isSentryMessage(eventData: unknown): eventData is WebWorkerMessage { diff --git a/packages/browser/test/helpers.test.ts b/packages/browser/test/helpers.test.ts index 740ff2ecd7e6..6ffda1158ae3 100644 --- a/packages/browser/test/helpers.test.ts +++ b/packages/browser/test/helpers.test.ts @@ -1,6 +1,6 @@ import type { WrappedFunction } from '@sentry/core'; -import { describe, expect, it, vi } from 'vitest'; -import { wrap } from '../src/helpers'; +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; +import { ignoreNextOnErrorMatching, shouldIgnoreOnError, wrap } from '../src/helpers'; describe('internal wrap()', () => { it('should wrap only functions', () => { @@ -201,3 +201,42 @@ describe('internal wrap()', () => { expect(wrapped).not.toBe('something that is not a function'); }); }); + +describe('ignoreNextOnErrorMatching()', () => { + const report = { msg: 'Uncaught Error: boom', url: 'http://localhost/worker.js', line: 12, column: 9 }; + + beforeEach(async () => { + // The wrap() tests above leave real `ignoreNextOnError` resets pending. + await new Promise(resolve => setTimeout(resolve)); + vi.useFakeTimers(); + }); + + afterEach(() => { + vi.runAllTimers(); + vi.useRealTimers(); + }); + + it('skips a matching report once', () => { + ignoreNextOnErrorMatching(report); + + expect(shouldIgnoreOnError({ ...report })).toBe(true); + expect(shouldIgnoreOnError({ ...report })).toBe(false); + }); + + it('does not skip a report that differs in any field', () => { + ignoreNextOnErrorMatching(report); + + expect(shouldIgnoreOnError({ ...report, msg: 'Uncaught Error: other' })).toBe(false); + expect(shouldIgnoreOnError({ ...report, url: 'http://localhost/other.js' })).toBe(false); + expect(shouldIgnoreOnError({ ...report, line: 13 })).toBe(false); + expect(shouldIgnoreOnError({ ...report, column: 10 })).toBe(false); + expect(shouldIgnoreOnError()).toBe(false); + }); + + it('forgets a report that never arrives after the current task', () => { + ignoreNextOnErrorMatching(report); + vi.runAllTimers(); + + expect(shouldIgnoreOnError({ ...report })).toBe(false); + }); +}); diff --git a/packages/browser/test/integrations/webWorker.test.ts b/packages/browser/test/integrations/webWorker.test.ts index c239e31bd638..a5c1b268c175 100644 --- a/packages/browser/test/integrations/webWorker.test.ts +++ b/packages/browser/test/integrations/webWorker.test.ts @@ -3,9 +3,14 @@ */ import * as SentryCore from '@sentry/core'; +import type { MockInstance } from 'vitest'; import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; +import { isError } from '@sentry/core'; +import { BrowserClient } from '../../src/client'; import * as helpers from '../../src/helpers'; import { INTEGRATION_NAME, registerWebWorker, webWorkerIntegration } from '../../src/integrations/webWorker'; +import { defaultStackParser } from '../../src/stack-parsers'; +import { getDefaultBrowserClientOptions } from '../helper/browser-client-options'; // Mock @sentry/core vi.mock('@sentry/core', async importActual => { @@ -27,8 +32,17 @@ vi.mock('../../src/helpers', () => ({ WINDOW: { _sentryDebugIds: undefined, }, + ignoreNextOnErrorMatching: vi.fn(), })); +function getListener(addEventListener: ReturnType, type: string): (event: any) => void { + const call = addEventListener.mock.calls.find(([eventType]) => eventType === type); + if (!call) { + throw new Error(`No ${type} listener registered`); + } + return call[1]; +} + describe('webWorkerIntegration', () => { const mockDebugLog = SentryCore.debug.log as any; @@ -115,9 +129,7 @@ describe('webWorkerIntegration', () => { const integration = webWorkerIntegration({ worker: mockWorker as any }); integration.setupOnce!(); - // Extract the message handler from the addEventListener call - expect(mockWorker.addEventListener.mock.calls).toBeDefined(); - messageHandler = mockWorker.addEventListener.mock.calls[0]![1]; + messageHandler = getListener(mockWorker.addEventListener, 'message'); }); it('ignores non-Sentry messages', () => { @@ -407,8 +419,12 @@ describe('registerWebWorker', () => { addEventListener: ReturnType; _sentryDebugIds?: Record; _sentryModuleMetadata?: Record; + location?: { href?: string }; }; + // registerWebWorker raises this globally, so every test has to put it back. + const originalStackTraceLimit = Error.stackTraceLimit; + beforeEach(() => { vi.clearAllMocks(); @@ -418,6 +434,10 @@ describe('registerWebWorker', () => { }; }); + afterEach(() => { + Error.stackTraceLimit = originalStackTraceLimit; + }); + it('posts message with _sentryMessage flag', () => { registerWebWorker({ self: mockWorkerSelf as any }); @@ -510,6 +530,183 @@ describe('registerWebWorker', () => { _sentryModuleMetadata: rawMetadata, }); }); + + describe('error forwarding', () => { + function trigger(type: string, event: unknown): void { + getListener(mockWorkerSelf.addEventListener, type)(event); + } + + it('raises the stack trace limit so forwarded stacks are not truncated', () => { + Error.stackTraceLimit = 10; + + registerWebWorker({ self: mockWorkerSelf as any }); + + expect(Error.stackTraceLimit).toBe(50); + }); + + it('forwards an uncaught error with its location, name and kind "error"', () => { + registerWebWorker({ self: mockWorkerSelf as any }); + + mockWorkerSelf.location = { href: 'http://localhost/worker.js' }; + const error = new Error('boom'); + trigger('error', { + error, + message: 'Uncaught Error: boom', + filename: 'http://localhost/chunk.js', + lineno: 12, + colno: 9, + }); + + expect(mockWorkerSelf.postMessage).toHaveBeenLastCalledWith({ + _sentryMessage: true, + _sentryWorkerError: { + reason: error, + filename: 'http://localhost/worker.js', + kind: 'error', + name: 'Error', + message: 'Uncaught Error: boom', + url: 'http://localhost/chunk.js', + lineno: 12, + colno: 9, + }, + }); + }); + + it('sends the error name separately because structured clone resets it', () => { + registerWebWorker({ self: mockWorkerSelf as any }); + + const error = new Error('divide by zero'); + error.name = 'RuntimeError'; + trigger('error', { error }); + + expect(mockWorkerSelf.postMessage).toHaveBeenLastCalledWith({ + _sentryMessage: true, + _sentryWorkerError: expect.objectContaining({ reason: error, name: 'RuntimeError' }), + }); + }); + + it('falls back to the event message when there is no error object', () => { + registerWebWorker({ self: mockWorkerSelf as any }); + + trigger('error', { error: null, message: 'Uncaught Error: boom', lineno: 3, colno: 7 }); + + expect(mockWorkerSelf.postMessage).toHaveBeenLastCalledWith({ + _sentryMessage: true, + _sentryWorkerError: expect.objectContaining({ + reason: 'Uncaught Error: boom', + kind: 'error', + name: undefined, + lineno: 3, + colno: 7, + }), + }); + }); + + it('tags forwarded rejections with kind "unhandledrejection"', () => { + registerWebWorker({ self: mockWorkerSelf as any }); + + const reason = new Error('rejected'); + trigger('unhandledrejection', { reason }); + + expect(mockWorkerSelf.postMessage).toHaveBeenLastCalledWith({ + _sentryMessage: true, + _sentryWorkerError: { + reason, + filename: undefined, + kind: 'unhandledrejection', + name: 'Error', + }, + }); + }); + + describe('when the reason cannot be structured-cloned', () => { + beforeEach(() => { + mockWorkerSelf.postMessage.mockImplementation(message => structuredClone(message)); + }); + + it('retries with a plain copy that keeps message and stack but drops the cause', () => { + registerWebWorker({ self: mockWorkerSelf as any }); + + const error = new Error('boom') as Error & { cause?: unknown }; + error.cause = () => {}; + expect(() => trigger('error', { error })).not.toThrow(); + + // The mocked postMessage clones for real, so a third call proves the + // retry no longer carries the function that blocked the first one. + expect(mockWorkerSelf.postMessage).toHaveBeenCalledTimes(3); + expect(mockWorkerSelf.postMessage).toHaveBeenLastCalledWith({ + _sentryMessage: true, + _sentryWorkerError: expect.objectContaining({ + reason: { message: 'boom', stack: error.stack }, + plainError: true, + name: 'Error', + kind: 'error', + }), + }); + }); + + it('sends only plain data when the browser cannot clone errors at all', () => { + registerWebWorker({ self: mockWorkerSelf as any }); + mockWorkerSelf.postMessage.mockImplementation(message => { + if (isError(message._sentryWorkerError?.reason)) { + throw new DOMException('could not be cloned', 'DataCloneError'); + } + }); + + const error = new Error('boom'); + trigger('error', { error }); + + expect(mockWorkerSelf.postMessage).toHaveBeenLastCalledWith({ + _sentryMessage: true, + _sentryWorkerError: expect.objectContaining({ + reason: { message: 'boom', stack: error.stack }, + plainError: true, + }), + }); + }); + + it('keeps the message and stack of a WebAssembly.Exception', () => { + registerWebWorker({ self: mockWorkerSelf as any }); + + const tag = new WebAssembly.Tag({ parameters: [] }); + const exception = new WebAssembly.Exception(tag, [], { traceStack: true }); + trigger('error', { error: exception }); + + expect(mockWorkerSelf.postMessage).toHaveBeenLastCalledWith({ + _sentryMessage: true, + _sentryWorkerError: expect.objectContaining({ + reason: { message: 'wasm exception', stack: exception.stack }, + plainError: true, + name: 'WebAssembly.Exception', + }), + }); + }); + + it('normalizes a reason that is not an error', () => { + registerWebWorker({ self: mockWorkerSelf as any }); + + trigger('unhandledrejection', { reason: { retry: () => {} } }); + + expect(mockWorkerSelf.postMessage).toHaveBeenLastCalledWith({ + _sentryMessage: true, + _sentryWorkerError: expect.objectContaining({ + reason: { retry: '[Function: retry]' }, + plainError: false, + kind: 'unhandledrejection', + }), + }); + }); + + it('does not throw out of the error handler when the retry fails as well', () => { + registerWebWorker({ self: mockWorkerSelf as any }); + mockWorkerSelf.postMessage.mockImplementation(() => { + throw new DOMException('could not be cloned', 'DataCloneError'); + }); + + expect(() => trigger('error', { error: new Error('boom') })).not.toThrow(); + }); + }); + }); }); describe('registerWebWorker and webWorkerIntegration', () => { @@ -614,3 +811,209 @@ describe('registerWebWorker and webWorkerIntegration', () => { }); }); }); + +describe('forwarded worker errors', () => { + let client: BrowserClient; + let captureEventSpy: MockInstance; + let mockWorker: { addEventListener: ReturnType; postMessage: ReturnType }; + + beforeEach(() => { + vi.clearAllMocks(); + + client = new BrowserClient({ + ...getDefaultBrowserClientOptions(), + stackParser: defaultStackParser, + }); + SentryCore.setCurrentClient(client); + client.init(); + captureEventSpy = vi.spyOn(client, 'captureEvent'); + + mockWorker = { addEventListener: vi.fn(), postMessage: vi.fn() }; + const integration = webWorkerIntegration({ worker: mockWorker as any }); + integration.setupOnce!(); + }); + + function receive(data: Record): void { + getListener( + mockWorker.addEventListener, + 'message', + )({ + data: { _sentryMessage: true, ...data }, + stopImmediatePropagation: vi.fn(), + }); + } + + function forward(workerError: Record): void { + receive({ _sentryWorkerError: workerError }); + } + + function expectCapturedException(exception: Record): void { + expect(captureEventSpy).toHaveBeenCalledWith( + expect.objectContaining({ exception: { values: [expect.objectContaining(exception)] } }), + expect.anything(), + expect.anything(), + ); + } + + it('captures a forwarded error with the onerror mechanism', () => { + const error = new Error('boom'); + + forward({ reason: error, filename: 'http://localhost/worker.js', kind: 'error' }); + + expect(captureEventSpy).toHaveBeenCalledWith( + expect.objectContaining({ level: 'error' }), + expect.objectContaining({ + originalException: error, + mechanism: { handled: false, type: 'auto.browser.web_worker.onerror' }, + }), + expect.anything(), + ); + }); + + it.each([ + ['kind "unhandledrejection"', 'unhandledrejection'], + // Workers registered by an older SDK only forwarded rejections and sent no kind. + ['no kind', undefined], + ])('captures a forwarded rejection with %s using the onunhandledrejection mechanism', (_, kind) => { + forward({ reason: new Error('rejected'), kind }); + + expect(captureEventSpy).toHaveBeenCalledWith( + expect.anything(), + expect.objectContaining({ + mechanism: { handled: false, type: 'auto.browser.web_worker.onunhandledrejection' }, + }), + expect.anything(), + ); + }); + + it('does not apply promise-rejection wording to a thrown primitive', () => { + forward({ reason: 'just a string', kind: 'error' }); + + expectCapturedException({ type: 'Error', value: 'just a string' }); + }); + + it('keeps promise-rejection wording for a rejected primitive', () => { + forward({ reason: 'just a string', kind: 'unhandledrejection' }); + + expectCapturedException({ + type: 'UnhandledRejection', + value: 'Non-Error promise rejection captured with value: just a string', + }); + }); + + it('restores the name that structured clone dropped and parses the forwarded stack', () => { + const error = new Error('divide by zero'); + error.name = 'RuntimeError'; + error.stack = [ + 'RuntimeError: divide by zero', + ' at trigger_crash (http://localhost:8080/maze.wasm:wasm-function[36]:0x2877)', + ' at runStepGame (http://localhost:8080/worker.js:12:9)', + ].join('\n'); + const cloned = structuredClone(error); + expect(cloned.name).toBe('Error'); + + forward({ reason: cloned, name: 'RuntimeError', kind: 'error' }); + + expectCapturedException({ + type: 'RuntimeError', + value: 'divide by zero', + stacktrace: { + frames: expect.arrayContaining([ + expect.objectContaining({ filename: 'http://localhost:8080/maze.wasm:wasm-function[36]:0x2877' }), + expect.objectContaining({ filename: 'http://localhost:8080/worker.js' }), + ]), + }, + }); + }); + + it('rebuilds an error from a plain copy and restores its name', () => { + const stack = ['RuntimeError: divide by zero', ' at runStepGame (http://localhost:8080/worker.js:12:9)'].join( + '\n', + ); + + forward({ reason: { message: 'divide by zero', stack }, plainError: true, name: 'RuntimeError', kind: 'error' }); + + expectCapturedException({ + type: 'RuntimeError', + value: 'divide by zero', + stacktrace: { frames: [expect.objectContaining({ filename: 'http://localhost:8080/worker.js', lineno: 12 })] }, + }); + }); + + it.each([ + ['the script that threw', 'http://localhost/chunk.js', 'http://localhost/chunk.js'], + ['the worker script when the event has no url', undefined, 'http://localhost/worker.js'], + ['the worker script when the event url is empty', '', 'http://localhost/worker.js'], + ])('adds a frame at %s when a message-only error has no stack', (_, url, frameFilename) => { + forward({ + reason: 'Uncaught Error: boom', + kind: 'error', + filename: 'http://localhost/worker.js', + url, + lineno: 12, + colno: 9, + }); + + expectCapturedException({ + value: 'Uncaught Error: boom', + stacktrace: { frames: [expect.objectContaining({ filename: frameFilename, lineno: 12, colno: 9 })] }, + }); + }); + + const bubbled = { + message: 'Uncaught Error: boom', + filename: 'http://localhost/worker.js', + lineno: 12, + colno: 9, + }; + const forwardedError = { + reason: new Error('boom'), + kind: 'error', + message: bubbled.message, + url: bubbled.filename, + lineno: bubbled.lineno, + colno: bubbled.colno, + }; + + it('skips the global onerror copy of an error that was forwarded', () => { + forward(forwardedError); + getListener(mockWorker.addEventListener, 'error')(bubbled); + + expect(helpers.ignoreNextOnErrorMatching).toHaveBeenCalledExactlyOnceWith({ + msg: 'Uncaught Error: boom', + url: 'http://localhost/worker.js', + line: 12, + column: 9, + }); + }); + + it('keeps the global onerror copy of an error that was never forwarded', () => { + getListener(mockWorker.addEventListener, 'error')(bubbled); + + expect(helpers.ignoreNextOnErrorMatching).not.toHaveBeenCalled(); + }); + + it('keeps the global onerror copy when a different error was forwarded', () => { + forward({ ...forwardedError, lineno: 13 }); + getListener(mockWorker.addEventListener, 'error')(bubbled); + + expect(helpers.ignoreNextOnErrorMatching).not.toHaveBeenCalled(); + }); + + it('skips each forwarded error once', () => { + const onWorkerError = getListener(mockWorker.addEventListener, 'error'); + + forward(forwardedError); + onWorkerError(bubbled); + onWorkerError(bubbled); + + expect(helpers.ignoreNextOnErrorMatching).toHaveBeenCalledOnce(); + }); + + it('does not expect a bubbled copy of a forwarded rejection', () => { + forward({ ...forwardedError, kind: 'unhandledrejection' }); + getListener(mockWorker.addEventListener, 'error')(bubbled); + + expect(helpers.ignoreNextOnErrorMatching).not.toHaveBeenCalled(); + }); +});