@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/src/domain/session/sessionManager.ts

@@ -1,139 +1,397 @@
+import {
+  ONE_HOUR,
+  ONE_MINUTE,
+  ONE_SECOND,
+  dateNow,
+  elapsed,
+  timeStampNow,
+  clocksOrigin,
+  relativeNow,
+  clocksNow,
+  timeStampToClocks,
+  toTimeStamp,
+} from '@kubesense/kubesense-js-core/time'
+import type { ClocksState, TimeStamp, RelativeTime } from '@kubesense/kubesense-js-core/time'
+import { isWorkerEnvironment } from '@kubesense/kubesense-js-core/util'
+import { monitorError } from '@kubesense/kubesense-js-core/monitor'
 import { Observable } from '../../tools/observable'
-import type { Context } from '../../tools/serialisation/context'
 import { createValueHistory } from '../../tools/valueHistory'
-import type { RelativeTime } from '../../tools/utils/timeUtils'
-import { clocksOrigin, dateNow, ONE_MINUTE, relativeNow } from '../../tools/utils/timeUtils'
 import { addEventListener, addEventListeners, DOM_EVENT } from '../../browser/addEventListener'
-import { clearInterval, setInterval } from '../../tools/timer'
+import { clearInterval, clearTimeout, setInterval, setTimeout } from '../../tools/timer'
+import { mockable } from '../../tools/mockable'
+import { noop, throttle } from '../../tools/utils/functionUtils'
+import { generateUUID } from '../../tools/utils/stringUtils'
 import type { Configuration } from '../configuration'
 import type { TrackingConsentState } from '../trackingConsent'
-import { addTelemetryDebug } from '../telemetry'
-import { isSyntheticsTest } from '../synthetics/syntheticsWorkerValues'
-import type { CookieStore } from '../../browser/browser.types'
-import { getCurrentSite } from '../../browser/cookie'
-import { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures'
-import { findLast } from '../../tools/utils/polyfills'
-import { monitorError } from '../../tools/monitor'
-import { SESSION_NOT_TRACKED, SESSION_TIME_OUT_DELAY, SessionPersistence } from './sessionConstants'
-import { startSessionStore } from './sessionStore'
+import { display } from '../../tools/display'
+import { isSampled } from '../sampler'
+import { TelemetryMetrics, addTelemetryMetrics } from '../telemetry'
 import type { SessionState } from './sessionState'
-import { toSessionState } from './sessionState'
-import { retrieveSessionCookie } from './storeStrategies/sessionInCookie'
-import { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy'
-import { retrieveSessionFromLocalStorage } from './storeStrategies/sessionInLocalStorage'
-
-export interface SessionManager<TrackingType extends string> {
-  findSession: (
+import {
+  expandOnly,
+  expandOrRenew,
+  getCreatedDate,
+  getExpireDate,
+  getExpiredSessionState,
+  initializeSession,
+  isSessionInExpiredState,
+} from './sessionState'
+import { getSessionStoreStrategy, selectSessionStoreStrategyType } from './sessionStore'
+import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
+
+export interface SessionManager {
+  findSession: (startTime?: RelativeTime, options?: { returnInactive: boolean }) => SessionContext | undefined
+  findTrackedSession: (
     startTime?: RelativeTime,
-    options?: { returnInactive: boolean }
-  ) => SessionContext<TrackingType> | undefined
+    options?: { returnInactive?: boolean; maxAge?: number }
+  ) => SessionContext | undefined
   renewObservable: Observable<void>
   expireObservable: Observable<void>
-  sessionStateUpdateObservable: Observable<{ previousState: SessionState; newState: SessionState }>
   expire: () => void
   updateSessionState: (state: Partial<SessionState>) => void
 }
 
-export interface SessionContext<TrackingType extends string> extends Context {
+export interface SessionContext {
   id: string
-  trackingType: TrackingType
-  isReplayForced: boolean
-  anonymousId: string | undefined
+  anonymousId?: string | undefined
+  isReplayForced?: boolean
+  createdAt: TimeStamp
 }
 
 export const VISIBILITY_CHECK_DELAY = ONE_MINUTE
-const SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY
+
+// Arbitrary value to cap memory consumption for very long-lived pages with many session
+// renewals. Entries are *not* evicted based on elapsed time: an idle session's sole (closed)
+// entry must survive indefinitely so browser-logs can keep sending logs after it expires, with
+// or without a session attached (see browser-logs/src/domain/contexts/sessionContext.ts).
+export const MAX_SESSION_CONTEXT_HISTORY_ENTRIES = 1000
+
+// Maximum duration for which we can send data related to a session.
+//
+// The backend behavior depends on how old the session is when it receives an event:
+// - Session started < 4h ago: the backend updates the session normally.
+// - Session started between 4h and 24h ago: the backend ignores the event (safe).
+// - Session started > 24h ago: the backend recreates a session with that id (problematic).
+//
+// We choose 12h as a threshold — safely between 4h and 24h — to avoid both recreating
+// sessions and discarding too many legitimate late events.
+export const TRACKED_SESSION_MAX_AGE = ONE_HOUR * 12
 let stopCallbacks: Array<() => void> = []
 
-export function startSessionManager<TrackingType extends string>(
+export async function startSessionManager(
   configuration: Configuration,
-  productKey: string,
-  computeTrackingType: (rawTrackingType?: string) => TrackingType,
   trackingConsentState: TrackingConsentState
-): SessionManager<TrackingType> {
+): Promise<SessionManager | undefined> {
+  const startTime = relativeNow()
   const renewObservable = new Observable<void>()
   const expireObservable = new Observable<void>()
 
-  // TODO - Improve configuration type and remove assertion
-  const sessionStore = startSessionStore(
-    configuration.sessionStoreStrategyType!,
-    configuration,
-    productKey,
-    computeTrackingType
-  )
-  stopCallbacks.push(() => sessionStore.stop())
+  const sessionStoreStrategyType = await mockable(selectSessionStoreStrategyType)(configuration)
+  if (!sessionStoreStrategyType) {
+    display.warn('No storage available for session. We will not send any data.')
+    return
+  }
 
-  const sessionContextHistory = createValueHistory<SessionContext<TrackingType>>({
-    expireDelay: SESSION_CONTEXT_TIMEOUT_DELAY,
+  const strategy = mockable(getSessionStoreStrategy)(sessionStoreStrategyType, configuration)
+
+  const sessionContextHistory = createValueHistory<SessionContext>({
+    maxEntries: MAX_SESSION_CONTEXT_HISTORY_ENTRIES,
   })
   stopCallbacks.push(() => sessionContextHistory.stop())
 
-  sessionStore.renewObservable.subscribe(() => {
-    sessionContextHistory.add(buildSessionContext(), relativeNow())
-    renewObservable.notify()
+  let sessionExpired = false
+
+  const { throttled: throttledExpandOrRenew, cancel: cancelExpandOrRenew } = throttle(() => {
+    expireTimedOutSession()
+    sessionExpired = false
+    strategy
+      .setSessionState((state) => expandOrRenew(state, configuration), 'expandOrRenewOnActivity')
+      .catch(monitorError)
+  }, ONE_SECOND)
+  stopCallbacks.push(cancelExpandOrRenew)
+
+  let expirationTimeoutId: ReturnType<typeof setTimeout> | undefined
+  stopCallbacks.push(() => clearTimeout(expirationTimeoutId))
+
+  let stopped = false
+  stopCallbacks.push(() => {
+    stopped = true
   })
-  sessionStore.expireObservable.subscribe(() => {
-    expireObservable.notify()
-    sessionContextHistory.closeActive(relativeNow())
+
+  let initialState = await resolveInitialState().catch((error) =>
+    monitorError(new Error(`Error while resolving initial session state: ${error}`))
+  )
+  if (!initialState || stopped) {
+    return
+  }
+
+  // Consent is always granted when the session manager is started, but it may
+  // be revoked during the async initialization (e.g., while waiting for cookie lock).
+  // Mirror setupSessionTracking's revoke/grant handler until the manager is installed:
+  // expire the session in storage, wait for the next grant, then re-resolve.
+  while (!trackingConsentState.isGranted()) {
+    expire()
+    await new Promise<void>((resolve) => trackingConsentState.onGrantedOnce(resolve))
+    if (stopped) {
+      return
+    }
+    initialState = await resolveInitialState().catch(monitorError)
+    if (!initialState || stopped) {
+      return
+    }
+  }
+
+  sessionContextHistory.add(buildSessionContext(initialState), clocksOrigin().relative)
+  scheduleExpirationTimeout(initialState)
+  subscribeToSessionChanges()
+  setupSessionTracking()
+
+  // monitor-until: 2026-10-15
+  addTelemetryMetrics(TelemetryMetrics.SESSION_MANAGER_INIT_METRICS_TELEMETRY_NAME, {
+    metrics: { duration: elapsed(startTime, relativeNow()) },
   })
 
-  // We expand/renew session unconditionally as tracking consent is always granted when the session
-  // manager is started.
-  sessionStore.expandOrRenewSession()
-  sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative)
-  if (isExperimentalFeatureEnabled(ExperimentalFeature.SHORT_SESSION_INVESTIGATION)) {
-    const session = sessionStore.getSession()
-    if (session) {
-      detectSessionIdChange(configuration, session)
+  return buildSessionManager()
+
+  async function resolveInitialState() {
+    let state: SessionState = {}
+    await strategy.setSessionState((currentState) => {
+      const initialState = initializeSession(currentState, configuration)
+      state = expandOrRenew(initialState, configuration)
+      return state
+    }, 'initialize')
+    return state
+  }
+
+  function subscribeToSessionChanges() {
+    const subscription = strategy.sessionObservable.subscribe((sessionState) => {
+      scheduleExpirationTimeout(sessionState)
+      handleStateChange(sessionState)
+    })
+    stopCallbacks.push(() => subscription.unsubscribe())
+  }
+
+  function scheduleExpirationTimeout(state: SessionState) {
+    clearTimeout(expirationTimeoutId)
+    const expireDate = getExpireDate(state)
+    if (expireDate) {
+      const delay = expireDate - dateNow()
+      expirationTimeoutId = setTimeout(() => {
+        strategy
+          .setSessionState((state) => {
+            if (isSessionInExpiredState(state)) {
+              const nextState = getExpiredSessionState(state, configuration)
+              if (!trackingConsentState.isGranted()) {
+                delete nextState.anonymousId
+              }
+
+              return nextState
+            }
+
+            return state
+          }, 'expireOnTimeout')
+          .catch(monitorError)
+      }, delay)
     }
   }
 
-  trackingConsentState.observable.subscribe(() => {
-    if (trackingConsentState.isGranted()) {
-      sessionStore.expandOrRenewSession()
-    } else {
-      sessionStore.expire(false)
+  function setupSessionTracking() {
+    trackingConsentState.observable.subscribe(() => {
+      if (trackingConsentState.isGranted()) {
+        sessionExpired = false
+        strategy
+          .setSessionState((state) => expandOrRenew(state, configuration), 'expandOrRenewOnConsent')
+          .catch(monitorError)
+      } else {
+        expire()
+      }
+    })
+
+    if (!isWorkerEnvironment) {
+      trackActivity(() => {
+        if (trackingConsentState.isGranted()) {
+          throttledExpandOrRenew()
+        }
+      })
+      trackVisibility(() => {
+        if (!sessionExpired) {
+          strategy.setSessionState((state) => expandOnly(state), 'expandOnVisibility').catch(monitorError)
+        }
+      })
+      trackResume(() => {
+        strategy
+          .setSessionState((state) => initializeSession(state, configuration), 'initializeOnResume')
+          .catch(monitorError)
+      })
     }
-  })
+  }
 
-  trackActivity(configuration, () => {
-    if (trackingConsentState.isGranted()) {
-      sessionStore.expandOrRenewSession()
+  function buildSessionManager(): SessionManager {
+    return {
+      findSession: (startTime, options) => sessionContextHistory.find(startTime, options),
+      findTrackedSession: (startTime, { returnInactive = false, maxAge = TRACKED_SESSION_MAX_AGE } = {}) => {
+        const session = sessionContextHistory.find(startTime, { returnInactive })
+
+        if (!session || session.id === 'invalid' || !isSampled(session.id, configuration.sessionSampleRate)) {
+          return
+        }
+
+        if (dateNow() - session.createdAt > maxAge) {
+          return
+        }
+
+        // A session lasts SESSION_TIME_OUT_DELAY at most, and nothing that happens after that
+        // belongs to it. The expiry timeout enforces it, but a hidden tab runs that timeout late:
+        // browsers throttle background timers, and Edge and Chrome freeze a sleeping tab outright.
+        // Until it runs, the history still holds the session as active, so a woken tab kept
+        // sending view updates under an id that had expired 20 minutes earlier, and a route
+        // change started a new view in it. `returnInactive` callers ask for a past session on
+        // purpose (logs keep sending after expiry), so they are left as they are.
+        if (!returnInactive && eventTimeStamp(startTime) >= getSessionTimeoutDate(session)) {
+          return
+        }
+
+        return session
+      },
+      renewObservable,
+      expireObservable,
+      expire,
+      updateSessionState: (partialState) => {
+        strategy.setSessionState((state) => ({ ...state, ...partialState }), 'updateState').catch(monitorError)
+      },
     }
-  })
-  trackVisibility(configuration, () => sessionStore.expandSession())
-  trackResume(configuration, () => sessionStore.restartSession())
+  }
 
-  function buildSessionContext() {
-    const session = sessionStore.getSession()
+  function handleStateChange(newState: SessionState) {
+    const previousSession = sessionContextHistory.find()
+    const hadSession = previousSession?.id !== undefined
+    const hasSession = newState.id !== undefined
+    const sessionIdChanged = hadSession && hasSession && previousSession.id !== newState.id
+
+    if (hadSession && (!hasSession || sessionIdChanged)) {
+      // Session expired or replaced
+      sessionExpired = true
+      expireObservable.notify()
+      sessionContextHistory.closeActive(getSessionEndClocks(previousSession).relative)
+    }
 
-    if (!session) {
-      reportUnexpectedSessionState(configuration).catch(() => void 0) // Ignore errors
+    if (hasSession && (!hadSession || sessionIdChanged)) {
+      if (sessionExpired) {
+        // Don't adopt another tab's session — this tab needs its own user interaction to renew
+        return
+      }
+      // New session appeared
+      sessionContextHistory.add(buildSessionContext(newState), relativeNow())
+      renewObservable.notify()
+    } else if (hadSession && hasSession && !sessionIdChanged) {
+      // Same session,
+      // Mutate the session context in the history for replay forced changes
+
+      previousSession.isReplayForced = !!newState.forcedReplay
+    }
+  }
 
+  // What the expiry timeout does in memory, for a tab that did not run it on time (see
+  // findTrackedSession). Called before renewing on activity, so the old session is closed by the
+  // time the renewal lands: otherwise the renewed session reads as another tab replacing a live one,
+  // which is not adopted, and the tab has no session until a second interaction.
+  function expireTimedOutSession() {
+    const session = sessionContextHistory.find()
+    if (session && timeStampNow() >= getSessionTimeoutDate(session)) {
+      handleStateChange(getExpiredSessionState(session, configuration))
+    }
+  }
+
+  function expire() {
+    cancelExpandOrRenew()
+    // Update in-memory state synchronously so events stop being collected immediately
+    const expiredState = getExpiredSessionState(sessionContextHistory.find(), configuration)
+    if (!trackingConsentState.isGranted()) {
+      delete expiredState.anonymousId
+    }
+    handleStateChange(expiredState)
+    // Persist to storage asynchronously
+    strategy
+      .setSessionState((state) => {
+        const nextState = getExpiredSessionState(state, configuration)
+        if (!trackingConsentState.isGranted()) {
+          // The anonymous id is regenerated for the next session, so it has to be dropped from the
+          // result rather than from the previous state.
+          delete nextState.anonymousId
+        }
+        return nextState
+      }, 'expire')
+      .catch(monitorError)
+  }
+
+  function buildSessionContext(sessionState: SessionState): SessionContext {
+    const createdAt = getCreatedDate(sessionState) ?? timeStampNow()
+
+    if (!sessionState.id) {
       return {
         id: 'invalid',
-        trackingType: SESSION_NOT_TRACKED as TrackingType,
         isReplayForced: false,
         anonymousId: undefined,
+        createdAt,
       }
     }
 
     return {
-      id: session.id!,
-      trackingType: session[productKey] as TrackingType,
-      isReplayForced: !!session.forcedReplay,
-      anonymousId: session.anonymousId,
+      id: sessionState.id,
+      isReplayForced: !!sessionState.forcedReplay,
+      anonymousId: sessionState.anonymousId,
+      createdAt,
     }
   }
+}
+
+/**
+ * When a session times out: SESSION_TIME_OUT_DELAY after it was created, however much later the tab
+ * finds out.
+ */
+function getSessionTimeoutDate(session: SessionContext): TimeStamp {
+  return (session.createdAt + SESSION_TIME_OUT_DELAY) as TimeStamp
+}
+
+/**
+ * When a session that is expiring now ended: now, or its timeout if that came first. Views and
+ * the session history are closed at this time, so a tab that learns of a timeout late does not
+ * stretch the session past it.
+ */
+export function getSessionEndClocks(session: SessionContext | undefined): ClocksState {
+  const now = clocksNow()
+  if (!session) {
+    return now
+  }
+  const timeoutDate = getSessionTimeoutDate(session)
+  return timeoutDate < now.timeStamp ? timeStampToClocks(timeoutDate) : now
+}
+
+function eventTimeStamp(startTime: RelativeTime | undefined): TimeStamp {
+  return startTime === undefined ? timeStampNow() : toTimeStamp(startTime)
+}
 
-  return {
-    findSession: (startTime, options) => sessionContextHistory.find(startTime, options),
-    renewObservable,
-    expireObservable,
-    sessionStateUpdateObservable: sessionStore.sessionStateUpdateObservable,
-    expire: sessionStore.expire,
-    updateSessionState: sessionStore.updateSessionState,
+export function startSessionManagerStub(): Promise<SessionManager> {
+  const stubSessionId = generateUUID()
+  let sessionContext: SessionContext = {
+    id: stubSessionId,
+    isReplayForced: false,
+    anonymousId: undefined,
+    createdAt: timeStampNow(),
   }
+  return Promise.resolve({
+    findSession: () => sessionContext,
+    findTrackedSession: () => sessionContext,
+    renewObservable: new Observable(),
+    expireObservable: new Observable(),
+    expire: noop,
+    updateSessionState: (state) => {
+      sessionContext = {
+        ...sessionContext,
+        ...state,
+      }
+    },
+  })
 }
 
 export function stopSessionManager() {
@@ -141,9 +399,8 @@ export function stopSessionManager() {
   stopCallbacks = []
 }
 
-function trackActivity(configuration: Configuration, expandOrRenewSession: () => void) {
+function trackActivity(expandOrRenewSession: () => void) {
   const { stop } = addEventListeners(
-    configuration,
     window,
     [DOM_EVENT.CLICK, DOM_EVENT.TOUCH_START, DOM_EVENT.KEY_DOWN, DOM_EVENT.SCROLL],
     expandOrRenewSession,
@@ -152,14 +409,14 @@ function trackActivity(configuration: Configuration, expandOrRenewSession: () =>
   stopCallbacks.push(stop)
 }
 
-function trackVisibility(configuration: Configuration, expandSession: () => void) {
+function trackVisibility(expandSession: () => void) {
   const expandSessionWhenVisible = () => {
     if (document.visibilityState === 'visible') {
       expandSession()
     }
   }
 
-  const { stop } = addEventListener(configuration, document, DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible)
+  const { stop } = addEventListener(document, DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible)
   stopCallbacks.push(stop)
 
   const visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY)
@@ -168,95 +425,7 @@ function trackVisibility(configuration: Configuration, expandSession: () => void
   })
 }
 
-function trackResume(configuration: Configuration, cb: () => void) {
-  const { stop } = addEventListener(configuration, window, DOM_EVENT.RESUME, cb, { capture: true })
-  stopCallbacks.push(stop)
-}
-
-async function reportUnexpectedSessionState(configuration: Configuration) {
-  const sessionStoreStrategyType = configuration.sessionStoreStrategyType
-  if (!sessionStoreStrategyType) {
-    return
-  }
-
-  let rawSession
-  let cookieContext
-
-  if (sessionStoreStrategyType.type === SessionPersistence.COOKIE) {
-    rawSession = retrieveSessionCookie(sessionStoreStrategyType.cookieOptions, configuration)
-
-    cookieContext = {
-      cookie: await getSessionCookies(),
-      currentDomain: `${window.location.protocol}//${window.location.hostname}`,
-    }
-  } else {
-    rawSession = retrieveSessionFromLocalStorage()
-  }
-  // monitor-until: forever, could be handy to troubleshoot issues until session manager rework
-  addTelemetryDebug('Unexpected session state', {
-    sessionStoreStrategyType: sessionStoreStrategyType.type,
-    session: rawSession,
-    isSyntheticsTest: isSyntheticsTest(),
-    createdTimestamp: rawSession?.created,
-    expireTimestamp: rawSession?.expire,
-    ...cookieContext,
-  })
-}
-
-function detectSessionIdChange(configuration: Configuration, initialSessionState: SessionState) {
-  if (!window.cookieStore || !initialSessionState.created) {
-    return
-  }
-
-  const sessionCreatedTime = Number(initialSessionState.created)
-  const sdkInitTime = dateNow()
-
-  const { stop } = addEventListener(configuration, cookieStore as CookieStore, DOM_EVENT.CHANGE, listener)
+function trackResume(cb: () => void) {
+  const { stop } = addEventListener(window, DOM_EVENT.RESUME, cb, { capture: true })
   stopCallbacks.push(stop)
-
-  function listener(event: CookieChangeEvent) {
-    const changed = findLast(event.changed, (change): change is CookieListItem => change.name === SESSION_STORE_KEY)
-    if (!changed) {
-      return
-    }
-
-    const sessionAge = dateNow() - sessionCreatedTime
-    if (sessionAge > 14 * ONE_MINUTE) {
-      // The session might have expired just because it's too old or lack activity
-      stop()
-    } else {
-      const newSessionState = toSessionState(changed.value)
-      if (newSessionState.id && newSessionState.id !== initialSessionState.id) {
-        stop()
-        const time = dateNow() - sdkInitTime
-        getSessionCookies()
-          .then((cookie) => {
-            // monitor-until: 2026-04-01, after RUM-10845 investigation done
-            addTelemetryDebug('Session cookie changed', {
-              time,
-              session_age: sessionAge,
-              old: initialSessionState,
-              new: newSessionState,
-              cookie,
-            })
-          })
-          .catch(monitorError)
-      }
-    }
-  }
-}
-
-async function getSessionCookies(): Promise<{ count: number; domain: string }> {
-  let sessionCookies: string[] | Awaited<ReturnType<CookieStore['getAll']>>
-  if ('cookieStore' in window) {
-    sessionCookies = await (window as { cookieStore: CookieStore }).cookieStore.getAll(SESSION_STORE_KEY)
-  } else {
-    sessionCookies = document.cookie.split(/\s*;\s*/).filter((cookie) => cookie.startsWith(SESSION_STORE_KEY))
-  }
-
-  return {
-    count: sessionCookies.length,
-    domain: getCurrentSite() || 'undefined',
-    ...sessionCookies,
-  }
 }