@kubesense/kubesense-browser-rum 1.8.0 → 2.0.0-beta.1

package/src/boot/postStartStrategy.ts

@@ -1,22 +1,23 @@
 import type {
   LifeCycle,
   RumConfiguration,
-  RumSessionManager,
   StartRecordingOptions,
   ViewHistory,
-  RumSession,
 } from '@kubesense/kubesense-browser-rum-core'
 import {
   LifeCycleEventType,
   SessionReplayState,
+  computeSessionReplayState,
   getRoutePath,
   isRouteRecordable,
 } from '@kubesense/kubesense-browser-rum-core'
-import type { Telemetry, DeflateEncoder } from '@kubesense/kubesense-browser-core'
-import { asyncRunOnReadyState, monitorError, Observable } from '@kubesense/kubesense-browser-core'
+import type { Telemetry, DeflateEncoder, SessionManager } from '@kubesense/kubesense-browser-core'
+import { monitorError } from '@kubesense/kubesense-js-core/monitor'
+import { asyncRunOnReadyState, Observable } from '@kubesense/kubesense-browser-core'
 import { getSessionReplayLink } from '../domain/getSessionReplayLink'
 import { startRecorderInitTelemetry } from '../domain/startRecorderInitTelemetry'
-import type { startRecording } from './startRecording'
+import type { startRecording } from './kubesenseRecorder'
+import { lazyLoadRecorder } from './lazyLoadRecorder'
 
 export type StartRecording = typeof startRecording
 
@@ -51,9 +52,8 @@ export interface Strategy {
 export function createPostStartStrategy(
   configuration: RumConfiguration,
   lifeCycle: LifeCycle,
-  sessionManager: RumSessionManager,
+  sessionManager: SessionManager,
   viewHistory: ViewHistory,
-  loadRecorder: () => Promise<StartRecording | undefined>,
   getOrCreateDeflateEncoder: () => DeflateEncoder | undefined,
   telemetry: Telemetry
 ): Strategy {
@@ -93,8 +93,8 @@ export function createPostStartStrategy(
     observable.notify({ type: 'start', forced })
 
     const [startRecordingImpl] = await Promise.all([
-      notifyWhenSettled(observable, { type: 'recorder-settled' }, loadRecorder()),
-      notifyWhenSettled(observable, { type: 'document-ready' }, asyncRunOnReadyState(configuration, 'interactive')),
+      notifyWhenSettled(observable, { type: 'recorder-settled' }, lazyLoadRecorder()),
+      notifyWhenSettled(observable, { type: 'document-ready' }, asyncRunOnReadyState('interactive')),
     ])
 
     if (status !== RecorderStatus.Starting) {
@@ -137,7 +137,9 @@ export function createPostStartStrategy(
     }
 
     const session = sessionManager.findTrackedSession()
-    if (canStartRecording(session, options)) {
+    const replayState = session ? computeSessionReplayState(session, configuration) : undefined
+
+    if (!canStartRecording(replayState, options)) {
       status = RecorderStatus.IntentToStart
       return
     }
@@ -148,13 +150,13 @@ export function createPostStartStrategy(
 
     status = RecorderStatus.Starting
 
-    const forced = shouldForceReplay(session!, options) || false
+    const forced = shouldForceReplay(replayState, options) || false
 
     // Intentionally not awaiting doStart() to keep it asynchronous
     doStart(forced).catch(monitorError)
 
     if (forced) {
-      sessionManager.setForcedReplay()
+      sessionManager.updateSessionState({ forcedReplay: '1' })
     }
   }
 
@@ -176,16 +178,16 @@ export function createPostStartStrategy(
   }
 }
 
-function canStartRecording(session: RumSession | undefined, options?: StartRecordingOptions) {
-  return !session || (session.sessionReplay === SessionReplayState.OFF && (!options || !options.force))
+function canStartRecording(replayState: SessionReplayState | undefined, options?: StartRecordingOptions) {
+  return replayState !== undefined && (replayState !== SessionReplayState.OFF || options?.force)
 }
 
 function isRecordingInProgress(status: RecorderStatus) {
   return status === RecorderStatus.Starting || status === RecorderStatus.Started
 }
 
-function shouldForceReplay(session: RumSession, options?: StartRecordingOptions) {
-  return options && options.force && session.sessionReplay === SessionReplayState.OFF
+function shouldForceReplay(replayState: SessionReplayState | undefined, options?: StartRecordingOptions) {
+  return options && options.force && replayState === SessionReplayState.OFF
 }
 
 async function notifyWhenSettled<Event, Result>(

package/src/boot/profilerApi.ts

@@ -1,15 +1,20 @@
 import type {
+  Hooks,
   LifeCycle,
-  ViewHistory,
-  RumSessionManager,
-  RumConfiguration,
   ProfilerApi,
-  Hooks,
-  LongTaskContexts,
+  RumConfiguration,
+  ViewHistory,
 } from '@kubesense/kubesense-browser-rum-core'
-import type { DeflateEncoderStreamId, Encoder } from '@kubesense/kubesense-browser-core'
-import { isSampled } from '@kubesense/kubesense-browser-rum-core'
-import { addTelemetryDebug, monitorError } from '@kubesense/kubesense-browser-core'
+import type { DeflateEncoderStreamId, Encoder, SessionContext, SessionManager } from '@kubesense/kubesense-browser-core'
+import {
+  BridgeCapability,
+  bridgeSupports,
+  canUseEventBridge,
+  correctedChildSampleRate,
+  isSampled,
+  mockable,
+} from '@kubesense/kubesense-browser-core'
+import { monitorError } from '@kubesense/kubesense-js-core/monitor'
 import type { RUMProfiler } from '../domain/profiling/types'
 import { isProfilingSupported } from '../domain/profiling/profilingSupported'
 import { startProfilingContext } from '../domain/profiling/profilingContext'
@@ -22,9 +27,8 @@ export function makeProfilerApi(): ProfilerApi {
     lifeCycle: LifeCycle,
     hooks: Hooks,
     configuration: RumConfiguration,
-    sessionManager: RumSessionManager,
+    sessionManager: SessionManager,
     viewHistory: ViewHistory,
-    longTaskContexts: LongTaskContexts,
     createEncoder: (streamId: DeflateEncoderStreamId) => Encoder
   ) {
     const session = sessionManager.findTrackedSession() // Check if the session is tracked.
@@ -35,10 +39,7 @@ export function makeProfilerApi(): ProfilerApi {
       return
     }
 
-    // Sampling (sticky sampling based on session id)
-    if (!isSampled(session.id, configuration.profilingSampleRate)) {
-      // No sampling, no profiling.
-      // Note: No Profiling context is set at this stage.
+    if (!isProfilingSampled(configuration, session)) {
       return
     }
 
@@ -46,7 +47,7 @@ export function makeProfilerApi(): ProfilerApi {
     const profilingContextManager = startProfilingContext(hooks)
 
     // Browser support check
-    if (!isProfilingSupported()) {
+    if (!mockable(isProfilingSupported)()) {
       profilingContextManager.set({
         status: 'error',
         error_reason: 'not-supported-by-browser',
@@ -54,10 +55,9 @@ export function makeProfilerApi(): ProfilerApi {
       return
     }
 
-    lazyLoadProfiler()
+    mockable(lazyLoadProfiler)()
       .then((createRumProfiler) => {
         if (!createRumProfiler) {
-          addTelemetryDebug('[KUBESENSE_SDK] Failed to lazy load the RUM Profiler')
           profilingContextManager.set({ status: 'error', error_reason: 'failed-to-lazy-load' })
           return
         }
@@ -67,7 +67,6 @@ export function makeProfilerApi(): ProfilerApi {
           lifeCycle,
           sessionManager,
           profilingContextManager,
-          longTaskContexts,
           createEncoder,
           viewHistory,
           undefined
@@ -80,7 +79,18 @@ export function makeProfilerApi(): ProfilerApi {
   return {
     onRumStart,
     stop: () => {
-      profiler?.stop().catch(monitorError)
+      profiler?.stop()
     },
   }
 }
+
+function isProfilingSampled(configuration: RumConfiguration, session: SessionContext) {
+  if (canUseEventBridge()) {
+    // In bridge mode, native SDK owns the sampling decision, skip the rate check
+    return bridgeSupports(BridgeCapability.PROFILES)
+  }
+  return isSampled(
+    session.id,
+    correctedChildSampleRate(configuration.sessionSampleRate, configuration.profilingSampleRate)
+  )
+}

package/src/boot/recorderApi.ts

@@ -1,4 +1,4 @@
-import type { DeflateEncoder, DeflateWorker, Telemetry } from '@kubesense/kubesense-browser-core'
+import type { DeflateEncoder, DeflateWorker, Telemetry, SessionManager } from '@kubesense/kubesense-browser-core'
 import {
   canUseEventBridge,
   noop,
@@ -9,29 +9,22 @@ import {
 import type {
   LifeCycle,
   ViewHistory,
-  RumSessionManager,
   RecorderApi,
   RumConfiguration,
   StartRecordingOptions,
 } from '@kubesense/kubesense-browser-rum-core'
 import { getReplayStats as getReplayStatsImpl } from '../domain/replayStats'
-import type { CreateDeflateWorker } from '../domain/deflate'
 import {
   createDeflateEncoder,
   DeflateWorkerStatus,
   getDeflateWorkerStatus,
   startDeflateWorker,
 } from '../domain/deflate'
-import { isBrowserSupported } from './isBrowserSupported'
-import type { StartRecording } from './postStartStrategy'
 import { createPostStartStrategy } from './postStartStrategy'
 import { createPreStartStrategy } from './preStartStrategy'
 
-export function makeRecorderApi(
-  loadRecorder: () => Promise<StartRecording | undefined>,
-  createDeflateWorkerImpl?: CreateDeflateWorker
-): RecorderApi {
-  if ((canUseEventBridge() && !bridgeSupports(BridgeCapability.RECORDS)) || !isBrowserSupported()) {
+export function makeRecorderApi(): RecorderApi {
+  if (canUseEventBridge() && !bridgeSupports(BridgeCapability.RECORDS)) {
     return {
       start: noop,
       stop: noop,
@@ -82,7 +75,7 @@ export function makeRecorderApi(
   function onRumStart(
     lifeCycle: LifeCycle,
     configuration: RumConfiguration,
-    sessionManager: RumSessionManager,
+    sessionManager: SessionManager,
     viewHistory: ViewHistory,
     worker: DeflateWorker | undefined,
     telemetry: Telemetry
@@ -91,17 +84,10 @@ export function makeRecorderApi(
 
     function getOrCreateDeflateEncoder() {
       if (!cachedDeflateEncoder) {
-        worker ??= startDeflateWorker(
-          configuration,
-          'Kubesense Session Replay',
-          () => {
-            strategy.stop()
-          },
-          createDeflateWorkerImpl
-        )
+        worker ??= startDeflateWorker(configuration, 'KubeSense Session Replay', () => strategy.stop())
 
         if (worker) {
-          cachedDeflateEncoder = createDeflateEncoder(configuration, worker, DeflateEncoderStreamId.REPLAY)
+          cachedDeflateEncoder = createDeflateEncoder(worker, DeflateEncoderStreamId.REPLAY)
         }
       }
       return cachedDeflateEncoder
@@ -112,7 +98,6 @@ export function makeRecorderApi(
       lifeCycle,
       sessionManager,
       viewHistory,
-      loadRecorder,
       getOrCreateDeflateEncoder,
       telemetry
     )

package/src/domain/deflate/deflateEncoder.ts

@@ -7,13 +7,8 @@ import type {
   Uint8ArrayBuffer,
 } from '@kubesense/kubesense-browser-core'
 import { addEventListener, concatBuffers } from '@kubesense/kubesense-browser-core'
-import type { RumConfiguration } from '@kubesense/kubesense-browser-rum-core'
 
-export function createDeflateEncoder(
-  configuration: RumConfiguration,
-  worker: DeflateWorker,
-  streamId: DeflateEncoderStreamId
-): DeflateEncoder {
+export function createDeflateEncoder(worker: DeflateWorker, streamId: DeflateEncoderStreamId): DeflateEncoder {
   let rawBytesCount = 0
   let compressedData: Uint8ArrayBuffer[] = []
   let compressedDataTrailer: Uint8ArrayBuffer
@@ -27,12 +22,12 @@ export function createDeflateEncoder(
     data: string
   }> = []
 
+  const expectedStreamId: number = streamId
   const { stop: removeMessageListener } = addEventListener(
-    configuration,
     worker,
     'message',
     ({ data: workerResponse }: MessageEvent<DeflateWorkerResponse>) => {
-      if (workerResponse.type !== 'wrote' || (workerResponse.streamId as DeflateEncoderStreamId) !== streamId) {
+      if (workerResponse.type !== 'wrote' || workerResponse.streamId !== expectedStreamId) {
         return
       }
 

package/src/domain/deflate/deflateWorker.ts

@@ -1,5 +1,6 @@
 import type { DeflateWorker, DeflateWorkerResponse } from '@kubesense/kubesense-browser-core'
-import { addTelemetryError, display, addEventListener, setTimeout, ONE_SECOND } from '@kubesense/kubesense-browser-core'
+import { ONE_SECOND } from '@kubesense/kubesense-js-core/time'
+import { addTelemetryError, display, addEventListener, setTimeout, mockable } from '@kubesense/kubesense-browser-core'
 import type { RumConfiguration } from '@kubesense/kubesense-browser-rum-core'
 import { reportScriptLoadingError } from '../scriptLoadingError'
 
@@ -41,7 +42,7 @@ type DeflateWorkerState =
 
 export type CreateDeflateWorker = typeof createDeflateWorker
 
-function createDeflateWorker(configuration: RumConfiguration): DeflateWorker {
+export function createDeflateWorker(configuration: RumConfiguration): DeflateWorker {
   return new Worker(configuration.workerUrl || URL.createObjectURL(new Blob([__BUILD_ENV__WORKER_STRING__])))
 }
 
@@ -50,12 +51,11 @@ let state: DeflateWorkerState = { status: DeflateWorkerStatus.Nil }
 export function startDeflateWorker(
   configuration: RumConfiguration,
   source: string,
-  onInitializationFailure: () => void,
-  createDeflateWorkerImpl = createDeflateWorker
+  onInitializationFailure: () => void
 ) {
   if (state.status === DeflateWorkerStatus.Nil) {
     // doStartDeflateWorker updates the state to "loading" or "error"
-    doStartDeflateWorker(configuration, source, createDeflateWorkerImpl)
+    doStartDeflateWorker(configuration, source)
   }
 
   switch (state.status) {
@@ -87,18 +87,13 @@ export function getDeflateWorkerStatus() {
  *
  * more details: https://bugzilla.mozilla.org/show_bug.cgi?id=1736865#c2
  */
-export function doStartDeflateWorker(
-  configuration: RumConfiguration,
-  source: string,
-  createDeflateWorkerImpl = createDeflateWorker
-) {
+export function doStartDeflateWorker(configuration: RumConfiguration, source: string) {
   try {
-    const worker = createDeflateWorkerImpl(configuration)
-    const { stop: removeErrorListener } = addEventListener(configuration, worker, 'error', (error) => {
+    const worker = mockable(createDeflateWorker)(configuration)
+    const { stop: removeErrorListener } = addEventListener(worker, 'error', (error) => {
       onError(configuration, source, error)
     })
     const { stop: removeMessageListener } = addEventListener(
-      configuration,
       worker,
       'message',
       ({ data }: MessageEvent<DeflateWorkerResponse>) => {

package/src/domain/deflate/index.ts

@@ -5,4 +5,5 @@ export {
   DeflateWorkerStatus,
   getDeflateWorkerStatus,
   resetDeflateWorkerState,
+  createDeflateWorker,
 } from './deflateWorker'

package/src/domain/getSessionReplayLink.ts

@@ -1,15 +1,18 @@
-import type { RumConfiguration, RumSessionManager, ViewHistory, RumSession } from '@kubesense/kubesense-browser-rum-core'
-import { getSessionReplayUrl, SessionReplayState } from '@kubesense/kubesense-browser-rum-core'
-import { isBrowserSupported } from '../boot/isBrowserSupported'
-
+import type { RumConfiguration, ViewHistory } from '@kubesense/kubesense-browser-rum-core'
+import {
+  getSessionReplayUrl,
+  SessionReplayState,
+  computeSessionReplayState,
+} from '@kubesense/kubesense-browser-rum-core'
+import type { SessionManager, SessionContext } from '@kubesense/kubesense-browser-core'
 export function getSessionReplayLink(
   configuration: RumConfiguration,
-  sessionManager: RumSessionManager,
+  sessionManager: SessionManager,
   viewHistory: ViewHistory,
   isRecordingStarted: boolean
 ): string | undefined {
   const session = sessionManager.findTrackedSession()
-  const errorType = getErrorType(session, isRecordingStarted)
+  const errorType = getErrorType(configuration, session, isRecordingStarted)
   const viewContext = viewHistory.findView()
 
   return getSessionReplayUrl(configuration, {
@@ -19,17 +22,18 @@ export function getSessionReplayLink(
   })
 }
 
-function getErrorType(session: RumSession | undefined, isRecordingStarted: boolean) {
-  if (!isBrowserSupported()) {
-    return 'browser-not-supported'
-  }
+function getErrorType(
+  configuration: RumConfiguration,
+  session: SessionContext | undefined,
+  isRecordingStarted: boolean
+) {
   if (!session) {
     // possibilities:
     // - rum sampled out
     // - session expired (edge case)
     return 'rum-not-tracked'
   }
-  if (session.sessionReplay === SessionReplayState.OFF) {
+  if (computeSessionReplayState(session, configuration) === SessionReplayState.OFF) {
     // possibilities
     // - replay sampled out
     return 'incorrect-session-plan'

package/src/domain/profiling/actionHistory.ts

@@ -0,0 +1,66 @@
+import type { ClocksState, Duration } from '@kubesense/kubesense-js-core/time'
+import { addDuration } from '@kubesense/kubesense-js-core/time'
+import { createValueHistory, SESSION_TIME_OUT_DELAY } from '@kubesense/kubesense-browser-core'
+import type { LifeCycle } from '@kubesense/kubesense-browser-rum-core'
+import { LifeCycleEventType } from '@kubesense/kubesense-browser-rum-core'
+
+export const ACTION_ID_HISTORY_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY
+
+export interface ActionContext {
+  id: string
+  label: string
+  duration?: Duration
+  startClocks: ClocksState
+}
+
+export function createActionHistory(lifeCycle: LifeCycle) {
+  const history = createValueHistory<ActionContext>({
+    expireDelay: ACTION_ID_HISTORY_TIME_OUT_DELAY,
+  })
+
+  lifeCycle.subscribe(LifeCycleEventType.ACTION_STARTED, (actionStart) => {
+    history.add(
+      {
+        id: actionStart.id,
+        // The label is temporarily empty since we need to account for customers that might
+        // redact the action name in the beforeSend callback. We will either try to do patch this
+        // behavior, or remove the label field entirely.
+        label: '',
+        startClocks: actionStart.startClocks,
+        duration: undefined,
+      },
+      actionStart.startClocks.relative
+    )
+  })
+
+  lifeCycle.subscribe(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, ({ rawRumEvent, startClocks, duration }) => {
+    if (rawRumEvent.type === 'action') {
+      const historyEntry = history
+        .getEntries(startClocks.relative)
+        .find((entry) => entry.value.id === rawRumEvent.action.id)
+      const durationForEntry = duration ?? (0 as Duration)
+
+      if (historyEntry) {
+        historyEntry.value.duration = durationForEntry
+        historyEntry.close(addDuration(startClocks.relative, durationForEntry))
+      } else {
+        history
+          .add(
+            {
+              id: rawRumEvent.action.id,
+              // The label is temporarily empty since we need to account for customers that might
+              // redact the action name in the beforeSend callback. We will either try to do patch this
+              // behavior, or remove the label field entirely.
+              label: '',
+              startClocks,
+              duration,
+            },
+            startClocks.relative
+          )
+          .close(addDuration(startClocks.relative, durationForEntry))
+      }
+    }
+  })
+
+  return history
+}