@openobserve/browser-core 0.2.11-rc1 → 0.2.11

package/src/domain/session/storeStrategies/sessionStoreStrategy.ts

@@ -6,7 +6,6 @@ export const SESSION_STORE_KEY = '_oo_s'
 export type SessionStoreStrategyType = { type: 'Cookie'; cookieOptions: CookieOptions } | { type: 'LocalStorage' }
 
 export interface SessionStoreStrategy {
-  isLockEnabled: boolean
   persistSession: (session: SessionState) => void
   retrieveSession: () => SessionState
   clearSession: () => void

package/src/domain/synthetics/syntheticsWorkerValues.ts

@@ -1,4 +1,4 @@
-import { getInitCookie } from '../../browser/cookie'
+import { getCookie } from '../../browser/cookie'
 
 export const SYNTHETICS_TEST_ID_COOKIE_NAME = 'openobserve-synthetics-public-id'
 export const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'openobserve-synthetics-result-id'
@@ -12,16 +12,16 @@ export interface BrowserWindow extends Window {
 
 export function willSyntheticsInjectRum(): boolean {
   return Boolean(
-    (window as BrowserWindow)._OO_SYNTHETICS_INJECTS_RUM || getInitCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
+    (window as BrowserWindow)._OO_SYNTHETICS_INJECTS_RUM || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
   )
 }
 
 export function getSyntheticsTestId(): string | undefined {
-  const value = (window as BrowserWindow)._OO_SYNTHETICS_PUBLIC_ID || getInitCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
+  const value = (window as BrowserWindow)._OO_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
   return typeof value === 'string' ? value : undefined
 }
 
 export function getSyntheticsResultId(): string | undefined {
-  const value = (window as BrowserWindow)._OO_SYNTHETICS_RESULT_ID || getInitCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
+  const value = (window as BrowserWindow)._OO_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
   return typeof value === 'string' ? value : undefined
 }

package/src/domain/telemetry/rawTelemetryEvent.types.ts

@@ -10,10 +10,5 @@ export const enum StatusType {
   error = 'error',
 }
 
-export interface RuntimeEnvInfo {
-  is_local_file: boolean
-  is_worker: boolean
-}
-
 export type RawTelemetryEvent = TelemetryEvent['telemetry']
 export type RawTelemetryConfiguration = TelemetryConfigurationEvent['telemetry']['configuration']

package/src/domain/telemetry/telemetry.ts

@@ -4,6 +4,8 @@ import { toStackTraceString, NO_ERROR_STACK_PRESENT_MESSAGE } from '../error/err
 import { getExperimentalFeatures } from '../../tools/experimentalFeatures'
 import type { Configuration } from '../configuration'
 import { INTAKE_SITE_STAGING, INTAKE_SITE_US1_FED } from '../configuration'
+import type { StackTrace } from '../tracekit'
+import { computeStackTrace } from '../tracekit'
 import { Observable } from '../../tools/observable'
 import { timeStampNow } from '../../tools/utils/timeUtils'
 import { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor'
@@ -13,11 +15,8 @@ import { performDraw } from '../../tools/utils/numberUtils'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
 import { combine } from '../../tools/mergeInto'
 import { NonErrorPrefix } from '../error/error.types'
-import type { StackTrace } from '../error/computeStackTrace'
-import { computeStackTrace } from '../error/computeStackTrace'
-import { getConnectivity } from '../connectivity'
 import type { TelemetryEvent } from './telemetryEvent.types'
-import type { RawTelemetryConfiguration, RawTelemetryEvent, RuntimeEnvInfo } from './rawTelemetryEvent.types'
+import type { RawTelemetryConfiguration, RawTelemetryEvent } from './rawTelemetryEvent.types'
 import { StatusType, TelemetryType } from './rawTelemetryEvent.types'
 
 // replaced at build time
@@ -59,10 +58,9 @@ export function startTelemetry(telemetryService: TelemetryService, configuration
   telemetryConfiguration.telemetryConfigurationEnabled =
     telemetryConfiguration.telemetryEnabled && performDraw(configuration.telemetryConfigurationSampleRate)
 
-  const runtimeEnvInfo = getRuntimeEnvInfo()
   onRawTelemetryEventCollected = (rawEvent: RawTelemetryEvent) => {
     if (telemetryConfiguration.telemetryEnabled) {
-      const event = toTelemetryEvent(telemetryService, rawEvent, runtimeEnvInfo)
+      const event = toTelemetryEvent(telemetryService, rawEvent)
       observable.notify(event)
       sendToExtension('telemetry', event)
     }
@@ -74,11 +72,7 @@ export function startTelemetry(telemetryService: TelemetryService, configuration
     sentEventCount: 0,
   })
 
-  function toTelemetryEvent(
-    telemetryService: TelemetryService,
-    event: RawTelemetryEvent,
-    runtimeEnvInfo: RuntimeEnvInfo
-  ): TelemetryEvent & Context {
+  function toTelemetryEvent(telemetryService: TelemetryService, event: RawTelemetryEvent): TelemetryEvent & Context {
     return combine(
       {
         type: 'telemetry' as const,
@@ -89,14 +83,11 @@ export function startTelemetry(telemetryService: TelemetryService, configuration
         _oo: {
           format_version: 2 as const,
         },
-        telemetry: combine(event, {
-          runtime_env: runtimeEnvInfo,
-          connectivity: getConnectivity(),
-        }),
+        telemetry: event as any, // https://github.com/microsoft/TypeScript/issues/48457
         experimental_features: arrayFrom(getExperimentalFeatures()),
       },
       contextProvider !== undefined ? contextProvider() : {}
-    ) as TelemetryEvent & Context
+    )
   }
 
   return {
@@ -107,12 +98,6 @@ export function startTelemetry(telemetryService: TelemetryService, configuration
     enabled: telemetryConfiguration.telemetryEnabled,
   }
 }
-function getRuntimeEnvInfo(): RuntimeEnvInfo {
-  return {
-    is_local_file: window.location.protocol === 'file:',
-    is_worker: 'WorkerGlobalScope' in self,
-  }
-}
 
 export function startFakeTelemetry() {
   const events: RawTelemetryEvent[] = []

package/src/domain/telemetry/telemetryEvent.types.ts

@@ -142,13 +142,9 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        */
       track_long_task?: boolean
       /**
-       * Whether a secure cross-site session cookie is used (deprecated)
+       * Whether a secure cross-site session cookie is used
        */
       use_cross_site_session_cookie?: boolean
-      /**
-       * Whether a partitioned secure cross-site session cookie is used
-       */
-      use_partitioned_cross_site_session_cookie?: boolean
       /**
        * Whether a secure session cookie is used
        */
@@ -157,10 +153,6 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * Whether it is allowed to use LocalStorage when cookies are not available
        */
       allow_fallback_to_local_storage?: boolean
-      /**
-       * Whether contexts are stored in local storage
-       */
-      store_contexts_across_pages?: boolean
       /**
        * Whether untrusted events are allowed
        */
@@ -289,14 +281,6 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * The upload frequency of batches (in milliseconds)
        */
       batch_upload_frequency?: number
-      /**
-       * Maximum number of batches processed sequencially without a delay
-       */
-      batch_processing_level?: number
-      /**
-       * Whether UIApplication background tasks are enabled
-       */
-      background_tasks_enabled?: boolean
       /**
        * The version of React used in a ReactNative application
        */
@@ -345,7 +329,7 @@ export interface CommonTelemetryProperties {
   /**
    * The source of this event
    */
-  readonly source: 'android' | 'ios' | 'browser' | 'flutter' | 'react-native' | 'unity'
+  readonly source: 'android' | 'ios' | 'browser' | 'flutter' | 'react-native'
   /**
    * The version of the SDK generating the telemetry event
    */

package/src/domain/{error → tracekit}/computeStackTrace.ts

@@ -1,33 +1,11 @@
-/**
- * Cross-browser stack trace computation.
- *
- * Reference implementation: https://github.com/csnover/TraceKit/blob/04530298073c3823de72deb0b97e7b38ca7bcb59/tracekit.js
- */
-
 import { startsWith } from '../../tools/utils/polyfills'
-
-export interface StackFrame {
-  url?: string
-  func?: string
-  /** The arguments passed to the function, if known. */
-  args?: string[]
-  line?: number
-  column?: number
-  /** An array of source code lines; the middle element corresponds to the correct line. */
-  context?: string[]
-}
-
-export interface StackTrace {
-  name?: string
-  message?: string
-  url?: string
-  stack: StackFrame[]
-  incomplete?: boolean
-  partial?: boolean
-}
+import type { StackTrace, StackFrame } from './types'
 
 const UNKNOWN_FUNCTION = '?'
 
+/**
+ * Computes a stack trace for an exception.
+ */
 export function computeStackTrace(ex: unknown): StackTrace {
   const stack: StackFrame[] = []
 
@@ -161,26 +139,3 @@ function tryToGetString(candidate: unknown, property: string) {
   const value = (candidate as { [k: string]: unknown })[property]
   return typeof value === 'string' ? value : undefined
 }
-
-export function computeStackTraceFromOnErrorMessage(messageObj: unknown, url?: string, line?: number, column?: number) {
-  const stack = [{ url, column, line }]
-  const { name, message } = tryToParseMessage(messageObj)
-  return {
-    name,
-    message,
-    stack,
-  }
-}
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types
-const ERROR_TYPES_RE =
-  /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?([\s\S]*)$/
-
-function tryToParseMessage(messageObj: unknown) {
-  let name
-  let message
-  if ({}.toString.call(messageObj) === '[object String]') {
-    ;[, name, message] = ERROR_TYPES_RE.exec(messageObj as string)!
-  }
-  return { name, message }
-}

package/src/domain/tracekit/index.ts

@@ -0,0 +1,3 @@
+export { StackTrace, BrowserError } from './types'
+export { computeStackTrace } from './computeStackTrace'
+export { startUnhandledErrorCollection } from './tracekit'

package/src/domain/tracekit/tracekit.ts

@@ -0,0 +1,96 @@
+import { instrumentMethodAndCallOriginal } from '../../tools/instrumentMethod'
+import { computeStackTrace } from './computeStackTrace'
+import type { UnhandledErrorCallback, StackTrace } from './types'
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types
+const ERROR_TYPES_RE =
+  /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?([\s\S]*)$/
+
+/**
+ * Cross-browser collection of unhandled errors
+ *
+ * Supports:
+ * - Firefox: full stack trace with line numbers, plus column number
+ * on top frame; column number is not guaranteed
+ * - Opera: full stack trace with line and column numbers
+ * - Chrome: full stack trace with line and column numbers
+ * - Safari: line and column number for the top frame only; some frames
+ * may be missing, and column number is not guaranteed
+ * - IE: line and column number for the top frame only; some frames
+ * may be missing, and column number is not guaranteed
+ *
+ * In theory, TraceKit should work on all of the following versions:
+ * - IE5.5+ (only 8.0 tested)
+ * - Firefox 0.9+ (only 3.5+ tested)
+ * - Opera 7+ (only 10.50 tested; versions 9 and earlier may require
+ * Exceptions Have Stacktrace to be enabled in opera:config)
+ * - Safari 3+ (only 4+ tested)
+ * - Chrome 1+ (only 5+ tested)
+ * - Konqueror 3.5+ (untested)
+ *
+ * Tries to catch all unhandled errors and report them to the
+ * callback.
+ *
+ * Callbacks receive a StackTrace object as described in the
+ * computeStackTrace docs.
+ *
+ * @memberof TraceKit
+ * @namespace
+ */
+
+export function startUnhandledErrorCollection(callback: UnhandledErrorCallback) {
+  const { stop: stopInstrumentingOnError } = instrumentOnError(callback)
+  const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(callback)
+
+  return {
+    stop: () => {
+      stopInstrumentingOnError()
+      stopInstrumentingOnUnhandledRejection()
+    },
+  }
+}
+
+/**
+ * Install a global onerror handler
+ */
+function instrumentOnError(callback: UnhandledErrorCallback) {
+  return instrumentMethodAndCallOriginal(window, 'onerror', {
+    before(this: any, messageObj: unknown, url?: string, line?: number, column?: number, errorObj?: unknown) {
+      let stackTrace: StackTrace
+      if (errorObj instanceof Error) {
+        stackTrace = computeStackTrace(errorObj)
+      } else {
+        const stack = [{ url, column, line }]
+        const { name, message } = tryToParseMessage(messageObj)
+        stackTrace = {
+          name,
+          message,
+          stack,
+        }
+      }
+      callback(stackTrace, errorObj ?? messageObj)
+    },
+  })
+}
+
+function tryToParseMessage(messageObj: unknown) {
+  let name
+  let message
+  if ({}.toString.call(messageObj) === '[object String]') {
+    ;[, name, message] = ERROR_TYPES_RE.exec(messageObj as string)!
+  }
+  return { name, message }
+}
+
+/**
+ * Install a global onunhandledrejection handler
+ */
+function instrumentUnhandledRejection(callback: UnhandledErrorCallback) {
+  return instrumentMethodAndCallOriginal(window, 'onunhandledrejection', {
+    before(e: PromiseRejectionEvent) {
+      const reason = e.reason || 'Empty reason'
+      const stack = computeStackTrace(reason)
+      callback(stack, reason)
+    },
+  })
+}

package/src/domain/tracekit/types.ts

@@ -0,0 +1,47 @@
+export interface BrowserError extends Error {
+  sourceURL?: string
+  fileName?: string
+  line?: string | number
+  lineNumber?: string | number
+  description?: string
+}
+
+export type UnhandledErrorCallback = (stack: StackTrace, errorObject?: any) => any
+
+/**
+ * An object representing a single stack frame.
+ * @typedef {Object} StackFrame
+ * @property {string=} url The JavaScript or HTML file URL.
+ * @property {string=} func The function name, or empty for anonymous functions (if guessing did not work).
+ * @property {string[]=} args The arguments passed to the function, if known.
+ * @property {number=} line The line number, if known.
+ * @property {number=} column The column number, if known.
+ * @property {string[]=} context An array of source code lines; the middle element corresponds to the correct line#.
+ * @memberof TraceKit
+ */
+export interface StackFrame {
+  url?: string
+  func?: string
+  args?: string[]
+  line?: number
+  column?: number
+  context?: string[]
+}
+
+/**
+ * An object representing a JavaScript stack trace.
+ * @typedef {Object} StackTrace
+ * @property {string=} name The name of the thrown exception.
+ * @property {string} message The exception error message.
+ * @property {StackFrame[]} stack An array of stack frames.
+ * -- method used to collect the stack trace.
+ * @memberof TraceKit
+ */
+export interface StackTrace {
+  name?: string
+  message?: string
+  url?: string
+  stack: StackFrame[]
+  incomplete?: boolean
+  partial?: boolean
+}

package/src/index.ts

@@ -5,6 +5,7 @@ export {
   DefaultPrivacyLevel,
   EndpointBuilder,
   serializeConfiguration,
+  INTAKE_SITE_AP1,
   INTAKE_SITE_STAGING,
   INTAKE_SITE_US1,
   INTAKE_SITE_US1_FED,
@@ -18,7 +19,7 @@ export {
   ExperimentalFeature,
 } from './tools/experimentalFeatures'
 export { trackRuntimeError } from './domain/error/trackRuntimeError'
-export { computeStackTrace, StackTrace } from './domain/error/computeStackTrace'
+export { computeStackTrace, StackTrace } from './domain/tracekit'
 export { defineGlobal, makePublicApi } from './boot/init'
 export { initReportObservable, RawReport, RawReportType } from './domain/report/reportObservable'
 export {
@@ -61,7 +62,6 @@ export {
   FlushReason,
 } from './transport'
 export * from './tools/display'
-export { Encoder, EncoderResult, createIdentityEncoder } from './tools/encoder'
 export * from './tools/utils/urlPolyfill'
 export * from './tools/utils/timeUtils'
 export * from './tools/utils/arrayUtils'
@@ -73,7 +73,7 @@ export * from './tools/utils/browserDetection'
 export { sendToExtension } from './tools/sendToExtension'
 export { runOnReadyState } from './browser/runOnReadyState'
 export { getZoneJsOriginalValue } from './tools/getZoneJsOriginalValue'
-export { instrumentMethod, instrumentSetter, InstrumentedMethodCall } from './tools/instrumentMethod'
+export { instrumentMethod, instrumentMethodAndCallOriginal, instrumentSetter } from './tools/instrumentMethod'
 export {
   computeRawError,
   createHandlingStack,
@@ -92,17 +92,12 @@ export * from './tools/timer'
 export { initConsoleObservable, resetConsoleObservable, ConsoleLog } from './domain/console/consoleObservable'
 export { BoundedBuffer } from './tools/boundedBuffer'
 export { catchUserErrors } from './tools/catchUserErrors'
-export { createContextManager, ContextManager } from './domain/context/contextManager'
-export { storeContextManager, removeStorageListeners } from './domain/context/storeContextManager'
+export { createContextManager, ContextManager } from './tools/serialisation/contextManager'
 export {
-  createCustomerDataTrackerManager,
-  createCustomerDataTracker,
-  CustomerDataTracker,
-  CustomerDataTrackerManager,
+  warnIfCustomerDataLimitReached,
+  CustomerDataType,
   CUSTOMER_DATA_BYTES_LIMIT,
-  CustomerDataCompressionStatus,
-} from './domain/context/customerDataTracker'
-export { CustomerDataType } from './domain/context/contextConstants'
+} from './tools/serialisation/heavyCustomerDataWarning'
 export { ValueHistory, ValueHistoryEntry, CLEAR_OLD_VALUES_INTERVAL } from './tools/valueHistory'
 export { readBytesFromStream } from './tools/readBytesFromStream'
 export { STORAGE_POLL_DELAY } from './domain/session/sessionStore'
@@ -131,4 +126,3 @@ export { RawError } from './domain/error/error.types'
 export { RawErrorCause } from './domain/error/error.types'
 export { ErrorWithCause } from './domain/error/error.types'
 export * from './domain/deflate'
-export * from './domain/connectivity'

package/src/tools/display.ts

@@ -18,6 +18,7 @@ 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
@@ -25,6 +26,13 @@ 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.
@@ -36,17 +44,8 @@ interface Display {
  */
 export const globalConsole = console
 
-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),
-}
+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)

package/src/tools/experimentalFeatures.ts

@@ -14,10 +14,12 @@ 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',
-  ZERO_LCP_TELEMETRY = 'zero_lcp_telemetry',
+  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',
-  WRITABLE_RESOURCE_GRAPHQL = 'writable_resource_graphql',
 }
 
 const enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()