@honeybadger-io/js 6.15.3 → 6.16.1

package/dist/browser/honeybadger.js

@@ -35,7 +35,7 @@
 
 	var src = {};
 
-	var events = {};
+	var console_events = {};
 
 	var util$1 = {};
 
@@ -242,7 +242,7 @@
 		    }
 		};
 		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.logDeprecatedMethod = exports.globalThisOrWindow = exports.isBrowserConfig = exports.clone = exports.formatCGIData = exports.filterUrl = exports.filter = exports.generateStackTrace = exports.endpoint = exports.instrumentConsole = exports.instrument = exports.isErrorObject = exports.makeNotice = exports.logger = exports.sanitize = exports.shallowClone = exports.runAfterNotifyHandlers = exports.runBeforeNotifyHandlers = exports.getSourceForBacktrace = exports.getCauses = exports.calculateBacktraceShift = exports.DEFAULT_BACKTRACE_SHIFT = exports.makeBacktrace = exports.objectIsExtensible = exports.objectIsEmpty = exports.mergeNotice = exports.merge = void 0;
+		exports.logDeprecatedMethod = exports.globalThisOrWindow = exports.isBrowserConfig = exports.clone = exports.formatCGIData = exports.filterUrl = exports.filter = exports.generateStackTrace = exports.endpoint = exports.instrumentConsole = exports.instrument = exports.isErrorObject = exports.makeNotice = exports.logger = exports.sanitize = exports.shallowClone = exports.runAfterNotifyHandlers = exports.shouldSampleEvent = exports.resolveInsights = exports.runBeforeEventHandlers = exports.runBeforeNotifyHandlers = exports.getSourceForBacktrace = exports.getCauses = exports.calculateBacktraceShift = exports.DEFAULT_BACKTRACE_SHIFT = exports.makeBacktrace = exports.objectIsExtensible = exports.objectIsEmpty = exports.mergeNotice = exports.merge = void 0;
 		/* eslint-disable prefer-rest-params */
 		var stackTraceParser = __importStar(require$$0$1);
 		function merge(obj1, obj2) {
@@ -418,6 +418,88 @@
 		    };
 		}
 		exports.runBeforeNotifyHandlers = runBeforeNotifyHandlers;
+		function runBeforeEventHandlers(payload, handlers, logger) {
+		    return __awaiter(this, void 0, void 0, function () {
+		        var i, len, result, err_1;
+		        return __generator(this, function (_a) {
+		            switch (_a.label) {
+		                case 0:
+		                    i = 0, len = handlers.length;
+		                    _a.label = 1;
+		                case 1:
+		                    if (!(i < len)) return [3 /*break*/, 7];
+		                    result = void 0;
+		                    _a.label = 2;
+		                case 2:
+		                    _a.trys.push([2, 4, , 5]);
+		                    return [4 /*yield*/, handlers[i](payload)];
+		                case 3:
+		                    result = _a.sent();
+		                    return [3 /*break*/, 5];
+		                case 4:
+		                    err_1 = _a.sent();
+		                    // A buggy handler should not suppress unrelated events. Log and treat as no-op.
+		                    logger === null || logger === void 0 ? void 0 : logger.error('beforeEvent handler threw; continuing', err_1);
+		                    return [3 /*break*/, 6];
+		                case 5:
+		                    if (result === false) {
+		                        return [2 /*return*/, false];
+		                    }
+		                    _a.label = 6;
+		                case 6:
+		                    i++;
+		                    return [3 /*break*/, 1];
+		                case 7: return [2 /*return*/, true];
+		            }
+		        });
+		    });
+		}
+		exports.runBeforeEventHandlers = runBeforeEventHandlers;
+		function resolveInsights(config) {
+		    var _a, _b;
+		    var insights = config.insights;
+		    if (!insights || insights.enabled !== true) {
+		        return { console: false, http: false };
+		    }
+		    return {
+		        console: (_a = insights.console) !== null && _a !== void 0 ? _a : false,
+		        http: (_b = insights.http) !== null && _b !== void 0 ? _b : false,
+		    };
+		}
+		exports.resolveInsights = resolveInsights;
+		function fnv1a(str) {
+		    var h = 0x811c9dc5;
+		    for (var i = 0, len = str.length; i < len; i++) {
+		        h ^= str.charCodeAt(i);
+		        h = Math.imul(h, 0x01000193);
+		    }
+		    return h >>> 0;
+		}
+		function clampSampleRate(rate) {
+		    if (rate < 0)
+		        return 0;
+		    if (rate > 100)
+		        return 100;
+		    return rate;
+		}
+		function shouldSampleEvent(event, configRate) {
+		    var meta = event._hb;
+		    var override = meta && Number.isFinite(meta.sampleRate) ? meta.sampleRate : undefined;
+		    var rawRate = override !== undefined ? override : configRate;
+		    // Guard against non-finite rates (e.g. NaN from Number(invalidConfig)); an
+		    // unusable rate must not silently drop every event, so fall back to send-all.
+		    var rate = clampSampleRate(Number.isFinite(rawRate) ? rawRate : 100);
+		    if (rate <= 0)
+		        return false;
+		    if (rate >= 100)
+		        return true;
+		    var requestId = event.request_id;
+		    if (typeof requestId === 'string' && requestId.length > 0) {
+		        return fnv1a(requestId) % 100 < rate;
+		    }
+		    return Math.random() * 100 < rate;
+		}
+		exports.shouldSampleEvent = shouldSampleEvent;
 		function runAfterNotifyHandlers(notice, handlers, error) {
 		    if (notice && notice.afterNotify) {
 		        notice.afterNotify(error, notice);
@@ -756,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;
@@ -838,7 +948,7 @@
 		
 	} (util$1));
 
-	Object.defineProperty(events, "__esModule", { value: true });
+	Object.defineProperty(console_events, "__esModule", { value: true });
 	var util_1$4 = util$1;
 	function default_1$4(_window) {
 	    if (_window === void 0) { _window = (0, util_1$4.globalThisOrWindow)(); }
@@ -846,7 +956,7 @@
 	        shouldReloadOnConfigure: false,
 	        load: function (client) {
 	            function sendEventsToInsights() {
-	                return client.config.eventsEnabled;
+	                return (0, util_1$4.resolveInsights)(client.config).console;
 	            }
 	            if (!sendEventsToInsights()) {
 	                return;
@@ -873,7 +983,7 @@
 	        }
 	    };
 	}
-	events.default = default_1$4;
+	console_events.default = default_1$4;
 
 	var client = {};
 
@@ -895,11 +1005,21 @@
 	    };
 	    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 || {});
 	    };
+	    GlobalStore.prototype.setEventContext = function (eventContext) {
+	        this.contents.eventContext = (0, util_1$3.merge)(this.contents.eventContext, eventContext || {});
+	    };
+	    GlobalStore.prototype.clearEventContext = function () {
+	        this.contents.eventContext = {};
+	    };
 	    GlobalStore.prototype.addBreadcrumb = function (breadcrumb) {
 	        if (this.contents.breadcrumbs.length == this.breadcrumbsLimit) {
 	            this.contents.breadcrumbs.shift();
@@ -908,6 +1028,7 @@
 	    };
 	    GlobalStore.prototype.clear = function () {
 	        this.contents.context = {};
+	        this.contents.eventContext = {};
 	        this.contents.breadcrumbs = [];
 	    };
 	    GlobalStore.prototype.run = function (callback) {
@@ -917,7 +1038,7 @@
 	}());
 	store.GlobalStore = GlobalStore;
 
-	var throttled_events_logger = {};
+	var throttled_events_worker = {};
 
 	class NdJson {
 	    static parse(data) {
@@ -952,8 +1073,18 @@
 	    revision: null,
 	    reportData: null,
 	    breadcrumbsEnabled: true,
-	    // we could decide the value of eventsEnabled based on `env` and `developmentEnvironments`
+	    // deprecated: `eventsEnabled: true` auto-enables insights.enabled + insights.console
 	    eventsEnabled: false,
+	    insights: {
+	        enabled: false,
+	        console: false,
+	        http: false,
+	    },
+	    events: {
+	        dispatchIntervalSeconds: 10,
+	        bulkThreshold: 500,
+	        sampleRatePercentage: 100,
+	    },
 	    maxBreadcrumbs: 40,
 	    maxObjectDepth: 8,
 	    logger: console,
@@ -1016,72 +1147,179 @@
 	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
 	    }
 	};
-	Object.defineProperty(throttled_events_logger, "__esModule", { value: true });
-	throttled_events_logger.ThrottledEventsLogger = void 0;
+	Object.defineProperty(throttled_events_worker, "__esModule", { value: true });
+	throttled_events_worker.ThrottledEventsWorker = void 0;
 	var json_nd_1 = require$$0;
 	var util_1$2 = util$1;
 	var defaults_1$1 = defaults;
-	var ThrottledEventsLogger = /** @class */ (function () {
-	    function ThrottledEventsLogger(config, transport) {
+	var ThrottledEventsWorker = /** @class */ (function () {
+	    function ThrottledEventsWorker(config, transport) {
 	        this.config = config;
 	        this.transport = transport;
 	        this.queue = [];
-	        this.isProcessing = false;
+	        this.cooldownTimer = null;
+	        // Timestamp (ms) until which the post-send cooldown window is active. A timer
+	        // is only armed while there are queued events waiting for this window; when the
+	        // queue drains empty we keep the timestamp but drop the timer, so an idle worker
+	        // never holds a pending timer (which would otherwise keep a Node process alive
+	        // for the full interval.
+	        this.cooldownUntil = 0;
+	        this.inFlight = null;
 	        this.config = __assign$2(__assign$2({}, defaults_1$1.CONFIG), config);
 	        this.logger = this.originalLogger();
 	    }
-	    ThrottledEventsLogger.prototype.configure = function (opts) {
+	    ThrottledEventsWorker.prototype.configure = function (opts) {
 	        for (var k in opts) {
 	            this.config[k] = opts[k];
 	        }
 	    };
-	    ThrottledEventsLogger.prototype.log = function (payload) {
+	    ThrottledEventsWorker.prototype.log = function (payload) {
 	        this.queue.push(payload);
-	        if (!this.isProcessing) {
+	        if (this.inFlight) {
+	            return;
+	        }
+	        // Crossing the bulk threshold preempts any pending cooldown and dispatches now.
+	        if (this.queue.length >= this.bulkThreshold()) {
+	            this.clearCooldownTimer();
 	            this.processQueue();
+	            return;
 	        }
+	        // A timer is already counting down the cooldown window; the queued event
+	        // will be picked up when it fires.
+	        if (this.cooldownTimer) {
+	            return;
+	        }
+	        // We're inside a cooldown window but no timer is armed (the queue had drained
+	        // empty after the previous send). Arm one for the remaining time so this event
+	        // still respects the interval.
+	        var remaining = this.cooldownRemainingMs();
+	        if (remaining > 0) {
+	            this.scheduleCooldownTimer(remaining);
+	            return;
+	        }
+	        this.processQueue();
 	    };
-	    ThrottledEventsLogger.prototype.flushAsync = function () {
+	    ThrottledEventsWorker.prototype.flushAsync = function () {
+	        var _this = this;
+	        var _a;
 	        this.logger.debug('[Honeybadger] Flushing events');
-	        return this.send();
+	        this.clearCooldownTimer();
+	        var previous = (_a = this.inFlight) !== null && _a !== void 0 ? _a : Promise.resolve();
+	        var flush = previous.then(function () { return _this.drainAll(); });
+	        // Mark the flush as in-flight so a concurrent log() doesn't start an
+	        // overlapping processQueue() drain while we're draining here.
+	        this.inFlight = flush;
+	        var clear = function () {
+	            if (_this.inFlight === flush) {
+	                _this.inFlight = null;
+	            }
+	        };
+	        flush.then(clear, clear);
+	        return flush;
+	    };
+	    ThrottledEventsWorker.prototype.drainAll = function () {
+	        return __awaiter$2(this, void 0, void 0, function () {
+	            return __generator$2(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (!(this.queue.length > 0)) return [3 /*break*/, 2];
+	                        return [4 /*yield*/, this.send()];
+	                    case 1:
+	                        _a.sent();
+	                        return [3 /*break*/, 0];
+	                    case 2: return [2 /*return*/];
+	                }
+	            });
+	        });
 	    };
-	    ThrottledEventsLogger.prototype.processQueue = function () {
+	    ThrottledEventsWorker.prototype.processQueue = function () {
 	        var _this = this;
-	        if (this.queue.length === 0 || this.isProcessing) {
+	        if (this.queue.length === 0 || this.inFlight) {
 	            return;
 	        }
-	        this.isProcessing = true;
-	        this.send()
-	            .then(function () {
-	            setTimeout(function () {
-	                _this.isProcessing = false;
-	                _this.processQueue();
-	            }, 50);
-	        })
+	        var inFlight = this.send()
 	            .catch(function (error) {
 	            _this.logger.error('[Honeybadger] Error making HTTP request:', error);
-	            // Continue processing the queue even if there's an error
-	            setTimeout(function () {
-	                _this.isProcessing = false;
-	                _this.processQueue();
-	            }, 50);
+	        })
+	            .then(function () {
+	            // Only reset if we're still the current operation; a flushAsync() may
+	            // have taken ownership of inFlight while this send was resolving.
+	            if (_this.inFlight === inFlight) {
+	                _this.inFlight = null;
+	                _this.scheduleNextDispatch();
+	            }
 	        });
+	        this.inFlight = inFlight;
+	    };
+	    ThrottledEventsWorker.prototype.scheduleNextDispatch = function () {
+	        var intervalMs = this.dispatchIntervalMs();
+	        // Capture the cooldown deadline at dispatch time so a later config change to
+	        // the interval doesn't retroactively shorten a window already in progress.
+	        this.cooldownUntil = Date.now() + intervalMs;
+	        if (this.queue.length >= this.bulkThreshold()) {
+	            this.processQueue();
+	            return;
+	        }
+	        // Only arm a timer when there's queued work waiting for it. If the queue is
+	        // empty, `cooldownUntil` alone enforces the window: the next log() will arm a
+	        // timer for whatever time remains, and an idle worker holds no timer at all.
+	        if (this.queue.length > 0) {
+	            this.scheduleCooldownTimer(intervalMs);
+	        }
+	    };
+	    ThrottledEventsWorker.prototype.cooldownRemainingMs = function () {
+	        if (!this.cooldownUntil) {
+	            return 0;
+	        }
+	        return Math.max(0, this.cooldownUntil - Date.now());
+	    };
+	    ThrottledEventsWorker.prototype.scheduleCooldownTimer = function (ms) {
+	        var _this = this;
+	        this.cooldownTimer = setTimeout(function () {
+	            _this.cooldownTimer = null;
+	            _this.processQueue();
+	        }, ms);
+	        // In Node, don't let a pending cooldown timer keep the process alive for the
+	        // whole batching interval. `unref` lets the event loop go idle so the process
+	        // can exit (or a shutdown / `beforeExit` handler can run) promptly instead of
+	        // blocking for `dispatchIntervalSeconds`. Queued events aren't lost: a
+	        // `flushAsync()` on the way out still drains them before exit. (`unref` is
+	        // Node-only; the browser's numeric setTimeout handle has no such method.)
+	        if (typeof this.cooldownTimer === 'object' && this.cooldownTimer !== null && typeof this.cooldownTimer.unref === 'function') {
+	            this.cooldownTimer.unref();
+	        }
 	    };
-	    ThrottledEventsLogger.prototype.send = function () {
+	    ThrottledEventsWorker.prototype.clearCooldownTimer = function () {
+	        if (this.cooldownTimer) {
+	            clearTimeout(this.cooldownTimer);
+	            this.cooldownTimer = null;
+	        }
+	    };
+	    ThrottledEventsWorker.prototype.send = function () {
 	        return __awaiter$2(this, void 0, void 0, function () {
 	            var eventsData, data;
 	            return __generator$2(this, function (_a) {
 	                if (this.queue.length === 0) {
 	                    return [2 /*return*/];
 	                }
-	                eventsData = this.queue.slice();
-	                this.queue = [];
+	                eventsData = this.queue.splice(0, this.bulkThreshold());
 	                data = json_nd_1.NdJson.stringify(eventsData);
 	                return [2 /*return*/, this.makeHttpRequest(data)];
 	            });
 	        });
 	    };
-	    ThrottledEventsLogger.prototype.makeHttpRequest = function (data) {
+	    ThrottledEventsWorker.prototype.bulkThreshold = function () {
+	        var _a;
+	        var v = (_a = this.config.events) === null || _a === void 0 ? void 0 : _a.bulkThreshold;
+	        return typeof v === 'number' && v > 0 ? v : defaults_1$1.CONFIG.events.bulkThreshold;
+	    };
+	    ThrottledEventsWorker.prototype.dispatchIntervalMs = function () {
+	        var _a;
+	        var v = (_a = this.config.events) === null || _a === void 0 ? void 0 : _a.dispatchIntervalSeconds;
+	        var seconds = typeof v === 'number' && v >= 0 ? v : defaults_1$1.CONFIG.events.dispatchIntervalSeconds;
+	        return seconds * 1000;
+	    };
+	    ThrottledEventsWorker.prototype.makeHttpRequest = function (data) {
 	        return __awaiter$2(this, void 0, void 0, function () {
 	            var _this = this;
 	            return __generator$2(this, function (_a) {
@@ -1096,10 +1334,13 @@
 	                        maxObjectDepth: this.config.maxObjectDepth,
 	                        logger: this.logger,
 	                    }, data)
-	                        .then(function () {
-	                        if (_this.config.debug) {
+	                        .then(function (resp) {
+	                        if ([200, 201].includes(resp.statusCode)) {
 	                            _this.logger.debug('[Honeybadger] Events sent successfully');
 	                        }
+	                        else {
+	                            _this.logger.debug("[Honeybadger] Events failed[".concat(resp.statusCode, "]: ").concat(resp.body));
+	                        }
 	                    })
 	                        .catch(function (err) {
 	                        _this.logger.error("[Honeybadger] Error sending events: ".concat(err.message));
@@ -1110,28 +1351,40 @@
 	    /**
 	     * todo: improve this
 	     *
-	     * The EventsLogger overrides the console methods to enable automatic instrumentation
+	     * The events plugin overrides the console methods to enable automatic instrumentation
 	     * of console logs to the Honeybadger API.
 	     * So if we want to log something in here we need to use the original methods.
 	     */
-	    ThrottledEventsLogger.prototype.originalLogger = function () {
-	        var _a, _b, _c, _d, _e;
+	    ThrottledEventsWorker.prototype.originalLogger = function () {
+	        var _this = this;
+	        var _a, _b, _c, _d;
 	        return {
 	            // eslint-disable-next-line @typescript-eslint/no-explicit-any
 	            log: (_a = console.log.__hb_original) !== null && _a !== void 0 ? _a : console.log,
 	            // eslint-disable-next-line @typescript-eslint/no-explicit-any
 	            info: (_b = console.info.__hb_original) !== null && _b !== void 0 ? _b : console.info,
+	            debug: function () {
+	                var _a;
+	                var args = [];
+	                for (var _i = 0; _i < arguments.length; _i++) {
+	                    args[_i] = arguments[_i];
+	                }
+	                if (!_this.config.debug) {
+	                    return;
+	                }
+	                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+	                var func = (_a = console.debug.__hb_original) !== null && _a !== void 0 ? _a : console.debug;
+	                return func.apply(void 0, args);
+	            },
 	            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-	            debug: (_c = console.debug.__hb_original) !== null && _c !== void 0 ? _c : console.debug,
-	            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-	            warn: (_d = console.warn.__hb_original) !== null && _d !== void 0 ? _d : console.warn,
+	            warn: (_c = console.warn.__hb_original) !== null && _c !== void 0 ? _c : console.warn,
 	            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-	            error: (_e = console.error.__hb_original) !== null && _e !== void 0 ? _e : console.error,
+	            error: (_d = console.error.__hb_original) !== null && _d !== void 0 ? _d : console.error,
 	        };
 	    };
-	    return ThrottledEventsLogger;
+	    return ThrottledEventsWorker;
 	}());
-	throttled_events_logger.ThrottledEventsLogger = ThrottledEventsLogger;
+	throttled_events_worker.ThrottledEventsWorker = ThrottledEventsWorker;
 
 	var __assign$1 = (commonjsGlobal && commonjsGlobal.__assign) || function () {
 	    __assign$1 = Object.assign || function(t) {
@@ -1184,7 +1437,7 @@
 	client.Client = void 0;
 	var util_1$1 = util$1;
 	var store_1 = store;
-	var throttled_events_logger_1 = throttled_events_logger;
+	var throttled_events_worker_1 = throttled_events_worker;
 	var defaults_1 = defaults;
 	// Split at commas and spaces
 	var TAG_SEPARATOR = /,|\s+/;
@@ -1196,17 +1449,20 @@
 	        this.__pluginsLoaded = false;
 	        this.__store = null;
 	        this.__beforeNotifyHandlers = [];
+	        this.__beforeEventHandlers = [];
 	        this.__afterNotifyHandlers = [];
+	        this.__pendingEvents = new Set();
 	        this.__notifier = {
 	            name: '@honeybadger-io/core',
 	            url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/core',
-	            version: '6.15.3'
+	            version: '6.16.1'
 	        };
 	        this.config = __assign$1(__assign$1({}, defaults_1.CONFIG), opts);
 	        this.__initStore();
 	        this.__transport = transport;
-	        this.__eventsLogger = new throttled_events_logger_1.ThrottledEventsLogger(this.config, this.__transport);
+	        this.__eventsWorker = new throttled_events_worker_1.ThrottledEventsWorker(this.config, this.__transport);
 	        this.logger = (0, util_1$1.logger)(this);
+	        this.__applyEventsEnabledShim(opts);
 	    }
 	    Client.prototype.getVersion = function () {
 	        return this.__notifier.version;
@@ -1229,10 +1485,24 @@
 	        for (var k in opts) {
 	            this.config[k] = opts[k];
 	        }
-	        this.__eventsLogger.configure(this.config);
+	        this.__applyEventsEnabledShim(opts);
+	        this.__eventsWorker.configure(this.config);
 	        this.loadPlugins();
 	        return this;
 	    };
+	    /**
+	     * Backwards compatibility: `eventsEnabled: true` used to opt into console events.
+	     * The deprecated flag auto-enables `insights.enabled` and `insights.console`;
+	     * explicit user-provided insights values win over the shim.
+	     */
+	    Client.prototype.__applyEventsEnabledShim = function (opts) {
+	        var _a;
+	        if (opts.eventsEnabled !== true) {
+	            return;
+	        }
+	        this.logger.warn('Deprecation warning: `eventsEnabled` has been deprecated; please use `insights.enabled` and `insights.console` instead.');
+	        this.config.insights = __assign$1(__assign$1(__assign$1({}, ((_a = this.config.insights) !== null && _a !== void 0 ? _a : {})), { enabled: true, console: true }), opts.insights);
+	    };
 	    Client.prototype.loadPlugins = function () {
 	        var _this = this;
 	        var pluginsToLoad = this.__pluginsLoaded
@@ -1242,12 +1512,16 @@
 	        this.__pluginsLoaded = true;
 	    };
 	    Client.prototype.__initStore = function () {
-	        this.__store = new store_1.GlobalStore({ context: {}, breadcrumbs: [] }, this.config.maxBreadcrumbs);
+	        this.__store = new store_1.GlobalStore({ context: {}, eventContext: {}, breadcrumbs: [] }, this.config.maxBreadcrumbs);
 	    };
 	    Client.prototype.beforeNotify = function (handler) {
 	        this.__beforeNotifyHandlers.push(handler);
 	        return this;
 	    };
+	    Client.prototype.beforeEvent = function (handler) {
+	        this.__beforeEventHandlers.push(handler);
+	        return this;
+	    };
 	    Client.prototype.afterNotify = function (handler) {
 	        this.__afterNotifyHandlers.push(handler);
 	        return this;
@@ -1258,6 +1532,16 @@
 	        }
 	        return this;
 	    };
+	    Client.prototype.setEventContext = function (eventContext) {
+	        if (typeof eventContext === 'object' && eventContext != null) {
+	            this.__store.setEventContext(eventContext);
+	        }
+	        return this;
+	    };
+	    Client.prototype.clearEventContext = function () {
+	        this.__store.clearEventContext();
+	        return this;
+	    };
 	    Client.prototype.resetContext = function (context) {
 	        this.logger.warn('Deprecation warning: `Honeybadger.resetContext()` has been deprecated; please use `Honeybadger.clear()` instead.');
 	        this.__store.clear();
@@ -1270,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.
@@ -1310,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
@@ -1338,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) {
@@ -1412,19 +1743,59 @@
 	        this.event('log', data);
 	    };
 	    Client.prototype.event = function (type, data) {
+	        var _this = this;
 	        var _a;
 	        if (typeof type === 'object') {
 	            data = type;
 	            type = (_a = type['event_type']) !== null && _a !== void 0 ? _a : undefined;
 	        }
-	        this.__eventsLogger.log(__assign$1({ event_type: type, ts: new Date().toISOString() }, data));
+	        var eventContext = this.__store.getContents('eventContext') || {};
+	        var payload = __assign$1(__assign$1({ event_type: type, ts: new Date().toISOString() }, eventContext), data);
+	        // Track in-flight handler chains so flushAsync() can await them before
+	        // delegating to the events logger; otherwise a caller that awaits flushAsync()
+	        // immediately after event() may flush before the payload enters the queue.
+	        var inFlight = (0, util_1$1.runBeforeEventHandlers)(payload, this.__beforeEventHandlers, this.logger)
+	            .then(function (shouldSend) {
+	            var _a, _b;
+	            if (!shouldSend) {
+	                _this.logger.debug('skipping event: beforeEvent handler returned false');
+	                return;
+	            }
+	            var sampleRate = (_b = (_a = _this.config.events) === null || _a === void 0 ? void 0 : _a.sampleRatePercentage) !== null && _b !== void 0 ? _b : 100;
+	            if (!(0, util_1$1.shouldSampleEvent)(payload, sampleRate)) {
+	                _this.logger.debug('skipping event: dropped by sampleRatePercentage');
+	                return;
+	            }
+	            delete payload._hb;
+	            _this.__eventsWorker.log(payload);
+	        })
+	            .catch(function (err) {
+	            // should not happen, because each handler is wrapped with a try/catch
+	            _this.logger.error('beforeEvent handler chain failed; dropping event', err);
+	        })
+	            .finally(function () {
+	            _this.__pendingEvents.delete(inFlight);
+	        });
+	        this.__pendingEvents.add(inFlight);
 	    };
 	    /**
 	     * This method currently flushes the event (Insights) queue.
 	     * In the future, it should also flush the error queue (assuming an error throttler is implemented).
 	     */
 	    Client.prototype.flushAsync = function () {
-	        return this.__eventsLogger.flushAsync();
+	        return __awaiter$1(this, void 0, void 0, function () {
+	            return __generator$1(this, function (_a) {
+	                switch (_a.label) {
+	                    case 0:
+	                        if (!(this.__pendingEvents.size > 0)) return [3 /*break*/, 2];
+	                        return [4 /*yield*/, Promise.allSettled(Array.from(this.__pendingEvents))];
+	                    case 1:
+	                        _a.sent();
+	                        _a.label = 2;
+	                    case 2: return [2 /*return*/, this.__eventsWorker.flushAsync()];
+	                }
+	            });
+	        });
 	    };
 	    Client.prototype.__getBreadcrumbs = function () {
 	        return this.__store.getContents('breadcrumbs').slice();
@@ -1616,7 +1987,7 @@
 		};
 		Object.defineProperty(exports, "__esModule", { value: true });
 		exports.Plugins = exports.Defaults = exports.Util = exports.Types = exports.Client = void 0;
-		var events_1 = __importDefault(events);
+		var console_events_1 = __importDefault(console_events);
 		var client_1 = client;
 		Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
 		__exportStar(store, exports);
@@ -1624,7 +1995,12 @@
 		exports.Util = __importStar(util$1);
 		exports.Defaults = __importStar(defaults);
 		exports.Plugins = {
-		    events: events_1.default
+		    consoleEvents: console_events_1.default,
+		    /**
+		     * @deprecated Use `consoleEvents` instead. Kept as an alias for backwards
+		     * compatibility and will be removed in a future major version.
+		     */
+		    events: console_events_1.default,
 		};
 		
 	} (src));
@@ -2067,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.
@@ -2773,7 +3153,7 @@
 		var NOTIFIER = {
 		    name: '@honeybadger-io/js',
 		    url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/js',
-		    version: '6.15.3'
+		    version: '6.16.1'
 		};
 		var userAgent = function () {
 		    if (typeof navigator !== 'undefined') {
@@ -2788,7 +3168,7 @@
 		        (0, timers_1.default)(),
 		        (0, event_listeners_1.default)(),
 		        (0, breadcrumbs_1.default)(),
-		        core_1.Plugins.events(),
+		        core_1.Plugins.consoleEvents(),
 		    ]
 		});
 		singleton.setNotifier(NOTIFIER);