Skip to content

Commit

Permalink
Merge branch 'master' into jb/bundle/drop-severity
Browse files Browse the repository at this point in the history
  • Loading branch information
@JonasBa
JonasBa authored Dec 15, 2021
2 parents 502e317 + a60d7a5 commit a2642a1
Show file tree
Hide file tree
Showing 2 changed files with 234 additions and 234 deletions.
234 changes: 117 additions & 117 deletions packages/browser/src/integrations/dedupe.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ export class Dedupe implements Integration {
if (self) {
// Juuust in case something goes wrong
try {
if (_shouldDropEvent(currentEvent, self._previousEvent)) {
if (self._shouldDropEvent(currentEvent, self._previousEvent)) {
logger.warn(`Event dropped due to being a duplicate of previously captured event.`);
return null;
}
Expand All @@ -40,164 +40,164 @@ export class Dedupe implements Integration {
return currentEvent;
});
}
}

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

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

if (_isSameExceptionEvent(currentEvent, previousEvent)) {
return true;
}
/** JSDoc */
private _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {
if (!previousEvent) {
return false;
}

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

/** JSDoc */
function _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {
const currentMessage = currentEvent.message;
const previousMessage = previousEvent.message;
if (this._isSameExceptionEvent(currentEvent, previousEvent)) {
return true;
}

// 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;
}
/** JSDoc */
private _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {
const currentMessage = currentEvent.message;
const previousMessage = previousEvent.message;

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

if (!_isSameFingerprint(currentEvent, previousEvent)) {
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 (!_isSameStacktrace(currentEvent, previousEvent)) {
return false;
}
if (currentMessage !== previousMessage) {
return false;
}

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

/** JSDoc */
function _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
const previousException = _getExceptionFromEvent(previousEvent);
const currentException = _getExceptionFromEvent(currentEvent);
if (!this._isSameStacktrace(currentEvent, previousEvent)) {
return false;
}

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

if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
return false;
}
/** JSDoc */
private _getFramesFromEvent(event: Event): StackFrame[] | undefined {
const exception = event.exception;

if (!_isSameFingerprint(currentEvent, previousEvent)) {
return false;
if (exception) {
try {
// @ts-ignore Object could be undefined
return exception.values[0].stacktrace.frames;
} catch (_oO) {
return undefined;
}
} else if (event.stacktrace) {
return event.stacktrace.frames;
}
return undefined;
}

if (!_isSameStacktrace(currentEvent, previousEvent)) {
return false;
}
/** JSDoc */
private _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
let currentFrames = this._getFramesFromEvent(currentEvent);
let previousFrames = this._getFramesFromEvent(previousEvent);

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

/** JSDoc */
function _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
let currentFrames = _getFramesFromEvent(currentEvent);
let previousFrames = _getFramesFromEvent(previousEvent);
// 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 as StackFrame[];
previousFrames = previousFrames as StackFrame[];

// 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;
}
}

// 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;
/** JSDoc */
private _getExceptionFromEvent(event: Event): Exception | undefined {
return event.exception && event.exception.values && event.exception.values[0];
}

currentFrames = currentFrames as StackFrame[];
previousFrames = previousFrames as StackFrame[];
/** JSDoc */
private _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
const previousException = this._getExceptionFromEvent(previousEvent);
const currentException = this._getExceptionFromEvent(currentEvent);

// If number of frames differ, they are not the same
if (previousFrames.length !== currentFrames.length) {
return false;
}
if (!previousException || !currentException) {
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
) {
if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
return false;
}
}

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

/** JSDoc */
function _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {
let currentFingerprint = currentEvent.fingerprint;
let previousFingerprint = previousEvent.fingerprint;
if (!this._isSameStacktrace(currentEvent, previousEvent)) {
return false;
}

// 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 as string[];
previousFingerprint = previousFingerprint as string[];
/** JSDoc */
private _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {
let currentFingerprint = currentEvent.fingerprint;
let previousFingerprint = previousEvent.fingerprint;

// Otherwise, compare the two
try {
return !!(currentFingerprint.join('') === previousFingerprint.join(''));
} catch (_oO) {
return false;
}
}
// If neither event has a fingerprint, they are assumed to be the same
if (!currentFingerprint && !previousFingerprint) {
return true;
}

/** JSDoc */
function _getExceptionFromEvent(event: Event): Exception | undefined {
return event.exception && event.exception.values && event.exception.values[0];
}
// If only one event has a fingerprint, but not the other one, they are not the same
if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {
return false;
}

/** JSDoc */
function _getFramesFromEvent(event: Event): StackFrame[] | undefined {
const exception = event.exception;
currentFingerprint = currentFingerprint as string[];
previousFingerprint = previousFingerprint as string[];

if (exception) {
// Otherwise, compare the two
try {
// @ts-ignore Object could be undefined
return exception.values[0].stacktrace.frames;
return !!(currentFingerprint.join('') === previousFingerprint.join(''));
} catch (_oO) {
return undefined;
return false;
}
} else if (event.stacktrace) {
return event.stacktrace.frames;
}
return undefined;
}
Loading

0 comments on commit a2642a1

Please sign in to comment.