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

package/src/index.ts

@@ -1,115 +1,151 @@
+export type { Configuration, InitConfiguration, EndpointBuilder, ProxyFn } from './domain/configuration'
 export {
-  Configuration,
-  InitConfiguration,
   validateAndBuildConfiguration,
   DefaultPrivacyLevel,
-  EndpointBuilder,
+  TraceContextInjection,
   serializeConfiguration,
-  INTAKE_SITE_AP1,
-  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/tracekit'
+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 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, instrumentMethodAndCallOriginal, instrumentSetter } 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 './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 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 { 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'
@@ -120,9 +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

@@ -18,7 +18,6 @@ export const ConsoleApiName = {
 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
@@ -26,13 +25,6 @@ interface Display {
   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.
@@ -44,8 +36,21 @@ export const display: Display = (api, ...args) => {
  */
 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)
+export const originalConsoleMethods = {} as Display
+Object.keys(ConsoleApiName).forEach((name) => {
+  originalConsoleMethods[name as ConsoleApiName] = globalConsole[name as ConsoleApiName]
+})
+
+const PREFIX = 'Datadog Browser SDK:'
+
+export const display: Display = {
+  debug: originalConsoleMethods.debug.bind(globalConsole, PREFIX),
+  log: originalConsoleMethods.log.bind(globalConsole, PREFIX),
+  info: originalConsoleMethods.info.bind(globalConsole, PREFIX),
+  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

@@ -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

@@ -9,21 +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',
-  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',
+  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