@honeybadger-io/js 3.2.8 → 4.0.0-beta.2

package/dist/browser/honeybadger.js

@@ -2,7 +2,7 @@
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
     typeof define === 'function' && define.amd ? define(factory) :
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Honeybadger = factory());
-}(this, (function () { 'use strict';
+})(this, (function () { 'use strict';
 
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -215,7 +215,8 @@
     function makeBacktrace(stack, shift) {
         if (shift === void 0) { shift = 0; }
         try {
-            var backtrace = parse(stack).map(function (line) {
+            var backtrace = parse(stack)
+                .map(function (line) {
                 return {
                     file: line.file,
                     method: line.methodName,
@@ -231,24 +232,46 @@
             return [];
         }
     }
+    function getSourceForBacktrace(backtrace, getSourceFileHandler, cb) {
+        if (!getSourceFileHandler || !backtrace || !backtrace.length) {
+            cb([]);
+            return;
+        }
+        var result = [];
+        var getSourceFromFile = function (index) {
+            if (index === void 0) { index = 0; }
+            if (!backtrace.length) {
+                return cb(result);
+            }
+            var trace = backtrace.splice(0)[index];
+            getSourceFileHandler(trace.file, (function (fileContent) {
+                result[index] = getSourceCodeSnippet(fileContent, trace.number);
+                getSourceFromFile(index + 1);
+            }));
+        };
+        getSourceFromFile();
+    }
     function runBeforeNotifyHandlers(notice, handlers) {
+        var result = true;
         for (var i = 0, len = handlers.length; i < len; i++) {
             var handler = handlers[i];
             if (handler(notice) === false) {
-                return false;
+                result = false;
             }
         }
-        return true;
+        return result;
     }
     function runAfterNotifyHandlers(notice, handlers, error) {
-        if (error === void 0) { error = undefined; }
+        if (notice && notice.afterNotify) {
+            notice.afterNotify(error, notice);
+        }
         for (var i = 0, len = handlers.length; i < len; i++) {
             handlers[i](error, notice);
         }
         return true;
     }
     // Returns a new object with properties from other object.
-    function newObject(obj) {
+    function shallowClone(obj) {
         if (typeof (obj) !== 'object' || obj === null) {
             return {};
         }
@@ -275,8 +298,14 @@
             return false;
         }
         function canSerialize(obj) {
-            // Functions are TMI and Symbols can't convert to strings.
-            if (/function|symbol/.test(typeof (obj))) {
+            var typeOfObj = typeof obj;
+            // Functions are TMI
+            if (/function/.test(typeOfObj)) {
+                // Let special toJSON method pass as it's used by JSON.stringify (#722)
+                return obj.name === 'toJSON';
+            }
+            // Symbols can't convert to strings.
+            if (/symbol/.test(typeOfObj)) {
                 return false;
             }
             if (obj === null) {
@@ -325,7 +354,7 @@
                 return serialize(obj, depth);
             }
             catch (e) {
-                return "[ERROR] " + e;
+                return "[ERROR] ".concat(e);
             }
         }
         return safeSerialize(obj);
@@ -338,8 +367,13 @@
                 for (var _i = 0; _i < arguments.length; _i++) {
                     args[_i] = arguments[_i];
                 }
-                if (method === 'debug' && !client.config.debug) {
-                    return;
+                if (method === 'debug') {
+                    if (!client.config.debug) {
+                        return;
+                    }
+                    // Log at default level so that you don't need to also enable verbose
+                    // logging in Chrome.
+                    method = 'log';
                 }
                 args.unshift('[Honeybadger]');
                 (_a = client.config.logger)[method].apply(_a, args);
@@ -362,12 +396,12 @@
         if (!thing) {
             notice = {};
         }
-        else if (Object.prototype.toString.call(thing) === '[object Error]') {
+        else if (thing instanceof Error || Object.prototype.toString.call(thing) === '[object Error]') {
             var e = thing;
             notice = merge(thing, { name: e.name, message: e.message, stack: e.stack });
         }
         else if (typeof thing === 'object') {
-            notice = newObject(thing);
+            notice = shallowClone(thing);
         }
         else {
             var m = String(thing);
@@ -403,7 +437,7 @@
     function endpoint(config, path) {
         var endpoint = config.endpoint.trim().replace(/\/$/, '');
         path = path.trim().replace(/(^\/|\/$)/g, '');
-        return endpoint + "/" + path;
+        return "".concat(endpoint, "/").concat(path);
     }
     function generateStackTrace() {
         try {
@@ -462,7 +496,9 @@
                 return newObj;
             }
             if (is('Array', obj)) {
-                return obj.map(function (v) { return filter(v); });
+                return obj.map(function (v) {
+                    return filter(v);
+                });
             }
             if (is('Function', obj)) {
                 return '[FUNC]';
@@ -498,7 +534,7 @@
         query.split(/[&]\s?/).forEach(function (pair) {
             var _a = pair.split('=', 2), key = _a[0], value = _a[1];
             if (filterMatch(key, filters)) {
-                result = result.replace(key + "=" + value, key + "=[FILTERED]");
+                result = result.replace("".concat(key, "=").concat(value), "".concat(key, "=[FILTERED]"));
             }
         });
         return result;
@@ -512,34 +548,64 @@
         });
         return formattedVars;
     }
+    function getSourceCodeSnippet(fileData, lineNumber, sourceRadius) {
+        if (sourceRadius === void 0) { sourceRadius = 2; }
+        if (!fileData) {
+            return null;
+        }
+        var lines = fileData.split('\n');
+        // add one empty line because array index starts from 0, but error line number is counted from 1
+        lines.unshift('');
+        var start = lineNumber - sourceRadius;
+        var end = lineNumber + sourceRadius;
+        var result = {};
+        for (var i = start; i <= end; i++) {
+            var line = lines[i];
+            if (typeof line === 'string') {
+                result[i] = line;
+            }
+        }
+        return result;
+    }
+
+    var GlobalStore = /** @class */ (function () {
+        function GlobalStore(store) {
+            this.store = store;
+        }
+        GlobalStore.prototype.getStore = function () {
+            return this.store;
+        };
+        GlobalStore.prototype.run = function (store, callback) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            this.store = store;
+            return callback.apply(void 0, args);
+        };
+        return GlobalStore;
+    }());
 
     var notifier = {
         name: 'honeybadger-js',
         url: 'https://github.com/honeybadger-io/honeybadger-js',
-        version: '3.2.8'
+        version: '4.0.0-beta.2'
     };
-    // Split at commas
-    var TAG_SEPARATOR = /,/;
-    // Removes any non-word characters
-    var TAG_SANITIZER = /[^\w]/g;
-    // Checks for blank strings
-    var STRING_EMPTY = '';
+    // Split at commas and spaces
+    var TAG_SEPARATOR = /,|\s+/;
     // Checks for non-blank characters
     var NOT_BLANK = /\S/;
     var Client = /** @class */ (function () {
         function Client(opts) {
             if (opts === void 0) { opts = {}; }
-            /** @internal */
             this.__pluginsExecuted = false;
-            /** @internal */
-            this.__context = {};
-            /** @internal */
-            this.__breadcrumbs = [];
-            /** @internal */
+            this.__store = null;
             this.__beforeNotifyHandlers = [];
-            /** @internal */
             this.__afterNotifyHandlers = [];
-            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'], disabled: false, debug: false, tags: null, enableUncaught: true, enableUnhandledRejection: true, afterUncaught: function () { return true; }, filters: ['creditcard', 'password'], __plugins: [] }, opts);
+            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);
+            // First, we go with the global (shared) store.
+            // Webserver middleware can then switch to the AsyncStore for async context tracking.
+            this.__store = new GlobalStore({ context: {}, breadcrumbs: [] });
             this.logger = logger(this);
         }
         Client.prototype.factory = function (_opts) {
@@ -560,6 +626,10 @@
             }
             return this;
         };
+        /** @internal */
+        Client.prototype.__setStore = function (store) {
+            this.__store = store;
+        };
         Client.prototype.beforeNotify = function (handler) {
             this.__beforeNotifyHandlers.push(handler);
             return this;
@@ -570,41 +640,129 @@
         };
         Client.prototype.setContext = function (context) {
             if (typeof context === 'object') {
-                this.__context = merge(this.__context, context);
+                var store = this.__store.getStore();
+                store.context = merge(store.context, context);
             }
             return this;
         };
         Client.prototype.resetContext = function (context) {
             this.logger.warn('Deprecation warning: `Honeybadger.resetContext()` has been deprecated; please use `Honeybadger.clear()` instead.');
+            var store = this.__store.getStore();
             if (typeof context === 'object' && context !== null) {
-                this.__context = merge({}, context);
+                store.context = context;
             }
             else {
-                this.__context = {};
+                store.context = {};
             }
             return this;
         };
         Client.prototype.clear = function () {
-            this.__context = {};
-            this.__breadcrumbs = [];
+            var store = this.__store.getStore();
+            store.context = {};
+            store.breadcrumbs = [];
             return this;
         };
-        Client.prototype.notify = function (notice, name, extra) {
+        Client.prototype.notify = function (noticeable, name, extra) {
+            var _this = this;
             if (name === void 0) { name = undefined; }
             if (extra === void 0) { extra = undefined; }
-            if (this.config.disabled) {
-                this.logger.warn('Deprecation warning: instead of `disabled: true`, use `reportData: false` to explicitly disable Honeybadger reporting. (Dropping notice: honeybadger.js is disabled)');
-                return false;
+            var preConditionError = null;
+            var notice = this.makeNotice(noticeable, name, extra);
+            if (!notice) {
+                this.logger.debug('failed to build error report');
+                preConditionError = new Error('failed to build error report');
             }
-            if (!this.__reportData()) {
-                this.logger.debug('Dropping notice: honeybadger.js is in development mode');
-                return false;
+            if (!preConditionError && this.config.reportData === false) {
+                this.logger.debug('skipping error report: honeybadger.js is disabled', notice);
+                preConditionError = new Error('honeybadger.js is disabled');
             }
-            if (!this.config.apiKey) {
-                this.logger.warn('Unable to send error report: no API key has been configured');
+            if (!preConditionError && this.__developmentMode()) {
+                this.logger.log('honeybadger.js is in development mode; the following error report will be sent in production.', notice);
+                preConditionError = new Error('honeybadger.js is in development mode');
+            }
+            if (!preConditionError && !this.config.apiKey) {
+                this.logger.warn('could not send error report: no API key has been configured', notice);
+                preConditionError = new Error('missing API key');
+            }
+            var beforeNotifyResult = runBeforeNotifyHandlers(notice, this.__beforeNotifyHandlers);
+            if (!preConditionError && !beforeNotifyResult) {
+                this.logger.debug('skipping error report: beforeNotify handlers returned false', notice);
+                preConditionError = new Error('beforeNotify handlers returned false');
+            }
+            if (preConditionError) {
+                runAfterNotifyHandlers(notice, this.__afterNotifyHandlers, preConditionError);
                 return false;
             }
-            notice = makeNotice(notice);
+            this.addBreadcrumb('Honeybadger Notice', {
+                category: 'notice',
+                metadata: {
+                    message: notice.message,
+                    name: notice.name,
+                    stack: notice.stack
+                }
+            });
+            var breadcrumbs = this.__getStoreOrDefaultObject().breadcrumbs;
+            notice.__breadcrumbs = this.config.breadcrumbsEnabled ? breadcrumbs.slice() : [];
+            // we need to have the source file data before the beforeNotifyHandlers,
+            // in case they modify them
+            var sourceCodeData = notice && notice.backtrace ? notice.backtrace.map(function (trace) { return shallowClone(trace); }) : null;
+            getSourceForBacktrace(sourceCodeData, this.__getSourceFileHandler, function (sourcePerTrace) {
+                sourcePerTrace.forEach(function (source, index) {
+                    notice.backtrace[index].source = source;
+                });
+                _this.__send(notice);
+            });
+            return true;
+        };
+        /**
+         * An async version of {@link notify} that resolves only after the notice has been reported to Honeybadger.
+         * Implemented using the {@link afterNotify} hook.
+         * Rejects if for any reason the report failed to be reported.
+         * Useful in serverless environments (AWS Lambda).
+         */
+        Client.prototype.notifyAsync = function (noticeable, name, extra) {
+            var _this = this;
+            if (name === void 0) { name = undefined; }
+            if (extra === void 0) { extra = undefined; }
+            return new Promise(function (resolve, reject) {
+                var applyAfterNotify = function (partialNotice) {
+                    var originalAfterNotify = partialNotice.afterNotify;
+                    partialNotice.afterNotify = function (err) {
+                        originalAfterNotify === null || originalAfterNotify === void 0 ? void 0 : originalAfterNotify.call(_this, err);
+                        if (err) {
+                            return reject(err);
+                        }
+                        resolve();
+                    };
+                };
+                // We have to respect any afterNotify hooks that come from the arguments
+                var objectToOverride;
+                if (noticeable.afterNotify) {
+                    objectToOverride = noticeable;
+                }
+                else if (name && name.afterNotify) {
+                    objectToOverride = name;
+                }
+                else if (extra && extra.afterNotify) {
+                    objectToOverride = extra;
+                }
+                else if (name && typeof name === 'object') {
+                    objectToOverride = name;
+                }
+                else if (extra) {
+                    objectToOverride = extra;
+                }
+                else {
+                    objectToOverride = name = {};
+                }
+                applyAfterNotify(objectToOverride);
+                _this.notify(noticeable, name, extra);
+            });
+        };
+        Client.prototype.makeNotice = function (noticeable, name, extra) {
+            if (name === void 0) { name = undefined; }
+            if (extra === void 0) { extra = undefined; }
+            var notice = makeNotice(noticeable);
             if (name && !(typeof name === 'object')) {
                 var n = String(name);
                 name = { name: n };
@@ -616,17 +774,18 @@
                 notice = mergeNotice(notice, extra);
             }
             if (objectIsEmpty(notice)) {
-                return false;
+                return null;
             }
+            var context = this.__getStoreOrDefaultObject().context;
             var noticeTags = this.__constructTags(notice.tags);
-            var contextTags = this.__constructTags(this.__context["tags"]);
+            var contextTags = this.__constructTags(context["tags"]);
             var configTags = this.__constructTags(this.config.tags);
             // Turning into a Set will remove duplicates
             var tags = noticeTags.concat(contextTags).concat(configTags);
             var uniqueTags = tags.filter(function (item, index) { return tags.indexOf(item) === index; });
             notice = merge(notice, {
                 name: notice.name || 'Error',
-                context: merge(this.__context, notice.context),
+                context: merge(context, notice.context),
                 projectRoot: notice.projectRoot || this.config.projectRoot,
                 environment: notice.environment || this.config.environment,
                 component: notice.component || this.config.component,
@@ -640,52 +799,40 @@
                 backtraceShift = 2;
             }
             notice.backtrace = makeBacktrace(notice.stack, backtraceShift);
-            if (!runBeforeNotifyHandlers(notice, this.__beforeNotifyHandlers)) {
-                return false;
-            }
-            this.addBreadcrumb('Honeybadger Notice', {
-                category: 'notice',
-                metadata: {
-                    message: notice.message,
-                    name: notice.name,
-                    stack: notice.stack
-                }
-            });
-            notice.__breadcrumbs = this.config.breadcrumbsEnabled ? this.__breadcrumbs.slice() : [];
-            return this.__send(notice);
+            return notice;
         };
         Client.prototype.addBreadcrumb = function (message, opts) {
             if (!this.config.breadcrumbsEnabled) {
                 return;
             }
             opts = opts || {};
-            var metadata = newObject(opts.metadata);
+            var metadata = shallowClone(opts.metadata);
             var category = opts.category || 'custom';
             var timestamp = new Date().toISOString();
-            this.__breadcrumbs.push({
+            var store = this.__store.getStore();
+            var breadcrumbs = store.breadcrumbs;
+            breadcrumbs.push({
                 category: category,
                 message: message,
                 metadata: metadata,
                 timestamp: timestamp
             });
             var limit = this.config.maxBreadcrumbs;
-            if (this.__breadcrumbs.length > limit) {
-                this.__breadcrumbs = this.__breadcrumbs.slice(this.__breadcrumbs.length - limit);
+            if (breadcrumbs.length > limit) {
+                breadcrumbs = breadcrumbs.slice(breadcrumbs.length - limit);
             }
+            store.breadcrumbs = breadcrumbs;
             return this;
         };
-        /** @internal */
-        Client.prototype.__reportData = function () {
-            if (this.config.reportData !== null) {
-                return this.config.reportData;
+        Client.prototype.__developmentMode = function () {
+            if (this.config.reportData === true) {
+                return false;
             }
-            return !(this.config.environment && this.config.developmentEnvironments.includes(this.config.environment));
+            return (this.config.environment && this.config.developmentEnvironments.includes(this.config.environment));
         };
-        /** @internal */
         Client.prototype.__send = function (_notice) {
             throw (new Error('Must implement send in subclass'));
         };
-        /** @internal */
         Client.prototype.__buildPayload = function (notice) {
             var headers = filter(notice.headers, this.config.filters) || {};
             var cgiData = filter(__assign(__assign({}, notice.cgiData), formatCGIData(headers, 'HTTP_')), this.config.filters);
@@ -721,14 +868,22 @@
                 details: notice.details || {}
             };
         };
-        /** @internal */
         Client.prototype.__constructTags = function (tags) {
             if (!tags) {
                 return [];
             }
-            return tags.toString().split(TAG_SEPARATOR).map(function (tag) {
-                return tag.replace(TAG_SANITIZER, STRING_EMPTY);
-            }).filter(function (tag) { return NOT_BLANK.test(tag); });
+            return tags.toString().split(TAG_SEPARATOR).filter(function (tag) { return NOT_BLANK.test(tag); });
+        };
+        /**
+         * For ALS, the store may be uninitialized (if .run()` has not been called).
+         * This provides an easy way to read the existing store object or fall back to a default.
+         * Returns *a copy* of the store.
+         * @internal
+         */
+        Client.prototype.__getStoreOrDefaultObject = function () {
+            var existingStore = this.__store.getStore();
+            var store = existingStore || {};
+            return __assign({ context: {}, breadcrumbs: [] }, store);
         };
         return Client;
     }());
@@ -748,23 +903,23 @@
             return '';
         }
         if (element.id) {
-            name += "#" + element.id;
+            name += "#".concat(element.id);
         }
         var stringClassNames = element.getAttribute('class');
         if (stringClassNames) {
             stringClassNames.split(/\s+/).forEach(function (className) {
-                name += "." + className;
+                name += ".".concat(className);
             });
         }
         ['alt', 'name', 'title', 'type'].forEach(function (attrName) {
             var attr = element.getAttribute(attrName);
             if (attr) {
-                name += "[" + attrName + "=\"" + attr + "\"]";
+                name += "[".concat(attrName, "=\"").concat(attr, "\"]");
             }
         });
         var siblings = getSiblings(element);
         if (siblings.length > 1) {
-            name += ":nth-child(" + (Array.prototype.indexOf.call(siblings, element) + 1) + ")";
+            name += ":nth-child(".concat(Array.prototype.indexOf.call(siblings, element) + 1, ")");
         }
         return name;
     }
@@ -773,7 +928,7 @@
         if (element.parentNode && element.parentNode.tagName) {
             var parentName = stringSelectorOfElement(element.parentNode);
             if (parentName.length > 0) {
-                return parentName + " > " + name;
+                return "".concat(parentName, " > ").concat(name);
             }
         }
         return name;
@@ -833,7 +988,7 @@
             return parsed.pathname;
         }
         // x-domain
-        return parsed.protocol + "://" + parsed.host + parsed.pathname;
+        return "".concat(parsed.protocol, "://").concat(parsed.host).concat(parsed.pathname);
     }
     function decodeCookie(string) {
         var result = {};
@@ -921,12 +1076,12 @@
                             ignoreOnError -= 1;
                             return;
                         }
-                        if (!client.config.enableUncaught) {
-                            return;
-                        }
+                        // See https://developer.mozilla.org/en/docs/Web/API/GlobalEventHandlers/onerror#Notes
                         if (line === 0 && /Script error\.?/.test(msg)) {
-                            // See https://developer.mozilla.org/en/docs/Web/API/GlobalEventHandlers/onerror#Notes
-                            client.logger.info('Ignoring cross-domain script error: enable CORS to track these types of errors', arguments);
+                            if (client.config.enableUncaught) {
+                                // Log only if the user wants to report uncaught errors
+                                client.logger.warn('Ignoring cross-domain script error: enable CORS to track these types of errors', arguments);
+                            }
                             return;
                         }
                         var notice = makeNotice(err);
@@ -940,7 +1095,7 @@
                             // Simulate v8 stack
                             notice.stack = [notice.message, '\n    at ? (', url || 'unknown', ':', line || 0, ':', col || 0, ')'].join('');
                         }
-                        client.addBreadcrumb((notice.name === 'window.onerror' || !notice.name) ? 'window.onerror' : "window.onerror: " + notice.name, {
+                        client.addBreadcrumb((notice.name === 'window.onerror' || !notice.name) ? 'window.onerror' : "window.onerror: ".concat(notice.name), {
                             category: 'error',
                             metadata: {
                                 name: notice.name,
@@ -948,7 +1103,9 @@
                                 stack: notice.stack
                             }
                         });
-                        client.notify(notice);
+                        if (client.config.enableUncaught) {
+                            client.notify(notice);
+                        }
                     };
                     return function (msg, url, line, col, err) {
                         onerror(msg, url, line, col, err);
@@ -986,14 +1143,14 @@
                             // const lineNumber = reason.lineNumber || 0
                             var fileName = 'unknown';
                             var lineNumber = 0;
-                            var stackFallback = reason.message + "\n    at ? (" + fileName + ":" + lineNumber + ")";
+                            var stackFallback = "".concat(reason.message, "\n    at ? (").concat(fileName, ":").concat(lineNumber, ")");
                             var stack = reason.stack || stackFallback;
                             var err = {
                                 name: reason.name,
-                                message: "UnhandledPromiseRejectionWarning: " + reason,
+                                message: "UnhandledPromiseRejectionWarning: ".concat(reason),
                                 stack: stack
                             };
-                            client.addBreadcrumb("window.onunhandledrejection: " + err.name, {
+                            client.addBreadcrumb("window.onunhandledrejection: ".concat(err.name), {
                                 category: 'error',
                                 metadata: err
                             });
@@ -1003,7 +1160,7 @@
                         var message = typeof reason === 'string' ? reason : ((_a = JSON.stringify(reason)) !== null && _a !== void 0 ? _a : 'Unspecified reason');
                         client.notify({
                             name: 'window.onunhandledrejection',
-                            message: "UnhandledPromiseRejectionWarning: " + message
+                            message: "UnhandledPromiseRejectionWarning: ".concat(message)
                         });
                     }
                     return function (promiseRejectionEvent) {
@@ -1112,7 +1269,7 @@
                             var xhr = this;
                             var url = arguments[1];
                             var method = typeof arguments[0] === 'string' ? arguments[0].toUpperCase() : arguments[0];
-                            var message = method + " " + localURLPathname(url);
+                            var message = "".concat(method, " ").concat(localURLPathname(url));
                             this.__hb_xhr = {
                                 type: 'xhr',
                                 method: method,
@@ -1197,7 +1354,7 @@
                             if (typeof method === 'string') {
                                 method = method.toUpperCase();
                             }
-                            var message = method + " " + localURLPathname(url);
+                            var message = "".concat(method, " ").concat(localURLPathname(url));
                             var metadata = {
                                 type: 'fetch',
                                 method: method,
@@ -1310,7 +1467,7 @@
                     var prototype = _window[prop] && _window[prop].prototype;
                     if (prototype && Object.prototype.hasOwnProperty.call(prototype, 'addEventListener')) {
                         instrument(prototype, 'addEventListener', function (original) {
-                            var wrapOpts = { component: prop + ".prototype.addEventListener" };
+                            var wrapOpts = { component: "".concat(prop, ".prototype.addEventListener") };
                             // See https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener
                             return function (type, listener, useCapture, wantsUntrusted) {
                                 try {
@@ -1401,10 +1558,6 @@
             var _this = this;
             this.__incrementErrorsCount();
             var payload = this.__buildPayload(notice);
-            var handlers = Array.prototype.slice.call(this.__afterNotifyHandlers);
-            if (notice.afterNotify) {
-                handlers.unshift(notice.afterNotify);
-            }
             try {
                 var x_1 = new XMLHttpRequest();
                 x_1.open('POST', endpoint(this.config, '/v1/notices/js'), this.config.async);
@@ -1414,21 +1567,21 @@
                 x_1.send(JSON.stringify(sanitize(payload, this.config.maxObjectDepth)));
                 x_1.onload = function () {
                     if (x_1.status !== 201) {
-                        runAfterNotifyHandlers(notice, handlers, new Error("Bad HTTP response: " + x_1.status));
-                        _this.logger.debug("Unable to send error report: " + x_1.status + ": " + x_1.statusText, x_1, notice);
+                        runAfterNotifyHandlers(notice, _this.__afterNotifyHandlers, new Error("Bad HTTP response: ".concat(x_1.status)));
+                        _this.logger.debug("Unable to send error report: ".concat(x_1.status, ": ").concat(x_1.statusText), x_1, notice);
                         return;
                     }
+                    var uuid = JSON.parse(x_1.response).id;
                     runAfterNotifyHandlers(merge(notice, {
-                        id: JSON.parse(x_1.response).id
-                    }), handlers);
-                    _this.logger.debug('Error report sent', notice);
+                        id: uuid
+                    }), _this.__afterNotifyHandlers);
+                    _this.logger.debug("Error report sent \u26A1 https://app.honeybadger.io/notice/".concat(uuid));
                 };
             }
             catch (err) {
-                runAfterNotifyHandlers(notice, handlers, err);
+                runAfterNotifyHandlers(notice, this.__afterNotifyHandlers, err);
                 this.logger.error('Unable to send error report: error while initializing request', err, notice);
             }
-            return true;
         };
         /**
          * wrap always returns the same function so that callbacks can be removed via
@@ -1452,14 +1605,7 @@
                     // eslint-disable-next-line @typescript-eslint/no-this-alias
                     var client_1 = this;
                     func.___hb = function () {
-                        var onErrorEnabled = client_1.config.enableUncaught;
-                        // Catch if:
-                        //   1. We explicitly want to catch (i.e. if the error could be
-                        //      caught before reaching window.onerror)
-                        //   2. The browser provides less information via the window.onerror
-                        //      handler
-                        //   3. The window.onerror handler is unavailable
-                        if (opts.catch || preferCatch || !onErrorEnabled) {
+                        if (preferCatch) {
                             try {
                                 // eslint-disable-next-line prefer-rest-params
                                 return func.apply(this, arguments);
@@ -1470,7 +1616,7 @@
                                 }
                                 client_1.__lastWrapErr = err;
                                 ignoreNextOnError();
-                                client_1.addBreadcrumb(opts.component ? opts.component + ": " + err.name : err.name, {
+                                client_1.addBreadcrumb(opts.component ? "".concat(opts.component, ": ").concat(err.name) : err.name, {
                                     category: 'error',
                                     metadata: {
                                         message: err.message,
@@ -1478,7 +1624,9 @@
                                         stack: err.stack
                                     }
                                 });
-                                client_1.notify(err);
+                                if (client_1.config.enableUncaught) {
+                                    client_1.notify(err);
+                                }
                                 throw (err);
                             }
                         }
@@ -1517,5 +1665,5 @@
 
     return browser;
 
-})));
+}));
 //# sourceMappingURL=honeybadger.js.map