@openobserve/browser-core 0.3.4 → 0.4.0-beta.2

package/src/domain/contexts/accountContext.ts

@@ -1,8 +1,8 @@
+import type { Hook } from '@openobserve/js-core/assembly'
+import { SKIPPED } from '@openobserve/js-core/assembly'
 import type { Configuration } from '../configuration'
 import { CustomerDataType } from '../context/contextConstants'
 import { storeContextManager } from '../context/storeContextManager'
-import { HookNames, SKIPPED } from '../../tools/abstractHooks'
-import type { AbstractHooks } from '../../tools/abstractHooks'
 import { isEmptyObject } from '../../tools/utils/objectUtils'
 import { createContextManager } from '../context/contextManager'
 
@@ -15,14 +15,14 @@ export interface Account {
   [key: string]: unknown
 }
 
-export function startAccountContext(hooks: AbstractHooks, configuration: Configuration, productKey: string) {
+export function startAccountContext(assembleHook: Hook<any, any>, configuration: Configuration, productKey: string) {
   const accountContextManager = buildAccountContextManager()
 
   if (configuration.storeContextsAcrossPages) {
-    storeContextManager(configuration, accountContextManager, productKey, CustomerDataType.Account)
+    storeContextManager(accountContextManager, productKey, CustomerDataType.Account)
   }
 
-  hooks.register(HookNames.Assemble, () => {
+  assembleHook.register(() => {
     const account = accountContextManager.getContext() as Account
 
     if (isEmptyObject(account) || !account.id) {

package/src/domain/contexts/globalContext.ts

@@ -1,12 +1,11 @@
-import type { AbstractHooks } from '../../tools/abstractHooks'
+import type { Hook } from '@openobserve/js-core/assembly'
 import { CustomerDataType } from '../context/contextConstants'
 import { storeContextManager } from '../context/storeContextManager'
-import { HookNames } from '../../tools/abstractHooks'
 import { createContextManager } from '../context/contextManager'
 import type { Configuration } from '../configuration'
 
 export function startGlobalContext(
-  hooks: AbstractHooks,
+  assembleHook: Hook<any, any>,
   configuration: Configuration,
   productKey: string,
   useContextNamespace: boolean
@@ -14,10 +13,10 @@ export function startGlobalContext(
   const globalContextManager = buildGlobalContextManager()
 
   if (configuration.storeContextsAcrossPages) {
-    storeContextManager(configuration, globalContextManager, productKey, CustomerDataType.GlobalContext)
+    storeContextManager(globalContextManager, productKey, CustomerDataType.GlobalContext)
   }
 
-  hooks.register(HookNames.Assemble, () => {
+  assembleHook.register(() => {
     const context = globalContextManager.getContext()
     return useContextNamespace ? { context } : context
   })

package/src/domain/contexts/tabContext.ts

@@ -0,0 +1,43 @@
+import type { Hook } from '@openobserve/js-core/assembly'
+import { generateUUID } from '../../tools/utils/stringUtils'
+
+export const TAB_ID_STORAGE_KEY = '_dd_tab_id'
+
+let cachedTabId: string | undefined
+
+// Exported for test cleanup only — allows specs to reset the in-memory cache between tests.
+export function resetCachedTabId(): void {
+  cachedTabId = undefined
+}
+
+export function startTabContext(assembleHook: Hook<any, any>) {
+  const tabId = retrieveOrCreateTabId()
+
+  assembleHook.register(() => ({
+    tab: {
+      id: tabId,
+    },
+  }))
+}
+
+function retrieveOrCreateTabId(): string {
+  if (!cachedTabId) {
+    cachedTabId = getOrCreateIdInSessionStorage() ?? generateUUID()
+  }
+  return cachedTabId
+}
+
+function getOrCreateIdInSessionStorage(): string | undefined {
+  try {
+    const existingId = sessionStorage.getItem(TAB_ID_STORAGE_KEY)
+    if (existingId) {
+      return existingId
+    }
+    const newId = generateUUID()
+    sessionStorage.setItem(TAB_ID_STORAGE_KEY, newId)
+    return newId
+  } catch {
+    // sessionStorage unavailable (e.g. Web Worker, sandboxed iframe, quota exceeded)
+    return undefined
+  }
+}

package/src/domain/contexts/telemetrySessionContext.ts

@@ -0,0 +1,26 @@
+import type { Hook } from '@openobserve/js-core/assembly'
+import { SKIPPED } from '@openobserve/js-core/assembly'
+import type { SessionManager } from '../session/sessionManager'
+import type { Context } from '../../tools/serialisation/context'
+
+export function startTelemetrySessionContext(
+  assembleTelemetryHook: Hook<any, any>,
+  sessionManager: SessionManager,
+  extraContext?: Context
+) {
+  assembleTelemetryHook.register(({ startTime }) => {
+    const session = sessionManager.findTrackedSession(startTime)
+
+    if (!session) {
+      return SKIPPED
+    }
+
+    return {
+      session: {
+        id: session.id,
+      },
+      anonymous_id: session.anonymousId,
+      ...extraContext,
+    }
+  })
+}

package/src/domain/contexts/userContext.ts

@@ -1,11 +1,11 @@
-import type { AbstractHooks } from '../../tools/abstractHooks'
+import type { RelativeTime } from '@openobserve/js-core/time'
+import type { Hook } from '@openobserve/js-core/assembly'
+import { SKIPPED } from '@openobserve/js-core/assembly'
 import { CustomerDataType } from '../context/contextConstants'
 import { storeContextManager } from '../context/storeContextManager'
-import { HookNames, SKIPPED } from '../../tools/abstractHooks'
 import { createContextManager } from '../context/contextManager'
 import type { Configuration } from '../configuration'
 import { isEmptyObject } from '../../tools/utils/objectUtils'
-import type { RelativeTime } from '../../tools/utils/timeUtils'
 
 export interface User {
   id?: string | undefined
@@ -15,7 +15,7 @@ export interface User {
 }
 
 export function startUserContext(
-  hooks: AbstractHooks,
+  hook: Hook<{ eventType?: string; startTime: RelativeTime }, { usr?: User }>,
   configuration: Configuration,
   sessionManager: {
     findTrackedSession: (startTime?: RelativeTime) => { anonymousId?: string } | undefined
@@ -25,14 +25,14 @@ export function startUserContext(
   const userContextManager = buildUserContextManager()
 
   if (configuration.storeContextsAcrossPages) {
-    storeContextManager(configuration, userContextManager, productKey, CustomerDataType.User)
+    storeContextManager(userContextManager, productKey, CustomerDataType.User)
   }
 
-  hooks.register(HookNames.Assemble, ({ eventType, startTime }) => {
+  hook.register(({ eventType, startTime }) => {
     const user = userContextManager.getContext()
     const session = sessionManager.findTrackedSession(startTime)
 
-    if (session && session.anonymousId && !user.anonymous_id && !!configuration.trackAnonymousUser) {
+    if (session?.anonymousId && !user.anonymous_id && !!configuration.trackAnonymousUser) {
       user.anonymous_id = session.anonymousId
     }
 
@@ -46,10 +46,6 @@ export function startUserContext(
     }
   })
 
-  hooks.register(HookNames.AssembleTelemetry, ({ startTime }) => ({
-    anonymous_id: sessionManager.findTrackedSession(startTime)?.anonymousId,
-  }))
-
   return userContextManager
 }
 

package/src/domain/error/error.ts

@@ -1,5 +1,6 @@
+import type { ClocksState } from '@openobserve/js-core/time'
+import { isIndexableObject } from '@openobserve/js-core/util'
 import { sanitize } from '../../tools/serialisation/sanitize'
-import type { ClocksState } from '../../tools/utils/timeUtils'
 import type { Context } from '../../tools/serialisation/context'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
 import type { StackTrace } from '../../tools/stackTrace/computeStackTrace'
@@ -21,6 +22,32 @@ interface RawErrorParams {
   handling: ErrorHandling
 }
 
+function computeErrorBase({
+  originalError,
+  stackTrace,
+  source,
+  useFallbackStack = true,
+  nonErrorPrefix,
+}: {
+  originalError: unknown
+  stackTrace?: StackTrace
+  source: ErrorSource
+  useFallbackStack?: boolean
+  nonErrorPrefix?: NonErrorPrefix
+}) {
+  const isErrorInstance = isError(originalError)
+  if (!stackTrace && isErrorInstance) {
+    stackTrace = computeStackTrace(originalError)
+  }
+
+  return {
+    source,
+    type: stackTrace ? stackTrace.name : undefined,
+    message: computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError),
+    stack: stackTrace ? toStackTraceString(stackTrace) : useFallbackStack ? NO_ERROR_STACK_PRESENT_MESSAGE : undefined,
+  }
+}
+
 export function computeRawError({
   stackTrace,
   originalError,
@@ -32,22 +59,16 @@ export function computeRawError({
   source,
   handling,
 }: RawErrorParams): RawError {
-  const isErrorInstance = isError(originalError)
-  if (!stackTrace && isErrorInstance) {
-    stackTrace = computeStackTrace(originalError)
-  }
+  const errorBase = computeErrorBase({ originalError, stackTrace, source, useFallbackStack, nonErrorPrefix })
 
   return {
     startClocks,
-    source,
     handling,
     handlingStack,
     componentStack,
     originalError,
-    type: stackTrace ? stackTrace.name : undefined,
-    message: computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError),
-    stack: stackTrace ? toStackTraceString(stackTrace) : useFallbackStack ? NO_ERROR_STACK_PRESENT_MESSAGE : undefined,
-    causes: isErrorInstance ? flattenErrorCauses(originalError as ErrorWithCause, source) : undefined,
+    ...errorBase,
+    causes: isError(originalError) ? flattenErrorCauses(originalError, source) : undefined,
     fingerprint: tryToGetFingerprint(originalError),
     context: tryToGetErrorContext(originalError),
   }
@@ -56,7 +77,7 @@ export function computeRawError({
 function computeMessage(
   stackTrace: StackTrace | undefined,
   isErrorInstance: boolean,
-  nonErrorPrefix: NonErrorPrefix,
+  nonErrorPrefix: NonErrorPrefix | undefined,
   originalError: unknown
 ) {
   // Favor stackTrace message only if tracekit has really been able to extract something meaningful (message + name)
@@ -64,7 +85,9 @@ function computeMessage(
   return stackTrace?.message && stackTrace?.name
     ? stackTrace.message
     : !isErrorInstance
-      ? `${nonErrorPrefix} ${jsonStringify(sanitize(originalError))!}`
+      ? nonErrorPrefix
+        ? `${nonErrorPrefix} ${jsonStringify(sanitize(originalError))!}`
+        : jsonStringify(sanitize(originalError))!
       : 'Empty message'
 }
 
@@ -73,8 +96,8 @@ export function tryToGetFingerprint(originalError: unknown) {
 }
 
 export function tryToGetErrorContext(originalError: unknown) {
-  if (originalError !== null && typeof originalError === 'object' && 'dd_context' in originalError) {
-    return originalError.dd_context as Context
+  if (isIndexableObject(originalError)) {
+    return originalError.dd_context as Context | undefined
   }
 }
 
@@ -83,21 +106,28 @@ export function getFileFromStackTraceString(stack: string) {
 }
 
 export function isError(error: unknown): error is Error {
-  return error instanceof Error || Object.prototype.toString.call(error) === '[object Error]'
+  try {
+    return error instanceof Error || Object.prototype.toString.call(error) === '[object Error]'
+  } catch {
+    return false
+  }
 }
 
 export function flattenErrorCauses(error: ErrorWithCause, parentSource: ErrorSource): RawErrorCause[] | undefined {
-  let currentError = error
   const causes: RawErrorCause[] = []
-  while (isError(currentError?.cause) && causes.length < 10) {
-    const stackTrace = computeStackTrace(currentError.cause)
-    causes.push({
-      message: currentError.cause.message,
+  let currentCause = error.cause
+
+  while (currentCause !== undefined && currentCause !== null && causes.length < 10) {
+    const causeBase = computeErrorBase({
+      originalError: currentCause,
       source: parentSource,
-      type: stackTrace?.name,
-      stack: stackTrace && toStackTraceString(stackTrace),
+      useFallbackStack: false,
     })
-    currentError = currentError.cause
+
+    causes.push(causeBase)
+
+    currentCause = isError(currentCause) ? (currentCause as ErrorWithCause).cause : undefined
   }
+
   return causes.length ? causes : undefined
 }

package/src/domain/error/error.types.ts

@@ -1,5 +1,5 @@
+import type { ClocksState } from '@openobserve/js-core/time'
 import type { Context } from '../../tools/serialisation/context'
-import type { ClocksState } from '../../tools/utils/timeUtils'
 
 // TS v4.6 introduced Error.cause[1] typed as `Error`. TS v4.8 changed Error.cause to be
 // `unknown`[2].

package/src/domain/error/trackRuntimeError.ts

@@ -1,9 +1,11 @@
+import { clocksNow } from '@openobserve/js-core/time'
 import { instrumentMethod } from '../../tools/instrumentMethod'
 import { Observable } from '../../tools/observable'
-import { clocksNow } from '../../tools/utils/timeUtils'
 import type { StackTrace } from '../../tools/stackTrace/computeStackTrace'
 import { computeStackTraceFromOnErrorMessage } from '../../tools/stackTrace/computeStackTrace'
-import { getGlobalObject } from '../../tools/globalObject'
+import { globalObject } from '../../tools/globalObject'
+import { DOM_EVENT, isEventSupported } from '../../browser/addEventListener'
+import { noop } from '../../tools/utils/functionUtils'
 import { computeRawError, isError } from './error'
 import type { RawError } from './error.types'
 import { ErrorHandling, ErrorSource, NonErrorPrefix } from './error.types'
@@ -34,7 +36,7 @@ export function trackRuntimeError() {
 }
 
 export function instrumentOnError(callback: UnhandledErrorCallback) {
-  return instrumentMethod(getGlobalObject(), 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {
+  return instrumentMethod(globalObject, 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {
     let stackTrace
     if (!isError(errorObj)) {
       stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column)
@@ -44,7 +46,12 @@ export function instrumentOnError(callback: UnhandledErrorCallback) {
 }
 
 export function instrumentUnhandledRejection(callback: UnhandledErrorCallback) {
-  return instrumentMethod(getGlobalObject(), 'onunhandledrejection', ({ parameters: [e] }) => {
+  // Salesforce LWS does not support the unhandledrejection event. https://developer.salesforce.com/tools/lws-distortion-viewer
+  if (!isEventSupported(globalObject.window, DOM_EVENT.UNHANDLED_REJECTION)) {
+    return { stop: noop }
+  }
+
+  return instrumentMethod(globalObject, 'onunhandledrejection', ({ parameters: [e] }) => {
     callback(e.reason || 'Empty reason')
   })
 }

package/src/domain/eventRateLimiter/createEventRateLimiter.ts

@@ -1,5 +1,5 @@
+import { ONE_MINUTE, clocksNow } from '@openobserve/js-core/time'
 import { setTimeout } from '../../tools/timer'
-import { clocksNow, ONE_MINUTE } from '../../tools/utils/timeUtils'
 import type { RawError } from '../error/error.types'
 import { ErrorSource } from '../error/error.types'
 

package/src/domain/intakeSites.ts

@@ -4,15 +4,20 @@ export type Site =
   | 'us5.datadoghq.com'
   | 'datadoghq.eu'
   | 'ddog-gov.com'
+  | 'us2.ddog-gov.com'
   | 'ap1.datadoghq.com'
   | 'ap2.datadoghq.com'
   | (string & {})
 
 export const INTAKE_SITE_STAGING: Site = 'datad0g.com'
-export const INTAKE_SITE_FED_STAGING: Site = 'dd0g-gov.com'
 export const INTAKE_SITE_US1: Site = 'datadoghq.com'
 export const INTAKE_SITE_EU1: Site = 'datadoghq.eu'
 export const INTAKE_SITE_US1_FED: Site = 'ddog-gov.com'
+export const INTAKE_SITE_US2_FED: Site = 'us2.ddog-gov.com'
 
-export const PCI_INTAKE_HOST_US1 = 'pci.browser-intake-datadoghq.com'
-export const INTAKE_URL_PARAMETERS = ['ddsource', 'dd-api-key', 'dd-request-id']
+export const INTAKE_URL_PARAMETERS = ['o2source', 'o2-api-key', 'o2-request-id']
+
+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/report/reportObservable.ts

@@ -1,12 +1,11 @@
+import { clocksNow } from '@openobserve/js-core/time'
 import { toStackTraceString } from '../../tools/stackTrace/handlingStack'
 import { monitor } from '../../tools/monitor'
 import { mergeObservables, Observable } from '../../tools/observable'
-import { addEventListener, DOM_EVENT } from '../../browser/addEventListener'
+import { addEventListener, DOM_EVENT, isEventSupported } from '../../browser/addEventListener'
 import { safeTruncate } from '../../tools/utils/stringUtils'
-import type { Configuration } from '../configuration'
 import type { RawError } from '../error/error.types'
 import { ErrorHandling, ErrorSource } from '../error/error.types'
-import { clocksNow } from '../../tools/utils/timeUtils'
 import type { ReportType, InterventionReport, DeprecationReport } from './browser.types'
 
 export const RawReportType = {
@@ -21,11 +20,11 @@ export type RawReportError = RawError & {
   originalError: SecurityPolicyViolationEvent | DeprecationReport | InterventionReport
 }
 
-export function initReportObservable(configuration: Configuration, apis: RawReportType[]) {
+export function initReportObservable(apis: RawReportType[]) {
   const observables: Array<Observable<RawReportError>> = []
 
   if (apis.includes(RawReportType.cspViolation)) {
-    observables.push(createCspViolationReportObservable(configuration))
+    observables.push(createCspViolationReportObservable())
   }
 
   const reportTypes = apis.filter((api: RawReportType): api is ReportType => api !== RawReportType.cspViolation)
@@ -58,9 +57,14 @@ function createReportObservable(reportTypes: ReportType[]) {
   })
 }
 
-function createCspViolationReportObservable(configuration: Configuration) {
+function createCspViolationReportObservable() {
   return new Observable<RawReportError>((observable) => {
-    const { stop } = addEventListener(configuration, document, DOM_EVENT.SECURITY_POLICY_VIOLATION, (event) => {
+    // Salesforce does not allow to add a securitypolicyviolation event listener. https://developer.salesforce.com/tools/lws-distortion-viewer
+    if (!isEventSupported(document, DOM_EVENT.SECURITY_POLICY_VIOLATION)) {
+      return
+    }
+
+    const { stop } = addEventListener(document, DOM_EVENT.SECURITY_POLICY_VIOLATION, (event) => {
       observable.notify(buildRawReportErrorFromCspViolation(event))
     })
 

package/src/domain/sampler.ts

@@ -0,0 +1,64 @@
+export function correctedChildSampleRate(parentRate: number, childRate: number): number {
+  return (parentRate * childRate) / 100
+}
+
+const sampleDecisionCache: Map<number, { sessionId: string; decision: boolean }> = new Map()
+
+export function isSampled(sessionId: string, sampleRate: number): boolean {
+  // Shortcuts for common cases. This is not strictly necessary, but it makes the code faster for
+  // customers willing to ingest all traces.
+  if (sampleRate === 100) {
+    return true
+  }
+
+  if (sampleRate === 0) {
+    return false
+  }
+
+  const cachedDecision = sampleDecisionCache.get(sampleRate)
+  if (sessionId === cachedDecision?.sessionId) {
+    return cachedDecision.decision
+  }
+
+  const decision = sampleUsingKnuthFactor(BigInt(`0x${sessionId.split('-')[4]}`), sampleRate)
+  sampleDecisionCache.set(sampleRate, { sessionId, decision })
+  return decision
+}
+
+// Exported for tests
+export function resetSampleDecisionCache() {
+  sampleDecisionCache.clear()
+}
+
+/**
+ * Perform sampling using the Knuth factor method. This method offer consistent sampling result
+ * based on the provided identifier.
+ *
+ * @param identifier - The identifier to use for sampling.
+ * @param sampleRate - The sample rate in percentage between 0 and 100.
+ */
+export function sampleUsingKnuthFactor(identifier: bigint, sampleRate: number): boolean {
+  // The formula is:
+  //
+  //   (identifier * knuthFactor) % 2^64 < sampleRate * 2^64
+  //
+  // Because JavaScript numbers are 64-bit floats, we can't represent 64-bit integers, and the
+  // modulo would be incorrect. Thus, we are using BigInts here.
+  //
+  // Implementation in other languages:
+  // * Go     https://github.com/DataDog/dd-trace-go/blob/ec6fbb1f2d517b7b8e69961052adf7136f3af773/ddtrace/tracer/sampler.go#L86-L91
+  // * Python https://github.com/DataDog/dd-trace-py/blob/0cee2f066fb6e79aa15947c1514c0f406dea47c5/ddtrace/sampling_rule.py#L197
+  // * Ruby   https://github.com/DataDog/dd-trace-rb/blob/1a6e255cdcb7e7e22235ea5955f90f6dfa91045d/lib/datadog/tracing/sampling/rate_sampler.rb#L42
+  // * C++    https://github.com/DataDog/dd-trace-cpp/blob/159629edc438ae45f2bb318eb7bd51abd05e94b5/src/datadog/trace_sampler.cpp#L58
+  // * Java   https://github.com/DataDog/dd-trace-java/blob/896dd6b380533216e0bdee59614606c8272d313e/dd-trace-core/src/main/java/datadog/trace/common/sampling/DeterministicSampler.java#L48
+  //
+  // Note: All implementations have slight variations. Some of them use '<=' instead of '<', and
+  // use `sampleRate * 2^64 - 1` instead of `sampleRate * 2^64`. The following implementation
+  // should adhere to the spec and is a bit simpler than using a 2^64-1 limit as there are less
+  // BigInt arithmetic to write. In practice this does not matter, as we are using floating point
+  // numbers in the end, and Number(2n**64n-1n) === Number(2n**64n).
+  const knuthFactor = 1111111111111111111n
+  const twoPow64 = 2n ** 64n
+  const hash = (identifier * knuthFactor) % twoPow64
+  return Number(hash) <= (sampleRate / 100) * Number(twoPow64)
+}

package/src/domain/session/sessionConstants.ts

@@ -1,4 +1,4 @@
-import { ONE_HOUR, ONE_MINUTE, ONE_YEAR } from '../../tools/utils/timeUtils'
+import { ONE_HOUR, ONE_MINUTE, ONE_YEAR } from '@openobserve/js-core/time'
 
 export const SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR
 export const SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE
@@ -10,6 +10,7 @@ export const SESSION_NOT_TRACKED = '0'
  */
 export const SessionPersistence = {
   COOKIE: 'cookie',
+  MEMORY: 'memory',
   LOCAL_STORAGE: 'local-storage',
 } as const