feat: Compare fingerprints for exceptionEvents

Author: kamilogorek

packages/browser/src/integrations/dedupe.ts

@@ -40,22 +40,14 @@ export class Dedupe implements Integration {
       return false;
     }
 
-    if (this.isSameMessage(currentEvent, previousEvent)) {
-      if (!this.isSameFingerprint(currentEvent, previousEvent)) {
-        return false;
-      }
-
-      if (!this.isSameStacktrace(currentEvent, previousEvent)) {
-        return false;
-      }
-
+    if (this.isSameMessageEvent(currentEvent, previousEvent)) {
       logger.warn(
         `Event dropped due to being a duplicate of previous event (same message).\n  Event: ${currentEvent.event_id}`,
       );
       return true;
     }
 
-    if (this.isSameException(currentEvent, previousEvent)) {
+    if (this.isSameExceptionEvent(currentEvent, previousEvent)) {
       logger.warn(
         `Event dropped due to being a duplicate of previous event (same exception).\n  Event: ${currentEvent.event_id}`,
       );
@@ -66,7 +58,7 @@ export class Dedupe implements Integration {
   }
 
   /** JSDoc */
-  private isSameMessage(currentEvent: SentryEvent, previousEvent: SentryEvent): boolean {
+  private isSameMessageEvent(currentEvent: SentryEvent, previousEvent: SentryEvent): boolean {
     const currentMessage = currentEvent.message;
     const previousMessage = previousEvent.message;
 
@@ -80,8 +72,19 @@ export class Dedupe implements Integration {
       return false;
     }
 
-    // Otherwise, compare the two
-    return currentMessage === previousMessage;
+    if (currentMessage !== previousMessage) {
+      return false;
+    }
+
+    if (!this.isSameFingerprint(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    if (!this.isSameStacktrace(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    return true;
   }
 
   /** JSDoc */
@@ -149,7 +152,7 @@ export class Dedupe implements Integration {
   }
 
   /** JSDoc */
-  private isSameException(currentEvent: SentryEvent, previousEvent: SentryEvent): boolean {
+  private isSameExceptionEvent(currentEvent: SentryEvent, previousEvent: SentryEvent): boolean {
     const previousException = this.getExceptionFromEvent(previousEvent);
     const currentException = this.getExceptionFromEvent(currentEvent);
 
@@ -161,7 +164,15 @@ export class Dedupe implements Integration {
       return false;
     }
 
-    return this.isSameStacktrace(currentEvent, previousEvent);
+    if (!this.isSameFingerprint(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    if (!this.isSameStacktrace(currentEvent, previousEvent)) {
+      return false;
+    }
+
+    return true;
   }
 
   /** JSDoc */

packages/browser/test/integrations/dedupe.test.ts

@@ -51,6 +51,7 @@ const exceptionEvent = {
       },
     ],
   },
+  fingerprint: ['MrSnuffles'],
 };
 
 describe('Dedupe', () => {
@@ -101,6 +102,11 @@ describe('Dedupe', () => {
   });
 
   describe('shouldDropEvent(exceptionEvent)', () => {
+    it('should not drop if there was no previous event', () => {
+      const event = clone(exceptionEvent);
+      expect(dedupe.shouldDropEvent(event)).equal(false);
+    });
+
     it('should drop when events type, value and stacktrace are the same', () => {
       const event = clone(exceptionEvent);
       expect(dedupe.shouldDropEvent(event, event)).equal(true);
@@ -126,5 +132,30 @@ describe('Dedupe', () => {
       eventB.exception.values[0].stacktrace.frames[0].colno = 1337;
       expect(dedupe.shouldDropEvent(eventA, eventB)).equal(false);
     });
+
+    it('should drop if there are two events with same exception and no fingerprints', () => {
+      const eventA = clone(exceptionEvent);
+      delete eventA.fingerprint;
+      const eventB = clone(exceptionEvent);
+      delete eventB.fingerprint;
+      expect(dedupe.shouldDropEvent(eventA, eventB)).equal(true);
+    });
+
+    it('should drop if there are two events with same exception and same fingerprints', () => {
+      const eventA = clone(exceptionEvent);
+      const eventB = clone(exceptionEvent);
+      expect(dedupe.shouldDropEvent(eventA, eventB)).equal(true);
+    });
+
+    it('should not drop if there are two events with same exception but different fingerprints', () => {
+      const eventA = clone(exceptionEvent);
+      const eventB = clone(exceptionEvent);
+      eventA.fingerprint = ['Birdperson'];
+      const eventC = clone(exceptionEvent);
+      delete eventC.fingerprint;
+      expect(dedupe.shouldDropEvent(eventA, eventB)).equal(false);
+      expect(dedupe.shouldDropEvent(eventA, eventC)).equal(false);
+      expect(dedupe.shouldDropEvent(eventB, eventC)).equal(false);
+    });
   });
 });