UNPKG

@sentry/browser

Version:
280 lines (279 loc) • 11.2 kB
const require_debug_build = require("../debug-build.js"); const require_eventbuilder = require("../eventbuilder.js"); const require_helpers = require("../helpers.js"); const require_globalhandlers = require("./globalhandlers.js"); let _sentry_core = require("@sentry/core"); // src/integrations/webWorker.ts const INTEGRATION_NAME = "WebWorker"; const MAX_FORWARDED_ERRORS = 20; /** * Use this integration to set up Sentry with web workers. * * IMPORTANT: This integration must be added **before** you start listening to * any messages from the worker. Otherwise, your message handlers will receive * messages from the Sentry SDK which you need to ignore. * * This integration only has an effect, if you call `Sentry.registerWebWorker(self)` * from within the worker(s) you're adding to the integration. * * Given that you want to initialize the SDK as early as possible, you most likely * want to add this integration **after** initializing the SDK: * * @example: * ```ts filename={main.js} * import * as Sentry from '@sentry/<your-sdk>'; * * // some time earlier: * Sentry.init(...) * * // 1. Initialize the worker * const worker = new Worker(new URL('./worker.ts', import.meta.url)); * * // 2. Add the integration * const webWorkerIntegration = Sentry.webWorkerIntegration({ worker }); * Sentry.addIntegration(webWorkerIntegration); * * // 3. Register message listeners on the worker * worker.addEventListener('message', event => { * // ... * }); * ``` * * If you initialize multiple workers at the same time, you can also pass an array of workers * to the integration: * * ```ts filename={main.js} * const webWorkerIntegration = Sentry.webWorkerIntegration({ worker: [worker1, worker2] }); * Sentry.addIntegration(webWorkerIntegration); * ``` * * If you have any additional workers that you initialize at a later point, * you can add them to the integration as follows: * * ```ts filename={main.js} * const webWorkerIntegration = Sentry.webWorkerIntegration({ worker: worker1 }); * Sentry.addIntegration(webWorkerIntegration); * * // sometime later: * webWorkerIntegration.addWorker(worker2); * ``` * * Of course, you can also directly add the integration in Sentry.init: * ```ts filename={main.js} * import * as Sentry from '@sentry/<your-sdk>'; * * // 1. Initialize the worker * const worker = new Worker(new URL('./worker.ts', import.meta.url)); * * // 2. Initialize the SDK * Sentry.init({ * integrations: [Sentry.webWorkerIntegration({ worker })] * }); * * // 3. Register message listeners on the worker * worker.addEventListener('message', event => { * // ... * }); * ``` * * @param options {WebWorkerIntegrationOptions} Integration options: * - `worker`: The worker instance. */ const webWorkerIntegration = (0, _sentry_core.defineIntegration)(({ worker }) => ({ name: INTEGRATION_NAME, setupOnce: () => { (Array.isArray(worker) ? worker : [worker]).forEach((w) => listenForSentryMessages(w)); }, addWorker: (worker) => listenForSentryMessages(worker) })); function listenForSentryMessages(worker) { const forwardedErrors = []; 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) { forwardedErrors.splice(0, index + 1); require_helpers.ignoreNextOnErrorMatching({ msg: message, url: filename, line: lineno, column: colno }); } }); worker.addEventListener("message", (event) => { if (isSentryMessage(event.data)) { event.stopImmediatePropagation(); if (event.data._sentryDebugIds) { require_debug_build.DEBUG_BUILD && _sentry_core.debug.log("Sentry debugId web worker message received", event.data); require_helpers.WINDOW._sentryDebugIds = { ...event.data._sentryDebugIds, ...require_helpers.WINDOW._sentryDebugIds }; } if (event.data._sentryModuleMetadata) { require_debug_build.DEBUG_BUILD && _sentry_core.debug.log("Sentry module metadata web worker message received", event.data); require_helpers.WINDOW._sentryModuleMetadata = { ...event.data._sentryModuleMetadata, ...require_helpers.WINDOW._sentryModuleMetadata }; } if (event.data._sentryWasmImages) { require_debug_build.DEBUG_BUILD && _sentry_core.debug.log("Sentry WASM images web worker message received", event.data); const existingImages = require_helpers.WINDOW._sentryWasmImages || []; const newImages = event.data._sentryWasmImages.filter((newImg) => (0, _sentry_core.isPlainObject)(newImg) && typeof newImg.code_file === "string" && !existingImages.some((existing) => existing.code_file === newImg.code_file)); require_helpers.WINDOW._sentryWasmImages = [...existingImages, ...newImages]; } if (event.data._sentryWorkerError) { require_debug_build.DEBUG_BUILD && _sentry_core.debug.log("Sentry worker error message received", event.data._sentryWorkerError); const { kind, message, url, lineno, colno } = event.data._sentryWorkerError; if (kind === "error") { if (forwardedErrors.push({ message, url, lineno, colno }) > MAX_FORWARDED_ERRORS) forwardedErrors.shift(); } handleForwardedWorkerError(event.data._sentryWorkerError); } } }); } function handleForwardedWorkerError(workerError) { const { reason, kind, name, filename, url, lineno, colno, plainError } = workerError; const isUnhandledRejection = kind !== "error"; const error = plainError && (0, _sentry_core.isPlainObject)(reason) ? errorFromPlain(reason) : reason; if (name && (0, _sentry_core.isError)(error) && error.name !== name) (0, _sentry_core.addNonEnumerableProperty)(error, "name", name); const client = (0, _sentry_core.getClient)(); if (!client) return; const { stackParser, attachStacktrace } = client.getOptions(); const event = isUnhandledRejection && (0, _sentry_core.isPrimitive)(error) ? require_globalhandlers._eventFromRejectionWithPrimitive(error) : require_eventbuilder.eventFromUnknownInput(stackParser, error, void 0, attachStacktrace, isUnhandledRejection); if (!isUnhandledRejection) require_globalhandlers._enhanceEventWithInitialFrame(event, url || filename, lineno, colno); event.level = "error"; if (filename) event.contexts = { ...event.contexts, worker: { filename } }; (0, _sentry_core.captureEvent)(event, { originalException: error, mechanism: { handled: false, type: isUnhandledRejection ? "auto.browser.web_worker.onunhandledrejection" : "auto.browser.web_worker.onerror" } }); require_debug_build.DEBUG_BUILD && _sentry_core.debug.log(`Captured worker ${isUnhandledRejection ? "unhandled rejection" : "error"}`, error); } /** * Use this function to register the worker with the Sentry SDK. * * This function will: * - Send debug IDs to the parent thread * - Send module metadata to the parent thread (for thirdPartyErrorFilterIntegration) * - Set up handlers for uncaught errors and unhandled rejections in the worker * - Forward both to the parent thread for capture * * 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} * import * as Sentry from '@sentry/<your-sdk>'; * * // Do this as early as possible in your worker. * Sentry.registerWebWorker({ self }); * * // continue setting up your worker * self.postMessage(...) * ``` * @param options {RegisterWebWorkerOptions} Integration options: * - `self`: The worker instance you're calling this function from (self). */ function registerWebWorker({ self }) { Error.stackTraceLimit = 50; self.postMessage({ _sentryMessage: true, _sentryDebugIds: self._sentryDebugIds ?? void 0, _sentryModuleMetadata: self._sentryModuleMetadata ?? void 0 }); const forward = (serializedError) => { const { reason } = serializedError; require_debug_build.DEBUG_BUILD && _sentry_core.debug.log(`[Sentry Worker] Forwarding ${serializedError.kind} to parent`, serializedError); postSerializedWorkerError(self, { ...serializedError, filename: self.location?.href, name: (0, _sentry_core.isError)(reason) ? require_eventbuilder.extractType(reason) : void 0 }); }; self.addEventListener("error", (event) => { const { error, message, filename, lineno, colno } = event; forward({ kind: "error", reason: error ?? message, message, url: filename, lineno, colno }); }); self.addEventListener("unhandledrejection", (event) => { forward({ kind: "unhandledrejection", reason: require_globalhandlers._getUnhandledRejectionError(event) }); }); require_debug_build.DEBUG_BUILD && _sentry_core.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, serializedError) { try { self.postMessage({ _sentryMessage: true, _sentryWorkerError: serializedError }); return; } catch {} const { reason } = serializedError; const plainError = (0, _sentry_core.isError)(reason); const plainReason = plainError ? { message: require_eventbuilder.extractMessage(reason), stack: reason.stack } : (0, _sentry_core.normalize)(reason); try { self.postMessage({ _sentryMessage: true, _sentryWorkerError: { ...serializedError, reason: plainReason, plainError } }); } catch {} } function errorFromPlain(plain) { const error = new Error(String(plain.message)); error.stack = typeof plain.stack === "string" ? plain.stack : void 0; return error; } function isSentryMessage(eventData) { if (!(0, _sentry_core.isPlainObject)(eventData) || eventData._sentryMessage !== true) return false; const hasDebugIds = "_sentryDebugIds" in eventData; const hasModuleMetadata = "_sentryModuleMetadata" in eventData; const hasWorkerError = "_sentryWorkerError" in eventData; const hasWasmImages = "_sentryWasmImages" in eventData; if (!hasDebugIds && !hasModuleMetadata && !hasWorkerError && !hasWasmImages) return false; if (hasDebugIds && !((0, _sentry_core.isPlainObject)(eventData._sentryDebugIds) || eventData._sentryDebugIds === void 0)) return false; if (hasModuleMetadata && !((0, _sentry_core.isPlainObject)(eventData._sentryModuleMetadata) || eventData._sentryModuleMetadata === void 0)) return false; if (hasWorkerError && !(0, _sentry_core.isPlainObject)(eventData._sentryWorkerError)) return false; if (hasWasmImages && (!Array.isArray(eventData._sentryWasmImages) || !eventData._sentryWasmImages.every((img) => (0, _sentry_core.isPlainObject)(img) && typeof img.code_file === "string"))) return false; return true; } exports.INTEGRATION_NAME = INTEGRATION_NAME; exports.registerWebWorker = registerWebWorker; exports.webWorkerIntegration = webWorkerIntegration; //# sourceMappingURL=webWorker.js.map