@openobserve/browser-core 0.2.8

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

@@ -0,0 +1,382 @@
+/* eslint-disable */
+/**
+ * DO NOT MODIFY IT BY HAND. Run `yarn rum-events-format:sync` instead.
+ */
+
+/**
+ * Schema of all properties of a telemetry event
+ */
+export type TelemetryEvent = TelemetryErrorEvent | TelemetryDebugEvent | TelemetryConfigurationEvent
+/**
+ * Schema of all properties of a telemetry error event
+ */
+export type TelemetryErrorEvent = CommonTelemetryProperties & {
+  /**
+   * The telemetry log information
+   */
+  telemetry: {
+    /**
+     * Telemetry type
+     */
+    type?: 'log'
+    /**
+     * Level/severity of the log
+     */
+    status: 'error'
+    /**
+     * Body of the log
+     */
+    message: string
+    /**
+     * Error properties
+     */
+    error?: {
+      /**
+       * The stack trace or the complementary information about the error
+       */
+      stack?: string
+      /**
+       * The error type or kind (or code in some cases)
+       */
+      kind?: string
+      [k: string]: unknown
+    }
+    [k: string]: unknown
+  }
+  [k: string]: unknown
+}
+/**
+ * Schema of all properties of a telemetry debug event
+ */
+export type TelemetryDebugEvent = CommonTelemetryProperties & {
+  /**
+   * The telemetry log information
+   */
+  telemetry: {
+    /**
+     * Telemetry type
+     */
+    type?: 'log'
+    /**
+     * Level/severity of the log
+     */
+    status: 'debug'
+    /**
+     * Body of the log
+     */
+    message: string
+    [k: string]: unknown
+  }
+  [k: string]: unknown
+}
+/**
+ * Schema of all properties of a telemetry configuration event
+ */
+export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
+  /**
+   * The telemetry configuration information
+   */
+  telemetry: {
+    /**
+     * Telemetry type
+     */
+    type: 'configuration'
+    /**
+     * Configuration properties
+     */
+    configuration: {
+      /**
+       * The percentage of sessions tracked
+       */
+      session_sample_rate?: number
+      /**
+       * The percentage of telemetry events sent
+       */
+      telemetry_sample_rate?: number
+      /**
+       * The percentage of telemetry configuration events sent after being sampled by telemetry_sample_rate
+       */
+      telemetry_configuration_sample_rate?: number
+      /**
+       * The percentage of requests traced
+       */
+      trace_sample_rate?: number
+      /**
+       * The percentage of sessions with Browser RUM & Session Replay pricing tracked (deprecated in favor of session_replay_sample_rate)
+       */
+      premium_sample_rate?: number
+      /**
+       * The percentage of sessions with Browser RUM & Session Replay pricing tracked (deprecated in favor of session_replay_sample_rate)
+       */
+      replay_sample_rate?: number
+      /**
+       * The percentage of sessions with RUM & Session Replay pricing tracked
+       */
+      session_replay_sample_rate?: number
+      /**
+       * Whether the session replay start is handled manually
+       */
+      start_session_replay_recording_manually?: boolean
+      /**
+       * Whether a proxy is used
+       */
+      use_proxy?: boolean
+      /**
+       * Whether beforeSend callback function is used
+       */
+      use_before_send?: boolean
+      /**
+       * Whether initialization fails silently if the SDK is already initialized
+       */
+      silent_multiple_init?: boolean
+      /**
+       * Whether sessions across subdomains for the same site are tracked
+       */
+      track_session_across_subdomains?: boolean
+      /**
+       * Whether resources are tracked
+       */
+      track_resources?: boolean
+      /**
+       * Whether long tasks are tracked
+       */
+      track_long_task?: boolean
+      /**
+       * Whether a secure cross-site session cookie is used
+       */
+      use_cross_site_session_cookie?: boolean
+      /**
+       * Whether a secure session cookie is used
+       */
+      use_secure_session_cookie?: boolean
+      /**
+       * Whether it is allowed to use LocalStorage when cookies are not available
+       */
+      allow_fallback_to_local_storage?: boolean
+      /**
+       * Whether untrusted events are allowed
+       */
+      allow_untrusted_events?: boolean
+      /**
+       * Attribute to be used to name actions
+       */
+      action_name_attribute?: string
+      /**
+       * Whether the allowed tracing origins list is used (deprecated in favor of use_allowed_tracing_urls)
+       */
+      use_allowed_tracing_origins?: boolean
+      /**
+       * Whether the allowed tracing urls list is used
+       */
+      use_allowed_tracing_urls?: boolean
+      /**
+       * A list of selected tracing propagators
+       */
+      selected_tracing_propagators?: ('tracecontext' | 'b3' | 'b3multi')[]
+      /**
+       * Session replay default privacy level
+       */
+      default_privacy_level?: string
+      /**
+       * Whether the request origins list to ignore when computing the page activity is used
+       */
+      use_excluded_activity_urls?: boolean
+      /**
+       * Whether the Worker is loaded from an external URL
+       */
+      use_worker_url?: boolean
+      /**
+       * Whether user frustrations are tracked
+       */
+      track_frustrations?: boolean
+      /**
+       * Whether the RUM views creation is handled manually
+       */
+      track_views_manually?: boolean
+      /**
+       * Whether user actions are tracked (deprecated in favor of track_user_interactions)
+       */
+      track_interactions?: boolean
+      /**
+       * Whether user actions are tracked
+       */
+      track_user_interactions?: boolean
+      /**
+       * Whether console.error logs, uncaught exceptions and network errors are tracked
+       */
+      forward_errors_to_logs?: boolean
+      /**
+       * The console.* tracked
+       */
+      forward_console_logs?: string[] | 'all'
+      /**
+       * The reports from the Reporting API tracked
+       */
+      forward_reports?: string[] | 'all'
+      /**
+       * Whether local encryption is used
+       */
+      use_local_encryption?: boolean
+      /**
+       * View tracking strategy
+       */
+      view_tracking_strategy?:
+      | 'ActivityViewTrackingStrategy'
+      | 'FragmentViewTrackingStrategy'
+      | 'MixedViewTrackingStrategy'
+      | 'NavigationViewTrackingStrategy'
+      /**
+       * Whether RUM events are tracked when the application is in Background
+       */
+      track_background_events?: boolean
+      /**
+       * The period between each Mobile Vital sample (in milliseconds)
+       */
+      mobile_vitals_update_period?: number
+      /**
+       * Whether error monitoring & crash reporting is enabled for the source platform
+       */
+      track_errors?: boolean
+      /**
+       * Whether automatic collection of network requests is enabled
+       */
+      track_network_requests?: boolean
+      /**
+       * Whether tracing features are enabled
+       */
+      use_tracing?: boolean
+      /**
+       * Whether native views are tracked (for cross platform SDKs)
+       */
+      track_native_views?: boolean
+      /**
+       * Whether native error monitoring & crash reporting is enabled (for cross platform SDKs)
+       */
+      track_native_errors?: boolean
+      /**
+       * Whether long task tracking is performed automatically
+       */
+      track_native_long_tasks?: boolean
+      /**
+       * Whether long task tracking is performed automatically for cross platform SDKs
+       */
+      track_cross_platform_long_tasks?: boolean
+      /**
+       * Whether the client has provided a list of first party hosts
+       */
+      use_first_party_hosts?: boolean
+      /**
+       * The type of initialization the SDK used, in case multiple are supported
+       */
+      initialization_type?: string
+      /**
+       * Whether Flutter build and raster time tracking is enabled
+       */
+      track_flutter_performance?: boolean
+      /**
+       * The window duration for batches sent by the SDK (in milliseconds)
+       */
+      batch_size?: number
+      /**
+       * The upload frequency of batches (in milliseconds)
+       */
+      batch_upload_frequency?: number
+      /**
+       * The version of React used in a ReactNative application
+       */
+      react_version?: string
+      /**
+       * The version of ReactNative used in a ReactNative application
+       */
+      react_native_version?: string
+      /**
+       * The version of Dart used in a Flutter application
+       */
+      dart_version?: string
+      [k: string]: unknown
+    }
+    [k: string]: unknown
+  }
+  [k: string]: unknown
+}
+
+/**
+ * Schema of common properties of Telemetry events
+ */
+export interface CommonTelemetryProperties {
+  /**
+   * Internal properties
+   */
+  _oo: {
+    /**
+     * Version of the RUM event format
+     */
+    readonly format_version: 2
+    [k: string]: unknown
+  }
+  /**
+   * Telemetry event type. Should specify telemetry only.
+   */
+  readonly type: 'telemetry'
+  /**
+   * Start of the event in ms from epoch
+   */
+  date: number
+  /**
+   * The SDK generating the telemetry event
+   */
+  service: string
+  /**
+   * The source of this event
+   */
+  readonly source: 'android' | 'ios' | 'browser' | 'flutter' | 'react-native'
+  /**
+   * The version of the SDK generating the telemetry event
+   */
+  version: string
+  /**
+   * Application properties
+   */
+  readonly application?: {
+    /**
+     * UUID of the application
+     */
+    id: string
+    [k: string]: unknown
+  }
+  /**
+   * Session properties
+   */
+  session?: {
+    /**
+     * UUID of the session
+     */
+    id: string
+    [k: string]: unknown
+  }
+  /**
+   * View properties
+   */
+  view?: {
+    /**
+     * UUID of the view
+     */
+    id: string
+    [k: string]: unknown
+  }
+  /**
+   * Action properties
+   */
+  action?: {
+    /**
+     * UUID of the action
+     */
+    id: string
+    [k: string]: unknown
+  }
+  /**
+   * Enabled experimental features
+   */
+  readonly experimental_features?: string[]
+  [k: string]: unknown
+}

package/src/domain/tracekit/computeStackTrace.ts

@@ -0,0 +1,141 @@
+import { startsWith } from '../../tools/utils/polyfills'
+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[] = []
+
+  let stackProperty = tryToGetString(ex, 'stack')
+  const exString = String(ex)
+  if (stackProperty && startsWith(stackProperty, exString)) {
+    stackProperty = stackProperty.slice(exString.length)
+  }
+  if (stackProperty) {
+    stackProperty.split('\n').forEach((line) => {
+      const stackFrame =
+        parseChromeLine(line) || parseChromeAnonymousLine(line) || parseWinLine(line) || parseGeckoLine(line)
+      if (stackFrame) {
+        if (!stackFrame.func && stackFrame.line) {
+          stackFrame.func = UNKNOWN_FUNCTION
+        }
+
+        stack.push(stackFrame)
+      }
+    })
+  }
+
+  return {
+    message: tryToGetString(ex, 'message'),
+    name: tryToGetString(ex, 'name'),
+    stack,
+  }
+}
+const fileUrl = '((?:file|https?|blob|chrome-extension|native|eval|webpack|snippet|<anonymous>|\\w+\\.|\\/).*?)'
+const filePosition = '(?::(\\d+))'
+const CHROME_LINE_RE = new RegExp(`^\\s*at (.*?) ?\\(${fileUrl}${filePosition}?${filePosition}?\\)?\\s*$`, 'i')
+
+const CHROME_EVAL_RE = new RegExp(`\\((\\S*)${filePosition}${filePosition}\\)`)
+
+function parseChromeLine(line: string): StackFrame | undefined {
+  const parts = CHROME_LINE_RE.exec(line)
+
+  if (!parts) {
+    return
+  }
+
+  const isNative = parts[2] && parts[2].indexOf('native') === 0 // start of line
+  const isEval = parts[2] && parts[2].indexOf('eval') === 0 // start of line
+  const submatch = CHROME_EVAL_RE.exec(parts[2])
+
+  if (isEval && submatch) {
+    // throw out eval line/column and use top-most line/column number
+    parts[2] = submatch[1] // url
+    parts[3] = submatch[2] // line
+    parts[4] = submatch[3] // column
+  }
+
+  return {
+    args: isNative ? [parts[2]] : [],
+    column: parts[4] ? +parts[4] : undefined,
+    func: parts[1] || UNKNOWN_FUNCTION,
+    line: parts[3] ? +parts[3] : undefined,
+    url: !isNative ? parts[2] : undefined,
+  }
+}
+
+const CHROME_ANONYMOUS_FUNCTION_RE = new RegExp(`^\\s*at ?${fileUrl}${filePosition}?${filePosition}??\\s*$`, 'i')
+
+function parseChromeAnonymousLine(line: string): StackFrame | undefined {
+  const parts = CHROME_ANONYMOUS_FUNCTION_RE.exec(line)
+
+  if (!parts) {
+    return
+  }
+
+  return {
+    args: [],
+    column: parts[3] ? +parts[3] : undefined,
+    func: UNKNOWN_FUNCTION,
+    line: parts[2] ? +parts[2] : undefined,
+    url: parts[1],
+  }
+}
+
+const WINJS_LINE_RE =
+  /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i
+
+function parseWinLine(line: string): StackFrame | undefined {
+  const parts = WINJS_LINE_RE.exec(line)
+  if (!parts) {
+    return
+  }
+
+  return {
+    args: [],
+    column: parts[4] ? +parts[4] : undefined,
+    func: parts[1] || UNKNOWN_FUNCTION,
+    line: +parts[3],
+    url: parts[2],
+  }
+}
+
+const GECKO_LINE_RE =
+  /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i
+const GECKO_EVAL_RE = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i
+
+function parseGeckoLine(line: string): StackFrame | undefined {
+  const parts = GECKO_LINE_RE.exec(line)
+  if (!parts) {
+    return
+  }
+
+  const isEval = parts[3] && parts[3].indexOf(' > eval') > -1
+  const submatch = GECKO_EVAL_RE.exec(parts[3])
+
+  if (isEval && submatch) {
+    // throw out eval line/column and use top-most line number
+    parts[3] = submatch[1]
+    parts[4] = submatch[2]
+    parts[5] = undefined! // no column when eval
+  }
+
+  return {
+    args: parts[2] ? parts[2].split(',') : [],
+    column: parts[5] ? +parts[5] : undefined,
+    func: parts[1] || UNKNOWN_FUNCTION,
+    line: parts[4] ? +parts[4] : undefined,
+    url: parts[3],
+  }
+}
+
+function tryToGetString(candidate: unknown, property: string) {
+  if (typeof candidate !== 'object' || !candidate || !(property in candidate)) {
+    return undefined
+  }
+  const value = (candidate as { [k: string]: unknown })[property]
+  return typeof value === 'string' ? value : undefined
+}

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/domain/user/index.ts

@@ -0,0 +1,2 @@
+export * from './user.types'
+export * from './user'

package/src/domain/user/user.ts

@@ -0,0 +1,33 @@
+import type { Context } from '../../tools/serialisation/context'
+import { display } from '../../tools/display'
+import { getType } from '../../tools/utils/typeUtils'
+import { assign } from '../../tools/utils/polyfills'
+import type { User } from './user.types'
+
+/**
+ * Clone input data and ensure known user properties (id, name, email)
+ * are strings, as defined here:
+ * https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#user-related-attributes
+ */
+export function sanitizeUser(newUser: Context): Context {
+  // We shallow clone only to prevent mutation of user data.
+  const user = assign({}, newUser)
+  const keys = ['id', 'name', 'email']
+  keys.forEach((key) => {
+    if (key in user) {
+      user[key] = String(user[key])
+    }
+  })
+  return user
+}
+
+/**
+ * Simple check to ensure user is valid
+ */
+export function checkUser(newUser: User): boolean {
+  const isValid = getType(newUser) === 'object'
+  if (!isValid) {
+    display.error('Unsupported user:', newUser)
+  }
+  return isValid
+}