Added new EventExclusionPlugin

src/Utils.ts

@@ -149,8 +149,7 @@ export class Utils {
       }
 
       if (startsWithWildcard) {
-        let lastIndexOf = input.lastIndexOf(pattern);
-        return lastIndexOf !== -1 && lastIndexOf === (input.length - pattern.length);
+        return Utils.startsWith(input, pattern);
       }
 
       if (endsWithWildcard) {
@@ -165,6 +164,11 @@ export class Utils {
     return input === null || (typeof (input) === 'object' && Object.keys(input).length === 0);
   }
 
+  public static startsWith(input: string, pattern: string): boolean {
+    let lastIndexOf = input.lastIndexOf(pattern);
+    return lastIndexOf !== -1 && lastIndexOf === (input.length - pattern.length);
+  }
+
   /**
    * Stringifys an object with optional exclusions and max depth.
    * @param data The data object to add.

src/plugins/EventPluginManager.ts

@@ -8,6 +8,7 @@ import { RequestInfoPlugin } from './default/RequestInfoPlugin';
 import { EnvironmentInfoPlugin } from './default/EnvironmentInfoPlugin';
 import { SubmissionMethodPlugin } from './default/SubmissionMethodPlugin';
 import { DuplicateCheckerPlugin } from './default/DuplicateCheckerPlugin';
+import { EventExclusionPlugin } from './default/EventExclusionPlugin';
 
 export class EventPluginManager {
   public static run(context: EventPluginContext, callback: (context?: EventPluginContext) => void): void {
@@ -45,6 +46,7 @@ export class EventPluginManager {
     config.addPlugin(new ConfigurationDefaultsPlugin());
     config.addPlugin(new ErrorPlugin());
     config.addPlugin(new DuplicateCheckerPlugin());
+    config.addPlugin(new EventExclusionPlugin());
     config.addPlugin(new ModuleInfoPlugin());
     config.addPlugin(new RequestInfoPlugin());
     config.addPlugin(new EnvironmentInfoPlugin());

src/plugins/default/DuplicateCheckerPlugin.ts

@@ -11,7 +11,7 @@ export class DuplicateCheckerPlugin implements IEventPlugin {
   private _processedHashcodes: TimestampedHash[] = [];
   private _getCurrentTime: () => number;
 
-  constructor(getCurrentTime:() => number = () => Date.now()) {
+  constructor(getCurrentTime: () => number = () => Date.now()) {
     this._getCurrentTime = getCurrentTime;
   }
 

src/plugins/default/EventExclusionPlugin.ts

@@ -0,0 +1,86 @@
+import { IInnerError } from '../../models/IInnerError';
+import { IEventPlugin } from '../IEventPlugin';
+import { EventPluginContext } from '../EventPluginContext';
+import { Utils } from '../../Utils';
+
+export class EventExclusionPlugin implements IEventPlugin {
+  public priority: number = 45;
+  public name: string = 'EventExclusionPlugin';
+
+  public run(context: EventPluginContext, next?: () => void): void {
+    function getLogLevel(level: string): number {
+      switch (level.toLowerCase()) {
+        case 'trace':
+          return 0;
+        case 'debug':
+          return 1;
+        case 'info':
+          return 2;
+        case 'warn':
+          return 3;
+        case 'error':
+          return 4;
+        case 'fatal':
+          return 5;
+        case 'off':
+          return 6;
+        default:
+          return -1;
+      }
+    }
+
+    function getMinLogLevel(settings: Object, loggerName: string = '*'): number {
+      return getLogLevel(getTypeAndSourceSetting(settings, 'log', loggerName, 'Trace'));
+    }
+
+    function getTypeAndSourceSetting(settings: Object = {}, type: string, source: string, defaultValue: string|boolean = undefined): string|boolean {
+      if (!type) {
+        return defaultValue;
+      }
+
+      let sourcePrefix =  `@@${type}:`;
+      if (settings[sourcePrefix + source]) {
+        return settings[sourcePrefix + source];
+      }
+
+      // check for wildcard match
+      for (let key in settings) {
+        if (Utils.startsWith(key.toLowerCase(), sourcePrefix.toLowerCase()) && Utils.isMatch(source, [key.substring(sourcePrefix.length)])) {
+          return settings[key];
+        }
+      }
+
+      return defaultValue;
+    }
+
+    let ev = context.event;
+    let settings = context.client.config.settings;
+
+    if (ev.type === 'log') {
+      let minLogLevel = getMinLogLevel(settings, ev.source);
+      let logLevel = getLogLevel(ev.data['@level'] || 'Trace');
+
+      if (logLevel >= 0 && (logLevel > 5 || logLevel < minLogLevel)) {
+        context.log.info('Cancelling log event due to minimum log level.');
+        context.cancelled = true;
+      }
+    } else if (ev.type === 'error') {
+      let error: IInnerError = ev.data['@error'];
+      while (!context.cancelled && error) {
+        if (getTypeAndSourceSetting(settings, ev.type, error.type, true) === true) {
+          context.log.info(`Cancelling error from excluded exception type: ${error.type}`);
+          context.cancelled = true;
+        }
+
+        error = error.inner;
+      }
+    }
+
+    if (!context.cancelled && getTypeAndSourceSetting(settings, ev.type, ev.source, true) === true) {
+      context.log.info(`Cancelling event from excluded type: ${ev.type} and source: ${ev.source}`);
+      context.cancelled = true;
+    }
+
+    next && next();
+  }
+}