@openobserve/browser-core 0.2.8

package/src/tools/serialisation/sanitize.ts

@@ -0,0 +1,255 @@
+import { display } from '../display'
+import { ONE_KIBI_BYTE } from '../utils/byteUtils'
+import type { Context, ContextArray, ContextValue } from './context'
+import type { ObjectWithToJsonMethod } from './jsonStringify'
+import { detachToJsonMethod } from './jsonStringify'
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type PrimitivesAndFunctions = string | number | boolean | undefined | null | symbol | bigint | Function
+type ExtendedContextValue = PrimitivesAndFunctions | object | ExtendedContext | ExtendedContextArray
+type ExtendedContext = { [key: string]: ExtendedContextValue }
+type ExtendedContextArray = ExtendedContextValue[]
+
+type ContainerElementToProcess = {
+  source: ExtendedContextArray | ExtendedContext
+  target: ContextArray | Context
+  path: string
+}
+
+// The maximum size of a single event is 256KiB. By default, we ensure that user-provided data
+// going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...
+const SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE
+
+// Symbol for the root element of the JSONPath used for visited objects
+const JSON_PATH_ROOT_ELEMENT = '$'
+
+// When serializing (using JSON.stringify) a key of an object, { key: 42 } gets wrapped in quotes as "key".
+// With the separator (:), we need to add 3 characters to the count.
+const KEY_DECORATION_LENGTH = 3
+
+/**
+ * Ensures user-provided data is 'safe' for the SDK
+ * - Deep clones data
+ * - Removes cyclic references
+ * - Transforms unserializable types to a string representation
+ *
+ * LIMITATIONS:
+ * - Size is in characters, not byte count (may differ according to character encoding)
+ * - Size does not take into account indentation that can be applied to JSON.stringify
+ * - Non-numerical properties of Arrays are ignored. Same behavior as JSON.stringify
+ *
+ * @param source              User-provided data meant to be serialized using JSON.stringify
+ * @param maxCharacterCount   Maximum number of characters allowed in serialized form
+ */
+export function sanitize(source: string, maxCharacterCount?: number): string | undefined
+export function sanitize(source: Context, maxCharacterCount?: number): Context
+export function sanitize(source: unknown, maxCharacterCount?: number): ContextValue
+export function sanitize(source: unknown, maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT) {
+  // Unbind any toJSON function we may have on [] or {} prototypes
+  const restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype)
+  const restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype)
+
+  // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object
+  const containerQueue: ContainerElementToProcess[] = []
+  const visitedObjectsWithPath = new WeakMap<object, string>()
+  const sanitizedData = sanitizeProcessor(
+    source as ExtendedContextValue,
+    JSON_PATH_ROOT_ELEMENT,
+    undefined,
+    containerQueue,
+    visitedObjectsWithPath
+  )
+  let accumulatedCharacterCount = JSON.stringify(sanitizedData)?.length || 0
+  if (accumulatedCharacterCount > maxCharacterCount) {
+    warnOverCharacterLimit(maxCharacterCount, 'discarded', source)
+    return undefined
+  }
+
+  while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {
+    const containerToProcess = containerQueue.shift()!
+    let separatorLength = 0 // 0 for the first element, 1 for subsequent elements
+
+    // Arrays and Objects have to be handled distinctly to ensure
+    // we do not pick up non-numerical properties from Arrays
+    if (Array.isArray(containerToProcess.source)) {
+      for (let key = 0; key < containerToProcess.source.length; key++) {
+        const targetData = sanitizeProcessor(
+          containerToProcess.source[key],
+          containerToProcess.path,
+          key,
+          containerQueue,
+          visitedObjectsWithPath
+        )
+
+        if (targetData !== undefined) {
+          accumulatedCharacterCount += JSON.stringify(targetData).length
+        } else {
+          // When an element of an Array (targetData) is undefined, it is serialized as null:
+          // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters
+          accumulatedCharacterCount += 4
+        }
+        accumulatedCharacterCount += separatorLength
+        separatorLength = 1
+        if (accumulatedCharacterCount > maxCharacterCount) {
+          warnOverCharacterLimit(maxCharacterCount, 'truncated', source)
+          break
+        }
+        ;(containerToProcess.target as ContextArray)[key] = targetData
+      }
+    } else {
+      for (const key in containerToProcess.source) {
+        if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {
+          const targetData = sanitizeProcessor(
+            containerToProcess.source[key],
+            containerToProcess.path,
+            key,
+            containerQueue,
+            visitedObjectsWithPath
+          )
+          // When a property of an object has an undefined value, it will be dropped during serialization:
+          // JSON.stringify({a:undefined}) => '{}'
+          if (targetData !== undefined) {
+            accumulatedCharacterCount +=
+              JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH
+            separatorLength = 1
+          }
+          if (accumulatedCharacterCount > maxCharacterCount) {
+            warnOverCharacterLimit(maxCharacterCount, 'truncated', source)
+            break
+          }
+          ;(containerToProcess.target as Context)[key] = targetData
+        }
+      }
+    }
+  }
+
+  // Rebind detached toJSON functions
+  restoreObjectPrototypeToJson()
+  restoreArrayPrototypeToJson()
+
+  return sanitizedData
+}
+
+/**
+ * Internal function to factorize the process common to the
+ * initial call to sanitize, and iterations for Arrays and Objects
+ *
+ */
+function sanitizeProcessor(
+  source: ExtendedContextValue,
+  parentPath: string,
+  key: string | number | undefined,
+  queue: ContainerElementToProcess[],
+  visitedObjectsWithPath: WeakMap<object, string>
+) {
+  // Start by handling toJSON, as we want to sanitize its output
+  const sourceToSanitize = tryToApplyToJSON(source)
+
+  if (!sourceToSanitize || typeof sourceToSanitize !== 'object') {
+    return sanitizePrimitivesAndFunctions(sourceToSanitize)
+  }
+
+  const sanitizedSource = sanitizeObjects(sourceToSanitize)
+  if (sanitizedSource !== '[Object]' && sanitizedSource !== '[Array]' && sanitizedSource !== '[Error]') {
+    return sanitizedSource
+  }
+
+  // Handle potential cyclic references
+  // We need to use source as sourceToSanitize could be a reference to a new object
+  // At this stage, we know the source is an object type
+  const sourceAsObject = source as object
+  if (visitedObjectsWithPath.has(sourceAsObject)) {
+    return `[Reference seen at ${visitedObjectsWithPath.get(sourceAsObject)!}]`
+  }
+
+  // Add processed source to queue
+  const currentPath = key !== undefined ? `${parentPath}.${key}` : parentPath
+  const target = Array.isArray(sourceToSanitize) ? ([] as ContextArray) : ({} as Context)
+  visitedObjectsWithPath.set(sourceAsObject, currentPath)
+  queue.push({ source: sourceToSanitize as ExtendedContext | ExtendedContextArray, target, path: currentPath })
+
+  return target
+}
+
+/**
+ * Handles sanitization of simple, non-object types
+ *
+ */
+function sanitizePrimitivesAndFunctions(value: PrimitivesAndFunctions) {
+  // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation
+  if (typeof value === 'bigint') {
+    return `[BigInt] ${value.toString()}`
+  }
+  // Functions cannot be serialized by JSON.stringify(). Moreover, if a faulty toJSON is present, it needs to be converted
+  // so it won't prevent stringify from serializing later
+  if (typeof value === 'function') {
+    return `[Function] ${value.name || 'unknown'}`
+  }
+  // JSON.stringify() does not serialize symbols.
+  if (typeof value === 'symbol') {
+    // symbol.description is part of ES2019+
+    type symbolWithDescription = symbol & { description: string }
+    return `[Symbol] ${(value as symbolWithDescription).description || value.toString()}`
+  }
+
+  return value
+}
+
+/**
+ * Handles sanitization of object types
+ *
+ * LIMITATIONS
+ * - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.
+ * To avoid this, a toJSON method can be defined.
+ * - IE11 does not return a distinct type for objects such as Map, WeakMap, ... These objects will pass through and their
+ * properties enumerated if any.
+ *
+ */
+function sanitizeObjects(value: object) {
+  try {
+    // Handle events - Keep a simple implementation to avoid breaking changes
+    if (value instanceof Event) {
+      return {
+        isTrusted: value.isTrusted,
+      }
+    }
+
+    // Handle all remaining object types in a generic way
+    const result = Object.prototype.toString.call(value)
+    const match = result.match(/\[object (.*)\]/)
+    if (match && match[1]) {
+      return `[${match[1]}]`
+    }
+  } catch {
+    // If the previous serialization attempts failed, and we cannot convert using
+    // Object.prototype.toString, declare the value unserializable
+  }
+  return '[Unserializable]'
+}
+
+/**
+ * Checks if a toJSON function exists and tries to execute it
+ *
+ */
+function tryToApplyToJSON(value: ExtendedContextValue) {
+  const object = value as ObjectWithToJsonMethod
+  if (object && typeof object.toJSON === 'function') {
+    try {
+      return object.toJSON() as ExtendedContextValue
+    } catch {
+      // If toJSON fails, we continue by trying to serialize the value manually
+    }
+  }
+
+  return value
+}
+
+/**
+ * Helper function to display the warning when the accumulated character count is over the limit
+ */
+function warnOverCharacterLimit(maxCharacterCount: number, changeType: 'discarded' | 'truncated', source: unknown) {
+  display.warn(
+    `The data provided has been ${changeType} as it is over the limit of ${maxCharacterCount} characters:`,
+    source
+  )
+}

package/src/tools/timer.ts

@@ -0,0 +1,21 @@
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
+import { monitor } from './monitor'
+import { getGlobalObject } from './getGlobalObject'
+
+export type TimeoutId = ReturnType<typeof globalThis.setTimeout>
+
+export function setTimeout(callback: () => void, delay?: number): TimeoutId {
+  return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(monitor(callback), delay)
+}
+
+export function clearTimeout(timeoutId: TimeoutId | undefined) {
+  getZoneJsOriginalValue(getGlobalObject(), 'clearTimeout')(timeoutId)
+}
+
+export function setInterval(callback: () => void, delay?: number): TimeoutId {
+  return getZoneJsOriginalValue(getGlobalObject(), 'setInterval')(monitor(callback), delay)
+}
+
+export function clearInterval(timeoutId: TimeoutId | undefined) {
+  getZoneJsOriginalValue(getGlobalObject(), 'clearInterval')(timeoutId)
+}

package/src/tools/utils/arrayUtils.ts

@@ -0,0 +1,7 @@
+import { arrayFrom } from './polyfills'
+
+export function removeDuplicates<T>(array: T[]) {
+  const set = new Set<T>()
+  array.forEach((item) => set.add(item))
+  return arrayFrom(set)
+}

package/src/tools/utils/browserDetection.ts

@@ -0,0 +1,7 @@
+export function isIE() {
+  return Boolean((document as any).documentMode)
+}
+
+export function isChromium() {
+  return !!(window as any).chrome || /HeadlessChrome/.test(window.navigator.userAgent)
+}

package/src/tools/utils/byteUtils.ts

@@ -0,0 +1,29 @@
+export const ONE_KIBI_BYTE = 1024
+export const ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE
+
+// eslint-disable-next-line no-control-regex
+const HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/
+
+export function computeBytesCount(candidate: string): number {
+  // Accurate bytes count computations can degrade performances when there is a lot of events to process
+  if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {
+    return candidate.length
+  }
+
+  if (window.TextEncoder !== undefined) {
+    return new TextEncoder().encode(candidate).length
+  }
+
+  return new Blob([candidate]).size
+}
+
+export function concatBuffers(buffers: Uint8Array[]) {
+  const length = buffers.reduce((total, buffer) => total + buffer.length, 0)
+  const result = new Uint8Array(length)
+  let offset = 0
+  for (const buffer of buffers) {
+    result.set(buffer, offset)
+    offset += buffer.length
+  }
+  return result
+}

package/src/tools/utils/functionUtils.ts

@@ -0,0 +1,47 @@
+import type { TimeoutId } from '../timer'
+import { setTimeout, clearTimeout } from '../timer'
+
+// use lodash API
+export function throttle<T extends (...args: any[]) => void>(
+  fn: T,
+  wait: number,
+  options?: { leading?: boolean; trailing?: boolean }
+) {
+  const needLeadingExecution = options && options.leading !== undefined ? options.leading : true
+  const needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true
+  let inWaitPeriod = false
+  let pendingExecutionWithParameters: Parameters<T> | undefined
+  let pendingTimeoutId: TimeoutId
+
+  return {
+    throttled: (...parameters: Parameters<T>) => {
+      if (inWaitPeriod) {
+        pendingExecutionWithParameters = parameters
+        return
+      }
+      if (needLeadingExecution) {
+        fn(...parameters)
+      } else {
+        pendingExecutionWithParameters = parameters
+      }
+      inWaitPeriod = true
+      pendingTimeoutId = setTimeout(() => {
+        if (needTrailingExecution && pendingExecutionWithParameters) {
+          fn(...pendingExecutionWithParameters)
+        }
+        inWaitPeriod = false
+        pendingExecutionWithParameters = undefined
+      }, wait)
+    },
+    cancel: () => {
+      clearTimeout(pendingTimeoutId)
+      inWaitPeriod = false
+      pendingExecutionWithParameters = undefined
+    },
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export function noop() {}
+
+export type ListenerHandler = () => void

package/src/tools/utils/numberUtils.ts

@@ -0,0 +1,19 @@
+/**
+ * Return true if the draw is successful
+ * @param threshold between 0 and 100
+ */
+export function performDraw(threshold: number): boolean {
+  return threshold !== 0 && Math.random() * 100 <= threshold
+}
+
+export function round(num: number, decimals: 0 | 1 | 2 | 3 | 4) {
+  return +num.toFixed(decimals)
+}
+
+export function isPercentage(value: unknown) {
+  return isNumber(value) && value >= 0 && value <= 100
+}
+
+export function isNumber(value: unknown): value is number {
+  return typeof value === 'number'
+}

package/src/tools/utils/objectUtils.ts

@@ -0,0 +1,21 @@
+import { assign } from './polyfills'
+
+export function shallowClone<T>(object: T): T & Record<string, never> {
+  return assign({}, object)
+}
+
+export function objectHasValue<T extends { [key: string]: unknown }>(object: T, value: unknown): value is T[keyof T] {
+  return Object.keys(object).some((key) => object[key] === value)
+}
+
+export function isEmptyObject(object: object) {
+  return Object.keys(object).length === 0
+}
+
+export function mapValues<A, B>(object: { [key: string]: A }, fn: (arg: A) => B) {
+  const newObject: { [key: string]: B } = {}
+  for (const key of Object.keys(object)) {
+    newObject[key] = fn(object[key])
+  }
+  return newObject
+}

package/src/tools/utils/polyfills.ts

@@ -0,0 +1,127 @@
+export function includes(candidate: string, search: string): boolean
+export function includes<T>(candidate: T[], search: T): boolean
+export function includes(candidate: string | unknown[], search: any) {
+  return candidate.indexOf(search) !== -1
+}
+
+export function arrayFrom<T>(arrayLike: ArrayLike<T> | Set<T>): T[] {
+  if (Array.from) {
+    return Array.from(arrayLike)
+  }
+
+  const array = []
+
+  if (arrayLike instanceof Set) {
+    arrayLike.forEach((item) => array.push(item))
+  } else {
+    for (let i = 0; i < arrayLike.length; i++) {
+      array.push(arrayLike[i])
+    }
+  }
+
+  return array
+}
+
+export function find<T, S extends T>(
+  array: ArrayLike<T>,
+  predicate: (item: T, index: number) => item is S
+): S | undefined
+export function find<T>(array: ArrayLike<T>, predicate: (item: T, index: number) => boolean): T | undefined
+export function find(
+  array: ArrayLike<unknown>,
+  predicate: (item: unknown, index: number) => boolean
+): unknown | undefined {
+  for (let i = 0; i < array.length; i += 1) {
+    const item = array[i]
+    if (predicate(item, i)) {
+      return item
+    }
+  }
+  return undefined
+}
+
+export function findLast<T, S extends T>(
+  array: T[],
+  predicate: (item: T, index: number, array: T[]) => item is S
+): S | undefined {
+  for (let i = array.length - 1; i >= 0; i -= 1) {
+    const item = array[i]
+    if (predicate(item, i, array)) {
+      return item
+    }
+  }
+  return undefined
+}
+
+export function forEach<List extends { [index: number]: any }>(
+  list: List,
+  callback: (value: List[number], index: number, parent: List) => void
+) {
+  Array.prototype.forEach.call(list, callback as any)
+}
+
+export function objectValues<T = unknown>(object: { [key: string]: T }) {
+  return Object.keys(object).map((key) => object[key])
+}
+
+export function objectEntries<T = unknown>(object: { [key: string]: T }): Array<[string, T]> {
+  return Object.keys(object).map((key) => [key, object[key]])
+}
+
+export function startsWith(candidate: string, search: string) {
+  return candidate.slice(0, search.length) === search
+}
+
+export function endsWith(candidate: string, search: string) {
+  return candidate.slice(-search.length) === search
+}
+
+export function elementMatches(element: Element & { msMatchesSelector?(selector: string): boolean }, selector: string) {
+  if (element.matches) {
+    return element.matches(selector)
+  }
+  // IE11 support
+  if (element.msMatchesSelector) {
+    return element.msMatchesSelector(selector)
+  }
+  return false
+}
+
+// https://github.com/jquery/jquery/blob/a684e6ba836f7c553968d7d026ed7941e1a612d8/src/selector/escapeSelector.js
+export function cssEscape(str: string) {
+  if (window.CSS && window.CSS.escape) {
+    return window.CSS.escape(str)
+  }
+
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g, function (ch, asCodePoint) {
+    if (asCodePoint) {
+      // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
+      if (ch === '\0') {
+        return '\uFFFD'
+      }
+      // Control characters and (dependent upon position) numbers get escaped as code points
+      return `${ch.slice(0, -1)}\\${ch.charCodeAt(ch.length - 1).toString(16)} `
+    }
+    // Other potentially-special ASCII characters get backslash-escaped
+    return `\\${ch}`
+  })
+}
+
+interface Assignable {
+  [key: string]: any
+}
+
+export function assign<T, U>(target: T, source: U): T & U
+export function assign<T, U, V>(target: T, source1: U, source2: V): T & U & V
+export function assign<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W
+export function assign(target: Assignable, ...toAssign: Assignable[]) {
+  toAssign.forEach((source: Assignable) => {
+    for (const key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = source[key]
+      }
+    }
+  })
+  return target
+}

package/src/tools/utils/responseUtils.ts

@@ -0,0 +1,12 @@
+export function isServerError(status: number) {
+  return status >= 500
+}
+
+export function tryToClone(response: Response): Response | undefined {
+  try {
+    return response.clone()
+  } catch (e) {
+    // clone can throw if the response has already been used by another instrumentation or is disturbed
+    return
+  }
+}

package/src/tools/utils/stringUtils.ts

@@ -0,0 +1,28 @@
+/**
+ * UUID v4
+ * from https://gist.github.com/jed/982883
+ */
+export function generateUUID(placeholder?: string): string {
+  return placeholder
+    ? // eslint-disable-next-line  no-bitwise
+      (parseInt(placeholder, 10) ^ ((Math.random() * 16) >> (parseInt(placeholder, 10) / 4))).toString(16)
+    : `${1e7}-${1e3}-${4e3}-${8e3}-${1e11}`.replace(/[018]/g, generateUUID)
+}
+
+export function findCommaSeparatedValue(rawString: string, name: string) {
+  const regex = new RegExp(`(?:^|;)\\s*${name}\\s*=\\s*([^;]+)`)
+  const matches = regex.exec(rawString)
+  return matches ? matches[1] : undefined
+}
+
+export function safeTruncate(candidate: string, length: number, suffix = '') {
+  const lastChar = candidate.charCodeAt(length - 1)
+  const isLastCharSurrogatePair = lastChar >= 0xd800 && lastChar <= 0xdbff
+  const correctedLength = isLastCharSurrogatePair ? length + 1 : length
+
+  if (candidate.length <= correctedLength) {
+    return candidate
+  }
+
+  return `${candidate.slice(0, correctedLength)}${suffix}`
+}