@pratham.raval/browser-core 6.22.3

package/src/tools/instrumentMethod.ts

@@ -0,0 +1,170 @@
+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 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.
+   *
+   * Note: if needed, parameters can be mutated by the instrumentation
+   */
+  parameters: Parameters<TARGET[METHOD]>
+
+  /**
+   * Registers a callback that will be called after the original method is called, with the 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> = (
+  result: ReturnType<TARGET[METHOD]>
+) => void
+
+/**
+ * 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)
+ *    })
+ *  })
+ */
+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,
+  { computeHandlingStack }: { computeHandlingStack?: boolean } = {}
+) {
+  let original = targetPrototype[method]
+
+  if (typeof original !== 'function') {
+    if (method in targetPrototype && method.startsWith('on')) {
+      original = noop as TARGET[METHOD]
+    } else {
+      return { stop: noop }
+    }
+  }
+
+  let stopped = false
+
+  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
+
+    callMonitored(onPreCall, null, [
+      {
+        target: this,
+        parameters,
+        onPostCall: (callback) => {
+          postCallCallback = callback
+        },
+        handlingStack: computeHandlingStack ? createHandlingStack('instrumented method') : undefined,
+      },
+    ])
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    const result = original.apply(this, parameters)
+
+    if (postCallCallback) {
+      callMonitored(postCallCallback, null, [result])
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return result
+  }
+
+  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>(
+  targetPrototype: TARGET,
+  property: PROPERTY,
+  after: (target: TARGET, value: TARGET[PROPERTY]) => void
+) {
+  const originalDescriptor = Object.getOwnPropertyDescriptor(targetPrototype, property)
+  if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {
+    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(() => {
+      if (instrumentation !== stoppedInstrumentation) {
+        after(target, value)
+      }
+    }, 0)
+  }
+
+  const instrumentationWrapper = function (this: TARGET, value: TARGET[PROPERTY]) {
+    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
+    },
+  }
+}

package/src/tools/matchOption.ts

@@ -0,0 +1,31 @@
+import { display } from './display'
+import { getType } from './utils/typeUtils'
+
+export type MatchOption = string | RegExp | ((value: string) => boolean)
+
+export function isMatchOption(item: unknown): item is MatchOption {
+  const itemType = getType(item)
+  return itemType === 'string' || itemType === 'function' || item instanceof RegExp
+}
+
+/**
+ * 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.
+ */
+export function matchList(list: MatchOption[], value: string, useStartsWith = false): boolean {
+  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.error(e)
+    }
+    return false
+  })
+}

package/src/tools/mergeInto.ts

@@ -0,0 +1,177 @@
+import { getType } from './utils/typeUtils'
+
+type Merged<TDestination, TSource> =
+  // case 1 - source is undefined - return destination
+  TSource extends undefined
+    ? TDestination
+    : // case 2 - destination is undefined - return source
+      TDestination extends undefined
+      ? TSource
+      : // case 3 - source is an array - see if it merges or overwrites
+        TSource extends any[]
+        ? TDestination extends any[]
+          ? TDestination & TSource
+          : TSource
+        : // case 4 - source is an object - see if it merges or overwrites
+          TSource extends object
+          ? TDestination extends object
+            ? TDestination extends any[]
+              ? TSource
+              : TDestination & TSource
+            : TSource
+          : // case 5 - cannot merge - return source
+            TSource
+
+/**
+ * Iterate over source and affect its sub values into destination, recursively.
+ * If the source and destination can't be merged, return source.
+ */
+export function mergeInto<D, S>(
+  destination: D,
+  source: S,
+  circularReferenceChecker = createCircularReferenceChecker()
+): Merged<D, S> {
+  // ignore the source if it is undefined
+  if (source === undefined) {
+    return destination as Merged<D, S>
+  }
+
+  if (typeof source !== 'object' || source === null) {
+    // primitive values - just return source
+    return source as Merged<D, S>
+  } else if (source instanceof Date) {
+    return new Date(source.getTime()) as unknown as Merged<D, S>
+  } else if (source instanceof RegExp) {
+    const flags =
+      source.flags ||
+      // old browsers compatibility
+      [
+        source.global ? 'g' : '',
+        source.ignoreCase ? 'i' : '',
+        source.multiline ? 'm' : '',
+        source.sticky ? 'y' : '',
+        source.unicode ? 'u' : '',
+      ].join('')
+    return new RegExp(source.source, flags) as unknown as Merged<D, S>
+  }
+
+  if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {
+    // remove circular references
+    return undefined as unknown as Merged<D, S>
+  } else if (Array.isArray(source)) {
+    const merged: any[] = Array.isArray(destination) ? destination : []
+    for (let i = 0; i < source.length; ++i) {
+      merged[i] = mergeInto(merged[i], source[i], circularReferenceChecker)
+    }
+    return merged as unknown as Merged<D, S>
+  }
+
+  const merged = getType(destination) === 'object' ? (destination as Record<any, any>) : {}
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      merged[key] = mergeInto(merged[key], source[key], circularReferenceChecker)
+    }
+  }
+  return merged as unknown as Merged<D, S>
+}
+
+/**
+ * A simplistic implementation of a deep clone algorithm.
+ * Caveats:
+ * - It doesn't maintain prototype chains - don't use with instances of custom classes.
+ * - It doesn't handle Map and Set
+ */
+export function deepClone<T>(value: T): T {
+  return mergeInto(undefined, value) as T
+}
+
+type Combined<A, B> = A extends null ? B : B extends null ? A : Merged<A, B>
+
+/*
+ * Performs a deep merge of objects and arrays.
+ * - Arguments won't be mutated
+ * - Object and arrays in the output value are de-referenced ("deep cloned")
+ * - Arrays values are merged index by index
+ * - Objects are merged by keys
+ * - Values get replaced, unless undefined
+ */
+export function combine<A, B>(a: A, b: B): Combined<A, B>
+export function combine<A, B, C>(a: A, b: B, c: C): Combined<Combined<A, B>, C>
+export function combine<A, B, C, D>(a: A, b: B, c: C, d: D): Combined<Combined<Combined<A, B>, C>, D>
+export function combine<A, B, C, D, E>(
+  a: A,
+  b: B,
+  c: C,
+  d: D,
+  e: E
+): Combined<Combined<Combined<Combined<A, B>, C>, D>, E>
+export function combine<A, B, C, D, E, F>(
+  a: A,
+  b: B,
+  c: C,
+  d: D,
+  e: E,
+  f: F
+): Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>
+export function combine<A, B, C, D, E, F, G>(
+  a: A,
+  b: B,
+  c: C,
+  d: D,
+  e: E,
+  f: F,
+  g: G
+): Combined<Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>, G>
+export function combine<A, B, C, D, E, F, G, H>(
+  a: A,
+  b: B,
+  c: C,
+  d: D,
+  e: E,
+  f: F,
+  g: G,
+  h: H
+): Combined<Combined<Combined<Combined<Combined<Combined<Combined<A, B>, C>, D>, E>, F>, G>, H>
+export function combine(...sources: any[]): unknown {
+  let destination: any
+
+  for (const source of sources) {
+    // Ignore any undefined or null sources.
+    if (source === undefined || source === null) {
+      continue
+    }
+
+    destination = mergeInto(destination, source)
+  }
+
+  return destination as unknown
+}
+
+interface CircularReferenceChecker {
+  hasAlreadyBeenSeen(value: any): boolean
+}
+
+function createCircularReferenceChecker(): CircularReferenceChecker {
+  if (typeof WeakSet !== 'undefined') {
+    const set: WeakSet<any> = new WeakSet()
+    return {
+      hasAlreadyBeenSeen(value) {
+        const has = set.has(value)
+        if (!has) {
+          set.add(value)
+        }
+        return has
+      },
+    }
+  }
+  const array: any[] = []
+  return {
+    hasAlreadyBeenSeen(value) {
+      const has = array.indexOf(value) >= 0
+      if (!has) {
+        array.push(value)
+      }
+      return has
+    },
+  }
+}

package/src/tools/monitor.ts

@@ -0,0 +1,72 @@
+import { display } from './display'
+
+let onMonitorErrorCollected: undefined | ((error: unknown) => void)
+let debugMode = false
+
+export function startMonitorErrorCollection(newOnMonitorErrorCollected: (error: unknown) => void) {
+  onMonitorErrorCollected = newOnMonitorErrorCollected
+}
+
+export function setDebugMode(newDebugMode: boolean) {
+  debugMode = newDebugMode
+}
+
+export function resetMonitor() {
+  onMonitorErrorCollected = undefined
+  debugMode = false
+}
+
+export function monitored<T extends (...params: any[]) => unknown>(
+  _: any,
+  __: string,
+  descriptor: TypedPropertyDescriptor<T>
+) {
+  const originalMethod = descriptor.value!
+  descriptor.value = function (this: any, ...args: Parameters<T>) {
+    const decorated = onMonitorErrorCollected ? monitor(originalMethod) : originalMethod
+    return decorated.apply(this, args) as ReturnType<T>
+  } as T
+}
+
+export function monitor<T extends (...args: any[]) => any>(fn: T): T {
+  return function (this: any) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return callMonitored(fn, this, arguments as unknown as Parameters<T>)
+  } as unknown as T // consider output type has input type
+}
+
+export function callMonitored<T extends (...args: any[]) => any>(
+  fn: T,
+  context: ThisParameterType<T>,
+  args: Parameters<T>
+): ReturnType<T> | undefined
+export function callMonitored<T extends (this: void) => any>(fn: T): ReturnType<T> | undefined
+export function callMonitored<T extends (...args: any[]) => any>(
+  fn: T,
+  context?: any,
+  args?: any
+): ReturnType<T> | undefined {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return fn.apply(context, args)
+  } catch (e) {
+    monitorError(e)
+  }
+}
+
+export function monitorError(e: unknown) {
+  displayIfDebugEnabled(e)
+  if (onMonitorErrorCollected) {
+    try {
+      onMonitorErrorCollected(e)
+    } catch (e) {
+      displayIfDebugEnabled(e)
+    }
+  }
+}
+
+export function displayIfDebugEnabled(...args: any[]) {
+  if (debugMode) {
+    display.error('[MONITOR]', ...args)
+  }
+}

package/src/tools/observable.ts

@@ -0,0 +1,104 @@
+import { queueMicrotask } from './queueMicrotask'
+
+export interface Subscription {
+  unsubscribe: () => void
+}
+
+type Observer<T> = (data: T) => void
+
+// eslint-disable-next-line no-restricted-syntax
+export class Observable<T> {
+  protected observers: Array<Observer<T>> = []
+  private onLastUnsubscribe?: () => void
+
+  constructor(private onFirstSubscribe?: (observable: Observable<T>) => (() => void) | void) {}
+
+  subscribe(observer: Observer<T>): Subscription {
+    this.addObserver(observer)
+    return {
+      unsubscribe: () => this.removeObserver(observer),
+    }
+  }
+
+  notify(data: T) {
+    this.observers.forEach((observer) => observer(data))
+  }
+
+  protected addObserver(observer: Observer<T>) {
+    this.observers.push(observer)
+    if (this.observers.length === 1 && this.onFirstSubscribe) {
+      this.onLastUnsubscribe = this.onFirstSubscribe(this) || undefined
+    }
+  }
+
+  protected removeObserver(observer: Observer<T>) {
+    this.observers = this.observers.filter((other) => observer !== other)
+    if (!this.observers.length && this.onLastUnsubscribe) {
+      this.onLastUnsubscribe()
+    }
+  }
+}
+
+export function mergeObservables<T>(...observables: Array<Observable<T>>) {
+  return new Observable<T>((globalObservable) => {
+    const subscriptions: Subscription[] = observables.map((observable) =>
+      observable.subscribe((data) => globalObservable.notify(data))
+    )
+    return () => subscriptions.forEach((subscription) => subscription.unsubscribe())
+  })
+}
+
+// eslint-disable-next-line no-restricted-syntax
+export class BufferedObservable<T> extends Observable<T> {
+  private buffer: T[] = []
+
+  constructor(private maxBufferSize: number) {
+    super()
+  }
+
+  notify(data: T) {
+    this.buffer.push(data)
+    if (this.buffer.length > this.maxBufferSize) {
+      this.buffer.shift()
+    }
+    super.notify(data)
+  }
+
+  subscribe(observer: Observer<T>): Subscription {
+    let closed = false
+
+    const subscription = {
+      unsubscribe: () => {
+        closed = true
+        this.removeObserver(observer)
+      },
+    }
+
+    queueMicrotask(() => {
+      for (const data of this.buffer) {
+        if (closed) {
+          return
+        }
+        observer(data)
+      }
+
+      if (!closed) {
+        this.addObserver(observer)
+      }
+    })
+
+    return subscription
+  }
+
+  /**
+   * Drop buffered data and don't buffer future data. This is to avoid leaking memory when it's not
+   * needed anymore. This can be seen as a performance optimization, and things will work probably
+   * even if this method isn't called, but still useful to clarify our intent and lowering our
+   * memory impact.
+   */
+  unbuffer() {
+    queueMicrotask(() => {
+      this.maxBufferSize = this.buffer.length = 0
+    })
+  }
+}

package/src/tools/queueMicrotask.ts

@@ -0,0 +1,13 @@
+import { monitor } from './monitor'
+import { globalObject } from './globalObject'
+
+export function queueMicrotask(callback: () => void) {
+  const nativeImplementation = globalObject.queueMicrotask?.bind(globalObject)
+
+  if (typeof nativeImplementation === 'function') {
+    nativeImplementation(monitor(callback))
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises -- the callback is monitored, so it'll never throw
+    Promise.resolve().then(monitor(callback))
+  }
+}

package/src/tools/readBytesFromStream.ts

@@ -0,0 +1,77 @@
+import { monitor } from './monitor'
+import { noop } from './utils/functionUtils'
+
+interface Options {
+  bytesLimit: number
+  collectStreamBody?: boolean
+}
+/**
+ * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of
+ * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit
+ * has been exceeded if more bytes were available.
+ */
+export function readBytesFromStream(
+  stream: ReadableStream<Uint8Array>,
+  callback: (error?: Error, bytes?: Uint8Array, limitExceeded?: boolean) => void,
+  options: Options
+) {
+  const reader = stream.getReader()
+  const chunks: Uint8Array[] = []
+  let readBytesCount = 0
+
+  readMore()
+
+  function readMore() {
+    reader.read().then(
+      monitor((result: ReadableStreamReadResult<Uint8Array>) => {
+        if (result.done) {
+          onDone()
+          return
+        }
+
+        if (options.collectStreamBody) {
+          chunks.push(result.value)
+        }
+        readBytesCount += result.value.length
+
+        if (readBytesCount > options.bytesLimit) {
+          onDone()
+        } else {
+          readMore()
+        }
+      }),
+      monitor((error) => callback(error))
+    )
+  }
+
+  function onDone() {
+    reader.cancel().catch(
+      // we don't care if cancel fails, but we still need to catch the error to avoid reporting it
+      // as an unhandled rejection
+      noop
+    )
+
+    let bytes: Uint8Array | undefined
+    let limitExceeded: boolean | undefined
+    if (options.collectStreamBody) {
+      let completeBuffer: Uint8Array
+      if (chunks.length === 1) {
+        // optimization: if the response is small enough to fit in a single buffer (provided by the browser), just
+        // use it directly.
+        completeBuffer = chunks[0]
+      } else {
+        // else, we need to copy buffers into a larger buffer to concatenate them.
+        completeBuffer = new Uint8Array(readBytesCount)
+        let offset = 0
+        chunks.forEach((chunk) => {
+          completeBuffer.set(chunk, offset)
+          offset += chunk.length
+        })
+      }
+      bytes = completeBuffer.slice(0, options.bytesLimit)
+      limitExceeded = completeBuffer.length > options.bytesLimit
+    }
+
+    callback(undefined, bytes, limitExceeded)
+  }
+}

package/src/tools/requestIdleCallback.ts

@@ -0,0 +1,40 @@
+import { setTimeout, clearTimeout } from './timer'
+import { monitor } from './monitor'
+import { dateNow } from './utils/timeUtils'
+
+// This type is not yet supported in TS 3.8. Imported from the TS source until we upgrade the
+// minimum supported TS version.
+// https://github.com/microsoft/TypeScript/blob/13c374a868c926f6a907666a5599992c1351b773/src/lib/dom.generated.d.ts#L9513-L9516
+export interface IdleDeadline {
+  readonly didTimeout: boolean
+  timeRemaining(): DOMHighResTimeStamp
+}
+
+/**
+ * 'requestIdleCallback' with a shim.
+ */
+export function requestIdleCallback(callback: (deadline: IdleDeadline) => void, opts?: { timeout?: number }) {
+  // Note: check both 'requestIdleCallback' and 'cancelIdleCallback' existence because some polyfills only implement 'requestIdleCallback'.
+  if (window.requestIdleCallback && window.cancelIdleCallback) {
+    const id = window.requestIdleCallback(monitor(callback), opts)
+    return () => window.cancelIdleCallback(id)
+  }
+  return requestIdleCallbackShim(callback)
+}
+
+export const MAX_TASK_TIME = 50
+
+/*
+ * Shim from https://developer.chrome.com/blog/using-requestidlecallback#checking_for_requestidlecallback
+ * Note: there is no simple way to support the "timeout" option, so we ignore it.
+ */
+export function requestIdleCallbackShim(callback: (deadline: IdleDeadline) => void) {
+  const start = dateNow()
+  const timeoutId = setTimeout(() => {
+    callback({
+      didTimeout: false,
+      timeRemaining: () => Math.max(0, MAX_TASK_TIME - (dateNow() - start)),
+    })
+  }, 0)
+  return () => clearTimeout(timeoutId)
+}

package/src/tools/sendToExtension.ts

@@ -0,0 +1,14 @@
+import { globalObject } from './globalObject'
+
+interface BrowserWindow {
+  __ddBrowserSdkExtensionCallback?: (message: unknown) => void
+}
+
+type ExtensionMessageType = 'logs' | 'record' | 'rum' | 'telemetry'
+
+export function sendToExtension(type: ExtensionMessageType, payload: unknown) {
+  const callback = (globalObject as BrowserWindow).__ddBrowserSdkExtensionCallback
+  if (callback) {
+    callback({ type, payload })
+  }
+}