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

package/src/domain/configuration/remoteSdkConfiguration.ts

@@ -5,13 +5,21 @@ import {
   getCachedSdkConfig,
   readBoolean,
   readEnum,
+  readNumberInRange,
   readSampleRate,
   readString,
+  readStringList,
   refreshSdkConfig,
 } from '@kubesense/kubesense-browser-core'
+import { isIndexableObject } from '@kubesense/kubesense-js-core/util'
+import type { MatchOption } from '@kubesense/kubesense-js-core/configuration'
+import type { PropagatorType } from '../tracing/tracer.types'
 import type { RumInitConfiguration } from './configuration'
+import { CanvasRecordingQuality } from './configuration'
 import type { SessionReplayRoutes } from './sessionReplayRoutes'
 
+const PROPAGATOR_TYPES: readonly PropagatorType[] = ['kubesense', 'b3', 'b3multi', 'tracecontext']
+
 /**
  * Applies the dashboard-managed configuration document to the user's init configuration.
  *
@@ -29,31 +37,48 @@ const PRIVACY_LEVELS = [
   DefaultPrivacyLevel.ALLOW,
   DefaultPrivacyLevel.MASK,
   DefaultPrivacyLevel.MASK_USER_INPUT,
+  DefaultPrivacyLevel.MASK_UNLESS_ALLOWLISTED,
 ] as const
 
 const TRACE_CONTEXT_INJECTIONS = [TraceContextInjection.ALL, TraceContextInjection.SAMPLED] as const
 
+const CANVAS_RECORDING_QUALITIES = [
+  CanvasRecordingQuality.LOW,
+  CanvasRecordingQuality.MEDIUM,
+  CanvasRecordingQuality.HIGH,
+] as const
+
 export interface RemoteSdkConfigurationResult {
   initConfiguration: RumInitConfiguration
   /** `false` when the dashboard has switched RUM off entirely. */
   rumEnabled: boolean
 }
 
+/** The context managers the document can contribute to. */
+export interface RemoteSdkConfigurationContexts {
+  globalContext?: { setContextProperty: (key: string, value: unknown) => void }
+  userContext?: { setContextProperty: (key: string, value: unknown) => void }
+}
+
 /**
  * Read the cached document and merge it into the init configuration. Synchronous and
  * network-free: this runs on the initialization path.
  */
-export function applyCachedSdkConfiguration(initConfiguration: RumInitConfiguration): RemoteSdkConfigurationResult {
-  const remoteConfig = getCachedSdkConfig()
+export function applyCachedSdkConfiguration(
+  initConfiguration: RumInitConfiguration,
+  contexts?: RemoteSdkConfigurationContexts
+): RemoteSdkConfigurationResult {
+  const remoteConfig = getCachedSdkConfig(initConfiguration.clientToken)
   if (!remoteConfig) {
     return { initConfiguration, rumEnabled: true }
   }
-  return applySdkConfiguration(initConfiguration, remoteConfig)
+  return applySdkConfiguration(initConfiguration, remoteConfig, contexts)
 }
 
 export function applySdkConfiguration(
   initConfiguration: RumInitConfiguration,
-  remoteConfig: RemoteSdkConfig
+  remoteConfig: RemoteSdkConfig,
+  contexts?: RemoteSdkConfigurationContexts
 ): RemoteSdkConfigurationResult {
   const features = remoteConfig.features
   if (readBoolean(features as { [key: string]: unknown } | undefined, 'rum') === false) {
@@ -63,6 +88,7 @@ export function applySdkConfiguration(
   const applied: RumInitConfiguration = { ...initConfiguration }
 
   applyRumSection(applied, remoteConfig.rum)
+  applyContexts(remoteConfig.rum, contexts)
   applySessionReplaySection(applied, remoteConfig.sessionReplay)
   applyProfilingSection(applied, remoteConfig.profiling)
   applyFeatureSwitches(applied, features)
@@ -83,7 +109,6 @@ function applyRumSection(applied: RumInitConfiguration, rum: { [key: string]: un
   assign(applied, 'trackResources', readBoolean(rum, 'trackResources'))
   assign(applied, 'trackLongTasks', readBoolean(rum, 'trackLongTasks'))
   assign(applied, 'trackViewsManually', readBoolean(rum, 'trackViewsManually'))
-  assign(applied, 'trackBfcacheViews', readBoolean(rum, 'trackBfcacheViews'))
   assign(applied, 'trackAnonymousUser', readBoolean(rum, 'trackAnonymousUser'))
   assign(applied, 'trackSessionAcrossSubdomains', readBoolean(rum, 'trackSessionAcrossSubdomains'))
   assign(applied, 'enablePrivacyForActionName', readBoolean(rum, 'enablePrivacyForActionName'))
@@ -93,11 +118,86 @@ function applyRumSection(applied: RumInitConfiguration, rum: { [key: string]: un
   assign(applied, 'traceContextInjection', readEnum(rum, 'traceContextInjection', TRACE_CONTEXT_INJECTIONS))
   assign(applied, 'actionNameAttribute', readString(rum, 'actionNameAttribute'))
 
+  assign(applied, 'betaEnableViewUpdates', readBoolean(rum, 'betaEnableViewUpdates'))
+  assign(applied, 'betaTrackWebSockets', readBoolean(rum, 'betaTrackWebSockets'))
+  // Only the "collect the default headers / collect nothing" switch travels. The MatchHeader[] form
+  // selects headers by name with optional extractor functions, which cannot come from JSON.
+  assign(applied, 'trackResourceHeaders', readBoolean(rum, 'trackResourceHeaders'))
+
+  assign(applied, 'allowedTracingUrls', readTracingUrls(rum.allowedTracingUrls))
+  assign(applied, 'allowedTrackingOrigins', readStringList(rum.allowedTrackingOrigins))
+
   assign(applied, 'service', readString(rum, 'service'))
   assign(applied, 'env', readString(rum, 'env'))
   assign(applied, 'version', readString(rum, 'version'))
 }
 
+/**
+ * Tracing URLs arriving as JSON can only be plain strings (prefix matches), optionally paired with
+ * the propagators to inject. As with route rules, regexes and functions stay in application code:
+ * they cannot be expressed safely in JSON, and this list decides which cross-origin requests get
+ * tracing headers attached — a pattern that is broader than intended leaks trace ids to third
+ * parties and can break their CORS preflight.
+ */
+function readTracingUrls(value: unknown): RumInitConfiguration['allowedTracingUrls'] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined
+  }
+
+  const options: Array<MatchOption | { match: MatchOption; propagatorTypes?: PropagatorType[] }> = []
+  for (const entry of value) {
+    if (typeof entry === 'string' && entry.length > 0) {
+      options.push(entry)
+      continue
+    }
+    if (!isIndexableObject(entry)) {
+      continue
+    }
+    const match = readString(entry, 'match')
+    if (!match) {
+      continue
+    }
+    const propagatorTypes = readStringList(entry.propagatorTypes)?.filter((propagator): propagator is PropagatorType =>
+      (PROPAGATOR_TYPES as readonly string[]).includes(propagator)
+    )
+    options.push(propagatorTypes?.length ? { match, propagatorTypes } : { match })
+  }
+
+  return options.length > 0 ? options : undefined
+}
+
+/**
+ * Properties from the document are set individually rather than replacing the whole context, so
+ * anything the application has already attached with `setGlobalContext()` / `setUser()` survives.
+ *
+ * The user is applied here, before `startUserContext()` installs its change subscription, so a
+ * remotely-supplied identity behaves exactly like an application calling `setUser()` at the top of
+ * its bootstrap: it becomes the session owner rather than looking like a mid-session user switch.
+ * Changing the user in the dashboard therefore expires the session once, on the first load that
+ * reads the new document — which is the intended behaviour for a user change — and steady-state
+ * loads leave the session alone.
+ */
+function applyContexts(
+  rum: { [key: string]: unknown } | undefined,
+  contexts: RemoteSdkConfigurationContexts | undefined
+) {
+  applyContextProperties(contexts?.globalContext, rum?.context)
+  applyContextProperties(contexts?.userContext, rum?.user)
+}
+
+function applyContextProperties(
+  contextManager: { setContextProperty: (key: string, value: unknown) => void } | undefined,
+  properties: unknown
+) {
+  if (!contextManager || !isIndexableObject(properties)) {
+    return
+  }
+
+  for (const [key, value] of Object.entries(properties)) {
+    contextManager.setContextProperty(key, value)
+  }
+}
+
 function applySessionReplaySection(
   applied: RumInitConfiguration,
   sessionReplay: { [key: string]: unknown } | undefined
@@ -110,6 +210,32 @@ function applySessionReplaySection(
   assign(applied, 'startSessionReplayRecordingManually', readBoolean(sessionReplay, 'startRecordingManually'))
   assign(applied, 'defaultPrivacyLevel', readEnum(sessionReplay, 'defaultPrivacyLevel', PRIVACY_LEVELS))
   assign(applied, 'sessionReplayRoutes', readRoutes(sessionReplay.routes))
+  assign(applied, 'sessionReplayCanvasRecording', readCanvasRecording(sessionReplay.canvasRecording))
+}
+
+/**
+ * Canvas capture is the most expensive replay setting there is — it uploads rendered frames — so it
+ * is only enabled when the document says so explicitly, and each limit is validated against the
+ * range the SDK accepts instead of being clamped.
+ */
+function readCanvasRecording(canvasRecording: unknown): RumInitConfiguration['sessionReplayCanvasRecording'] {
+  if (!isIndexableObject(canvasRecording)) {
+    return undefined
+  }
+
+  const enable = readBoolean(canvasRecording, 'enable')
+  if (enable === undefined) {
+    // Without an explicit switch there is nothing to apply: the remaining fields are only limits.
+    return undefined
+  }
+
+  return {
+    enable,
+    quality: readEnum(canvasRecording, 'quality', CANVAS_RECORDING_QUALITIES),
+    maxFramesPerSecond: readNumberInRange(canvasRecording, 'maxFramesPerSecond', 0, 8),
+    hashingMaxDimension: readNumberInRange(canvasRecording, 'hashingMaxDimension', 1, 100),
+    maxImageDimension: readNumberInRange(canvasRecording, 'maxImageDimension', 1, 1280),
+  }
 }
 
 /**
@@ -132,14 +258,6 @@ function readRoutes(routes: unknown): SessionReplayRoutes | undefined {
   return { include, exclude }
 }
 
-function readStringList(value: unknown): string[] | undefined {
-  if (!Array.isArray(value)) {
-    return undefined
-  }
-  const strings = value.filter((item): item is string => typeof item === 'string' && item.length > 0)
-  return strings.length > 0 ? strings : undefined
-}
-
 function applyProfilingSection(applied: RumInitConfiguration, profiling: { [key: string]: unknown } | undefined) {
   if (!profiling) {
     return

package/src/domain/configuration/sessionReplayRoutes.ts

@@ -1,5 +1,5 @@
-import type { MatchOption } from '@kubesense/kubesense-browser-core'
-import { display, isMatchOption, matchList } from '@kubesense/kubesense-browser-core'
+import type { MatchOption } from '@kubesense/kubesense-js-core/configuration'
+import { matchList } from '@kubesense/kubesense-browser-core'
 
 /**
  * Route-scoped Session Replay.
@@ -49,48 +49,3 @@ export function isRouteRecordable(routes: SessionReplayRoutes | undefined, path:
 
   return true
 }
-
-/**
- * Validates the user-provided option. An invalid entry is dropped rather than silently treated
- * as "match nothing", which would turn a typo into a total loss of replay.
- */
-export function validateSessionReplayRoutes(routes: unknown): SessionReplayRoutes | undefined {
-  if (routes === undefined || routes === null) {
-    return undefined
-  }
-
-  if (typeof routes !== 'object' || Array.isArray(routes)) {
-    display.error('Session Replay routes should be an object with optional include and exclude arrays')
-    return undefined
-  }
-
-  const include = validateMatchOptionList((routes as SessionReplayRoutes).include, 'include')
-  const exclude = validateMatchOptionList((routes as SessionReplayRoutes).exclude, 'exclude')
-
-  if (!include && !exclude) {
-    return undefined
-  }
-
-  return { include, exclude }
-}
-
-function validateMatchOptionList(list: unknown, name: string): MatchOption[] | undefined {
-  if (list === undefined) {
-    return undefined
-  }
-
-  if (!Array.isArray(list)) {
-    display.error(`Session Replay routes "${name}" should be an array`)
-    return undefined
-  }
-
-  const validOptions = list.filter((item) => {
-    if (isMatchOption(item)) {
-      return true
-    }
-    display.error(`Session Replay routes "${name}" entries should be a string, RegExp or function`)
-    return false
-  }) as MatchOption[]
-
-  return validOptions.length > 0 ? validOptions : undefined
-}

package/src/domain/contexts/ciVisibilityContext.ts

@@ -1,8 +1,8 @@
-import { getInitCookie, HookNames, SKIPPED } from '@kubesense/kubesense-browser-core'
-import type { Configuration } from '@kubesense/kubesense-browser-core'
+import { display, getInitCookie } from '@kubesense/kubesense-browser-core'
+import { SKIPPED } from '@kubesense/kubesense-js-core/assembly'
 import { createCookieObservable } from '../../browser/cookieObservable'
-import { SessionType } from '../rumSessionManager'
-import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+import type { AssembleHook, DefaultRumEventAttributes } from '../hooks'
+import { SessionType } from './sessionContext'
 
 export const CI_VISIBILITY_TEST_ID_COOKIE_NAME = 'kubesense-ci-visibility-test-execution-id'
 
@@ -12,21 +12,17 @@ export interface CiTestWindow extends Window {
   }
 }
 
-export type CiVisibilityContext = ReturnType<typeof startCiVisibilityContext>
-
 export function startCiVisibilityContext(
-  configuration: Configuration,
-  hooks: Hooks,
-  cookieObservable = createCookieObservable(configuration, CI_VISIBILITY_TEST_ID_COOKIE_NAME)
+  assembleHook: AssembleHook,
+  cookieObservable = createCookieObservable(CI_VISIBILITY_TEST_ID_COOKIE_NAME)
 ) {
-  let testExecutionId =
-    getInitCookie(CI_VISIBILITY_TEST_ID_COOKIE_NAME) || (window as CiTestWindow).Cypress?.env('traceId')
+  let testExecutionId = getInitCookie(CI_VISIBILITY_TEST_ID_COOKIE_NAME) || readCypressTraceId()
 
   const cookieObservableSubscription = cookieObservable.subscribe((value) => {
     testExecutionId = value
   })
 
-  hooks.register(HookNames.Assemble, ({ eventType }): DefaultRumEventAttributes | SKIPPED => {
+  assembleHook.register(({ eventType }): DefaultRumEventAttributes | SKIPPED => {
     if (typeof testExecutionId !== 'string') {
       return SKIPPED
     }
@@ -48,3 +44,18 @@ export function startCiVisibilityContext(
     },
   }
 }
+
+function readCypressTraceId(): string | undefined {
+  const cypress = (window as CiTestWindow).Cypress
+  if (!cypress) {
+    return undefined
+  }
+  try {
+    return cypress.env('traceId')
+  } catch {
+    display.warn(
+      'Failed to read Cypress test execution id via Cypress.env(). Upgrade dd-trace-js to >= 5.88.0 to keep RUM ↔ test correlation working.'
+    )
+    return undefined
+  }
+}

package/src/domain/contexts/connectivityContext.ts

@@ -1,12 +1,9 @@
-import { getConnectivity, HookNames } from '@kubesense/kubesense-browser-core'
-import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+import { getConnectivity } from '@kubesense/kubesense-browser-core'
+import type { AssembleHook, DefaultRumEventAttributes } from '../hooks'
 
-export function startConnectivityContext(hooks: Hooks) {
-  hooks.register(
-    HookNames.Assemble,
-    ({ eventType }): DefaultRumEventAttributes => ({
-      type: eventType,
-      connectivity: getConnectivity(),
-    })
-  )
+export function startConnectivityContext(assembleHook: AssembleHook) {
+  assembleHook.register(({ eventType }): DefaultRumEventAttributes => ({
+    type: eventType,
+    connectivity: getConnectivity(),
+  }))
 }

package/src/domain/contexts/defaultContext.ts

@@ -1,27 +1,31 @@
-import { canUseEventBridge, currentDrift, HookNames, round, timeStampNow } from '@kubesense/kubesense-browser-core'
+import { clockDrift, timeStampNow } from '@kubesense/kubesense-js-core/time'
+import { canUseEventBridge, round } from '@kubesense/kubesense-browser-core'
 import type { RumConfiguration } from '../configuration'
-import type { DefaultRumEventAttributes, DefaultTelemetryEventAttributes, Hooks } from '../hooks'
+import type { AssembleHook, DefaultRumEventAttributes } from '../hooks'
 
 // replaced at build time
 declare const __BUILD_ENV__SDK_VERSION__: string
 
-export type SdkName = 'rum' | 'rum-slim' | 'rum-synthetics'
+export type SdkName = 'rum' | 'rum-slim' | 'rum-synthetics' | 'rum-salesforce' | 'rum-shopify'
 
-export function startDefaultContext(hooks: Hooks, configuration: RumConfiguration, sdkName: SdkName | undefined) {
-  hooks.register(HookNames.Assemble, ({ eventType }): DefaultRumEventAttributes => {
+export function startDefaultContext(
+  assembleHook: AssembleHook,
+  configuration: RumConfiguration,
+  sdkName: SdkName | undefined
+) {
+  assembleHook.register(({ eventType }): DefaultRumEventAttributes => {
     const source = configuration.source
 
     return {
       type: eventType,
       _kubesense: {
         format_version: 2,
-        drift: currentDrift(),
+        drift: clockDrift(),
         configuration: {
           session_sample_rate: round(configuration.sessionSampleRate, 3),
           session_replay_sample_rate: round(configuration.sessionReplaySampleRate, 3),
           profiling_sample_rate: round(configuration.profilingSampleRate, 3),
           trace_sample_rate: round(configuration.traceSampleRate, 3),
-          beta_encode_cookie_options: configuration.betaEncodeCookieOptions,
         },
         browser_sdk_version: canUseEventBridge() ? __BUILD_ENV__SDK_VERSION__ : undefined,
         sdk_name: sdkName,
@@ -33,11 +37,4 @@ export function startDefaultContext(hooks: Hooks, configuration: RumConfiguratio
       source,
     }
   })
-
-  hooks.register(
-    HookNames.AssembleTelemetry,
-    (): DefaultTelemetryEventAttributes => ({
-      application: { id: configuration.applicationId },
-    })
-  )
 }

package/src/domain/contexts/displayContext.ts

@@ -1,12 +1,11 @@
-import { HookNames, monitor } from '@kubesense/kubesense-browser-core'
-import type { RumConfiguration } from '../configuration'
+import { monitor } from '@kubesense/kubesense-js-core/monitor'
 import type { ViewportDimension } from '../../browser/viewportObservable'
 import { getViewportDimension, initViewportObservable } from '../../browser/viewportObservable'
-import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+import type { AssembleHook, DefaultRumEventAttributes } from '../hooks'
 
 export type DisplayContext = ReturnType<typeof startDisplayContext>
 
-export function startDisplayContext(hooks: Hooks, configuration: RumConfiguration) {
+export function startDisplayContext(assembleHook: AssembleHook) {
   let viewport: ViewportDimension | undefined
   // Use requestAnimationFrame to delay the calculation of viewport dimensions until after SDK initialization, preventing long tasks.
   const animationFrameId = requestAnimationFrame(
@@ -15,17 +14,14 @@ export function startDisplayContext(hooks: Hooks, configuration: RumConfiguratio
     })
   )
 
-  const unsubscribeViewport = initViewportObservable(configuration).subscribe((viewportDimension) => {
+  const unsubscribeViewport = initViewportObservable().subscribe((viewportDimension) => {
     viewport = viewportDimension
   }).unsubscribe
 
-  hooks.register(
-    HookNames.Assemble,
-    ({ eventType }): DefaultRumEventAttributes => ({
-      type: eventType,
-      display: viewport ? { viewport } : undefined,
-    })
-  )
+  assembleHook.register(({ eventType }): DefaultRumEventAttributes => ({
+    type: eventType,
+    display: viewport ? { viewport } : undefined,
+  }))
 
   return {
     stop: () => {

package/src/domain/contexts/featureFlagContext.ts

@@ -1,10 +1,11 @@
 import type { ContextValue, Context } from '@kubesense/kubesense-browser-core'
-import { HookNames, SESSION_TIME_OUT_DELAY, SKIPPED, createValueHistory, isEmptyObject } from '@kubesense/kubesense-browser-core'
+import { SESSION_TIME_OUT_DELAY, createValueHistory, isEmptyObject } from '@kubesense/kubesense-browser-core'
+import { SKIPPED } from '@kubesense/kubesense-js-core/assembly'
 import type { LifeCycle } from '../lifeCycle'
 import { LifeCycleEventType } from '../lifeCycle'
 import { RumEventType } from '../../rawRumEvent.types'
 import type { RumConfiguration } from '../configuration'
-import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+import type { AssembleHook, DefaultRumEventAttributes } from '../hooks'
 
 export const FEATURE_FLAG_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY
 export const BYTES_COMPUTATION_THROTTLING_DELAY = 200
@@ -25,7 +26,7 @@ export interface FeatureFlagContexts {
  */
 export function startFeatureFlagContexts(
   lifeCycle: LifeCycle,
-  hooks: Hooks,
+  assembleHook: AssembleHook,
   configuration: RumConfiguration
 ): FeatureFlagContexts {
   const featureFlagContexts = createValueHistory<FeatureFlagContext>({
@@ -40,7 +41,7 @@ export function startFeatureFlagContexts(
     featureFlagContexts.closeActive(endClocks.relative)
   })
 
-  hooks.register(HookNames.Assemble, ({ startTime, eventType }): DefaultRumEventAttributes | SKIPPED => {
+  assembleHook.register(({ startTime, eventType }): DefaultRumEventAttributes | SKIPPED => {
     const trackFeatureFlagsForEvents = (configuration.trackFeatureFlagsForEvents as RumEventType[]).concat([
       RumEventType.VIEW,
       RumEventType.ERROR,

package/src/domain/contexts/internalContext.ts

@@ -1,6 +1,6 @@
-import type { RelativeTime, RumInternalContext } from '@kubesense/kubesense-browser-core'
+import type { RelativeTime } from '@kubesense/kubesense-js-core/time'
+import type { RumInternalContext, SessionManager } from '@kubesense/kubesense-browser-core'
 import type { ActionContexts } from '../action/actionCollection'
-import type { RumSessionManager } from '../rumSessionManager'
 import type { ViewHistory } from './viewHistory'
 import type { UrlContexts } from './urlContexts'
 
@@ -10,7 +10,7 @@ import type { UrlContexts } from './urlContexts'
  */
 export function startInternalContext(
   applicationId: string,
-  sessionManager: RumSessionManager,
+  sessionManager: SessionManager,
   viewHistory: ViewHistory,
   actionContexts: ActionContexts,
   urlContexts: UrlContexts

package/src/domain/contexts/pageStateHistory.ts

@@ -1,20 +1,16 @@
-import type { Duration, RelativeTime } from '@kubesense/kubesense-browser-core'
+import { elapsed, toServerDuration, relativeNow } from '@kubesense/kubesense-js-core/time'
+import type { Duration, RelativeTime } from '@kubesense/kubesense-js-core/time'
+import { SKIPPED } from '@kubesense/kubesense-js-core/assembly'
 import {
-  SKIPPED,
-  elapsed,
   createValueHistory,
   SESSION_TIME_OUT_DELAY,
-  toServerDuration,
   addEventListeners,
-  relativeNow,
   DOM_EVENT,
-  HookNames,
 } from '@kubesense/kubesense-browser-core'
-import type { RumConfiguration } from '../configuration'
 import { supportPerformanceTimingEvent, RumPerformanceEntryType } from '../../browser/performanceObservable'
 import type { PageStateServerEntry } from '../../rawRumEvent.types'
 import { RumEventType } from '../../rawRumEvent.types'
-import type { DefaultRumEventAttributes, Hooks } from '../hooks'
+import type { AssembleHook, DefaultRumEventAttributes } from '../hooks'
 
 // Arbitrary value to cap number of element for memory consumption in the browser
 export const MAX_PAGE_STATE_ENTRIES = 4000
@@ -43,8 +39,7 @@ export interface PageStateHistory {
 }
 
 export function startPageStateHistory(
-  hooks: Hooks,
-  configuration: RumConfiguration,
+  assembleHook: AssembleHook,
   maxPageStateEntriesSelectable = MAX_PAGE_STATE_ENTRIES_SELECTABLE
 ): PageStateHistory {
   const pageStateEntryHistory = createValueHistory<PageStateEntry>({
@@ -55,9 +50,7 @@ export function startPageStateHistory(
   let currentPageState: PageState
 
   if (supportPerformanceTimingEvent(RumPerformanceEntryType.VISIBILITY_STATE)) {
-    const visibilityEntries = performance.getEntriesByType(
-      RumPerformanceEntryType.VISIBILITY_STATE
-    ) as PerformanceEntry[]
+    const visibilityEntries = performance.getEntriesByType(RumPerformanceEntryType.VISIBILITY_STATE)
 
     visibilityEntries.forEach((entry) => {
       const state = entry.name === 'hidden' ? PageState.HIDDEN : PageState.ACTIVE
@@ -68,7 +61,6 @@ export function startPageStateHistory(
   addPageState(getPageState(), relativeNow())
 
   const { stop: stopEventListeners } = addEventListeners(
-    configuration,
     window,
     [
       DOM_EVENT.PAGE_SHOW,
@@ -99,27 +91,24 @@ export function startPageStateHistory(
     return pageStateEntryHistory.findAll(startTime, duration).some((pageState) => pageState.state === state)
   }
 
-  hooks.register(
-    HookNames.Assemble,
-    ({ startTime, duration = 0 as Duration, eventType }): DefaultRumEventAttributes | SKIPPED => {
-      if (eventType === RumEventType.VIEW) {
-        const pageStates = pageStateEntryHistory.findAll(startTime, duration)
-        return {
-          type: eventType,
-          _kubesense: { page_states: processPageStates(pageStates, startTime, maxPageStateEntriesSelectable) },
-        }
+  assembleHook.register(({ startTime, duration = 0 as Duration, eventType }): DefaultRumEventAttributes | SKIPPED => {
+    if (eventType === RumEventType.VIEW) {
+      const pageStates = pageStateEntryHistory.findAll(startTime, duration)
+      return {
+        type: eventType,
+        _kubesense: { page_states: processPageStates(pageStates, startTime, maxPageStateEntriesSelectable) },
       }
+    }
 
-      if (eventType === RumEventType.ACTION || eventType === RumEventType.ERROR) {
-        return {
-          type: eventType,
-          view: { in_foreground: wasInPageStateDuringPeriod(PageState.ACTIVE, startTime, 0 as Duration) },
-        }
+    if (eventType === RumEventType.ACTION || eventType === RumEventType.ERROR) {
+      return {
+        type: eventType,
+        view: { in_foreground: wasInPageStateDuringPeriod(PageState.ACTIVE, startTime, 0 as Duration) },
       }
-
-      return SKIPPED
     }
-  )
+
+    return SKIPPED
+  })
 
   return {
     wasInPageStateDuringPeriod,

package/src/domain/contexts/sessionContext.ts

@@ -1,18 +1,26 @@
-import { DISCARDED, HookNames, SKIPPED } from '@kubesense/kubesense-browser-core'
-import { SessionReplayState, SessionType } from '../rumSessionManager'
-import type { RumSessionManager } from '../rumSessionManager'
+import type { SessionManager } from '@kubesense/kubesense-browser-core'
+import { DISCARDED } from '@kubesense/kubesense-js-core/assembly'
+import type { RumConfiguration } from '../configuration'
+import { SessionReplayState, computeSessionReplayState } from '../sessionReplayState'
 import { RumEventType } from '../../rawRumEvent.types'
 import type { RecorderApi } from '../../boot/rumPublicApi'
-import type { DefaultRumEventAttributes, DefaultTelemetryEventAttributes, Hooks } from '../hooks'
+import type { AssembleHook, DefaultRumEventAttributes } from '../hooks'
 import type { ViewHistory } from './viewHistory'
 
+export const enum SessionType {
+  SYNTHETICS = 'synthetics',
+  USER = 'user',
+  CI_TEST = 'ci_test',
+}
+
 export function startSessionContext(
-  hooks: Hooks,
-  sessionManager: RumSessionManager,
+  assembleHook: AssembleHook,
+  configuration: RumConfiguration,
+  sessionManager: SessionManager,
   recorderApi: RecorderApi,
   viewHistory: ViewHistory
 ) {
-  hooks.register(HookNames.Assemble, ({ eventType, startTime }): DefaultRumEventAttributes | DISCARDED => {
+  assembleHook.register(({ eventType, startTime }): DefaultRumEventAttributes | DISCARDED => {
     const session = sessionManager.findTrackedSession(startTime)
     const view = viewHistory.findView(startTime)
 
@@ -25,7 +33,7 @@ export function startSessionContext(
     let isActive
     if (eventType === RumEventType.VIEW) {
       hasReplay = recorderApi.getReplayStats(view.id) ? true : undefined
-      sampledForReplay = session.sessionReplay === SessionReplayState.SAMPLED
+      sampledForReplay = computeSessionReplayState(session, configuration) === SessionReplayState.SAMPLED
       isActive = view.sessionIsActive ? undefined : false
     } else {
       hasReplay = recorderApi.isRecording() ? true : undefined
@@ -42,18 +50,4 @@ export function startSessionContext(
       },
     }
   })
-
-  hooks.register(HookNames.AssembleTelemetry, ({ startTime }): DefaultTelemetryEventAttributes | SKIPPED => {
-    const session = sessionManager.findTrackedSession(startTime)
-
-    if (!session) {
-      return SKIPPED
-    }
-
-    return {
-      session: {
-        id: session.id,
-      },
-    }
-  })
 }