@honeybadger-io/js 6.15.3 → 6.16.1

package/dist/server/honeybadger.js

@@ -5,7 +5,8 @@ var require$$1$1 = require('domain');
 var require$$1 = require('fs');
 var require$$2 = require('path');
 var require$$3 = require('util');
-var require$$0$3 = require('url');
+var require$$0$3 = require('crypto');
+var require$$0$4 = require('url');
 var require$$3$1 = require('http');
 var require$$4 = require('https');
 
@@ -17,6 +18,7 @@ var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
 var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2);
 var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3);
 var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$3);
+var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$4);
 var require$$3__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$3$1);
 var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
 
@@ -51,7 +53,7 @@ var server$1 = {};
 
 var src = {};
 
-var events = {};
+var console_events = {};
 
 var util$1 = {};
 
@@ -258,7 +260,7 @@ var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(stackTraceParser_esm);
 	    }
 	};
 	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) {
@@ -434,6 +436,88 @@ var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(stackTraceParser_esm);
 	    };
 	}
 	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);
@@ -772,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;
@@ -854,7 +966,7 @@ var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(stackTraceParser_esm);
 	
 } (util$1));
 
-Object.defineProperty(events, "__esModule", { value: true });
+Object.defineProperty(console_events, "__esModule", { value: true });
 var util_1$8 = util$1;
 function default_1$3(_window) {
     if (_window === void 0) { _window = (0, util_1$8.globalThisOrWindow)(); }
@@ -862,7 +974,7 @@ function default_1$3(_window) {
         shouldReloadOnConfigure: false,
         load: function (client) {
             function sendEventsToInsights() {
-                return client.config.eventsEnabled;
+                return (0, util_1$8.resolveInsights)(client.config).console;
             }
             if (!sendEventsToInsights()) {
                 return;
@@ -889,7 +1001,7 @@ function default_1$3(_window) {
         }
     };
 }
-events.default = default_1$3;
+console_events.default = default_1$3;
 
 var client$1 = {};
 
@@ -911,11 +1023,21 @@ 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 || {});
     };
+    GlobalStore.prototype.setEventContext = function (eventContext) {
+        this.contents.eventContext = (0, util_1$7.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();
@@ -924,6 +1046,7 @@ var GlobalStore = /** @class */ (function () {
     };
     GlobalStore.prototype.clear = function () {
         this.contents.context = {};
+        this.contents.eventContext = {};
         this.contents.breadcrumbs = [];
     };
     GlobalStore.prototype.run = function (callback) {
@@ -933,7 +1056,7 @@ var GlobalStore = /** @class */ (function () {
 }());
 store.GlobalStore = GlobalStore;
 
-var throttled_events_logger = {};
+var throttled_events_worker = {};
 
 class NdJson {
     static parse(data) {
@@ -968,8 +1091,18 @@ defaults.CONFIG = {
     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,
@@ -1032,72 +1165,179 @@ var __generator$4 = (commonjsGlobal && commonjsGlobal.__generator) || function (
         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$6 = 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$4(this, void 0, void 0, function () {
+            return __generator$4(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());
     };
-    ThrottledEventsLogger.prototype.send = function () {
+    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();
+        }
+    };
+    ThrottledEventsWorker.prototype.clearCooldownTimer = function () {
+        if (this.cooldownTimer) {
+            clearTimeout(this.cooldownTimer);
+            this.cooldownTimer = null;
+        }
+    };
+    ThrottledEventsWorker.prototype.send = function () {
         return __awaiter$4(this, void 0, void 0, function () {
             var eventsData, data;
             return __generator$4(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$4(this, void 0, void 0, function () {
             var _this = this;
             return __generator$4(this, function (_a) {
@@ -1112,10 +1352,13 @@ var ThrottledEventsLogger = /** @class */ (function () {
                         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));
@@ -1126,28 +1369,40 @@ var ThrottledEventsLogger = /** @class */ (function () {
     /**
      * 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) {
@@ -1200,7 +1455,7 @@ Object.defineProperty(client$1, "__esModule", { value: true });
 client$1.Client = void 0;
 var util_1$5 = 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+/;
@@ -1212,17 +1467,20 @@ var Client = /** @class */ (function () {
         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$5.logger)(this);
+        this.__applyEventsEnabledShim(opts);
     }
     Client.prototype.getVersion = function () {
         return this.__notifier.version;
@@ -1245,10 +1503,24 @@ var Client = /** @class */ (function () {
         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
@@ -1258,12 +1530,16 @@ var Client = /** @class */ (function () {
         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;
@@ -1274,6 +1550,16 @@ var Client = /** @class */ (function () {
         }
         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();
@@ -1286,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.
@@ -1326,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
@@ -1354,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) {
@@ -1428,19 +1761,59 @@ var Client = /** @class */ (function () {
         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$5.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$5.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$3(this, void 0, void 0, function () {
+            return __generator$3(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();
@@ -1632,7 +2005,7 @@ Object.defineProperty(types, "__esModule", { value: true });
 	};
 	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$1;
 	Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
 	__exportStar(store, exports);
@@ -1640,7 +2013,12 @@ Object.defineProperty(types, "__esModule", { value: true });
 	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));
@@ -1802,8 +2180,145 @@ var uncaught_exception_monitor = {};
 
 var aws_lambda = {};
 
+var http_event = {};
+
+/**
+ * Shared helpers for HTTP-event instrumentation.
+ *
+ * Used by inbound (Express, Fastify, Lambda, Next.js) and — in a later PR —
+ * outbound (`http`, `https`, `fetch`) integrations.
+ */
+Object.defineProperty(http_event, "__esModule", { value: true });
+http_event.buildRequestEventPayload = http_event.durationMs = http_event.startTimer = http_event.seedRequestEventContext = http_event.getOrCreateCorrelationId = http_event.getOrCreateRequestId = void 0;
+var crypto_1 = require$$0__default$1["default"];
+/**
+ * Reads a header value from a Node-style headers bag in a case-insensitive
+ * manner. When the value is an array (e.g. `Set-Cookie`), returns the first
+ * element. Returns `undefined` when the header is missing or empty.
+ */
+function readHeader(headers, name) {
+    if (!headers)
+        return undefined;
+    var lower = name.toLowerCase();
+    var value = headers[lower];
+    if (value === undefined) {
+        for (var _i = 0, _a = Object.keys(headers); _i < _a.length; _i++) {
+            var key = _a[_i];
+            if (key.toLowerCase() === lower) {
+                value = headers[key];
+                break;
+            }
+        }
+    }
+    if (Array.isArray(value))
+        value = value[0];
+    if (typeof value !== 'string')
+        return undefined;
+    var trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+/**
+ * Generates a UUID-like identifier. Prefers Node's `crypto.randomUUID()` when
+ * available (Node 14.17+); falls back to a Math.random-based v4-shaped string
+ * for older Node versions.
+ */
+function generateId() {
+    if (typeof crypto_1.randomUUID === 'function') {
+        try {
+            return (0, crypto_1.randomUUID)();
+        }
+        catch (_e) {
+            // fall through to manual generation
+        }
+    }
+    // v4-shaped, not crypto-quality. Acceptable since this is a correlation id,
+    // not a security token.
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (ch) {
+        var r = (Math.random() * 16) | 0;
+        var v = ch === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * Returns a unique-per-request id. Reads `x-request-id`, then `request-id`
+ * headers; falls back to a generated id when neither is present.
+ */
+function getOrCreateRequestId(headers) {
+    var _a, _b;
+    return ((_b = (_a = readHeader(headers, 'x-request-id')) !== null && _a !== void 0 ? _a : readHeader(headers, 'request-id')) !== null && _b !== void 0 ? _b : generateId());
+}
+http_event.getOrCreateRequestId = getOrCreateRequestId;
+/**
+ * Returns a correlation id that may span multiple requests in a logical trace.
+ * Reads `x-correlation-id`, then `x-amzn-trace-id`; falls back to the supplied
+ * `requestId` so callers always have both fields populated.
+ */
+function getOrCreateCorrelationId(headers, requestId) {
+    var _a, _b;
+    return ((_b = (_a = readHeader(headers, 'x-correlation-id')) !== null && _a !== void 0 ? _a : readHeader(headers, 'x-amzn-trace-id')) !== null && _b !== void 0 ? _b : requestId);
+}
+http_event.getOrCreateCorrelationId = getOrCreateCorrelationId;
+/**
+ * Convenience helper for framework integrations: read request/correlation ids
+ * from the request headers and return both. When no headers contain either
+ * value, both ids are generated and `requestId === correlationId`.
+ */
+function seedRequestEventContext(headers) {
+    var requestId = getOrCreateRequestId(headers);
+    var correlationId = getOrCreateCorrelationId(headers, requestId);
+    return { request_id: requestId, correlation_id: correlationId };
+}
+http_event.seedRequestEventContext = seedRequestEventContext;
+/**
+ * Starts a high-resolution timer.
+ */
+function startTimer() {
+    return process.hrtime.bigint();
+}
+http_event.startTimer = startTimer;
+var NS_PER_MS = BigInt(1000000);
+/**
+ * Returns the integer number of milliseconds elapsed since `start`.
+ */
+function durationMs(start) {
+    var diff = process.hrtime.bigint() - start;
+    return Number(diff / NS_PER_MS);
+}
+http_event.durationMs = durationMs;
+/**
+ * Builds the per-request event payload. `request_id` and `correlation_id` are
+ * NOT added here — they live on `eventContext` and are merged onto every event
+ * by the client.
+ */
+function buildRequestEventPayload(input) {
+    var payload = {};
+    if (input.method !== undefined)
+        payload.method = input.method;
+    if (input.path !== undefined)
+        payload.path = input.path;
+    if (input.route !== undefined)
+        payload.route = input.route;
+    if (input.status !== undefined)
+        payload.status = input.status;
+    if (input.duration !== undefined)
+        payload.duration = input.duration;
+    if (input.extra) {
+        for (var _i = 0, _a = Object.keys(input.extra); _i < _a.length; _i++) {
+            var k = _a[_i];
+            if (!Object.prototype.hasOwnProperty.call(payload, k)) {
+                payload[k] = input.extra[k];
+            }
+        }
+    }
+    return payload;
+}
+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$5 = src;
+var http_event_1$1 = http_event;
 function isHandlerSync(handler) {
     return handler.length > 2;
 }
@@ -1815,28 +2330,132 @@ function reportToHoneybadger(hb, err, callback) {
         }
     });
 }
+// Detects inbound HTTP Lambda events (API Gateway v1 REST, API Gateway v2 HTTP, and ALB).
+// API Gateway v1 and ALB carry `httpMethod` at the top level; API Gateway v2 nests
+// method under `requestContext.http`.
+function isHttpLambdaEvent(event) {
+    if (!event || typeof event !== 'object') {
+        return false;
+    }
+    var e = event;
+    if (typeof e.httpMethod === 'string') {
+        return true;
+    }
+    var rc = e.requestContext;
+    var http = rc && rc.http;
+    return !!(http && typeof http.method === 'string');
+}
+function getLambdaMethod(event) {
+    if (!event || typeof event !== 'object') {
+        return undefined;
+    }
+    var e = event;
+    if (typeof e.httpMethod === 'string') {
+        return e.httpMethod;
+    }
+    var rc = e.requestContext;
+    var http = rc && rc.http;
+    if (http && typeof http.method === 'string') {
+        return http.method;
+    }
+    return undefined;
+}
+function getLambdaPath(event) {
+    if (!event || typeof event !== 'object') {
+        return undefined;
+    }
+    var e = event;
+    var rc = e.requestContext;
+    var http = rc && rc.http;
+    if (http && typeof http.path === 'string') {
+        return http.path;
+    }
+    if (typeof e.rawPath === 'string') {
+        return e.rawPath;
+    }
+    if (typeof e.path === 'string') {
+        return e.path;
+    }
+    return undefined;
+}
+function lambdaStatus(result) {
+    if (result && typeof result === 'object') {
+        var status_1 = result.statusCode;
+        if (typeof status_1 === 'number')
+            return status_1;
+    }
+    return 200;
+}
+function getLambdaHeaders(event) {
+    if (!event || typeof event !== 'object')
+        return {};
+    var headers = event.headers;
+    if (!headers || typeof headers !== 'object')
+        return {};
+    return headers;
+}
+function seedLambdaEventContext(hb, event, context) {
+    if (isHttpLambdaEvent(event)) {
+        hb.setEventContext((0, http_event_1$1.seedRequestEventContext)(getLambdaHeaders(event)));
+        return;
+    }
+    // Non-HTTP triggers (SQS, S3, EventBridge, scheduled) have no inbound headers.
+    // Use the AWS request id as the request_id, and X-Ray's trace id (if set) as
+    // the correlation_id, otherwise mirror request_id.
+    var requestId = context.awsRequestId;
+    var correlationId = process.env._X_AMZN_TRACE_ID || requestId;
+    hb.setEventContext({ request_id: requestId, correlation_id: correlationId });
+}
+// Returns an emitter for the `request.handled` event, or null when HTTP
+// instrumentation is off (nothing to emit). The emitter also owns delivery:
+// Lambda may freeze the execution environment the moment the handler completes,
+// so after recording the event it flushes the queue and returns that promise.
+// Callers must await it before resolving/invoking the callback. Delivery failures
+// are logged by the events worker and must not break the handler.
+function createLambdaRequestEmitter(hb, event) {
+    if (!isHttpLambdaEvent(event))
+        return null;
+    if (!core_1$5.Util.resolveInsights(hb.config).http)
+        return null;
+    var start = (0, http_event_1$1.startTimer)();
+    var emitted = false;
+    return function emit(status) {
+        if (emitted)
+            return Promise.resolve();
+        emitted = true;
+        hb.event('request.handled', (0, http_event_1$1.buildRequestEventPayload)({
+            method: getLambdaMethod(event),
+            path: getLambdaPath(event),
+            status: status,
+            duration: (0, http_event_1$1.durationMs)(start),
+        }));
+        return hb.flushAsync().catch(function () { });
+    };
+}
 function asyncHandler(handler, hb) {
     return function wrappedLambdaHandler(event, context) {
         return new Promise(function (resolve, reject) {
             hb.run(function () {
+                seedLambdaEventContext(hb, event, context);
+                var emit = createLambdaRequestEmitter(hb, event);
                 var timeoutHandler = setupTimeoutWarning(hb, context);
                 try {
-                    var result = handler(event, context);
+                    var result_1 = handler(event, context);
                     // check if handler returns a promise
-                    if (result && result.then) {
-                        result
-                            .then(resolve)
-                            .catch(function (err) { return reportToHoneybadger(hb, err, reject); })
+                    if (result_1 && result_1.then) {
+                        result_1
+                            .then(function (value) { return Promise.resolve(emit === null || emit === void 0 ? void 0 : emit(lambdaStatus(value))).then(function () { return resolve(value); }); })
+                            .catch(function (err) { return Promise.resolve(emit === null || emit === void 0 ? void 0 : emit(500)).then(function () { return reportToHoneybadger(hb, err, reject); }); })
                             .finally(function () { return clearTimeout(timeoutHandler); });
                     }
                     else {
                         clearTimeout(timeoutHandler);
-                        resolve(result);
+                        Promise.resolve(emit === null || emit === void 0 ? void 0 : emit(lambdaStatus(result_1))).then(function () { return resolve(result_1); });
                     }
                 }
                 catch (err) {
                     clearTimeout(timeoutHandler);
-                    reportToHoneybadger(hb, err, reject);
+                    Promise.resolve(emit === null || emit === void 0 ? void 0 : emit(500)).then(function () { return reportToHoneybadger(hb, err, reject); });
                 }
             });
         });
@@ -1845,19 +2464,22 @@ function asyncHandler(handler, hb) {
 function syncHandler(handler, hb) {
     return function wrappedLambdaHandler(event, context, cb) {
         hb.run(function () {
+            seedLambdaEventContext(hb, event, context);
+            var emit = createLambdaRequestEmitter(hb, event);
             var timeoutHandler = setupTimeoutWarning(hb, context);
             try {
                 handler(event, context, function (error, result) {
                     clearTimeout(timeoutHandler);
                     if (error) {
-                        return reportToHoneybadger(hb, error, cb);
+                        Promise.resolve(emit === null || emit === void 0 ? void 0 : emit(500)).then(function () { return reportToHoneybadger(hb, error, cb); });
+                        return;
                     }
-                    cb(null, result);
+                    Promise.resolve(emit === null || emit === void 0 ? void 0 : emit(lambdaStatus(result))).then(function () { return cb(null, result); });
                 });
             }
             catch (err) {
                 clearTimeout(timeoutHandler);
-                reportToHoneybadger(hb, err, cb);
+                Promise.resolve(emit === null || emit === void 0 ? void 0 : emit(500)).then(function () { return reportToHoneybadger(hb, err, cb); });
             }
         });
     };
@@ -2130,6 +2752,7 @@ var ShutdownMonitor = /** @class */ (function () {
     function ShutdownMonitor() {
         this.__isReporting = false;
         this.__listener = this.makeListener();
+        this.__beforeExitListener = this.makeBeforeExitListener();
     }
     ShutdownMonitor.prototype.setClient = function (client) {
         this.__client = client;
@@ -2158,6 +2781,35 @@ var ShutdownMonitor = /** @class */ (function () {
         }); };
         return honeybadgerShutdownListener;
     };
+    // `beforeExit` fires when the event loop drains and the process is about to
+    // exit on its own — a natural exit, which the SIGTERM/SIGINT listeners above do
+    // *not* cover. We flush any queued events (e.g. batched Insights events whose
+    // cooldown timer is unref'd and therefore won't hold the process open) so they
+    // aren't dropped on the way out. Unlike the signal path we don't force-exit;
+    // flushing schedules real I/O, which keeps the process alive until delivery, and
+    // then Node exits naturally. The `__isReporting` guard stops the flush's own I/O
+    // from re-triggering us.
+    ShutdownMonitor.prototype.makeBeforeExitListener = function () {
+        var _this = this;
+        // noinspection UnnecessaryLocalVariableJS
+        var honeybadgerBeforeExitListener = function () { return __awaiter$1(_this, void 0, void 0, function () {
+            return __generator$1(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.__isReporting || !this.__client) {
+                            return [2 /*return*/];
+                        }
+                        this.__isReporting = true;
+                        return [4 /*yield*/, this.__client.flushAsync()];
+                    case 1:
+                        _a.sent();
+                        this.__isReporting = false;
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        return honeybadgerBeforeExitListener;
+    };
     ShutdownMonitor.prototype.maybeAddListener = function () {
         for (var _i = 0, _a = ShutdownMonitor.KILL_SIGNALS; _i < _a.length; _i++) {
             var signal = _a[_i];
@@ -2166,6 +2818,10 @@ var ShutdownMonitor = /** @class */ (function () {
                 process.on(signal, this.__listener);
             }
         }
+        var beforeExitListeners = process.listeners('beforeExit') || [];
+        if (!beforeExitListeners.includes(this.__beforeExitListener)) {
+            process.on('beforeExit', this.__beforeExitListener);
+        }
     };
     ShutdownMonitor.prototype.maybeRemoveListener = function () {
         for (var _i = 0, _a = ShutdownMonitor.KILL_SIGNALS; _i < _a.length; _i++) {
@@ -2175,6 +2831,10 @@ var ShutdownMonitor = /** @class */ (function () {
                 process.removeListener(signal, this.__listener);
             }
         }
+        var beforeExitListeners = process.listeners('beforeExit') || [];
+        if (beforeExitListeners.includes(this.__beforeExitListener)) {
+            process.removeListener('beforeExit', this.__beforeExitListener);
+        }
     };
     ShutdownMonitor.prototype.hasOtherShutdownListeners = function (signal) {
         var _this = this;
@@ -2199,14 +2859,9 @@ function default_1() {
     return {
         load: function (client) {
             shutdownMonitor.setClient(client);
-            // at the moment, the shutdown monitor only sends events from the queue
-            // if we implement a queue for throttling errors, we won't have to check for `config.eventsEnabled`
-            if (client.config.eventsEnabled) {
-                shutdownMonitor.maybeAddListener();
-            }
-            else {
-                shutdownMonitor.maybeRemoveListener();
-            }
+            // programmatic events can be queued at any time, so the flush listener
+            // is always registered
+            shutdownMonitor.maybeAddListener();
         },
         shouldReloadOnConfigure: true,
     };
@@ -2220,7 +2875,9 @@ 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$1["default"]);
+var url_1$1 = __importDefault(require$$0__default$2["default"]);
+var core_1$4 = src;
+var http_event_1 = http_event;
 function fullUrl(req) {
     var connection = req.connection;
     var address = connection && connection.address();
@@ -2235,8 +2892,43 @@ function fullUrl(req) {
         query: req.query
     });
 }
+function instrumentInboundRequest(client, req, res) {
+    // Completion is observed via response events, which requires a Node
+    // ServerResponse. A non-EventEmitter response (e.g. a FastifyReply when this
+    // middleware is mistakenly registered as a fastify preHandler) would break
+    // every request — degrade to "no request event" instead. Fastify users
+    // should register fastifyPlugin() from server/fastify.
+    if (typeof res.once !== 'function') {
+        client.logger.debug('skipping insights instrumentation for http requests: response object is not an EventEmitter and does not have a .once() hook');
+        return;
+    }
+    var start = (0, http_event_1.startTimer)();
+    var emitted = false;
+    var emit = function () {
+        var _a;
+        if (emitted)
+            return;
+        emitted = true;
+        client.event('request.handled', (0, http_event_1.buildRequestEventPayload)({
+            method: req.method,
+            path: req.path,
+            route: (_a = req.route) === null || _a === void 0 ? void 0 : _a.path,
+            status: res.statusCode,
+            duration: (0, http_event_1.durationMs)(start),
+        }));
+    };
+    res.once('finish', emit);
+    res.once('close', emit);
+}
 function requestHandler(req, res, next) {
-    this.withRequest(req, next, next);
+    var _this = this;
+    this.withRequest(req, function () {
+        _this.setEventContext((0, http_event_1.seedRequestEventContext)(req.headers));
+        if (core_1$4.Util.resolveInsights(_this.config).http) {
+            instrumentInboundRequest(_this, req, res);
+        }
+        next();
+    }, next);
 }
 middleware.requestHandler = requestHandler;
 function errorHandler(err, req, _res, next) {
@@ -2294,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 url_1 = require$$0__default$1["default"];
+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 = {}; }
@@ -2375,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) {
@@ -2405,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();
@@ -2413,6 +3110,12 @@ var AsyncStore = /** @class */ (function () {
     AsyncStore.prototype.setContext = function (context) {
         Object.assign(this.__currentContents().context, context || {});
     };
+    AsyncStore.prototype.setEventContext = function (eventContext) {
+        Object.assign(this.__currentContents().eventContext, eventContext || {});
+    };
+    AsyncStore.prototype.clearEventContext = function () {
+        this.__currentContents().eventContext = {};
+    };
     AsyncStore.prototype.addBreadcrumb = function (breadcrumb) {
         if (this.__currentContents().breadcrumbs.length == this.breadcrumbsLimit) {
             this.__currentContents().breadcrumbs.shift();
@@ -2421,6 +3124,7 @@ var AsyncStore = /** @class */ (function () {
     };
     AsyncStore.prototype.clear = function () {
         this.__currentContents().context = {};
+        this.__currentContents().eventContext = {};
         this.__currentContents().breadcrumbs = [];
     };
     AsyncStore.prototype.run = function (callback, request) {
@@ -2457,7 +3161,7 @@ var async_store_1 = async_store;
  */
 var StackedStore = /** @class */ (function () {
     function StackedStore(breadcrumbsLimit) {
-        this.contents = { context: {}, breadcrumbs: [] };
+        this.contents = { context: {}, eventContext: {}, breadcrumbs: [] };
         this.asyncStore = async_store_1.AsyncStore.create(this.contents, breadcrumbsLimit);
         this.globalStore = core_1$1.GlobalStore.create(this.contents, breadcrumbsLimit);
     }
@@ -2475,6 +3179,12 @@ var StackedStore = /** @class */ (function () {
     StackedStore.prototype.setContext = function (context) {
         this.__activeStore().setContext(context);
     };
+    StackedStore.prototype.setEventContext = function (eventContext) {
+        this.__activeStore().setEventContext(eventContext);
+    };
+    StackedStore.prototype.clearEventContext = function () {
+        this.__activeStore().clearEventContext();
+    };
     StackedStore.prototype.addBreadcrumb = function (breadcrumb) {
         this.__activeStore().addBreadcrumb(breadcrumb);
     };
@@ -3121,7 +3831,7 @@ client.CheckInsClient = CheckInsClient;
 	    (0, uncaught_exception_plugin_1.default)(),
 	    (0, unhandled_rejection_plugin_1.default)(),
 	    (0, shutdown_plugin_1.default)(),
-	    core_1.Plugins.events(),
+	    core_1.Plugins.consoleEvents(),
 	];
 	var Honeybadger = /** @class */ (function (_super) {
 	    __extends(Honeybadger, _super);
@@ -3279,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.15.3'
+	    version: '6.16.1'
 	};
 	var userAgent = function () {
 	    return "Honeybadger JS Server Client ".concat(NOTIFIER.version, ", ").concat(os_1.default.version(), "; ").concat(os_1.default.platform());