dedupe.js
View Options

	import { logger } from '@sentry/utils';

	/** Deduplication filter */
	class Dedupe {constructor() { Dedupe.prototype.__init.call(this); }
	/**
	* @inheritDoc
	*/
	static __initStatic() {this.id = 'Dedupe';}

	/**
	* @inheritDoc
	*/
	__init() {this.name = Dedupe.id;}

	/**
	* @inheritDoc
	*/

	/**
	* @inheritDoc
	*/
	setupOnce(addGlobalEventProcessor, getCurrentHub) {
	const eventProcessor = currentEvent => {
	const self = getCurrentHub().getIntegration(Dedupe);
	if (self) {
	// Juuust in case something goes wrong
	try {
	if (_shouldDropEvent(currentEvent, self._previousEvent)) {
	(typeof __SENTRY_DEBUG__ === 'undefined' \|\| __SENTRY_DEBUG__) && logger.warn('Event dropped due to being a duplicate of previously captured event.');
	return null;
	}
	} catch (_oO) {
	return (self._previousEvent = currentEvent);
	}

	return (self._previousEvent = currentEvent);
	}
	return currentEvent;
	};

	eventProcessor.id = this.name;
	addGlobalEventProcessor(eventProcessor);
	}
	} Dedupe.__initStatic();

	/** JSDoc */
	function _shouldDropEvent(currentEvent, previousEvent) {
	if (!previousEvent) {
	return false;
	}

	if (_isSameMessageEvent(currentEvent, previousEvent)) {
	return true;
	}

	if (_isSameExceptionEvent(currentEvent, previousEvent)) {
	return true;
	}

	return false;
	}

	/** JSDoc */
	function _isSameMessageEvent(currentEvent, previousEvent) {
	const currentMessage = currentEvent.message;
	const previousMessage = previousEvent.message;

	// If neither event has a message property, they were both exceptions, so bail out
	if (!currentMessage && !previousMessage) {
	return false;
	}

	// If only one event has a stacktrace, but not the other one, they are not the same
	if ((currentMessage && !previousMessage) \|\| (!currentMessage && previousMessage)) {
	return false;
	}

	if (currentMessage !== previousMessage) {
	return false;
	}

	if (!_isSameFingerprint(currentEvent, previousEvent)) {
	return false;
	}

	if (!_isSameStacktrace(currentEvent, previousEvent)) {
	return false;
	}

	return true;
	}

	/** JSDoc */
	function _isSameExceptionEvent(currentEvent, previousEvent) {
	const previousException = _getExceptionFromEvent(previousEvent);
	const currentException = _getExceptionFromEvent(currentEvent);

	if (!previousException \|\| !currentException) {
	return false;
	}

	if (previousException.type !== currentException.type \|\| previousException.value !== currentException.value) {
	return false;
	}

	if (!_isSameFingerprint(currentEvent, previousEvent)) {
	return false;
	}

	if (!_isSameStacktrace(currentEvent, previousEvent)) {
	return false;
	}

	return true;
	}

	/** JSDoc */
	function _isSameStacktrace(currentEvent, previousEvent) {
	let currentFrames = _getFramesFromEvent(currentEvent);
	let previousFrames = _getFramesFromEvent(previousEvent);

	// If neither event has a stacktrace, they are assumed to be the same
	if (!currentFrames && !previousFrames) {
	return true;
	}

	// If only one event has a stacktrace, but not the other one, they are not the same
	if ((currentFrames && !previousFrames) \|\| (!currentFrames && previousFrames)) {
	return false;
	}

	currentFrames = currentFrames ;
	previousFrames = previousFrames ;

	// If number of frames differ, they are not the same
	if (previousFrames.length !== currentFrames.length) {
	return false;
	}

	// Otherwise, compare the two
	for (let i = 0; i < previousFrames.length; i++) {
	const frameA = previousFrames[i];
	const frameB = currentFrames[i];

	if (
	frameA.filename !== frameB.filename \|\|
	frameA.lineno !== frameB.lineno \|\|
	frameA.colno !== frameB.colno \|\|
	frameA.function !== frameB.function
	) {
	return false;
	}
	}

	return true;
	}

	/** JSDoc */
	function _isSameFingerprint(currentEvent, previousEvent) {
	let currentFingerprint = currentEvent.fingerprint;
	let previousFingerprint = previousEvent.fingerprint;

	// If neither event has a fingerprint, they are assumed to be the same
	if (!currentFingerprint && !previousFingerprint) {
	return true;
	}

	// If only one event has a fingerprint, but not the other one, they are not the same
	if ((currentFingerprint && !previousFingerprint) \|\| (!currentFingerprint && previousFingerprint)) {
	return false;
	}

	currentFingerprint = currentFingerprint ;
	previousFingerprint = previousFingerprint ;

	// Otherwise, compare the two
	try {
	return !!(currentFingerprint.join('') === previousFingerprint.join(''));
	} catch (_oO) {
	return false;
	}
	}

	/** JSDoc */
	function _getExceptionFromEvent(event) {
	return event.exception && event.exception.values && event.exception.values[0];
	}

	/** JSDoc */
	function _getFramesFromEvent(event) {
	const exception = event.exception;

	if (exception) {
	try {
	// @ts-ignore Object could be undefined
	return exception.values[0].stacktrace.frames;
	} catch (_oO) {
	return undefined;
	}
	}
	return undefined;
	}

	export { Dedupe };
	//# sourceMappingURL=dedupe.js.map

File Metadata

Mime Type: text/plain
Expires: Sat, Jun 21, 6:40 PM (2 w, 9 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3356577

dedupe.js
No OneTemporary
Actions

dedupe.js
View Options

File Metadata

Event Timeline

dedupe.jsNo OneTemporaryActions

dedupe.jsView Options

File Metadata

Event Timeline

dedupe.js
No OneTemporary
Actions

dedupe.js
View Options