@cloudcare/browser-core 3.2.3 → 3.2.6

package/src/helper/taskQueue.js

@@ -0,0 +1,55 @@
+import { ONE_SECOND } from './tools'
+import { requestIdleCallback } from './requestIdleCallback'
+
+/**
+ * Maximum delay before starting to execute tasks in the queue. We don't want to wait too long
+ * before running tasks, as it might hurt reliability (ex: if the user navigates away, we might lose
+ * the opportunity to send some data). We also don't want to run tasks too often, as it might hurt
+ * performance.
+ */
+const IDLE_CALLBACK_TIMEOUT = ONE_SECOND
+
+/**
+ * Maximum amount of time allocated to running tasks when a timeout (`IDLE_CALLBACK_TIMEOUT`) is
+ * reached. We should not run tasks for too long as it will hurt performance, but we should still
+ * run some tasks to avoid postponing them forever.
+ *
+ * Rational: Running tasks for 30ms every second (IDLE_CALLBACK_TIMEOUT) should be acceptable.
+ */
+export const MAX_EXECUTION_TIME_ON_TIMEOUT = 30
+
+export function createTaskQueue() {
+  const pendingTasks = []
+
+  function run(deadline) {
+    let executionTimeRemaining
+    if (deadline.didTimeout) {
+      const start = performance.now()
+      executionTimeRemaining = function () {
+        return MAX_EXECUTION_TIME_ON_TIMEOUT - (performance.now() - start)
+      }
+    } else {
+      executionTimeRemaining = deadline.timeRemaining.bind(deadline)
+    }
+
+    while (executionTimeRemaining() > 0 && pendingTasks.length) {
+      pendingTasks.shift()()
+    }
+
+    if (pendingTasks.length) {
+      scheduleNextRun()
+    }
+  }
+
+  function scheduleNextRun() {
+    requestIdleCallback(run, { timeout: IDLE_CALLBACK_TIMEOUT })
+  }
+
+  return {
+    push(task) {
+      if (pendingTasks.push(task) === 1) {
+        scheduleNextRun()
+      }
+    }
+  }
+}

package/src/helper/tools.js

@@ -1553,7 +1553,12 @@ export function findByPath(source, path) {
   var pathArr = path.split('.')
   while (pathArr.length) {
     var key = pathArr.shift()
-    if (source && key in source && hasOwnProperty.call(source, key)) {
+    if (
+      source &&
+      isObject(source) &&
+      key in source &&
+      hasOwnProperty.call(source, key)
+    ) {
       source = source[key]
     } else {
       return undefined

package/src/index.js

@@ -22,6 +22,8 @@ export * from './helper/mobileUtil'
 export * from './helper/getZoneJsOriginalValue'
 export * from './helper/timer'
 export * from './helper/readBytesFromStream'
+export * from './helper/requestIdleCallback'
+export * from './helper/taskQueue'
 export * from './tracekit'
 export * from './configuration/configuration'
 export * from './configuration/transportConfiguration'
@@ -36,10 +38,15 @@ export * from './browser/scroll'
 
 export * from './dataMap'
 export * from './init'
-export * from './session/sessionManagement'
-export * from './session/sessionConstants'
-export * from './session/sessionCookieStore'
-export * from './session/sessionStore'
+export {
+  startSessionManager,
+  stopSessionManager
+} from './session/sessionManagement'
+export {
+  SESSION_TIME_OUT_DELAY,
+  SESSION_STORE_KEY
+} from './session/sessionConstants'
+export { STORAGE_POLL_DELAY } from './session/sessionStore'
 export * from './transport'
 export * from './synthetics/syntheticsWorkerValues'
 

package/src/init.js

@@ -60,22 +60,3 @@ export function getGlobalObject() {
   }
   return globalObject
 }
-// export function checkCookiesAuthorized(options) {
-//   if (!areCookiesAuthorized(options)) {
-//     console.warn('Cookies are not authorized, we will not send any data.')
-//     return false
-//   }
-//   return true
-// }
-
-// export function checkIsNotLocalFile() {
-//   if (isLocalFile()) {
-//     console.error('Execution is not allowed in the current context.')
-//     return false
-//   }
-//   return true
-// }
-
-// function isLocalFile() {
-//   return window.location.protocol === 'file:'
-// }

package/src/session/sessionConstants.js

@@ -1,3 +1,4 @@
 import { ONE_HOUR, ONE_MINUTE } from '../helper/tools'
 export var SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR
 export var SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE
+export var SESSION_STORE_KEY = '_gc_s'

package/src/session/sessionInCookie.js

@@ -0,0 +1,87 @@
+import { isChromium } from '../helper/tools'
+import {
+  getCurrentSite,
+  areCookiesAuthorized,
+  getCookie,
+  setCookie
+} from '../browser/cookie'
+import {
+  SESSION_EXPIRATION_DELAY,
+  SESSION_TIME_OUT_DELAY,
+  SESSION_STORE_KEY
+} from './sessionConstants'
+import {
+  toSessionString,
+  toSessionState,
+  getExpiredSessionState
+} from './sessionState'
+
+export function selectCookieStrategy(initConfiguration) {
+  const cookieOptions = buildCookieOptions(initConfiguration)
+  return areCookiesAuthorized(cookieOptions)
+    ? { type: 'Cookie', cookieOptions }
+    : undefined
+}
+
+export function initCookieStrategy(cookieOptions) {
+  const cookieStore = {
+    /**
+     * 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.
+     */
+    isLockEnabled: isChromium(),
+    persistSession: persistSessionCookie(cookieOptions),
+    retrieveSession: retrieveSessionCookie(cookieOptions),
+    expireSession: function () {
+      return expireSessionCookie(cookieOptions)
+    }
+  }
+  return cookieStore
+}
+
+function persistSessionCookie(options) {
+  return function (session) {
+    setCookie(
+      SESSION_STORE_KEY,
+      toSessionString(session),
+      SESSION_EXPIRATION_DELAY,
+      options
+    )
+  }
+}
+
+function expireSessionCookie(options) {
+  setCookie(
+    SESSION_STORE_KEY,
+    toSessionString(getExpiredSessionState()),
+    SESSION_TIME_OUT_DELAY,
+    options
+  )
+}
+
+function retrieveSessionCookie(options) {
+  return function () {
+    var sessionString = getCookie(SESSION_STORE_KEY, options)
+    return toSessionState(sessionString)
+  }
+}
+
+export function buildCookieOptions(initConfiguration) {
+  const cookieOptions = {}
+
+  cookieOptions.secure =
+    !!initConfiguration.useSecureSessionCookie ||
+    !!initConfiguration.usePartitionedCrossSiteSessionCookie ||
+    !!initConfiguration.useCrossSiteSessionCookie
+  cookieOptions.crossSite =
+    !!initConfiguration.usePartitionedCrossSiteSessionCookie ||
+    !!initConfiguration.useCrossSiteSessionCookie
+  cookieOptions.partitioned =
+    !!initConfiguration.usePartitionedCrossSiteSessionCookie
+
+  if (initConfiguration.trackSessionAcrossSubdomains) {
+    cookieOptions.domain = getCurrentSite()
+  }
+
+  return cookieOptions
+}

package/src/session/sessionInLocalStorage.js

@@ -0,0 +1,45 @@
+import { UUID } from '../helper/tools'
+import {
+  toSessionString,
+  toSessionState,
+  getExpiredSessionState
+} from './sessionState'
+
+import { SESSION_STORE_KEY } from './sessionConstants'
+
+const LOCAL_STORAGE_TEST_KEY = '_gc_test_'
+
+export function selectLocalStorageStrategy() {
+  try {
+    const id = UUID()
+    const testKey = `${LOCAL_STORAGE_TEST_KEY}${id}`
+    localStorage.setItem(testKey, id)
+    const retrievedId = localStorage.getItem(testKey)
+    localStorage.removeItem(testKey)
+    return id === retrievedId ? { type: 'LocalStorage' } : undefined
+  } catch (e) {
+    return undefined
+  }
+}
+
+export function initLocalStorageStrategy() {
+  return {
+    isLockEnabled: false,
+    persistSession: persistInLocalStorage,
+    retrieveSession: retrieveSessionFromLocalStorage,
+    expireSession: expireSessionFromLocalStorage
+  }
+}
+
+function persistInLocalStorage(sessionState) {
+  localStorage.setItem(SESSION_STORE_KEY, toSessionString(sessionState))
+}
+
+function retrieveSessionFromLocalStorage() {
+  const sessionString = localStorage.getItem(SESSION_STORE_KEY)
+  return toSessionState(sessionString)
+}
+
+function expireSessionFromLocalStorage() {
+  persistInLocalStorage(getExpiredSessionState())
+}

package/src/session/sessionManagement.js

@@ -1,31 +1,37 @@
-import { relativeNow, clocksOrigin, ONE_MINUTE, each } from '../helper/tools'
-import {
-  addEventListeners,
-  addEventListener
-} from '../browser/addEventListener'
+import { Observable } from '../helper/observable'
 import { createValueHistory } from '../helper/valueHistory'
-import { startSessionStore } from './sessionStore'
-import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
+import { relativeNow, clocksOrigin, ONE_MINUTE } from '../helper/tools'
 import { DOM_EVENT } from '../helper/enums'
+import {
+  addEventListener,
+  addEventListeners
+} from '../browser/addEventListener'
 import { clearInterval, setInterval } from '../helper/timer'
-import { Observable } from '../helper/observable'
-export var VISIBILITY_CHECK_DELAY = ONE_MINUTE
-var SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY
-var stopCallbacks = []
+import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
+import { startSessionStore } from './sessionStore'
 
-export var startSessionManager = function (
-  options,
+export const VISIBILITY_CHECK_DELAY = ONE_MINUTE
+const SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY
+let stopCallbacks = []
+
+export function startSessionManager(
+  configuration,
   productKey,
   computeSessionState
 ) {
-  var renewObservable = new Observable()
-  var expireObservable = new Observable()
-  var sessionStore = startSessionStore(options, productKey, computeSessionState)
+  const renewObservable = new Observable()
+  const expireObservable = new Observable()
+
+  const sessionStore = startSessionStore(
+    configuration.sessionStoreStrategyType,
+    productKey,
+    computeSessionState
+  )
   stopCallbacks.push(function () {
     return sessionStore.stop()
   })
 
-  var sessionContextHistory = createValueHistory({
+  const sessionContextHistory = createValueHistory({
     expireDelay: SESSION_CONTEXT_TIMEOUT_DELAY
   })
   stopCallbacks.push(function () {
@@ -41,18 +47,20 @@ export var startSessionManager = function (
     sessionContextHistory.closeActive(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)
 
   trackActivity(function () {
-    return sessionStore.expandOrRenewSession()
+    sessionStore.expandOrRenewSession()
   })
   trackVisibility(function () {
     return sessionStore.expandSession()
   })
-  //   trackResume(function () {
-  //     return sessionStore.expandSession()
-  //   })
+  trackResume(function () {
+    sessionStore.restartSession()
+  })
 
   function buildSessionContext() {
     return {
@@ -62,24 +70,26 @@ export var startSessionManager = function (
   }
 
   return {
-    findActiveSession: function (startTime) {
-      return sessionContextHistory.find(startTime)
+    findSession: function (startTime, options) {
+      return sessionContextHistory.find(startTime, options)
     },
-    renewObservable: renewObservable,
-    expireObservable: expireObservable,
-    expire: sessionStore.expire
+    renewObservable,
+    expireObservable,
+    sessionStateUpdateObservable: sessionStore.sessionStateUpdateObservable,
+    expire: sessionStore.expire,
+    updateSessionState: sessionStore.updateSessionState
   }
 }
 
 export function stopSessionManager() {
-  each(stopCallbacks, function (e) {
-    return e()
+  stopCallbacks.forEach(function (e) {
+    e()
   })
   stopCallbacks = []
 }
 
 function trackActivity(expandOrRenewSession) {
-  var _addEventListeners = addEventListeners(
+  const { stop } = addEventListeners(
     window,
     [
       DOM_EVENT.CLICK,
@@ -90,23 +100,24 @@ function trackActivity(expandOrRenewSession) {
     expandOrRenewSession,
     { capture: true, passive: true }
   )
-  stopCallbacks.push(_addEventListeners.stop)
+  stopCallbacks.push(stop)
 }
 
 function trackVisibility(expandSession) {
-  var expandSessionWhenVisible = function () {
+  const expandSessionWhenVisible = function () {
     if (document.visibilityState === 'visible') {
       expandSession()
     }
   }
-  var _addEventListener = addEventListener(
+
+  const { stop } = addEventListener(
     document,
     DOM_EVENT.VISIBILITY_CHANGE,
     expandSessionWhenVisible
   )
-  stopCallbacks.push(_addEventListener.stop)
+  stopCallbacks.push(stop)
 
-  var visibilityCheckInterval = setInterval(
+  const visibilityCheckInterval = setInterval(
     expandSessionWhenVisible,
     VISIBILITY_CHECK_DELAY
   )
@@ -114,9 +125,10 @@ function trackVisibility(expandSession) {
     clearInterval(visibilityCheckInterval)
   })
 }
+
 function trackResume(cb) {
-  var _addEventListener = addEventListener(window, DOM_EVENT.RESUME, cb, {
+  const { stop } = addEventListener(window, DOM_EVENT.RESUME, cb, {
     capture: true
   })
-  stopCallbacks.push(_addEventListener.stop)
+  stopCallbacks.push(stop)
 }

package/src/session/sessionState.js

@@ -0,0 +1,72 @@
+import { isEmptyObject, objectEntries, dateNow, map } from '../helper/tools'
+import {
+  SESSION_EXPIRATION_DELAY,
+  SESSION_TIME_OUT_DELAY
+} from './sessionConstants'
+
+const SESSION_ENTRY_REGEXP = /^([a-zA-Z]+)=([a-z0-9-]+)$/
+const SESSION_ENTRY_SEPARATOR = '&'
+
+export const EXPIRED = '1'
+
+export function getExpiredSessionState() {
+  return {
+    isExpired: EXPIRED
+  }
+}
+
+export function isSessionInNotStartedState(session) {
+  return isEmptyObject(session)
+}
+
+export function isSessionStarted(session) {
+  return !isSessionInNotStartedState(session)
+}
+
+export function isSessionInExpiredState(session) {
+  return session.isExpired !== undefined || !isActiveSession(session)
+}
+
+// An active session is a session in either `Tracked` or `NotTracked` state
+function isActiveSession(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) {
+  session.expire = String(dateNow() + SESSION_EXPIRATION_DELAY)
+}
+
+export function toSessionString(session) {
+  return map(objectEntries(session), function (item) {
+    return item[0] + '=' + item[1]
+  }).join(SESSION_ENTRY_SEPARATOR)
+}
+
+export function toSessionState(sessionString) {
+  const session = {}
+  if (isValidSessionString(sessionString)) {
+    sessionString.split(SESSION_ENTRY_SEPARATOR).forEach(function (entry) {
+      const matches = SESSION_ENTRY_REGEXP.exec(entry)
+      if (matches !== null) {
+        const [, key, value] = matches
+        session[key] = value
+      }
+    })
+  }
+  return session
+}
+
+function isValidSessionString(sessionString) {
+  return (
+    !!sessionString &&
+    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 ||
+      SESSION_ENTRY_REGEXP.test(sessionString))
+  )
+}