Parse the stack function name to try and bring back namespace & type info.

@ejsmith added 1KB but we now get namespaces and type info :(. Thoughts?

Author: niemyjski

dist/exceptionless.d.ts

@@ -166,6 +166,7 @@ export declare class Utils {
     static getCookies(cookies: string, separator: string): Object;
     static guid(): string;
     static merge(defaultValues: any, values: any): {};
+    static parseFunctionName(frame: string): IStackFrame;
     static parseVersion(source: string): string;
     static parseQueryString(query: string): {};
     static randomNumber(): number;
@@ -278,9 +279,9 @@ export interface IMethod {
     module_id?: number;
 }
 export interface IStackFrame extends IMethod {
-    file_name: string;
-    line_number: number;
-    column: number;
+    file_name?: string;
+    line_number?: number;
+    column?: number;
 }
 export interface IInnerError {
     message?: string;

dist/exceptionless.js

@@ -1,6 +1,58 @@
 import { Utils } from 'Utils';
 
 describe('Utils', () => {
+  it('should parse namespace, type and name', () => {
+    expect(Utils.parseFunctionName('?')).toEqual({
+      name: '<anonymous>',
+    });
+
+    expect(Utils.parseFunctionName(null)).toEqual({
+      name: '<anonymous>',
+    });
+
+    expect(Utils.parseFunctionName('Array.EventPluginManager.run.wrap')).toEqual({
+      declaring_type: 'EventPluginManager',
+      name: 'run.wrap',
+    });
+
+    expect(Utils.parseFunctionName('EventPluginManager.run.wrap')).toEqual({
+      declaring_type: 'EventPluginManager',
+      name: 'run.wrap',
+    });
+
+    expect(Utils.parseFunctionName('EventBuilder.submit')).toEqual({
+      declaring_type: 'EventBuilder',
+      name: 'submit',
+    });
+
+    expect(Utils.parseFunctionName('processUnhandledException')).toEqual({
+      name: 'processUnhandledException',
+    });
+
+    expect(Utils.parseFunctionName('test.process')).toEqual({
+      declaring_type: 'test',
+      name: 'process',
+    });
+
+    expect(Utils.parseFunctionName('exceptionless.Plugins.EventPluginManager.run')).toEqual({
+      declaring_namespace: 'exceptionless.Plugins',
+      declaring_type: 'EventPluginManager',
+      name: 'run',
+    });
+
+    expect(Utils.parseFunctionName('exceptionless.plugins.EventPluginManager.run')).toEqual({
+      declaring_namespace: 'exceptionless.plugins',
+      declaring_type: 'EventPluginManager',
+      name: 'run',
+    });
+
+    expect(Utils.parseFunctionName('exceptionless.plugins.utils.parse')).toEqual({
+      declaring_namespace: 'exceptionless.plugins',
+      declaring_type: 'utils',
+      name: 'parse',
+    });
+  });
+
   it('should stringify circular reference', () => {
     var afoo:any = { a: 'foo' };
     afoo.b = afoo;

dist/exceptionless.js.map

@@ -1,3 +1,5 @@
+import { IStackFrame } from 'models/IStackFrame';
+
 export class Utils {
   public static getHashCode(source:string): string {
     if (!source || source.length === 0) {
@@ -52,6 +54,66 @@ export class Utils {
     return result;
   }
 
+  public static parseFunctionName(frame:string): IStackFrame {
+    function isLowerCase(part:string) {
+      for (var index = 0; index < (part || '').length; index++) {
+        var code = part.charCodeAt(index);
+        if (code >= 65 && code <= 90) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    var anonymous = '<anonymous>';
+    var parts = (frame || '').replace('?', anonymous).split('.');
+    if (parts[0] === 'Array' || parts[0] === 'Function') {
+      parts.shift();
+    }
+
+    var namespace:string[] = [];
+    var type:string;
+    var name:string[] = [parts.pop() || anonymous];
+
+    for (var index = 0; index < parts.length; index++) {
+      var part = parts[index];
+      if (!type && index === (parts.length -1)) {
+        type = part;
+        break;
+      }
+
+      var isLower = isLowerCase(part);
+      if (isLower) {
+        if (!type) {
+          namespace.push(part);
+        } else {
+          name.unshift(part);
+        }
+
+        continue;
+      }
+
+      // mixed case.
+      if (type) {
+        namespace.push(type);
+      }
+
+      type = part;
+    }
+
+    var stackFrame:IStackFrame = { name: name.join('.') };
+    if (namespace.join('.').length > 0) {
+      stackFrame.declaring_namespace = namespace.join('.');
+    }
+
+    if (!!type && type.length > 0) {
+      stackFrame.declaring_type = type;
+    }
+
+    return stackFrame;
+  }
+
   public static parseVersion(source:string): string {
     if (!source) {
       return null;

dist/exceptionless.min.js

@@ -1,7 +1,7 @@
 import { IMethod } from './IMethod';
 
 export interface IStackFrame extends IMethod {
-  file_name:string;
-  line_number:number;
-  column:number;
+  file_name?:string;
+  line_number?:number;
+  column?:number;
 }

dist/exceptionless.min.js.map

@@ -3,6 +3,7 @@ import { IParameter } from '../models/IParameter';
 import { IErrorParser } from 'IErrorParser';
 import { IStackFrame } from '../models/IStackFrame';
 import { EventPluginContext } from '../plugins/EventPluginContext';
+import { Utils } from '../Utils';
 
 export class WebErrorParser implements IErrorParser {
   public parse(context:EventPluginContext, exception:Error): void {
@@ -28,12 +29,19 @@ export class WebErrorParser implements IErrorParser {
 
     for (var index = 0; index < stackFrames.length; index++) {
       var frame = stackFrames[index];
+      var parseResult = Utils.parseFunctionName(frame.func);
+
       frames.push({
-        name: frame.func || '[anonymous]',
+        declaring_namespace: parseResult.declaring_namespace,
+        declaring_type: parseResult.declaring_type,
+        name: parseResult.name,
         parameters: this.getParameters(frame.args),
         file_name: frame.url,
         line_number: frame.line,
-        column: frame.column
+        column: frame.column,
+        data: {
+          '@@original_name': frame.func
+        }
       });
     }