Test anonymous id on staging behind ff

packages/core/src/browser/cookie.ts

@@ -9,7 +9,7 @@ export interface CookieOptions {
   domain?: string
 }
 
-export function setCookie(name: string, value: string, expireDelay: number, options?: CookieOptions) {
+export function setCookie(name: string, value: string, expireDelay: number = 0, options?: CookieOptions) {
   const date = new Date()
   date.setTime(date.getTime() + expireDelay)
   const expires = `expires=${date.toUTCString()}`

packages/core/src/domain/session/sessionConstants.ts

@@ -1,4 +1,5 @@
-import { ONE_HOUR, ONE_MINUTE } from '../../tools/utils/timeUtils'
+import { ONE_HOUR, ONE_MINUTE, ONE_YEAR } from '../../tools/utils/timeUtils'
 
 export const SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR
 export const SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE
+export const SESSION_COOKIE_EXPIRATION_DELAY = ONE_YEAR

packages/core/src/domain/session/sessionManager.ts

@@ -27,6 +27,7 @@ export interface SessionContext<TrackingType extends string> extends Context {
   id: string
   trackingType: TrackingType
   isReplayForced: boolean
+  anonymousId: string | undefined
 }
 
 export const VISIBILITY_CHECK_DELAY = ONE_MINUTE
@@ -86,6 +87,7 @@ export function startSessionManager<TrackingType extends string>(
       id: sessionStore.getSession().id!,
       trackingType: sessionStore.getSession()[productKey] as TrackingType,
       isReplayForced: !!sessionStore.getSession().forcedReplay,
+      anonymousId: sessionStore.getSession().anonymousId,
     }
   }
 

packages/core/src/domain/session/sessionState.ts

@@ -1,11 +1,10 @@
+import { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../tools/experimentalFeatures'
 import { isEmptyObject } from '../../tools/utils/objectUtils'
 import { objectEntries } from '../../tools/utils/polyfills'
 import { dateNow } from '../../tools/utils/timeUtils'
+import { generateAnonymousId } from '../user'
 import { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from './sessionConstants'
-
-const SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/
-const SESSION_ENTRY_SEPARATOR = '&'
-
+import { isValidSessionString, SESSION_ENTRY_REGEXP, SESSION_ENTRY_SEPARATOR } from './sessionStateValidation'
 export const EXPIRED = '1'
 
 export interface SessionState {
@@ -17,10 +16,18 @@ export interface SessionState {
   [key: string]: string | undefined
 }
 
-export function getExpiredSessionState(): SessionState {
-  return {
+export function getExpiredSessionState(previousSessionState: SessionState | undefined): SessionState {
+  const expiredSessionState: SessionState = {
     isExpired: EXPIRED,
   }
+  if (isExperimentalFeatureEnabled(ExperimentalFeature.ANONYMOUS_USER_TRACKING)) {
+    if (previousSessionState?.anonymousId) {
+      expiredSessionState.anonymousId = previousSessionState?.anonymousId
+    } else {
+      expiredSessionState.anonymousId = generateAnonymousId()
+    }
+  }
+  return expiredSessionState
 }
 
 export function isSessionInNotStartedState(session: SessionState) {
@@ -50,9 +57,12 @@ export function expandSessionState(session: SessionState) {
 }
 
 export function toSessionString(session: SessionState) {
-  return objectEntries(session)
-    .map(([key, value]) => `${key}=${value}`)
-    .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) {
@@ -62,16 +72,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))
-  )
-}

packages/core/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))
+  )
+}

packages/core/src/domain/session/sessionStore.ts

@@ -4,7 +4,6 @@ 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 { assign } from '../../tools/utils/polyfills'
 import { selectCookieStrategy, initCookieStrategy } from './storeStrategies/sessionInCookie'
 import type { SessionStoreStrategyType } from './storeStrategies/sessionStoreStrategy'
 import {
@@ -117,7 +116,8 @@ export function startSessionStore<TrackingType extends string>(
   function watchSession() {
     processSessionStoreOperations(
       {
-        process: (sessionState) => (isSessionInExpiredState(sessionState) ? getExpiredSessionState() : undefined),
+        process: (sessionState) =>
+          isSessionInExpiredState(sessionState) ? getExpiredSessionState(sessionState) : undefined,
         after: synchronizeSession,
       },
       sessionStoreStrategy
@@ -126,7 +126,7 @@ export function startSessionStore<TrackingType extends string>(
 
   function synchronizeSession(sessionState: SessionState) {
     if (isSessionInExpiredState(sessionState)) {
-      sessionState = getExpiredSessionState()
+      sessionState = getExpiredSessionState(sessionState)
     }
     if (hasSessionInCache()) {
       if (isSessionInCacheOutdated(sessionState)) {
@@ -144,7 +144,7 @@ export function startSessionStore<TrackingType extends string>(
       {
         process: (sessionState) => {
           if (isSessionInNotStartedState(sessionState)) {
-            return getExpiredSessionState()
+            return getExpiredSessionState(sessionState)
           }
         },
         after: (sessionState) => {
@@ -178,7 +178,7 @@ export function startSessionStore<TrackingType extends string>(
   }
 
   function expireSessionInCache() {
-    sessionCache = getExpiredSessionState()
+    sessionCache = getExpiredSessionState(sessionCache)
     expireObservable.notify()
   }
 
@@ -190,7 +190,7 @@ export function startSessionStore<TrackingType extends string>(
   function updateSessionState(partialSessionState: Partial<SessionState>) {
     processSessionStoreOperations(
       {
-        process: (sessionState) => assign({}, sessionState, partialSessionState),
+        process: (sessionState) => ({ ...sessionState, ...partialSessionState }),
         after: synchronizeSession,
       },
       sessionStoreStrategy
@@ -207,8 +207,8 @@ export function startSessionStore<TrackingType extends string>(
     restartSession: startSession,
     expire: () => {
       cancelExpandOrRenewSession()
-      expireSession()
-      synchronizeSession(getExpiredSessionState())
+      expireSession(sessionCache)
+      synchronizeSession(getExpiredSessionState(sessionCache))
     },
     stop: () => {
       clearInterval(watchSessionTimeoutId)

packages/core/src/domain/session/sessionStoreOperations.spec.ts

@@ -37,7 +37,7 @@ const EXPIRED_SESSION: SessionState = { isExpired: '1' }
     const now = Date.now()
 
     beforeEach(() => {
-      sessionStoreStrategy.expireSession()
+      sessionStoreStrategy.expireSession(initialSession)
       initialSession = { id: '123', created: String(now) }
       otherSession = { id: '456', created: String(now + 100) }
       processSpy = jasmine.createSpy('process')

packages/core/src/domain/session/sessionStoreOperations.ts

@@ -1,6 +1,5 @@
 import { setTimeout } from '../../tools/timer'
 import { generateUUID } from '../../tools/utils/stringUtils'
-import { assign } from '../../tools/utils/polyfills'
 import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
 import type { SessionState } from './sessionState'
 import { expandSessionState, isSessionInExpiredState } from './sessionState'
@@ -21,7 +20,7 @@ export function processSessionStoreOperations(
   numberOfRetries = 0
 ) {
   const { isLockEnabled, persistSession, expireSession } = sessionStoreStrategy
-  const persistWithLock = (session: SessionState) => persistSession(assign({}, session, { lock: currentLock }))
+  const persistWithLock = (session: SessionState) => persistSession({ ...session, lock: currentLock })
   const retrieveStore = () => {
     const session = sessionStoreStrategy.retrieveSession()
     const lock = session.lock
@@ -76,7 +75,7 @@ export function processSessionStoreOperations(
   }
   if (processedSession) {
     if (isSessionInExpiredState(processedSession)) {
-      expireSession()
+      expireSession(processedSession)
     } else {
       expandSessionState(processedSession)
       isLockEnabled ? persistWithLock(processedSession) : persistSession(processedSession)

packages/core/src/domain/session/storeStrategies/sessionInCookie.spec.ts

@@ -1,3 +1,5 @@
+import { ExperimentalFeature, resetExperimentalFeatures } from '../../../tools/experimentalFeatures'
+import { mockExperimentalFeatures } from '../../../../test'
 import { setCookie, deleteCookie, getCookie, getCurrentSite } from '../../../browser/cookie'
 import { type SessionState } from '../sessionState'
 import { buildCookieOptions, selectCookieStrategy, initCookieStrategy } from './sessionInCookie'
@@ -25,7 +27,7 @@ describe('session in cookie strategy', () => {
 
   it('should set `isExpired=1` to the cookie holding the session', () => {
     cookieStorageStrategy.persistSession(sessionState)
-    cookieStorageStrategy.expireSession()
+    cookieStorageStrategy.expireSession(sessionState)
     const session = cookieStorageStrategy.retrieveSession()
     expect(session).toEqual({ isExpired: '1' })
     expect(getCookie(SESSION_STORE_KEY)).toBe('isExpired=1')
@@ -108,3 +110,33 @@ describe('session in cookie strategy', () => {
     })
   })
 })
+describe('session in cookie strategy with anonymous user tracking', () => {
+  const anonymousId = 'device-123'
+  const sessionState: SessionState = { id: '123', created: '0' }
+  let cookieStorageStrategy: SessionStoreStrategy
+
+  beforeEach(() => {
+    mockExperimentalFeatures([ExperimentalFeature.ANONYMOUS_USER_TRACKING])
+    cookieStorageStrategy = initCookieStrategy({})
+  })
+
+  afterEach(() => {
+    resetExperimentalFeatures()
+    deleteCookie(SESSION_STORE_KEY)
+  })
+
+  it('should persist a session with anonymous id in a cookie', () => {
+    cookieStorageStrategy.persistSession({ ...sessionState, anonymousId })
+    const session = cookieStorageStrategy.retrieveSession()
+    expect(session).toEqual({ ...sessionState, anonymousId })
+    expect(getCookie(SESSION_STORE_KEY)).toBe(`id=123&created=0&aid=${anonymousId}`)
+  })
+
+  it('should expire a session with anonymous id in a cookie', () => {
+    cookieStorageStrategy.persistSession({ ...sessionState, anonymousId })
+    cookieStorageStrategy.expireSession({ ...sessionState, anonymousId })
+    const session = cookieStorageStrategy.retrieveSession()
+    expect(session).toEqual({ isExpired: '1', anonymousId })
+    expect(getCookie(SESSION_STORE_KEY)).toBe(`isExpired=1&aid=${anonymousId}`)
+  })
+})

packages/core/src/domain/session/storeStrategies/sessionInCookie.ts

@@ -1,9 +1,10 @@
 import { isChromium } from '../../../tools/utils/browserDetection'
+import { ExperimentalFeature, isExperimentalFeatureEnabled } from '../../../tools/experimentalFeatures'
 import type { CookieOptions } from '../../../browser/cookie'
 import { getCurrentSite, areCookiesAuthorized, getCookie, setCookie } from '../../../browser/cookie'
 import type { InitConfiguration } from '../../configuration'
 import { tryOldCookiesMigration } from '../oldCookiesMigration'
-import { SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from '../sessionConstants'
+import { SESSION_COOKIE_EXPIRATION_DELAY, SESSION_EXPIRATION_DELAY, SESSION_TIME_OUT_DELAY } from '../sessionConstants'
 import type { SessionState } from '../sessionState'
 import { toSessionString, toSessionState, getExpiredSessionState } from '../sessionState'
 import type { SessionStoreStrategy, SessionStoreStrategyType } from './sessionStoreStrategy'
@@ -23,7 +24,7 @@ export function initCookieStrategy(cookieOptions: CookieOptions): SessionStoreSt
     isLockEnabled: isChromium(),
     persistSession: persistSessionCookie(cookieOptions),
     retrieveSession: retrieveSessionCookie,
-    expireSession: () => expireSessionCookie(cookieOptions),
+    expireSession: (sessionState: SessionState) => expireSessionCookie(cookieOptions, sessionState),
   }
 
   tryOldCookiesMigration(cookieStore)
@@ -37,13 +38,22 @@ function persistSessionCookie(options: CookieOptions) {
   }
 }
 
-function expireSessionCookie(options: CookieOptions) {
-  setCookie(SESSION_STORE_KEY, toSessionString(getExpiredSessionState()), SESSION_TIME_OUT_DELAY, options)
+function expireSessionCookie(options: CookieOptions, sessionState: SessionState) {
+  const expiredSessionState = getExpiredSessionState(sessionState)
+  setCookie(
+    SESSION_STORE_KEY,
+    toSessionString(expiredSessionState),
+    isExperimentalFeatureEnabled(ExperimentalFeature.ANONYMOUS_USER_TRACKING)
+      ? SESSION_COOKIE_EXPIRATION_DELAY
+      : SESSION_TIME_OUT_DELAY,
+    options
+  )
 }
 
 function retrieveSessionCookie(): SessionState {
   const sessionString = getCookie(SESSION_STORE_KEY)
-  return toSessionState(sessionString)
+  const sessionState = toSessionState(sessionString)
+  return sessionState
 }
 
 export function buildCookieOptions(initConfiguration: InitConfiguration) {

packages/core/src/domain/session/storeStrategies/sessionInLocalStorage.spec.ts

@@ -1,9 +1,15 @@
+import { mockExperimentalFeatures } from '../../../../test'
+import { ExperimentalFeature } from '../../../tools/experimentalFeatures'
 import { type SessionState } from '../sessionState'
 import { selectLocalStorageStrategy, initLocalStorageStrategy } from './sessionInLocalStorage'
 import { SESSION_STORE_KEY } from './sessionStoreStrategy'
 
 describe('session in local storage strategy', () => {
   const sessionState: SessionState = { id: '123', created: '0' }
+  beforeEach(() => {
+    mockExperimentalFeatures([ExperimentalFeature.ANONYMOUS_USER_TRACKING])
+    spyOn(Math, 'random').and.returnValue(1)
+  })
 
   afterEach(() => {
     window.localStorage.clear()
@@ -31,25 +37,18 @@ describe('session in local storage strategy', () => {
   it('should set `isExpired=1` to the local storage item holding the session', () => {
     const localStorageStrategy = initLocalStorageStrategy()
     localStorageStrategy.persistSession(sessionState)
-    localStorageStrategy.expireSession()
+    localStorageStrategy.expireSession(sessionState)
     const session = localStorageStrategy?.retrieveSession()
-    expect(session).toEqual({ isExpired: '1' })
-    expect(window.localStorage.getItem(SESSION_STORE_KEY)).toBe('isExpired=1')
+    expect(session).toEqual({ isExpired: '1', anonymousId: '2gosa7pa2gw' })
+    expect(window.localStorage.getItem(SESSION_STORE_KEY)).toBe('isExpired=1&aid=2gosa7pa2gw')
   })
 
   it('should not interfere with other keys present in local storage', () => {
     window.localStorage.setItem('test', 'hello')
     const localStorageStrategy = initLocalStorageStrategy()
     localStorageStrategy.persistSession(sessionState)
     localStorageStrategy.retrieveSession()
-    localStorageStrategy.expireSession()
+    localStorageStrategy.expireSession(sessionState)
     expect(window.localStorage.getItem('test')).toEqual('hello')
   })
-
-  it('should return an empty object if session string is invalid', () => {
-    const localStorageStrategy = initLocalStorageStrategy()
-    localStorage.setItem(SESSION_STORE_KEY, '{test:42}')
-    const session = localStorageStrategy?.retrieveSession()
-    expect(session).toEqual({})
-  })
 })

packages/core/src/domain/session/storeStrategies/sessionInLocalStorage.ts

@@ -37,6 +37,6 @@ function retrieveSessionFromLocalStorage(): SessionState {
   return toSessionState(sessionString)
 }
 
-function expireSessionFromLocalStorage() {
-  persistInLocalStorage(getExpiredSessionState())
+function expireSessionFromLocalStorage(previousSessionState: SessionState) {
+  persistInLocalStorage(getExpiredSessionState(previousSessionState))
 }

packages/core/src/domain/session/storeStrategies/sessionStoreStrategy.ts

@@ -9,5 +9,5 @@ export interface SessionStoreStrategy {
   isLockEnabled: boolean
   persistSession: (session: SessionState) => void
   retrieveSession: () => SessionState
-  expireSession: () => void
+  expireSession: (previousSessionState: SessionState) => void
 }

packages/core/src/domain/user/user.spec.ts

@@ -1,5 +1,5 @@
 import { display } from '../../tools/display'
-import { checkUser, sanitizeUser } from './user'
+import { checkUser, generateAnonymousId, sanitizeUser } from './user'
 import type { User } from './user.types'
 
 describe('sanitize user function', () => {
@@ -37,3 +37,9 @@ describe('check user function', () => {
     expect(display.error).toHaveBeenCalledTimes(3)
   })
 })
+
+describe('check anonymous id storage functions', () => {
+  it('should generate a random anonymous id', () => {
+    expect(generateAnonymousId()).toMatch(/^[a-z0-9]+$/)
+  })
+})