stacktrace.js
View Options

	import { _optionalChain } from './buildPolyfills';

	var STACKTRACE_LIMIT = 50;

	/**
	* Creates a stack parser with the supplied line parsers
	*
	* StackFrames are returned in the correct order for Sentry Exception
	* frames and with Sentry SDK internal frames removed from the top and bottom
	*
	*/
	function createStackParser(...parsers) {
	var sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);

	return (stack, skipFirst = 0) => {
	var frames = [];

	for (var line of stack.split('\n').slice(skipFirst)) {
	for (var parser of sortedParsers) {
	var frame = parser(line);

	if (frame) {
	frames.push(frame);
	break;
	}
	}
	}

	return stripSentryFramesAndReverse(frames);
	};
	}

	/**
	* Gets a stack parser implementation from Options.stackParser
	* @see Options
	*
	* If options contains an array of line parsers, it is converted into a parser
	*/
	function stackParserFromStackParserOptions(stackParser) {
	if (Array.isArray(stackParser)) {
	return createStackParser(...stackParser);
	}
	return stackParser;
	}

	/**
	* @hidden
	*/
	function stripSentryFramesAndReverse(stack) {
	if (!stack.length) {
	return [];
	}

	let localStack = stack;

	var firstFrameFunction = localStack[0].function \|\| '';
	var lastFrameFunction = localStack[localStack.length - 1].function \|\| '';

	// If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)
	if (firstFrameFunction.indexOf('captureMessage') !== -1 \|\| firstFrameFunction.indexOf('captureException') !== -1) {
	localStack = localStack.slice(1);
	}

	// If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)
	if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {
	localStack = localStack.slice(0, -1);
	}

	// The frame where the crash happened, should be the last entry in the array
	return localStack
	.slice(0, STACKTRACE_LIMIT)
	.map(frame => ({
	...frame,
	filename: frame.filename \|\| localStack[0].filename,
	function: frame.function \|\| '?',
	}))
	.reverse();
	}

	var defaultFunctionName = '<anonymous>';

	/**
	* Safely extract function name from itself
	*/
	function getFunctionName(fn) {
	try {
	if (!fn \|\| typeof fn !== 'function') {
	return defaultFunctionName;
	}
	return fn.name \|\| defaultFunctionName;
	} catch (e) {
	// Just accessing custom props in some Selenium environments
	// can cause a "Permission denied" exception (see raven-js#495).
	return defaultFunctionName;
	}
	}

	function node(getModule) {
	var FILENAME_MATCH = /^\s*[-]{4,}$/;
	var FULL_MATCH = /at (?:async )?(?:(.+?)\s+$)?(?:(.+?):(\d+)(?::(\d+))?\|([^)]+))$?/;

	return (line) => {
	if (line.match(FILENAME_MATCH)) {
	return {
	filename: line,
	};
	}

	var lineMatch = line.match(FULL_MATCH);
	if (!lineMatch) {
	return undefined;
	}

	let object;
	let method;
	let functionName;
	let typeName;
	let methodName;

	if (lineMatch[1]) {
	functionName = lineMatch[1];

	let methodStart = functionName.lastIndexOf('.');
	if (functionName[methodStart - 1] === '.') {
	methodStart--;
	}

	if (methodStart > 0) {
	object = functionName.substr(0, methodStart);
	method = functionName.substr(methodStart + 1);
	var objectEnd = object.indexOf('.Module');
	if (objectEnd > 0) {
	functionName = functionName.substr(objectEnd + 1);
	object = object.substr(0, objectEnd);
	}
	}
	typeName = undefined;
	}

	if (method) {
	typeName = object;
	methodName = method;
	}

	if (method === '<anonymous>') {
	methodName = undefined;
	functionName = undefined;
	}

	if (functionName === undefined) {
	methodName = methodName \|\| '<anonymous>';
	functionName = typeName ? `${typeName}.${methodName}` : methodName;
	}

	var filename = _optionalChain([lineMatch, 'access', _ => _[2], 'optionalAccess', _2 => _2.startsWith, 'call', _3 => _3('file://')]) ? lineMatch[2].substr(7) : lineMatch[2];
	var isNative = lineMatch[5] === 'native';
	var isInternal =
	isNative \|\| (filename && !filename.startsWith('/') && !filename.startsWith('.') && filename.indexOf(':\\') !== 1);

	// in_app is all that's not an internal Node function or a module within node_modules
	// note that isNative appears to return true even for node core libraries
	// see https://github.com/getsentry/raven-node/issues/176
	var in_app = !isInternal && filename !== undefined && !filename.includes('node_modules/');

	return {
	filename,
	module: _optionalChain([getModule, 'optionalCall', _4 => _4(filename)]),
	function: functionName,
	lineno: parseInt(lineMatch[3], 10) \|\| undefined,
	colno: parseInt(lineMatch[4], 10) \|\| undefined,
	in_app,
	};
	};
	}

	/**
	* Node.js stack line parser
	*
	* This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.
	* This allows it to be used without referencing or importing any node specific code which causes bundlers to complain
	*/
	function nodeStackLineParser(getModule) {
	return [90, node(getModule)];
	}

	export { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };
	//# sourceMappingURL=stacktrace.js.map

File Metadata

Mime Type: text/x-java
Expires: Wed, Jun 4, 7:25 PM (5 d, 3 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3298162

stacktrace.js
No OneTemporary
Actions

stacktrace.js
View Options

File Metadata

Event Timeline

stacktrace.jsNo OneTemporaryActions

stacktrace.jsView Options

File Metadata

Event Timeline

stacktrace.js
No OneTemporary
Actions

stacktrace.js
View Options