Skip to content

Revert "ref(browser): Extract private methods from Dedupe integration #4297

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Dec 15, 2021
Merged

Revert "ref(browser): Extract private methods from Dedupe integration #4297

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
234 changes: 117 additions & 117 deletions packages/browser/src/integrations/dedupe.ts
View file
Open in desktop
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