fix(grouper): identify events similarity only when titles are same

workers/grouper/src/index.ts

@@ -14,7 +14,6 @@ import HawkCatcher from '@hawk.so/nodejs';
 import { MS_IN_SEC } from '../../../lib/utils/consts';
 import DataFilter from './data-filter';
 import RedisHelper from './redisHelper';
-import levenshtein from 'js-levenshtein';
 import { computeDelta } from './utils/repetitionDiff';
 import TimeMs from '../../../lib/utils/time';
 
@@ -244,22 +243,24 @@ export default class GrouperWorker extends Worker {
    */
   private async findSimilarEvent(projectId: string, event: EventDataAccepted<EventAddons>): Promise<GroupedEventDBScheme | undefined> {
     const eventsCountToCompare = 60;
-    const diffTreshold = 0.35;
+    // const diffTreshold = 0.35;
 
     const lastUniqueEvents = await this.findLastEvents(projectId, eventsCountToCompare);
 
     /**
-     * First try to find by Levenshtein distance
+     * First try to find similar event by title
      */
-    const similarByLevenshtein = lastUniqueEvents.filter(prevEvent => {
-      const distance = levenshtein(event.title, prevEvent.payload.title);
-      const threshold = event.title.length * diffTreshold;
+    const similarByTitle = lastUniqueEvents.filter(prevEvent => {
+      // const distance = levenshtein(event.title, prevEvent.payload.title);
 
-      return distance < threshold;
+      // const threshold = event.title.length * diffTreshold;
+
+      // return distance < threshold;
+      return event.title.toLowerCase() === prevEvent.payload.title.toLowerCase();
     }).pop();
 
-    if (similarByLevenshtein) {
-      return similarByLevenshtein;
+    if (similarByTitle) {
+      return similarByTitle;
     }
 
     /**
@@ -280,13 +281,14 @@ export default class GrouperWorker extends Worker {
                 { sort: { _id: 1 } }
               );
           });
+
           this.logger.info(`original event for pattern: ${JSON.stringify(originalEvent)}`);
 
           if (originalEvent) {
             return originalEvent;
           }
         } catch (e) {
-          this.logger.error(`Error while getting original event for pattern ${matchingPattern}`)
+          this.logger.error(`Error while getting original event for pattern ${matchingPattern}`);
         }
       }
     }

workers/grouper/tests/index.test.ts

@@ -472,17 +472,17 @@
   });
 
   describe('Grouping', () => {
-    test('should group events with partially different titles', async () => {
-      await worker.handle(generateTask({ title: 'Some error (but not filly identical) example' }));
-      await worker.handle(generateTask({ title: 'Some error (yes, it is not the identical) example' }));
-      await worker.handle(generateTask({ title: 'Some error (and it is not identical) example' }));
+    // test('should group events with partially different titles', async () => {
+    //   await worker.handle(generateTask({ title: 'Some error (but not filly identical) example' }));
+    //   await worker.handle(generateTask({ title: 'Some error (yes, it is not the identical) example' }));
+    //   await worker.handle(generateTask({ title: 'Some error (and it is not identical) example' }));
 
-      const originalEvent = await eventsCollection.findOne({});
+    //   const originalEvent = await eventsCollection.findOne({});
 
-      expect((await repetitionsCollection.find({
-        groupHash: originalEvent.groupHash,
-      }).toArray()).length).toBe(2);
-    });
+    //   expect((await repetitionsCollection.find({
+    //     groupHash: originalEvent.groupHash,
+    //   }).toArray()).length).toBe(2);
+    // });
 
     describe('Pattern matching', () => {
       beforeEach(() => {
@@ -490,8 +490,8 @@
       });
 
       test('should group events with titles matching one pattern', async () => {
         jest.spyOn(GrouperWorker.prototype as any, 'getProjectPatterns').mockResolvedValue([ 'New error .*' ]);
         const findMatchingPatternSpy = jest.spyOn(GrouperWorker.prototype as any, 'findMatchingPattern');
 
         await worker.handle(generateTask({ title: 'New error 0000000000000000' }));
         await worker.handle(generateTask({ title: 'New error 1111111111111111' }));
@@ -506,7 +506,7 @@
       });
 
       test('should handle multiple patterns and match the first one that applies', async () => {
         jest.spyOn(GrouperWorker.prototype as any, 'getProjectPatterns').mockResolvedValue([
           'Database error: .*',
           'Network error: .*',
           'New error: .*',
@@ -525,7 +525,7 @@
       });
 
       test('should handle complex regex patterns', async () => {
         jest.spyOn(GrouperWorker.prototype as any, 'getProjectPatterns').mockResolvedValue([
           'Error \\d{3}: [A-Za-z\\s]+ in file .*\\.js$',
           'Warning \\d{3}: .*',
         ]);
@@ -543,7 +543,7 @@
       });
 
       test('should maintain separate groups for different patterns', async () => {
         jest.spyOn(GrouperWorker.prototype as any, 'getProjectPatterns').mockResolvedValue([
           'TypeError: .*',
           'ReferenceError: .*',
         ]);
@@ -565,7 +565,7 @@
       });
 
       test('should handle patterns with special regex characters', async () => {
         jest.spyOn(GrouperWorker.prototype as any, 'getProjectPatterns').mockResolvedValue([
           'Error \\[\\d+\\]: .*',
           'Warning \\(code=\\d+\\): .*',
         ]);

workers/grouper/tests/mocks/randomId.ts

@@ -8,5 +8,5 @@ export function generateRandomId(): string {
 
   return Math.random().toString(RADIX)
     .substring(FIRST_RANDOM_START, FIRST_RANDOM_END) + Math.random().toString(RADIX)
-      .substring(FIRST_RANDOM_START, FIRST_RANDOM_END);
+    .substring(FIRST_RANDOM_START, FIRST_RANDOM_END);
 }