Simplified the duplicate checker plugin

src/plugins/default/DuplicateCheckerPlugin-spec.ts

@@ -6,14 +6,11 @@ import { createFixture } from './EventPluginTestFixture';
 import { expect } from 'chai';
 
 describe('DuplicateCheckerPlugin', () => {
-
-  let target: DuplicateCheckerPlugin;
-  let now: number;
+  let now: number = 0;
+  let plugin: DuplicateCheckerPlugin;
 
   beforeEach(() => {
-    target = new DuplicateCheckerPlugin();
-    (<any>target).getNow = () => now;
-    now = 0;
+    plugin = new DuplicateCheckerPlugin(() => now);
   });
 
   function run(exception: Error) {
@@ -28,7 +25,7 @@ describe('DuplicateCheckerPlugin', () => {
 
     let errorPlugin = new ErrorPlugin();
     errorPlugin.run(context);
-    target.run(context);
+    plugin.run(context);
 
     return context;
   }

src/plugins/default/DuplicateCheckerPlugin.ts

@@ -4,67 +4,50 @@ import { IEventPlugin } from '../IEventPlugin';
 import { EventPluginContext } from '../EventPluginContext';
 import { Utils } from '../../Utils';
 
-const ERROR_KEY: string = '@error';
-const WINDOW_MILLISECONDS = 2000;
-const MAX_QUEUE_LENGTH = 10;
-
 export class DuplicateCheckerPlugin implements IEventPlugin {
   public priority: number = 40;
   public name: string = 'DuplicateCheckerPlugin';
 
-  private recentlyProcessedErrors: TimestampedHash[] = [];
-
-  public run(context: EventPluginContext, next?: () => void): void {
-    if (context.event.type === 'error') {
-      let error = context.event.data[ERROR_KEY];
-      let isDuplicate = this.checkDuplicate(error, context.log);
-      if (isDuplicate) {
-        context.cancelled = true;
-        return;
-      }
-    }
+  private _processedHashcodes: TimestampedHash[] = [];
+  private _getCurrentTime: () => number;
 
-    next && next();
+  constructor(getCurrentTime:() => number = () => Date.now()) {
+    this._getCurrentTime = getCurrentTime;
   }
 
-  private getNow() {
-    return Date.now();
-  }
+  public run(context: EventPluginContext, next?: () => void): void {
+    function isDuplicate(error: IInnerError, processedHashcodes, now, log: ILog): boolean {
+      while (error) {
+        let hashCode = Utils.getHashCode(error.stack_trace && JSON.stringify(error.stack_trace));
 
-  private checkDuplicate(error: IInnerError, log: ILog): boolean {
-    function getHashCodeForError(err: IInnerError): number {
-      if (!err.stack_trace) {
-        return null;
-      }
+        // Only process the unique errors times within a 2 second window.
+        if (hashCode && processedHashcodes.some(h => h.hash === hashCode && h.timestamp >= (now - 2000))) {
+          log.info(`Ignoring duplicate error event hash: ${hashCode}`);
+          return true;
+        }
 
-      return Utils.getHashCode(JSON.stringify(err.stack_trace));
-    }
+        // Add this exception to our list of recent processed errors.
+        processedHashcodes.push({ hash: hashCode, timestamp: now });
 
-    let now = this.getNow();
-    let repeatWindow = now - WINDOW_MILLISECONDS;
-    let hashCode: number;
-    while (error) {
-      hashCode = getHashCodeForError(error);
+        // Only keep the last 20 recent errors.
+        while (processedHashcodes.length > 20) {
+          processedHashcodes.shift();
+        }
 
-      // make sure that we don't process the same error multiple times within the repeat window
-      if (hashCode && this.recentlyProcessedErrors.some(h =>
-        h.hash === hashCode && h.timestamp >= repeatWindow)) {
-        log.info(`Ignoring duplicate error event: hash=${hashCode}`);
-        return true;
+        error = error.inner;
       }
 
-      // add this exception to our list of recent errors that we have processed
-      this.recentlyProcessedErrors.push({ hash: hashCode, timestamp: now });
+      return false;
+    }
 
-      // only keep the last 10 recent errors
-      while (this.recentlyProcessedErrors.length > MAX_QUEUE_LENGTH) {
-        this.recentlyProcessedErrors.shift();
+    if (context.event.type === 'error') {
+      if (isDuplicate(context.event.data['@error'], this._processedHashcodes, this._getCurrentTime(), context.log)) {
+        context.cancelled = true;
+        return;
       }
-
-      error = error.inner;
     }
 
-    return false;
+    next && next();
   }
 }