@sentry/browser
Version:
Official Sentry SDK for browsers
141 lines (140 loc) • 6.33 kB
JavaScript
const require_helpers = require("../helpers.js");
let _sentry_core = require("@sentry/core");
// src/integrations/browserapierrors.ts
const DEFAULT_EVENT_TARGET = "EventTarget,Window,Node,ApplicationCache,AudioTrackList,BroadcastChannel,ChannelMergerNode,CryptoOperation,EventSource,FileReader,HTMLUnknownElement,IDBDatabase,IDBRequest,IDBTransaction,KeyOperation,MediaController,MessagePort,ModalWindow,Notification,SVGElementInstance,Screen,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebSocket,WebSocketWorker,Worker,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload".split(",");
const INTEGRATION_NAME = "BrowserApiErrors";
const _browserApiErrorsIntegration = ((options = {}) => {
const _options = {
XMLHttpRequest: true,
eventTarget: true,
requestAnimationFrame: true,
setInterval: true,
setTimeout: true,
unregisterOriginalCallbacks: false,
...options
};
return {
name: INTEGRATION_NAME,
setupOnce() {
if (_options.setTimeout) (0, _sentry_core.fill)(require_helpers.WINDOW, "setTimeout", _wrapTimeFunction);
if (_options.setInterval) (0, _sentry_core.fill)(require_helpers.WINDOW, "setInterval", _wrapTimeFunction);
if (_options.requestAnimationFrame) (0, _sentry_core.fill)(require_helpers.WINDOW, "requestAnimationFrame", _wrapRAF);
if (_options.XMLHttpRequest && "XMLHttpRequest" in require_helpers.WINDOW) (0, _sentry_core.fill)(XMLHttpRequest.prototype, "send", _wrapXHR);
const eventTargetOption = _options.eventTarget;
if (eventTargetOption) (Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET).forEach((target) => _wrapEventTarget(target, _options));
}
};
});
/**
* Wrap timer functions and event targets to catch errors and provide better meta data.
*/
const browserApiErrorsIntegration = (0, _sentry_core.defineIntegration)(_browserApiErrorsIntegration);
function _wrapTimeFunction(original) {
return function(...args) {
const originalCallback = args[0];
args[0] = require_helpers.wrap(originalCallback, { mechanism: {
handled: false,
type: `auto.browser.browserapierrors.${(0, _sentry_core.getFunctionName)(original)}`
} });
return original.apply(this, args);
};
}
function _wrapRAF(original) {
return function(callback) {
return original.apply(this, [require_helpers.wrap(callback, { mechanism: {
data: { handler: (0, _sentry_core.getFunctionName)(original) },
handled: false,
type: "auto.browser.browserapierrors.requestAnimationFrame"
} })]);
};
}
function _wrapXHR(originalSend) {
return function(...args) {
const xhr = this;
[
"onload",
"onerror",
"onprogress",
"onreadystatechange"
].forEach((prop) => {
if (prop in xhr && typeof xhr[prop] === "function") (0, _sentry_core.fill)(xhr, prop, function(original) {
const wrapOptions = { mechanism: {
data: { handler: (0, _sentry_core.getFunctionName)(original) },
handled: false,
type: `auto.browser.browserapierrors.xhr.${prop}`
} };
const originalFunction = (0, _sentry_core.getOriginalFunction)(original);
if (originalFunction) wrapOptions.mechanism.data.handler = (0, _sentry_core.getFunctionName)(originalFunction);
return require_helpers.wrap(original, wrapOptions);
});
});
return originalSend.apply(this, args);
};
}
function _wrapEventTarget(target, integrationOptions) {
const proto = require_helpers.WINDOW[target]?.prototype;
if (!proto?.hasOwnProperty?.("addEventListener")) return;
(0, _sentry_core.fill)(proto, "addEventListener", function(original) {
return function(eventName, fn, options) {
try {
if (isEventListenerObject(fn)) fn.handleEvent = require_helpers.wrap(fn.handleEvent, { mechanism: {
data: {
handler: (0, _sentry_core.getFunctionName)(fn),
target
},
handled: false,
type: "auto.browser.browserapierrors.handleEvent"
} });
} catch {}
if (integrationOptions.unregisterOriginalCallbacks) unregisterOriginalCallback(this, eventName, fn);
return original.apply(this, [
eventName,
require_helpers.wrap(fn, { mechanism: {
data: {
handler: (0, _sentry_core.getFunctionName)(fn),
target
},
handled: false,
type: "auto.browser.browserapierrors.addEventListener"
} }),
options
]);
};
});
(0, _sentry_core.fill)(proto, "removeEventListener", function(originalRemoveEventListener) {
return function(eventName, fn, options) {
/**
* There are 2 possible scenarios here:
*
* 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified
* method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function
* as a pass-through, and call original `removeEventListener` with it.
*
* 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using
* our wrapped version of `addEventListener`, which internally calls `wrap` helper.
* This helper "wraps" whole callback inside a try/catch statement, and attached appropriate metadata to it,
* in order for us to make a distinction between wrapped/non-wrapped functions possible.
* If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.
*
* When someone adds a handler prior to initialization, and then do it again, but after,
* then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible
* to get rid of the initial handler and it'd stick there forever.
*/
try {
if (Object.prototype.hasOwnProperty.call(fn, "__sentry_wrapped__")) {
const originalEventHandler = fn.__sentry_wrapped__;
if (originalEventHandler) originalRemoveEventListener.call(this, eventName, originalEventHandler, options);
}
} catch {}
return originalRemoveEventListener.call(this, eventName, fn, options);
};
});
}
function isEventListenerObject(obj) {
return typeof obj.handleEvent === "function";
}
function unregisterOriginalCallback(target, eventName, fn) {
if (target && typeof target === "object" && "removeEventListener" in target && typeof target.removeEventListener === "function") target.removeEventListener(eventName, fn);
}
exports.browserApiErrorsIntegration = browserApiErrorsIntegration;
//# sourceMappingURL=browserapierrors.js.map