@honeybadger-io/js 6.16.0 → 6.16.2

package/dist/server/fastify.js

@@ -838,8 +838,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;
@@ -977,7 +1005,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$2.clone)(value);
     };
     GlobalStore.prototype.setContext = function (context) {
         this.contents.context = (0, util_1$2.merge)(this.contents.context, context || {});
@@ -1423,7 +1455,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(__assign({}, defaults_1.CONFIG), opts);
         this.__initStore();
@@ -1522,31 +1554,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.shallowClone)(trace); }) : null;
-        var preConditionsResult = this.__runPreconditions(notice);
-        if (preConditionsResult instanceof Error) {
-            (0, util_1.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.shallowClone)(trace); }) : null;
+            var preConditionsResult = this.__runPreconditions(notice_1);
+            if (preConditionsResult instanceof Error) {
+                (0, util_1.runAfterNotifyHandlers)(notice_1, this.__afterNotifyHandlers, preConditionsResult);
+                return false;
+            }
+            if (preConditionsResult instanceof Promise) {
+                preConditionsResult.then(function (result) {
+                    if (result instanceof Error) {
+                        (0, util_1.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.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.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.
@@ -1562,11 +1626,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
@@ -1590,7 +1662,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) {