@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/cjs/tools/instrumentMethod.js

@@ -1,118 +1,185 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.instrumentMethod = instrumentMethod;
-exports.instrumentSetter = instrumentSetter;
-const timer_1 = require("./timer");
-const monitor_1 = require("./monitor");
-const functionUtils_1 = require("./utils/functionUtils");
-const handlingStack_1 = require("./stackTrace/handlingStack");
+const require_timer = require("./timer.js");
+const require_functionUtils = require("./utils/functionUtils.js");
+const require_handlingStack = require("./stackTrace/handlingStack.js");
+let _kubesense_kubesense_js_core_monitor = require("@kubesense/kubesense-js-core/monitor");
+//#region src/tools/instrumentMethod.ts
 /**
- * Instruments a method on a object, calling the given callback before the original method is
- * invoked. The callback receives an object with information about the method call.
- *
- * This function makes sure that we are "good citizens" regarding third party instrumentations: when
- * removing the instrumentation, the original method is usually restored, but if a third party
- * instrumentation was set after ours, we keep it in place and just replace our instrumentation with
- * a noop.
- *
- * Note: it is generally better to instrument methods that are "owned" by the object instead of ones
- * that are inherited from the prototype chain. Example:
- * * do:    `instrumentMethod(Array.prototype, 'push', ...)`
- * * don't: `instrumentMethod([], 'push', ...)`
- *
- * This method is also used to set event handler properties (ex: window.onerror = ...), as it has
- * the same requirements as instrumenting a method:
- * * if the event handler is already set by a third party, we need to call it and not just blindly
- * override it.
- * * if the event handler is set by a third party after us, we need to keep it in place when
- * removing ours.
- *
- * @example
- *
- *  instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {
- *    console.log('Before calling fetch on', target, 'with parameters', parameters)
- *
- *    onPostCall((result) => {
- *      console.log('After fetch calling on', target, 'with parameters', parameters, 'and result', result)
- *    })
- *  })
- */
+* Instruments a method on a object, calling the given callback before the original method is
+* invoked. The callback receives an object with information about the method call.
+*
+* This function makes sure that we are "good citizens" regarding third party instrumentations: when
+* removing the instrumentation, the original method is usually restored, but if a third party
+* instrumentation was set after ours, we keep it in place and just replace our instrumentation with
+* a noop.
+*
+* Note: it is generally better to instrument methods that are "owned" by the object instead of ones
+* that are inherited from the prototype chain. Example:
+* * do:    `instrumentMethod(Array.prototype, 'push', ...)`
+* * don't: `instrumentMethod([], 'push', ...)`
+*
+* This method is also used to set event handler properties (ex: window.onerror = ...), as it has
+* the same requirements as instrumenting a method:
+* * if the event handler is already set by a third party, we need to call it and not just blindly
+* override it.
+* * if the event handler is set by a third party after us, we need to keep it in place when
+* removing ours.
+*
+* To instrument a constructor @see {@link instrumentConstructor}.
+*
+* @example
+*
+*  instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {
+*    console.log('Before calling fetch on', target, 'with parameters', parameters)
+*
+*    onPostCall((result) => {
+*      console.log('After fetch calling on', target, 'with parameters', parameters, 'and result', result)
+*    })
+*  })
+*/
 function instrumentMethod(targetPrototype, method, onPreCall, { computeHandlingStack } = {}) {
-    let original = targetPrototype[method];
-    if (typeof original !== 'function') {
-        if (method in targetPrototype && typeof method === 'string' && method.startsWith('on')) {
-            original = functionUtils_1.noop;
-        }
-        else {
-            return { stop: functionUtils_1.noop };
-        }
-    }
-    let stopped = false;
-    const instrumentation = function () {
-        if (stopped) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
-            return original.apply(this, arguments);
-        }
-        const parameters = Array.from(arguments);
-        let postCallCallback;
-        (0, monitor_1.callMonitored)(onPreCall, null, [
-            {
-                target: this,
-                parameters,
-                onPostCall: (callback) => {
-                    postCallCallback = callback;
-                },
-                handlingStack: computeHandlingStack ? (0, handlingStack_1.createHandlingStack)('instrumented method') : undefined,
-            },
-        ]);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        const result = original.apply(this, parameters);
-        if (postCallCallback) {
-            (0, monitor_1.callMonitored)(postCallCallback, null, [result]);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return result;
-    };
-    targetPrototype[method] = instrumentation;
-    return {
-        stop: () => {
-            stopped = true;
-            // If the instrumentation has been removed by a third party, keep the last one
-            if (targetPrototype[method] === instrumentation) {
-                targetPrototype[method] = original;
-            }
-        },
-    };
+	let original = targetPrototype[method];
+	if (typeof original !== "function") {
+		if (method in targetPrototype && typeof method === "string" && method.startsWith("on")) original = require_functionUtils.noop;
+		else return { stop: require_functionUtils.noop };
+	}
+	let stopped = false;
+	const instrumentation = function() {
+		if (stopped) return original.apply(this, arguments);
+		const parameters = Array.from(arguments);
+		return notifyInstrumentation(onPreCall, {
+			target: this,
+			parameters,
+			handlingStack: computeHandlingStack ? require_handlingStack.createHandlingStack("instrumented method") : void 0
+		}, () => original.apply(this, parameters));
+	};
+	const { stop: restoreOriginal } = replaceWithInstrumentation(targetPrototype, method, original, instrumentation);
+	return { stop: () => {
+		stopped = true;
+		restoreOriginal();
+	} };
+}
+/**
+* Instruments a constructor on an object (typically a global, e.g. `window.WebSocket`), calling the
+* given callback before the original constructor is invoked. The callback receives an object with
+* information about the constructor call, and can register an `onPostCall` callback to be notified
+* with the constructed instance.
+*
+* Like `instrumentMethod`, this is a "good citizen" regarding third party instrumentations: stopping
+* restores the original constructor unless a third party replaced it afterwards.
+*
+* The wrapper preserves the original prototype (so `instanceof` keeps working), the original
+* `new.target` (so constructors that inspect it behave as if not instrumented), the original
+* static members (e.g. `WebSocket.OPEN`), and `instance.constructor ===` so checks like
+* `new WebSocket(url).constructor === WebSocket` stay true.
+*
+* @see {@link preserveConstructorShape} for limitations on static members preservation.
+* @example
+*
+*  instrumentConstructor(window, 'WebSocket', ({ parameters, onPostCall }) => {
+*    console.log('Before constructing WebSocket with parameters', parameters)
+*
+*    onPostCall((instance) => {
+*      console.log('Constructed WebSocket instance', instance)
+*    })
+*  })
+*/
+function instrumentConstructor(container, constructor, onPreCall, { computeHandlingStack } = {}) {
+	const original = container[constructor];
+	if (typeof original !== "function") return { stop: require_functionUtils.noop };
+	let stopped = false;
+	const instrumentation = function() {
+		if (!new.target) return Reflect.apply(original, this, Array.from(arguments));
+		const newTarget = new.target === instrumentation ? original : new.target;
+		if (stopped) return Reflect.construct(original, arguments, newTarget);
+		const parameters = Array.from(arguments);
+		return notifyInstrumentation(onPreCall, {
+			parameters,
+			handlingStack: computeHandlingStack ? require_handlingStack.createHandlingStack("instrumented constructor") : void 0
+		}, () => Reflect.construct(original, parameters, newTarget));
+	};
+	const restorePrototypeConstructor = preserveConstructorShape(instrumentation, original);
+	const { stop: restoreOriginal } = replaceWithInstrumentation(container, constructor, original, instrumentation);
+	return { stop: () => {
+		stopped = true;
+		restorePrototypeConstructor();
+		restoreOriginal();
+	} };
+}
+/**
+* Replaces `targetPrototype[method]` with the provided instrumentation and
+* returns a `stop` function restoring the original (unless a third party replaced us afterwards).
+*/
+function replaceWithInstrumentation(targetPrototype, method, original, instrumentation) {
+	targetPrototype[method] = instrumentation;
+	return { stop: () => {
+		if (targetPrototype[method] === instrumentation) targetPrototype[method] = original;
+	} };
+}
+/**
+* Runs the pre-call callback (injecting the `onPostCall` registration), invokes the original
+* method/constructor, then runs the registered post-call callback with the result.
+*
+* Note: the handling stack must be computed by the caller (at the topmost position of the call
+* stack), so it is part of `baseCallInfo` rather than computed here.
+*/
+function notifyInstrumentation(onPreCall, baseCallInfo, invokeOriginal) {
+	let postCallCallback;
+	(0, _kubesense_kubesense_js_core_monitor.callMonitored)(onPreCall, null, [{
+		...baseCallInfo,
+		onPostCall: (callback) => {
+			postCallCallback = callback;
+		}
+	}]);
+	const result = invokeOriginal();
+	if (postCallCallback) (0, _kubesense_kubesense_js_core_monitor.callMonitored)(postCallCallback, null, [result]);
+	return result;
+}
+/**
+* Copies the original constructor prototype and other static members onto the instrumentation, so that
+* `instanceof` checks keep working and statics such as `WebSocket.OPEN` remain available while
+* instrumented.
+*
+* Returns a function that restores `prototype.constructor` to its prior descriptor; call it
+* before restoring the global property in `stop()`.
+*/
+function preserveConstructorShape(instrumentation, original) {
+	/**
+	* Limitation: Only the original's *own* static members are copied. Statics inherited through the
+	* constructor's prototype chain (e.g. `class Child extends Parent` where `Parent` defines statics)
+	* are not preserved, since the instrumentation still inherits from `Function.prototype`. This is
+	* acceptable for the globals we instrument (e.g. `WebSocket`, whose own statics are the only ones
+	* that matter), but we would need to delegate the static prototype chain to support subclassed
+	* constructors with meaningful inherited statics.
+	*/
+	for (const key of [].concat(Object.getOwnPropertyNames(original), Object.getOwnPropertySymbols(original))) {
+		const descriptor = Object.getOwnPropertyDescriptor(original, key);
+		Object.defineProperty(instrumentation, key, descriptor);
+	}
+	const { stop: restoreOriginalConstructor } = replaceWithInstrumentation(original.prototype, "constructor", original.prototype.constructor, instrumentation);
+	return restoreOriginalConstructor;
 }
 function instrumentSetter(targetPrototype, property, after) {
-    const originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property);
-    if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {
-        return { stop: functionUtils_1.noop };
-    }
-    const stoppedInstrumentation = functionUtils_1.noop;
-    let instrumentation = (target, value) => {
-        // put hooked setter into event loop to avoid of set latency
-        (0, timer_1.setTimeout)(() => {
-            if (instrumentation !== stoppedInstrumentation) {
-                after(target, value);
-            }
-        }, 0);
-    };
-    const instrumentationWrapper = function (value) {
-        originalDescriptor.set.call(this, value);
-        instrumentation(this, value);
-    };
-    Object.defineProperty(targetPrototype, property, {
-        set: instrumentationWrapper,
-    });
-    return {
-        stop: () => {
-            var _a;
-            if (((_a = Object.getOwnPropertyDescriptor(targetPrototype, property)) === null || _a === void 0 ? void 0 : _a.set) === instrumentationWrapper) {
-                Object.defineProperty(targetPrototype, property, originalDescriptor);
-            }
-            instrumentation = stoppedInstrumentation;
-        },
-    };
+	const originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property);
+	if (!originalDescriptor?.set || !originalDescriptor.configurable) return { stop: require_functionUtils.noop };
+	const stoppedInstrumentation = require_functionUtils.noop;
+	let instrumentation = (target, value) => {
+		require_timer.setTimeout(() => {
+			if (instrumentation !== stoppedInstrumentation) after(target, value);
+		}, 0);
+	};
+	const instrumentationWrapper = function(value) {
+		originalDescriptor.set.call(this, value);
+		instrumentation(this, value);
+	};
+	Object.defineProperty(targetPrototype, property, { set: instrumentationWrapper });
+	return { stop: () => {
+		if (Object.getOwnPropertyDescriptor(targetPrototype, property)?.set === instrumentationWrapper) Object.defineProperty(targetPrototype, property, originalDescriptor);
+		instrumentation = stoppedInstrumentation;
+	} };
 }
+//#endregion
+exports.instrumentConstructor = instrumentConstructor;
+exports.instrumentMethod = instrumentMethod;
+exports.instrumentSetter = instrumentSetter;
+
 //# sourceMappingURL=instrumentMethod.js.map

package/cjs/tools/instrumentMethod.js.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentMethod.js","sourceRoot":"","sources":["../../src/tools/instrumentMethod.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"instrumentMethod.js","names":["noop","createHandlingStack"],"sources":["../../src/tools/instrumentMethod.ts"],"sourcesContent":["import { callMonitored } from '@kubesense/kubesense-js-core/monitor'\nimport { setTimeout } from './timer'\nimport { noop } from './utils/functionUtils'\nimport { createHandlingStack } from './stackTrace/handlingStack'\n\n/**\n * Object passed to the callback of an instrumented method call. See `instrumentMethod` for more\n * info.\n */\nexport interface InstrumentedMethodCall<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET> {\n  /**\n   * The target object on which the method was called.\n   */\n  target: TARGET\n\n  /**\n   * The parameters with which the method was called.\n   *\n   * Note: if needed, parameters can be mutated by the instrumentation\n   */\n  parameters: Parameters<TARGET[METHOD]>\n\n  /**\n   * Registers a callback that will be called after the original method is called, with the method\n   * result passed as argument.\n   */\n  onPostCall: (callback: PostCallCallback<TARGET, METHOD>) => void\n\n  /**\n   * The stack trace of the method call.\n   */\n  handlingStack?: string\n}\n\ntype PostCallCallback<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET> = (\n  result: ReturnType<TARGET[METHOD]>\n) => void\n\ntype ConstructorParametersOf<CONSTRUCTOR> = CONSTRUCTOR extends new (...args: infer P) => any ? P : never\ntype ConstructorInstanceOf<CONSTRUCTOR> = CONSTRUCTOR extends new (...args: any[]) => infer R ? R : never\n\ntype AnyConstructor = abstract new (...args: any[]) => any\n\n/**\n * Object passed to the callback of an instrumented constructor call. See `instrumentConstructor`\n * for more info.\n */\nexport interface InstrumentedConstructorCall<CONSTRUCTOR> {\n  /**\n   * The parameters with which the constructor was called.\n   *\n   * Note: if needed, parameters can be mutated by the instrumentation\n   */\n  parameters: ConstructorParametersOf<CONSTRUCTOR>\n\n  /**\n   * Registers a callback that will be called after the original constructor is called, with the\n   * constructed instance passed as argument.\n   */\n  onPostCall: (callback: (result: ConstructorInstanceOf<CONSTRUCTOR>) => void) => void\n\n  /**\n   * The stack trace of the constructor call.\n   */\n  handlingStack?: string\n}\n\n/**\n * Instruments a method on a object, calling the given callback before the original method is\n * invoked. The callback receives an object with information about the method call.\n *\n * This function makes sure that we are \"good citizens\" regarding third party instrumentations: when\n * removing the instrumentation, the original method is usually restored, but if a third party\n * instrumentation was set after ours, we keep it in place and just replace our instrumentation with\n * a noop.\n *\n * Note: it is generally better to instrument methods that are \"owned\" by the object instead of ones\n * that are inherited from the prototype chain. Example:\n * * do:    `instrumentMethod(Array.prototype, 'push', ...)`\n * * don't: `instrumentMethod([], 'push', ...)`\n *\n * This method is also used to set event handler properties (ex: window.onerror = ...), as it has\n * the same requirements as instrumenting a method:\n * * if the event handler is already set by a third party, we need to call it and not just blindly\n * override it.\n * * if the event handler is set by a third party after us, we need to keep it in place when\n * removing ours.\n *\n * To instrument a constructor @see {@link instrumentConstructor}.\n *\n * @example\n *\n *  instrumentMethod(window, 'fetch', ({ target, parameters, onPostCall }) => {\n *    console.log('Before calling fetch on', target, 'with parameters', parameters)\n *\n *    onPostCall((result) => {\n *      console.log('After fetch calling on', target, 'with parameters', parameters, 'and result', result)\n *    })\n *  })\n */\nexport function instrumentMethod<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET>(\n  targetPrototype: TARGET,\n  method: METHOD,\n  onPreCall: (this: null, callInfos: InstrumentedMethodCall<TARGET, METHOD>) => void,\n  { computeHandlingStack }: { computeHandlingStack?: boolean } = {}\n) {\n  let original = targetPrototype[method]\n\n  if (typeof original !== 'function') {\n    if (method in targetPrototype && typeof method === 'string' && method.startsWith('on')) {\n      original = noop as TARGET[METHOD]\n    } else {\n      return { stop: noop }\n    }\n  }\n\n  let stopped = false\n\n  const instrumentation = function (this: TARGET): ReturnType<TARGET[METHOD]> {\n    if (stopped) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call\n      return original.apply(this, arguments)\n    }\n\n    const parameters = Array.from(arguments) as Parameters<TARGET[METHOD]>\n\n    return notifyInstrumentation<InstrumentedMethodCall<TARGET, METHOD>, ReturnType<TARGET[METHOD]>>(\n      onPreCall,\n      {\n        target: this,\n        parameters,\n        handlingStack: computeHandlingStack ? createHandlingStack('instrumented method') : undefined,\n      },\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call -- TARGET[METHOD] is any under the index signature; value is verified as a function above\n      () => original.apply(this, parameters)\n    )\n  } as TARGET[METHOD]\n\n  const { stop: restoreOriginal } = replaceWithInstrumentation(targetPrototype, method, original, instrumentation)\n\n  return {\n    stop: () => {\n      stopped = true\n      restoreOriginal()\n    },\n  }\n}\n\n/**\n * Instruments a constructor on an object (typically a global, e.g. `window.WebSocket`), calling the\n * given callback before the original constructor is invoked. The callback receives an object with\n * information about the constructor call, and can register an `onPostCall` callback to be notified\n * with the constructed instance.\n *\n * Like `instrumentMethod`, this is a \"good citizen\" regarding third party instrumentations: stopping\n * restores the original constructor unless a third party replaced it afterwards.\n *\n * The wrapper preserves the original prototype (so `instanceof` keeps working), the original\n * `new.target` (so constructors that inspect it behave as if not instrumented), the original\n * static members (e.g. `WebSocket.OPEN`), and `instance.constructor ===` so checks like\n * `new WebSocket(url).constructor === WebSocket` stay true.\n *\n * @see {@link preserveConstructorShape} for limitations on static members preservation.\n * @example\n *\n *  instrumentConstructor(window, 'WebSocket', ({ parameters, onPostCall }) => {\n *    console.log('Before constructing WebSocket with parameters', parameters)\n *\n *    onPostCall((instance) => {\n *      console.log('Constructed WebSocket instance', instance)\n *    })\n *  })\n */\nexport function instrumentConstructor<CONTAINER extends { [key: string]: any }, CONSTRUCTOR extends keyof CONTAINER>(\n  container: CONTAINER,\n  constructor: CONSTRUCTOR,\n  onPreCall: (this: null, callInfos: InstrumentedConstructorCall<CONTAINER[CONSTRUCTOR]>) => void,\n  { computeHandlingStack }: { computeHandlingStack?: boolean } = {}\n) {\n  const original = container[constructor]\n\n  if (typeof original !== 'function') {\n    return { stop: noop }\n  }\n\n  let stopped = false\n\n  const instrumentation = function (this: unknown): ConstructorInstanceOf<CONTAINER[CONSTRUCTOR]> {\n    // Bare `[[Call]]` (no `new`): delegate through `[[Call]]` and skip `onPreCall`. Otherwise we\n    // would notify instrumentation before the original rejects or returns, unlike the native\n    // constructor (e.g. `WebSocket(url)` or `class {}()` without `new`).\n    if (!new.target) {\n      return Reflect.apply(original, this, Array.from(arguments)) as ConstructorInstanceOf<CONTAINER[CONSTRUCTOR]>\n    }\n\n    // When `new` is used on this instrumented property, `new.target` is this wrapper. Passing\n    // it through to Reflect.construct would expose the wrong new.target inside the original\n    // body. If a subclass extends the wrapper, or a third party wraps us and their class is\n    // instantiated, `new.target` is that outer constructor and must be preserved.\n    const newTarget = new.target === instrumentation ? original : new.target\n\n    if (stopped) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n      return Reflect.construct(\n        original,\n        arguments as unknown as ConstructorParametersOf<CONTAINER[CONSTRUCTOR]>,\n        newTarget\n      )\n    }\n\n    const parameters = Array.from(arguments) as ConstructorParametersOf<CONTAINER[CONSTRUCTOR]>\n\n    return notifyInstrumentation<\n      InstrumentedConstructorCall<CONTAINER[CONSTRUCTOR]>,\n      ConstructorInstanceOf<CONTAINER[CONSTRUCTOR]>\n    >(\n      onPreCall,\n      {\n        parameters,\n        handlingStack: computeHandlingStack ? createHandlingStack('instrumented constructor') : undefined,\n      },\n      () =>\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        Reflect.construct(original, parameters, newTarget)\n    )\n  } as CONTAINER[CONSTRUCTOR]\n\n  const restorePrototypeConstructor = preserveConstructorShape(instrumentation, original)\n  const { stop: restoreOriginal } = replaceWithInstrumentation(container, constructor, original, instrumentation)\n\n  return {\n    stop: () => {\n      stopped = true\n      restorePrototypeConstructor()\n      restoreOriginal()\n    },\n  }\n}\n\n/**\n * Replaces `targetPrototype[method]` with the provided instrumentation and\n * returns a `stop` function restoring the original (unless a third party replaced us afterwards).\n */\nfunction replaceWithInstrumentation<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET>(\n  targetPrototype: TARGET,\n  method: METHOD,\n  original: TARGET[METHOD],\n  instrumentation: TARGET[METHOD]\n) {\n  targetPrototype[method] = instrumentation\n\n  return {\n    stop: () => {\n      // If the instrumentation has been removed by a third party, keep the last one\n      if (targetPrototype[method] === instrumentation) {\n        targetPrototype[method] = original\n      }\n    },\n  }\n}\n\n/**\n * Runs the pre-call callback (injecting the `onPostCall` registration), invokes the original\n * method/constructor, then runs the registered post-call callback with the result.\n *\n * Note: the handling stack must be computed by the caller (at the topmost position of the call\n * stack), so it is part of `baseCallInfo` rather than computed here.\n */\nfunction notifyInstrumentation<CALL_INFO extends InstrumentationCallbacks<RESULT>, RESULT>(\n  onPreCall: (this: null, callInfo: CALL_INFO) => void,\n  baseCallInfo: Omit<CALL_INFO, 'onPostCall'>,\n  invokeOriginal: () => RESULT\n): RESULT {\n  let postCallCallback: ((result: RESULT) => void) | undefined\n\n  callMonitored(onPreCall, null, [\n    {\n      ...baseCallInfo,\n      onPostCall: (callback: (result: RESULT) => void) => {\n        postCallCallback = callback\n      },\n    } as CALL_INFO,\n  ])\n\n  const result = invokeOriginal()\n\n  if (postCallCallback) {\n    callMonitored(postCallCallback, null, [result])\n  }\n\n  return result\n}\n\ninterface InstrumentationCallbacks<RESULT> {\n  onPostCall: (callback: (result: RESULT) => void) => void\n  handlingStack?: string\n}\n\n/**\n * Copies the original constructor prototype and other static members onto the instrumentation, so that\n * `instanceof` checks keep working and statics such as `WebSocket.OPEN` remain available while\n * instrumented.\n *\n * Returns a function that restores `prototype.constructor` to its prior descriptor; call it\n * before restoring the global property in `stop()`.\n */\nfunction preserveConstructorShape(instrumentation: AnyConstructor, original: AnyConstructor): () => void {\n  /**\n   * Limitation: Only the original's *own* static members are copied. Statics inherited through the\n   * constructor's prototype chain (e.g. `class Child extends Parent` where `Parent` defines statics)\n   * are not preserved, since the instrumentation still inherits from `Function.prototype`. This is\n   * acceptable for the globals we instrument (e.g. `WebSocket`, whose own statics are the only ones\n   * that matter), but we would need to delegate the static prototype chain to support subclassed\n   * constructors with meaningful inherited statics.\n   */\n  for (const key of ([] as PropertyKey[]).concat(\n    Object.getOwnPropertyNames(original),\n    Object.getOwnPropertySymbols(original)\n  )) {\n    const descriptor = Object.getOwnPropertyDescriptor(original, key) as PropertyDescriptor\n    Object.defineProperty(instrumentation, key, descriptor)\n  }\n\n  /*\n   * Limitation: Repointing `constructor` on this shared prototype affects every instance whose\n   * `[[Prototype]]` is this object, including instances created before instrumentation, because\n   * `constructor` is inherited rather than snapshotted per instance. Code that held `original` (or\n   * whatever was in `prototype.constructor` before) as the canonical constructor and expects reference\n   * equality to that value for the lifetime of the page can observe a behavior change while RUM is\n   * active; restoring on `stop()` fixes this. In practice the SDK initializes as early as possible,\n   * which narrows the window where pre-instrument instances exist.\n   */\n  const { stop: restoreOriginalConstructor } = replaceWithInstrumentation(\n    original.prototype,\n    'constructor',\n    original.prototype.constructor,\n    instrumentation\n  )\n\n  return restoreOriginalConstructor\n}\n\nexport function instrumentSetter<TARGET extends { [key: string]: any }, PROPERTY extends keyof TARGET>(\n  targetPrototype: TARGET,\n  property: PROPERTY,\n  after: (target: TARGET, value: TARGET[PROPERTY]) => void\n) {\n  const originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property)\n  if (!originalDescriptor?.set || !originalDescriptor.configurable) {\n    return { stop: noop }\n  }\n\n  const stoppedInstrumentation = noop\n  let instrumentation = (target: TARGET, value: TARGET[PROPERTY]) => {\n    // put hooked setter into event loop to avoid of set latency\n    setTimeout(() => {\n      if (instrumentation !== stoppedInstrumentation) {\n        after(target, value)\n      }\n    }, 0)\n  }\n\n  const instrumentationWrapper = function (this: TARGET, value: TARGET[PROPERTY]) {\n    originalDescriptor.set!.call(this, value)\n    instrumentation(this, value)\n  }\n\n  Object.defineProperty(targetPrototype, property, {\n    set: instrumentationWrapper,\n  })\n\n  return {\n    stop: () => {\n      if (Object.getOwnPropertyDescriptor(targetPrototype, property)?.set === instrumentationWrapper) {\n        Object.defineProperty(targetPrototype, property, originalDescriptor)\n      }\n      instrumentation = stoppedInstrumentation\n    },\n  }\n}\n"],"mappings":"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"}

package/cjs/tools/matchOption.d.ts

@@ -1,5 +1,4 @@
 export type MatchOption = string | RegExp | ((value: string) => boolean);
-export declare function isMatchOption(item: unknown): item is MatchOption;
 /**
  * Returns true if value can be matched by at least one of the provided MatchOptions.
  * When comparing strings, setting useStartsWith to true will compare the value with the start of

package/cjs/tools/matchOption.js

@@ -1,35 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMatchOption = isMatchOption;
-exports.matchList = matchList;
-const display_1 = require("./display");
-const typeUtils_1 = require("./utils/typeUtils");
-function isMatchOption(item) {
-    const itemType = (0, typeUtils_1.getType)(item);
-    return itemType === 'string' || itemType === 'function' || item instanceof RegExp;
-}
+const require_display = require("./display.js");
+//#region src/tools/matchOption.ts
 /**
- * Returns true if value can be matched by at least one of the provided MatchOptions.
- * When comparing strings, setting useStartsWith to true will compare the value with the start of
- * the option, instead of requiring an exact match.
- */
+* Returns true if value can be matched by at least one of the provided MatchOptions.
+* When comparing strings, setting useStartsWith to true will compare the value with the start of
+* the option, instead of requiring an exact match.
+*/
 function matchList(list, value, useStartsWith = false) {
-    return list.some((item) => {
-        try {
-            if (typeof item === 'function') {
-                return item(value);
-            }
-            else if (item instanceof RegExp) {
-                return item.test(value);
-            }
-            else if (typeof item === 'string') {
-                return useStartsWith ? value.startsWith(item) : item === value;
-            }
-        }
-        catch (e) {
-            display_1.display.error(e);
-        }
-        return false;
-    });
+	return list.some((item) => {
+		try {
+			if (typeof item === "function") return item(value);
+			else if (item instanceof RegExp) {
+				item.lastIndex = 0;
+				return item.test(value);
+			} else if (typeof item === "string") return useStartsWith ? value.startsWith(item) : item === value;
+		} catch (e) {
+			require_display.display.error(e);
+		}
+		return false;
+	});
 }
+//#endregion
+exports.matchList = matchList;
+
 //# sourceMappingURL=matchOption.js.map

package/cjs/tools/matchOption.js.map

@@ -1 +1 @@
-{"version":3,"file":"matchOption.js","sourceRoot":"","sources":["../../src/tools/matchOption.ts"],"names":[],"mappings":";;AAKA,sCAGC;AAOD,8BAeC;AA9BD,uCAAmC;AACnC,iDAA2C;AAI3C,SAAgB,aAAa,CAAC,IAAa;IACzC,MAAM,QAAQ,GAAG,IAAA,mBAAO,EAAC,IAAI,CAAC,CAAA;IAC9B,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,UAAU,IAAI,IAAI,YAAY,MAAM,CAAA;AACnF,CAAC;AAED;;;;GAIG;AACH,SAAgB,SAAS,CAAC,IAAmB,EAAE,KAAa,EAAE,aAAa,GAAG,KAAK;IACjF,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;QACxB,IAAI,CAAC;YACH,IAAI,OAAO,IAAI,KAAK,UAAU,EAAE,CAAC;gBAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA;YACpB,CAAC;iBAAM,IAAI,IAAI,YAAY,MAAM,EAAE,CAAC;gBAClC,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YACzB,CAAC;iBAAM,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACpC,OAAO,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,KAAK,CAAA;YAChE,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,iBAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QAClB,CAAC;QACD,OAAO,KAAK,CAAA;IACd,CAAC,CAAC,CAAA;AACJ,CAAC"}
+{"version":3,"file":"matchOption.js","names":[],"sources":["../../src/tools/matchOption.ts"],"sourcesContent":["import { display } from './display'\n\nexport type MatchOption = string | RegExp | ((value: string) => boolean)\n\n/**\n * Returns true if value can be matched by at least one of the provided MatchOptions.\n * When comparing strings, setting useStartsWith to true will compare the value with the start of\n * the option, instead of requiring an exact match.\n */\nexport function matchList(list: MatchOption[], value: string, useStartsWith = false): boolean {\n  return list.some((item) => {\n    try {\n      if (typeof item === 'function') {\n        return item(value)\n      } else if (item instanceof RegExp) {\n        // Prevent stateful matching\n        item.lastIndex = 0\n        return item.test(value)\n      } else if (typeof item === 'string') {\n        return useStartsWith ? value.startsWith(item) : item === value\n      }\n    } catch (e) {\n      display.error(e)\n    }\n    return false\n  })\n}\n"],"mappings":";;;;;;;AASA,SAAgB,UAAU,MAAqB,OAAe,gBAAgB,OAAgB;CAC5F,OAAO,KAAK,MAAM,SAAS;EACzB,IAAI;GACF,IAAI,OAAO,SAAS,YAClB,OAAO,KAAK,KAAK;QACZ,IAAI,gBAAgB,QAAQ;IAEjC,KAAK,YAAY;IACjB,OAAO,KAAK,KAAK,KAAK;GACxB,OAAO,IAAI,OAAO,SAAS,UACzB,OAAO,gBAAgB,MAAM,WAAW,IAAI,IAAI,SAAS;EAE7D,SAAS,GAAG;GACV,gBAAA,QAAQ,MAAM,CAAC;EACjB;EACA,OAAO;CACT,CAAC;AACH"}

package/cjs/tools/mockable.d.ts

@@ -0,0 +1,22 @@
+export declare const mockableReplacements: Map<unknown, unknown>;
+/**
+ * Wraps a value to make it mockable in tests. In production builds, this is a no-op
+ * that returns the value as-is. In test builds, it checks if a mock replacement has
+ * been registered and returns that instead.
+ *
+ * @example
+ * // In source file:
+ * import { mockable } from '../tools/mockable'
+ * export function formatNavigationEntry(): string {
+ *   const navigationEntry = mockable(getNavigationEntry)()
+ *   ...
+ * }
+ *
+ * // In test file:
+ * import { replaceMockable } from '@kubesense/kubesense-browser-core/test'
+ * it('...', () => {
+ *   replaceMockable(getNavigationEntry, () => FAKE_NAVIGATION_ENTRY)
+ *   expect(formatNavigationEntry()).toEqual(...)
+ * })
+ */
+export declare function mockable<T>(value: T): T;

package/cjs/tools/mockable.js

@@ -0,0 +1,28 @@
+//#region src/tools/mockable.ts
+/**
+* Wraps a value to make it mockable in tests. In production builds, this is a no-op
+* that returns the value as-is. In test builds, it checks if a mock replacement has
+* been registered and returns that instead.
+*
+* @example
+* // In source file:
+* import { mockable } from '../tools/mockable'
+* export function formatNavigationEntry(): string {
+*   const navigationEntry = mockable(getNavigationEntry)()
+*   ...
+* }
+*
+* // In test file:
+* import { replaceMockable } from '@kubesense/kubesense-browser-core/test'
+* it('...', () => {
+*   replaceMockable(getNavigationEntry, () => FAKE_NAVIGATION_ENTRY)
+*   expect(formatNavigationEntry()).toEqual(...)
+* })
+*/
+function mockable(value) {
+	return value;
+}
+//#endregion
+exports.mockable = mockable;
+
+//# sourceMappingURL=mockable.js.map

package/cjs/tools/mockable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockable.js","names":[],"sources":["../../src/tools/mockable.ts"],"sourcesContent":["declare const __BUILD_ENV__SDK_VERSION__: string\n\nexport const mockableReplacements = new Map<unknown, unknown>()\n\n/**\n * Wraps a value to make it mockable in tests. In production builds, this is a no-op\n * that returns the value as-is. In test builds, it checks if a mock replacement has\n * been registered and returns that instead.\n *\n * @example\n * // In source file:\n * import { mockable } from '../tools/mockable'\n * export function formatNavigationEntry(): string {\n *   const navigationEntry = mockable(getNavigationEntry)()\n *   ...\n * }\n *\n * // In test file:\n * import { replaceMockable } from '@kubesense/kubesense-browser-core/test'\n * it('...', () => {\n *   replaceMockable(getNavigationEntry, () => FAKE_NAVIGATION_ENTRY)\n *   expect(formatNavigationEntry()).toEqual(...)\n * })\n */\nexport function mockable<T>(value: T): T {\n  // In test builds, return a wrapper that checks for mocks at call time\n  if (__BUILD_ENV__SDK_VERSION__ === 'test' && mockableReplacements.has(value)) {\n    return mockableReplacements.get(value)! as T\n  }\n  // In production, return the value as-is\n  return value\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,SAAY,OAAa;CAMvC,OAAO;AACT"}

package/cjs/tools/observable.d.ts

@@ -15,8 +15,10 @@ export declare class Observable<T> {
 export declare function mergeObservables<T>(...observables: Array<Observable<T>>): Observable<T>;
 export declare class BufferedObservable<T> extends Observable<T> {
     private maxBufferSize;
+    private onDrop?;
     private buffer;
-    constructor(maxBufferSize: number);
+    private droppedCount;
+    constructor(maxBufferSize: number, onDrop?: ((count: number) => void) | undefined);
     notify(data: T): void;
     subscribe(observer: Observer<T>): Subscription;
     /**