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

package/dist/server/honeybadger.js

@@ -4,8 +4,8 @@ var https = require('https');
 var http = require('http');
 var url = require('url');
 var os = require('os');
-var fs = require('fs');
 var domain = require('domain');
+var fs = require('fs');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -13,8 +13,8 @@ var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
 var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
 var url__default = /*#__PURE__*/_interopDefaultLegacy(url);
 var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var domain__default = /*#__PURE__*/_interopDefaultLegacy(domain);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -221,7 +221,8 @@ function objectIsEmpty(obj) {
 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,
@@ -237,24 +238,46 @@ function makeBacktrace(stack, shift) {
         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 {};
     }
@@ -281,8 +304,14 @@ function sanitize(obj, maxDepth) {
         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) {
@@ -331,7 +360,7 @@ function sanitize(obj, maxDepth) {
             return serialize(obj, depth);
         }
         catch (e) {
-            return "[ERROR] " + e;
+            return "[ERROR] ".concat(e);
         }
     }
     return safeSerialize(obj);
@@ -344,8 +373,13 @@ function logger(client) {
             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);
@@ -368,12 +402,12 @@ function makeNotice(thing) {
     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);
@@ -384,7 +418,7 @@ function makeNotice(thing) {
 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 {
@@ -443,7 +477,9 @@ function filter(obj, filters) {
             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]';
@@ -479,7 +515,7 @@ function filterUrl(url, filters) {
     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;
@@ -493,34 +529,64 @@ function formatCGIData(vars, prefix) {
     });
     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$1 = /** @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$1({ context: {}, breadcrumbs: [] });
         this.logger = logger(this);
     }
     Client.prototype.factory = function (_opts) {
@@ -541,6 +607,10 @@ var Client = /** @class */ (function () {
         }
         return this;
     };
+    /** @internal */
+    Client.prototype.__setStore = function (store) {
+        this.__store = store;
+    };
     Client.prototype.beforeNotify = function (handler) {
         this.__beforeNotifyHandlers.push(handler);
         return this;
@@ -551,41 +621,129 @@ var Client = /** @class */ (function () {
     };
     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 };
@@ -597,17 +755,18 @@ var Client = /** @class */ (function () {
             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,
@@ -621,52 +780,40 @@ var Client = /** @class */ (function () {
             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);
@@ -702,14 +849,22 @@ var Client = /** @class */ (function () {
             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;
 }());
@@ -720,7 +875,7 @@ function fatallyLogAndExit(err) {
     process.exit(1);
 }
 function getStats(cb) {
-    var load = os__default['default'].loadavg(), stats = {
+    var load = os__default["default"].loadavg(), stats = {
         load: {
             one: load[0],
             five: load[1],
@@ -728,8 +883,8 @@ function getStats(cb) {
         },
         mem: {}
     };
-    if (fs__default['default'].existsSync('/proc/meminfo')) {
-        return fs__default['default'].readFile('/proc/meminfo', 'utf8', parseStats);
+    if (fs__default["default"].existsSync('/proc/meminfo')) {
+        return fs__default["default"].readFile('/proc/meminfo', 'utf8', parseStats);
     }
     fallback();
     function parseStats(err, memData) {
@@ -752,21 +907,125 @@ function getStats(cb) {
     }
     function fallback() {
         stats.mem = {
-            free: os__default['default'].freemem(),
-            total: os__default['default'].totalmem()
+            free: os__default["default"].freemem(),
+            total: os__default["default"].totalmem()
         };
         return cb(stats);
     }
 }
+/**
+ * Get source file if possible, used to build `notice.backtrace.source`
+ *
+ * @param path to source code
+ * @param cb callback with fileContent
+ */
+function getSourceFile(path, cb) {
+    fs__default["default"].readFile(path, 'utf-8', function (err, data) {
+        cb(err ? null : data);
+    });
+}
+
+var Store;
+try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    var AsyncLocalStorage = require('async_hooks').AsyncLocalStorage;
+    Store = new AsyncLocalStorage();
+}
+catch (e) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    var GlobalStore = require('../core/store').GlobalStore;
+    Store = new GlobalStore();
+}
+var AsyncStore = Store;
+
+function isHandlerSync(handler) {
+    return handler.length > 2;
+}
+function reportToHoneybadger(hb, err, callback) {
+    hb.notify(err, {
+        afterNotify: function () {
+            hb.clear();
+            callback(err);
+        }
+    });
+}
+function asyncHandler(handler, hb) {
+    return function wrappedLambdaHandler(event, context) {
+        hb.__setStore(AsyncStore);
+        return new Promise(function (resolve, reject) {
+            AsyncStore.run({ context: {}, breadcrumbs: [] }, function () {
+                try {
+                    handler(event, context)
+                        .then(resolve)
+                        .catch(function (err) { return reportToHoneybadger(hb, err, reject); });
+                }
+                catch (err) {
+                    reportToHoneybadger(hb, err, reject);
+                }
+            });
+        });
+    };
+}
+function syncHandler(handler, hb) {
+    return function wrappedLambdaHandler(event, context, cb) {
+        hb.__setStore(AsyncStore);
+        AsyncStore.run({ context: {}, breadcrumbs: [] }, function () {
+            try {
+                handler(event, context, function (error, result) {
+                    if (error) {
+                        return reportToHoneybadger(hb, error, cb);
+                    }
+                    cb(null, result);
+                });
+            }
+            catch (err) {
+                reportToHoneybadger(hb, err, cb);
+            }
+        });
+    };
+}
+function lambdaHandler(handler) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    var hb = this;
+    if (isHandlerSync(handler)) {
+        return syncHandler(handler, hb);
+    }
+    return asyncHandler(handler, hb);
+}
+var listenerRemoved = false;
+/**
+ * Removes AWS Lambda default listener that
+ * exits the process before letting us report to honeybadger.
+ */
+function removeAwsDefaultUncaughtExceptionListener() {
+    if (listenerRemoved) {
+        return;
+    }
+    listenerRemoved = true;
+    var listeners = process.listeners('uncaughtException');
+    if (listeners.length === 0) {
+        return;
+    }
+    // We assume it's the first listener
+    process.removeListener('uncaughtException', listeners[0]);
+}
 
 var count = 0;
+function removeAwsLambdaListener() {
+    var isLambda = !!process.env.LAMBDA_TASK_ROOT;
+    if (!isLambda) {
+        return;
+    }
+    removeAwsDefaultUncaughtExceptionListener();
+}
 function uncaughtException () {
     return {
         load: function (client) {
             if (!client.config.enableUncaught) {
                 return;
             }
-            process.on('uncaughtException', function (uncaughtError) {
+            removeAwsLambdaListener();
+            process.on('uncaughtException', function honeybadgerUncaughtExceptionListener(uncaughtError) {
                 // Prevent recursive errors
                 if (count > 1) {
                     fatallyLogAndExit(uncaughtError);
@@ -810,7 +1069,7 @@ function fullUrl(req) {
     // @ts-ignore The old @types/node incorrectly defines `address` as string|Address
     var port = address ? address.port : undefined;
     // @ts-ignore
-    return url__default['default'].format({
+    return url__default["default"].format({
         protocol: req.protocol,
         hostname: req.hostname,
         port: port,
@@ -819,10 +1078,7 @@ function fullUrl(req) {
     });
 }
 function requestHandler(req, res, next) {
-    this.clear();
-    var dom = domain__default['default'].create();
-    dom.on('error', next);
-    dom.run(next);
+    this.run(next, next);
 }
 function errorHandler(err, req, _res, next) {
     this.notify(err, {
@@ -837,50 +1093,12 @@ function errorHandler(err, req, _res, next) {
     });
     return next(err);
 }
-function lambdaHandler(handler) {
-    return function lambdaHandler(event, context, callback) {
-        // in the case of an async handler, the length of the handler will be less than 3 (no callback function).
-        // if this is the case, we have to explicitly call the callback function from the function we are returning.
-        // we don't have to do that if the handler has third callback function parameter,
-        // because it will be called directly from inside the handler.
-        var shouldInvokeCallbackExplicitly = handler.length < 3;
-        // eslint-disable-next-line prefer-rest-params
-        var args = arguments;
-        var dom = domain__default['default'].create();
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        var hb = this;
-        var hbHandler = function (err) {
-            var willNotify = hb.notify(err, {
-                afterNotify: function () {
-                    hb.clear();
-                    callback(err);
-                }
-            });
-            if (!willNotify) {
-                callback(err);
-            }
-        };
-        dom.on('error', hbHandler);
-        dom.run(function () {
-            process.nextTick(function () {
-                Promise.resolve(handler.apply(this, args))
-                    .then(function (res) {
-                    hb.clear();
-                    if (shouldInvokeCallbackExplicitly) {
-                        callback(null, res);
-                    }
-                })
-                    .catch(hbHandler);
-            });
-        });
-    }.bind(this);
-}
 
 var Honeybadger = /** @class */ (function (_super) {
     __extends(Honeybadger, _super);
     function Honeybadger(opts) {
         if (opts === void 0) { opts = {}; }
-        var _this = _super.call(this, __assign({ afterUncaught: fatallyLogAndExit, projectRoot: process.cwd(), hostname: os__default['default'].hostname() }, opts)) || this;
+        var _this = _super.call(this, __assign({ afterUncaught: fatallyLogAndExit, projectRoot: process.cwd(), hostname: os__default["default"].hostname() }, opts)) || this;
         /** @internal */
         _this.__beforeNotifyHandlers = [
             function (notice) {
@@ -893,6 +1111,7 @@ var Honeybadger = /** @class */ (function (_super) {
                 });
             }
         ];
+        _this.__getSourceFileHandler = getSourceFile.bind(_this);
         _this.errorHandler = errorHandler.bind(_this);
         _this.requestHandler = requestHandler.bind(_this);
         _this.lambdaHandler = lambdaHandler.bind(_this);
@@ -905,13 +1124,9 @@ var Honeybadger = /** @class */ (function (_super) {
     Honeybadger.prototype.__send = function (notice) {
         var _this = this;
         var protocol = new url.URL(this.config.endpoint).protocol;
-        var transport = (protocol === "http:" ? http__default['default'] : https__default['default']);
+        var transport = (protocol === "http:" ? http__default["default"] : https__default["default"]);
         var payload = this.__buildPayload(notice);
         payload.server.pid = process.pid;
-        var handlers = Array.prototype.slice.call(this.__afterNotifyHandlers);
-        if (notice.afterNotify) {
-            handlers.unshift(notice.afterNotify);
-        }
         getStats(function (stats) {
             payload.server.stats = stats;
             var data = Buffer.from(JSON.stringify(sanitize(payload, _this.config.maxObjectDepth)), 'utf8');
@@ -924,32 +1139,50 @@ var Honeybadger = /** @class */ (function (_super) {
                 }
             };
             var req = transport.request(endpoint(_this.config, '/v1/notices/js'), options, function (res) {
-                _this.logger.debug("statusCode: " + res.statusCode);
+                _this.logger.debug("statusCode: ".concat(res.statusCode));
                 var body = '';
                 res.on('data', function (chunk) {
                     body += chunk;
                 });
                 res.on('end', function () {
                     if (res.statusCode !== 201) {
-                        runAfterNotifyHandlers(notice, handlers, new Error("Bad HTTP response: " + res.statusCode));
-                        _this.logger.warn("Error report failed: unknown response from server. code=" + res.statusCode);
+                        runAfterNotifyHandlers(notice, _this.__afterNotifyHandlers, new Error("Bad HTTP response: ".concat(res.statusCode)));
+                        _this.logger.warn("Error report failed: unknown response from server. code=".concat(res.statusCode));
                         return;
                     }
                     var uuid = JSON.parse(body).id;
                     runAfterNotifyHandlers(merge(notice, {
                         id: uuid
-                    }), handlers);
-                    _this.logger.info('Error report sent.', "id=" + uuid);
+                    }), _this.__afterNotifyHandlers);
+                    _this.logger.info("Error report sent \u26A1 https://app.honeybadger.io/notice/".concat(uuid));
                 });
             });
             req.on('error', function (err) {
-                _this.logger.error('Error report failed: an unknown error occurred.', "message=" + err.message);
-                runAfterNotifyHandlers(notice, handlers, err);
+                _this.logger.error('Error report failed: an unknown error occurred.', "message=".concat(err.message));
+                runAfterNotifyHandlers(notice, _this.__afterNotifyHandlers, err);
             });
             req.write(data);
             req.end();
         });
-        return true;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Honeybadger.prototype.run = function (handler, onError) {
+        var _this = this;
+        var storeObject = this.__getStoreOrDefaultObject();
+        this.__setStore(AsyncStore);
+        if (onError) {
+            // ALS is fine for context-tracking, but `domain` allows us to catch errors
+            // thrown asynchronously (timers, event emitters)
+            // We can't use unhandledRejection/uncaughtException listeners; they're global and shared across all requests
+            // But the `onError` handler might be request-specific.
+            // Note that this doesn't still handle all cases. `domain` has its own problems:
+            // See https://github.com/honeybadger-io/honeybadger-js/pull/711
+            var dom = domain__default["default"].create();
+            var onErrorWithContext = function (err) { return _this.__store.run(storeObject, function () { return onError(err); }); };
+            dom.on('error', onErrorWithContext);
+            handler = dom.bind(handler);
+        }
+        return this.__store.run(storeObject, handler);
     };
     return Honeybadger;
 }(Client));
@@ -957,7 +1190,7 @@ var server = new Honeybadger({
     __plugins: [
         uncaughtException(),
         unhandledRejection()
-    ]
+    ],
 });
 
 module.exports = server;