@honeybadger-io/js 4.3.0 → 4.6.0

package/dist/server/async_store.d.ts

@@ -1,6 +1,26 @@
+/// <reference types="node" />
 import { Types } from '@honeybadger-io/core';
-export declare const AsyncStore: Types.HoneybadgerStore<{
-    context: Record<string, unknown>;
-    breadcrumbs: Types.BreadcrumbRecord[];
-}>;
+import { AsyncLocalStorage } from 'async_hooks';
+export declare class AsyncStore implements Types.HoneybadgerStore {
+    private als;
+    private readonly contents;
+    private readonly breadcrumbsLimit;
+    constructor(asyncLocalStorage: AsyncLocalStorage<Types.StoreContents>, contents: Types.StoreContents, breadcrumbsLimit: number);
+    /**
+     * Attempt to create a new AsyncStore instance
+     */
+    static create(contents: Types.StoreContents, breadcrumbsLimit: number): AsyncStore | null;
+    /**
+     * This returns the live store object, so we can mutate it.
+     * If we're in an async context (a `run()` callback), the stored contents at this point will be returned.
+     * Otherwise, the initial stored contents will be returned.
+     */
+    __currentContents(): Types.StoreContents;
+    getContents(key?: keyof Types.StoreContents): any;
+    available(): boolean;
+    setContext(context: Record<string, unknown>): void;
+    addBreadcrumb(breadcrumb: any): void;
+    clear(): void;
+    run<R>(callback: () => R, request?: Record<symbol, unknown>): R;
+}
 //# sourceMappingURL=async_store.d.ts.map

package/dist/server/honeybadger.d.ts

@@ -9,8 +9,10 @@ declare class Honeybadger extends Client {
     constructor(opts?: Partial<Types.Config | Types.ServerlessConfig>);
     factory(opts?: Partial<Types.Config | Types.ServerlessConfig>): this;
     configure(opts?: Partial<Types.Config | Types.ServerlessConfig>): this;
+    protected __initStore(): void;
     checkIn(id: string): Promise<void>;
     withRequest<R>(request: Record<symbol, unknown>, handler: (...args: never[]) => R, onError?: (...args: unknown[]) => unknown): R | void;
+    run<R>(callback: (...args: never[]) => R): R;
 }
 export { Types } from '@honeybadger-io/core';
 declare const _default: Honeybadger;

package/dist/server/honeybadger.js

@@ -703,20 +703,37 @@ var store = {};
 
 Object.defineProperty(store, "__esModule", { value: true });
 store.GlobalStore = void 0;
+var util_1$4 = util$1;
 var GlobalStore = /** @class */ (function () {
-    function GlobalStore(store) {
-        this.store = store;
+    function GlobalStore(contents, breadcrumbsLimit) {
+        this.contents = contents;
+        this.breadcrumbsLimit = breadcrumbsLimit;
     }
-    GlobalStore.prototype.getStore = function () {
-        return this.store;
+    GlobalStore.create = function (contents, breadcrumbsLimit) {
+        return new GlobalStore(contents, breadcrumbsLimit);
     };
-    GlobalStore.prototype.run = function (store, callback) {
-        var args = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            args[_i - 2] = arguments[_i];
+    GlobalStore.prototype.available = function () {
+        return true;
+    };
+    GlobalStore.prototype.getContents = function (key) {
+        var value = key ? this.contents[key] : this.contents;
+        return JSON.parse(JSON.stringify(value));
+    };
+    GlobalStore.prototype.setContext = function (context) {
+        this.contents.context = (0, util_1$4.merge)(this.contents.context, context || {});
+    };
+    GlobalStore.prototype.addBreadcrumb = function (breadcrumb) {
+        if (this.contents.breadcrumbs.length == this.breadcrumbsLimit) {
+            this.contents.breadcrumbs.shift();
         }
-        this.store = store;
-        return callback.apply(void 0, args);
+        this.contents.breadcrumbs.push(breadcrumb);
+    };
+    GlobalStore.prototype.clear = function () {
+        this.contents.context = {};
+        this.contents.breadcrumbs = [];
+    };
+    GlobalStore.prototype.run = function (callback) {
+        return callback();
     };
     return GlobalStore;
 }());
@@ -740,7 +757,7 @@ var store_1 = store;
 var notifier = {
     name: 'honeybadger-js',
     url: 'https://github.com/honeybadger-io/honeybadger-js',
-    version: '4.3.0'
+    version: '4.6.0'
 };
 // Split at commas and spaces
 var TAG_SEPARATOR = /,|\s+/;
@@ -754,9 +771,7 @@ var Client = /** @class */ (function () {
         this.__beforeNotifyHandlers = [];
         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 store_1.GlobalStore({ context: {}, breadcrumbs: [] });
+        this.__initStore();
         this.__transport = transport;
         this.logger = (0, util_1$3.logger)(this);
     }
@@ -775,8 +790,8 @@ var Client = /** @class */ (function () {
         }
         return this;
     };
-    Client.prototype.__setStore = function (store) {
-        this.__store = store;
+    Client.prototype.__initStore = function () {
+        this.__store = new store_1.GlobalStore({ context: {}, breadcrumbs: [] }, this.config.maxBreadcrumbs);
     };
     Client.prototype.beforeNotify = function (handler) {
         this.__beforeNotifyHandlers.push(handler);
@@ -787,27 +802,21 @@ var Client = /** @class */ (function () {
         return this;
     };
     Client.prototype.setContext = function (context) {
-        if (typeof context === 'object') {
-            var store = this.__store.getStore();
-            store.context = (0, util_1$3.merge)(store.context, context);
+        if (typeof context === 'object' && context != null) {
+            this.__store.setContext(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();
+        this.__store.clear();
         if (typeof context === 'object' && context !== null) {
-            store.context = context;
-        }
-        else {
-            store.context = {};
+            this.__store.setContext(context);
         }
         return this;
     };
     Client.prototype.clear = function () {
-        var store = this.__store.getStore();
-        store.context = {};
-        store.breadcrumbs = [];
+        this.__store.clear();
         return this;
     };
     Client.prototype.notify = function (noticeable, name, extra) {
@@ -852,8 +861,8 @@ var Client = /** @class */ (function () {
                 stack: notice.stack
             }
         });
-        var breadcrumbs = this.__getStoreContentsOrDefault().breadcrumbs;
-        notice.__breadcrumbs = this.config.breadcrumbsEnabled ? breadcrumbs.slice() : [];
+        var breadcrumbs = this.__store.getContents('breadcrumbs');
+        notice.__breadcrumbs = this.config.breadcrumbsEnabled ? breadcrumbs : [];
         (0, util_1$3.getSourceForBacktrace)(sourceCodeData, this.__getSourceFileHandler)
             .then(function (sourcePerTrace) {
             sourcePerTrace.forEach(function (source, index) {
@@ -954,7 +963,7 @@ var Client = /** @class */ (function () {
         if ((0, util_1$3.objectIsEmpty)(notice)) {
             return null;
         }
-        var context = this.__getStoreContentsOrDefault().context;
+        var context = this.__store.getContents('context');
         var noticeTags = this.__constructTags(notice.tags);
         var contextTags = this.__constructTags(context['tags']);
         var configTags = this.__constructTags(this.config.tags);
@@ -987,21 +996,20 @@ var Client = /** @class */ (function () {
         var metadata = (0, util_1$3.shallowClone)(opts.metadata);
         var category = opts.category || 'custom';
         var timestamp = new Date().toISOString();
-        var store = this.__store.getStore();
-        var breadcrumbs = store.breadcrumbs;
-        breadcrumbs.push({
+        this.__store.addBreadcrumb({
             category: category,
             message: message,
             metadata: metadata,
             timestamp: timestamp
         });
-        var limit = this.config.maxBreadcrumbs;
-        if (breadcrumbs.length > limit) {
-            breadcrumbs = breadcrumbs.slice(breadcrumbs.length - limit);
-        }
-        store.breadcrumbs = breadcrumbs;
         return this;
     };
+    Client.prototype.__getBreadcrumbs = function () {
+        return this.__store.getContents('breadcrumbs').slice();
+    };
+    Client.prototype.__getContext = function () {
+        return this.__store.getContents('context');
+    };
     Client.prototype.__developmentMode = function () {
         if (this.config.reportData === true) {
             return false;
@@ -1050,16 +1058,6 @@ var Client = /** @class */ (function () {
         }
         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 s tore contents.
-     */
-    Client.prototype.__getStoreContentsOrDefault = function () {
-        var existingStoreContents = this.__store.getStore();
-        var storeContents = existingStoreContents || {};
-        return __assign({ context: {}, breadcrumbs: [] }, storeContents);
-    };
     return Client;
 }());
 client.Client = Client;
@@ -1085,6 +1083,9 @@ Object.defineProperty(types, "__esModule", { value: true });
 	}) : function(o, v) {
 	    o["default"] = v;
 	});
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
 	var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
 	    if (mod && mod.__esModule) return mod;
 	    var result = {};
@@ -1093,10 +1094,10 @@ Object.defineProperty(types, "__esModule", { value: true });
 	    return result;
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.Util = exports.Types = exports.Store = exports.Client = void 0;
+	exports.Util = exports.Types = exports.Client = void 0;
 	var client_1 = client;
 	Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
-	exports.Store = __importStar(store);
+	__exportStar(store, exports);
 	exports.Types = __importStar(types);
 	exports.Util = __importStar(util$1);
 } (src));
@@ -1237,25 +1238,8 @@ var uncaught_exception = {};
 
 var aws_lambda = {};
 
-var async_store = {};
-
-Object.defineProperty(async_store, "__esModule", { value: true });
-async_store.AsyncStore = void 0;
-var core_1$1 = src;
-var Store;
-try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    var AsyncLocalStorage = require('async_hooks').AsyncLocalStorage;
-    Store = new AsyncLocalStorage();
-}
-catch (e) {
-    Store = new core_1$1.Store.GlobalStore({ context: {}, breadcrumbs: [] });
-}
-async_store.AsyncStore = Store;
-
 Object.defineProperty(aws_lambda, "__esModule", { value: true });
 aws_lambda.removeAwsDefaultUncaughtExceptionListener = aws_lambda.lambdaHandler = void 0;
-var async_store_1 = async_store;
 function isHandlerSync(handler) {
     return handler.length > 2;
 }
@@ -1269,9 +1253,8 @@ function reportToHoneybadger(hb, err, callback) {
 }
 function asyncHandler(handler, hb) {
     return function wrappedLambdaHandler(event, context) {
-        hb.__setStore(async_store_1.AsyncStore);
         return new Promise(function (resolve, reject) {
-            async_store_1.AsyncStore.run({ context: {}, breadcrumbs: [] }, function () {
+            hb.run(function () {
                 var timeoutHandler = setupTimeoutWarning(hb, context);
                 try {
                     var result = handler(event, context);
@@ -1297,8 +1280,7 @@ function asyncHandler(handler, hb) {
 }
 function syncHandler(handler, hb) {
     return function wrappedLambdaHandler(event, context, cb) {
-        hb.__setStore(async_store_1.AsyncStore);
-        async_store_1.AsyncStore.run({ context: {}, breadcrumbs: [] }, function () {
+        hb.run(function () {
             var timeoutHandler = setupTimeoutWarning(hb, context);
             try {
                 handler(event, context, function (error, result) {
@@ -1467,12 +1449,12 @@ var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || func
 };
 Object.defineProperty(transport, "__esModule", { value: true });
 transport.ServerTransport = void 0;
-var core_1 = src;
+var core_1$1 = src;
 var url_1 = require$$0__default$1["default"];
 var http_1 = __importDefault(require$$2__default$1["default"]);
 var https_1 = __importDefault(require$$3__default["default"]);
 var util_1 = util;
-var sanitize = core_1.Util.sanitize;
+var sanitize = core_1$1.Util.sanitize;
 var ServerTransport = /** @class */ (function () {
     function ServerTransport() {
     }
@@ -1536,6 +1518,126 @@ var ServerTransport = /** @class */ (function () {
 }());
 transport.ServerTransport = ServerTransport;
 
+var stacked_store = {};
+
+var async_store = {};
+
+Object.defineProperty(async_store, "__esModule", { value: true });
+async_store.AsyncStore = void 0;
+var kHoneybadgerStore = Symbol.for('kHoneybadgerStore');
+var AsyncStore = /** @class */ (function () {
+    function AsyncStore(asyncLocalStorage, contents, breadcrumbsLimit) {
+        this.als = asyncLocalStorage;
+        this.contents = contents;
+        this.breadcrumbsLimit = breadcrumbsLimit;
+    }
+    /**
+     * Attempt to create a new AsyncStore instance
+     */
+    AsyncStore.create = function (contents, breadcrumbsLimit) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            var AsyncLocalStorage_1 = require('async_hooks').AsyncLocalStorage;
+            return new AsyncStore(new AsyncLocalStorage_1, contents, breadcrumbsLimit);
+        }
+        catch (e) {
+            return null;
+        }
+    };
+    /**
+     * This returns the live store object, so we can mutate it.
+     * If we're in an async context (a `run()` callback), the stored contents at this point will be returned.
+     * Otherwise, the initial stored contents will be returned.
+     */
+    AsyncStore.prototype.__currentContents = function () {
+        return this.als.getStore() || this.contents;
+    };
+    AsyncStore.prototype.getContents = function (key) {
+        var value = key ? this.__currentContents()[key] : this.__currentContents();
+        return JSON.parse(JSON.stringify(value));
+    };
+    AsyncStore.prototype.available = function () {
+        return !!this.als.getStore();
+    };
+    AsyncStore.prototype.setContext = function (context) {
+        Object.assign(this.__currentContents().context, context || {});
+    };
+    AsyncStore.prototype.addBreadcrumb = function (breadcrumb) {
+        if (this.__currentContents().breadcrumbs.length == this.breadcrumbsLimit) {
+            this.__currentContents().breadcrumbs.shift();
+        }
+        this.__currentContents().breadcrumbs.push(breadcrumb);
+    };
+    AsyncStore.prototype.clear = function () {
+        this.__currentContents().context = {};
+        this.__currentContents().breadcrumbs = [];
+    };
+    AsyncStore.prototype.run = function (callback, request) {
+        // When entering an async context, we pass in *a copy* of the initial contents.
+        // This allows every request to start from the same state
+        // and add data specific to them, without overlapping.
+        if (!request) {
+            return this.als.run(this.getContents(), callback);
+        }
+        var contents;
+        if (request[kHoneybadgerStore]) {
+            contents = request[kHoneybadgerStore];
+        }
+        else {
+            contents = this.getContents();
+            request[kHoneybadgerStore] = contents;
+        }
+        return this.als.run(contents, callback);
+    };
+    return AsyncStore;
+}());
+async_store.AsyncStore = AsyncStore;
+
+Object.defineProperty(stacked_store, "__esModule", { value: true });
+stacked_store.StackedStore = void 0;
+var core_1 = src;
+var async_store_1 = async_store;
+/**
+ * A store that's really a "stack" of stores (async and global)
+ * Will proxy calls to the async store if it's active (ie when we enter an async context via `ALS.run()`),
+ * otherwise it will fall back to the global store.
+ * Both stores in the stack start out with the same contents object.
+ * Note that the asyncStore may be null if ALS is not supported.
+ */
+var StackedStore = /** @class */ (function () {
+    function StackedStore(breadcrumbsLimit) {
+        this.contents = { context: {}, breadcrumbs: [] };
+        this.asyncStore = async_store_1.AsyncStore.create(this.contents, breadcrumbsLimit);
+        this.globalStore = core_1.GlobalStore.create(this.contents, breadcrumbsLimit);
+    }
+    StackedStore.prototype.__activeStore = function () {
+        var _a;
+        return ((_a = this.asyncStore) === null || _a === void 0 ? void 0 : _a.available()) ? this.asyncStore : this.globalStore;
+    };
+    StackedStore.prototype.available = function () {
+        return true;
+    };
+    // @ts-ignore
+    StackedStore.prototype.getContents = function (key) {
+        return this.__activeStore().getContents(key);
+    };
+    StackedStore.prototype.setContext = function (context) {
+        this.__activeStore().setContext(context);
+    };
+    StackedStore.prototype.addBreadcrumb = function (breadcrumb) {
+        this.__activeStore().addBreadcrumb(breadcrumb);
+    };
+    StackedStore.prototype.clear = function () {
+        this.__activeStore().clear();
+    };
+    StackedStore.prototype.run = function (callback, request) {
+        // We explicitly favour the async store here, if ALS is supported. It's the whole point of the `run()` method
+        return this.asyncStore ? this.asyncStore.run(callback, request) : this.globalStore.run(callback);
+    };
+    return StackedStore;
+}());
+stacked_store.StackedStore = StackedStore;
+
 (function (exports) {
 	var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
 	    var extendStatics = function (d, b) {
@@ -1576,10 +1678,9 @@ transport.ServerTransport = ServerTransport;
 	var unhandled_rejection_1 = __importDefault(unhandled_rejection);
 	var middleware_1 = middleware;
 	var aws_lambda_1 = aws_lambda;
-	var async_store_1 = async_store;
 	var transport_1 = transport;
+	var stacked_store_1 = stacked_store;
 	var endpoint = core_1.Util.endpoint;
-	var kHoneybadgerStore = Symbol.for('kHoneybadgerStore');
 	var Honeybadger = /** @class */ (function (_super) {
 	    __extends(Honeybadger, _super);
 	    function Honeybadger(opts) {
@@ -1619,6 +1720,10 @@ transport.ServerTransport = ServerTransport;
 	        if (opts === void 0) { opts = {}; }
 	        return _super.prototype.configure.call(this, opts);
 	    };
+	    Honeybadger.prototype.__initStore = function () {
+	        // @ts-ignore
+	        this.__store = new stacked_store_1.StackedStore(this.config.maxBreadcrumbs);
+	    };
 	    Honeybadger.prototype.checkIn = function (id) {
 	        var _this = this;
 	        return this.__transport
@@ -1641,14 +1746,10 @@ transport.ServerTransport = ServerTransport;
 	    // 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
+	    //   (for example, in an error-handling middleware)
 	    // 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(async_store_1.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)
@@ -1657,11 +1758,14 @@ transport.ServerTransport = ServerTransport;
 	            // 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_1.default.create();
-	            var onErrorWithContext = function (err) { return _this.__store.run(storeObject, function () { return onError(err); }); };
+	            var onErrorWithContext = function (err) { return _this.__store.run(function () { return onError(err); }, request); };
 	            dom.on('error', onErrorWithContext);
 	            handler = dom.bind(handler);
 	        }
-	        return this.__store.run(storeObject, handler);
+	        return this.__store.run(handler, request);
+	    };
+	    Honeybadger.prototype.run = function (callback) {
+	        return this.__store.run(callback);
 	    };
 	    return Honeybadger;
 	}(core_1.Client));

package/dist/server/stacked_store.d.ts

@@ -0,0 +1,23 @@
+import { GlobalStore, Types } from '@honeybadger-io/core';
+import { AsyncStore } from './types/async_store';
+/**
+ * A store that's really a "stack" of stores (async and global)
+ * Will proxy calls to the async store if it's active (ie when we enter an async context via `ALS.run()`),
+ * otherwise it will fall back to the global store.
+ * Both stores in the stack start out with the same contents object.
+ * Note that the asyncStore may be null if ALS is not supported.
+ */
+export declare class StackedStore implements Types.HoneybadgerStore {
+    private readonly contents;
+    private readonly asyncStore;
+    private readonly globalStore;
+    constructor(breadcrumbsLimit: number);
+    __activeStore(): AsyncStore | GlobalStore;
+    available(): boolean;
+    getContents(key?: keyof Types.StoreContents): any;
+    setContext(context: any): void;
+    addBreadcrumb(breadcrumb: any): void;
+    clear(): void;
+    run<R>(callback: () => R, request?: Record<symbol, unknown>): R;
+}
+//# sourceMappingURL=stacked_store.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@honeybadger-io/js",
-  "version": "4.3.0",
+  "version": "4.6.0",
   "license": "MIT",
   "homepage": "https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/js",
   "author": {
@@ -50,7 +50,7 @@
     "postpublish": "./scripts/release-cdn.sh"
   },
   "dependencies": {
-    "@honeybadger-io/core": "^4.3.0",
+    "@honeybadger-io/core": "^4.6.0",
     "@types/aws-lambda": "^8.10.89"
   },
   "devDependencies": {
@@ -74,5 +74,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c5aff95bcaf716d5df122e5225c217b5e3c2620e"
+  "gitHead": "91209fc67df96975d1cacf057d4bbf16e29943d5"
 }