@honeybadger-io/js 6.4.1 → 6.4.3

package/dist/server/honeybadger.js

@@ -864,14 +864,14 @@ var NOT_BLANK = /\S/;
 var Client = /** @class */ (function () {
     function Client(opts, transport) {
         if (opts === void 0) { opts = {}; }
-        this.__pluginsExecuted = false;
+        this.__pluginsLoaded = false;
         this.__store = null;
         this.__beforeNotifyHandlers = [];
         this.__afterNotifyHandlers = [];
         this.__notifier = {
             name: '@honeybadger-io/core',
             url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/core',
-            version: '6.4.1'
+            version: '6.4.3'
         };
         this.config = __assign({ apiKey: null, endpoint: 'https://api.honeybadger.io', environment: null, hostname: null, projectRoot: null, component: null, action: null, revision: null, reportData: null, breadcrumbsEnabled: true, maxBreadcrumbs: 40, maxObjectDepth: 8, logger: console, developmentEnvironments: ['dev', 'development', 'test'], debug: false, tags: null, enableUncaught: true, enableUnhandledRejection: true, afterUncaught: function () { return true; }, filters: ['creditcard', 'password'], __plugins: [] }, opts);
         this.__initStore();
@@ -895,17 +895,21 @@ var Client = /** @class */ (function () {
         this.__notifier = notifier;
     };
     Client.prototype.configure = function (opts) {
-        var _this = this;
         if (opts === void 0) { opts = {}; }
         for (var k in opts) {
             this.config[k] = opts[k];
         }
-        if (!this.__pluginsExecuted) {
-            this.__pluginsExecuted = true;
-            this.config.__plugins.forEach(function (plugin) { return plugin.load(_this); });
-        }
+        this.loadPlugins();
         return this;
     };
+    Client.prototype.loadPlugins = function () {
+        var _this = this;
+        var pluginsToLoad = this.__pluginsLoaded
+            ? this.config.__plugins.filter(function (plugin) { return plugin.shouldReloadOnConfigure; })
+            : this.config.__plugins;
+        pluginsToLoad.forEach(function (plugin) { return plugin.load(_this); });
+        this.__pluginsLoaded = true;
+    };
     Client.prototype.__initStore = function () {
         this.__store = new store_1.GlobalStore({ context: {}, breadcrumbs: [] }, this.config.maxBreadcrumbs);
     };
@@ -1301,13 +1305,13 @@ var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (th
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __importDefault$3 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+var __importDefault$4 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(util, "__esModule", { value: true });
 util.getSourceFile = util.getStats = util.fatallyLogAndExit = void 0;
-var os_1 = __importDefault$3(require$$0__default["default"]);
-var fs_1 = __importDefault$3(require$$1__default["default"]);
+var os_1 = __importDefault$4(require$$0__default["default"]);
+var fs_1 = __importDefault$4(require$$1__default["default"]);
 var util_1$3 = require$$2__default["default"];
 var readFile = (0, util_1$3.promisify)(fs_1.default.readFile);
 function fatallyLogAndExit(err) {
@@ -1505,12 +1509,61 @@ Object.defineProperty(uncaught_exception_monitor, "__esModule", { value: true })
 var aws_lambda_1 = aws_lambda;
 var util_1$2 = util;
 var UncaughtExceptionMonitor = /** @class */ (function () {
-    function UncaughtExceptionMonitor(client) {
+    function UncaughtExceptionMonitor() {
         this.__isReporting = false;
         this.__handlerAlreadyCalled = false;
-        this.__client = client;
+        this.__listener = this.makeListener();
         this.removeAwsLambdaListener();
     }
+    UncaughtExceptionMonitor.prototype.setClient = function (client) {
+        this.__client = client;
+    };
+    UncaughtExceptionMonitor.prototype.makeListener = function () {
+        var _this = this;
+        var honeybadgerUncaughtExceptionListener = function (uncaughtError) {
+            if (_this.__isReporting || !_this.__client) {
+                return;
+            }
+            if (!_this.__client.config.enableUncaught) {
+                _this.__client.config.afterUncaught(uncaughtError);
+                if (!_this.hasOtherUncaughtExceptionListeners()) {
+                    (0, util_1$2.fatallyLogAndExit)(uncaughtError);
+                }
+                return;
+            }
+            // report only the first error - prevent reporting recursive errors
+            if (_this.__handlerAlreadyCalled) {
+                if (!_this.hasOtherUncaughtExceptionListeners()) {
+                    (0, util_1$2.fatallyLogAndExit)(uncaughtError);
+                }
+                return;
+            }
+            _this.__isReporting = true;
+            _this.__client.notify(uncaughtError, {
+                afterNotify: function (_err, _notice) {
+                    _this.__isReporting = false;
+                    _this.__handlerAlreadyCalled = true;
+                    _this.__client.config.afterUncaught(uncaughtError);
+                    if (!_this.hasOtherUncaughtExceptionListeners()) {
+                        (0, util_1$2.fatallyLogAndExit)(uncaughtError);
+                    }
+                }
+            });
+        };
+        return honeybadgerUncaughtExceptionListener;
+    };
+    UncaughtExceptionMonitor.prototype.maybeAddListener = function () {
+        var listeners = process.listeners('uncaughtException');
+        if (!listeners.includes(this.__listener)) {
+            process.on('uncaughtException', this.__listener);
+        }
+    };
+    UncaughtExceptionMonitor.prototype.maybeRemoveListener = function () {
+        var listeners = process.listeners('uncaughtException');
+        if (listeners.includes(this.__listener)) {
+            process.removeListener('uncaughtException', this.__listener);
+        }
+    };
     UncaughtExceptionMonitor.prototype.removeAwsLambdaListener = function () {
         var isLambda = !!process.env.LAMBDA_TASK_ROOT;
         if (!isLambda) {
@@ -1523,112 +1576,125 @@ var UncaughtExceptionMonitor = /** @class */ (function () {
      * we want to report the exception to Honeybadger and
      * mimic the default behavior of NodeJs,
      * which is to exit the process with code 1
+     *
+     * Node sets up domainUncaughtExceptionClear when we use domains.
+     * Since they're not set up by a user, they shouldn't affect whether we exit or not
      */
     UncaughtExceptionMonitor.prototype.hasOtherUncaughtExceptionListeners = function () {
-        var allListeners = process.listeners('uncaughtException');
-        // Node sets up these listeners when we use domains
-        // Since they're not set up by a user, they shouldn't affect whether we exit or not
-        var domainListeners = allListeners.filter(function (listener) {
-            listener.name === 'domainUncaughtExceptionClear';
-        });
-        return allListeners.length - domainListeners.length > 1;
-    };
-    UncaughtExceptionMonitor.prototype.handleUncaughtException = function (uncaughtError) {
         var _this = this;
-        if (this.__isReporting) {
-            return;
-        }
-        if (!this.__client.config.enableUncaught) {
-            this.__client.config.afterUncaught(uncaughtError);
-            if (!this.hasOtherUncaughtExceptionListeners()) {
-                (0, util_1$2.fatallyLogAndExit)(uncaughtError);
-            }
-            return;
-        }
-        // report only the first error - prevent reporting recursive errors
-        if (this.__handlerAlreadyCalled) {
-            if (!this.hasOtherUncaughtExceptionListeners()) {
-                (0, util_1$2.fatallyLogAndExit)(uncaughtError);
-            }
-            return;
-        }
-        this.__isReporting = true;
-        this.__client.notify(uncaughtError, {
-            afterNotify: function (_err, _notice) {
-                _this.__isReporting = false;
-                _this.__handlerAlreadyCalled = true;
-                _this.__client.config.afterUncaught(uncaughtError);
-                if (!_this.hasOtherUncaughtExceptionListeners()) {
-                    (0, util_1$2.fatallyLogAndExit)(uncaughtError);
-                }
-            }
-        });
+        var allListeners = process.listeners('uncaughtException');
+        var otherListeners = allListeners.filter(function (listener) { return (listener.name !== 'domainUncaughtExceptionClear'
+            && listener !== _this.__listener); });
+        return otherListeners.length > 0;
     };
     return UncaughtExceptionMonitor;
 }());
 uncaught_exception_monitor.default = UncaughtExceptionMonitor;
 
-var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+var __importDefault$3 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(uncaught_exception_plugin, "__esModule", { value: true });
-var uncaught_exception_monitor_1 = __importDefault$2(uncaught_exception_monitor);
+var uncaught_exception_monitor_1 = __importDefault$3(uncaught_exception_monitor);
+var uncaughtExceptionMonitor = new uncaught_exception_monitor_1.default();
 function default_1$1() {
     return {
         load: function (client) {
-            if (!client.config.enableUncaught) {
-                return;
+            uncaughtExceptionMonitor.setClient(client);
+            if (client.config.enableUncaught) {
+                uncaughtExceptionMonitor.maybeAddListener();
+            }
+            else {
+                uncaughtExceptionMonitor.maybeRemoveListener();
             }
-            var uncaughtExceptionMonitor = new uncaught_exception_monitor_1.default(client);
-            process.on('uncaughtException', function honeybadgerUncaughtExceptionListener(uncaughtError) {
-                uncaughtExceptionMonitor.handleUncaughtException(uncaughtError);
-            });
         }
     };
 }
 uncaught_exception_plugin.default = default_1$1;
 
-var unhandled_rejection = {};
+var unhandled_rejection_plugin = {};
+
+var unhandled_rejection_monitor = {};
 
-Object.defineProperty(unhandled_rejection, "__esModule", { value: true });
+Object.defineProperty(unhandled_rejection_monitor, "__esModule", { value: true });
 var util_1$1 = util;
-var isReporting = false;
-/**
- * If there are no other unhandledRejection listeners,
- * we want to report the exception to Honeybadger and
- * mimic the default behavior of NodeJs,
- * which is to exit the process with code 1
- */
-function hasOtherUnhandledRejectionListeners() {
-    return process.listeners('unhandledRejection').length > 1;
-}
-function default_1() {
-    return {
-        load: function (client) {
-            if (!client.config.enableUnhandledRejection) {
+var UnhandledRejectionMonitor = /** @class */ (function () {
+    function UnhandledRejectionMonitor() {
+        this.__isReporting = false;
+        this.__listener = this.makeListener();
+    }
+    UnhandledRejectionMonitor.prototype.setClient = function (client) {
+        this.__client = client;
+    };
+    UnhandledRejectionMonitor.prototype.makeListener = function () {
+        var _this = this;
+        var honeybadgerUnhandledRejectionListener = function (reason, _promise) {
+            if (!_this.__client || !_this.__client.config.enableUnhandledRejection) {
+                if (!_this.hasOtherUnhandledRejectionListeners() && !_this.__isReporting) {
+                    (0, util_1$1.fatallyLogAndExit)(reason);
+                }
                 return;
             }
-            process.on('unhandledRejection', function honeybadgerUnhandledRejectionListener(reason, _promise) {
-                if (!client.config.enableUnhandledRejection) {
-                    if (!hasOtherUnhandledRejectionListeners() && !isReporting) {
+            _this.__isReporting = true;
+            _this.__client.notify(reason, { component: 'unhandledRejection' }, {
+                afterNotify: function () {
+                    _this.__isReporting = false;
+                    if (!_this.hasOtherUnhandledRejectionListeners()) {
                         (0, util_1$1.fatallyLogAndExit)(reason);
                     }
-                    return;
                 }
-                isReporting = true;
-                client.notify(reason, { component: 'unhandledRejection' }, {
-                    afterNotify: function () {
-                        isReporting = false;
-                        if (!hasOtherUnhandledRejectionListeners()) {
-                            (0, util_1$1.fatallyLogAndExit)(reason);
-                        }
-                    }
-                });
             });
+        };
+        return honeybadgerUnhandledRejectionListener;
+    };
+    UnhandledRejectionMonitor.prototype.maybeAddListener = function () {
+        var listeners = process.listeners('unhandledRejection');
+        if (!listeners.includes(this.__listener)) {
+            process.on('unhandledRejection', this.__listener);
+        }
+    };
+    UnhandledRejectionMonitor.prototype.maybeRemoveListener = function () {
+        var listeners = process.listeners('unhandledRejection');
+        if (listeners.includes(this.__listener)) {
+            process.removeListener('unhandledRejection', this.__listener);
+        }
+    };
+    /**
+     * If there are no other unhandledRejection listeners,
+     * we want to report the exception to Honeybadger and
+     * mimic the default behavior of NodeJs,
+     * which is to exit the process with code 1
+     */
+    UnhandledRejectionMonitor.prototype.hasOtherUnhandledRejectionListeners = function () {
+        var _this = this;
+        var otherListeners = process.listeners('unhandledRejection')
+            .filter(function (listener) { return listener !== _this.__listener; });
+        return otherListeners.length > 0;
+    };
+    return UnhandledRejectionMonitor;
+}());
+unhandled_rejection_monitor.default = UnhandledRejectionMonitor;
+
+var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(unhandled_rejection_plugin, "__esModule", { value: true });
+var unhandled_rejection_monitor_1 = __importDefault$2(unhandled_rejection_monitor);
+var unhandledRejectionMonitor = new unhandled_rejection_monitor_1.default();
+function default_1() {
+    return {
+        load: function (client) {
+            unhandledRejectionMonitor.setClient(client);
+            if (client.config.enableUnhandledRejection) {
+                unhandledRejectionMonitor.maybeAddListener();
+            }
+            else {
+                unhandledRejectionMonitor.maybeRemoveListener();
+            }
         }
     };
 }
-unhandled_rejection.default = default_1;
+unhandled_rejection_plugin.default = default_1;
 
 var middleware = {};
 
@@ -1906,7 +1972,7 @@ stacked_store.StackedStore = StackedStore;
 	var core_1 = src;
 	var util_1 = util;
 	var uncaught_exception_plugin_1 = __importDefault(uncaught_exception_plugin);
-	var unhandled_rejection_1 = __importDefault(unhandled_rejection);
+	var unhandled_rejection_plugin_1 = __importDefault(unhandled_rejection_plugin);
 	var middleware_1 = middleware;
 	var aws_lambda_1 = aws_lambda;
 	var transport_1 = transport;
@@ -2008,13 +2074,13 @@ stacked_store.StackedStore = StackedStore;
 	var singleton = new Honeybadger({
 	    __plugins: [
 	        (0, uncaught_exception_plugin_1.default)(),
-	        (0, unhandled_rejection_1.default)()
+	        (0, unhandled_rejection_plugin_1.default)()
 	    ],
 	});
 	var NOTIFIER = {
 	    name: '@honeybadger-io/js',
 	    url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/js',
-	    version: '6.4.1'
+	    version: '6.4.3'
 	};
 	singleton.setNotifier(NOTIFIER);
 	var core_2 = src;