@openobserve/browser-core 0.3.3 → 0.4.0-beta.1

package/src/domain/configuration/transportConfiguration.ts

@@ -1,78 +0,0 @@
-import type { Site } from '../intakeSites'
-import { INTAKE_SITE_US1, INTAKE_URL_PARAMETERS } from '../intakeSites'
-import type { InitConfiguration } from './configuration'
-import type { EndpointBuilder } from './endpointBuilder'
-import { createEndpointBuilder } from './endpointBuilder'
-
-export interface TransportConfiguration {
-  logsEndpointBuilder: EndpointBuilder
-  rumEndpointBuilder: EndpointBuilder
-  sessionReplayEndpointBuilder: EndpointBuilder
-  profilingEndpointBuilder: EndpointBuilder
-  exposuresEndpointBuilder: EndpointBuilder
-  datacenter?: string | undefined
-  replica?: ReplicaConfiguration
-  site: Site
-  source: 'browser' | 'flutter' | 'unity'
-}
-
-export interface ReplicaConfiguration {
-  logsEndpointBuilder: EndpointBuilder
-  rumEndpointBuilder: EndpointBuilder
-}
-
-export function computeTransportConfiguration(initConfiguration: InitConfiguration): TransportConfiguration {
-  const site = initConfiguration.site || INTAKE_SITE_US1
-  const source = validateSource(initConfiguration.source)
-
-  const endpointBuilders = computeEndpointBuilders({ ...initConfiguration, site, source })
-  const replicaConfiguration = computeReplicaConfiguration({ ...initConfiguration, site, source })
-
-  return {
-    replica: replicaConfiguration,
-    site,
-    source,
-    ...endpointBuilders,
-  }
-}
-
-function validateSource(source: string | undefined) {
-  if (source === 'flutter' || source === 'unity') {
-    return source
-  }
-  return 'browser'
-}
-
-function computeEndpointBuilders(initConfiguration: InitConfiguration) {
-  return {
-    logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs'),
-    rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum'),
-    profilingEndpointBuilder: createEndpointBuilder(initConfiguration, 'profile'),
-    sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'replay'),
-    exposuresEndpointBuilder: createEndpointBuilder(initConfiguration, 'exposures'),
-  }
-}
-
-function computeReplicaConfiguration(initConfiguration: InitConfiguration): ReplicaConfiguration | undefined {
-  if (!initConfiguration.replica) {
-    return
-  }
-
-  const replicaConfiguration: InitConfiguration = {
-    ...initConfiguration,
-    site: INTAKE_SITE_US1,
-    clientToken: initConfiguration.replica.clientToken,
-  }
-
-  return {
-    logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs'),
-    rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', [
-      `application.id=${initConfiguration.replica.applicationId}`,
-    ]),
-  }
-}
-
-export function isIntakeUrl(url: string): boolean {
-  // check if tags is present in the query string
-  return INTAKE_URL_PARAMETERS.every((param) => url.includes(param))
-}

package/src/domain/session/oldCookiesMigration.ts

@@ -1,42 +0,0 @@
-import { getInitCookie } from '../../browser/cookie'
-import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
-import { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy'
-import type { SessionState } from './sessionState'
-import { expandSessionState, isSessionStarted } from './sessionState'
-
-export const OLD_SESSION_COOKIE_NAME = '_oo'
-export const OLD_RUM_COOKIE_NAME = '_oo_r'
-export const OLD_LOGS_COOKIE_NAME = '_oo_l'
-
-// duplicate values to avoid dependency issues
-export const RUM_SESSION_KEY = 'rum'
-export const LOGS_SESSION_KEY = 'logs'
-
-/**
- * This migration should remain in the codebase as long as older versions are available/live
- * to allow older sdk versions to be upgraded to newer versions without compatibility issues.
- */
-export function tryOldCookiesMigration(cookieStoreStrategy: SessionStoreStrategy) {
-  const sessionString = getInitCookie(SESSION_STORE_KEY)
-  if (!sessionString) {
-    const oldSessionId = getInitCookie(OLD_SESSION_COOKIE_NAME)
-    const oldRumType = getInitCookie(OLD_RUM_COOKIE_NAME)
-    const oldLogsType = getInitCookie(OLD_LOGS_COOKIE_NAME)
-    const session: SessionState = {}
-
-    if (oldSessionId) {
-      session.id = oldSessionId
-    }
-    if (oldLogsType && /^[01]$/.test(oldLogsType)) {
-      session[LOGS_SESSION_KEY] = oldLogsType
-    }
-    if (oldRumType && /^[012]$/.test(oldRumType)) {
-      session[RUM_SESSION_KEY] = oldRumType
-    }
-
-    if (isSessionStarted(session)) {
-      expandSessionState(session)
-      cookieStoreStrategy.persistSession(session)
-    }
-  }
-}

package/src/domain/session/sessionStoreOperations.ts

@@ -1,131 +0,0 @@
-import { setTimeout } from '../../tools/timer'
-import { generateUUID } from '../../tools/utils/stringUtils'
-import type { TimeStamp } from '../../tools/utils/timeUtils'
-import { elapsed, ONE_SECOND, timeStampNow } from '../../tools/utils/timeUtils'
-import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
-import type { SessionState } from './sessionState'
-import { expandSessionState, isSessionInExpiredState } from './sessionState'
-
-interface Operations {
-  process: (sessionState: SessionState) => SessionState | undefined
-  after?: (sessionState: SessionState) => void
-}
-
-export const LOCK_RETRY_DELAY = 10
-export const LOCK_MAX_TRIES = 100
-
-// Locks should be hold for a few milliseconds top, just the time it takes to read and write a
-// cookie. Using one second should be enough in most situations.
-export const LOCK_EXPIRATION_DELAY = ONE_SECOND
-const LOCK_SEPARATOR = '--'
-
-const bufferedOperations: Operations[] = []
-let ongoingOperations: Operations | undefined
-
-export function processSessionStoreOperations(
-  operations: Operations,
-  sessionStoreStrategy: SessionStoreStrategy,
-  numberOfRetries = 0
-) {
-  const { isLockEnabled, persistSession, expireSession } = sessionStoreStrategy
-  const persistWithLock = (session: SessionState) => persistSession({ ...session, lock: currentLock })
-  const retrieveStore = () => {
-    const { lock, ...session } = sessionStoreStrategy.retrieveSession()
-    return {
-      session,
-      lock: lock && !isLockExpired(lock) ? lock : undefined,
-    }
-  }
-
-  if (!ongoingOperations) {
-    ongoingOperations = operations
-  }
-  if (operations !== ongoingOperations) {
-    bufferedOperations.push(operations)
-    return
-  }
-  if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
-    next(sessionStoreStrategy)
-    return
-  }
-  let currentLock: string
-  let currentStore = retrieveStore()
-  if (isLockEnabled) {
-    // if someone has lock, retry later
-    if (currentStore.lock) {
-      retryLater(operations, sessionStoreStrategy, numberOfRetries)
-      return
-    }
-    // acquire lock
-    currentLock = createLock()
-    persistWithLock(currentStore.session)
-    // if lock is not acquired, retry later
-    currentStore = retrieveStore()
-    if (currentStore.lock !== currentLock) {
-      retryLater(operations, sessionStoreStrategy, numberOfRetries)
-      return
-    }
-  }
-  let processedSession = operations.process(currentStore.session)
-  if (isLockEnabled) {
-    // if lock corrupted after process, retry later
-    currentStore = retrieveStore()
-    if (currentStore.lock !== currentLock!) {
-      retryLater(operations, sessionStoreStrategy, numberOfRetries)
-      return
-    }
-  }
-  if (processedSession) {
-    if (isSessionInExpiredState(processedSession)) {
-      expireSession(processedSession)
-    } else {
-      expandSessionState(processedSession)
-      if (isLockEnabled) {
-        persistWithLock(processedSession)
-      } else {
-        persistSession(processedSession)
-      }
-    }
-  }
-  if (isLockEnabled) {
-    // correctly handle lock around expiration would require to handle this case properly at several levels
-    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it
-    if (!(processedSession && isSessionInExpiredState(processedSession))) {
-      // if lock corrupted after persist, retry later
-      currentStore = retrieveStore()
-      if (currentStore.lock !== currentLock!) {
-        retryLater(operations, sessionStoreStrategy, numberOfRetries)
-        return
-      }
-      persistSession(currentStore.session)
-      processedSession = currentStore.session
-    }
-  }
-  // call after even if session is not persisted in order to perform operations on
-  // up-to-date session state value => the value could have been modified by another tab
-  operations.after?.(processedSession || currentStore.session)
-  next(sessionStoreStrategy)
-}
-
-function retryLater(operations: Operations, sessionStore: SessionStoreStrategy, currentNumberOfRetries: number) {
-  setTimeout(() => {
-    processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1)
-  }, LOCK_RETRY_DELAY)
-}
-
-function next(sessionStore: SessionStoreStrategy) {
-  ongoingOperations = undefined
-  const nextOperations = bufferedOperations.shift()
-  if (nextOperations) {
-    processSessionStoreOperations(nextOperations, sessionStore)
-  }
-}
-
-export function createLock(): string {
-  return generateUUID() + LOCK_SEPARATOR + timeStampNow()
-}
-
-function isLockExpired(lock: string) {
-  const [, timeStamp] = lock.split(LOCK_SEPARATOR)
-  return !timeStamp || elapsed(Number(timeStamp) as TimeStamp, timeStampNow()) > LOCK_EXPIRATION_DELAY
-}

package/src/tools/abstractHooks.ts

@@ -1,72 +0,0 @@
-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/boundedBuffer.ts

@@ -1,45 +0,0 @@
-import { removeItem } from './utils/arrayUtils'
-
-const BUFFER_LIMIT = 500
-
-/**
- * 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> = []
-
-  const add: BoundedBuffer<T>['add'] = (callback: (arg: T) => void) => {
-    const length = buffer.push(callback)
-    if (length > BUFFER_LIMIT) {
-      buffer.splice(0, 1)
-    }
-  }
-
-  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/mergeInto.ts

@@ -1,177 +0,0 @@
-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/utils/timeUtils.ts

@@ -1,117 +0,0 @@
-import { isNumber, round } from './numberUtils'
-
-export const ONE_SECOND = 1000
-export const ONE_MINUTE = 60 * ONE_SECOND
-export const ONE_HOUR = 60 * ONE_MINUTE
-export const ONE_DAY = 24 * ONE_HOUR
-export const ONE_YEAR = 365 * ONE_DAY
-
-export type Duration = number & { d: 'Duration in ms' }
-export type ServerDuration = number & { s: 'Duration in ns' }
-export type TimeStamp = number & { t: 'Epoch time' }
-export type RelativeTime = number & { r: 'Time relative to navigation start' } & { d: 'Duration in ms' }
-export interface ClocksState {
-  relative: RelativeTime
-  timeStamp: TimeStamp
-}
-
-export function relativeToClocks(relative: RelativeTime) {
-  return { relative, timeStamp: getCorrectedTimeStamp(relative) }
-}
-
-export function timeStampToClocks(timeStamp: TimeStamp) {
-  return { relative: getRelativeTime(timeStamp), timeStamp }
-}
-
-function getCorrectedTimeStamp(relativeTime: RelativeTime) {
-  const correctedOrigin = (dateNow() - performance.now()) as TimeStamp
-  // apply correction only for positive drift
-  if (correctedOrigin > getNavigationStart()) {
-    return Math.round(addDuration(correctedOrigin, relativeTime)) as TimeStamp
-  }
-  return getTimeStamp(relativeTime)
-}
-
-export function currentDrift() {
-  return Math.round(dateNow() - addDuration(getNavigationStart(), performance.now() as Duration))
-}
-
-export function toServerDuration(duration: Duration): ServerDuration
-export function toServerDuration(duration: Duration | undefined): ServerDuration | undefined
-export function toServerDuration(duration: Duration | undefined) {
-  if (!isNumber(duration)) {
-    return duration
-  }
-  return round(duration * 1e6, 0) as ServerDuration
-}
-
-export function dateNow() {
-  // Do not use `Date.now` because sometimes websites are wrongly "polyfilling" it. For example, we
-  // had some users using a very old version of `datejs`, which patched `Date.now` to return a Date
-  // instance instead of a timestamp[1]. Those users are unlikely to fix this, so let's handle this
-  // case ourselves.
-  // [1]: https://github.com/datejs/Datejs/blob/97f5c7c58c5bc5accdab8aa7602b6ac56462d778/src/core-debug.js#L14-L16
-  return new Date().getTime()
-}
-
-export function timeStampNow() {
-  return dateNow() as TimeStamp
-}
-
-export function relativeNow() {
-  return performance.now() as RelativeTime
-}
-
-export function clocksNow() {
-  return { relative: relativeNow(), timeStamp: timeStampNow() }
-}
-
-export function clocksOrigin() {
-  return { relative: 0 as RelativeTime, timeStamp: getNavigationStart() }
-}
-
-export function elapsed(start: TimeStamp, end: TimeStamp): Duration
-export function elapsed(start: RelativeTime, end: RelativeTime): Duration
-export function elapsed(start: number, end: number) {
-  return (end - start) as Duration
-}
-
-export function addDuration(a: TimeStamp, b: Duration): TimeStamp
-export function addDuration(a: RelativeTime, b: Duration): RelativeTime
-export function addDuration(a: Duration, b: Duration): Duration
-export function addDuration(a: number, b: number) {
-  return a + b
-}
-
-// Get the time since the navigation was started.
-export function getRelativeTime(timestamp: TimeStamp) {
-  return (timestamp - getNavigationStart()) as RelativeTime
-}
-
-export function getTimeStamp(relativeTime: RelativeTime) {
-  return Math.round(addDuration(getNavigationStart(), relativeTime)) as TimeStamp
-}
-
-export function looksLikeRelativeTime(time: RelativeTime | TimeStamp): time is RelativeTime {
-  return time < ONE_YEAR
-}
-
-/**
- * Navigation start slightly change on some rare cases
- */
-let navigationStart: TimeStamp | undefined
-
-/**
- * Notes: this does not use `performance.timeOrigin` because:
- * - It doesn't seem to reflect the actual time on which the navigation has started: it may be much farther in the past,
- * at least in Firefox 71. (see: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926)
- * - It is not supported in Safari <15
- */
-function getNavigationStart() {
-  if (navigationStart === undefined) {
-    // ServiceWorkers do not support navigationStart (it's deprecated), so we fallback to timeOrigin
-    navigationStart = (performance.timing?.navigationStart ?? performance.timeOrigin) as TimeStamp
-  }
-
-  return navigationStart
-}

package/src/tools/utils/typeUtils.ts

@@ -1,12 +0,0 @@
-/**
- * Similar to `typeof`, but distinguish plain objects from `null` and arrays
- */
-export function getType(value: unknown) {
-  if (value === null) {
-    return 'null'
-  }
-  if (Array.isArray(value)) {
-    return 'array'
-  }
-  return typeof value
-}