Skip to content

ref(browser): Extract private methods from Dedupe integration #4302

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 4 commits into from
Dec 15, 2021
Merged

ref(browser): Extract private methods from Dedupe integration #4302

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
542c592
ref(browser): Extract private methods from Dedupe integration
AbhiPrasad Dec 15, 2021
6b3b16b
update tests
AbhiPrasad Dec 15, 2021
a2f9ba0
Merge branch 'master' into abhi-dedupe-private
AbhiPrasad Dec 15, 2021
ac44eef
Merge branch 'master' into abhi-dedupe-private
AbhiPrasad Dec 15, 2021
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 (self._shouldDropEvent(currentEvent, self._previousEvent)) {
if (_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 */
private _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {
if (!previousEvent) {
return false;
}

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

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

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

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

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

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

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

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

if (!this._isSameStacktrace(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;
}

return true;
if (currentMessage !== previousMessage) {
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 _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
const previousException = _getExceptionFromEvent(previousEvent);
const currentException = _getExceptionFromEvent(currentEvent);

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

currentFrames = currentFrames as StackFrame[];
previousFrames = previousFrames as StackFrame[];
if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
return false;
}

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

return true;
}

/** JSDoc */
function _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {
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;
}

/** JSDoc */
private _getExceptionFromEvent(event: Event): Exception | undefined {
return event.exception && event.exception.values && event.exception.values[0];
// 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 _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {
const previousException = this._getExceptionFromEvent(previousEvent);
const currentException = this._getExceptionFromEvent(currentEvent);
currentFrames = currentFrames as StackFrame[];
previousFrames = previousFrames as StackFrame[];

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

if (previousException.type !== currentException.type || previousException.value !== currentException.value) {
// 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 (!this._isSameFingerprint(currentEvent, previousEvent)) {
return false;
}
return true;
}

if (!this._isSameStacktrace(currentEvent, previousEvent)) {
return false;
}
/** JSDoc */
function _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {
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;
}

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

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

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

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

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