@openobserve/browser-core 0.3.4 → 0.4.0-beta.1

package/src/domain/session/sessionManager.ts

@@ -1,139 +1,333 @@
+import {
+  ONE_HOUR,
+  ONE_MINUTE,
+  ONE_SECOND,
+  dateNow,
+  elapsed,
+  timeStampNow,
+  clocksOrigin,
+  relativeNow,
+} from '@openobserve/js-core/time'
+import type { TimeStamp, RelativeTime } from '@openobserve/js-core/time'
 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 { isWorkerEnvironment } from '../../tools/globalObject'
+import { display } from '../../tools/display'
+import { isSampled } from '../sampler'
+import { TelemetryMetrics, addTelemetryMetrics } from '../telemetry'
 import { monitorError } from '../../tools/monitor'
-import { SESSION_NOT_TRACKED, SESSION_TIME_OUT_DELAY, SessionPersistence } from './sessionConstants'
-import { startSessionStore } from './sessionStore'
+import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
 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: (
-    startTime?: RelativeTime,
-    options?: { returnInactive: boolean }
-  ) => SessionContext<TrackingType> | undefined
+import {
+  expandOnly,
+  expandOrRenew,
+  getCreatedDate,
+  getExpireDate,
+  getExpiredSessionState,
+  initializeSession,
+  isSessionInExpiredState,
+} from './sessionState'
+import { getSessionStoreStrategy, selectSessionStoreStrategyType } from './sessionStore'
+
+export interface SessionManager {
+  findSession: (startTime?: RelativeTime, options?: { returnInactive: boolean }) => SessionContext | undefined
+  findTrackedSession: (startTime?: RelativeTime, options?: { returnInactive: boolean }) => 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
+
+// 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>>({
+  const strategy = mockable(getSessionStoreStrategy)(sessionStoreStrategyType, configuration)
+
+  const sessionContextHistory = createValueHistory<SessionContext>({
     expireDelay: SESSION_CONTEXT_TIMEOUT_DELAY,
   })
   stopCallbacks.push(() => sessionContextHistory.stop())
 
-  sessionStore.renewObservable.subscribe(() => {
-    sessionContextHistory.add(buildSessionContext(), relativeNow())
-    renewObservable.notify()
+  let sessionExpired = false
+
+  const { throttled: throttledExpandOrRenew, cancel: cancelExpandOrRenew } = throttle(() => {
+    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)) {
+              if (!trackingConsentState.isGranted()) {
+                delete state.anonymousId
+              }
+
+              return getExpiredSessionState(state, configuration)
+            }
+
+            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, options) => {
+        const session = sessionContextHistory.find(startTime, options)
+
+        if (!session || session.id === 'invalid' || !isSampled(session.id, configuration.sessionSampleRate)) {
+          return
+        }
+
+        if (dateNow() - session.createdAt > TRACKED_SESSION_MAX_AGE) {
+          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 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(relativeNow())
+    }
+
+    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
+    }
+  }
 
-  function buildSessionContext() {
-    const session = sessionStore.getSession()
+  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) => {
+        if (!trackingConsentState.isGranted()) {
+          delete state.anonymousId
+        }
+        return getExpiredSessionState(state, configuration)
+      }, 'expire')
+      .catch(monitorError)
+  }
 
-    if (!session) {
-      reportUnexpectedSessionState(configuration).catch(() => void 0) // Ignore errors
+  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,
     }
   }
+}
 
-  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 +335,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 +345,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 +361,7 @@ function trackVisibility(configuration: Configuration, expandSession: () => void
   })
 }
 
-function trackResume(configuration: Configuration, cb: () => void) {
-  const { stop } = addEventListener(configuration, window, DOM_EVENT.RESUME, cb, { capture: true })
+function trackResume(cb: () => void) {
+  const { stop } = addEventListener(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)
-  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: 2025-12-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,
-  }
-}

package/src/domain/session/sessionState.ts

@@ -1,6 +1,8 @@
+import { dateNow } from '@openobserve/js-core/time'
+import type { TimeStamp } from '@openobserve/js-core/time'
 import { isEmptyObject } from '../../tools/utils/objectUtils'
 import { objectEntries } from '../../tools/utils/polyfills'
-import { dateNow } from '../../tools/utils/timeUtils'
+import { generateUUID } from '../../tools/utils/stringUtils'
 import type { Configuration } from '../configuration'
 import { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from './sessionConstants'
 import { isValidSessionString, SESSION_ENTRY_REGEXP, SESSION_ENTRY_SEPARATOR } from './sessionStateValidation'
@@ -11,12 +13,25 @@ export interface SessionState {
   created?: string
   expire?: string
   isExpired?: typeof EXPIRED
+  anonymousId?: string
 
   [key: string]: string | undefined
 }
 
+export function getCreatedDate(state: SessionState): TimeStamp | undefined {
+  return state.created ? (Number(state.created) as TimeStamp) : undefined
+}
+
+export function getExpireDate(state: SessionState): TimeStamp | undefined {
+  const expireDate = state.expire && (Number(state.expire) as TimeStamp)
+  const createdDate = getCreatedDate(state)
+  if (expireDate && createdDate) {
+    return Math.min(expireDate, createdDate + SESSION_TIME_OUT_DELAY) as TimeStamp
+  }
+}
+
 export function getExpiredSessionState(
-  previousSessionState: SessionState | undefined,
+  previousSessionState: { anonymousId?: string } | undefined,
   configuration: Configuration
 ): SessionState {
   const expiredSessionState: SessionState = {
@@ -25,6 +40,7 @@ export function getExpiredSessionState(
   if (configuration.trackAnonymousUser && previousSessionState?.anonymousId) {
     expiredSessionState.anonymousId = previousSessionState?.anonymousId
   }
+
   return expiredSessionState
 }
 
@@ -42,12 +58,8 @@ export function isSessionInExpiredState(session: SessionState) {
 
 // An active session is a session in either `Tracked` or `NotTracked` state
 function isActiveSession(sessionState: SessionState) {
-  // created and expire can be undefined for versions which was not storing them
-  // these checks could be removed when older versions will not be available/live anymore
-  return (
-    (sessionState.created === undefined || dateNow() - Number(sessionState.created) < SESSION_TIME_OUT_DELAY) &&
-    (sessionState.expire === undefined || dateNow() < Number(sessionState.expire))
-  )
+  const expireDate = getExpireDate(sessionState)
+  return expireDate ? dateNow() < expireDate : false
 }
 
 export function expandSessionState(session: SessionState) {
@@ -81,3 +93,47 @@ export function toSessionState(sessionString: string | undefined | null) {
   }
   return session
 }
+
+export function initializeSession(state: SessionState, configuration: Configuration): SessionState {
+  if (isSessionInNotStartedState(state)) {
+    if (configuration.trackAnonymousUser) {
+      state.anonymousId = generateUUID()
+    }
+    return getExpiredSessionState(state, configuration)
+  }
+  return state
+}
+
+export function expandOrRenew(state: SessionState, configuration: Configuration): SessionState {
+  // prevent renewing if state is altered by a 3rd party (e.g. adblocker deleting the cookie)
+  if (isSessionInNotStartedState(state)) {
+    return state
+  }
+
+  let newState = state
+
+  if (isSessionInExpiredState(state)) {
+    newState = getExpiredSessionState(state, configuration)
+  }
+
+  if (!newState.id) {
+    newState.id = generateUUID()
+    newState.created = String(dateNow())
+  }
+  if (configuration.trackAnonymousUser && !newState.anonymousId) {
+    newState.anonymousId = generateUUID()
+  }
+
+  delete newState.isExpired
+  expandSessionState(newState)
+
+  return newState
+}
+
+export function expandOnly(state: SessionState): SessionState {
+  if (isSessionInExpiredState(state) || isSessionInNotStartedState(state) || !state.id) {
+    return state
+  }
+  expandSessionState(state)
+  return state
+}