@openobserve/browser-core 0.2.8

package/src/domain/user/user.types.ts

@@ -0,0 +1,6 @@
+export interface User {
+  id?: string | undefined
+  email?: string | undefined
+  name?: string | undefined
+  [key: string]: unknown
+}

package/src/index.ts

@@ -0,0 +1,128 @@
+export {
+  Configuration,
+  InitConfiguration,
+  validateAndBuildConfiguration,
+  DefaultPrivacyLevel,
+  EndpointBuilder,
+  serializeConfiguration,
+  INTAKE_SITE_AP1,
+  INTAKE_SITE_STAGING,
+  INTAKE_SITE_US1,
+  INTAKE_SITE_US1_FED,
+  INTAKE_SITE_EU1,
+} from './domain/configuration'
+export {
+  isExperimentalFeatureEnabled,
+  addExperimentalFeatures,
+  resetExperimentalFeatures,
+  getExperimentalFeatures,
+  ExperimentalFeature,
+} from './tools/experimentalFeatures'
+export { trackRuntimeError } from './domain/error/trackRuntimeError'
+export { computeStackTrace, StackTrace } from './domain/tracekit'
+export { defineGlobal, makePublicApi } from './boot/init'
+export { initReportObservable, RawReport, RawReportType } from './domain/report/reportObservable'
+export {
+  startTelemetry,
+  Telemetry,
+  RawTelemetryEvent,
+  RawTelemetryConfiguration,
+  addTelemetryDebug,
+  addTelemetryError,
+  startFakeTelemetry,
+  resetTelemetry,
+  TelemetryEvent,
+  TelemetryErrorEvent,
+  TelemetryDebugEvent,
+  TelemetryConfigurationEvent,
+  TelemetryService,
+  isTelemetryReplicationAllowed,
+  addTelemetryConfiguration,
+} 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 {
+  SESSION_TIME_OUT_DELAY, // Exposed for tests
+} from './domain/session/sessionConstants'
+export {
+  HttpRequest,
+  Payload,
+  createHttpRequest,
+  canUseEventBridge,
+  getEventBridge,
+  startBatchWithReplica,
+  createFlushController,
+  FlushEvent,
+  FlushReason,
+} from './transport'
+export * from './tools/display'
+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 { 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 { getZoneJsOriginalValue } from './tools/getZoneJsOriginalValue'
+export { instrumentMethod, instrumentMethodAndCallOriginal, instrumentSetter } from './tools/instrumentMethod'
+export {
+  computeRawError,
+  createHandlingStack,
+  toStackTraceString,
+  getFileFromStackTraceString,
+  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 * from './browser/addEventListener'
+export * from './tools/timer'
+export { initConsoleObservable, resetConsoleObservable, ConsoleLog } from './domain/console/consoleObservable'
+export { BoundedBuffer } from './tools/boundedBuffer'
+export { catchUserErrors } from './tools/catchUserErrors'
+export { createContextManager, ContextManager } from './tools/serialisation/contextManager'
+export {
+  warnIfCustomerDataLimitReached,
+  CustomerDataType,
+  CUSTOMER_DATA_BYTES_LIMIT,
+} from './tools/serialisation/heavyCustomerDataWarning'
+export { ValueHistory, ValueHistoryEntry, CLEAR_OLD_VALUES_INTERVAL } from './tools/valueHistory'
+export { readBytesFromStream } from './tools/readBytesFromStream'
+export { STORAGE_POLL_DELAY } from './domain/session/sessionStore'
+export { SESSION_STORE_KEY } from './domain/session/storeStrategies/sessionStoreStrategy'
+export {
+  willSyntheticsInjectRum,
+  getSyntheticsTestId,
+  getSyntheticsResultId,
+} from './domain/synthetics/syntheticsWorkerValues'
+export { User, checkUser, sanitizeUser } from './domain/user'
+export * from './domain/resourceUtils'
+export * from './tools/utils/polyfills'
+export * from './tools/utils/numberUtils'
+export * from './tools/utils/byteUtils'
+export * from './tools/utils/objectUtils'
+export * from './tools/utils/functionUtils'
+export * from './tools/serialisation/jsonStringify'
+export * from './tools/mergeInto'
+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 * from './domain/deflate'

package/src/tools/abstractLifeCycle.ts

@@ -0,0 +1,45 @@
+import type { Subscription } from './observable'
+
+/**
+ * Type helper to extract event types that have "void" data. This allows to call `notify` without a
+ * second argument. Ex:
+ *
+ * ```
+ * interface EventMap {
+ *   foo: void
+ * }
+ * const LifeCycle = AbstractLifeCycle<EventMap>
+ * new LifeCycle().notify('foo')
+ * ```
+ */
+type EventTypesWithoutData<EventMap> = {
+  [K in keyof EventMap]: EventMap[K] extends void ? K : never
+}[keyof EventMap]
+
+export class AbstractLifeCycle<EventMap> {
+  private callbacks: { [key in keyof EventMap]?: Array<(data: any) => void> } = {}
+
+  notify<EventType extends EventTypesWithoutData<EventMap>>(eventType: EventType): void
+  notify<EventType extends keyof EventMap>(eventType: EventType, data: EventMap[EventType]): void
+  notify(eventType: keyof EventMap, data?: unknown) {
+    const eventCallbacks = this.callbacks[eventType]
+    if (eventCallbacks) {
+      eventCallbacks.forEach((callback) => callback(data))
+    }
+  }
+
+  subscribe<EventType extends keyof EventMap>(
+    eventType: EventType,
+    callback: (data: EventMap[EventType]) => void
+  ): Subscription {
+    if (!this.callbacks[eventType]) {
+      this.callbacks[eventType] = []
+    }
+    this.callbacks[eventType]!.push(callback)
+    return {
+      unsubscribe: () => {
+        this.callbacks[eventType] = this.callbacks[eventType]!.filter((other) => callback !== other)
+      },
+    }
+  }
+}

package/src/tools/boundedBuffer.ts

@@ -0,0 +1,17 @@
+const BUFFER_LIMIT = 500
+
+export class BoundedBuffer {
+  private buffer: Array<() => void> = []
+
+  add(callback: () => void) {
+    const length = this.buffer.push(callback)
+    if (length > BUFFER_LIMIT) {
+      this.buffer.splice(0, 1)
+    }
+  }
+
+  drain() {
+    this.buffer.forEach((callback) => callback())
+    this.buffer.length = 0
+  }
+}

package/src/tools/catchUserErrors.ts

@@ -0,0 +1,11 @@
+import { display } from './display'
+
+export function catchUserErrors<Args extends any[], R>(fn: (...args: Args) => R, errorMsg: string) {
+  return (...args: Args) => {
+    try {
+      return fn(...args)
+    } catch (err) {
+      display.error(errorMsg, err)
+    }
+  }
+}

package/src/tools/display.ts

@@ -0,0 +1,51 @@
+/* eslint-disable local-rules/disallow-side-effects */
+/**
+ * Keep references on console methods to avoid triggering patched behaviors
+ *
+ * NB: in some setup, console could already be patched by another SDK.
+ * In this case, some display messages can be sent by the other SDK
+ * but we should be safe from infinite loop nonetheless.
+ */
+
+export const ConsoleApiName = {
+  log: 'log',
+  debug: 'debug',
+  info: 'info',
+  warn: 'warn',
+  error: 'error',
+} as const
+
+export type ConsoleApiName = (typeof ConsoleApiName)[keyof typeof ConsoleApiName]
+
+interface Display {
+  (api: ConsoleApiName, ...args: any[]): void
+  debug: typeof console.debug
+  log: typeof console.log
+  info: typeof console.info
+  warn: typeof console.warn
+  error: typeof console.error
+}
+
+export const display: Display = (api, ...args) => {
+  if (!Object.prototype.hasOwnProperty.call(ConsoleApiName, api)) {
+    api = ConsoleApiName.log
+  }
+  display[api](...args)
+}
+
+/**
+ * When building JS bundles, some users might use a plugin[1] or configuration[2] to remove
+ * "console.*" references. This causes some issue as we expect `console.*` to be defined.
+ * As a workaround, let's use a variable alias, so those expressions won't be taken into account by
+ * simple static analysis.
+ *
+ * [1]: https://babeljs.io/docs/babel-plugin-transform-remove-console/
+ * [2]: https://github.com/terser/terser#compress-options (look for drop_console)
+ */
+export const globalConsole = console
+
+display.debug = globalConsole.debug.bind(globalConsole)
+display.log = globalConsole.log.bind(globalConsole)
+display.info = globalConsole.info.bind(globalConsole)
+display.warn = globalConsole.warn.bind(globalConsole)
+display.error = globalConsole.error.bind(globalConsole)

package/src/tools/experimentalFeatures.ts

@@ -0,0 +1,43 @@
+/**
+ * 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
+// eslint-disable-next-line no-restricted-syntax
+export enum ExperimentalFeature {
+  PAGEHIDE = 'pagehide',
+  FEATURE_FLAGS = 'feature_flags',
+  RESOURCE_PAGE_STATES = 'resource_page_states',
+  PAGE_STATES = 'page_states',
+  COLLECT_FLUSH_REASON = 'collect_flush_reason',
+  NO_RESOURCE_DURATION_FROZEN_STATE = 'no_resource_duration_frozen_state',
+  SCROLLMAP = 'scrollmap',
+  INTERACTION_TO_NEXT_PAINT = 'interaction_to_next_paint',
+  DISABLE_REPLAY_INLINE_CSS = 'disable_replay_inline_css',
+}
+
+const enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()
+
+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/getGlobalObject.ts

@@ -0,0 +1,31 @@
+/**
+ * inspired by https://mathiasbynens.be/notes/globalthis
+ */
+
+export function getGlobalObject<T = typeof globalThis>(): T {
+  if (typeof globalThis === 'object') {
+    return globalThis as unknown as T
+  }
+  Object.defineProperty(Object.prototype, '_oo_temp_', {
+    get() {
+      return this as object
+    },
+    configurable: true,
+  })
+  // @ts-ignore _oo_temp is defined using defineProperty
+  let globalObject: unknown = _oo_temp_
+  // @ts-ignore _oo_temp is defined using defineProperty
+  delete Object.prototype._oo_temp_
+  if (typeof globalObject !== 'object') {
+    // on safari _oo_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
+}

package/src/tools/getZoneJsOriginalValue.ts

@@ -0,0 +1,38 @@
+import { getGlobalObject } from './getGlobalObject'
+
+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/instrumentMethod.ts

@@ -0,0 +1,109 @@
+import { setTimeout } from './timer'
+import { callMonitored } from './monitor'
+import { noop } from './utils/functionUtils'
+
+export function instrumentMethod<OBJECT extends { [key: string]: any }, METHOD extends keyof OBJECT>(
+  object: OBJECT,
+  method: METHOD,
+  instrumentationFactory: (
+    original: OBJECT[METHOD]
+  ) => (this: OBJECT, ...args: Parameters<OBJECT[METHOD]>) => ReturnType<OBJECT[METHOD]>
+) {
+  const original = object[method]
+
+  let instrumentation = instrumentationFactory(original)
+
+  const instrumentationWrapper = function (this: OBJECT): ReturnType<OBJECT[METHOD]> | undefined {
+    if (typeof instrumentation !== 'function') {
+      return undefined
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return instrumentation.apply(this, arguments as unknown as Parameters<OBJECT[METHOD]>)
+  }
+  object[method] = instrumentationWrapper as OBJECT[METHOD]
+
+  return {
+    stop: () => {
+      if (object[method] === instrumentationWrapper) {
+        object[method] = original
+      } else {
+        instrumentation = original
+      }
+    },
+  }
+}
+
+export function instrumentMethodAndCallOriginal<OBJECT extends { [key: string]: any }, METHOD extends keyof OBJECT>(
+  object: OBJECT,
+  method: METHOD,
+  {
+    before,
+    after,
+  }: {
+    before?: (this: OBJECT, ...args: Parameters<OBJECT[METHOD]>) => void
+    after?: (this: OBJECT, ...args: Parameters<OBJECT[METHOD]>) => void
+  }
+) {
+  return instrumentMethod(
+    object,
+    method,
+    (original) =>
+      function () {
+        const args = arguments as unknown as Parameters<OBJECT[METHOD]>
+        let result
+
+        if (before) {
+          callMonitored(before, this, args)
+        }
+
+        if (typeof original === 'function') {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+          result = original.apply(this, args)
+        }
+
+        if (after) {
+          callMonitored(after, this, args)
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return result
+      }
+  )
+}
+
+export function instrumentSetter<OBJECT extends { [key: string]: any }, PROPERTY extends keyof OBJECT>(
+  object: OBJECT,
+  property: PROPERTY,
+  after: (thisObject: OBJECT, value: OBJECT[PROPERTY]) => void
+) {
+  const originalDescriptor = Object.getOwnPropertyDescriptor(object, property)
+  if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {
+    return { stop: noop }
+  }
+
+  let instrumentation = (thisObject: OBJECT, value: OBJECT[PROPERTY]) => {
+    // put hooked setter into event loop to avoid of set latency
+    setTimeout(() => {
+      after(thisObject, value)
+    }, 0)
+  }
+
+  const instrumentationWrapper = function (this: OBJECT, value: OBJECT[PROPERTY]) {
+    originalDescriptor.set!.call(this, value)
+    instrumentation(this, value)
+  }
+
+  Object.defineProperty(object, property, {
+    set: instrumentationWrapper,
+  })
+
+  return {
+    stop: () => {
+      if (Object.getOwnPropertyDescriptor(object, property)?.set === instrumentationWrapper) {
+        Object.defineProperty(object, property, originalDescriptor)
+      } else {
+        instrumentation = noop
+      }
+    },
+  }
+}

package/src/tools/matchOption.ts

@@ -0,0 +1,32 @@
+import { startsWith } from './utils/polyfills'
+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 ? startsWith(value, item) : item === value
+      }
+    } catch (e) {
+      display.error(e)
+    }
+    return false
+  })
+}