@cloudcare/browser-core 2.0.3 → 2.0.5

package/cjs/session/sessionManagement.js

@@ -8,6 +8,8 @@ exports.stopSessionManager = stopSessionManager;
 
 var _tools = require("../helper/tools");
 
+var _addEventListener2 = require("../browser/addEventListener");
+
 var _contextHistory = require("../helper/contextHistory");
 
 var _sessionStore = require("./sessionStore");
@@ -16,6 +18,8 @@ var _sessionConstants = require("./sessionConstants");
 
 var _enums = require("../helper/enums");
 
+var _timer = require("../helper/timer");
+
 var VISIBILITY_CHECK_DELAY = _tools.ONE_MINUTE;
 exports.VISIBILITY_CHECK_DELAY = VISIBILITY_CHECK_DELAY;
 var SESSION_CONTEXT_TIMEOUT_DELAY = _sessionConstants.SESSION_TIME_OUT_DELAY;
@@ -57,7 +61,8 @@ var startSessionManager = function startSessionManager(options, productKey, comp
       return sessionContextHistory.find(startTime);
     },
     renewObservable: sessionStore.renewObservable,
-    expireObservable: sessionStore.expireObservable
+    expireObservable: sessionStore.expireObservable,
+    expire: sessionStore.expire
   };
 };
 
@@ -71,7 +76,7 @@ function stopSessionManager() {
 }
 
 function trackActivity(expandOrRenewSession) {
-  var _addEventListeners = (0, _tools.addEventListeners)(window, [_enums.DOM_EVENT.CLICK, _enums.DOM_EVENT.TOUCH_START, _enums.DOM_EVENT.KEY_DOWN, _enums.DOM_EVENT.SCROLL], expandOrRenewSession, {
+  var _addEventListeners = (0, _addEventListener2.addEventListeners)(window, [_enums.DOM_EVENT.CLICK, _enums.DOM_EVENT.TOUCH_START, _enums.DOM_EVENT.KEY_DOWN, _enums.DOM_EVENT.SCROLL], expandOrRenewSession, {
     capture: true,
     passive: true
   });
@@ -86,11 +91,11 @@ function trackVisibility(expandSession) {
     }
   };
 
-  var _addEventListener = (0, _tools.addEventListener)(document, _enums.DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible);
+  var _addEventListener = (0, _addEventListener2.addEventListener)(document, _enums.DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible);
 
   stopCallbacks.push(_addEventListener.stop);
-  var visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);
+  var visibilityCheckInterval = (0, _timer.setInterval)(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);
   stopCallbacks.push(function () {
-    clearInterval(visibilityCheckInterval);
+    (0, _timer.clearInterval)(visibilityCheckInterval);
   });
 }

package/cjs/session/sessionStore.js

@@ -15,6 +15,8 @@ var _sessionConstants = require("./sessionConstants");
 
 var _sessionCookieStore = require("./sessionCookieStore");
 
+var _timer = require("../helper/timer");
+
 /**
  * Different session concepts:
  * - tracked, the session has an id and is updated along the user navigation
@@ -24,7 +26,7 @@ var _sessionCookieStore = require("./sessionCookieStore");
 function startSessionStore(options, productKey, computeSessionState) {
   var renewObservable = new _observable.Observable();
   var expireObservable = new _observable.Observable();
-  var watchSessionTimeoutId = setInterval(watchSession, _cookie.COOKIE_ACCESS_DELAY);
+  var watchSessionTimeoutId = (0, _timer.setInterval)(watchSession, _cookie.COOKIE_ACCESS_DELAY);
   var sessionCache = retrieveActiveSession();
 
   function expandOrRenewSession() {
@@ -78,7 +80,7 @@ function startSessionStore(options, productKey, computeSessionState) {
 
     if (hasSessionInCache()) {
       if (isSessionInCacheOutdated(cookieSession)) {
-        expireSession();
+        expireSessionInCache();
       } else {
         sessionCache = cookieSession;
       }
@@ -109,7 +111,7 @@ function startSessionStore(options, productKey, computeSessionState) {
     return sessionCache.id !== cookieSession.id || sessionCache[productKey] !== cookieSession[productKey];
   }
 
-  function expireSession() {
+  function expireSessionInCache() {
     sessionCache = {};
     expireObservable.notify();
   }
@@ -143,8 +145,12 @@ function startSessionStore(options, productKey, computeSessionState) {
     },
     renewObservable: renewObservable,
     expireObservable: expireObservable,
+    expire: function expire() {
+      deleteSessionCookie(options);
+      synchronizeSession({});
+    },
     stop: function stop() {
-      clearInterval(watchSessionTimeoutId);
+      (0, _timer.clearInterval)(watchSessionTimeoutId);
     }
   };
 }

package/cjs/transport/batch.js

@@ -9,10 +9,16 @@ var _display = require("../helper/display");
 
 var _tools = require("../helper/tools");
 
+var _rowData = require("../helper/serialisation/rowData");
+
 var _dataMap = require("../dataMap");
 
 var _enums = require("../helper/enums");
 
+var _byteUtils = require("../helper/byteUtils");
+
+var _pageExitObservable = require("../browser/pageExitObservable");
+
 // https://en.wikipedia.org/wiki/UTF-8
 // eslint-disable-next-line no-control-regex
 var HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/;
@@ -43,8 +49,8 @@ var processedMessageByDataMap = function processedMessageByDataMap(message) {
         filterFileds.push(_key);
 
         if (_value || (0, _tools.isNumber)(_value)) {
-          rowData.tags[_key] = (0, _tools.escapeJsonValue)(_value);
-          tagsStr.push((0, _tools.escapeRowData)(_key) + '=' + (0, _tools.escapeRowData)(_value));
+          rowData.tags[_key] = (0, _rowData.escapeJsonValue)(_value);
+          tagsStr.push((0, _rowData.escapeRowData)(_key) + '=' + (0, _rowData.escapeRowData)(_value));
         }
       });
       var fieldsStr = [];
@@ -67,7 +73,7 @@ var processedMessageByDataMap = function processedMessageByDataMap(message) {
             //       '"'
             //     : escapeRowData(_valueData)
 
-            fieldsStr.push((0, _tools.escapeRowData)(_key) + '=' + (0, _tools.escapeRowField)(_valueData));
+            fieldsStr.push((0, _rowData.escapeRowData)(_key) + '=' + (0, _rowData.escapeRowField)(_valueData));
           }
         } else if ((0, _tools.isString)(_value)) {
           var _valueData = (0, _tools.findByPath)(message, _value);
@@ -77,7 +83,7 @@ var processedMessageByDataMap = function processedMessageByDataMap(message) {
           if (_valueData || (0, _tools.isNumber)(_valueData)) {
             rowData.fields[_key] = _valueData; // 这里不需要转译
 
-            fieldsStr.push((0, _tools.escapeRowData)(_key) + '=' + (0, _tools.escapeRowField)(_valueData));
+            fieldsStr.push((0, _rowData.escapeRowData)(_key) + '=' + (0, _rowData.escapeRowField)(_valueData));
           }
         }
       });
@@ -95,13 +101,13 @@ var processedMessageByDataMap = function processedMessageByDataMap(message) {
 
             rowData.fields[_key] = _value; // 这里不需要转译
 
-            fieldsStr.push((0, _tools.escapeRowData)(_key) + '=' + (0, _tools.escapeRowField)(_value));
+            fieldsStr.push((0, _rowData.escapeRowData)(_key) + '=' + (0, _rowData.escapeRowField)(_value));
           }
         });
 
         if (_tagKeys.length) {
-          rowData.fields[CUSTOM_KEYS] = (0, _tools.escapeRowField)(_tagKeys);
-          fieldsStr.push((0, _tools.escapeRowData)(CUSTOM_KEYS) + '=' + (0, _tools.escapeRowField)(_tagKeys));
+          rowData.fields[CUSTOM_KEYS] = (0, _rowData.escapeRowField)(_tagKeys);
+          fieldsStr.push((0, _rowData.escapeRowData)(CUSTOM_KEYS) + '=' + (0, _rowData.escapeRowField)(_tagKeys));
         }
       }
 
@@ -111,7 +117,7 @@ var processedMessageByDataMap = function processedMessageByDataMap(message) {
           if (filterFileds.indexOf(key) === -1 && ((0, _tools.isNumber)(value) || (0, _tools.isString)(value) || (0, _tools.isBoolean)(value))) {
             rowData.fields[key] = value; // 这里不需要转译
 
-            fieldsStr.push((0, _tools.escapeRowData)(key) + '=' + (0, _tools.escapeRowField)(value));
+            fieldsStr.push((0, _rowData.escapeRowData)(key) + '=' + (0, _rowData.escapeRowField)(value));
           }
         });
       }
@@ -138,23 +144,18 @@ var processedMessageByDataMap = function processedMessageByDataMap(message) {
 
 exports.processedMessageByDataMap = processedMessageByDataMap;
 
-var batch = function batch(request, batchMessagesLimit, batchBytesLimit, messageBytesLimit, flushTimeout, pageExitObservable) {
+var batch = function batch(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) {
@@ -165,45 +166,26 @@ batch.prototype.upsert = function (message, key) {
   this.addOrUpdate(message, key);
 };
 
-batch.prototype.flush = function (sendFn) {
-  if (typeof sendFn !== 'function') {
-    sendFn = this.request.send;
-  }
+batch.prototype.flush = function (event) {
+  var messages = this.pushOnlyBuffer.concat((0, _tools.values)(this.upsertBuffer));
+  this.pushOnlyBuffer = [];
+  this.upsertBuffer = {};
 
-  if (this.bufferMessagesCount !== 0) {
-    var messages = this.pushOnlyBuffer.concat((0, _tools.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
-      });
+  if (messages.length > 0) {
+    var payload = {
+      data: messages.join('\n'),
+      bytesCount: event.bytesCount,
+      flushReason: event.reason
+    };
+
+    if ((0, _pageExitObservable.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);
 
@@ -220,20 +202,12 @@ batch.prototype.addOrUpdate = function (message, 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 = (0, _byteUtils.computeBytesCount)(processedMessage);
   return {
     processedMessage: processedMessage,
     messageBytesCount: messageBytesCount
@@ -241,10 +215,8 @@ 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;
@@ -252,44 +224,21 @@ batch.prototype.push = function (processedMessage, messageBytesCount, key) {
     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;
+  var messageBytesCount = (0, _byteUtils.computeBytesCount)(removedMessage); // If there are other messages, a '\n' will be added at serialization
 
-  if (this.bufferMessagesCount > 0) {
-    this.bufferBytesCount -= 1;
-  }
+  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);
-};
-
 var Batch = batch;
 exports.Batch = Batch;

package/cjs/transport/flushController.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFlushController = createFlushController;
+
+var _observable = require("../helper/observable");
+
+var _timer = require("../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.
+ */
+function createFlushController(_ref) {
+  var messagesLimit = _ref.messagesLimit,
+      bytesLimit = _ref.bytesLimit,
+      durationLimit = _ref.durationLimit,
+      pageExitObservable = _ref.pageExitObservable,
+      sessionExpireObservable = _ref.sessionExpireObservable;
+  var flushObservable = new _observable.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 = (0, _timer.setTimeout)(function () {
+        flush('duration_limit');
+      }, durationLimit);
+    }
+  }
+
+  function cancelDurationLimitTimeout() {
+    (0, _timer.clearTimeout)(durationLimitTimeoutId);
+    durationLimitTimeoutId = undefined;
+  }
+
+  return {
+    flushObservable: flushObservable,
+    getMessagesCount: function getMessagesCount() {
+      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 notifyBeforeAddMessage(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 notifyAfterAddMessage() {
+      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 notifyAfterRemoveMessage(messageBytesCount) {
+      currentBytesCount -= messageBytesCount;
+      currentMessagesCount -= 1;
+
+      if (currentMessagesCount === 0) {
+        cancelDurationLimitTimeout();
+      }
+    }
+  };
+}

package/cjs/transport/httpRequest.js

@@ -8,6 +8,8 @@ exports.fetchKeepAliveStrategy = fetchKeepAliveStrategy;
 
 var _sendWithRetryStrategy = require("./sendWithRetryStrategy");
 
+var _addEventListener = require("../browser/addEventListener");
+
 /**
  * Use POST request without content type to:
  * - avoid CORS preflight requests
@@ -103,12 +105,14 @@ function isKeepAliveSupported() {
 function sendXHR(url, data, onResponse) {
   var request = new XMLHttpRequest();
   request.open('POST', url, true);
-  request.send(data);
-  request.addEventListener('loadend', function () {
+  (0, _addEventListener.addEventListener)(request, 'loadend', function () {
     if (typeof onResponse === 'function') {
       onResponse({
         status: request.status
       });
     }
+  }, {
+    once: true
   });
+  request.send(data);
 }

package/cjs/transport/index.js

@@ -9,6 +9,12 @@ Object.defineProperty(exports, "Batch", {
     return _batch.Batch;
   }
 });
+Object.defineProperty(exports, "createFlushController", {
+  enumerable: true,
+  get: function get() {
+    return _flushController.createFlushController;
+  }
+});
 Object.defineProperty(exports, "createHttpRequest", {
   enumerable: true,
   get: function get() {
@@ -26,4 +32,6 @@ var _httpRequest = require("./httpRequest");
 
 var _batch = require("./batch");
 
-var _startBatchWithReplica = require("./startBatchWithReplica");
+var _startBatchWithReplica = require("./startBatchWithReplica");
+
+var _flushController = require("./flushController");

package/cjs/transport/sendWithRetryStrategy.js

@@ -9,13 +9,17 @@ exports.sendWithRetryStrategy = sendWithRetryStrategy;
 
 var _tools = require("../helper/tools");
 
+var _byteUtils = require("../helper/byteUtils");
+
 var _errorTools = require("../helper/errorTools");
 
-var MAX_ONGOING_BYTES_COUNT = 80 * _tools.ONE_KIBI_BYTE;
+var _timer = require("../helper/timer");
+
+var MAX_ONGOING_BYTES_COUNT = 80 * _byteUtils.ONE_KIBI_BYTE;
 exports.MAX_ONGOING_BYTES_COUNT = MAX_ONGOING_BYTES_COUNT;
 var MAX_ONGOING_REQUESTS = 32;
 exports.MAX_ONGOING_REQUESTS = MAX_ONGOING_REQUESTS;
-var MAX_QUEUE_BYTES_COUNT = 3 * _tools.ONE_MEBI_BYTE;
+var MAX_QUEUE_BYTES_COUNT = 3 * _byteUtils.ONE_MEBI_BYTE;
 exports.MAX_QUEUE_BYTES_COUNT = MAX_QUEUE_BYTES_COUNT;
 var MAX_BACKOFF_TIME = 256 * _tools.ONE_SECOND;
 exports.MAX_BACKOFF_TIME = MAX_BACKOFF_TIME;
@@ -52,7 +56,7 @@ function scheduleRetry(state, sendStrategy, reportError) {
     return;
   }
 
-  setTimeout(function () {
+  (0, _timer.setTimeout)(function () {
     var payload = state.queuedPayloads.first();
     send(payload, state, sendStrategy, {
       onSuccess: function onSuccess() {
@@ -95,7 +99,7 @@ function send(payload, state, sendStrategy, responseData) {
 function retryQueuedPayloads(reason, state, sendStrategy, reportError) {
   if (reason === RetryReason.AFTER_SUCCESS && state.queuedPayloads.isFull() && !state.queueFullReported) {
     reportError({
-      message: 'Reached max events size queued for upload: ' + MAX_QUEUE_BYTES_COUNT / _tools.ONE_MEBI_BYTE + 'MiB',
+      message: 'Reached max events size queued for upload: ' + MAX_QUEUE_BYTES_COUNT / _byteUtils.ONE_MEBI_BYTE + 'MiB',
       source: _errorTools.ErrorSource.AGENT,
       startClocks: (0, _tools.clocksNow)()
     });

package/cjs/transport/startBatchWithReplica.js

@@ -9,11 +9,19 @@ var _batch = require("./batch");
 
 var _httpRequest = require("./httpRequest");
 
-function startBatchWithReplica(configuration, endpointUrl, reportError, pageExitObservable) {
+var _flushController = require("./flushController");
+
+function startBatchWithReplica(configuration, endpointUrl, reportError, pageExitObservable, sessionExpireObservable) {
   var primaryBatch = createBatch(endpointUrl);
 
   function createBatch(endpointUrl) {
-    return new _batch.Batch((0, _httpRequest.createHttpRequest)(endpointUrl, configuration.batchBytesLimit, reportError), configuration.batchMessagesLimit, configuration.batchBytesLimit, configuration.messageBytesLimit, configuration.flushTimeout, pageExitObservable);
+    return new _batch.Batch((0, _httpRequest.createHttpRequest)(endpointUrl, configuration.batchBytesLimit, reportError), (0, _flushController.createFlushController)({
+      messagesLimit: configuration.batchMessagesLimit,
+      bytesLimit: configuration.batchBytesLimit,
+      durationLimit: configuration.flushTimeout,
+      pageExitObservable: pageExitObservable,
+      sessionExpireObservable: sessionExpireObservable
+    }), configuration.messageBytesLimit);
   }
 
   return {

package/cjs/user/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _user = require("./user");
+
+Object.keys(_user).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _user[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _user[key];
+    }
+  });
+});

package/cjs/user/user.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkUser = checkUser;
+exports.sanitizeUser = sanitizeUser;
+
+var _display = require("../helper/display");
+
+var _tools = require("../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
+ */
+function sanitizeUser(newUser) {
+  // We shallow clone only to prevent mutation of user data.
+  var user = (0, _tools.assign)({}, newUser);
+  var keys = ['id', 'name', 'email'];
+  (0, _tools.each)(keys, function (key) {
+    if (key in user) {
+      user[key] = String(user[key]);
+    }
+  });
+  return user;
+}
+/**
+ * Simple check to ensure user is valid
+ */
+
+
+function checkUser(newUser) {
+  var isValid = (0, _tools.getType)(newUser) === 'object';
+
+  if (!isValid) {
+    _display.display.error('Unsupported user:', newUser);
+  }
+
+  return isValid;
+}

package/esm/browser/addEventListener.js

@@ -0,0 +1,46 @@
+import { each } from '../helper/tools';
+import { getZoneJsOriginalValue } from '../helper/getZoneJsOriginalValue';
+export function addEventListener(eventTarget, event, listener, options) {
+  return addEventListeners(eventTarget, [event], listener, options);
+}
+/**
+ * Add event listeners to an event emitter object (Window, Element, mock object...).  This provides
+ * a few conveniences compared to using `element.addEventListener` directly:
+ *
+ * * supports IE11 by:
+ *   * using an option object only if needed
+ *   * emulating the `once` option
+ *
+ * * wraps the listener with a `monitor` function
+ *
+ * * returns a `stop` function to remove the listener
+ *
+ * * with `once: true`, the listener will be called at most once, even if different events are
+ *   listened
+ */
+
+export function addEventListeners(eventTarget, events, listener, options) {
+  var wrappedListener = options && options.once ? function (event) {
+    stop();
+    listener(event);
+  } : listener;
+  options = options && options.passive ? {
+    capture: options.capture,
+    passive: options.passive
+  } : options && options.capture;
+  var add = getZoneJsOriginalValue(eventTarget, 'addEventListener');
+  each(events, function (event) {
+    add.call(eventTarget, event, wrappedListener, options);
+  });
+
+  var stop = function stop() {
+    var remove = getZoneJsOriginalValue(eventTarget, 'removeEventListener');
+    each(events, function (event) {
+      remove.call(eventTarget, event, wrappedListener, options);
+    });
+  };
+
+  return {
+    stop: stop
+  };
+}