helpers.js
View Options

	import { withScope, captureException } from '@sentry/core';
	import { getOriginalFunction, addExceptionTypeValue, addExceptionMechanism, markFunctionWrapped, addNonEnumerableProperty } from '@sentry/utils';

	let ignoreOnError = 0;

	/**
	* @hidden
	*/
	function shouldIgnoreOnError() {
	return ignoreOnError > 0;
	}

	/**
	* @hidden
	*/
	function ignoreNextOnError() {
	// onerror should trigger before setTimeout
	ignoreOnError += 1;
	setTimeout(() => {
	ignoreOnError -= 1;
	});
	}

	/**
	* Instruments the given function and sends an event to Sentry every time the
	* function throws an exception.
	*
	* @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always
	* has a correct `this` context.
	* @returns The wrapped function.
	* @hidden
	*/
	function wrap(
	fn,
	options

	= {},
	before,
	) {
	// for future readers what this does is wrap a function and then create
	// a bi-directional wrapping between them.
	//
	// example: wrapped = wrap(original);
	// original.__sentry_wrapped__ -> wrapped
	// wrapped.__sentry_original__ -> original

	if (typeof fn !== 'function') {
	return fn;
	}

	try {
	// if we're dealing with a function that was previously wrapped, return
	// the original wrapper.
	var wrapper = fn.__sentry_wrapped__;
	if (wrapper) {
	return wrapper;
	}

	// We don't wanna wrap it twice
	if (getOriginalFunction(fn)) {
	return fn;
	}
	} catch (e) {
	// Just accessing custom props in some Selenium environments
	// can cause a "Permission denied" exception (see raven-js#495).
	// Bail on wrapping and return the function as-is (defers to window.onerror).
	return fn;
	}

	// It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`
	var sentryWrapped = function () {
	var args = Array.prototype.slice.call(arguments);

	try {
	if (before && typeof before === 'function') {
	before.apply(this, arguments);
	}

	var wrappedArguments = args.map((arg) => wrap(arg, options));

	// Attempt to invoke user-land function
	// NOTE: If you are a Sentry user, and you are seeing this stack frame, it
	// means the sentry.javascript SDK caught an error invoking your application code. This
	// is expected behavior and NOT indicative of a bug with sentry.javascript.
	return fn.apply(this, wrappedArguments);
	} catch (ex) {
	ignoreNextOnError();

	withScope((scope) => {
	scope.addEventProcessor((event) => {
	if (options.mechanism) {
	addExceptionTypeValue(event, undefined, undefined);
	addExceptionMechanism(event, options.mechanism);
	}

	event.extra = {
	...event.extra,
	arguments: args,
	};

	return event;
	});

	captureException(ex);
	});

	throw ex;
	}
	};

	// Accessing some objects may throw
	// ref: https://github.com/getsentry/sentry-javascript/issues/1168
	try {
	for (var property in fn) {
	if (Object.prototype.hasOwnProperty.call(fn, property)) {
	sentryWrapped[property] = fn[property];
	}
	}
	} catch (_oO) {}
	// Signal that this function has been wrapped/filled already
	// for both debugging and to prevent it to being wrapped/filled twice
	markFunctionWrapped(sentryWrapped, fn);

	addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);

	// Restore original function name (not all browsers allow that)
	try {
	var descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') ;
	if (descriptor.configurable) {
	Object.defineProperty(sentryWrapped, 'name', {
	get() {
	return fn.name;
	},
	});
	}
	} catch (_oO) {}

	return sentryWrapped;
	}

	/**
	* All properties the report dialog supports
	*/

	export { ignoreNextOnError, shouldIgnoreOnError, wrap };
	//# sourceMappingURL=helpers.js.map

File Metadata

Mime Type: text/x-java
Expires: Jun 4 2025, 7:23 PM (9 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3353450

helpers.js
No OneTemporary
Actions

helpers.js
View Options

File Metadata

Event Timeline

helpers.jsNo OneTemporaryActions

helpers.jsView Options

File Metadata

Event Timeline

helpers.js
No OneTemporary
Actions

helpers.js
View Options