@honeybadger-io/js 6.16.3 → 6.16.5

package/dist/server/fastify.js

@@ -1455,7 +1455,7 @@ var Client = /** @class */ (function () {
         this.__notifier = {
             name: '@honeybadger-io/core',
             url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/core',
-            version: '6.16.3'
+            version: '6.16.5'
         };
         this.config = __assign(__assign({}, defaults_1.CONFIG), opts);
         this.__initStore();

package/dist/server/honeybadger.js

@@ -1473,7 +1473,7 @@ var Client = /** @class */ (function () {
         this.__notifier = {
             name: '@honeybadger-io/core',
             url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/core',
-            version: '6.16.3'
+            version: '6.16.5'
         };
         this.config = __assign$1(__assign$1({}, defaults_1.CONFIG), opts);
         this.__initStore();
@@ -2883,12 +2883,14 @@ function fullUrl(req) {
     var address = connection && connection.address();
     // @ts-ignore The old @types/node incorrectly defines `address` as string|Address
     var port = address ? address.port : undefined;
-    // @ts-ignore
     return url_1$1.default.format({
         protocol: req.protocol,
         hostname: req.hostname,
         port: port,
         pathname: req.path,
+        // Express types `query` as `ParsedQs`, which permits arbitrarily nested objects, while
+        // `url.format` accepts `ParsedUrlQueryInput`. The two agree for the flat values a real
+        // query string produces, and `format` stringifies anything deeper either way.
         query: req.query
     });
 }
@@ -3745,6 +3747,104 @@ client.CheckInsClient = CheckInsClient;
 	
 } (checkInsManager));
 
+var globalSingleton = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getOrCreateSingleton = exports.singletonKey = exports.DISABLE_GLOBAL_SINGLETON_KEY = void 0;
+	var core_1 = src;
+	/**
+	 * Set this on the global object before the package is loaded to opt out of sharing.
+	 * Two independently bundled copies on one page then keep their own clients, the way
+	 * they did before the singleton was shared.
+	 */
+	exports.DISABLE_GLOBAL_SINGLETON_KEY = '__HONEYBADGER_DISABLE_GLOBAL_SINGLETON__';
+	/**
+	 * Stamped on the client when it is stored, and required when it is read back, so the slot
+	 * is only ever trusted when this package wrote it. Duck typing would not do: a value that
+	 * happens to carry a `notify` method would be handed out as the client.
+	 */
+	var CLIENT_MARKER = '__honeybadger_client__';
+	function singletonKey(target, version) {
+	    return "__honeybadger_singleton_".concat(target, "_").concat(version, "__");
+	}
+	exports.singletonKey = singletonKey;
+	function isSingleton(value) {
+	    return !!value && value[CLIENT_MARKER] === true;
+	}
+	function markAsSingleton(client) {
+	    Object.defineProperty(client, CLIENT_MARKER, {
+	        value: true,
+	        writable: false,
+	        configurable: true,
+	        enumerable: false,
+	    });
+	}
+	/**
+	 * Returns the client stored on the global object, creating and storing it the first time.
+	 *
+	 * Bundlers can emit more than one copy of this module — Next.js compiles the
+	 * instrumentation, page-rendering and edge contexts into separate module graphs — and
+	 * each copy would otherwise build its own client. Only the copy the configuration code
+	 * ran in would be configured, so a `Honeybadger.notify()` made through any other copy
+	 * would silently do nothing. Keeping the instance on the realm's global object lets every
+	 * copy find the same configured client.
+	 *
+	 * The slot is keyed by build target and by exact version: an older copy must never be
+	 * handed to a newer caller that would then call a method it does not have. Two different
+	 * versions in one realm fall back to one client each, which is the behaviour that shipped
+	 * before the singleton was shared.
+	 */
+	function getOrCreateSingleton(target, version, create, _global) {
+	    if (_global === void 0) { _global = core_1.Util.globalThisOrWindow(); }
+	    if (!_global) {
+	        return create();
+	    }
+	    var key = singletonKey(target, version);
+	    var shared;
+	    var canShare = false;
+	    // Reading the global object can throw as easily as writing to it can: the opt-out
+	    // flag, the slot and the marker are all ordinary properties, and a host or another
+	    // script may have installed a getter on any of them. `create()` stays outside, so a
+	    // genuine failure to build the client still propagates.
+	    try {
+	        if (_global[exports.DISABLE_GLOBAL_SINGLETON_KEY] !== true) {
+	            canShare = true;
+	            var existing = _global[key];
+	            if (isSingleton(existing)) {
+	                shared = existing;
+	            }
+	        }
+	    }
+	    catch (_e) {
+	        canShare = false;
+	    }
+	    if (shared) {
+	        return shared;
+	    }
+	    var created = create();
+	    if (!canShare) {
+	        return created;
+	    }
+	    try {
+	        markAsSingleton(created);
+	        Object.defineProperty(_global, key, {
+	            value: created,
+	            writable: true,
+	            configurable: true,
+	            enumerable: false,
+	        });
+	    }
+	    catch (_e) {
+	        // A frozen global object (node --frozen-intrinsics, SES lockdown). Importing this
+	        // package must never throw, so this copy keeps the client to itself.
+	    }
+	    return created;
+	}
+	exports.getOrCreateSingleton = getOrCreateSingleton;
+	
+} (globalSingleton));
+
 (function (exports) {
 	var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
 	    var extendStatics = function (d, b) {
@@ -3811,7 +3911,6 @@ client.CheckInsClient = CheckInsClient;
 	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
 	    return (mod && mod.__esModule) ? mod : { "default": mod };
 	};
-	var _a;
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.CheckIn = exports.Types = void 0;
 	var os_1 = __importDefault(require$$0__default["default"]);
@@ -3826,6 +3925,7 @@ client.CheckInsClient = CheckInsClient;
 	var transport_1 = transport;
 	var stacked_store_1 = stacked_store;
 	var check_ins_manager_1 = checkInsManager;
+	var global_singleton_1 = globalSingleton;
 	var endpoint = core_1.Util.endpoint;
 	var DEFAULT_PLUGINS = [
 	    (0, uncaught_exception_plugin_1.default)(),
@@ -3989,13 +4089,17 @@ client.CheckInsClient = CheckInsClient;
 	var NOTIFIER = {
 	    name: '@honeybadger-io/js',
 	    url: 'https://github.com/honeybadger-io/honeybadger-js/tree/master/packages/js',
-	    version: '6.16.3'
+	    version: '6.16.5'
 	};
 	var userAgent = function () {
 	    return "Honeybadger JS Server Client ".concat(NOTIFIER.version, ", ").concat(os_1.default.version(), "; ").concat(os_1.default.platform());
 	};
-	var singleton = new Honeybadger(__assign({ __plugins: DEFAULT_PLUGINS }, ((_a = (0, util_1.readConfigFromFileSystem)()) !== null && _a !== void 0 ? _a : {})));
-	singleton.setNotifier(NOTIFIER);
+	var singleton = (0, global_singleton_1.getOrCreateSingleton)('server', NOTIFIER.version, function () {
+	    var _a;
+	    var client = new Honeybadger(__assign({ __plugins: DEFAULT_PLUGINS }, ((_a = (0, util_1.readConfigFromFileSystem)()) !== null && _a !== void 0 ? _a : {})));
+	    client.setNotifier(NOTIFIER);
+	    return client;
+	});
 	var core_2 = src;
 	Object.defineProperty(exports, "Types", { enumerable: true, get: function () { return core_2.Types; } });
 	var check_in_1 = requireCheckIn();