@kubesense/kubesense-browser-core 1.0.0

package/src/tools/encoder.ts

@@ -0,0 +1,103 @@
+import type { Uint8ArrayBuffer } from './utils/byteUtils'
+import { computeBytesCount } from './utils/byteUtils'
+
+export interface Encoder<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {
+  /**
+   * Whether this encoder might call the provided callbacks asynchronously
+   */
+  isAsync: boolean
+
+  /**
+   * Whether some data has been written since the last finish() or finishSync() call
+   */
+  isEmpty: boolean
+
+  /**
+   * Write a string to be encoded.
+   *
+   * This operation can be synchronous or asynchronous depending on the encoder implementation.
+   *
+   * If specified, the callback will be invoked when the operation finishes, unless the operation is
+   * asynchronous and finish() or finishSync() is called in the meantime.
+   */
+  write(data: string, callback?: (additionalEncodedBytesCount: number) => void): void
+
+  /**
+   * Waits for pending data to be encoded and resets the encoder state.
+   *
+   * This operation can be synchronous or asynchronous depending on the encoder implementation.
+   *
+   * The callback will be invoked when the operation finishes, unless the operation is asynchronous
+   * and another call to finish() or finishSync() occurs in the meantime.
+   */
+  finish(callback: (result: EncoderResult<Output>) => void): void
+
+  /**
+   * Resets the encoder state then returns the encoded data and any potential pending data directly,
+   * discarding all pending write operations and finish() callbacks.
+   */
+  finishSync(): EncoderResult<Output> & { pendingData: string }
+
+  /**
+   * Returns a rough estimation of the bytes count if the data was encoded.
+   */
+  estimateEncodedBytesCount(data: string): number
+}
+
+export interface EncoderResult<Output extends string | Uint8ArrayBuffer = string | Uint8ArrayBuffer> {
+  output: Output
+  outputBytesCount: number
+
+  /**
+   * An encoding type supported by HTTP Content-Encoding, if applicable.
+   * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding#directives
+   */
+  encoding?: 'deflate'
+
+  /**
+   * Total bytes count of the input strings encoded to UTF-8.
+   */
+  rawBytesCount: number
+}
+
+export function createIdentityEncoder(): Encoder<string> {
+  let output = ''
+  let outputBytesCount = 0
+
+  return {
+    isAsync: false,
+
+    get isEmpty() {
+      return !output
+    },
+
+    write(data, callback) {
+      const additionalEncodedBytesCount = computeBytesCount(data)
+      outputBytesCount += additionalEncodedBytesCount
+      output += data
+      if (callback) {
+        callback(additionalEncodedBytesCount)
+      }
+    },
+
+    finish(callback) {
+      callback(this.finishSync())
+    },
+
+    finishSync() {
+      const result = {
+        output,
+        outputBytesCount,
+        rawBytesCount: outputBytesCount,
+        pendingData: '',
+      }
+      output = ''
+      outputBytesCount = 0
+      return result
+    },
+
+    estimateEncodedBytesCount(data) {
+      return data.length
+    },
+  }
+}

package/src/tools/experimentalFeatures.ts

@@ -0,0 +1,52 @@
+/**
+ * LIMITATION:
+ * For NPM setup, this feature flag singleton is shared between RUM and Logs product.
+ * This means that an experimental flag set on the RUM product will be set on the Logs product.
+ * So keep in mind that in certain configurations, your experimental feature flag may affect other products.
+ *
+ * FORMAT:
+ * All feature flags should be snake_cased
+ */
+// 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 {
+  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)
+  })
+}
+
+export function isExperimentalFeatureEnabled(featureName: ExperimentalFeature): boolean {
+  return enabledExperimentalFeatures.has(featureName)
+}
+
+export function resetExperimentalFeatures(): void {
+  enabledExperimentalFeatures.clear()
+}
+
+export function getExperimentalFeatures(): Set<ExperimentalFeature> {
+  return enabledExperimentalFeatures
+}

package/src/tools/getZoneJsOriginalValue.ts

@@ -0,0 +1,38 @@
+import { getGlobalObject } from './globalObject'
+
+export interface BrowserWindowWithZoneJs extends Window {
+  Zone?: {
+    // All Zone.js versions expose the __symbol__ method, but we observed that some website have a
+    // 'Zone' global variable unrelated to Zone.js, so let's consider this method optional
+    // nonetheless.
+    __symbol__?: (name: string) => string
+  }
+}
+
+/**
+ * Gets the original value for a DOM API that was potentially patched by Zone.js.
+ *
+ * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original
+ * value of the patched functions/constructors/methods in a hidden property prefixed by
+ * __zone_symbol__.
+ *
+ * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to
+ * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to
+ * use the original DOM API instead of the one patched by Zone.js.
+ *
+ * [1]: https://github.com/angular/angular/tree/main/packages/zone.js
+ */
+export function getZoneJsOriginalValue<Target, Name extends keyof Target & string>(
+  target: Target,
+  name: Name
+): Target[Name] {
+  const browserWindow = getGlobalObject<BrowserWindowWithZoneJs>()
+  let original: Target[Name] | undefined
+  if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {
+    original = (target as any)[browserWindow.Zone.__symbol__(name)]
+  }
+  if (!original) {
+    original = target[name]
+  }
+  return original
+}

package/src/tools/globalObject.ts

@@ -0,0 +1,51 @@
+/**
+ * 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
+  }
+  Object.defineProperty(Object.prototype, '_kubesense_temp_', {
+    get() {
+      return this as object
+    },
+    configurable: true,
+  })
+  // @ts-ignore _kubesense_temp is defined using defineProperty
+  let globalObject: unknown = _kubesense_temp_
+  // @ts-ignore _kubesense_temp is defined using defineProperty
+  delete Object.prototype._kubesense_temp_
+  if (typeof globalObject !== 'object') {
+    // on safari _kubesense_temp_ is available on window but not globally
+    // fallback on other browser globals check
+    if (typeof self === 'object') {
+      globalObject = self
+    } else if (typeof window === 'object') {
+      globalObject = window
+    } else {
+      globalObject = {}
+    }
+  }
+  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

@@ -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>(
+  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 && typeof method === 'string' && method.startsWith('on')) {
+      original = noop as TARGET[METHOD]
+    } else {
+      return { stop: noop }
+    }
+  }
+
+  let stopped = false
+
+  const instrumentation = function (this: TARGET): ReturnType<TARGET[METHOD]> {
+    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,71 @@
+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: ThisParameterType<T>, ...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[]) => unknown>(fn: T): T {
+  return function (this: ThisParameterType<T>, ...args: Parameters<T>) {
+    return callMonitored(fn, this, args)
+  } as unknown as T // consider output type has input type
+}
+
+export function callMonitored<T extends (...args: any[]) => unknown>(
+  fn: T,
+  context: ThisParameterType<T>,
+  args: Parameters<T>
+): ReturnType<T> | undefined
+export function callMonitored<T extends (this: void) => unknown>(fn: T): ReturnType<T> | undefined
+export function callMonitored<T extends (...args: any[]) => unknown>(
+  fn: T,
+  context?: any,
+  args?: any
+): ReturnType<T> | undefined {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return fn.apply(context, args) as ReturnType<T>
+  } catch (e) {
+    monitorError(e)
+  }
+}
+
+export function monitorError(e: unknown) {
+  displayIfDebugEnabled(e)
+  if (onMonitorErrorCollected) {
+    try {
+      onMonitorErrorCollected(e)
+    } catch (e) {
+      displayIfDebugEnabled(e)
+    }
+  }
+}
+
+export function displayIfDebugEnabled(...args: unknown[]) {
+  if (debugMode) {
+    display.error('[MONITOR]', ...args)
+  }
+}