@cloudcare/browser-core 3.2.28 → 3.2.30

package/src/session/sessionStore.js

@@ -1,5 +1,6 @@
 import { clearInterval, setInterval } from '../helper/timer'
 import { Observable } from '../helper/observable'
+import { display } from '../helper/display'
 import { ONE_SECOND, dateNow, throttle, UUID, assign } from '../helper/tools'
 import { selectCookieStrategy, initCookieStrategy } from './sessionInCookie'
 import {
@@ -13,6 +14,7 @@ import {
   selectLocalStorageStrategy
 } from './sessionInLocalStorage'
 import { processSessionStoreOperations } from './sessionStoreOperations'
+import { SessionPersistence } from './sessionConstants'
 
 /**
  * Every second, the storage will be polled to check for any change that can occur
@@ -26,14 +28,31 @@ export const STORAGE_POLL_DELAY = ONE_SECOND
  * Else, checks if LocalStorage is allowed and available
  */
 export function selectSessionStoreStrategyType(initConfiguration) {
-  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
 }
 
 /**
@@ -51,7 +70,7 @@ export function startSessionStore(
   const expireObservable = new Observable()
   const sessionStateUpdateObservable = new Observable()
   const sessionStoreStrategy =
-    sessionStoreStrategyType.type === 'Cookie'
+    sessionStoreStrategyType.type === SessionPersistence.COOKIE
       ? initCookieStrategy(sessionStoreStrategyType.cookieOptions)
       : initLocalStorageStrategy()
   const { expireSession } = sessionStoreStrategy

package/src/session/sessionStoreOperations.js

@@ -1,13 +1,20 @@
 import { setTimeout } from '../helper/timer'
-import { UUID, assign } from '../helper/tools'
 import {
-  expandSessionState,
-  isSessionInExpiredState,
-  isSessionInNotStartedState
-} from './sessionState'
-
+  UUID,
+  assign,
+  ONE_SECOND,
+  timeStampNow,
+  elapsed
+} from '../helper/tools'
+import { expandSessionState, isSessionInExpiredState } from './sessionState'
+import { addTelemetryDebug } from '../telemetry/telemetry'
 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 = []
 let ongoingOperations
 
@@ -21,15 +28,11 @@ export function processSessionStoreOperations(
     return persistSession(assign({}, session, { lock: currentLock }))
   }
   const retrieveStore = function () {
-    const session = sessionStoreStrategy.retrieveSession()
-    const lock = session.lock
-    if (session.lock) {
-      delete session.lock
-    }
+    const { lock, ...session } = sessionStoreStrategy.retrieveSession()
 
     return {
       session,
-      lock
+      lock: lock && !isLockExpired(lock) ? lock : undefined
     }
   }
 
@@ -41,6 +44,9 @@ export function processSessionStoreOperations(
     return
   }
   if (isLockEnabled && numberOfRetries >= LOCK_MAX_TRIES) {
+    addTelemetryDebug('Aborted session operation after max lock retries', {
+      currentStore: retrieveStore()
+    })
     next(sessionStoreStrategy)
     return
   }
@@ -53,7 +59,7 @@ export function processSessionStoreOperations(
       return
     }
     // acquire lock
-    currentLock = UUID()
+    currentLock = createLock()
     persistWithLock(currentStore.session)
     // if lock is not acquired, retry later
     currentStore = retrieveStore()
@@ -120,3 +126,15 @@ function next(sessionStore) {
     processSessionStoreOperations(nextOperations, sessionStore)
   }
 }
+
+export function createLock() {
+  return UUID() + LOCK_SEPARATOR + timeStampNow()
+}
+
+function isLockExpired(lock) {
+  const [, timeStamp] = lock.split(LOCK_SEPARATOR)
+  return (
+    !timeStamp ||
+    elapsed(Number(timeStamp), timeStampNow()) > LOCK_EXPIRATION_DELAY
+  )
+}

package/src/transport/batch.js

@@ -234,9 +234,8 @@ export function createBatch(options) {
       if (encoderResult.outputBytesCount) {
         send(formatPayloadFromEncoder(encoderResult, sendContentTypeByJson))
       }
-
       // Send messages that are not yet encoded at this point
-      var pendingMessages = [encoderResult.pendingData, upsertMessages]
+      var pendingMessages = [...encoderResult.pendingData, upsertMessages]
         .filter(Boolean)
         .join('\n')
 

package/src/transport/httpRequest.js

@@ -104,22 +104,28 @@ export function fetchKeepAliveStrategy(
       keepalive: true,
       mode: 'cors'
     }
+    const headers = {
+      'x-client-timestamp': Date.now().toString()
+    }
+
     if (payload.type) {
-      fetchOption.headers = {
-        'Content-Type': payload.type
-      }
+      headers['Content-Type'] = payload.type
     }
-    fetch(url, fetchOption).then(
-      monitor(function (response) {
-        if (typeof onResponse === 'function') {
-          onResponse({ status: response.status, type: response.type })
-        }
-      }),
-      monitor(function () {
-        // failed to queue the request
-        sendXHR(url, payload, onResponse)
-      })
-    )
+
+    fetchOption.headers = headers
+    fetch(url, fetchOption)
+      .then(
+        monitor(function (response) {
+          if (typeof onResponse === 'function') {
+            onResponse({ status: response.status, type: response.type })
+          }
+        })
+      )
+      .catch(
+        monitor(function () {
+          fetchStrategy(url, payload, onResponse)
+        })
+      )
   } else {
     sendXHR(url, payload, onResponse)
   }
@@ -143,7 +149,7 @@ function sendXHR(url, payload, onResponse) {
   } else if (payload.type) {
     request.setRequestHeader('Content-Type', payload.type)
   }
-
+  request.setRequestHeader('x-client-timestamp', Date.now().toString())
   addEventListener(
     request,
     'loadend',
@@ -158,3 +164,34 @@ function sendXHR(url, payload, onResponse) {
   )
   request.send(data)
 }
+function fetchStrategy(url, payload, onResponse) {
+  const fetchOption = {
+    method: 'POST',
+    body: payload.data,
+    keepalive: true,
+    mode: 'cors'
+  }
+  const headers = {
+    'x-client-timestamp': Date.now().toString()
+  }
+  if (payload.type) {
+    headers['Content-Type'] = payload.type
+  }
+  fetchOption.headers = headers
+
+  fetch(url, fetchOption)
+    .then(
+      monitor(function (response) {
+        if (typeof onResponse === 'function') {
+          onResponse({ status: response.status, type: response.type })
+        }
+      })
+    )
+    .catch(
+      monitor(function () {
+        if (typeof onResponse === 'function') {
+          onResponse({ status: 0 })
+        }
+      })
+    )
+}

package/types/index.d.ts

@@ -7,6 +7,8 @@ export interface User {
   name?: string | undefined
   [key: string]: unknown
 }
+export type SessionPersistence = 'cookie' | 'local-storage'
+
 export declare const ConsoleApiName: {
   readonly log: 'log'
   readonly debug: 'debug'
@@ -91,6 +93,13 @@ export interface InitConfiguration {
    * When cookies are not available, you can enable this option to store data in localStorage
    */
   allowFallbackToLocalStorage?: boolean | undefined
+  /**
+   * Which storage strategy to use for persisting sessions. Can be either 'cookie' or 'local-storage'.
+   *
+   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values
+   * @default "cookie"
+   */
+  sessionPersistence?: SessionPersistence | undefined
 }
 export enum TraceType {
   DDTRACE = 'ddtrace',
@@ -118,7 +127,7 @@ export const NodePrivacyLevel = {
 } as const
 export type NodePrivacyLevel =
   (typeof NodePrivacyLevel)[keyof typeof NodePrivacyLevel]
-
+export type OriginMatchOption = string | RegExp
 export type MatchOption = string | RegExp | ((value: string) => boolean)
 export type TracingOption = {
   match: MatchOption
@@ -145,11 +154,16 @@ export interface RumBaseInitConfiguration extends InitConfiguration {
    * https://docs.truewatch.com/security/page-performance/#_3
    */
   excludedActivityUrls?: MatchOption[] | undefined
+  /**
+       * List of all requests allowed to inject trace collector required headers. For example:
+       ["https://api.example.com/test", /https:\\/\\/.*\\.my-api-domain\\.com/, (url) => { return true }].
+      */
+  allowedTracingUrls?: Array<MatchOption | TracingOption> | undefined
   /**
        * List of all requests allowed to inject trace collector required headers. Can be the request origin or a regex. Origin: protocol (including ://), domain name (or IP address) [and port number]. For example:
        ["https://api.example.com", /https:\\/\\/.*\\.my-api-domain\\.com/].
       */
-  allowedTracingUrls?: Array<MatchOption | TracingOption> | undefined
+  allowedTracingOrigins?: Array<OriginMatchOption> | undefined
   defaultPrivacyLevel?: DefaultPrivacyLevel | undefined
   /**
    * Error session compensation sample rate: