@openobserve/browser-core 0.2.11-rc1 → 0.2.12-beta.1

package/src/index.ts

@@ -1,120 +1,151 @@
+export type { Configuration, InitConfiguration, EndpointBuilder, ProxyFn } from './domain/configuration'
 export {
-  Configuration,
-  InitConfiguration,
   validateAndBuildConfiguration,
   DefaultPrivacyLevel,
-  EndpointBuilder,
+  TraceContextInjection,
   serializeConfiguration,
-  INTAKE_SITE_STAGING,
-  INTAKE_SITE_US1,
-  INTAKE_SITE_US1_FED,
-  INTAKE_SITE_EU1,
+  isSampleRate,
+  buildEndpointHost,
+  isIntakeUrl,
 } from './domain/configuration'
+export * from './domain/intakeSites'
+export type { TrackingConsentState } from './domain/trackingConsent'
+export { TrackingConsent, createTrackingConsentState } from './domain/trackingConsent'
 export {
   isExperimentalFeatureEnabled,
   addExperimentalFeatures,
   resetExperimentalFeatures,
   getExperimentalFeatures,
+  initFeatureFlags,
   ExperimentalFeature,
 } from './tools/experimentalFeatures'
 export { trackRuntimeError } from './domain/error/trackRuntimeError'
-export { computeStackTrace, StackTrace } from './domain/error/computeStackTrace'
+export type { StackTrace } from './tools/stackTrace/computeStackTrace'
+export { computeStackTrace } from './tools/stackTrace/computeStackTrace'
+export type { PublicApi } from './boot/init'
 export { defineGlobal, makePublicApi } from './boot/init'
-export { initReportObservable, RawReport, RawReportType } from './domain/report/reportObservable'
-export {
-  startTelemetry,
+export { displayAlreadyInitializedError } from './boot/displayAlreadyInitializedError'
+export { initReportObservable, RawReportType } from './domain/report/reportObservable'
+export type {
   Telemetry,
   RawTelemetryEvent,
   RawTelemetryConfiguration,
-  addTelemetryDebug,
-  addTelemetryError,
-  startFakeTelemetry,
-  resetTelemetry,
   TelemetryEvent,
   TelemetryErrorEvent,
   TelemetryDebugEvent,
   TelemetryConfigurationEvent,
+  TelemetryUsageEvent,
+  RawTelemetryUsage,
+  RawTelemetryUsageFeature,
+} from './domain/telemetry'
+export {
+  startTelemetry,
+  addTelemetryDebug,
+  addTelemetryError,
+  resetTelemetry,
   TelemetryService,
-  isTelemetryReplicationAllowed,
+  TelemetryMetrics,
   addTelemetryConfiguration,
+  addTelemetryUsage,
+  addTelemetryMetrics,
 } from './domain/telemetry'
-export { monitored, monitor, callMonitored, setDebugMode } from './tools/monitor'
-export { Observable, Subscription } from './tools/observable'
-export {
-  startSessionManager,
-  SessionManager,
-  // Exposed for tests
-  stopSessionManager,
-} from './domain/session/sessionManager'
+export { monitored, monitor, callMonitored, setDebugMode, monitorError } from './tools/monitor'
+export type { Subscription } from './tools/observable'
+export { Observable, BufferedObservable } from './tools/observable'
+export type { SessionManager } from './domain/session/sessionManager'
+export { startSessionManager, stopSessionManager } from './domain/session/sessionManager'
 export {
   SESSION_TIME_OUT_DELAY, // Exposed for tests
+  SESSION_NOT_TRACKED,
+  SessionPersistence,
 } from './domain/session/sessionConstants'
+export type { BandwidthStats, HttpRequest, HttpRequestEvent, Payload, FlushEvent, FlushReason } from './transport'
 export {
-  HttpRequest,
-  Payload,
   createHttpRequest,
   canUseEventBridge,
   getEventBridge,
-  startBatchWithReplica,
+  bridgeSupports,
+  BridgeCapability,
+  createBatch,
   createFlushController,
-  FlushEvent,
-  FlushReason,
+  FLUSH_DURATION_LIMIT,
 } from './transport'
 export * from './tools/display'
-export { Encoder, EncoderResult, createIdentityEncoder } from './tools/encoder'
+export type { Encoder, EncoderResult } from './tools/encoder'
+export { createIdentityEncoder } from './tools/encoder'
 export * from './tools/utils/urlPolyfill'
 export * from './tools/utils/timeUtils'
 export * from './tools/utils/arrayUtils'
 export * from './tools/serialisation/sanitize'
-export * from './tools/getGlobalObject'
+export * from './tools/globalObject'
 export { AbstractLifeCycle } from './tools/abstractLifeCycle'
 export * from './domain/eventRateLimiter/createEventRateLimiter'
 export * from './tools/utils/browserDetection'
 export { sendToExtension } from './tools/sendToExtension'
-export { runOnReadyState } from './browser/runOnReadyState'
+export { runOnReadyState, asyncRunOnReadyState } from './browser/runOnReadyState'
 export { getZoneJsOriginalValue } from './tools/getZoneJsOriginalValue'
-export { instrumentMethod, instrumentSetter, InstrumentedMethodCall } from './tools/instrumentMethod'
+export type { InstrumentedMethodCall } from './tools/instrumentMethod'
+export { instrumentMethod, instrumentSetter } from './tools/instrumentMethod'
 export {
   computeRawError,
-  createHandlingStack,
-  toStackTraceString,
   getFileFromStackTraceString,
+  isError,
   NO_ERROR_STACK_PRESENT_MESSAGE,
 } from './domain/error/error'
 export { NonErrorPrefix } from './domain/error/error.types'
-export { Context, ContextArray, ContextValue } from './tools/serialisation/context'
-export { areCookiesAuthorized, getCookie, setCookie, deleteCookie } from './browser/cookie'
-export { initXhrObservable, XhrCompleteContext, XhrStartContext } from './browser/xhrObservable'
-export { initFetchObservable, FetchResolveContext, FetchStartContext, FetchContext } from './browser/fetchObservable'
-export { createPageExitObservable, PageExitEvent, PageExitReason, isPageExitReason } from './browser/pageExitObservable'
+export type { Context, ContextArray, ContextValue } from './tools/serialisation/context'
+export {
+  areCookiesAuthorized,
+  getCookie,
+  getInitCookie,
+  setCookie,
+  deleteCookie,
+  resetInitCookies,
+} from './browser/cookie'
+export type { CookieStore, WeakRef, WeakRefConstructor } from './browser/browser.types'
+export type { XhrCompleteContext, XhrStartContext } from './browser/xhrObservable'
+export { initXhrObservable } from './browser/xhrObservable'
+export type { FetchResolveContext, FetchStartContext, FetchContext } from './browser/fetchObservable'
+export { initFetchObservable, resetFetchObservable, ResponseBodyAction } from './browser/fetchObservable'
+export type { PageMayExitEvent } from './browser/pageMayExitObservable'
+export { createPageMayExitObservable, PageExitReason, isPageExitReason } from './browser/pageMayExitObservable'
 export * from './browser/addEventListener'
+export { requestIdleCallback } from './tools/requestIdleCallback'
+export * from './tools/taskQueue'
 export * from './tools/timer'
-export { initConsoleObservable, resetConsoleObservable, ConsoleLog } from './domain/console/consoleObservable'
-export { BoundedBuffer } from './tools/boundedBuffer'
+export type { ConsoleLog } from './domain/console/consoleObservable'
+export { initConsoleObservable, resetConsoleObservable } from './domain/console/consoleObservable'
+export type { BoundedBuffer } from './tools/boundedBuffer'
+export { createBoundedBuffer } from './tools/boundedBuffer'
 export { catchUserErrors } from './tools/catchUserErrors'
-export { createContextManager, ContextManager } from './domain/context/contextManager'
+export type { ContextManager } from './domain/context/contextManager'
+export { createContextManager } from './domain/context/contextManager'
+export { defineContextMethod, bufferContextCalls } from './domain/context/defineContextMethod'
 export { storeContextManager, removeStorageListeners } from './domain/context/storeContextManager'
-export {
-  createCustomerDataTrackerManager,
-  createCustomerDataTracker,
-  CustomerDataTracker,
-  CustomerDataTrackerManager,
-  CUSTOMER_DATA_BYTES_LIMIT,
-  CustomerDataCompressionStatus,
-} from './domain/context/customerDataTracker'
-export { CustomerDataType } from './domain/context/contextConstants'
-export { ValueHistory, ValueHistoryEntry, CLEAR_OLD_VALUES_INTERVAL } from './tools/valueHistory'
+export { startAccountContext, buildAccountContextManager } from './domain/contexts/accountContext'
+export { startGlobalContext, buildGlobalContextManager } from './domain/contexts/globalContext'
+export { startUserContext, buildUserContextManager } from './domain/contexts/userContext'
+export type { User } from './domain/contexts/userContext'
+export type { Account } from './domain/contexts/accountContext'
+export type { RumInternalContext } from './domain/contexts/rumInternalContext.type'
+export { CustomerDataType, CustomerContextKey, ContextManagerMethod } from './domain/context/contextConstants'
+export type { ValueHistory, ValueHistoryEntry } from './tools/valueHistory'
+export { createValueHistory, CLEAR_OLD_VALUES_INTERVAL } from './tools/valueHistory'
 export { readBytesFromStream } from './tools/readBytesFromStream'
+export type { SessionState } from './domain/session/sessionState'
 export { STORAGE_POLL_DELAY } from './domain/session/sessionStore'
 export { SESSION_STORE_KEY } from './domain/session/storeStrategies/sessionStoreStrategy'
 export {
   willSyntheticsInjectRum,
   getSyntheticsTestId,
   getSyntheticsResultId,
+  isSyntheticsTest,
 } from './domain/synthetics/syntheticsWorkerValues'
-export { User, checkUser, sanitizeUser } from './domain/user'
+export { checkContext } from './domain/context/contextUtils'
 export * from './domain/resourceUtils'
+export * from './domain/bufferedData'
 export * from './tools/utils/polyfills'
+export * from './tools/utils/timezone'
 export * from './tools/utils/numberUtils'
 export * from './tools/utils/byteUtils'
 export * from './tools/utils/objectUtils'
@@ -125,10 +156,10 @@ export * from './tools/utils/stringUtils'
 export * from './tools/matchOption'
 export * from './tools/utils/responseUtils'
 export * from './tools/utils/typeUtils'
-export { ErrorHandling } from './domain/error/error.types'
-export { ErrorSource } from './domain/error/error.types'
-export { RawError } from './domain/error/error.types'
-export { RawErrorCause } from './domain/error/error.types'
-export { ErrorWithCause } from './domain/error/error.types'
+export type { RawError, RawErrorCause, ErrorWithCause, Csp } from './domain/error/error.types'
+export { ErrorHandling, ErrorSource } from './domain/error/error.types'
 export * from './domain/deflate'
 export * from './domain/connectivity'
+export * from './tools/stackTrace/handlingStack'
+export * from './tools/abstractHooks'
+export * from './domain/tags'

package/src/tools/abstractHooks.ts

@@ -0,0 +1,72 @@
+import { combine } from './mergeInto'
+
+export const enum HookNames {
+  Assemble,
+  AssembleTelemetry,
+}
+
+// This is a workaround for an issue occurring when the Browser SDK is included in a TypeScript
+// project configured with `isolatedModules: true`. Even if the const enum is declared in this
+// module, we cannot use it directly to define the EventMap interface keys (TS error: "Cannot access
+// ambient const enums when the '--isolatedModules' flag is provided.").
+export declare const HookNamesAsConst: {
+  ASSEMBLE: HookNames.Assemble
+  ASSEMBLE_TELEMETRY: HookNames.AssembleTelemetry
+}
+
+export type RecursivePartial<T> = {
+  [P in keyof T]?: T[P] extends Array<infer U>
+    ? Array<RecursivePartial<U>>
+    : T[P] extends object | undefined
+      ? RecursivePartial<T[P]>
+      : T[P]
+}
+
+// Discards the event from being sent
+export const DISCARDED = 'DISCARDED'
+// Skips from the assembly of the event
+export const SKIPPED = 'SKIPPED'
+
+export type DISCARDED = typeof DISCARDED
+export type SKIPPED = typeof SKIPPED
+
+export type AbstractHooks = ReturnType<typeof abstractHooks>
+
+export function abstractHooks<T extends { [K in HookNames]: (...args: any[]) => unknown }>() {
+  const callbacks: { [K in HookNames]?: Array<T[K]> } = {}
+
+  return {
+    register<K extends HookNames>(hookName: K, callback: T[K]) {
+      if (!callbacks[hookName]) {
+        callbacks[hookName] = []
+      }
+      callbacks[hookName]!.push(callback)
+      return {
+        unregister: () => {
+          callbacks[hookName] = callbacks[hookName]!.filter((cb) => cb !== callback)
+        },
+      }
+    },
+    triggerHook<K extends HookNames>(
+      hookName: K,
+      param: Parameters<T[K]>[0]
+    ): Exclude<ReturnType<T[K]>, SKIPPED> | DISCARDED | undefined {
+      const hookCallbacks = callbacks[hookName] || []
+      const results: any[] = []
+
+      for (const callback of hookCallbacks) {
+        const result = callback(param)
+        if (result === DISCARDED) {
+          return DISCARDED
+        }
+        if (result === SKIPPED) {
+          continue
+        }
+
+        results.push(result)
+      }
+
+      return combine(...(results as [any, any])) as Exclude<ReturnType<T[K]>, SKIPPED>
+    },
+  }
+}

package/src/tools/abstractLifeCycle.ts

@@ -16,6 +16,7 @@ type EventTypesWithoutData<EventMap> = {
   [K in keyof EventMap]: EventMap[K] extends void ? K : never
 }[keyof EventMap]
 
+// eslint-disable-next-line no-restricted-syntax
 export class AbstractLifeCycle<EventMap> {
   private callbacks: { [key in keyof EventMap]?: Array<(data: any) => void> } = {}
 

package/src/tools/boundedBuffer.ts

@@ -1,17 +1,45 @@
+import { removeItem } from './utils/arrayUtils'
+
 const BUFFER_LIMIT = 500
 
-export class BoundedBuffer {
-  private buffer: Array<() => void> = []
+/**
+ * BoundedBuffer is a deprecated interface.
+ *
+ * @deprecated Use `BufferedObservable` instead.
+ */
+export interface BoundedBuffer<T = void> {
+  add: (callback: (arg: T) => void) => void
+  remove: (callback: (arg: T) => void) => void
+  drain: (arg: T) => void
+}
+
+/**
+ * createBoundedBuffer creates a BoundedBuffer.
+ *
+ * @deprecated Use `BufferedObservable` instead.
+ */
+export function createBoundedBuffer<T = void>(): BoundedBuffer<T> {
+  const buffer: Array<(arg: T) => void> = []
 
-  add(callback: () => void) {
-    const length = this.buffer.push(callback)
+  const add: BoundedBuffer<T>['add'] = (callback: (arg: T) => void) => {
+    const length = buffer.push(callback)
     if (length > BUFFER_LIMIT) {
-      this.buffer.splice(0, 1)
+      buffer.splice(0, 1)
     }
   }
 
-  drain() {
-    this.buffer.forEach((callback) => callback())
-    this.buffer.length = 0
+  const remove: BoundedBuffer<T>['remove'] = (callback: (arg: T) => void) => {
+    removeItem(buffer, callback)
+  }
+
+  const drain = (arg: T) => {
+    buffer.forEach((callback) => callback(arg))
+    buffer.length = 0
+  }
+
+  return {
+    add,
+    remove,
+    drain,
   }
 }

package/src/tools/display.ts

@@ -50,3 +50,7 @@ export const display: Display = {
   warn: originalConsoleMethods.warn.bind(globalConsole, PREFIX),
   error: originalConsoleMethods.error.bind(globalConsole, PREFIX),
 }
+
+export const DOCS_ORIGIN = 'https://docs.datadoghq.com'
+export const DOCS_TROUBLESHOOTING = `${DOCS_ORIGIN}/real_user_monitoring/browser/troubleshooting`
+export const MORE_DETAILS = 'More details:'

package/src/tools/encoder.ts

@@ -1,6 +1,7 @@
+import type { Uint8ArrayBuffer } from './utils/byteUtils'
 import { computeBytesCount } from './utils/byteUtils'
 
-export interface Encoder<Output extends string | Uint8Array = string | Uint8Array> {
+export interface Encoder<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {
   /**
    * Whether this encoder might call the provided callbacks asynchronously
    */
@@ -43,7 +44,7 @@ export interface Encoder<Output extends string | Uint8Array = string | Uint8Arra
   estimateEncodedBytesCount(data: string): number
 }
 
-export interface EncoderResult<Output extends string | Uint8Array = string | Uint8Array> {
+export interface EncoderResult<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {
   output: Output
   outputBytesCount: number
 

package/src/tools/experimentalFeatures.ts

@@ -9,19 +9,30 @@
  */
 // We want to use a real enum (i.e. not a const enum) here, to be able to check whether an arbitrary
 // string is an expected feature flag
+
+import { objectHasValue } from './utils/objectUtils'
+
 // eslint-disable-next-line no-restricted-syntax
 export enum ExperimentalFeature {
-  PAGEHIDE = 'pagehide',
-  FEATURE_FLAGS = 'feature_flags',
-  RESOURCE_PAGE_STATES = 'resource_page_states',
-  COLLECT_FLUSH_REASON = 'collect_flush_reason',
-  ZERO_LCP_TELEMETRY = 'zero_lcp_telemetry',
-  DISABLE_REPLAY_INLINE_CSS = 'disable_replay_inline_css',
-  WRITABLE_RESOURCE_GRAPHQL = 'writable_resource_graphql',
+  TRACK_INTAKE_REQUESTS = 'track_intake_requests',
+  USE_TREE_WALKER_FOR_ACTION_NAME = 'use_tree_walker_for_action_name',
+  FEATURE_OPERATION_VITAL = 'feature_operation_vital',
+  SHORT_SESSION_INVESTIGATION = 'short_session_investigation',
+  AVOID_FETCH_KEEPALIVE = 'avoid_fetch_keepalive',
 }
 
 const enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()
 
+export function initFeatureFlags(enableExperimentalFeatures: string[] | undefined) {
+  if (Array.isArray(enableExperimentalFeatures)) {
+    addExperimentalFeatures(
+      enableExperimentalFeatures.filter((flag): flag is ExperimentalFeature =>
+        objectHasValue(ExperimentalFeature, flag)
+      )
+    )
+  }
+}
+
 export function addExperimentalFeatures(enabledFeatures: ExperimentalFeature[]): void {
   enabledFeatures.forEach((flag) => {
     enabledExperimentalFeatures.add(flag)

package/src/tools/getZoneJsOriginalValue.ts

@@ -1,4 +1,4 @@
-import { getGlobalObject } from './getGlobalObject'
+import { getGlobalObject } from './globalObject'
 
 export interface BrowserWindowWithZoneJs extends Window {
   Zone?: {

package/src/tools/{getGlobalObject.ts → globalObject.ts}

@@ -2,6 +2,17 @@
  * inspired by https://mathiasbynens.be/notes/globalthis
  */
 
+// Extend/Create the WorkerGlobalScope interface to avoid issues when used in a non-browser tsconfig environment
+interface WorkerGlobalScope {
+  empty: never
+}
+
+// Utility type to enforce that exactly one of the two types is used
+type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never }
+type XOR<T, U> = T | U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U
+
+export type GlobalObject = XOR<Window, WorkerGlobalScope>
+
 export function getGlobalObject<T = typeof globalThis>(): T {
   if (typeof globalThis === 'object') {
     return globalThis as unknown as T
@@ -29,3 +40,12 @@ export function getGlobalObject<T = typeof globalThis>(): T {
   }
   return globalObject as T
 }
+
+/**
+ * Cached reference to the global object so it can be imported and re-used without
+ * re-evaluating the heavyweight fallback logic in `getGlobalObject()`.
+ */
+// eslint-disable-next-line local-rules/disallow-side-effects
+export const globalObject = getGlobalObject<GlobalObject>()
+
+export const isWorkerEnvironment = 'WorkerGlobalScope' in globalObject

package/src/tools/instrumentMethod.ts

@@ -1,21 +1,20 @@
 import { setTimeout } from './timer'
 import { callMonitored } from './monitor'
 import { noop } from './utils/functionUtils'
+import { createHandlingStack } from './stackTrace/handlingStack'
 
 /**
  * Object passed to the callback of an instrumented method call. See `instrumentMethod` for more
  * info.
  */
-export type InstrumentedMethodCall<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET> = {
+export interface InstrumentedMethodCall<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET> {
   /**
    * The target object on which the method was called.
    */
   target: TARGET
 
   /**
-   * The parameters with which the method was called. To avoid having to clone the argument list
-   * every time, this property is actually an instance of Argument, not Array, so not all methods
-   * are available (like .forEach).
+   * The parameters with which the method was called.
    *
    * Note: if needed, parameters can be mutated by the instrumentation
    */
@@ -26,6 +25,11 @@ export type InstrumentedMethodCall<TARGET extends { [key: string]: any }, METHOD
    * result passed as argument.
    */
   onPostCall: (callback: PostCallCallback<TARGET, METHOD>) => void
+
+  /**
+   * The stack trace of the method call.
+   */
+  handlingStack?: string
 }
 
 type PostCallCallback<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET> = (
@@ -36,11 +40,23 @@ type PostCallCallback<TARGET extends { [key: string]: any }, METHOD extends keyo
  * 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 }) => {
@@ -51,43 +67,31 @@ type PostCallCallback<TARGET extends { [key: string]: any }, METHOD extends keyo
  *    })
  *  })
  */
-export function instrumentMethod<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET>(
+export function instrumentMethod<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET & string>(
   targetPrototype: TARGET,
   method: METHOD,
-  onPreCall: (this: null, callInfos: InstrumentedMethodCall<TARGET, METHOD>) => void
+  onPreCall: (this: null, callInfos: InstrumentedMethodCall<TARGET, METHOD>) => void,
+  { computeHandlingStack }: { computeHandlingStack?: boolean } = {}
 ) {
-  const original = targetPrototype[method]
-
-  let instrumentation = createInstrumentedMethod(original, onPreCall)
+  let original = targetPrototype[method]
 
-  const instrumentationWrapper = function (this: TARGET): ReturnType<TARGET[METHOD]> | undefined {
-    if (typeof instrumentation !== 'function') {
-      return undefined
+  if (typeof original !== 'function') {
+    if (method in targetPrototype && method.startsWith('on')) {
+      original = noop as TARGET[METHOD]
+    } else {
+      return { stop: noop }
     }
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
-    return instrumentation.apply(this, arguments as unknown as Parameters<TARGET[METHOD]>)
   }
-  targetPrototype[method] = instrumentationWrapper as TARGET[METHOD]
 
-  return {
-    stop: () => {
-      if (targetPrototype[method] === instrumentationWrapper) {
-        targetPrototype[method] = original
-      } else {
-        instrumentation = original
-      }
-    },
-  }
-}
+  let stopped = false
 
-function createInstrumentedMethod<TARGET extends { [key: string]: any }, METHOD extends keyof TARGET>(
-  original: TARGET[METHOD],
-  onPreCall: (this: null, callInfos: InstrumentedMethodCall<TARGET, METHOD>) => void
-): TARGET[METHOD] {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-  return function (this: TARGET) {
-    const parameters = arguments as unknown as Parameters<TARGET[METHOD]>
-    let result
+  const instrumentation = function (this: TARGET): ReturnType<TARGET[METHOD]> | undefined {
+    if (stopped) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call
+      return original.apply(this, arguments as unknown as Parameters<TARGET[METHOD]>)
+    }
+
+    const parameters = Array.from(arguments) as Parameters<TARGET[METHOD]>
 
     let postCallCallback: PostCallCallback<TARGET, METHOD> | undefined
 
@@ -98,13 +102,12 @@ function createInstrumentedMethod<TARGET extends { [key: string]: any }, METHOD
         onPostCall: (callback) => {
           postCallCallback = callback
         },
+        handlingStack: computeHandlingStack ? createHandlingStack('instrumented method') : undefined,
       },
     ])
 
-    if (typeof original === 'function') {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-      result = original.apply(this, parameters)
-    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    const result = original.apply(this, parameters)
 
     if (postCallCallback) {
       callMonitored(postCallCallback, null, [result])
@@ -112,7 +115,19 @@ function createInstrumentedMethod<TARGET extends { [key: string]: any }, METHOD
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return result
-  } as TARGET[METHOD]
+  }
+
+  targetPrototype[method] = instrumentation as TARGET[METHOD]
+
+  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
+      }
+    },
+  }
 }
 
 export function instrumentSetter<TARGET extends { [key: string]: any }, PROPERTY extends keyof TARGET>(
@@ -125,10 +140,13 @@ export function instrumentSetter<TARGET extends { [key: string]: any }, PROPERTY
     return { stop: noop }
   }
 
+  const stoppedInstrumentation = noop
   let instrumentation = (target: TARGET, value: TARGET[PROPERTY]) => {
     // put hooked setter into event loop to avoid of set latency
     setTimeout(() => {
-      after(target, value)
+      if (instrumentation !== stoppedInstrumentation) {
+        after(target, value)
+      }
     }, 0)
   }
 
@@ -145,9 +163,8 @@ export function instrumentSetter<TARGET extends { [key: string]: any }, PROPERTY
     stop: () => {
       if (Object.getOwnPropertyDescriptor(targetPrototype, property)?.set === instrumentationWrapper) {
         Object.defineProperty(targetPrototype, property, originalDescriptor)
-      } else {
-        instrumentation = noop
       }
+      instrumentation = stoppedInstrumentation
     },
   }
 }

package/src/tools/matchOption.ts

@@ -1,4 +1,3 @@
-import { startsWith } from './utils/polyfills'
 import { display } from './display'
 import { getType } from './utils/typeUtils'
 
@@ -22,7 +21,7 @@ export function matchList(list: MatchOption[], value: string, useStartsWith = fa
       } else if (item instanceof RegExp) {
         return item.test(value)
       } else if (typeof item === 'string') {
-        return useStartsWith ? startsWith(value, item) : item === value
+        return useStartsWith ? value.startsWith(item) : item === value
       }
     } catch (e) {
       display.error(e)