@kubesense/kubesense-browser-rum-core 1.7.0 → 2.0.0-beta.1

package/src/boot/preStartRum.ts

@@ -1,55 +1,79 @@
-import type { TrackingConsentState, DeflateWorker, Context, ContextManager, BoundedBuffer } from '@kubesense/kubesense-browser-core'
+import { isWorkerEnvironment } from '@kubesense/kubesense-js-core/util'
+import { timeStampNow, clocksNow } from '@kubesense/kubesense-js-core/time'
+import { monitorError } from '@kubesense/kubesense-js-core/monitor'
+import type { TimeStamp } from '@kubesense/kubesense-js-core/time'
+import type {
+  TrackingConsentState,
+  DeflateWorker,
+  Context,
+  Telemetry,
+  SessionManager,
+} from '@kubesense/kubesense-browser-core'
 import {
-  createBoundedBuffer,
+  BufferedObservable,
   display,
   canUseEventBridge,
   displayAlreadyInitializedError,
   willSyntheticsInjectRum,
   noop,
-  timeStampNow,
-  clocksNow,
   getEventBridge,
   initFeatureFlags,
   addTelemetryConfiguration,
-  initFetchObservable,
   CustomerContextKey,
   buildAccountContextManager,
   buildGlobalContextManager,
   buildUserContextManager,
-  monitorError,
+  bufferContextCalls,
   sanitize,
+  startSessionManager,
+  startSessionManagerStub,
+  startTelemetry,
+  TelemetryService,
+  mockable,
+  startTelemetrySessionContext,
+  addTelemetryDebug,
+  setAllowUntrustedEvents,
+  isAllowedTrackingOrigins,
 } from '@kubesense/kubesense-browser-core'
-import type { RumConfiguration, RumInitConfiguration } from '../domain/configuration'
+import type { Hooks } from '../domain/hooks'
+import { createHooks } from '../domain/hooks'
+import type { RemoteConfigurationMetadata, RumConfiguration, RumInitConfiguration } from '../domain/configuration'
+
 import {
-  validateAndBuildRumConfiguration,
   fetchAndApplyRemoteConfiguration,
+  getRemoteConfiguration,
+  getRemoteConfigurationId,
+  validateAndBuildRumConfiguration,
   serializeRumConfiguration,
   applyCachedSdkConfiguration,
   scheduleSdkConfigurationRefresh,
 } from '../domain/configuration'
 import type { ViewOptions } from '../domain/view/trackViews'
-import type {
-  DurationVital,
-  CustomVitalsState,
-  FeatureOperationOptions,
-  FailureReason,
-} from '../domain/vital/vitalCollection'
-import { startDurationVital, stopDurationVital } from '../domain/vital/vitalCollection'
-import { callPluginsMethod } from '../domain/plugins'
+import type { OperationOptions, FailureReason } from '../domain/vital/vitalCollection'
+import { callPluginsOnInit } from '../domain/plugins'
+import { startTrackingConsentContext } from '../domain/contexts/trackingConsentContext'
 import type { StartRumResult } from './startRum'
 import type { RumPublicApiOptions, Strategy } from './rumPublicApi'
 
+export type DoStartRum = (
+  configuration: RumConfiguration,
+  sessionManager: SessionManager,
+  deflateWorker: DeflateWorker | undefined,
+  initialViewOptions: ViewOptions | undefined,
+  telemetry: Telemetry,
+  hooks: Hooks
+) => StartRumResult
+
 export function createPreStartStrategy(
-  { ignoreInitIfSyntheticsWillInjectRum = true, startDeflateWorker }: RumPublicApiOptions,
+  { ignoreInitIfSyntheticsWillInjectRum = true, startDeflateWorker, sdkName }: RumPublicApiOptions,
   trackingConsentState: TrackingConsentState,
-  customVitalsState: CustomVitalsState,
-  doStartRum: (
-    configuration: RumConfiguration,
-    deflateWorker: DeflateWorker | undefined,
-    initialViewOptions?: ViewOptions
-  ) => StartRumResult
+  doStartRum: DoStartRum
 ): Strategy {
-  const bufferApiCalls = createBoundedBuffer<StartRumResult>()
+  const BUFFER_LIMIT = 500
+  const bufferApiCalls = new BufferedObservable<(startRumResult: StartRumResult) => void>(BUFFER_LIMIT, (count) => {
+    // monitor-until: 2026-10-14
+    addTelemetryDebug('preStartRum buffer data lost', { count })
+  })
 
   // TODO next major: remove the globalContextManager, userContextManager and accountContextManager from preStartStrategy and use an empty context instead
   const globalContext = buildGlobalContextManager()
@@ -62,19 +86,23 @@ export function createPreStartStrategy(
   bufferContextCalls(accountContext, CustomerContextKey.accountContext, bufferApiCalls)
 
   let firstStartViewCall:
-    | { options: ViewOptions | undefined; callback: (startRumResult: StartRumResult) => void }
-    | undefined
+    { options: ViewOptions | undefined; callback: (startRumResult: StartRumResult) => void } | undefined
   let deflateWorker: DeflateWorker | undefined
 
   let cachedInitConfiguration: RumInitConfiguration | undefined
   let cachedConfiguration: RumConfiguration | undefined
+  let sessionManager: SessionManager | undefined
+  let telemetry: Telemetry | undefined
+  const hooks = createHooks()
 
   const trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartRum)
 
   const emptyContext: Context = {}
 
+  let started = false
+
   function tryStartRum() {
-    if (!cachedInitConfiguration || !cachedConfiguration || !trackingConsentState.isGranted()) {
+    if (started || !cachedInitConfiguration || !cachedConfiguration || !sessionManager || !telemetry) {
       return
     }
 
@@ -90,55 +118,81 @@ export function createPreStartStrategy(
       // When tracking views automatically, any startView call before RUM start creates an extra
       // view.
       // When tracking views manually, we use the ViewOptions from the first startView call as the
-      // initial view options, and we remove the actual startView call so we don't create an extra
+      // initial view options, and we skip the actual startView callback so we don't create an extra
       // view.
-      bufferApiCalls.remove(firstStartViewCall.callback)
       initialViewOptions = firstStartViewCall.options
     }
 
-    const startRumResult = doStartRum(cachedConfiguration, deflateWorker, initialViewOptions)
+    const callbackToSkip = cachedConfiguration.trackViewsManually ? firstStartViewCall?.callback : undefined
+
+    const startRumResult = doStartRum(
+      cachedConfiguration,
+      sessionManager,
+      deflateWorker,
+      initialViewOptions,
+      telemetry,
+      hooks
+    )
+
+    started = true
 
-    bufferApiCalls.drain(startRumResult)
+    bufferApiCalls.subscribe((callback) => {
+      if (callback !== callbackToSkip) {
+        callback(startRumResult)
+      }
+    })
+    bufferApiCalls.unbuffer()
   }
 
-  function doInit(initConfiguration: RumInitConfiguration, errorStack?: string) {
+  function doInit(
+    initConfiguration: RumInitConfiguration,
+    errorStack?: string,
+    remoteConfigurationMetadata?: RemoteConfigurationMetadata
+  ) {
     const eventBridgeAvailable = canUseEventBridge()
     if (eventBridgeAvailable) {
       initConfiguration = overrideInitConfigurationForBridge(initConfiguration)
     }
 
     const remoteSdkConfigurationEnabled = !!initConfiguration.enableRemoteSdkConfiguration
+
+    // A cached document that stops the SDK from starting must never be a one-way door: without a
+    // refresh on those paths the browser replays the same bad document on every load and can never
+    // learn about a corrected one. This covers a `features.rum: false` switch, an
+    // `allowedTrackingOrigins` list that no longer matches this origin, and settings that fail
+    // validation.
+    const refreshRemoteSdkConfiguration = () => {
+      if (remoteSdkConfigurationEnabled) {
+        scheduleSdkConfigurationRefresh(initConfiguration).catch(monitorError)
+      }
+    }
+
     if (remoteSdkConfigurationEnabled) {
       // Reading the cached document is synchronous and network-free, so it does not delay
       // initialization. The document fetched below only applies from the next page load.
-      const cachedSdkConfiguration = applyCachedSdkConfiguration(initConfiguration)
+      const cachedSdkConfiguration = applyCachedSdkConfiguration(initConfiguration, { globalContext, userContext })
       initConfiguration = cachedSdkConfiguration.initConfiguration
 
       if (!cachedSdkConfiguration.rumEnabled) {
         // RUM is switched off from the dashboard. Still refresh the document, otherwise the
         // switch would be one-way: the SDK could never learn that it has been turned back on.
         cachedInitConfiguration = initConfiguration
-        scheduleSdkConfigurationRefresh(initConfiguration).catch(monitorError)
+        refreshRemoteSdkConfiguration()
         return
       }
     }
 
     // Update the exposed initConfiguration to reflect the bridge and remote configuration overrides
     cachedInitConfiguration = initConfiguration
-    addTelemetryConfiguration(serializeRumConfiguration(initConfiguration))
 
     if (cachedConfiguration) {
       displayAlreadyInitializedError('KUBESENSE_SDK', initConfiguration)
       return
     }
 
-    const configuration = validateAndBuildRumConfiguration(initConfiguration, errorStack)
-    if (!configuration) {
-      return
-    }
-
-    if (!eventBridgeAvailable && !configuration.sessionStoreStrategyType) {
-      display.warn('No storage available for session. We will not send any data.')
+    const configuration = validateAndBuildRumConfiguration(initConfiguration, sdkName)
+    if (!configuration || !isAllowedTrackingOrigins(configuration, errorStack ?? '')) {
+      refreshRemoteSdkConfiguration()
       return
     }
 
@@ -153,41 +207,60 @@ export function createPreStartStrategy(
       )
       if (!deflateWorker) {
         // `startDeflateWorker` should have logged an error message explaining the issue
+        refreshRemoteSdkConfiguration()
         return
       }
     }
 
     cachedConfiguration = configuration
-    // Instrument fetch to track network requests
-    // This is needed in case the consent is not granted and some customer
-    // library (Apollo Client) is storing uninstrumented fetch to be used later
-    // The subscription is needed so that the instrumentation process is completed
-    initFetchObservable().subscribe(noop)
 
     trackingConsentState.tryToInit(configuration.trackingConsent)
-    tryStartRum()
 
-    if (remoteSdkConfigurationEnabled) {
-      // Fire-and-forget, after the SDK is running: refreshes the cache for the next page load.
-      scheduleSdkConfigurationRefresh(initConfiguration).catch(monitorError)
-    }
-  }
+    trackingConsentState.onGrantedOnce(() => {
+      const { assembleTelemetry: assembleTelemetryHook } = hooks
+      startTrackingConsentContext(assembleTelemetryHook, trackingConsentState)
+      telemetry = mockable(startTelemetry)(TelemetryService.RUM, configuration, assembleTelemetryHook, sdkName)
 
-  const addDurationVital = (vital: DurationVital) => {
-    bufferApiCalls.add((startRumResult) => startRumResult.addDurationVital(vital))
+      if (isWorkerEnvironment) {
+        display.warn('The RUM SDK is not supported in a web or service worker environment.')
+        return
+      }
+
+      const sessionManagerPromise = canUseEventBridge()
+        ? startSessionManagerStub()
+        : mockable(startSessionManager)(configuration, trackingConsentState)
+
+      void sessionManagerPromise
+        .then((newSessionManager) => {
+          if (!newSessionManager) {
+            return
+          }
+          sessionManager = newSessionManager
+          startTelemetrySessionContext(assembleTelemetryHook, sessionManager, {
+            application: { id: configuration.applicationId },
+          })
+          addTelemetryConfiguration(serializeRumConfiguration(initConfiguration, sdkName, remoteConfigurationMetadata))
+
+          tryStartRum()
+
+          // Fire-and-forget, after the SDK is running: refreshes the cache for the next page load.
+          refreshRemoteSdkConfiguration()
+        })
+        .catch(monitorError)
+    })
   }
 
   const addOperationStepVital = (
     name: string,
     stepType: 'start' | 'end',
-    options?: FeatureOperationOptions,
+    options?: OperationOptions,
     failureReason?: FailureReason
   ) => {
-    bufferApiCalls.add((startRumResult) =>
+    bufferApiCalls.notify((startRumResult) =>
       startRumResult.addOperationStepVital(
         sanitize(name)!,
         stepType,
-        sanitize(options) as FeatureOperationOptions,
+        sanitize(options) as OperationOptions,
         sanitize(failureReason) as FailureReason | undefined
       )
     )
@@ -201,6 +274,7 @@ export function createPreStartStrategy(
       }
       // Set the experimental feature flags as early as possible, so we can use them in most places
       initFeatureFlags(initConfiguration.enableExperimentalFeatures)
+      setAllowUntrustedEvents(initConfiguration.allowUntrustedEvents)
 
       // Expose the initial configuration regardless of initialization success.
       cachedInitConfiguration = initConfiguration
@@ -213,18 +287,52 @@ export function createPreStartStrategy(
         return
       }
 
-      callPluginsMethod(initConfiguration.plugins, 'onInit', { initConfiguration, publicApi })
+      const shouldContinue = callPluginsOnInit(initConfiguration.plugins, {
+        initConfiguration,
+        publicApi,
+        registerAssembleEventHook: hooks.assembleEvent.register,
+      })
 
-      if (initConfiguration.remoteConfigurationId) {
-        fetchAndApplyRemoteConfiguration(initConfiguration, { user: userContext, context: globalContext })
-          .then((initConfiguration) => {
-            if (initConfiguration) {
-              doInit(initConfiguration, errorStack)
+      if (typeof shouldContinue === 'boolean') {
+        if (shouldContinue) {
+          proceedWithInit()
+        }
+      } else {
+        shouldContinue
+          .then((result) => {
+            if (result) {
+              proceedWithInit()
             }
           })
           .catch(monitorError)
-      } else {
-        doInit(initConfiguration, errorStack)
+      }
+
+      function proceedWithInit() {
+        const hasRemoteConfiguration = getRemoteConfigurationId(initConfiguration)
+
+        if (hasRemoteConfiguration) {
+          const supportedContextManagers = { user: userContext, context: globalContext }
+          const isSyncLoading =
+            !!initConfiguration.remoteConfigurationId || !!initConfiguration.remoteConfiguration?.sync
+
+          if (isSyncLoading) {
+            fetchAndApplyRemoteConfiguration(initConfiguration, supportedContextManagers)
+              .then((resolvedInitConfiguration) => {
+                if (resolvedInitConfiguration) {
+                  doInit(resolvedInitConfiguration, errorStack)
+                }
+              })
+              .catch(monitorError)
+          } else {
+            const resolvedRemoteConfiguration = getRemoteConfiguration(initConfiguration, supportedContextManagers)
+
+            if (resolvedRemoteConfiguration) {
+              doInit(resolvedRemoteConfiguration.initConfiguration, errorStack, resolvedRemoteConfiguration.metadata)
+            }
+          }
+        } else {
+          doInit(initConfiguration, errorStack)
+        }
       }
     },
 
@@ -237,14 +345,18 @@ export function createPreStartStrategy(
     stopSession: noop,
 
     addTiming(name, time = timeStampNow()) {
-      bufferApiCalls.add((startRumResult) => startRumResult.addTiming(name, time))
+      bufferApiCalls.notify((startRumResult) => startRumResult.addTiming(name, time))
     },
 
+    setLoadingTime: ((callTimestamp: TimeStamp) => {
+      bufferApiCalls.notify((startRumResult) => startRumResult.setLoadingTime(callTimestamp))
+    }) as Strategy['setLoadingTime'],
+
     startView(options, startClocks = clocksNow()) {
       const callback = (startRumResult: StartRumResult) => {
         startRumResult.startView(options, startClocks)
       }
-      bufferApiCalls.add(callback)
+      bufferApiCalls.notify(callback)
 
       if (!firstStartViewCall) {
         firstStartViewCall = { options, callback }
@@ -253,17 +365,17 @@ export function createPreStartStrategy(
     },
 
     setViewName(name) {
-      bufferApiCalls.add((startRumResult) => startRumResult.setViewName(name))
+      bufferApiCalls.notify((startRumResult) => startRumResult.setViewName(name))
     },
 
     // View context APIs
 
     setViewContext(context) {
-      bufferApiCalls.add((startRumResult) => startRumResult.setViewContext(context))
+      bufferApiCalls.notify((startRumResult) => startRumResult.setViewContext(context))
     },
 
     setViewContextProperty(key, value) {
-      bufferApiCalls.add((startRumResult) => startRumResult.setViewContextProperty(key, value))
+      bufferApiCalls.notify((startRumResult) => startRumResult.setViewContextProperty(key, value))
     },
 
     getViewContext: () => emptyContext,
@@ -273,26 +385,50 @@ export function createPreStartStrategy(
     accountContext,
 
     addAction(action) {
-      bufferApiCalls.add((startRumResult) => startRumResult.addAction(action))
+      bufferApiCalls.notify((startRumResult) => startRumResult.addAction(action))
+    },
+
+    startAction(name, options) {
+      const startClocks = clocksNow()
+      bufferApiCalls.notify((startRumResult) => startRumResult.startAction(name, options, startClocks))
+    },
+
+    stopAction(name, options) {
+      const stopClocks = clocksNow()
+      bufferApiCalls.notify((startRumResult) => startRumResult.stopAction(name, options, stopClocks))
+    },
+
+    startResource(url, options) {
+      const startClocks = clocksNow()
+      bufferApiCalls.notify((startRumResult) => startRumResult.startResource(url, options, startClocks))
+    },
+
+    stopResource(url, options) {
+      const stopClocks = clocksNow()
+      bufferApiCalls.notify((startRumResult) => startRumResult.stopResource(url, options, stopClocks))
     },
 
     addError(providedError) {
-      bufferApiCalls.add((startRumResult) => startRumResult.addError(providedError))
+      bufferApiCalls.notify((startRumResult) => startRumResult.addError(providedError))
     },
 
     addFeatureFlagEvaluation(key, value) {
-      bufferApiCalls.add((startRumResult) => startRumResult.addFeatureFlagEvaluation(key, value))
+      bufferApiCalls.notify((startRumResult) => startRumResult.addFeatureFlagEvaluation(key, value))
     },
 
     startDurationVital(name, options) {
-      return startDurationVital(customVitalsState, name, options)
+      const startClocks = clocksNow()
+      bufferApiCalls.notify((startRumResult) => startRumResult.startDurationVital(name, options, startClocks))
     },
 
     stopDurationVital(name, options) {
-      stopDurationVital(addDurationVital, customVitalsState, name, options)
+      const stopClocks = clocksNow()
+      bufferApiCalls.notify((startRumResult) => startRumResult.stopDurationVital(name, options, stopClocks))
     },
 
-    addDurationVital,
+    addDurationVital(vital) {
+      bufferApiCalls.notify((startRumResult) => startRumResult.addDurationVital(vital))
+    },
     addOperationStepVital,
   }
 
@@ -302,20 +438,12 @@ export function createPreStartStrategy(
 function overrideInitConfigurationForBridge(initConfiguration: RumInitConfiguration): RumInitConfiguration {
   return {
     ...initConfiguration,
+    // Resolve the service default here, while the web application id is still available: the
+    // placeholder below would otherwise be used, and it is shared by every bridge session.
+    service: initConfiguration.service || initConfiguration.applicationId,
     applicationId: '00000000-aaaa-0000-aaaa-000000000000',
     clientToken: 'empty',
     sessionSampleRate: 100,
     defaultPrivacyLevel: initConfiguration.defaultPrivacyLevel ?? getEventBridge()?.getPrivacyLevel(),
   }
 }
-
-function bufferContextCalls(
-  preStartContextManager: ContextManager,
-  name: CustomerContextKey,
-  bufferApiCalls: BoundedBuffer<StartRumResult>
-) {
-  preStartContextManager.changeObservable.subscribe(() => {
-    const context = preStartContextManager.getContext()
-    bufferApiCalls.add((startRumResult) => startRumResult[name].setContext(context))
-  })
-}