@cloudcare/browser-core 2.0.4 → 2.0.5

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()
+      }
+    }
+  }
+}

package/src/transport/httpRequest.js

@@ -1,5 +1,5 @@
 import { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy'
-
+import { addEventListener } from '../browser/addEventListener'
 /**
  * Use POST request without content type to:
  * - avoid CORS preflight requests
@@ -100,10 +100,17 @@ function isKeepAliveSupported() {
 function sendXHR(url, data, onResponse) {
   const request = new XMLHttpRequest()
   request.open('POST', url, true)
-  request.send(data)
-  request.addEventListener('loadend', function () {
-    if (typeof onResponse === 'function') {
-      onResponse({ status: request.status })
+  addEventListener(
+    request,
+    'loadend',
+    function () {
+      if (typeof onResponse === 'function') {
+        onResponse({ status: request.status })
+      }
+    },
+    {
+      once: true
     }
-  })
+  )
+  request.send(data)
 }

package/src/transport/index.js

@@ -1,3 +1,4 @@
 export { createHttpRequest } from './httpRequest'
 export { Batch } from './batch'
 export { startBatchWithReplica } from './startBatchWithReplica'
+export { createFlushController } from './flushController'

package/src/transport/sendWithRetryStrategy.js

@@ -1,11 +1,7 @@
-import {
-  clocksNow,
-  ONE_KIBI_BYTE,
-  ONE_MEBI_BYTE,
-  ONE_SECOND
-} from '../helper/tools'
+import { clocksNow, ONE_SECOND } from '../helper/tools'
+import { ONE_MEBI_BYTE, ONE_KIBI_BYTE } from '../helper/byteUtils'
 import { ErrorSource } from '../helper/errorTools'
-
+import { setTimeout } from '../helper/timer'
 export var MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE
 export var MAX_ONGOING_REQUESTS = 32
 export var MAX_QUEUE_BYTES_COUNT = 3 * ONE_MEBI_BYTE

package/src/transport/startBatchWithReplica.js

@@ -1,11 +1,12 @@
 import { Batch } from './batch'
 import { createHttpRequest } from './httpRequest'
-
+import { createFlushController } from './flushController'
 export function startBatchWithReplica(
   configuration,
   endpointUrl,
   reportError,
-  pageExitObservable
+  pageExitObservable,
+  sessionExpireObservable
 ) {
   var primaryBatch = createBatch(endpointUrl)
 
@@ -16,11 +17,14 @@ export function startBatchWithReplica(
         configuration.batchBytesLimit,
         reportError
       ),
-      configuration.batchMessagesLimit,
-      configuration.batchBytesLimit,
-      configuration.messageBytesLimit,
-      configuration.flushTimeout,
-      pageExitObservable
+      createFlushController({
+        messagesLimit: configuration.batchMessagesLimit,
+        bytesLimit: configuration.batchBytesLimit,
+        durationLimit: configuration.flushTimeout,
+        pageExitObservable: pageExitObservable,
+        sessionExpireObservable: sessionExpireObservable
+      }),
+      configuration.messageBytesLimit
     )
   }
 

package/src/user/index.js

@@ -0,0 +1 @@
+export * from './user'

package/src/user/user.js

@@ -0,0 +1,31 @@
+import { display } from '../helper/display'
+import { assign, getType, each } from '../helper/tools'
+
+/**
+ * Clone input data and ensure known user properties (id, name, email)
+ * are strings, as defined here:
+ * https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/#user-related-attributes
+ */
+export function sanitizeUser(newUser) {
+  // We shallow clone only to prevent mutation of user data.
+  var user = assign({}, newUser)
+  var keys = ['id', 'name', 'email']
+  each(keys, function (key) {
+    if (key in user) {
+      user[key] = String(user[key])
+    }
+  })
+
+  return user
+}
+
+/**
+ * Simple check to ensure user is valid
+ */
+export function checkUser(newUser) {
+  var isValid = getType(newUser) === 'object'
+  if (!isValid) {
+    display.error('Unsupported user:', newUser)
+  }
+  return isValid
+}