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

package/src/domain/tracing/tracer.ts

@@ -1,11 +1,13 @@
-import type { ContextManager } from '@kubesense/kubesense-browser-core'
+import type { ContextManager, SessionManager } from '@kubesense/kubesense-browser-core'
 import {
   objectEntries,
   shallowClone,
-  getType,
-  isMatchOption,
   matchList,
   TraceContextInjection,
+  correctedChildSampleRate,
+  isSampled,
+  canUseEventBridge,
+  getEventBridge,
 } from '@kubesense/kubesense-browser-core'
 import type { RumConfiguration } from '../configuration'
 import type {
@@ -14,9 +16,7 @@ import type {
   RumXhrCompleteContext,
   RumXhrStartContext,
 } from '../requestCollection'
-import type { RumSessionManager } from '../rumSessionManager'
-import { isSampled } from '../sampler/sampler'
-import type { PropagatorType, TracingOption } from './tracer.types'
+import type { PropagatorType } from './tracer.types'
 import type { SpanIdentifier, TraceIdentifier } from './identifier'
 import { createSpanIdentifier, createTraceIdentifier, toPaddedHexadecimalString } from './identifier'
 
@@ -30,15 +30,6 @@ interface TracingHeaders {
   [key: string]: string
 }
 
-export function isTracingOption(item: unknown): item is TracingOption {
-  const expectedItem = item as TracingOption
-  return (
-    getType(expectedItem) === 'object' &&
-    isMatchOption(expectedItem.match) &&
-    Array.isArray(expectedItem.propagatorTypes)
-  )
-}
-
 /**
  * Clear tracing information to avoid incomplete traces. Ideally, we should do it when the
  * request did not reach the server, but the browser does not expose this. So, we clear tracing
@@ -66,7 +57,7 @@ export function clearTracingIfNeeded(context: RumFetchResolveContext | RumXhrCom
 
 export function startTracer(
   configuration: RumConfiguration,
-  sessionManager: RumSessionManager,
+  sessionManager: SessionManager,
   userContext: ContextManager,
   accountContext: ContextManager
 ): Tracer {
@@ -113,9 +104,13 @@ export function startTracer(
         userContext,
         accountContext,
         (tracingHeaders: TracingHeaders) => {
-          Object.keys(tracingHeaders).forEach((name) => {
-            xhr.setRequestHeader(name, tracingHeaders[name])
-          })
+          try {
+            Object.keys(tracingHeaders).forEach((name) => {
+              xhr.setRequestHeader(name, tracingHeaders[name])
+            })
+          } catch {
+            // XHR may have already been sent (buffered replay via microtask)
+          }
         }
       ),
   }
@@ -124,7 +119,7 @@ export function startTracer(
 function injectHeadersIfTracingAllowed(
   configuration: RumConfiguration,
   context: Partial<RumFetchStartContext | RumXhrStartContext>,
-  sessionManager: RumSessionManager,
+  sessionManager: SessionManager,
   userContext: ContextManager,
   accountContext: ContextManager,
   inject: (tracingHeaders: TracingHeaders) => void
@@ -141,7 +136,13 @@ function injectHeadersIfTracingAllowed(
     return
   }
 
-  const traceSampled = isSampled(session.id, configuration.traceSampleRate)
+  const fallbackTraceSampled = isSampled(
+    session.id,
+    correctedChildSampleRate(configuration.sessionSampleRate, configuration.traceSampleRate)
+  )
+  const traceSampled = canUseEventBridge()
+    ? (getEventBridge()?.getIsTraceSampled() ?? fallbackTraceSampled)
+    : fallbackTraceSampled
 
   const shouldInjectHeaders = traceSampled || configuration.traceContextInjection === TraceContextInjection.ALL
   if (!shouldInjectHeaders) {

package/src/domain/tracing/tracer.types.ts

@@ -8,6 +8,6 @@ import type { MatchOption } from '@kubesense/kubesense-browser-core'
  */
 export type PropagatorType = 'kubesense' | 'b3' | 'b3multi' | 'tracecontext'
 export interface TracingOption {
-    match: MatchOption
-    propagatorTypes: PropagatorType[]
-  }
+  match: MatchOption
+  propagatorTypes: PropagatorType[]
+}

package/src/domain/view/bfCacheSupport.ts

@@ -1,12 +1,7 @@
-import type { Configuration } from '@kubesense/kubesense-browser-core'
 import { addEventListener, DOM_EVENT } from '@kubesense/kubesense-browser-core'
 
-export function onBFCacheRestore(
-  configuration: Configuration,
-  callback: (event: PageTransitionEvent) => void
-): () => void {
+export function onBFCacheRestore(callback: (event: PageTransitionEvent) => void): () => void {
   const { stop } = addEventListener(
-    configuration,
     window,
     DOM_EVENT.PAGE_SHOW,
     (event: PageTransitionEvent) => {

package/src/domain/view/trackViews.ts

@@ -1,31 +1,27 @@
-import type {
-  Duration,
-  ClocksState,
-  TimeStamp,
-  Subscription,
-  RelativeTime,
-  Context,
-  ContextValue,
-} from '@kubesense/kubesense-browser-core'
+import {
+  ONE_MINUTE,
+  elapsed,
+  timeStampNow,
+  clocksNow,
+  clocksOrigin,
+  relativeToClocks,
+  isRelativeTime,
+} from '@kubesense/kubesense-js-core/time'
+import type { Duration, TimeStamp, ClocksState, RelativeTime } from '@kubesense/kubesense-js-core/time'
+import type { Subscription, Context, ContextValue } from '@kubesense/kubesense-browser-core'
 import {
   noop,
   PageExitReason,
   shallowClone,
-  elapsed,
   generateUUID,
-  ONE_MINUTE,
   throttle,
-  clocksNow,
-  clocksOrigin,
-  relativeToClocks,
-  timeStampNow,
   display,
-  looksLikeRelativeTime,
   setInterval,
   clearInterval,
   setTimeout,
   Observable,
   createContextManager,
+  mockable,
 } from '@kubesense/kubesense-browser-core'
 import type { ViewCustomTimings } from '../../rawRumEvent.types'
 import { ViewLoadingType } from '../../rawRumEvent.types'
@@ -50,6 +46,7 @@ export interface ViewEvent {
   version?: string
   context?: Context
   location: Readonly<Location>
+  handlingStack?: string
   commonViewMetrics: CommonViewMetrics
   initialViewMetrics: InitialViewMetrics
   customTimings: ViewCustomTimings
@@ -69,6 +66,7 @@ export interface ViewCreatedEvent {
   version?: string
   context?: Context
   startClocks: ClocksState
+  url?: string
 }
 
 export interface BeforeViewUpdateEvent {
@@ -99,10 +97,11 @@ export interface ViewOptions {
   service?: RumInitConfiguration['service']
   version?: RumInitConfiguration['version']
   context?: Context
+  handlingStack?: string
+  url?: string
 }
 
 export function trackViews(
-  location: Location,
   lifeCycle: LifeCycle,
   domMutationObservable: Observable<RumMutationRecord[]>,
   windowOpenObservable: Observable<void>,
@@ -120,13 +119,11 @@ export function trackViews(
   let locationChangeSubscription: Subscription
   if (areViewsTrackedAutomatically) {
     locationChangeSubscription = renewViewOnLocationChange(locationChangeObservable)
-    if (configuration.trackBfcacheViews) {
-      stopOnBFCacheRestore = onBFCacheRestore(configuration, (pageshowEvent) => {
-        currentView.end()
-        const startClocks = relativeToClocks(pageshowEvent.timeStamp as RelativeTime)
-        currentView = startNewView(ViewLoadingType.BF_CACHE, startClocks, undefined)
-      })
-    }
+    stopOnBFCacheRestore = onBFCacheRestore((pageshowEvent) => {
+      currentView.end()
+      const startClocks = relativeToClocks(pageshowEvent.timeStamp as RelativeTime)
+      currentView = startNewView(ViewLoadingType.BF_CACHE, startClocks, undefined)
+    })
   }
 
   function startNewView(loadingType: ViewLoadingType, startClocks?: ClocksState, viewOptions?: ViewOptions) {
@@ -135,7 +132,6 @@ export function trackViews(
       domMutationObservable,
       windowOpenObservable,
       configuration,
-      location,
       loadingType,
       startClocks,
       viewOptions
@@ -149,8 +145,8 @@ export function trackViews(
 
   function startViewLifeCycle() {
     lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {
-      // Renew view on session renewal
-      currentView = startNewView(ViewLoadingType.ROUTE_CHANGE, undefined, {
+      currentView = startNewView(ViewLoadingType.SESSION_RENEWAL, undefined, {
+        // Renew view on session renewal
         name: currentView.name,
         service: currentView.service,
         version: currentView.version,
@@ -158,8 +154,8 @@ export function trackViews(
       })
     })
 
-    lifeCycle.subscribe(LifeCycleEventType.SESSION_EXPIRED, () => {
-      currentView.end({ sessionIsActive: false })
+    lifeCycle.subscribe(LifeCycleEventType.SESSION_EXPIRED, ({ endClocks }) => {
+      currentView.end({ sessionIsActive: false, endClocks })
     })
   }
 
@@ -176,6 +172,7 @@ export function trackViews(
     addTiming: (name: string, time: RelativeTime | TimeStamp = timeStampNow()) => {
       currentView.addTiming(name, time)
     },
+    setLoadingTime: (callTimestamp?: TimeStamp) => currentView.setLoadingTime(callTimestamp),
     startView: (options?: ViewOptions, startClocks?: ClocksState) => {
       currentView.end({ endClocks: startClocks })
       currentView = startNewView(ViewLoadingType.ROUTE_CHANGE, startClocks, options)
@@ -209,7 +206,6 @@ function newView(
   domMutationObservable: Observable<RumMutationRecord[]>,
   windowOpenObservable: Observable<void>,
   configuration: RumConfiguration,
-  initialLocation: Location,
   loadingType: ViewLoadingType,
   startClocks: ClocksState = clocksNow(),
   viewOptions?: ViewOptions
@@ -220,7 +216,7 @@ function newView(
   const customTimings: ViewCustomTimings = {}
   let documentVersion = 0
   let endClocks: ClocksState | undefined
-  const location = shallowClone(initialLocation)
+  const location = shallowClone(mockable(window.location))
   const contextManager = createContextManager()
 
   let sessionIsActive = true
@@ -228,6 +224,7 @@ function newView(
   const service = viewOptions?.service || configuration.service
   const version = viewOptions?.version || configuration.version
   const context = viewOptions?.context
+  const handlingStack = viewOptions?.handlingStack
 
   if (context) {
     contextManager.setContext(context)
@@ -240,6 +237,7 @@ function newView(
     service,
     version,
     context,
+    url: viewOptions?.url,
   }
   lifeCycle.notify(LifeCycleEventType.BEFORE_VIEW_CREATED, viewCreatedEvent)
   lifeCycle.notify(LifeCycleEventType.VIEW_CREATED, viewCreatedEvent)
@@ -255,6 +253,7 @@ function newView(
     stop: stopCommonViewMetricsTracking,
     stopINPTracking,
     getCommonViewMetrics,
+    setLoadingTime,
   } = trackCommonViewMetrics(
     lifeCycle,
     domMutationObservable,
@@ -280,17 +279,14 @@ function newView(
   // Session keep alive
   const keepAliveIntervalId = setInterval(triggerViewUpdate, SESSION_KEEP_ALIVE_INTERVAL)
 
-  const pageMayExitSubscription = lifeCycle.subscribe(LifeCycleEventType.PAGE_MAY_EXIT, (pageMayExitEvent) => {
+  const pageMayExitSubscription = lifeCycle.subscribe(LifeCycleEventType.PREPARE_URGENT_FLUSH, (reason) => {
     // beforeunload is the unreliable half of this: it is skipped on mobile and
     // when a tab is discarded, while pagehide fires on the paths it misses. The
     // replay recorder already flushes on every exit reason, which is how a
     // session ends up with a segment recorded after the last view update the
     // backend ever saw — the view then stays active, and the session's duration
     // is reported without its final and usually longest view.
-    if (
-      pageMayExitEvent.reason === PageExitReason.UNLOADING ||
-      pageMayExitEvent.reason === PageExitReason.PAGEHIDE
-    ) {
+    if (reason === PageExitReason.UNLOADING || reason === PageExitReason.PAGEHIDE) {
       // Force the final emission's isActive=false without mutating endClocks.
       // Why this matters: the regular triggerViewUpdate computes
       // `isActive: endClocks === undefined`, which is `true` here because we
@@ -348,6 +344,7 @@ function newView(
       context: contextManager.getContext(),
       loadingType,
       location,
+      handlingStack,
       startClocks,
       commonViewMetrics: getCommonViewMetrics(),
       initialViewMetrics,
@@ -375,6 +372,11 @@ function newView(
         return
       }
       endClocks = options.endClocks ?? clocksNow()
+      // A session timeout is dated to when it happened (see getSessionEndClocks), which can
+      // precede a view a late-running tab started afterwards. A view never ends before it starts.
+      if (endClocks.relative < startClocks.relative) {
+        endClocks = startClocks
+      }
       sessionIsActive = options.sessionIsActive ?? true
 
       lifeCycle.notify(LifeCycleEventType.VIEW_ENDED, { endClocks })
@@ -398,10 +400,11 @@ function newView(
       if (endClocks) {
         return
       }
-      const relativeTime = looksLikeRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time)
+      const relativeTime = isRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time)
       customTimings[sanitizeTiming(name)] = relativeTime
       scheduleViewUpdate()
     },
+    setLoadingTime,
     setViewName(updatedName: string) {
       name = updatedName
       triggerViewUpdate()

package/src/domain/view/viewCollection.ts

@@ -1,5 +1,8 @@
-import type { Duration, ServerDuration, Observable } from '@kubesense/kubesense-browser-core'
-import { getTimeZone, DISCARDED, HookNames, isEmptyObject, mapValues, toServerDuration } from '@kubesense/kubesense-browser-core'
+import type { Observable } from '@kubesense/kubesense-browser-core'
+import { toServerDuration } from '@kubesense/kubesense-js-core/time'
+import type { Duration, ServerDuration } from '@kubesense/kubesense-js-core/time'
+import { getTimeZone, isEmptyObject, mapValues } from '@kubesense/kubesense-browser-core'
+import { DISCARDED } from '@kubesense/kubesense-js-core/assembly'
 import { discardNegativeDuration } from '../discardNegativeDuration'
 import type { RecorderApi } from '../../boot/rumPublicApi'
 import type { RawRumViewEvent, ViewPerformanceData } from '../../rawRumEvent.types'
@@ -20,7 +23,6 @@ export function startViewCollection(
   lifeCycle: LifeCycle,
   hooks: Hooks,
   configuration: RumConfiguration,
-  location: Location,
   domMutationObservable: Observable<RumMutationRecord[]>,
   pageOpenObservable: Observable<void>,
   locationChangeObservable: Observable<LocationChange>,
@@ -32,7 +34,7 @@ export function startViewCollection(
     lifeCycle.notify(LifeCycleEventType.RAW_RUM_EVENT_COLLECTED, processViewUpdate(view, configuration, recorderApi))
   )
 
-  hooks.register(HookNames.Assemble, ({ startTime, eventType }): DefaultRumEventAttributes | DISCARDED => {
+  hooks.assembleEventDefaults.register(({ startTime, eventType }): DefaultRumEventAttributes | DISCARDED => {
     const view = viewHistory.findView(startTime)
 
     if (!view) {
@@ -51,17 +53,13 @@ export function startViewCollection(
     }
   })
 
-  hooks.register(
-    HookNames.AssembleTelemetry,
-    ({ startTime }): DefaultTelemetryEventAttributes => ({
-      view: {
-        id: viewHistory.findView(startTime)?.id,
-      },
-    })
-  )
+  hooks.assembleTelemetry.register(({ startTime }): DefaultTelemetryEventAttributes => ({
+    view: {
+      id: viewHistory.findView(startTime)?.id,
+    },
+  }))
 
   return trackViews(
-    location,
     lifeCycle,
     domMutationObservable,
     pageOpenObservable,
@@ -90,6 +88,7 @@ function processViewUpdate(
         : undefined,
       configuration: {
         start_session_replay_recording_manually: configuration.startSessionReplayRecordingManually,
+        remote_configuration_id: configuration.remoteConfigurationId,
       },
     },
     date: view.startClocks.timeStamp,
@@ -112,9 +111,6 @@ function processViewUpdate(
         count: view.eventCounts.errorCount,
       },
       first_contentful_paint: toServerDuration(view.initialViewMetrics.firstContentfulPaint),
-      first_input_delay: toServerDuration(view.initialViewMetrics.firstInput?.delay),
-      first_input_time: toServerDuration(view.initialViewMetrics.firstInput?.time),
-      first_input_target_selector: view.initialViewMetrics.firstInput?.targetSelector,
       interaction_to_next_paint: toServerDuration(view.commonViewMetrics.interactionToNextPaint?.value),
       interaction_to_next_paint_time: toServerDuration(view.commonViewMetrics.interactionToNextPaint?.time),
       interaction_to_next_paint_target_selector: view.commonViewMetrics.interactionToNextPaint?.targetSelector,
@@ -163,17 +159,18 @@ function processViewUpdate(
 
   return {
     rawRumEvent: viewEvent,
-    startTime: view.startClocks.relative,
+    startClocks: view.startClocks,
     duration: view.duration,
     domainContext: {
       location: view.location,
+      handlingStack: view.handlingStack,
     },
   }
 }
 
 function computeViewPerformanceData(
   { cumulativeLayoutShift, interactionToNextPaint }: CommonViewMetrics,
-  { firstContentfulPaint, firstInput, largestContentfulPaint }: InitialViewMetrics
+  { firstContentfulPaint, largestContentfulPaint }: InitialViewMetrics
 ): ViewPerformanceData {
   return {
     cls: cumulativeLayoutShift && {
@@ -184,20 +181,29 @@ function computeViewPerformanceData(
       current_rect: cumulativeLayoutShift.currentRect,
     },
     fcp: firstContentfulPaint && { timestamp: toServerDuration(firstContentfulPaint) },
-    fid: firstInput && {
-      duration: toServerDuration(firstInput.delay),
-      timestamp: toServerDuration(firstInput.time),
-      target_selector: firstInput.targetSelector,
-    },
     inp: interactionToNextPaint && {
       duration: toServerDuration(interactionToNextPaint.value),
       timestamp: toServerDuration(interactionToNextPaint.time),
       target_selector: interactionToNextPaint.targetSelector,
+      sub_parts: interactionToNextPaint.subParts
+        ? {
+            input_delay: toServerDuration(interactionToNextPaint.subParts.inputDelay),
+            processing_duration: toServerDuration(interactionToNextPaint.subParts.processingDuration),
+            presentation_delay: toServerDuration(interactionToNextPaint.subParts.presentationDelay),
+          }
+        : undefined,
     },
     lcp: largestContentfulPaint && {
       timestamp: toServerDuration(largestContentfulPaint.value),
       target_selector: largestContentfulPaint.targetSelector,
       resource_url: largestContentfulPaint.resourceUrl,
+      sub_parts: largestContentfulPaint.subParts
+        ? {
+            load_delay: toServerDuration(largestContentfulPaint.subParts.loadDelay),
+            load_time: toServerDuration(largestContentfulPaint.subParts.loadTime),
+            render_delay: toServerDuration(largestContentfulPaint.subParts.renderDelay),
+          }
+        : undefined,
     },
   }
 }

package/src/domain/view/viewDiff.ts

@@ -0,0 +1,115 @@
+import { isIndexableObject } from '@kubesense/kubesense-js-core/util'
+
+/**
+ * Compare two values for deep equality
+ */
+export function isEqual(a: unknown, b: unknown): boolean {
+  if (a === b) {
+    return true
+  }
+
+  if (a === null || typeof a !== 'object' || b === null || typeof b !== 'object') {
+    return a === b
+  }
+
+  // Arrays
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false
+    }
+    return a.every((val, idx) => isEqual(val, b[idx]))
+  }
+
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return false
+  }
+
+  // Plain objects
+  const aObj = a as Record<string, unknown>
+  const bObj = b as Record<string, unknown>
+  const aKeys = Object.keys(aObj)
+  const bKeys = Object.keys(bObj)
+
+  if (aKeys.length !== bKeys.length) {
+    return false
+  }
+
+  return aKeys.every((key) => bKeys.includes(key) && isEqual(aObj[key], bObj[key]))
+}
+
+/**
+ * Options for controlling diff merge behavior
+ */
+export interface DiffMergeOptions {
+  replaceKeys?: Set<string>
+  appendKeys?: Set<string>
+  ignoreKeys?: Set<string>
+}
+
+/**
+ * MERGE strategy: compare two objects and return an object with only changed fields.
+ * Returns undefined if no changes.
+ *
+ * Default strategy is REPLACE (isEqual check). Exceptions:
+ * - Both values are plain objects and key is not in replaceKeys: recurse (MERGE), sub-paths
+ * (e.g. 'view.custom_timings') are propagated to the recursive call.
+ * - Both values are arrays and key is in appendKeys: include only new trailing elements (APPEND)
+ */
+export function diffMerge(
+  current: Record<string, unknown>,
+  lastSent: Record<string, unknown>,
+  options?: DiffMergeOptions
+): Record<string, unknown> | undefined {
+  const result: Record<string, unknown> = {}
+  const replaceKeys = options?.replaceKeys ?? new Set<string>()
+  const appendKeys = options?.appendKeys ?? new Set<string>()
+  const ignoreKeys = options?.ignoreKeys ?? new Set<string>()
+
+  for (const key of Object.keys(current)) {
+    if (ignoreKeys.has(key)) {
+      continue
+    }
+
+    const currentVal = current[key]
+    const lastSentVal = lastSent[key]
+
+    if (!replaceKeys.has(key) && isIndexableObject(currentVal) && isIndexableObject(lastSentVal)) {
+      // Both are plain objects and not marked for replace: recurse (MERGE)
+      const nestedDiff = diffMerge(currentVal, lastSentVal, {
+        replaceKeys: extractSubPaths(replaceKeys, key),
+        appendKeys: extractSubPaths(appendKeys, key),
+        ignoreKeys: extractSubPaths(ignoreKeys, key),
+      })
+      if (nestedDiff) {
+        result[key] = nestedDiff
+      }
+    } else if (appendKeys.has(key) && Array.isArray(currentVal) && Array.isArray(lastSentVal)) {
+      // Array in appendKeys: include only new trailing elements (APPEND)
+      if (currentVal.length > lastSentVal.length) {
+        result[key] = currentVal.slice(lastSentVal.length)
+      }
+    } else if (!isEqual(currentVal, lastSentVal)) {
+      // Default: replace the whole value (REPLACE)
+      result[key] = currentVal
+    }
+  }
+
+  // Deleted keys: present in lastSent but not in current
+  for (const key of Object.keys(lastSent)) {
+    if (!(key in current)) {
+      result[key] = null
+    }
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined
+}
+
+function extractSubPaths(keys: Set<string>, prefix: string): Set<string> {
+  const result = new Set<string>()
+  for (const key of keys) {
+    if (key.startsWith(`${prefix}.`)) {
+      result.add(key.slice(prefix.length + 1))
+    }
+  }
+  return result
+}

package/src/domain/view/viewMetrics/interactionCountPolyfill.ts

@@ -11,7 +11,7 @@
  * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/main/src/lib/polyfills/interactionCountPolyfill.ts
  */
 
-import { monitor } from '@kubesense/kubesense-browser-core'
+import { monitor } from '@kubesense/kubesense-js-core/monitor'
 import type {
   BrowserWindow,
   RumPerformanceEventTiming,
@@ -52,4 +52,15 @@ export function initInteractionCountPolyfill() {
  * or the polyfill estimate in this module.
  */
 export const getInteractionCount = () =>
-  observer ? interactionCountEstimate : (window as BrowserWindow).performance.interactionCount! || 0
+  observer ? interactionCountEstimate : (window as BrowserWindow).performance.interactionCount || 0
+
+export function resetInteractionCountPolyfill() {
+  if (observer) {
+    observer.disconnect()
+
+    observer = undefined
+    interactionCountEstimate = 0
+    minKnownInteractionId = Infinity
+    maxKnownInteractionId = 0
+  }
+}

package/src/domain/view/viewMetrics/trackBfcacheMetrics.ts

@@ -1,4 +1,4 @@
-import type { RelativeTime, ClocksState } from '@kubesense/kubesense-browser-core'
+import type { RelativeTime, ClocksState } from '@kubesense/kubesense-js-core/time'
 import type { InitialViewMetrics } from './trackInitialViewMetrics'
 import { trackRestoredFirstContentfulPaint } from './trackFirstContentfulPaint'
 

package/src/domain/view/viewMetrics/trackCommonViewMetrics.ts

@@ -1,4 +1,6 @@
-import type { ClocksState, Duration, Observable } from '@kubesense/kubesense-browser-core'
+import type { ClocksState, RelativeTime, Duration, TimeStamp } from '@kubesense/kubesense-js-core/time'
+import type { Observable } from '@kubesense/kubesense-browser-core'
+import { elapsed, timeStampNow } from '@kubesense/kubesense-js-core/time'
 import type { ViewLoadingType } from '../../../rawRumEvent.types'
 import type { RumConfiguration } from '../../configuration'
 import type { LifeCycle } from '../../lifeCycle'
@@ -28,6 +30,8 @@ export function trackCommonViewMetrics(
   viewStart: ClocksState
 ) {
   const commonViewMetrics: CommonViewMetrics = {}
+  let hasManualLoadingTime = false
+  let viewEnded = false
 
   const { stop: stopLoadingTimeTracking, setLoadEvent } = trackLoadingTime(
     lifeCycle,
@@ -37,12 +41,14 @@ export function trackCommonViewMetrics(
     loadingType,
     viewStart,
     (newLoadingTime) => {
-      commonViewMetrics.loadingTime = newLoadingTime
-      scheduleViewUpdate()
+      if (!hasManualLoadingTime) {
+        commonViewMetrics.loadingTime = newLoadingTime
+        scheduleViewUpdate()
+      }
     }
   )
 
-  const { stop: stopScrollMetricsTracking } = trackScrollMetrics(configuration, viewStart, (newScrollMetrics) => {
+  const { stop: stopScrollMetricsTracking } = trackScrollMetrics(viewStart, (newScrollMetrics) => {
     commonViewMetrics.scroll = newScrollMetrics
   })
 
@@ -58,7 +64,7 @@ export function trackCommonViewMetrics(
   const {
     stop: stopINPTracking,
     getInteractionToNextPaint,
-    setViewEnd,
+    setViewEnd: setINPViewEnd,
   } = trackInteractionToNextPaint(configuration, viewStart.relative, loadingType)
 
   return {
@@ -69,10 +75,25 @@ export function trackCommonViewMetrics(
     },
     stopINPTracking,
     setLoadEvent,
-    setViewEnd,
+    setViewEnd: (viewEndTime: RelativeTime) => {
+      viewEnded = true
+      setINPViewEnd(viewEndTime)
+    },
     getCommonViewMetrics: () => {
       commonViewMetrics.interactionToNextPaint = getInteractionToNextPaint()
       return commonViewMetrics
     },
+    setLoadingTime: (callTimestamp?: TimeStamp) => {
+      if (viewEnded) {
+        return
+      }
+      const loadingTime = elapsed(viewStart.timeStamp, callTimestamp ?? timeStampNow())
+      if (!hasManualLoadingTime) {
+        stopLoadingTimeTracking()
+      }
+      hasManualLoadingTime = true
+      commonViewMetrics.loadingTime = loadingTime
+      scheduleViewUpdate()
+    },
   }
 }