@cloudcare/browser-core 1.1.3 → 1.2.0

package/src/session/sessionStore.js

@@ -0,0 +1,139 @@
+import { COOKIE_ACCESS_DELAY } from '../browser/cookie'
+import { Observable } from '../helper/observable'
+import { dateNow, UUID, throttle } from '../helper/tools'
+import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
+import { retrieveSession, withCookieLockAccess } from './sessionCookieStore'
+
+/**
+ * Different session concepts:
+ * - tracked, the session has an id and is updated along the user navigation
+ * - not tracked, the session does not have an id but it is updated along the user navigation
+ * - inactive, no session in store or session expired, waiting for a renew session
+ */
+export function startSessionStore(
+  options,
+  productKey,
+  computeSessionState
+) {
+  var renewObservable = new Observable()
+  var expireObservable = new Observable()
+
+  var watchSessionTimeoutId = setInterval(watchSession, COOKIE_ACCESS_DELAY)
+  var sessionCache = retrieveActiveSession()
+
+  function expandOrRenewSession() {
+    var isTracked
+    withCookieLockAccess({
+      options: options,
+      process: function(cookieSession){
+        var synchronizedSession = synchronizeSession(cookieSession)
+        isTracked = expandOrRenewCookie(synchronizedSession)
+        return synchronizedSession
+      },
+      after: function(cookieSession) {
+        if (isTracked && !hasSessionInCache()) {
+          renewSession(cookieSession)
+        }
+        sessionCache = cookieSession
+      },
+    })
+  }
+
+  function expandSession() {
+    withCookieLockAccess({
+      options: options,
+      process: function(cookieSession) {
+        return (hasSessionInCache() ? synchronizeSession(cookieSession) : undefined)
+      },
+    })
+  }
+
+  /**
+   * allows two behaviors:
+   * - if the session is active, synchronize the session cache without updating the session cookie
+   * - if the session is not active, clear the session cookie and expire the session cache
+   */
+  function watchSession() {
+    withCookieLockAccess({
+      options:options,
+      process: function(cookieSession) {
+        return (!isActiveSession(cookieSession) ? {} : undefined)
+      },
+      after: synchronizeSession,
+    })
+  }
+
+  function synchronizeSession(cookieSession) {
+    if (!isActiveSession(cookieSession)) {
+      cookieSession = {}
+    }
+    if (hasSessionInCache()) {
+      if (isSessionInCacheOutdated(cookieSession)) {
+        expireSession()
+      } else {
+        sessionCache = cookieSession
+      }
+    }
+    return cookieSession
+  }
+
+  function expandOrRenewCookie(cookieSession) {
+    var sessionState= computeSessionState(cookieSession[productKey])
+    var trackingType = sessionState.trackingType
+    var isTracked = sessionState.isTracked
+    cookieSession[productKey] = trackingType
+    if (isTracked && !cookieSession.id) {
+      cookieSession.id = UUID()
+      cookieSession.created = String(dateNow())
+    }
+    return isTracked
+  }
+
+  function hasSessionInCache() {
+    return sessionCache[productKey] !== undefined
+  }
+
+  function isSessionInCacheOutdated(cookieSession) {
+    return sessionCache.id !== cookieSession.id || sessionCache[productKey] !== cookieSession[productKey]
+  }
+
+  function expireSession() {
+    sessionCache = {}
+    expireObservable.notify()
+  }
+
+  function renewSession(cookieSession) {
+    sessionCache = cookieSession
+    renewObservable.notify()
+  }
+
+  function retrieveActiveSession() {
+    var session = retrieveSession()
+    if (isActiveSession(session)) {
+      return session
+    }
+    return {}
+  }
+
+  function isActiveSession(session) {
+    // 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 (
+      (session.created === undefined || dateNow() - Number(session.created) < SESSION_TIME_OUT_DELAY) &&
+      (session.expire === undefined || dateNow() < Number(session.expire))
+    )
+  }
+
+  return {
+    expandOrRenewSession: throttle(expandOrRenewSession, COOKIE_ACCESS_DELAY),
+    expandSession: expandSession,
+    getSession: function() {
+      return sessionCache
+    },
+    renewObservable:renewObservable,
+    expireObservable:expireObservable,
+    stop: function() {
+      clearInterval(watchSessionTimeoutId)
+    },
+  }
+}

package/src/synthetics/syntheticsWorkerValues.js

@@ -0,0 +1,22 @@
+import { getCookie } from '../browser/cookie'
+
+export const SYNTHETICS_TEST_ID_COOKIE_NAME = 'guance-synthetics-public-id'
+export const SYNTHETICS_RESULT_ID_COOKIE_NAME = 'guance-synthetics-result-id'
+export const SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'guance-synthetics-injects-rum'
+
+
+export function willSyntheticsInjectRum() {
+  return Boolean(
+    window._GUANCE_SYNTHETICS_INJECTS_RUM || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME)
+  )
+}
+
+export function getSyntheticsTestId() {
+  var value = window._GUANCE_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME)
+  return typeof value === 'string' ? value : undefined
+}
+
+export function getSyntheticsResultId() {
+  const value = window._GUANCE_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME)
+  return typeof value === 'string' ? value : undefined
+}

package/src/synthetics/usr.js

@@ -0,0 +1,18 @@
+import { getCookie, setCookie } from '../browser/cookie'
+import { ONE_HOUR, UUID } from '../helper/tools'
+
+export var ANONYMOUS_ID_COOKIE_NAME = '_dataflulx_usr_id'
+export var ANONYMOUS_ID_EXPIRATION = 60 * 24 * ONE_HOUR
+
+export var startCacheUsrCache = function(configuration) {
+  var usrCacheId = getCookie(ANONYMOUS_ID_COOKIE_NAME)
+  if (!usrCacheId) {
+    usrCacheId = UUID()
+    setCookie(ANONYMOUS_ID_COOKIE_NAME, usrCacheId, ANONYMOUS_ID_EXPIRATION, configuration.cookieOptions)
+  }
+  return {
+    getUsrId: function() {
+      return usrCacheId
+    }
+  }
+}