@sentry/browser
Version:
Official Sentry SDK for browsers
278 lines (277 loc) • 10.6 kB
JavaScript
import { DEBUG_BUILD } from "../debug-build.js";
import { eventFromUnknownInput, extractMessage, extractType } from "../eventbuilder.js";
import { WINDOW, ignoreNextOnErrorMatching } from "../helpers.js";
import { _enhanceEventWithInitialFrame, _eventFromRejectionWithPrimitive, _getUnhandledRejectionError } from "./globalhandlers.js";
import { addNonEnumerableProperty, captureEvent, debug, defineIntegration, getClient, isError, isPlainObject, isPrimitive, normalize } from "@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 = 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);
ignoreNextOnErrorMatching({
msg: message,
url: filename,
line: lineno,
column: colno
});
}
});
worker.addEventListener("message", (event) => {
if (isSentryMessage(event.data)) {
event.stopImmediatePropagation();
if (event.data._sentryDebugIds) {
DEBUG_BUILD && debug.log("Sentry debugId web worker message received", event.data);
WINDOW._sentryDebugIds = {
...event.data._sentryDebugIds,
...WINDOW._sentryDebugIds
};
}
if (event.data._sentryModuleMetadata) {
DEBUG_BUILD && debug.log("Sentry module metadata web worker message received", event.data);
WINDOW._sentryModuleMetadata = {
...event.data._sentryModuleMetadata,
...WINDOW._sentryModuleMetadata
};
}
if (event.data._sentryWasmImages) {
DEBUG_BUILD && debug.log("Sentry WASM images web worker message received", event.data);
const existingImages = WINDOW._sentryWasmImages || [];
const newImages = event.data._sentryWasmImages.filter((newImg) => isPlainObject(newImg) && typeof newImg.code_file === "string" && !existingImages.some((existing) => existing.code_file === newImg.code_file));
WINDOW._sentryWasmImages = [...existingImages, ...newImages];
}
if (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") {
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 && isPlainObject(reason) ? errorFromPlain(reason) : reason;
if (name && isError(error) && error.name !== name) addNonEnumerableProperty(error, "name", name);
const client = getClient();
if (!client) return;
const { stackParser, attachStacktrace } = client.getOptions();
const event = isUnhandledRejection && isPrimitive(error) ? _eventFromRejectionWithPrimitive(error) : eventFromUnknownInput(stackParser, error, void 0, attachStacktrace, isUnhandledRejection);
if (!isUnhandledRejection) _enhanceEventWithInitialFrame(event, url || filename, lineno, colno);
event.level = "error";
if (filename) event.contexts = {
...event.contexts,
worker: { filename }
};
captureEvent(event, {
originalException: error,
mechanism: {
handled: false,
type: isUnhandledRejection ? "auto.browser.web_worker.onunhandledrejection" : "auto.browser.web_worker.onerror"
}
});
DEBUG_BUILD && 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;
DEBUG_BUILD && debug.log(`[Sentry Worker] Forwarding ${serializedError.kind} to parent`, serializedError);
postSerializedWorkerError(self, {
...serializedError,
filename: self.location?.href,
name: isError(reason) ? 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: _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, serializedError) {
try {
self.postMessage({
_sentryMessage: true,
_sentryWorkerError: serializedError
});
return;
} catch {}
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 {}
}
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 (!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 && !(isPlainObject(eventData._sentryDebugIds) || eventData._sentryDebugIds === void 0)) return false;
if (hasModuleMetadata && !(isPlainObject(eventData._sentryModuleMetadata) || eventData._sentryModuleMetadata === void 0)) return false;
if (hasWorkerError && !isPlainObject(eventData._sentryWorkerError)) return false;
if (hasWasmImages && (!Array.isArray(eventData._sentryWasmImages) || !eventData._sentryWasmImages.every((img) => isPlainObject(img) && typeof img.code_file === "string"))) return false;
return true;
}
export { INTEGRATION_NAME, registerWebWorker, webWorkerIntegration };
//# sourceMappingURL=webWorker.js.map