@depup/datadog__browser-rum 6.31.0-depup.0

package/src/domain/startRecorderInitTelemetry.ts

@@ -0,0 +1,90 @@
+import type { Context, Duration, Telemetry, Observable, TimeStamp } from '@datadog/browser-core'
+import { TelemetryMetrics, addTelemetryMetrics, noop, timeStampNow, elapsed } from '@datadog/browser-core'
+import type { RecorderInitEvent } from '../boot/postStartStrategy'
+
+type RecorderInitResult = 'aborted' | 'deflate-encoder-load-failed' | 'recorder-load-failed' | 'succeeded'
+
+export interface RecorderInitMetrics extends Context {
+  forced: boolean
+  loadRecorderModuleDuration: number | undefined
+  recorderInitDuration: number
+  result: RecorderInitResult
+  waitForDocReadyDuration: number | undefined
+}
+
+export function startRecorderInitTelemetry(telemetry: Telemetry, observable: Observable<RecorderInitEvent>) {
+  if (!telemetry.metricsEnabled) {
+    return { stop: noop }
+  }
+
+  let startContext:
+    | {
+        forced: boolean
+        timestamp: TimeStamp
+      }
+    | undefined
+
+  let documentReadyDuration: Duration | undefined
+  let recorderSettledDuration: Duration | undefined
+
+  const { unsubscribe } = observable.subscribe((event) => {
+    switch (event.type) {
+      case 'start':
+        startContext = { forced: event.forced, timestamp: timeStampNow() }
+        documentReadyDuration = undefined
+        recorderSettledDuration = undefined
+        break
+
+      case 'document-ready':
+        if (startContext) {
+          documentReadyDuration = elapsed(startContext.timestamp, timeStampNow())
+        }
+        break
+
+      case 'recorder-settled':
+        if (startContext) {
+          recorderSettledDuration = elapsed(startContext.timestamp, timeStampNow())
+        }
+        break
+
+      case 'aborted':
+      case 'deflate-encoder-load-failed':
+      case 'recorder-load-failed':
+      case 'succeeded':
+        // Only send metrics for the first attempt at starting the recorder.
+        unsubscribe()
+
+        if (startContext) {
+          // monitor-until: 2026-07-01
+          addTelemetryMetrics(TelemetryMetrics.RECORDER_INIT_METRICS_TELEMETRY_NAME, {
+            metrics: createRecorderInitMetrics(
+              startContext.forced,
+              recorderSettledDuration,
+              elapsed(startContext.timestamp, timeStampNow()),
+              event.type,
+              documentReadyDuration
+            ),
+          })
+        }
+        break
+    }
+  })
+
+  return { stop: unsubscribe }
+}
+
+function createRecorderInitMetrics(
+  forced: boolean,
+  loadRecorderModuleDuration: Duration | undefined,
+  recorderInitDuration: Duration,
+  result: RecorderInitResult,
+  waitForDocReadyDuration: Duration | undefined
+): RecorderInitMetrics {
+  return {
+    forced,
+    loadRecorderModuleDuration,
+    recorderInitDuration,
+    result,
+    waitForDocReadyDuration,
+  }
+}

package/src/entries/internal.ts

@@ -0,0 +1,18 @@
+/**
+ * Entry point consumed by the Datadog Web app to mutualize some types, constant and logic for
+ * tests.
+ *
+ * WARNING: this module is not intended for public usages, and won't follow semver for breaking
+ * changes.
+ */
+export type { TimeStamp } from '@datadog/browser-core'
+export {
+  PRIVACY_ATTR_NAME,
+  PRIVACY_ATTR_VALUE_HIDDEN,
+  PRIVACY_CLASS_PREFIX,
+  NodePrivacyLevel,
+} from '@datadog/browser-rum-core'
+
+export * from '../types'
+
+export { takeFullSnapshot, takeNodeSnapshot, serializeNode as serializeNodeWithId } from '../domain/record'

package/src/entries/internalSynthetics.ts

@@ -0,0 +1,24 @@
+/**
+ * Entry point consumed by the Datadog Synthetics worker to automatically inject a RUM SDK instance
+ * in test runs.
+ *
+ * WARNING: this module is not intended for public usages, and won't follow semver for breaking
+ * changes.
+ */
+import { makeRumPublicApi } from '@datadog/browser-rum-core'
+import { makeRecorderApi } from '../boot/recorderApi'
+import { lazyLoadRecorder } from '../boot/lazyLoadRecorder'
+import { makeProfilerApi } from '../boot/profilerApi'
+
+export { DefaultPrivacyLevel } from '@datadog/browser-core'
+
+// Disable the rule that forbids potential side effects, because we know that those functions don't
+// have side effects.
+/* eslint-disable local-rules/disallow-side-effects */
+const recorderApi = makeRecorderApi(lazyLoadRecorder)
+const profilerApi = makeProfilerApi()
+export const datadogRum = makeRumPublicApi(recorderApi, profilerApi, {
+  ignoreInitIfSyntheticsWillInjectRum: false,
+  sdkName: 'rum-synthetics',
+})
+/* eslint-enable local-rules/disallow-side-effects */

package/src/entries/main.ts

@@ -0,0 +1,96 @@
+/**
+ * Datadog Browser RUM SDK - Full version with Session Replay and Real User Profiling capabilities.
+ * Use this package to monitor your web application's performance and user experience.
+ *
+ * @packageDocumentation
+ * @see [RUM Browser Monitoring Setup](https://docs.datadoghq.com/real_user_monitoring/browser/)
+ */
+
+// Keep the following in sync with packages/rum-slim/src/entries/main.ts
+import { defineGlobal, getGlobalObject } from '@datadog/browser-core'
+import type { RumPublicApi } from '@datadog/browser-rum-core'
+import { makeRumPublicApi } from '@datadog/browser-rum-core'
+import { makeRecorderApi } from '../boot/recorderApi'
+import { createDeflateEncoder, startDeflateWorker } from '../domain/deflate'
+import { lazyLoadRecorder } from '../boot/lazyLoadRecorder'
+import { makeProfilerApi } from '../boot/profilerApi'
+
+export type {
+  User,
+  Account,
+  TraceContextInjection,
+  SessionPersistence,
+  TrackingConsent,
+  MatchOption,
+  ProxyFn,
+  Site,
+  Context,
+  ContextValue,
+  ContextArray,
+  RumInternalContext,
+} from '@datadog/browser-core'
+export { DefaultPrivacyLevel } from '@datadog/browser-core'
+
+/**
+ * @deprecated Use {@link DatadogRum} instead
+ */
+export type RumGlobal = RumPublicApi
+
+export type {
+  RumPublicApi as DatadogRum,
+  RumInitConfiguration,
+  RumBeforeSend,
+  ViewOptions,
+  StartRecordingOptions,
+  AddDurationVitalOptions,
+  DurationVitalOptions,
+  DurationVitalReference,
+  TracingOption,
+  RumPlugin,
+  OnRumStartOptions,
+  PropagatorType,
+  FeatureFlagsForEvents,
+
+  // Events
+  CommonProperties,
+  RumEvent,
+  RumActionEvent,
+  RumErrorEvent,
+  RumLongTaskEvent,
+  RumResourceEvent,
+  RumViewEvent,
+  RumVitalEvent,
+
+  // Events context
+  RumEventDomainContext,
+  RumViewEventDomainContext,
+  RumErrorEventDomainContext,
+  RumActionEventDomainContext,
+  RumVitalEventDomainContext,
+  RumFetchResourceEventDomainContext,
+  RumXhrResourceEventDomainContext,
+  RumOtherResourceEventDomainContext,
+  RumLongTaskEventDomainContext,
+} from '@datadog/browser-rum-core'
+
+const recorderApi = makeRecorderApi(lazyLoadRecorder)
+
+const profilerApi = makeProfilerApi()
+
+/**
+ * The global RUM instance. Use this to call RUM methods.
+ *
+ * @category Main
+ * @see {@link DatadogRum}
+ * @see [RUM Browser Monitoring Setup](https://docs.datadoghq.com/real_user_monitoring/browser/)
+ */
+export const datadogRum = makeRumPublicApi(recorderApi, profilerApi, {
+  startDeflateWorker,
+  createDeflateEncoder,
+  sdkName: 'rum',
+})
+
+interface BrowserWindow extends Window {
+  DD_RUM?: RumPublicApi
+}
+defineGlobal(getGlobalObject<BrowserWindow>(), 'DD_RUM', datadogRum)

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export type * from './sessionReplay'
+export * from './sessionReplayConstants'
+export type * from './profiling'

package/src/types/profiling.ts

@@ -0,0 +1,298 @@
+/**
+ * DO NOT MODIFY IT BY HAND. Run `yarn json-schemas:sync` instead.
+ */
+
+/**
+ * Schema of Browser SDK Profiling types.
+ */
+export type BrowserProfiling = BrowserProfileEvent | BrowserProfilerTrace
+/**
+ * Schema of the Browser SDK Profile Event payload.
+ */
+export type BrowserProfileEvent = ProfileCommonProperties & {
+  /**
+   * Profile data format.
+   */
+  readonly format: 'json'
+  /**
+   * Datadog internal metadata.
+   */
+  readonly _dd: {
+    /**
+     * Clock drift value. Used by Browser SDK.
+     */
+    readonly clock_drift: number
+  }
+  /**
+   * Action properties.
+   */
+  readonly action?: {
+    /**
+     * Array of action IDs.
+     */
+    readonly id: string[]
+    /**
+     * Array of action labels.
+     */
+    readonly label: string[]
+  }
+  /**
+   * Vital properties.
+   */
+  readonly vital?: {
+    /**
+     * Array of vital IDs.
+     */
+    readonly id: string[]
+    /**
+     * Array of vital labels.
+     */
+    readonly label: string[]
+  }
+}
+
+/**
+ * Schema of a Profile Event metadata. Contains attributes shared by all profiles.
+ */
+export interface ProfileCommonProperties {
+  /**
+   * Application properties.
+   */
+  readonly application: {
+    /**
+     * Application ID.
+     */
+    readonly id: string
+  }
+  /**
+   * Session properties.
+   */
+  readonly session?: {
+    /**
+     * Session ID.
+     */
+    readonly id: string
+  }
+  /**
+   * View properties.
+   */
+  readonly view?: {
+    /**
+     * Array of view IDs.
+     */
+    readonly id: string[]
+    /**
+     * Array of view names.
+     */
+    readonly name: string[]
+  }
+  /**
+   * Long task properties.
+   */
+  readonly long_task?: {
+    /**
+     * Array of long task IDs.
+     */
+    readonly id: string[]
+  }
+  /**
+   * List of attachment filenames.
+   */
+  readonly attachments: string[]
+  /**
+   * Start time as ISO 8601 date string (yyyy-MM-dd'T'HH:mm:ss.SSS'Z').
+   */
+  readonly start: string
+  /**
+   * End time marking when the profile ended, as ISO 8601 date string (yyyy-MM-dd'T'HH:mm:ss.SSS'Z').
+   */
+  readonly end: string
+  /**
+   * Profiler family.
+   */
+  readonly family: 'android' | 'chrome' | 'ios'
+  /**
+   * Runtime environment.
+   */
+  readonly runtime: 'android' | 'chrome' | 'ios'
+  /**
+   * Profile ingestion event version.
+   */
+  readonly version: number
+  /**
+   * Comma-separated profiler tags.
+   */
+  readonly tags_profiler: string
+}
+/**
+ * Schema of a RUM profiler trace containing profiling data enriched with RUM context.
+ */
+export interface BrowserProfilerTrace {
+  /**
+   * An array of profiler resources.
+   */
+  readonly resources: string[]
+  /**
+   * An array of profiler frames.
+   */
+  readonly frames: ProfilerFrame[]
+  /**
+   * An array of profiler stacks.
+   */
+  readonly stacks: ProfilerStack[]
+  /**
+   * An array of profiler samples.
+   */
+  readonly samples: ProfilerSample[]
+  startClocks: ClocksState
+  endClocks: ClocksState
+  clocksOrigin: ClocksState
+  /**
+   * Sample interval in milliseconds.
+   */
+  readonly sampleInterval: number
+  /**
+   * List of detected long tasks.
+   */
+  readonly longTasks: RumProfilerLongTaskEntry[]
+  /**
+   * List of detected vital entries.
+   */
+  readonly vitals?: RumProfilerVitalEntry[]
+  /**
+   * List of detected action entries.
+   */
+  readonly actions?: RumProfilerActionEntry[]
+  /**
+   * List of detected navigation entries.
+   */
+  readonly views: RumViewEntry[]
+}
+/**
+ * Schema of a profiler frame from the JS Self-Profiling API.
+ */
+export interface ProfilerFrame {
+  /**
+   * A function instance name.
+   */
+  readonly name: string
+  /**
+   * Index in the trace.resources array.
+   */
+  readonly resourceId?: number
+  /**
+   * 1-based index of the line.
+   */
+  readonly line?: number
+  /**
+   * 1-based index of the column.
+   */
+  readonly column?: number
+}
+/**
+ * Schema of a profiler stack from the JS Self-Profiling API.
+ */
+export interface ProfilerStack {
+  /**
+   * Index in the trace.stacks array.
+   */
+  readonly parentId?: number
+  /**
+   * Index in the trace.frames array.
+   */
+  readonly frameId: number
+}
+/**
+ * Schema of a profiler sample from the JS Self-Profiling API.
+ */
+export interface ProfilerSample {
+  /**
+   * High resolution time relative to the profiling session's time origin.
+   */
+  readonly timestamp: number
+  /**
+   * Index in the trace.stacks array.
+   */
+  readonly stackId?: number
+}
+/**
+ * Schema of timing state with both relative and absolute timestamps.
+ */
+export interface ClocksState {
+  /**
+   * Time relative to navigation start in milliseconds.
+   */
+  readonly relative: number
+  /**
+   * Epoch time in milliseconds.
+   */
+  readonly timeStamp: number
+}
+/**
+ * Schema of a long task entry recorded during profiling.
+ */
+export interface RumProfilerLongTaskEntry {
+  /**
+   * RUM Long Task id.
+   */
+  readonly id?: string
+  /**
+   * Duration in ms of the long task or long animation frame.
+   */
+  readonly duration: number
+  /**
+   * Type of the event: long task or long animation frame
+   */
+  readonly entryType: 'longtask' | 'long-animation-frame'
+  startClocks: ClocksState
+}
+/**
+ * Schema of a vital entry recorded during profiling.
+ */
+export interface RumProfilerVitalEntry {
+  /**
+   * RUM Vital id.
+   */
+  readonly id: string
+  /**
+   * RUM Vital label.
+   */
+  readonly label: string
+  /**
+   * Duration in ms of the vital.
+   */
+  readonly duration?: number
+  startClocks: ClocksState
+}
+/**
+ * Schema of a action entry recorded during profiling.
+ */
+export interface RumProfilerActionEntry {
+  /**
+   * RUM Action id.
+   */
+  readonly id: string
+  /**
+   * RUM Action label.
+   */
+  readonly label: string
+  /**
+   * Duration in ms of the duration vital.
+   */
+  readonly duration?: number
+  startClocks: ClocksState
+}
+/**
+ * Schema of a RUM view entry recorded during profiling.
+ */
+export interface RumViewEntry {
+  startClocks: ClocksState
+  /**
+   * RUM view id.
+   */
+  readonly viewId: string
+  /**
+   * RUM view name.
+   */
+  readonly viewName?: string
+}