@honeybadger-io/js 6.16.0 → 6.16.2

package/dist/browser/honeybadger.js

@@ -838,8 +838,36 @@
 		    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 @@
 	    };
 	    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$3.clone)(value);
 	    };
 	    GlobalStore.prototype.setContext = function (context) {
 	        this.contents.context = (0, util_1$3.merge)(this.contents.context, context || {});
@@ -1423,7 +1455,7 @@
 	        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();
@@ -1522,31 +1554,63 @@
 	        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$1.shallowClone)(trace); }) : null;
-	        var preConditionsResult = this.__runPreconditions(notice);
-	        if (preConditionsResult instanceof Error) {
-	            (0, util_1$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$1.shallowClone)(trace); }) : null;
+	            var preConditionsResult = this.__runPreconditions(notice_1);
+	            if (preConditionsResult instanceof Error) {
+	                (0, util_1$1.runAfterNotifyHandlers)(notice_1, this.__afterNotifyHandlers, preConditionsResult);
+	                return false;
+	            }
+	            if (preConditionsResult instanceof Promise) {
+	                preConditionsResult.then(function (result) {
+	                    if (result instanceof Error) {
+	                        (0, util_1$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$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$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 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 @@
 	                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) {
@@ -2364,7 +2443,11 @@
 	                        metadata: {
 	                            selector: selector,
 	                            text: text,
-	                            event: event
+	                            // Frameworks decorate the native event with their own properties
+	                            // (preact/compat adds a `nativeEvent` back-reference), so the raw
+	                            // event may be circular. Sanitize it here rather than storing a
+	                            // value we cannot serialize later.
+	                            event: sanitize$1(event, 3)
 	                        }
 	                    });
 	                }, _window.location ? true : false); // In CloudFlare workers useCapture must be false. window.location is a hacky way to detect it.
@@ -3070,7 +3153,7 @@
 		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 () {
 		    if (typeof navigator !== 'undefined') {