@openobserve/browser-core 0.2.8

package/src/domain/error/error.ts

@@ -0,0 +1,159 @@
+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 { jsonStringify } from '../../tools/serialisation/jsonStringify'
+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 = {
+  stackTrace?: StackTrace
+  originalError: unknown
+
+  handlingStack?: string
+  startClocks: ClocksState
+  nonErrorPrefix: NonErrorPrefix
+  source: ErrorSource
+  handling: ErrorHandling
+}
+
+export function computeRawError({
+  stackTrace,
+  originalError,
+  handlingStack,
+  startClocks,
+  nonErrorPrefix,
+  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)
+
+  return {
+    startClocks,
+    source,
+    handling,
+    handlingStack,
+    originalError,
+    type,
+    message,
+    stack,
+    causes,
+    fingerprint,
+  }
+}
+
+function computeMessage(
+  stackTrace: StackTrace | undefined,
+  isErrorInstance: boolean,
+  nonErrorPrefix: NonErrorPrefix,
+  originalError: unknown
+) {
+  // Favor stackTrace message only if tracekit has really been able to extract something meaningful (message + name)
+  // TODO rework tracekit integration to avoid scattering error building logic
+  return stackTrace?.message && stackTrace?.name
+    ? stackTrace.message
+    : !isErrorInstance
+      ? `${nonErrorPrefix} ${jsonStringify(sanitize(originalError))!}`
+      : '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
+}
+
+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 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 flattenErrorCauses(error: ErrorWithCause, parentSource: ErrorSource): RawErrorCause[] | undefined {
+  let currentError = error
+  const causes: RawErrorCause[] = []
+  while (currentError?.cause instanceof Error && causes.length < 10) {
+    const stackTrace = computeStackTrace(currentError.cause)
+    causes.push({
+      message: currentError.cause.message,
+      source: parentSource,
+      type: stackTrace?.name,
+      stack: stackTrace && toStackTraceString(stackTrace),
+    })
+    currentError = currentError.cause
+  }
+  return causes.length ? causes : undefined
+}

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

@@ -0,0 +1,47 @@
+import type { ClocksState } from '../../tools/utils/timeUtils'
+
+export interface ErrorWithCause extends Error {
+  cause?: Error
+}
+
+export type RawErrorCause = {
+  message: string
+  source: string
+  type?: string
+  stack?: string
+}
+
+export interface RawError {
+  startClocks: ClocksState
+  message: string
+  type?: string
+  stack?: string
+  source: ErrorSource
+  originalError?: unknown
+  handling?: ErrorHandling
+  handlingStack?: string
+  causes?: RawErrorCause[]
+  fingerprint?: string
+}
+
+export const ErrorSource = {
+  AGENT: 'agent',
+  CONSOLE: 'console',
+  CUSTOM: 'custom',
+  LOGGER: 'logger',
+  NETWORK: 'network',
+  SOURCE: 'source',
+  REPORT: 'report',
+} as const
+
+export const enum NonErrorPrefix {
+  UNCAUGHT = 'Uncaught',
+  PROVIDED = 'Provided',
+}
+
+export const enum ErrorHandling {
+  HANDLED = 'handled',
+  UNHANDLED = 'unhandled',
+}
+
+export type ErrorSource = (typeof ErrorSource)[keyof typeof ErrorSource]

package/src/domain/error/trackRuntimeError.ts

@@ -0,0 +1,21 @@
+import type { Observable } from '../../tools/observable'
+import { clocksNow } from '../../tools/utils/timeUtils'
+import { startUnhandledErrorCollection } from '../tracekit'
+import { computeRawError } 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({
+        stackTrace,
+        originalError,
+        startClocks: clocksNow(),
+        nonErrorPrefix: NonErrorPrefix.UNCAUGHT,
+        source: ErrorSource.SOURCE,
+        handling: ErrorHandling.UNHANDLED,
+      })
+    )
+  })
+}

package/src/domain/eventRateLimiter/createEventRateLimiter.ts

@@ -0,0 +1,46 @@
+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'
+
+export type EventRateLimiter = ReturnType<typeof createEventRateLimiter>
+
+export function createEventRateLimiter(
+  eventType: string,
+  limit: number,
+  onLimitReached: (limitError: RawError) => void
+) {
+  let eventCount = 0
+  let allowNextEvent = false
+
+  return {
+    isLimitReached() {
+      if (eventCount === 0) {
+        setTimeout(() => {
+          eventCount = 0
+        }, ONE_MINUTE)
+      }
+
+      eventCount += 1
+      if (eventCount <= limit || allowNextEvent) {
+        allowNextEvent = false
+        return false
+      }
+
+      if (eventCount === limit + 1) {
+        allowNextEvent = true
+        try {
+          onLimitReached({
+            message: `Reached max number of ${eventType}s by minute: ${limit}`,
+            source: ErrorSource.AGENT,
+            startClocks: clocksNow(),
+          })
+        } finally {
+          allowNextEvent = false
+        }
+      }
+
+      return true
+    },
+  }
+}

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

@@ -0,0 +1,26 @@
+export type ReportType = DeprecationReport['type'] | InterventionReport['type']
+
+export interface DeprecationReport extends Report {
+  type: 'deprecation'
+  body: DeprecationReportBody
+}
+export interface DeprecationReportBody extends ReportBody {
+  id: string
+  message: string
+  lineNumber: number | null
+  columnNumber: number | null
+  sourceFile: string | null
+  anticipatedRemoval: Date | null
+}
+
+export interface InterventionReport extends Report {
+  type: 'intervention'
+  body: InterventionReportBody
+}
+export interface InterventionReportBody extends ReportBody {
+  id: string
+  message: string
+  lineNumber: number | null
+  columnNumber: number | null
+  sourceFile: string | null
+}

package/src/domain/report/reportObservable.ts

@@ -0,0 +1,126 @@
+import { toStackTraceString } from '../error/error'
+import { monitor } from '../../tools/monitor'
+import { mergeObservables, Observable } from '../../tools/observable'
+import { addEventListener, DOM_EVENT } from '../../browser/addEventListener'
+import { includes } from '../../tools/utils/polyfills'
+import { safeTruncate } from '../../tools/utils/stringUtils'
+import type { Configuration } from '../configuration'
+import type { ReportType, InterventionReport, DeprecationReport } from './browser.types'
+
+export const RawReportType = {
+  intervention: 'intervention',
+  deprecation: 'deprecation',
+  cspViolation: 'csp_violation',
+} as const
+
+export type RawReportType = (typeof RawReportType)[keyof typeof RawReportType]
+
+export interface RawReport {
+  type: RawReportType
+  subtype: string
+  message: string
+  stack?: string
+}
+
+export function initReportObservable(configuration: Configuration, apis: RawReportType[]) {
+  const observables: Array<Observable<RawReport>> = []
+
+  if (includes(apis, RawReportType.cspViolation)) {
+    observables.push(createCspViolationReportObservable(configuration))
+  }
+
+  const reportTypes = apis.filter((api: RawReportType): api is ReportType => api !== RawReportType.cspViolation)
+  if (reportTypes.length) {
+    observables.push(createReportObservable(reportTypes))
+  }
+
+  return mergeObservables<RawReport>(...observables)
+}
+
+function createReportObservable(reportTypes: ReportType[]) {
+  const observable = new Observable<RawReport>(() => {
+    if (!window.ReportingObserver) {
+      return
+    }
+
+    const handleReports = monitor((reports: Array<DeprecationReport | InterventionReport>, _: ReportingObserver) =>
+      reports.forEach((report) => {
+        observable.notify(buildRawReportFromReport(report))
+      })
+    ) as ReportingObserverCallback
+
+    const observer = new window.ReportingObserver(handleReports, {
+      types: reportTypes,
+      buffered: true,
+    })
+
+    observer.observe()
+    return () => {
+      observer.disconnect()
+    }
+  })
+
+  return observable
+}
+
+function createCspViolationReportObservable(configuration: Configuration) {
+  const observable = new Observable<RawReport>(() => {
+    const { stop } = addEventListener(configuration, document, DOM_EVENT.SECURITY_POLICY_VIOLATION, (event) => {
+      observable.notify(buildRawReportFromCspViolation(event))
+    })
+
+    return stop
+  })
+  return observable
+}
+
+function buildRawReportFromReport({ type, body }: DeprecationReport | InterventionReport): RawReport {
+  return {
+    type,
+    subtype: body.id,
+    message: `${type}: ${body.message}`,
+    stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),
+  }
+}
+
+function buildRawReportFromCspViolation(event: SecurityPolicyViolationEvent): RawReport {
+  const type = RawReportType.cspViolation
+  const message = `'${event.blockedURI}' blocked by '${event.effectiveDirective}' directive`
+  return {
+    type: RawReportType.cspViolation,
+    subtype: event.effectiveDirective,
+    message: `${type}: ${message}`,
+    stack: buildStack(
+      event.effectiveDirective,
+      event.originalPolicy
+        ? `${message} of the policy "${safeTruncate(event.originalPolicy, 100, '...')}"`
+        : 'no policy',
+      event.sourceFile,
+      event.lineNumber,
+      event.columnNumber
+    ),
+  }
+}
+
+function buildStack(
+  name: string,
+  message: string,
+  sourceFile: string | null,
+  lineNumber: number | null,
+  columnNumber: number | null
+): string | undefined {
+  return sourceFile
+    ? toStackTraceString({
+        name,
+        message,
+        stack: [
+          {
+            func: '?',
+            url: sourceFile,
+            line: lineNumber ?? undefined,
+            column: columnNumber ?? undefined,
+          },
+        ],
+      })
+    : undefined
+}

package/src/domain/resourceUtils.ts

@@ -0,0 +1,17 @@
+export const enum ResourceType {
+  DOCUMENT = 'document',
+  XHR = 'xhr',
+  BEACON = 'beacon',
+  FETCH = 'fetch',
+  CSS = 'css',
+  JS = 'js',
+  IMAGE = 'image',
+  FONT = 'font',
+  MEDIA = 'media',
+  OTHER = 'other',
+}
+
+export const enum RequestType {
+  FETCH = ResourceType.FETCH,
+  XHR = ResourceType.XHR,
+}

package/src/domain/session/oldCookiesMigration.ts

@@ -0,0 +1,42 @@
+import { getCookie } from '../../browser/cookie'
+import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
+import { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy'
+import type { SessionState } from './sessionState'
+import { expandSessionState, isSessionInExpiredState } 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 = getCookie(SESSION_STORE_KEY)
+  if (!sessionString) {
+    const oldSessionId = getCookie(OLD_SESSION_COOKIE_NAME)
+    const oldRumType = getCookie(OLD_RUM_COOKIE_NAME)
+    const oldLogsType = getCookie(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 (!isSessionInExpiredState(session)) {
+      expandSessionState(session)
+      cookieStoreStrategy.persistSession(session)
+    }
+  }
+}

package/src/domain/session/sessionConstants.ts

@@ -0,0 +1,4 @@
+import { ONE_HOUR, ONE_MINUTE } from '../../tools/utils/timeUtils'
+
+export const SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR
+export const SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE

package/src/domain/session/sessionManager.ts

@@ -0,0 +1,98 @@
+import type { Observable } from '../../tools/observable'
+import type { Context } from '../../tools/serialisation/context'
+import { ValueHistory } from '../../tools/valueHistory'
+import type { RelativeTime } from '../../tools/utils/timeUtils'
+import { relativeNow, clocksOrigin, ONE_MINUTE } from '../../tools/utils/timeUtils'
+import { DOM_EVENT, addEventListener, addEventListeners } from '../../browser/addEventListener'
+import { clearInterval, setInterval } from '../../tools/timer'
+import type { Configuration } from '../configuration'
+import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
+import { startSessionStore } from './sessionStore'
+
+export interface SessionManager<TrackingType extends string> {
+  findActiveSession: (startTime?: RelativeTime) => SessionContext<TrackingType> | undefined
+  renewObservable: Observable<void>
+  expireObservable: Observable<void>
+  expire: () => void
+}
+
+export interface SessionContext<TrackingType extends string> extends Context {
+  id: string
+  trackingType: TrackingType
+}
+
+export const VISIBILITY_CHECK_DELAY = ONE_MINUTE
+const SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY
+let stopCallbacks: Array<() => void> = []
+
+export function startSessionManager<TrackingType extends string>(
+  configuration: Configuration,
+  productKey: string,
+  computeSessionState: (rawTrackingType?: string) => { trackingType: TrackingType; isTracked: boolean }
+): SessionManager<TrackingType> {
+  // TODO - Improve configuration type and remove assertion
+  const sessionStore = startSessionStore(configuration.sessionStoreStrategyType!, productKey, computeSessionState)
+  stopCallbacks.push(() => sessionStore.stop())
+
+  const sessionContextHistory = new ValueHistory<SessionContext<TrackingType>>(SESSION_CONTEXT_TIMEOUT_DELAY)
+  stopCallbacks.push(() => sessionContextHistory.stop())
+
+  sessionStore.renewObservable.subscribe(() => {
+    sessionContextHistory.add(buildSessionContext(), relativeNow())
+  })
+  sessionStore.expireObservable.subscribe(() => {
+    sessionContextHistory.closeActive(relativeNow())
+  })
+
+  sessionStore.expandOrRenewSession()
+  sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative)
+
+  trackActivity(configuration, () => sessionStore.expandOrRenewSession())
+  trackVisibility(configuration, () => sessionStore.expandSession())
+
+  function buildSessionContext() {
+    return {
+      id: sessionStore.getSession().id!,
+      trackingType: sessionStore.getSession()[productKey] as TrackingType,
+    }
+  }
+
+  return {
+    findActiveSession: (startTime) => sessionContextHistory.find(startTime),
+    renewObservable: sessionStore.renewObservable,
+    expireObservable: sessionStore.expireObservable,
+    expire: sessionStore.expire,
+  }
+}
+
+export function stopSessionManager() {
+  stopCallbacks.forEach((e) => e())
+  stopCallbacks = []
+}
+
+function trackActivity(configuration: Configuration, expandOrRenewSession: () => void) {
+  const { stop } = addEventListeners(
+    configuration,
+    window,
+    [DOM_EVENT.CLICK, DOM_EVENT.TOUCH_START, DOM_EVENT.KEY_DOWN, DOM_EVENT.SCROLL],
+    expandOrRenewSession,
+    { capture: true, passive: true }
+  )
+  stopCallbacks.push(stop)
+}
+
+function trackVisibility(configuration: Configuration, expandSession: () => void) {
+  const expandSessionWhenVisible = () => {
+    if (document.visibilityState === 'visible') {
+      expandSession()
+    }
+  }
+
+  const { stop } = addEventListener(configuration, document, DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible)
+  stopCallbacks.push(stop)
+
+  const visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY)
+  stopCallbacks.push(() => {
+    clearInterval(visibilityCheckInterval)
+  })
+}

package/src/domain/session/sessionState.ts

@@ -0,0 +1,51 @@
+import { isEmptyObject } from '../../tools/utils/objectUtils'
+import { objectEntries } from '../../tools/utils/polyfills'
+import { dateNow } from '../../tools/utils/timeUtils'
+import { SESSION_EXPIRATION_DELAY } from './sessionConstants'
+
+const SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/
+const SESSION_ENTRY_SEPARATOR = '&'
+
+export interface SessionState {
+  id?: string
+  created?: string
+  expire?: string
+  lock?: string
+
+  [key: string]: string | undefined
+}
+
+export function isSessionInExpiredState(session: SessionState) {
+  return isEmptyObject(session)
+}
+
+export function expandSessionState(session: SessionState) {
+  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY)
+}
+
+export function toSessionString(session: SessionState) {
+  return objectEntries(session)
+    .map(([key, value]) => `${key}=${value as string}`)
+    .join(SESSION_ENTRY_SEPARATOR)
+}
+
+export function toSessionState(sessionString: string | undefined | null) {
+  const session: SessionState = {}
+  if (isValidSessionString(sessionString)) {
+    sessionString.split(SESSION_ENTRY_SEPARATOR).forEach((entry) => {
+      const matches = SESSION_ENTRY_REGEXP.exec(entry)
+      if (matches !== null) {
+        const [, key, value] = matches
+        session[key] = value
+      }
+    })
+  }
+  return session
+}
+
+function isValidSessionString(sessionString: string | undefined | null): sessionString is string {
+  return (
+    !!sessionString &&
+    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString))
+  )
+}