@honeybadger-io/js 4.0.0-beta.0 → 4.0.0-beta.3

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.
@@ -56,45 +56,7 @@ var __assign = function() {
         return t;
     };
     return __assign.apply(this, arguments);
-};
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
+};
 
 var UNKNOWN_FUNCTION = '<unknown>';
 /**
@@ -307,7 +269,7 @@ function runBeforeNotifyHandlers(notice, handlers) {
 }
 function runAfterNotifyHandlers(notice, handlers, error) {
     if (notice && notice.afterNotify) {
-        handlers.unshift(notice.afterNotify);
+        notice.afterNotify(error, notice);
     }
     for (var i = 0, len = handlers.length; i < len; i++) {
         handlers[i](error, notice);
@@ -315,7 +277,7 @@ function runAfterNotifyHandlers(notice, handlers, error) {
     return true;
 }
 // Returns a new object with properties from other object.
-function newObject(obj) {
+function shallowClone(obj) {
     if (typeof (obj) !== 'object' || obj === null) {
         return {};
     }
@@ -342,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) {
@@ -370,7 +338,7 @@ function sanitize(obj, maxDepth) {
         }
         // Serialize inside arrays
         if (Array.isArray(obj)) {
-            return obj.map(function (o) { return serialize(o, depth + 1); });
+            return obj.map(function (o) { return safeSerialize(o, depth + 1); });
         }
         // Serialize inside objects
         if (typeof (obj) === 'object') {
@@ -378,7 +346,7 @@ function sanitize(obj, maxDepth) {
             for (var k in obj) {
                 var v = obj[k];
                 if (Object.prototype.hasOwnProperty.call(obj, k) && (k != null) && (v != null)) {
-                    ret[k] = serialize(v, depth + 1);
+                    ret[k] = safeSerialize(v, depth + 1);
                 }
             }
             return ret;
@@ -386,7 +354,16 @@ function sanitize(obj, maxDepth) {
         // Return everything else untouched
         return obj;
     }
-    return serialize(obj);
+    function safeSerialize(obj, depth) {
+        if (depth === void 0) { depth = 0; }
+        try {
+            return serialize(obj, depth);
+        }
+        catch (e) {
+            return "[ERROR] ".concat(e);
+        }
+    }
+    return safeSerialize(obj);
 }
 function logger(client) {
     var log = function (method) {
@@ -425,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);
@@ -572,33 +549,44 @@ function getSourceCodeSnippet(fileData, lineNumber, sourceRadius) {
     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: '4.0.0-beta.0'
+    version: '4.0.0-beta.3'
 };
-// 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'], 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) {
@@ -619,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;
@@ -629,23 +621,26 @@ 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 (noticeable, name, extra) {
@@ -687,10 +682,11 @@ var Client = /** @class */ (function () {
                 stack: notice.stack
             }
         });
-        notice.__breadcrumbs = this.config.breadcrumbsEnabled ? this.__breadcrumbs.slice() : [];
+        var breadcrumbs = this.__getStoreContentsOrDefault().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.slice() : null;
+        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;
@@ -761,15 +757,16 @@ var Client = /** @class */ (function () {
         if (objectIsEmpty(notice)) {
             return null;
         }
+        var context = this.__getStoreContentsOrDefault().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,
@@ -790,33 +787,33 @@ var Client = /** @class */ (function () {
             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.__developmentMode = function () {
         if (this.config.reportData === true) {
             return false;
         }
         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);
@@ -852,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 contents.
+     * @internal
+     */
+    Client.prototype.__getStoreContentsOrDefault = function () {
+        var existingStoreContents = this.__store.getStore();
+        var storeContents = existingStoreContents || {};
+        return __assign({ context: {}, breadcrumbs: [] }, storeContents);
     };
     return Client;
 }());
@@ -920,55 +925,63 @@ function getSourceFile(path, cb) {
     });
 }
 
+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 asyncHandler(handler, hb) {
-    var _this = this;
-    return function (event, context) { return __awaiter(_this, void 0, void 0, function () {
-        var err_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, handler(event, context)];
-                case 1: return [2 /*return*/, _a.sent()];
-                case 2:
-                    err_1 = _a.sent();
-                    return [2 /*return*/, new Promise(function (_, reject) {
-                            hb.notify(err_1, {
-                                afterNotify: function () {
-                                    hb.clear();
-                                    reject(err_1);
-                                }
-                            });
-                        })];
-                case 3: return [2 /*return*/];
-            }
-        });
-    }); };
+function reportToHoneybadger(hb, err, callback) {
+    hb.notify(err, {
+        afterNotify: function () {
+            hb.clear();
+            callback(err);
+        }
+    });
 }
-function syncHandler(handler, hb) {
-    return function (event, context, cb) {
-        var hbHandler = function (err) {
-            hb.notify(err, {
-                afterNotify: function () {
-                    hb.clear();
-                    cb(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); });
                 }
-            });
-        };
-        try {
-            handler(event, context, function (error, result) {
-                if (error) {
-                    return hbHandler(error);
+                catch (err) {
+                    reportToHoneybadger(hb, err, reject);
                 }
-                cb(null, result);
             });
-        }
-        catch (err) {
-            hbHandler(err);
-        }
+        });
+    };
+}
+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) {
@@ -1065,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.withRequest(req, next, next);
 }
 function errorHandler(err, req, _res, next) {
     this.notify(err, {
@@ -1081,9 +1091,12 @@ function errorHandler(err, req, _res, next) {
             REQUEST_METHOD: req.method
         }
     });
-    return next(err);
+    if (next) {
+        return next(err);
+    }
 }
 
+var kHoneybadgerStore = Symbol.for("kHoneybadgerStore");
 var Honeybadger = /** @class */ (function (_super) {
     __extends(Honeybadger, _super);
     function Honeybadger(opts) {
@@ -1144,7 +1157,7 @@ var Honeybadger = /** @class */ (function (_super) {
                     runAfterNotifyHandlers(merge(notice, {
                         id: uuid
                     }), _this.__afterNotifyHandlers);
-                    _this.logger.info('Error report sent.', "id=".concat(uuid));
+                    _this.logger.info("Error report sent \u26A1 https://app.honeybadger.io/notice/".concat(uuid));
                 });
             });
             req.on('error', function (err) {
@@ -1155,13 +1168,41 @@ var Honeybadger = /** @class */ (function (_super) {
             req.end();
         });
     };
+    // This method is intended for web frameworks.
+    // It allows us to track context for individual requests without leaking to other requests
+    // by doing two things:
+    // 1. Using AsyncLocalStorage so the context is tracked across async operations.
+    // 2. Attaching the store contents to the request object,
+    //   so, even if the store is destroyed, we can still recover the context for a given request
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Honeybadger.prototype.withRequest = function (request, handler, onError) {
+        var _this = this;
+        var storeObject = (request[kHoneybadgerStore] || this.__getStoreContentsOrDefault());
+        this.__setStore(AsyncStore);
+        if (!request[kHoneybadgerStore]) {
+            request[kHoneybadgerStore] = storeObject;
+        }
+        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));
 var server = new Honeybadger({
     __plugins: [
         uncaughtException(),
         unhandledRejection()
-    ]
+    ],
 });
 
 module.exports = server;

package/dist/server/types/core/client.d.ts

@@ -1,9 +1,17 @@
-import { Config, Logger, BeforeNotifyHandler, AfterNotifyHandler, Notice, Noticeable } from './types';
+import { Config, Logger, BeforeNotifyHandler, AfterNotifyHandler, Notice, Noticeable, HoneybadgerStore, BreadcrumbRecord } from './types';
 export default class Client {
+    private __pluginsExecuted;
+    protected __store: HoneybadgerStore<{
+        context: Record<string, unknown>;
+        breadcrumbs: BreadcrumbRecord[];
+    }>;
+    protected __beforeNotifyHandlers: BeforeNotifyHandler[];
+    protected __afterNotifyHandlers: AfterNotifyHandler[];
+    protected __getSourceFileHandler: (path: string, cb: (fileContent: string) => void) => void;
     config: Config;
     logger: Logger;
     constructor(opts?: Partial<Config>);
-    factory(_opts?: Record<string, unknown>): unknown;
+    factory(_opts?: Partial<Config>): Client;
     getVersion(): string;
     configure(opts?: Partial<Config>): Client;
     beforeNotify(handler: BeforeNotifyHandler): Client;
@@ -21,4 +29,8 @@ export default class Client {
     notifyAsync(noticeable: Noticeable, name?: string | Partial<Notice>, extra?: Partial<Notice>): Promise<void>;
     protected makeNotice(noticeable: Noticeable, name?: string | Partial<Notice>, extra?: Partial<Notice>): Notice | null;
     addBreadcrumb(message: string, opts?: Record<string, unknown>): Client;
+    protected __developmentMode(): boolean;
+    protected __send(_notice: Partial<Notice>): void;
+    protected __buildPayload(notice: Notice): Record<string, Record<string, unknown>>;
+    protected __constructTags(tags: unknown): Array<string>;
 }

package/dist/server/types/core/store.d.ts

@@ -0,0 +1,7 @@
+import { HoneybadgerStore } from "./types";
+export declare class GlobalStore<T> implements HoneybadgerStore<T> {
+    private store;
+    constructor(store: T);
+    getStore(): T;
+    run<R, TArgs extends never[]>(store: T, callback: (...args: TArgs) => R, ...args: TArgs): R;
+}

package/dist/server/types/core/types.d.ts

@@ -1,4 +1,6 @@
+/// <reference types="node" />
 import Client from './client';
+import { AsyncLocalStorage } from "async_hooks";
 export interface Logger {
     log(...args: unknown[]): unknown;
     info(...args: unknown[]): unknown;
@@ -88,3 +90,8 @@ export interface CGIData {
     HTTP_COOKIE: string | undefined;
     [x: string]: unknown;
 }
+export declare type HoneybadgerStore<T> = Pick<AsyncLocalStorage<T>, 'getStore' | 'run'>;
+export declare type DefaultStoreContents = {
+    context: Record<string, unknown>;
+    breadcrumbs: BreadcrumbRecord[];
+};

package/dist/server/types/core/util.d.ts

@@ -8,7 +8,7 @@ export declare function makeBacktrace(stack: string, shift?: number): BacktraceF
 export declare function getSourceForBacktrace(backtrace: BacktraceFrame[], getSourceFileHandler: (path: string, cb: (fileContent: string) => void) => void, cb: (sourcePerTrace: Record<string, string>[]) => void): void;
 export declare function runBeforeNotifyHandlers(notice: Notice | null, handlers: BeforeNotifyHandler[]): boolean;
 export declare function runAfterNotifyHandlers(notice: Notice | null, handlers: AfterNotifyHandler[], error?: Error): boolean;
-export declare function newObject<T>(obj: T): T | Record<string, unknown>;
+export declare function shallowClone<T>(obj: T): T | Record<string, unknown>;
 export declare function sanitize(obj: any, maxDepth?: number): any;
 export declare function logger(client: Client): Logger;
 /**

package/dist/server/types/server/async_store.d.ts

@@ -0,0 +1,5 @@
+import { BreadcrumbRecord, HoneybadgerStore } from "../core/types";
+export declare const AsyncStore: HoneybadgerStore<{
+    context: Record<string, unknown>;
+    breadcrumbs: BreadcrumbRecord[];
+}>;

package/dist/server/types/server.d.ts

@@ -8,6 +8,7 @@ declare class Honeybadger extends Client {
     lambdaHandler: typeof lambdaHandler;
     constructor(opts?: Partial<Config>);
     factory(opts?: Partial<Config>): Honeybadger;
+    withRequest<R>(request: Record<symbol, unknown>, handler: (...args: never[]) => R, onError?: (...args: any[]) => any): R | void;
 }
 declare const _default: Honeybadger;
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@honeybadger-io/js",
-  "version": "4.0.0-beta.0",
+  "version": "4.0.0-beta.3",
   "license": "MIT",
   "homepage": "https://github.com/honeybadger-io/honeybadger-js",
   "author": {
@@ -46,11 +46,12 @@
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^13.0.6",
-    "@rollup/plugin-replace": "^3.0.0",
+    "@rollup/plugin-replace": "^4.0.0",
     "@rollup/plugin-typescript": "^8.3.0",
     "@types/aws-lambda": "^8.10.89",
     "@types/express": "^4.17.13",
     "@types/jest": "^27.0.3",
+    "@types/node": "^12.20.46",
     "@typescript-eslint/eslint-plugin": "^5.6.0",
     "@typescript-eslint/parser": "^5.6.0",
     "axios": ">=0.24.0",
@@ -64,11 +65,11 @@
     "nock": "^13.2.1",
     "rollup": "^2.61.1",
     "rollup-plugin-uglify": "^6.0.2",
-    "shipjs": "0.24.2",
+    "shipjs": "0.24.3",
     "sinon": "^13.0.1",
     "supertest": "^6.1.6",
     "ts-jest": "^27.1.1",
-    "tsd": "^0.19.0",
+    "tsd": "^0.20.0",
     "tslib": "^2.3.1",
     "typescript": "^4.5.3"
   },

package/dist/browser/types/core/error.d.ts

@@ -1,3 +0,0 @@
-export default class NotifyError extends Error {
-    constructor(message: any);
-}

package/dist/server/types/core/error.d.ts

@@ -1,3 +0,0 @@
-export default class NotifyError extends Error {
-    constructor(message: any);
-}