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

package/src/domain/context/storeContextManager.ts

@@ -0,0 +1,55 @@
+import { addEventListener, DOM_EVENT } from '../../browser/addEventListener'
+import type { Context } from '../../tools/serialisation/context'
+import type { Configuration } from '../configuration'
+import { combine } from '../../tools/mergeInto'
+import { isEmptyObject } from '../../tools/utils/objectUtils'
+import type { ContextManager } from './contextManager'
+import type { CustomerDataType } from './contextConstants'
+
+const CONTEXT_STORE_KEY_PREFIX = '_dd_c'
+
+const storageListeners: Array<{ stop: () => void }> = []
+
+export function storeContextManager(
+  configuration: Configuration,
+  contextManager: ContextManager,
+  productKey: string,
+  customerDataType: CustomerDataType
+) {
+  const storageKey = buildStorageKey(productKey, customerDataType)
+
+  storageListeners.push(
+    addEventListener(configuration, window, DOM_EVENT.STORAGE, ({ key }) => {
+      if (storageKey === key) {
+        synchronizeWithStorage()
+      }
+    })
+  )
+  contextManager.changeObservable.subscribe(dumpToStorage)
+
+  const contextFromStorage = combine(getFromStorage(), contextManager.getContext())
+  if (!isEmptyObject(contextFromStorage)) {
+    contextManager.setContext(contextFromStorage)
+  }
+
+  function synchronizeWithStorage() {
+    contextManager.setContext(getFromStorage())
+  }
+
+  function dumpToStorage() {
+    localStorage.setItem(storageKey, JSON.stringify(contextManager.getContext()))
+  }
+
+  function getFromStorage() {
+    const rawContext = localStorage.getItem(storageKey)
+    return rawContext ? (JSON.parse(rawContext) as Context) : {}
+  }
+}
+
+export function buildStorageKey(productKey: string, customerDataType: CustomerDataType) {
+  return `${CONTEXT_STORE_KEY_PREFIX}_${productKey}_${customerDataType}`
+}
+
+export function removeStorageListeners() {
+  storageListeners.map((listener) => listener.stop())
+}

package/src/domain/contexts/accountContext.ts

@@ -0,0 +1,47 @@
+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'
+
+/**
+ * Account information for the browser SDK.
+ */
+export interface Account {
+  id: string
+  name?: string | undefined
+  [key: string]: unknown
+}
+
+export function startAccountContext(hooks: AbstractHooks, configuration: Configuration, productKey: string) {
+  const accountContextManager = buildAccountContextManager()
+
+  if (configuration.storeContextsAcrossPages) {
+    storeContextManager(configuration, accountContextManager, productKey, CustomerDataType.Account)
+  }
+
+  hooks.register(HookNames.Assemble, () => {
+    const account = accountContextManager.getContext() as Account
+
+    if (isEmptyObject(account) || !account.id) {
+      return SKIPPED
+    }
+
+    return {
+      account,
+    }
+  })
+
+  return accountContextManager
+}
+
+export function buildAccountContextManager() {
+  return createContextManager('account', {
+    propertiesConfig: {
+      id: { type: 'string', required: true },
+      name: { type: 'string' },
+    },
+  })
+}

package/src/domain/contexts/globalContext.ts

@@ -0,0 +1,30 @@
+import type { AbstractHooks } from '../../tools/abstractHooks'
+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,
+  configuration: Configuration,
+  productKey: string,
+  useContextNamespace: boolean
+) {
+  const globalContextManager = buildGlobalContextManager()
+
+  if (configuration.storeContextsAcrossPages) {
+    storeContextManager(configuration, globalContextManager, productKey, CustomerDataType.GlobalContext)
+  }
+
+  hooks.register(HookNames.Assemble, () => {
+    const context = globalContextManager.getContext()
+    return useContextNamespace ? { context } : context
+  })
+
+  return globalContextManager
+}
+
+export function buildGlobalContextManager() {
+  return createContextManager('global context')
+}

package/src/domain/contexts/rumInternalContext.type.ts

@@ -0,0 +1,15 @@
+import type { Context } from '../../tools/serialisation/context'
+
+export interface RumInternalContext extends Context {
+  application_id: string
+  session_id: string | undefined
+  view?: {
+    id: string
+    url: string
+    referrer: string
+    name?: string
+  }
+  user_action?: {
+    id: string | string[]
+  }
+}

package/src/domain/contexts/userContext.ts

@@ -0,0 +1,64 @@
+import type { AbstractHooks } from '../../tools/abstractHooks'
+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
+  email?: string | undefined
+  name?: string | undefined
+  [key: string]: unknown
+}
+
+export function startUserContext(
+  hooks: AbstractHooks,
+  configuration: Configuration,
+  sessionManager: {
+    findTrackedSession: (startTime?: RelativeTime) => { anonymousId?: string } | undefined
+  },
+  productKey: string
+) {
+  const userContextManager = buildUserContextManager()
+
+  if (configuration.storeContextsAcrossPages) {
+    storeContextManager(configuration, userContextManager, productKey, CustomerDataType.User)
+  }
+
+  hooks.register(HookNames.Assemble, ({ eventType, startTime }) => {
+    const user = userContextManager.getContext()
+    const session = sessionManager.findTrackedSession(startTime)
+
+    if (session && session.anonymousId && !user.anonymous_id && !!configuration.trackAnonymousUser) {
+      user.anonymous_id = session.anonymousId
+    }
+
+    if (isEmptyObject(user)) {
+      return SKIPPED
+    }
+
+    return {
+      type: eventType,
+      usr: user,
+    }
+  })
+
+  hooks.register(HookNames.AssembleTelemetry, ({ startTime }) => ({
+    anonymous_id: sessionManager.findTrackedSession(startTime)?.anonymousId,
+  }))
+
+  return userContextManager
+}
+
+export function buildUserContextManager() {
+  return createContextManager('user', {
+    propertiesConfig: {
+      id: { type: 'string' },
+      name: { type: 'string' },
+      email: { type: 'string' },
+    },
+  })
+}

package/src/domain/deflate/{types.ts → deflate.types.ts}

@@ -1,3 +1,6 @@
+import type { Encoder } from '../../tools/encoder'
+import type { Uint8ArrayBuffer } from '../../tools/utils/byteUtils'
+
 export type DeflateWorkerAction =
   // Action to send when creating the worker to check if the communication is working correctly.
   // The worker should respond with a 'initialized' response.
@@ -29,8 +32,8 @@ export type DeflateWorkerResponse =
       type: 'wrote'
       id: number
       streamId: number
-      result: Uint8Array
-      trailer: Uint8Array
+      result: Uint8ArrayBuffer
+      trailer: Uint8ArrayBuffer
       additionalBytesCount: number
     }
   // Could happen at any time when something goes wrong in the worker
@@ -39,3 +42,16 @@ export type DeflateWorkerResponse =
       streamId?: number
       error: Error | string
     }
+
+export interface DeflateWorker extends Worker {
+  postMessage(message: DeflateWorkerAction): void
+}
+
+export type DeflateEncoder = Encoder<Uint8ArrayBuffer> & { stop: () => void }
+
+export const enum DeflateEncoderStreamId {
+  REPLAY = 1,
+  RUM = 2,
+  TELEMETRY = 4,
+  PROFILING = 6,
+}

package/src/domain/deflate/index.ts

@@ -1 +1 @@
-export * from './types'
+export * from './deflate.types'

package/src/domain/error/error.ts

@@ -1,21 +1,22 @@
-import type { StackTrace } from '../tracekit'
-import { computeStackTrace } from '../tracekit'
-import { callMonitored } from '../../tools/monitor'
 import { sanitize } from '../../tools/serialisation/sanitize'
 import type { ClocksState } from '../../tools/utils/timeUtils'
-import { noop } from '../../tools/utils/functionUtils'
+import type { Context } from '../../tools/serialisation/context'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
+import type { StackTrace } from '../../tools/stackTrace/computeStackTrace'
+import { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'
+import { toStackTraceString } from '../../tools/stackTrace/handlingStack'
 import type { ErrorSource, ErrorHandling, RawError, RawErrorCause, ErrorWithCause, NonErrorPrefix } from './error.types'
 
 export const NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error'
 
-type RawErrorParams = {
+interface RawErrorParams {
   stackTrace?: StackTrace
   originalError: unknown
-
   handlingStack?: string
+  componentStack?: string
   startClocks: ClocksState
   nonErrorPrefix: NonErrorPrefix
+  useFallbackStack?: boolean
   source: ErrorSource
   handling: ErrorHandling
 }
@@ -24,32 +25,31 @@ export function computeRawError({
   stackTrace,
   originalError,
   handlingStack,
+  componentStack,
   startClocks,
   nonErrorPrefix,
+  useFallbackStack = true,
   source,
   handling,
 }: RawErrorParams): RawError {
-  const isErrorInstance = originalError instanceof Error
-
-  const message = computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError)
-  const stack = hasUsableStack(isErrorInstance, stackTrace)
-    ? toStackTraceString(stackTrace)
-    : NO_ERROR_STACK_PRESENT_MESSAGE
-  const causes = isErrorInstance ? flattenErrorCauses(originalError as ErrorWithCause, source) : undefined
-  const type = stackTrace?.name
-  const fingerprint = tryToGetFingerprint(originalError)
+  const isErrorInstance = isError(originalError)
+  if (!stackTrace && isErrorInstance) {
+    stackTrace = computeStackTrace(originalError)
+  }
 
   return {
     startClocks,
     source,
     handling,
     handlingStack,
+    componentStack,
     originalError,
-    type,
-    message,
-    stack,
-    causes,
-    fingerprint,
+    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,
+    fingerprint: tryToGetFingerprint(originalError),
+    context: tryToGetErrorContext(originalError),
   }
 }
 
@@ -68,84 +68,28 @@ function computeMessage(
       : 'Empty message'
 }
 
-function hasUsableStack(isErrorInstance: boolean, stackTrace?: StackTrace): stackTrace is StackTrace {
-  if (stackTrace === undefined) {
-    return false
-  }
-  if (isErrorInstance) {
-    return true
-  }
-  // handle cases where tracekit return stack = [] or stack = [{url: undefined, line: undefined, column: undefined}]
-  // TODO rework tracekit integration to avoid generating those unusable stack
-  return stackTrace.stack.length > 0 && (stackTrace.stack.length > 1 || stackTrace.stack[0].url !== undefined)
-}
-
 export function tryToGetFingerprint(originalError: unknown) {
-  return originalError instanceof Error && 'oo_fingerprint' in originalError
-    ? String(originalError.oo_fingerprint)
-    : undefined
+  return isError(originalError) && 'oo_fingerprint' in originalError ? String(originalError.oo_fingerprint) : undefined
 }
 
-export function toStackTraceString(stack: StackTrace) {
-  let result = formatErrorMessage(stack)
-  stack.stack.forEach((frame) => {
-    const func = frame.func === '?' ? '<anonymous>' : frame.func
-    const args = frame.args && frame.args.length > 0 ? `(${frame.args.join(', ')})` : ''
-    const line = frame.line ? `:${frame.line}` : ''
-    const column = frame.line && frame.column ? `:${frame.column}` : ''
-    result += `\n  at ${func!}${args} @ ${frame.url!}${line}${column}`
-  })
-  return result
+export function tryToGetErrorContext(originalError: unknown) {
+  if (originalError !== null && typeof originalError === 'object' && 'dd_context' in originalError) {
+    return originalError.dd_context as Context
+  }
 }
 
 export function getFileFromStackTraceString(stack: string) {
   return /@ (.+)/.exec(stack)?.[1]
 }
 
-export function formatErrorMessage(stack: StackTrace) {
-  return `${stack.name || 'Error'}: ${stack.message!}`
-}
-
-/**
- Creates a stacktrace without SDK internal frames.
- 
- Constraints:
- - Has to be called at the utmost position of the call stack.
- - No monitored function should encapsulate it, that is why we need to use callMonitored inside it.
- */
-export function createHandlingStack(): string {
-  /**
-   * Skip the two internal frames:
-   * - SDK API (console.error, ...)
-   * - this function
-   * in order to keep only the user calls
-   */
-  const internalFramesToSkip = 2
-  const error = new Error()
-  let formattedStack: string
-
-  // IE needs to throw the error to fill in the stack trace
-  if (!error.stack) {
-    try {
-      throw error
-    } catch (e) {
-      noop()
-    }
-  }
-
-  callMonitored(() => {
-    const stackTrace = computeStackTrace(error)
-    stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip)
-    formattedStack = toStackTraceString(stackTrace)
-  })
-
-  return formattedStack!
+export function isError(error: unknown): error is Error {
+  return error instanceof Error || Object.prototype.toString.call(error) === '[object Error]'
 }
 
 export function flattenErrorCauses(error: ErrorWithCause, parentSource: ErrorSource): RawErrorCause[] | undefined {
   let currentError = error
   const causes: RawErrorCause[] = []
-  while (currentError?.cause instanceof Error && causes.length < 10) {
+  while (isError(currentError?.cause) && causes.length < 10) {
     const stackTrace = computeStackTrace(currentError.cause)
     causes.push({
       message: currentError.cause.message,

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

@@ -1,16 +1,30 @@
+import type { Context } from '../../tools/serialisation/context'
 import type { ClocksState } from '../../tools/utils/timeUtils'
 
-export interface ErrorWithCause extends Error {
-  cause?: Error
+// TS v4.6 introduced Error.cause[1] typed as `Error`. TS v4.8 changed Error.cause to be
+// `unknown`[2].
+//
+// Because we still support TS 3.8, we need to declare our own type. We can remove it once we drop
+// support for TS v4.7 and before. The 'cause' property defined by TS needs to be omitted because
+// we define it with a type `unknown` which is incompatible with TS 4.6 and 4.7.
+//
+// [1]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-6/#target-es2022
+// [2]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-8/#lib-d-ts-updates
+export interface ErrorWithCause extends Omit<Error, 'cause'> {
+  cause?: unknown
 }
 
-export type RawErrorCause = {
+export interface RawErrorCause {
   message: string
-  source: string
+  source: ErrorSource
   type?: string
   stack?: string
 }
 
+export interface Csp {
+  disposition: 'enforce' | 'report'
+}
+
 export interface RawError {
   startClocks: ClocksState
   message: string
@@ -20,8 +34,11 @@ export interface RawError {
   originalError?: unknown
   handling?: ErrorHandling
   handlingStack?: string
+  componentStack?: string
   causes?: RawErrorCause[]
   fingerprint?: string
+  csp?: Csp
+  context?: Context
 }
 
 export const ErrorSource = {

package/src/domain/error/trackRuntimeError.ts

@@ -1,14 +1,19 @@
-import type { Observable } from '../../tools/observable'
+import { instrumentMethod } from '../../tools/instrumentMethod'
+import { Observable } from '../../tools/observable'
 import { clocksNow } from '../../tools/utils/timeUtils'
-import { startUnhandledErrorCollection } from '../tracekit'
-import { computeRawError } from './error'
+import type { StackTrace } from '../../tools/stackTrace/computeStackTrace'
+import { computeStackTraceFromOnErrorMessage } from '../../tools/stackTrace/computeStackTrace'
+import { getGlobalObject } from '../../tools/globalObject'
+import { computeRawError, isError } from './error'
 import type { RawError } from './error.types'
 import { ErrorHandling, ErrorSource, NonErrorPrefix } from './error.types'
 
-export function trackRuntimeError(errorObservable: Observable<RawError>) {
-  return startUnhandledErrorCollection((stackTrace, originalError) => {
-    errorObservable.notify(
-      computeRawError({
+export type UnhandledErrorCallback = (originalError: unknown, stackTrace?: StackTrace) => any
+
+export function trackRuntimeError() {
+  return new Observable<RawError>((observer) => {
+    const handleRuntimeError = (originalError: unknown, stackTrace?: StackTrace) => {
+      const rawError = computeRawError({
         stackTrace,
         originalError,
         startClocks: clocksNow(),
@@ -16,6 +21,30 @@ export function trackRuntimeError(errorObservable: Observable<RawError>) {
         source: ErrorSource.SOURCE,
         handling: ErrorHandling.UNHANDLED,
       })
-    )
+      observer.notify(rawError)
+    }
+    const { stop: stopInstrumentingOnError } = instrumentOnError(handleRuntimeError)
+    const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(handleRuntimeError)
+
+    return () => {
+      stopInstrumentingOnError()
+      stopInstrumentingOnUnhandledRejection()
+    }
+  })
+}
+
+export function instrumentOnError(callback: UnhandledErrorCallback) {
+  return instrumentMethod(getGlobalObject(), 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {
+    let stackTrace
+    if (!isError(errorObj)) {
+      stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column)
+    }
+    callback(errorObj ?? messageObj, stackTrace)
+  })
+}
+
+export function instrumentUnhandledRejection(callback: UnhandledErrorCallback) {
+  return instrumentMethod(getGlobalObject(), 'onunhandledrejection', ({ parameters: [e] }) => {
+    callback(e.reason || 'Empty reason')
   })
 }

package/src/domain/eventRateLimiter/createEventRateLimiter.ts

@@ -5,10 +5,13 @@ import { ErrorSource } from '../error/error.types'
 
 export type EventRateLimiter = ReturnType<typeof createEventRateLimiter>
 
+// Limit the maximum number of actions, errors and logs per minutes
+const EVENT_RATE_LIMIT = 3000
+
 export function createEventRateLimiter(
   eventType: string,
-  limit: number,
-  onLimitReached: (limitError: RawError) => void
+  onLimitReached: (limitError: RawError) => void,
+  limit = EVENT_RATE_LIMIT
 ) {
   let eventCount = 0
   let allowNextEvent = false

package/src/domain/extension/extensionUtils.ts

@@ -0,0 +1,28 @@
+export const EXTENSION_PREFIXES = ['chrome-extension://', 'moz-extension://']
+
+export function containsExtensionUrl(str: string): boolean {
+  return EXTENSION_PREFIXES.some((prefix) => str.includes(prefix))
+}
+
+/**
+ * Utility function to detect if the SDK is being initialized in an unsupported browser extension environment.
+ *
+ * @param windowLocation - The current window location to check
+ * @param stack - The error stack to check for extension URLs
+ * @returns true if running in an unsupported browser extension environment
+ */
+export function isUnsupportedExtensionEnvironment(windowLocation: string, stack: string = '') {
+  // If the page itself is an extension page.
+  if (containsExtensionUrl(windowLocation)) {
+    return false
+  }
+
+  // Since we generate the error on the init, we check the 2nd frame line.
+  const frameLines = stack.split('\n').filter((line) => {
+    const trimmedLine = line.trim()
+    return trimmedLine.length && /^at\s+|@/.test(trimmedLine)
+  })
+  const target = frameLines[1] || ''
+
+  return containsExtensionUrl(target)
+}

package/src/domain/intakeSites.ts

@@ -0,0 +1,18 @@
+export type Site =
+  | 'datadoghq.com'
+  | 'us3.datadoghq.com'
+  | 'us5.datadoghq.com'
+  | 'datadoghq.eu'
+  | '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 PCI_INTAKE_HOST_US1 = 'pci.browser-intake-datadoghq.com'
+export const INTAKE_URL_PARAMETERS = ['ddsource', 'dd-api-key', 'dd-request-id']

package/src/domain/report/browser.types.ts

@@ -1,5 +1,16 @@
 export type ReportType = DeprecationReport['type'] | InterventionReport['type']
 
+interface Report {
+  type: ReportType
+  url: string
+  body: DeprecationReportBody | InterventionReportBody
+  toJSON(): any
+}
+
+interface ReportBody {
+  toJSON(): any
+}
+
 export interface DeprecationReport extends Report {
   type: 'deprecation'
   body: DeprecationReportBody
@@ -17,6 +28,7 @@ export interface InterventionReport extends Report {
   type: 'intervention'
   body: InterventionReportBody
 }
+
 export interface InterventionReportBody extends ReportBody {
   id: string
   message: string