@openobserve/browser-core 0.2.11 → 0.2.12-beta.4

package/src/domain/session/sessionState.ts

@@ -1,32 +1,66 @@
 import { isEmptyObject } from '../../tools/utils/objectUtils'
 import { objectEntries } from '../../tools/utils/polyfills'
 import { dateNow } from '../../tools/utils/timeUtils'
-import { SESSION_EXPIRATION_DELAY } from './sessionConstants'
-
-const SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/
-const SESSION_ENTRY_SEPARATOR = '&'
+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'
+export const EXPIRED = '1'
 
 export interface SessionState {
   id?: string
   created?: string
   expire?: string
-  lock?: string
+  isExpired?: typeof EXPIRED
 
   [key: string]: string | undefined
 }
 
-export function isSessionInExpiredState(session: SessionState) {
+export function getExpiredSessionState(
+  previousSessionState: SessionState | undefined,
+  configuration: Configuration
+): SessionState {
+  const expiredSessionState: SessionState = {
+    isExpired: EXPIRED,
+  }
+  if (configuration.trackAnonymousUser && previousSessionState?.anonymousId) {
+    expiredSessionState.anonymousId = previousSessionState?.anonymousId
+  }
+  return expiredSessionState
+}
+
+export function isSessionInNotStartedState(session: SessionState) {
   return isEmptyObject(session)
 }
 
+export function isSessionStarted(session: SessionState) {
+  return !isSessionInNotStartedState(session)
+}
+
+export function isSessionInExpiredState(session: SessionState) {
+  return session.isExpired !== undefined || !isActiveSession(session)
+}
+
+// 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))
+  )
+}
+
 export function expandSessionState(session: SessionState) {
   session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY)
 }
 
 export function toSessionString(session: SessionState) {
-  return objectEntries(session)
-    .map(([key, value]) => `${key}=${value as string}`)
-    .join(SESSION_ENTRY_SEPARATOR)
+  return (
+    objectEntries(session)
+      // we use `aid` as a key for anonymousId
+      .map(([key, value]) => (key === 'anonymousId' ? `aid=${value}` : `${key}=${value}`))
+      .join(SESSION_ENTRY_SEPARATOR)
+  )
 }
 
 export function toSessionState(sessionString: string | undefined | null) {
@@ -36,16 +70,14 @@ export function toSessionState(sessionString: string | undefined | null) {
       const matches = SESSION_ENTRY_REGEXP.exec(entry)
       if (matches !== null) {
         const [, key, value] = matches
-        session[key] = value
+        if (key === 'aid') {
+          // we use `aid` as a key for anonymousId
+          session.anonymousId = value
+        } else {
+          session[key] = value
+        }
       }
     })
   }
   return session
 }
-
-function isValidSessionString(sessionString: string | undefined | null): sessionString is string {
-  return (
-    !!sessionString &&
-    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString))
-  )
-}

package/src/domain/session/sessionStateValidation.ts

@@ -0,0 +1,9 @@
+export const SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/
+export const SESSION_ENTRY_SEPARATOR = '&'
+
+export function isValidSessionString(sessionString: string | undefined | null): sessionString is string {
+  return (
+    !!sessionString &&
+    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString))
+  )
+}

package/src/domain/session/sessionStore.ts

@@ -3,22 +3,32 @@ import { Observable } from '../../tools/observable'
 import { ONE_SECOND, dateNow } from '../../tools/utils/timeUtils'
 import { throttle } from '../../tools/utils/functionUtils'
 import { generateUUID } from '../../tools/utils/stringUtils'
-import type { InitConfiguration } from '../configuration'
-import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
+import type { InitConfiguration, Configuration } from '../configuration'
+import { display } from '../../tools/display'
 import { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie'
-import type { SessionStoreStrategyType } from './storeStrategies/sessionStoreStrategy'
+import type { SessionStoreStrategy, SessionStoreStrategyType } from './storeStrategies/sessionStoreStrategy'
 import type { SessionState } from './sessionState'
+import {
+  getExpiredSessionState,
+  isSessionInExpiredState,
+  isSessionInNotStartedState,
+  isSessionStarted,
+} from './sessionState'
 import { initLocalStorageStrategy, selectLocalStorageStrategy } from './storeStrategies/sessionInLocalStorage'
 import { processSessionStoreOperations } from './sessionStoreOperations'
+import { SESSION_NOT_TRACKED, SessionPersistence } from './sessionConstants'
 
 export interface SessionStore {
   expandOrRenewSession: () => void
   expandSession: () => void
   getSession: () => SessionState
+  restartSession: () => void
   renewObservable: Observable<void>
   expireObservable: Observable<void>
-  expire: () => void
+  sessionStateUpdateObservable: Observable<{ previousState: SessionState; newState: SessionState }>
+  expire: (hasConsent?: boolean) => void
   stop: () => void
+  updateSessionState: (state: Partial<SessionState>) => void
 }
 
 /**
@@ -29,17 +39,39 @@ export interface SessionStore {
 export const STORAGE_POLL_DELAY = ONE_SECOND
 
 /**
- * Checks if cookies are available as the preferred storage
- * Else, checks if LocalStorage is allowed and available
+ * Selects the correct session store strategy type based on the configuration and storage
+ * availability.
  */
 export function selectSessionStoreStrategyType(
   initConfiguration: InitConfiguration
 ): SessionStoreStrategyType | undefined {
-  let sessionStoreStrategyType = selectCookieStrategy(initConfiguration)
-  if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {
-    sessionStoreStrategyType = selectLocalStorageStrategy()
+  switch (initConfiguration.sessionPersistence) {
+    case SessionPersistence.COOKIE:
+      return selectCookieStrategy(initConfiguration)
+
+    case SessionPersistence.LOCAL_STORAGE:
+      return selectLocalStorageStrategy()
+
+    case undefined: {
+      let sessionStoreStrategyType = selectCookieStrategy(initConfiguration)
+      if (!sessionStoreStrategyType && initConfiguration.allowFallbackToLocalStorage) {
+        sessionStoreStrategyType = selectLocalStorageStrategy()
+      }
+      return sessionStoreStrategyType
+    }
+
+    default:
+      display.error(`Invalid session persistence '${String(initConfiguration.sessionPersistence)}'`)
   }
-  return sessionStoreStrategyType
+}
+
+export function getSessionStoreStrategy(
+  sessionStoreStrategyType: SessionStoreStrategyType,
+  configuration: Configuration
+) {
+  return sessionStoreStrategyType.type === SessionPersistence.COOKIE
+    ? initCookieStrategy(configuration, sessionStoreStrategyType.cookieOptions)
+    : initLocalStorageStrategy(configuration)
 }
 
 /**
@@ -50,32 +82,34 @@ export function selectSessionStoreStrategyType(
  */
 export function startSessionStore<TrackingType extends string>(
   sessionStoreStrategyType: SessionStoreStrategyType,
+  configuration: Configuration,
   productKey: string,
-  computeSessionState: (rawTrackingType?: string) => { trackingType: TrackingType; isTracked: boolean }
+  computeTrackingType: (rawTrackingType?: string) => TrackingType,
+  sessionStoreStrategy: SessionStoreStrategy = getSessionStoreStrategy(sessionStoreStrategyType, configuration)
 ): SessionStore {
   const renewObservable = new Observable<void>()
   const expireObservable = new Observable<void>()
-
-  const sessionStoreStrategy =
-    sessionStoreStrategyType.type === 'Cookie'
-      ? initCookieStrategy(sessionStoreStrategyType.cookieOptions)
-      : initLocalStorageStrategy()
-  const { clearSession, retrieveSession } = sessionStoreStrategy
+  const sessionStateUpdateObservable = new Observable<{ previousState: SessionState; newState: SessionState }>()
 
   const watchSessionTimeoutId = setInterval(watchSession, STORAGE_POLL_DELAY)
-  let sessionCache: SessionState = retrieveActiveSession()
+  let sessionCache: SessionState
 
-  function expandOrRenewSession() {
-    let isTracked: boolean
+  startSession()
+
+  const { throttled: throttledExpandOrRenewSession, cancel: cancelExpandOrRenewSession } = throttle(() => {
     processSessionStoreOperations(
       {
         process: (sessionState) => {
+          if (isSessionInNotStartedState(sessionState)) {
+            return
+          }
+
           const synchronizedSession = synchronizeSession(sessionState)
-          isTracked = expandOrRenewSessionState(synchronizedSession)
+          expandOrRenewSessionState(synchronizedSession)
           return synchronizedSession
         },
         after: (sessionState) => {
-          if (isTracked && !hasSessionInCache()) {
+          if (isSessionStarted(sessionState) && !hasSessionInCache()) {
             renewSessionInCache(sessionState)
           }
           sessionCache = sessionState
@@ -83,7 +117,7 @@ export function startSessionStore<TrackingType extends string>(
       },
       sessionStoreStrategy
     )
-  }
+  }, STORAGE_POLL_DELAY)
 
   function expandSession() {
     processSessionStoreOperations(
@@ -100,41 +134,70 @@ export function startSessionStore<TrackingType extends string>(
    * - if the session is not active, clear the session store and expire the session cache
    */
   function watchSession() {
-    processSessionStoreOperations(
-      {
-        process: (sessionState) => (!isActiveSession(sessionState) ? {} : undefined),
-        after: synchronizeSession,
-      },
-      sessionStoreStrategy
-    )
+    const sessionState = sessionStoreStrategy.retrieveSession()
+
+    if (isSessionInExpiredState(sessionState)) {
+      processSessionStoreOperations(
+        {
+          process: (sessionState: SessionState) =>
+            isSessionInExpiredState(sessionState) ? getExpiredSessionState(sessionState, configuration) : undefined,
+          after: synchronizeSession,
+        },
+        sessionStoreStrategy
+      )
+    } else {
+      synchronizeSession(sessionState)
+    }
   }
 
   function synchronizeSession(sessionState: SessionState) {
-    if (!isActiveSession(sessionState)) {
-      sessionState = {}
+    if (isSessionInExpiredState(sessionState)) {
+      sessionState = getExpiredSessionState(sessionState, configuration)
     }
     if (hasSessionInCache()) {
       if (isSessionInCacheOutdated(sessionState)) {
         expireSessionInCache()
       } else {
+        sessionStateUpdateObservable.notify({ previousState: sessionCache, newState: sessionState })
         sessionCache = sessionState
       }
     }
     return sessionState
   }
 
+  function startSession() {
+    processSessionStoreOperations(
+      {
+        process: (sessionState) => {
+          if (isSessionInNotStartedState(sessionState)) {
+            sessionState.anonymousId = generateUUID()
+            return getExpiredSessionState(sessionState, configuration)
+          }
+        },
+        after: (sessionState) => {
+          sessionCache = sessionState
+        },
+      },
+      sessionStoreStrategy
+    )
+  }
+
   function expandOrRenewSessionState(sessionState: SessionState) {
-    const { trackingType, isTracked } = computeSessionState(sessionState[productKey])
+    if (isSessionInNotStartedState(sessionState)) {
+      return false
+    }
+
+    const trackingType = computeTrackingType(sessionState[productKey])
     sessionState[productKey] = trackingType
-    if (isTracked && !sessionState.id) {
+    delete sessionState.isExpired
+    if (trackingType !== SESSION_NOT_TRACKED && !sessionState.id) {
       sessionState.id = generateUUID()
       sessionState.created = String(dateNow())
     }
-    return isTracked
   }
 
   function hasSessionInCache() {
-    return sessionCache[productKey] !== undefined
+    return sessionCache?.[productKey] !== undefined
   }
 
   function isSessionInCacheOutdated(sessionState: SessionState) {
@@ -142,7 +205,7 @@ export function startSessionStore<TrackingType extends string>(
   }
 
   function expireSessionInCache() {
-    sessionCache = {}
+    sessionCache = getExpiredSessionState(sessionCache, configuration)
     expireObservable.notify()
   }
 
@@ -151,35 +214,35 @@ export function startSessionStore<TrackingType extends string>(
     renewObservable.notify()
   }
 
-  function retrieveActiveSession(): SessionState {
-    const session = retrieveSession()
-    if (isActiveSession(session)) {
-      return session
-    }
-    return {}
-  }
-
-  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))
+  function updateSessionState(partialSessionState: Partial<SessionState>) {
+    processSessionStoreOperations(
+      {
+        process: (sessionState) => ({ ...sessionState, ...partialSessionState }),
+        after: synchronizeSession,
+      },
+      sessionStoreStrategy
     )
   }
 
   return {
-    expandOrRenewSession: throttle(expandOrRenewSession, STORAGE_POLL_DELAY).throttled,
+    expandOrRenewSession: throttledExpandOrRenewSession,
     expandSession,
     getSession: () => sessionCache,
     renewObservable,
     expireObservable,
-    expire: () => {
-      clearSession()
-      synchronizeSession({})
+    sessionStateUpdateObservable,
+    restartSession: startSession,
+    expire: (hasConsent?: boolean) => {
+      cancelExpandOrRenewSession()
+      if (hasConsent === false && sessionCache) {
+        delete sessionCache.anonymousId
+      }
+      sessionStoreStrategy.expireSession(sessionCache)
+      synchronizeSession(getExpiredSessionState(sessionCache, configuration))
     },
     stop: () => {
       clearInterval(watchSessionTimeoutId)
     },
+    updateSessionState,
   }
 }

package/src/domain/session/sessionStoreOperations.ts

@@ -1,17 +1,24 @@
 import { setTimeout } from '../../tools/timer'
 import { generateUUID } from '../../tools/utils/stringUtils'
-import { isChromium } from '../../tools/utils/browserDetection'
+import type { TimeStamp } from '../../tools/utils/timeUtils'
+import { elapsed, ONE_SECOND, timeStampNow } from '../../tools/utils/timeUtils'
 import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
 import type { SessionState } from './sessionState'
 import { expandSessionState, isSessionInExpiredState } from './sessionState'
 
-type Operations = {
+interface Operations {
   process: (sessionState: SessionState) => SessionState | undefined
   after?: (sessionState: SessionState) => void
 }
 
 export const LOCK_RETRY_DELAY = 10
 export const LOCK_MAX_TRIES = 100
+
+// Locks should be hold for a few milliseconds top, just the time it takes to read and write a
+// cookie. Using one second should be enough in most situations.
+export const LOCK_EXPIRATION_DELAY = ONE_SECOND
+const LOCK_SEPARATOR = '--'
+
 const bufferedOperations: Operations[] = []
 let ongoingOperations: Operations | undefined
 
@@ -20,8 +27,15 @@ export function processSessionStoreOperations(
   sessionStoreStrategy: SessionStoreStrategy,
   numberOfRetries = 0
 ) {
-  const { retrieveSession, persistSession, clearSession } = sessionStoreStrategy
-  const lockEnabled = isLockEnabled()
+  const { isLockEnabled, persistSession, expireSession } = sessionStoreStrategy
+  const persistWithLock = (session: SessionState) => persistSession({ ...session, lock: currentLock })
+  const retrieveStore = () => {
+    const { lock, ...session } = sessionStoreStrategy.retrieveSession()
+    return {
+      session,
+      lock: lock && !isLockExpired(lock) ? lock : undefined,
+    }
+  }
 
   if (!ongoingOperations) {
     ongoingOperations = operations
@@ -30,73 +44,69 @@ export function processSessionStoreOperations(
     bufferedOperations.push(operations)
     return
   }
-  if (lockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
+  if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
     next(sessionStoreStrategy)
     return
   }
   let currentLock: string
-  let currentSession = retrieveSession()
-  if (lockEnabled) {
+  let currentStore = retrieveStore()
+  if (isLockEnabled) {
     // if someone has lock, retry later
-    if (currentSession.lock) {
+    if (currentStore.lock) {
       retryLater(operations, sessionStoreStrategy, numberOfRetries)
       return
     }
     // acquire lock
-    currentLock = generateUUID()
-    currentSession.lock = currentLock
-    persistSession(currentSession)
+    currentLock = createLock()
+    persistWithLock(currentStore.session)
     // if lock is not acquired, retry later
-    currentSession = retrieveSession()
-    if (currentSession.lock !== currentLock) {
+    currentStore = retrieveStore()
+    if (currentStore.lock !== currentLock) {
       retryLater(operations, sessionStoreStrategy, numberOfRetries)
       return
     }
   }
-  let processedSession = operations.process(currentSession)
-  if (lockEnabled) {
+  let processedSession = operations.process(currentStore.session)
+  if (isLockEnabled) {
     // if lock corrupted after process, retry later
-    currentSession = retrieveSession()
-    if (currentSession.lock !== currentLock!) {
+    currentStore = retrieveStore()
+    if (currentStore.lock !== currentLock!) {
       retryLater(operations, sessionStoreStrategy, numberOfRetries)
       return
     }
   }
   if (processedSession) {
     if (isSessionInExpiredState(processedSession)) {
-      clearSession()
+      expireSession(processedSession)
     } else {
       expandSessionState(processedSession)
-      persistSession(processedSession)
+      if (isLockEnabled) {
+        persistWithLock(processedSession)
+      } else {
+        persistSession(processedSession)
+      }
     }
   }
-  if (lockEnabled) {
+  if (isLockEnabled) {
     // correctly handle lock around expiration would require to handle this case properly at several levels
     // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it
     if (!(processedSession && isSessionInExpiredState(processedSession))) {
       // if lock corrupted after persist, retry later
-      currentSession = retrieveSession()
-      if (currentSession.lock !== currentLock!) {
+      currentStore = retrieveStore()
+      if (currentStore.lock !== currentLock!) {
         retryLater(operations, sessionStoreStrategy, numberOfRetries)
         return
       }
-      delete currentSession.lock
-      persistSession(currentSession)
-      processedSession = currentSession
+      persistSession(currentStore.session)
+      processedSession = currentStore.session
     }
   }
   // call after even if session is not persisted in order to perform operations on
   // up-to-date session state value => the value could have been modified by another tab
-  operations.after?.(processedSession || currentSession)
+  operations.after?.(processedSession || currentStore.session)
   next(sessionStoreStrategy)
 }
 
-/**
- * Lock strategy allows mitigating issues due to concurrent access to cookie.
- * This issue concerns only chromium browsers and enabling this on firefox increases cookie write failures.
- */
-export const isLockEnabled = () => isChromium()
-
 function retryLater(operations: Operations, sessionStore: SessionStoreStrategy, currentNumberOfRetries: number) {
   setTimeout(() => {
     processSessionStoreOperations(operations, sessionStore, currentNumberOfRetries + 1)
@@ -110,3 +120,12 @@ function next(sessionStore: SessionStoreStrategy) {
     processSessionStoreOperations(nextOperations, sessionStore)
   }
 }
+
+export function createLock(): string {
+  return generateUUID() + LOCK_SEPARATOR + timeStampNow()
+}
+
+function isLockExpired(lock: string) {
+  const [, timeStamp] = lock.split(LOCK_SEPARATOR)
+  return !timeStamp || elapsed(Number(timeStamp) as TimeStamp, timeStampNow()) > LOCK_EXPIRATION_DELAY
+}