@cloudcare/browser-core 2.0.4 → 2.0.6

package/src/report/reportObservable.js

@@ -1,11 +1,12 @@
 import { toStackTraceString } from '../helper/errorTools'
 import { mergeObservables, Observable } from '../helper/observable'
-import { includes, addEventListener, safeTruncate, filter, each } from '../helper/tools'
+import { includes, safeTruncate, filter, each } from '../helper/tools'
+import { addEventListener } from '../browser/addEventListener'
 import { DOM_EVENT } from '../helper/enums'
 export var RawReportType = {
   intervention: 'intervention',
   deprecation: 'deprecation',
-  cspViolation: 'csp_violation',
+  cspViolation: 'csp_violation'
 }
 export function initReportObservable(apis) {
   var observables = []
@@ -14,7 +15,9 @@ export function initReportObservable(apis) {
     observables.push(createCspViolationReportObservable())
   }
 
-  var reportTypes = filter(apis, function(api) { return api !== RawReportType.cspViolation })
+  var reportTypes = filter(apis, function (api) {
+    return api !== RawReportType.cspViolation
+  })
   if (reportTypes.length) {
     observables.push(createReportObservable(reportTypes))
   }
@@ -22,24 +25,24 @@ export function initReportObservable(apis) {
 }
 
 function createReportObservable(reportTypes) {
-  var observable = new Observable(function() {
+  var observable = new Observable(function () {
     if (!window.ReportingObserver) {
       return
     }
 
-    var handleReports = function(reports) {
-      each(reports, function(report) {
+    var handleReports = function (reports) {
+      each(reports, function (report) {
         observable.notify(buildRawReportFromReport(report))
       })
     }
 
     var observer = new window.ReportingObserver(handleReports, {
       types: reportTypes,
-      buffered: true,
+      buffered: true
     })
 
     observer.observe()
-    return function() {
+    return function () {
       observer.disconnect()
     }
   })
@@ -48,12 +51,16 @@ function createReportObservable(reportTypes) {
 }
 
 function createCspViolationReportObservable() {
-  var observable = new Observable(function() {
-    var handleCspViolation = function(event) {
+  var observable = new Observable(function () {
+    var handleCspViolation = function (event) {
       observable.notify(buildRawReportFromCspViolation(event))
     }
 
-    var _addEventListener = addEventListener(document, DOM_EVENT.SECURITY_POLICY_VIOLATION, handleCspViolation)
+    var _addEventListener = addEventListener(
+      document,
+      DOM_EVENT.SECURITY_POLICY_VIOLATION,
+      handleCspViolation
+    )
 
     return _addEventListener.stop
   })
@@ -67,34 +74,42 @@ function buildRawReportFromReport(report) {
     type: type,
     subtype: body.id,
     message: type + ': ' + body.message,
-    stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),
+    stack: buildStack(
+      body.id,
+      body.message,
+      body.sourceFile,
+      body.lineNumber,
+      body.columnNumber
+    )
   }
 }
 
 function buildRawReportFromCspViolation(event) {
   var type = RawReportType.cspViolation
-  var message = '\''+ event.blockedURI + '\' blocked by \'' + event.effectiveDirective + '\' directive'
+  var message =
+    "'" +
+    event.blockedURI +
+    "' blocked by '" +
+    event.effectiveDirective +
+    "' directive"
   return {
     type: RawReportType.cspViolation,
     subtype: event.effectiveDirective,
     message: type + ': ' + message,
     stack: buildStack(
       event.effectiveDirective,
-      message + ' of the policy "'+ safeTruncate(event.originalPolicy, 100, '...') + '"',
+      message +
+        ' of the policy "' +
+        safeTruncate(event.originalPolicy, 100, '...') +
+        '"',
       event.sourceFile,
       event.lineNumber,
       event.columnNumber
-    ),
+    )
   }
 }
 
-function buildStack(
-  name,
-  message,
-  sourceFile,
-  lineNumber,
-  columnNumber
-){
+function buildStack(name, message, sourceFile, lineNumber, columnNumber) {
   return (
     sourceFile &&
     toStackTraceString({
@@ -105,9 +120,9 @@ function buildStack(
           func: '?',
           url: sourceFile,
           line: lineNumber,
-          column: columnNumber,
-        },
-      ],
+          column: columnNumber
+        }
+      ]
     })
   )
 }

package/src/session/sessionCookieStore.js

@@ -1,7 +1,15 @@
 import { getCookie, setCookie } from '../browser/cookie'
-import { isChromium, dateNow, isEmptyObject, UUID, objectEntries,map, each, } from '../helper/tools'
+import {
+  isChromium,
+  dateNow,
+  isEmptyObject,
+  UUID,
+  objectEntries,
+  map,
+  each
+} from '../helper/tools'
 import { SESSION_EXPIRATION_DELAY } from './sessionConstants'
-
+import { setTimeout } from '../helper/timer'
 var SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/
 var SESSION_ENTRY_SEPARATOR = '&'
 
@@ -11,8 +19,7 @@ export var SESSION_COOKIE_NAME = '_dataflux_s'
 export var LOCK_RETRY_DELAY = 10
 export var MAX_NUMBER_OF_LOCK_RETRIES = 100
 
-
-var bufferedOperations= []
+var bufferedOperations = []
 var ongoingOperations
 
 export function withCookieLockAccess(operations, numberOfRetries) {
@@ -93,12 +100,9 @@ function isCookieLockEnabled() {
 }
 
 function retryLater(operations, currentNumberOfRetries) {
-  setTimeout(
-    function() {
-      withCookieLockAccess(operations, currentNumberOfRetries + 1)
-    },
-    LOCK_RETRY_DELAY
-  )
+  setTimeout(function () {
+    withCookieLockAccess(operations, currentNumberOfRetries + 1)
+  }, LOCK_RETRY_DELAY)
 }
 
 function next() {
@@ -119,11 +123,16 @@ export function persistSession(session, options) {
 }
 
 function setSession(session, options) {
-  setCookie(SESSION_COOKIE_NAME, toSessionString(session), SESSION_EXPIRATION_DELAY, options)
+  setCookie(
+    SESSION_COOKIE_NAME,
+    toSessionString(session),
+    SESSION_EXPIRATION_DELAY,
+    options
+  )
 }
 
 export function toSessionString(session) {
-  return map(objectEntries(session), function(item) {
+  return map(objectEntries(session), function (item) {
     return item[0] + '=' + item[1]
   }).join(SESSION_ENTRY_SEPARATOR)
 }
@@ -132,7 +141,7 @@ export function retrieveSession() {
   var sessionString = getCookie(SESSION_COOKIE_NAME)
   var session = {}
   if (isValidSessionString(sessionString)) {
-    each(sessionString.split(SESSION_ENTRY_SEPARATOR), function(entry) {
+    each(sessionString.split(SESSION_ENTRY_SEPARATOR), function (entry) {
       var matches = SESSION_ENTRY_REGEXP.exec(entry)
       if (matches !== null) {
         var key = matches[1]
@@ -147,7 +156,8 @@ export function retrieveSession() {
 function isValidSessionString(sessionString) {
   return (
     sessionString !== undefined &&
-    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString))
+    (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 ||
+      SESSION_ENTRY_REGEXP.test(sessionString))
   )
 }
 

package/src/session/sessionManagement.js

@@ -1,63 +1,68 @@
-import { relativeNow, clocksOrigin, ONE_MINUTE, each, addEventListeners, addEventListener } from '../helper/tools'
+import { relativeNow, clocksOrigin, ONE_MINUTE, each } from '../helper/tools'
+import {
+  addEventListeners,
+  addEventListener
+} from '../browser/addEventListener'
 import { ContextHistory } from '../helper/contextHistory'
 import { startSessionStore } from './sessionStore'
 import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
 import { DOM_EVENT } from '../helper/enums'
-
+import { clearInterval, setInterval } from '../helper/timer'
 export var VISIBILITY_CHECK_DELAY = ONE_MINUTE
 var SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY
 var stopCallbacks = []
 
-export var startSessionManager = function(
+export var startSessionManager = function (
   options,
   productKey,
   computeSessionState
 ) {
   var sessionStore = startSessionStore(options, productKey, computeSessionState)
-  stopCallbacks.push(function() {
+  stopCallbacks.push(function () {
     return sessionStore.stop()
   })
 
   var sessionContextHistory = new ContextHistory(SESSION_CONTEXT_TIMEOUT_DELAY)
-  stopCallbacks.push(function() {
+  stopCallbacks.push(function () {
     return sessionContextHistory.stop()
   })
 
-  sessionStore.renewObservable.subscribe(function(){
+  sessionStore.renewObservable.subscribe(function () {
     sessionContextHistory.add(buildSessionContext(), relativeNow())
   })
-  sessionStore.expireObservable.subscribe(function() {
+  sessionStore.expireObservable.subscribe(function () {
     sessionContextHistory.closeActive(relativeNow())
   })
 
   sessionStore.expandOrRenewSession()
   sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative)
 
-  trackActivity(function() { 
+  trackActivity(function () {
     return sessionStore.expandOrRenewSession()
   })
-  trackVisibility(function() {
+  trackVisibility(function () {
     return sessionStore.expandSession()
   })
 
   function buildSessionContext() {
     return {
       id: sessionStore.getSession().id,
-      trackingType: sessionStore.getSession()[productKey],
+      trackingType: sessionStore.getSession()[productKey]
     }
   }
 
   return {
-    findActiveSession: function(startTime) {
+    findActiveSession: function (startTime) {
       return sessionContextHistory.find(startTime)
     },
     renewObservable: sessionStore.renewObservable,
     expireObservable: sessionStore.expireObservable,
+    expire: sessionStore.expire
   }
 }
 
 export function stopSessionManager() {
-  each(stopCallbacks, function(e) {
+  each(stopCallbacks, function (e) {
     return e()
   })
   stopCallbacks = []
@@ -66,7 +71,12 @@ export function stopSessionManager() {
 function trackActivity(expandOrRenewSession) {
   var _addEventListeners = addEventListeners(
     window,
-    [DOM_EVENT.CLICK,DOM_EVENT.TOUCH_START, DOM_EVENT.KEY_DOWN, DOM_EVENT.SCROLL],
+    [
+      DOM_EVENT.CLICK,
+      DOM_EVENT.TOUCH_START,
+      DOM_EVENT.KEY_DOWN,
+      DOM_EVENT.SCROLL
+    ],
     expandOrRenewSession,
     { capture: true, passive: true }
   )
@@ -74,16 +84,23 @@ function trackActivity(expandOrRenewSession) {
 }
 
 function trackVisibility(expandSession) {
-  var expandSessionWhenVisible = function() {
+  var expandSessionWhenVisible = function () {
     if (document.visibilityState === 'visible') {
       expandSession()
     }
   }
-  var _addEventListener= addEventListener(document, DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible)
+  var _addEventListener = addEventListener(
+    document,
+    DOM_EVENT.VISIBILITY_CHANGE,
+    expandSessionWhenVisible
+  )
   stopCallbacks.push(_addEventListener.stop)
 
-  var visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY)
-  stopCallbacks.push(function() {
+  var visibilityCheckInterval = setInterval(
+    expandSessionWhenVisible,
+    VISIBILITY_CHECK_DELAY
+  )
+  stopCallbacks.push(function () {
     clearInterval(visibilityCheckInterval)
   })
 }

package/src/session/sessionStore.js

@@ -3,6 +3,7 @@ import { Observable } from '../helper/observable'
 import { dateNow, UUID, throttle } from '../helper/tools'
 import { SESSION_TIME_OUT_DELAY } from './sessionConstants'
 import { retrieveSession, withCookieLockAccess } from './sessionCookieStore'
+import { clearInterval, setInterval } from '../helper/timer'
 
 /**
  * Different session concepts:
@@ -67,7 +68,7 @@ export function startSessionStore(options, productKey, computeSessionState) {
     }
     if (hasSessionInCache()) {
       if (isSessionInCacheOutdated(cookieSession)) {
-        expireSession()
+        expireSessionInCache()
       } else {
         sessionCache = cookieSession
       }
@@ -98,7 +99,7 @@ export function startSessionStore(options, productKey, computeSessionState) {
     )
   }
 
-  function expireSession() {
+  function expireSessionInCache() {
     sessionCache = {}
     expireObservable.notify()
   }
@@ -135,6 +136,10 @@ export function startSessionStore(options, productKey, computeSessionState) {
     },
     renewObservable: renewObservable,
     expireObservable: expireObservable,
+    expire: function () {
+      deleteSessionCookie(options)
+      synchronizeSession({})
+    },
     stop: function () {
       clearInterval(watchSessionTimeoutId)
     }

package/src/transport/batch.js

@@ -1,10 +1,7 @@
 import { display } from '../helper/display'
 import {
-  addEventListener,
-  noop,
   values,
   findByPath,
-  escapeRowData,
   each,
   isNumber,
   isArray,
@@ -13,12 +10,17 @@ import {
   toServerDuration,
   isBoolean,
   isEmptyObject,
-  isObject,
-  escapeJsonValue,
-  escapeRowField
+  isObject
 } from '../helper/tools'
+import {
+  escapeJsonValue,
+  escapeRowField,
+  escapeRowData
+} from '../helper/serialisation/rowData'
 import { commonTags, dataMap, commonFields } from '../dataMap'
-import { DOM_EVENT, RumEventType } from '../helper/enums'
+import { RumEventType } from '../helper/enums'
+import { computeBytesCount } from '../helper/byteUtils'
+import { isPageExitReason } from '../browser/pageExitObservable'
 // https://en.wikipedia.org/wiki/UTF-8
 // eslint-disable-next-line no-control-regex
 var HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/
@@ -133,28 +135,16 @@ export var processedMessageByDataMap = function (message) {
     rowData: hasFileds ? rowData : undefined
   }
 }
-var batch = function (
-  request,
-  batchMessagesLimit,
-  batchBytesLimit,
-  messageBytesLimit,
-  flushTimeout,
-  pageExitObservable
-) {
+var batch = function (request, flushController, messageBytesLimit) {
   this.pushOnlyBuffer = []
   this.upsertBuffer = {}
-  this.bufferBytesCount = 0
-  this.bufferMessagesCount = 0
   this.request = request
-  this.batchMessagesLimit = batchMessagesLimit
-  this.batchBytesLimit = batchBytesLimit
+  this.flushController = flushController
   this.messageBytesLimit = messageBytesLimit
-  this.flushTimeout = flushTimeout
   var _this = this
-  pageExitObservable.subscribe(function () {
-    _this.flush(_this.request.sendOnExit)
+  this.flushController.flushObservable.subscribe(function (event) {
+    _this.flush(event)
   })
-  this.flushPeriodically()
 }
 batch.prototype.add = function (message) {
   this.addOrUpdate(message)
@@ -162,37 +152,24 @@ batch.prototype.add = function (message) {
 batch.prototype.upsert = function (message, key) {
   this.addOrUpdate(message, key)
 }
-batch.prototype.flush = function (sendFn) {
-  if (typeof sendFn !== 'function') {
-    sendFn = this.request.send
-  }
-  if (this.bufferMessagesCount !== 0) {
-    var messages = this.pushOnlyBuffer.concat(values(this.upsertBuffer))
-    var bytesCount = this.bufferBytesCount
-    this.pushOnlyBuffer = []
-    this.upsertBuffer = {}
-    this.bufferBytesCount = 0
-    this.bufferMessagesCount = 0
-    if (messages.length > 0) {
-      sendFn({ data: messages.join('\n'), bytesCount: bytesCount })
+batch.prototype.flush = function (event) {
+  var messages = this.pushOnlyBuffer.concat(values(this.upsertBuffer))
+  this.pushOnlyBuffer = []
+  this.upsertBuffer = {}
+  if (messages.length > 0) {
+    var payload = {
+      data: messages.join('\n'),
+      bytesCount: event.bytesCount,
+      flushReason: event.reason
+    }
+    if (isPageExitReason(event.reason)) {
+      this.request.sendOnExit(payload)
+    } else {
+      this.request.send(payload)
     }
   }
 }
-batch.prototype.flushOnExit = function () {
-  this.flush(this.request.sendOnExit)
-}
-batch.prototype.computeBytesCount = function (candidate) {
-  // Accurate bytes count computations can degrade performances when there is a lot of events to process
-  if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {
-    return candidate.length
-  }
-
-  if (window.TextEncoder !== undefined) {
-    return new TextEncoder().encode(candidate).length
-  }
 
-  return new Blob([candidate]).size
-}
 batch.prototype.addOrUpdate = function (message, key) {
   var _process = this.process(message)
   var processedMessage = _process.processedMessage
@@ -208,18 +185,11 @@ batch.prototype.addOrUpdate = function (message, key) {
   if (this.hasMessageFor(key)) {
     this.remove(key)
   }
-  if (this.willReachedBytesLimitWith(messageBytesCount)) {
-    this.flush()
-  }
-
   this.push(processedMessage, messageBytesCount, key)
-  if (this.isFull()) {
-    this.flush()
-  }
 }
 batch.prototype.process = function (message) {
   var processedMessage = processedMessageByDataMap(message).rowStr
-  var messageBytesCount = this.computeBytesCount(processedMessage)
+  var messageBytesCount = computeBytesCount(processedMessage)
   return {
     processedMessage: processedMessage,
     messageBytesCount: messageBytesCount
@@ -227,52 +197,30 @@ batch.prototype.process = function (message) {
 }
 
 batch.prototype.push = function (processedMessage, messageBytesCount, key) {
-  if (this.bufferMessagesCount > 0) {
-    // \n separator at serialization
-    this.bufferBytesCount += 1
-  }
+  var separatorBytesCount = this.flushController.getMessagesCount() > 0 ? 1 : 0
+  this.flushController.notifyBeforeAddMessage(
+    messageBytesCount + separatorBytesCount
+  )
   if (key !== undefined) {
     this.upsertBuffer[key] = processedMessage
   } else {
     this.pushOnlyBuffer.push(processedMessage)
   }
-  this.bufferBytesCount += messageBytesCount
-  this.bufferMessagesCount += 1
+  this.flushController.notifyAfterAddMessage()
 }
 
 batch.prototype.remove = function (key) {
   var removedMessage = this.upsertBuffer[key]
   delete this.upsertBuffer[key]
-  var messageBytesCount = this.computeBytesCount(removedMessage)
-  this.bufferBytesCount -= messageBytesCount
-  this.bufferMessagesCount -= 1
-  if (this.bufferMessagesCount > 0) {
-    this.bufferBytesCount -= 1
-  }
+  var messageBytesCount = computeBytesCount(removedMessage)
+  // If there are other messages, a '\n' will be added at serialization
+  var separatorBytesCount = this.flushController.getMessagesCount() > 1 ? 1 : 0
+  this.flushController.notifyAfterRemoveMessage(
+    messageBytesCount + separatorBytesCount
+  )
 }
 
 batch.prototype.hasMessageFor = function (key) {
   return key !== undefined && this.upsertBuffer[key] !== undefined
 }
-
-batch.prototype.willReachedBytesLimitWith = function (messageBytesCount) {
-  // byte of the separator at the end of the message
-  return this.bufferBytesCount + messageBytesCount + 1 >= this.batchBytesLimit
-}
-
-batch.prototype.isFull = function () {
-  return (
-    this.bufferMessagesCount === this.batchMessagesLimit ||
-    this.bufferBytesCount >= this.batchBytesLimit
-  )
-}
-
-batch.prototype.flushPeriodically = function () {
-  var _this = this
-  setTimeout(function () {
-    _this.flush()
-    _this.flushPeriodically()
-  }, this.flushTimeout)
-}
-
 export var Batch = batch

package/src/transport/flushController.js

@@ -0,0 +1,115 @@
+import { Observable } from '../helper/observable'
+import { clearTimeout, setTimeout } from '../helper/timer'
+
+// type FlushReason = PageExitReason | 'duration_limit' | 'bytes_limit' | 'messages_limit' | 'session_expire'
+
+/**
+ * Returns a "flush controller", responsible of notifying when flushing a pool of pending data needs
+ * to happen. The implementation is designed to support both synchronous and asynchronous usages,
+ * but relies on invariants described in each method documentation to keep a coherent state.
+ */
+export function createFlushController({
+  messagesLimit,
+  bytesLimit,
+  durationLimit,
+  pageExitObservable,
+  sessionExpireObservable
+}) {
+  var flushObservable = new Observable()
+
+  pageExitObservable.subscribe(function (event) {
+    return flush(event.reason)
+  })
+  sessionExpireObservable.subscribe(function () {
+    return flush('session_expire')
+  })
+
+  var currentBytesCount = 0
+  var currentMessagesCount = 0
+
+  function flush(flushReason) {
+    if (currentMessagesCount === 0) {
+      return
+    }
+
+    var messagesCount = currentMessagesCount
+    var bytesCount = currentBytesCount
+
+    currentMessagesCount = 0
+    currentBytesCount = 0
+    cancelDurationLimitTimeout()
+
+    flushObservable.notify({
+      reason: flushReason,
+      messagesCount: messagesCount,
+      bytesCount: bytesCount
+    })
+  }
+
+  var durationLimitTimeoutId
+  function scheduleDurationLimitTimeout() {
+    if (durationLimitTimeoutId === undefined) {
+      durationLimitTimeoutId = setTimeout(function () {
+        flush('duration_limit')
+      }, durationLimit)
+    }
+  }
+
+  function cancelDurationLimitTimeout() {
+    clearTimeout(durationLimitTimeoutId)
+    durationLimitTimeoutId = undefined
+  }
+
+  return {
+    flushObservable: flushObservable,
+    getMessagesCount: function () {
+      return currentMessagesCount
+    },
+
+    /**
+     * Notifies that a message will be added to a pool of pending messages waiting to be flushed.
+     *
+     * This function needs to be called synchronously, right before adding the message, so no flush
+     * event can happen after `notifyBeforeAddMessage` and before adding the message.
+     */
+    notifyBeforeAddMessage: function (messageBytesCount) {
+      if (currentBytesCount + messageBytesCount >= bytesLimit) {
+        flush('bytes_limit')
+      }
+      // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no
+      // message was added yet and `notifyAfterAddMessage` is called asynchronously, we still want
+      // to notify when a flush is needed (for example on page exit).
+      currentMessagesCount += 1
+      currentBytesCount += messageBytesCount
+      scheduleDurationLimitTimeout()
+    },
+
+    /**
+     * Notifies that a message *was* added to a pool of pending messages waiting to be flushed.
+     *
+     * This function can be called asynchronously after the message was added, but in this case it
+     * should not be called if a flush event occurred in between.
+     */
+    notifyAfterAddMessage: function () {
+      if (currentMessagesCount >= messagesLimit) {
+        flush('messages_limit')
+      } else if (currentBytesCount >= bytesLimit) {
+        flush('bytes_limit')
+      }
+    },
+
+    /**
+     * Notifies that a message was removed from a pool of pending messages waiting to be flushed.
+     *
+     * This function needs to be called synchronously, right after removing the message, so no flush
+     * event can happen after removing the message and before `notifyAfterRemoveMessage`.
+     */
+    notifyAfterRemoveMessage: function (messageBytesCount) {
+      currentBytesCount -= messageBytesCount
+      currentMessagesCount -= 1
+      if (currentMessagesCount === 0) {
+        cancelDurationLimitTimeout()
+      }
+    }
+  }
+}