Added ExitController and synchronous submission

Author: frankebersoll

dist/exceptionless.d.ts

@@ -14,8 +14,10 @@ import { IEventQueue } from '../queue/IEventQueue';
 import { DefaultEventQueue } from '../queue/DefaultEventQueue';
 import { IEnvironmentInfoCollector } from '../services/IEnvironmentInfoCollector';
 import { IErrorParser } from '../services/IErrorParser';
+import { IExitController } from '../services/IExitController';
 import { IModuleCollector } from '../services/IModuleCollector';
 import { IRequestInfoCollector } from '../services/IRequestInfoCollector';
+import { DefaultExitController } from '../services/DefaultExitController';
 import { IStorage } from '../storage/IStorage';
 import { InMemoryStorage } from '../storage/InMemoryStorage';
 import { ISubmissionClient } from '../submission/ISubmissionClient';
@@ -69,6 +71,8 @@ export class Configuration implements IConfigurationSettings {
 
   public queue:IEventQueue;
 
+  public exitController:IExitController;
+
   constructor(configSettings?:IConfigurationSettings) {
     function inject(fn:any) {
       return typeof fn === 'function' ? fn(this) : fn;
@@ -89,6 +93,7 @@ export class Configuration implements IConfigurationSettings {
     this.submissionClient = inject(configSettings.submissionClient);
     this.storage = inject(configSettings.storage) || new InMemoryStorage<any>();
     this.queue = inject(configSettings.queue) || new DefaultEventQueue(this);
+    this.exitController = inject(configSettings.exitController) || new DefaultExitController();
 
     SettingsManager.applySavedServerSettings(this);
     EventPluginManager.addDefaultPlugins(this);

dist/exceptionless.js

@@ -3,6 +3,7 @@ import { ILog } from '../logging/ILog';
 import { IEventQueue } from '../queue/IEventQueue';
 import { IEnvironmentInfoCollector } from '../services/IEnvironmentInfoCollector';
 import { IErrorParser } from '../services/IErrorParser';
+import { IExitController } from '../services/IExitController';
 import { IModuleCollector } from '../services/IModuleCollector';
 import { IRequestInfoCollector } from '../services/IRequestInfoCollector';
 import { IStorage } from '../storage/IStorage';
@@ -21,4 +22,5 @@ export interface IConfigurationSettings {
   submissionClient?:ISubmissionClient;
   storage?:IStorage<any>;
   queue?:IEventQueue;
+  exitController?: IExitController;
 }

dist/exceptionless.js.map

@@ -37,6 +37,7 @@ import { IModuleCollector } from './services/IModuleCollector';
 import { IRequestInfoCollector } from './services/IRequestInfoCollector';
 import { NodeEnvironmentInfoCollector } from './services/NodeEnvironmentInfoCollector';
 import { NodeErrorParser } from './services/NodeErrorParser';
+import { NodeExitController } from './services/NodeExitController';
 import { NodeRequestInfoCollector } from './services/NodeRequestInfoCollector';
 import { InMemoryStorage } from './storage/InMemoryStorage';
 import { IStorage } from './storage/IStorage';
@@ -50,22 +51,42 @@ import { EventBuilder } from 'EventBuilder';
 import { ExceptionlessClient } from 'ExceptionlessClient';
 import { Utils } from 'Utils';
 
-const BEFORE_EXIT:string = 'BEFORE_EXIT';
-const UNCAUGHT_EXCEPTION:string = 'UNCAUGHT_EXCEPTION';
+const EXIT:string = 'exit';
+const UNCAUGHT_EXCEPTION:string = 'uncaughtException';
 
 var defaults = Configuration.defaults;
 defaults.environmentInfoCollector = new NodeEnvironmentInfoCollector();
 defaults.errorParser = new NodeErrorParser();
+defaults.exitController = new NodeExitController();
 defaults.requestInfoCollector = new NodeRequestInfoCollector();
 defaults.submissionClient = new NodeSubmissionClient();
 
+function getListenerCount(emitter, event):number {
+  if (emitter.listenerCount) {
+    return emitter.listenerCount(event);
+  }
+
+  return require("events").listenerCount(emitter, event);
+}
+
 process.on(UNCAUGHT_EXCEPTION, function (error:Error) {
   ExceptionlessClient.default.submitUnhandledException(error, UNCAUGHT_EXCEPTION);
+
+  /*
+   * Default Node behavior: If this is the only uncaught-listener, we still exit.
+   * Discussion: https://nodejs.org/api/process.html#process_event_uncaughtexception
+   */
+  var uncaughtListenerCount = getListenerCount(process, UNCAUGHT_EXCEPTION);
+  if (uncaughtListenerCount <= 1) {
+    process.exit(1);
+  }
 });
 
-process.on(BEFORE_EXIT, function (code:number) {
+process.on(EXIT, function (code:number) {
   /**
    * exit codes: https://nodejs.org/api/process.html#process_event_exit
+   * From now on, only synchronous code may run. As soon as this method
+   * ends, the application inevitably will exit.
    */
   function  getExitCodeReason(code:number): string {
     if (code === 1) {
@@ -116,12 +137,16 @@ process.on(BEFORE_EXIT, function (code:number) {
   }
 
   var client = ExceptionlessClient.default;
+  var config = client.config;
   var message = getExitCodeReason(code);
+
   if (message !== null) {
-    client.submitLog(BEFORE_EXIT, message, 'Error')
+    client.submitLog(EXIT, message, 'Error')
   }
 
-  client.config.queue.process()
+  config.exitController.processExit(config);
+
+  // Application will now exit.
 });
 
 (<any>Error).stackTraceLimit = Infinity;

dist/exceptionless.min.js

@@ -0,0 +1,29 @@
+/*
+    TODO: Fix in DefinitelyTyped, remove this file, remove reference from tsconfig.node.json
+
+    Pull requests:
+      https://github.com/borisyankov/DefinitelyTyped/pull/6185
+*/
+
+declare module "child_process" {
+    export function spawnSync(command: string, args?: string[], options?: {
+        cwd?: string;
+        input?: string | Buffer;
+        stdio?: any;
+        env?: any;
+        uid?: number;
+        gid?: number;
+        timeout?: number;
+        maxBuffer?: number;
+        killSignal?: string;
+        encoding?: string;
+    }): {
+            pid: number;
+            output: string[];
+            stdout: string | Buffer;
+            stderr: string | Buffer;
+            status: number;
+            signal: string;
+            error: Error;
+        };
+}

dist/exceptionless.min.js.map

@@ -0,0 +1,12 @@
+import { Configuration } from '../configuration/Configuration';
+import { IExitController } from './IExitController';
+
+export class DefaultExitController implements IExitController {
+
+  public get isApplicationExiting() {
+    return false;
+  }
+
+  public processExit(config:Configuration): void {
+  }
+}

dist/exceptionless.node.js

@@ -0,0 +1,6 @@
+import { Configuration } from '../configuration/Configuration';
+
+export interface IExitController {
+  isApplicationExiting:boolean;
+  processExit(config:Configuration):void;
+}

dist/exceptionless.node.js.map

@@ -0,0 +1,16 @@
+import { Configuration } from '../configuration/Configuration';
+import { IExitController } from './IExitController';
+
+export class NodeExitController implements IExitController {
+
+  private _isApplicationExiting: boolean;
+
+  public get isApplicationExiting() {
+    return this._isApplicationExiting;
+  }
+
+  public processExit(config:Configuration):void {
+    this._isApplicationExiting = true;
+    config.queue.process();
+  }
+}

dist/integrations/angular.js

@@ -3,57 +3,48 @@ import { IEvent } from '../models/IEvent';
 import { IUserDescription } from '../models/IUserDescription';
 import { DefaultSubmissionClient } from './DefaultSubmissionClient';
 import { SettingsResponse } from './SettingsResponse';
+import { NodeSubmissionRequest, NodeSubmissionCallback, submitRequest } from './NodeSubmissionRequest';
 import { SubmissionResponse } from './SubmissionResponse';
 import { Utils } from '../Utils';
 
 import http = require('http');
-import https = require('https');
-import url = require('url');
+import child = require('child_process');
 
 export class NodeSubmissionClient extends DefaultSubmissionClient {
   constructor() {
     super();
     this.configurationVersionHeader = this.configurationVersionHeader.toLowerCase();
   }
 
-  public sendRequest(config:Configuration, method:string, path:string, data:string, callback: (status:number, message:string, data?:string, headers?:Object) => void): void {
-    function complete(response:http.IncomingMessage, responseBody:string, responseHeaders:Object) {
-      var message:string;
-      if (response.statusCode === 0) {
-        message = 'Unable to connect to server.';
-      } else if (response.statusCode < 200 || response.statusCode > 299) {
-        message = response.statusMessage || (<any>response).message;
-      }
+  public sendRequest(config: Configuration, method: string, path: string, data: string, callback: NodeSubmissionCallback): void {
+    var request: NodeSubmissionRequest = {
+      method,
+      path,
+      data,
+      serverUrl: config.serverUrl,
+      apiKey: config.apiKey,
+      userAgent: config.userAgent
+    };
 
-      callback(response.statusCode || 500, message, responseBody, responseHeaders);
+    var exitController = config.exitController;
+    if (exitController.isApplicationExiting) {
+      this.sendRequestSync(request, callback);
+    } else {
+      submitRequest(request, callback);
     }
+  }
 
-    var parsedHost = url.parse(config.serverUrl);
-    var options:https.RequestOptions = {
-      auth: `client:${config.apiKey}`,
-      headers: {},
-      hostname: parsedHost.hostname,
-      method: method,
-      port: parsedHost.port && parseInt(parsedHost.port),
-      path: path
-    };
+  private sendRequestSync(request: NodeSubmissionRequest, callback: NodeSubmissionCallback): void {
+    var requestJson = JSON.stringify(request);
+    var res = child.spawnSync(process.execPath, [require.resolve('./submitSync.js')],
+      {
+        input: requestJson,
+        stdio: ['pipe', 'pipe', process.stderr]
+      });
 
-    if (method === 'POST') {
-      options.headers = {
-        'Content-Type': 'application/json',
-        'Content-Length': data.length
-      }
-    }
-    
-    options.headers['User-Agent'] = config.userAgent;
-    var request:http.ClientRequest = (parsedHost.protocol === 'https' ? https : http).request(options, (response:http.IncomingMessage) => {
-      var body = '';
-      response.setEncoding('utf8');
-      response.on('data', (chunk) => body += chunk);
-      response.on('end', () => complete(response, body, response.headers));
-    });
+    var out = res.stdout.toString();
+    var result = JSON.parse(out);
 
-    request.on('error', (error:Error) => callback(500, error.message));
-    request.end(data);
+    callback(result.status, result.message, result.data, result.headers);
   }
 }

dist/submitSync.js

@@ -0,0 +1,60 @@
+import http = require('http');
+import https = require('https');
+import url = require('url');
+
+export interface NodeSubmissionCallback {
+  (status: number, message: string, data?: string, headers?: Object): void
+}
+
+export interface NodeSubmissionRequest {
+  serverUrl: string;
+  apiKey: string;
+  userAgent: string;
+  method: string;
+  path: string;
+  data: string;
+}
+
+function complete(response: http.IncomingMessage, responseBody: string, responseHeaders: Object, callback:NodeSubmissionCallback): void {
+    var message: string;
+    if(response.statusCode === 0) {
+    message = 'Unable to connect to server.';
+    } else if (response.statusCode < 200 || response.statusCode > 299) {
+    message = response.statusMessage || (<any>response).message;
+    }
+
+    callback(response.statusCode || 500, message, responseBody, responseHeaders);
+}
+
+export function submitRequest(request: NodeSubmissionRequest, callback: NodeSubmissionCallback): void {
+  var parsedHost = url.parse(request.serverUrl);
+
+  var options: https.RequestOptions = {
+    auth: `client:${request.apiKey}`,
+    headers: {},
+    hostname: parsedHost.hostname,
+    method: request.method,
+    port: parsedHost.port && parseInt(parsedHost.port),
+    path: request.path
+  };
+
+  options.headers['User-Agent'] = request.userAgent;
+
+  if (request.method === 'POST') {
+    options.headers = {
+      'Content-Type': 'application/json',
+      'Content-Length': request.data.length
+    }
+  }
+
+  var protocol = (parsedHost.protocol === 'https' ? https : http);
+  var clientRequest: http.ClientRequest = protocol.request(options, (response: http.IncomingMessage) => {
+    var body = '';
+    response.setEncoding('utf8');
+    response.on('data', (chunk) => body += chunk);
+    response.on('end', () => complete(response, body, response.headers, callback));
+  });
+
+  clientRequest.on('error', (error: Error) => callback(500, error.message));
+  clientRequest.end(request.data);
+}

dist/submitSync.js.map

@@ -0,0 +1,31 @@
+import { NodeSubmissionRequest, submitRequest } from './submission/NodeSubmissionRequest';
+
+import * as stream from 'stream';
+import { StringDecoder } from 'string_decoder';
+
+var decoder = new StringDecoder('utf8');
+var strings: string[] = [];
+
+var jsonStream = new stream.Writable();
+jsonStream._write = (chunk: Buffer|string, encoding: string, next: Function) => {
+    strings.push(decoder.write(<Buffer>chunk));
+    next();
+};
+
+jsonStream.on("finish", () => {
+  var json = strings.join("");
+  var request:NodeSubmissionRequest = JSON.parse(json);
+
+  submitRequest(request, (status, message, data, headers) => {
+    var result = {
+      status,
+      message,
+      data,
+      headers
+    };
+    process.stdout.write(JSON.stringify(result));
+    process.exit(0);
+  });
+});
+
+process.stdin.pipe(jsonStream);

src/configuration/Configuration.ts

@@ -10,13 +10,17 @@
     "exceptionless.node": {
       "files": [
         "typings/node/node.d.ts",
+        "node.fix.d.ts",
         "typings/stack-trace/stack-trace.d.ts",
 
         "exceptionless.node.ts"
       ]
     },
     "submitSync": {
       "files": [
+        "typings/node/node.d.ts",
+        "node.fix.d.ts",
+
         "submitSync.ts"
       ]
     }