@honeybadger-io/js 6.16.0 → 6.16.2

package/dist/server/honeybadger.js

@@ -856,8 +856,36 @@ var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(stackTraceParser_esm);
 	    return formattedVars;
 	}
 	exports.formatCGIData = formatCGIData;
+	/**
+	 * Deep-copies a value exactly the way a JSON round trip does -- `toJSON` is
+	 * honored, so dates become ISO strings -- except that circular references are
+	 * replaced with '[RECURSION]' instead of throwing.
+	 *
+	 * Only true cycles are replaced: a value referenced twice in sibling branches
+	 * is copied twice, as a JSON round trip would.
+	 *
+	 * Anything else a round trip rejects (a BigInt, a getter that throws) still
+	 * throws here. Callers that must not fail are expected to handle it: silently
+	 * substituting a placeholder would let a malformed value -- a string where an
+	 * object is expected, say -- travel on as though it were valid.
+	 */
 	function clone(obj) {
-	    return JSON.parse(JSON.stringify(obj));
+	    var ancestors = [];
+	    return JSON.parse(JSON.stringify(obj, function (_key, value) {
+	        if (typeof value !== 'object' || value === null) {
+	            return value;
+	        }
+	        // `this` is the object `value` sits in, so anything stacked above it has
+	        // been fully visited and is no longer an ancestor of `value`.
+	        while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+	            ancestors.pop();
+	        }
+	        if (ancestors.indexOf(value) !== -1) {
+	            return '[RECURSION]';
+	        }
+	        ancestors.push(value);
+	        return value;
+	    }));
 	}
 	exports.clone = clone;
 	var THRESHOLD_COLUMN_NUMBER = 10000;
@@ -995,7 +1023,11 @@ var GlobalStore = /** @class */ (function () {
     };
     GlobalStore.prototype.getContents = function (key) {
         var value = key ? this.contents[key] : this.contents;
-        return JSON.parse(JSON.stringify(value));
+        // `clone` keeps JSON round trip semantics but tolerates values a bare
+        // round trip throws on -- notably circular references, which arrive via
+        // context or breadcrumb metadata the host application controls.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (0, util_1$7.clone)(value);
     };
     GlobalStore.prototype.setContext = function (context) {
         this.contents.context = (0, util_1$7.merge)(this.contents.context, context || {});
@@ -1441,7 +1473,7 @@ var Client = /** @class */ (function () {
         this.__notifier = {
             name: '@honeybadger-io/core',
             url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/core',
-            version: '6.16.0'
+            version: '6.16.2'
         };
         this.config = __assign$1(__assign$1({}, defaults_1.CONFIG), opts);
         this.__initStore();
@@ -1540,31 +1572,63 @@ var Client = /** @class */ (function () {
         this.__store.clear();
         return this;
     };
+    /**
+     * Reporting an error must never break the host application, so any failure
+     * inside the reporting path is logged and swallowed rather than thrown back
+     * into the caller.
+     */
     Client.prototype.notify = function (noticeable, name, extra) {
         var _this = this;
         if (name === void 0) { name = undefined; }
         if (extra === void 0) { extra = undefined; }
-        var notice = this.makeNotice(noticeable, name, extra);
-        // 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 (0, util_1$5.shallowClone)(trace); }) : null;
-        var preConditionsResult = this.__runPreconditions(notice);
-        if (preConditionsResult instanceof Error) {
-            (0, util_1$5.runAfterNotifyHandlers)(notice, this.__afterNotifyHandlers, preConditionsResult);
+        // The body is inlined in this try/catch rather than delegated to a private
+        // method: generated backtraces are trimmed by a fixed frame count
+        // (DEFAULT_BACKTRACE_SHIFT), so an extra call frame here would shift every
+        // generated backtrace into Honeybadger's own source.
+        try {
+            var notice_1 = this.makeNotice(noticeable, name, extra);
+            // we need to have the source file data before the beforeNotifyHandlers,
+            // in case they modify them
+            var sourceCodeData_1 = notice_1 && notice_1.backtrace ? notice_1.backtrace.map(function (trace) { return (0, util_1$5.shallowClone)(trace); }) : null;
+            var preConditionsResult = this.__runPreconditions(notice_1);
+            if (preConditionsResult instanceof Error) {
+                (0, util_1$5.runAfterNotifyHandlers)(notice_1, this.__afterNotifyHandlers, preConditionsResult);
+                return false;
+            }
+            if (preConditionsResult instanceof Promise) {
+                preConditionsResult.then(function (result) {
+                    if (result instanceof Error) {
+                        (0, util_1$5.runAfterNotifyHandlers)(notice_1, _this.__afterNotifyHandlers, result);
+                        return false;
+                    }
+                    return _this.__send(notice_1, sourceCodeData_1);
+                }).catch(function (err) {
+                    // __send installs its own catch, which logs and runs the afterNotify
+                    // handlers. Anything arriving here failed before that chain existed,
+                    // so it is still unreported -- and notify() has already returned
+                    // true, leaving notifyAsync() waiting on those handlers.
+                    _this.__logReportingFailure(err);
+                    (0, util_1$5.runAfterNotifyHandlers)(notice_1, _this.__afterNotifyHandlers, err instanceof Error ? err : new Error(String(err)));
+                });
+                return true;
+            }
+            this.__send(notice_1, sourceCodeData_1).catch(function (_err) { });
+            return true;
+        }
+        catch (err) {
+            // Reporting an error must never break the host application, so a failure
+            // in the reporting path is logged rather than thrown back at the caller.
+            // notifyAsync() settles on the false return below.
+            this.__logReportingFailure(err);
             return false;
         }
-        if (preConditionsResult instanceof Promise) {
-            preConditionsResult.then(function (result) {
-                if (result instanceof Error) {
-                    (0, util_1$5.runAfterNotifyHandlers)(notice, _this.__afterNotifyHandlers, result);
-                    return false;
-                }
-                return _this.__send(notice, sourceCodeData);
-            });
-            return true;
+    };
+    /** The logger is host-supplied, so even reporting a failure gets a guard. */
+    Client.prototype.__logReportingFailure = function (err) {
+        try {
+            this.logger.error('Error report failed: an internal error occurred while reporting', err);
         }
-        this.__send(notice, sourceCodeData).catch(function (_err) { });
-        return true;
+        catch (_loggerErr) { /* nothing left to report it with */ }
     };
     /**
      * An async version of {@link notify} that resolves only after the notice has been reported to Honeybadger.
@@ -1580,11 +1644,19 @@ var Client = /** @class */ (function () {
             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);
+                    // Settle from a `finally` so a throwing handler cannot leave the
+                    // caller awaiting forever; its error propagates as it always has.
+                    try {
+                        originalAfterNotify === null || originalAfterNotify === void 0 ? void 0 : originalAfterNotify.call(_this, err);
+                    }
+                    finally {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve();
+                        }
                     }
-                    resolve();
                 };
             };
             // We have to respect any afterNotify hooks that come from the arguments
@@ -1608,7 +1680,14 @@ var Client = /** @class */ (function () {
                 objectToOverride = name = {};
             }
             applyAfterNotify(objectToOverride);
-            _this.notify(noticeable, name, extra);
+            // `notify` never throws, so a false return is the only signal that the
+            // report was abandoned. Every expected failure has already settled this
+            // promise through the afterNotify hook above (a second reject is a
+            // no-op); this catches the unexpected ones, which would otherwise leave
+            // the caller awaiting forever.
+            if (!_this.notify(noticeable, name, extra)) {
+                reject(new Error('Error report failed: see logs for details'));
+            }
         });
     };
     Client.prototype.makeNotice = function (noticeable, name, extra) {
@@ -2238,7 +2317,7 @@ http_event.buildRequestEventPayload = buildRequestEventPayload;
 Object.defineProperty(aws_lambda, "__esModule", { value: true });
 aws_lambda.removeAwsDefaultUncaughtExceptionListener = aws_lambda.lambdaHandler = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
-var core_1$4 = src;
+var core_1$5 = src;
 var http_event_1$1 = http_event;
 function isHandlerSync(handler) {
     return handler.length > 2;
@@ -2336,7 +2415,7 @@ function seedLambdaEventContext(hb, event, context) {
 function createLambdaRequestEmitter(hb, event) {
     if (!isHttpLambdaEvent(event))
         return null;
-    if (!core_1$4.Util.resolveInsights(hb.config).http)
+    if (!core_1$5.Util.resolveInsights(hb.config).http)
         return null;
     var start = (0, http_event_1$1.startTimer)();
     var emitted = false;
@@ -2797,7 +2876,7 @@ var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || func
 Object.defineProperty(middleware, "__esModule", { value: true });
 middleware.errorHandler = middleware.requestHandler = void 0;
 var url_1$1 = __importDefault(require$$0__default$2["default"]);
-var core_1$3 = src;
+var core_1$4 = src;
 var http_event_1 = http_event;
 function fullUrl(req) {
     var connection = req.connection;
@@ -2845,7 +2924,7 @@ function requestHandler(req, res, next) {
     var _this = this;
     this.withRequest(req, function () {
         _this.setEventContext((0, http_event_1.seedRequestEventContext)(req.headers));
-        if (core_1$3.Util.resolveInsights(_this.config).http) {
+        if (core_1$4.Util.resolveInsights(_this.config).http) {
             instrumentInboundRequest(_this, req, res);
         }
         next();
@@ -2907,12 +2986,12 @@ var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (
 };
 Object.defineProperty(transport, "__esModule", { value: true });
 transport.ServerTransport = void 0;
-var core_1$2 = src;
+var core_1$3 = src;
 var url_1 = require$$0__default$2["default"];
 var util_1 = util;
 var http = __importStar(require$$3__default$1["default"]);
 var https = __importStar(require$$4__default["default"]);
-var sanitize = core_1$2.Util.sanitize;
+var sanitize = core_1$3.Util.sanitize;
 var ServerTransport = /** @class */ (function () {
     function ServerTransport(headers) {
         if (headers === void 0) { headers = {}; }
@@ -2988,6 +3067,8 @@ var async_store = {};
 
 Object.defineProperty(async_store, "__esModule", { value: true });
 async_store.AsyncStore = void 0;
+var core_1$2 = src;
+var clone = core_1$2.Util.clone;
 var kHoneybadgerStore = Symbol.for('kHoneybadgerStore');
 var AsyncStore = /** @class */ (function () {
     function AsyncStore(asyncLocalStorage, contents, breadcrumbsLimit) {
@@ -3018,7 +3099,10 @@ var AsyncStore = /** @class */ (function () {
     };
     AsyncStore.prototype.getContents = function (key) {
         var value = key ? this.__currentContents()[key] : this.__currentContents();
-        return JSON.parse(JSON.stringify(value));
+        // Deep copy like a JSON round trip, but tolerate circular references in
+        // host-supplied context and breadcrumb metadata. See GlobalStore.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return clone(value);
     };
     AsyncStore.prototype.available = function () {
         return !!this.als.getStore();
@@ -3905,7 +3989,7 @@ client.CheckInsClient = CheckInsClient;
 	var NOTIFIER = {
 	    name: '@honeybadger-io/js',
 	    url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/js',
-	    version: '6.16.0'
+	    version: '6.16.2'
 	};
 	var userAgent = function () {
 	    return "Honeybadger JS Server Client ".concat(NOTIFIER.version, ", ").concat(os_1.default.version(), "; ").concat(os_1.default.platform());