@cloudcare/browser-core 2.0.3 → 2.0.5

package/cjs/browser/addEventListener.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addEventListener = addEventListener;
+exports.addEventListeners = addEventListeners;
+
+var _tools = require("../helper/tools");
+
+var _getZoneJsOriginalValue = require("../helper/getZoneJsOriginalValue");
+
+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
+ */
+
+
+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 = (0, _getZoneJsOriginalValue.getZoneJsOriginalValue)(eventTarget, 'addEventListener');
+  (0, _tools.each)(events, function (event) {
+    add.call(eventTarget, event, wrappedListener, options);
+  });
+
+  var stop = function stop() {
+    var remove = (0, _getZoneJsOriginalValue.getZoneJsOriginalValue)(eventTarget, 'removeEventListener');
+    (0, _tools.each)(events, function (event) {
+      remove.call(eventTarget, event, wrappedListener, options);
+    });
+  };
+
+  return {
+    stop: stop
+  };
+}

package/cjs/browser/pageExitObservable.js

@@ -13,6 +13,8 @@ var _tools = require("../helper/tools");
 
 var _enums = require("../helper/enums");
 
+var _addEventListener = require("../browser/addEventListener");
+
 var PageExitReason = {
   HIDDEN: 'visibility_hidden',
   UNLOADING: 'before_unload',
@@ -27,7 +29,7 @@ function createPageExitObservable() {
      * Only event that guarantee to fire on mobile devices when the page transitions to background state
      * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.
      */
-    var visibilityChangeListener = (0, _tools.addEventListeners)(document, [_enums.DOM_EVENT.VISIBILITY_CHANGE, _enums.DOM_EVENT.FREEZE, _enums.DOM_EVENT.PAGE_HIDE], function (event) {
+    var visibilityChangeListener = (0, _addEventListener.addEventListeners)(document, [_enums.DOM_EVENT.VISIBILITY_CHANGE, _enums.DOM_EVENT.FREEZE, _enums.DOM_EVENT.PAGE_HIDE], function (event) {
       if (event.type === _enums.DOM_EVENT.VISIBILITY_CHANGE && document.visibilityState === 'hidden') {
         /**
          * Only event that guarantee to fire on mobile devices when the page transitions to background state
@@ -54,7 +56,7 @@ function createPageExitObservable() {
      * - a page hide transition (cf: https://bugs.webkit.org/show_bug.cgi?id=188329)
      */
 
-    var beforeUnloadListener = (0, _tools.addEventListener)(window, _enums.DOM_EVENT.BEFORE_UNLOAD, function () {
+    var beforeUnloadListener = (0, _addEventListener.addEventListener)(window, _enums.DOM_EVENT.BEFORE_UNLOAD, function () {
       observable.notify({
         reason: PageExitReason.UNLOADING
       });

package/cjs/browser/runOnReadyState.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runOnReadyState = runOnReadyState;
+
+var _addEventListener = require("./addEventListener");
+
+var _enums = require("../helper/enums");
+
+function runOnReadyState(expectedReadyState, callback) {
+  if (document.readyState === expectedReadyState || document.readyState === 'complete') {
+    callback();
+  } else {
+    var eventName = expectedReadyState === 'complete' ? _enums.DOM_EVENT.LOAD : _enums.DOM_EVENT.DOM_CONTENT_LOADED;
+    (0, _addEventListener.addEventListener)(window, eventName, callback, {
+      once: true
+    });
+  }
+}

package/cjs/browser/xhrObservable.js

@@ -13,6 +13,8 @@ var _urlPolyfill = require("../helper/urlPolyfill");
 
 var _tools = require("../helper/tools");
 
+var _addEventListener = require("../browser/addEventListener");
+
 var xhrObservable;
 var xhrContexts = {};
 var DATA_FLUX_REQUEST_ID_KEY = '_DATAFLUX_REQUEST_UUID';
@@ -71,7 +73,7 @@ function sendXhr(observable) {
   startContext.isAborted = false;
   startContext.xhr = this;
   var hasBeenReported = false;
-  var onreadyStateChangeInstrumentMethod = (0, _instrumentMethod.instrumentMethodAndCallOriginal)(this, 'onreadystatechange', {
+  var stopInstrumentingOnReadyStateChange = (0, _instrumentMethod.instrumentMethodAndCallOriginal)(this, 'onreadystatechange', {
     before: function before() {
       if (this.readyState === XMLHttpRequest.DONE) {
         // Try to report the XHR as soon as possible, because the XHR may be mutated by the
@@ -81,11 +83,11 @@ function sendXhr(observable) {
         onEnd.call(this);
       }
     }
-  });
+  }).stop;
 
   var onEnd = function onEnd() {
-    this.removeEventListener('loadend', onEnd);
-    onreadyStateChangeInstrumentMethod.stop();
+    unsubscribeLoadEndListener();
+    stopInstrumentingOnReadyStateChange();
 
     if (hasBeenReported) {
       return;
@@ -100,7 +102,7 @@ function sendXhr(observable) {
     clearRequestId.call(this);
   };
 
-  this.addEventListener('loadend', onEnd);
+  var unsubscribeLoadEndListener = (0, _addEventListener.addEventListener)(this, 'loadend', onEnd).stop;
   observable.notify(startContext);
 }
 

package/cjs/configuration/configuration.js

@@ -15,6 +15,8 @@ var _display = require("../helper/display");
 
 var _tools = require("../helper/tools");
 
+var _byteUtils = require("../helper/byteUtils");
+
 var _transportConfiguration = require("./transportConfiguration");
 
 var DefaultPrivacyLevel = {
@@ -51,7 +53,7 @@ function validateAndBuildConfiguration(initConfiguration) {
      * beacon payload max queue size implementation is 64kb
      * ensure that we leave room for logs, rum and potential other users
      */
-    batchBytesLimit: 16 * _tools.ONE_KIBI_BYTE,
+    batchBytesLimit: 16 * _byteUtils.ONE_KIBI_BYTE,
     eventRateLimiterThreshold: 3000,
 
     /**
@@ -64,8 +66,8 @@ function validateAndBuildConfiguration(initConfiguration) {
      * Logs intake limit
      */
     batchMessagesLimit: 50,
-    messageBytesLimit: 256 * _tools.ONE_KIBI_BYTE,
-    resourceUrlLimit: 5 * _tools.ONE_KIBI_BYTE
+    messageBytesLimit: 256 * _byteUtils.ONE_KIBI_BYTE,
+    resourceUrlLimit: 5 * _byteUtils.ONE_KIBI_BYTE
   }, (0, _transportConfiguration.computeTransportConfiguration)(initConfiguration));
 }
 

package/cjs/console/consoleObservable.js

@@ -13,6 +13,8 @@ var _observable = require("../helper/observable");
 
 var _tools = require("../helper/tools");
 
+var _jsonStringify = require("../helper/serialisation/jsonStringify");
+
 var _display = require("../helper/display");
 
 var consoleObservablesByApi = {};
@@ -80,5 +82,5 @@ function formatConsoleParameters(param) {
     return (0, _errorTools.formatErrorMessage)((0, _tracekit.computeStackTrace)(param));
   }
 
-  return (0, _tools.jsonStringify)(param, undefined, 2);
+  return (0, _jsonStringify.jsonStringify)(param, undefined, 2);
 }

package/cjs/dataMap.js

@@ -58,6 +58,7 @@ var dataMap = {
     },
     fields: {
       session_replay_stats: '_dd.replay_stats',
+      session_is_active: 'session.is_active',
       view_error_count: 'view.error.count',
       view_resource_count: 'view.resource.count',
       view_long_task_count: 'view.long_task.count',

package/cjs/helper/byteUtils.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ONE_MEBI_BYTE = exports.ONE_KIBI_BYTE = void 0;
+exports.computeBytesCount = computeBytesCount;
+var ONE_KIBI_BYTE = 1024;
+exports.ONE_KIBI_BYTE = ONE_KIBI_BYTE;
+var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE; // eslint-disable-next-line no-control-regex
+
+exports.ONE_MEBI_BYTE = ONE_MEBI_BYTE;
+var HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/;
+
+function computeBytesCount(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;
+}

package/cjs/helper/contextHistory.js

@@ -8,6 +8,8 @@ exports.ContextHistory = ContextHistory;
 
 var _tools = require("./tools");
 
+var _timer = require("./timer");
+
 var END_OF_TIMES = Infinity;
 var CLEAR_OLD_CONTEXTS_INTERVAL = _tools.ONE_MINUTE;
 exports.CLEAR_OLD_CONTEXTS_INTERVAL = CLEAR_OLD_CONTEXTS_INTERVAL;
@@ -18,7 +20,7 @@ function ContextHistory(expireDelay) {
 
   var _this = this;
 
-  this.clearOldContextsInterval = setInterval(function () {
+  this.clearOldContextsInterval = (0, _timer.setInterval)(function () {
     _this.clearOldContexts();
   }, CLEAR_OLD_CONTEXTS_INTERVAL);
 }
@@ -107,7 +109,7 @@ ContextHistory.prototype.reset = function () {
 
 
 ContextHistory.prototype.stop = function () {
-  clearInterval(this.clearOldContextsInterval);
+  (0, _timer.clearInterval)(this.clearOldContextsInterval);
 };
 
 ContextHistory.prototype.clearOldContexts = function () {

package/cjs/helper/createEventRateLimiter.js

@@ -9,13 +9,15 @@ var _errorTools = require("./errorTools");
 
 var _tools = require("./tools");
 
+var _timer = require("./timer");
+
 function createEventRateLimiter(eventType, limit, onLimitReached) {
   var eventCount = 0;
   var allowNextEvent = false;
   return {
     isLimitReached: function isLimitReached() {
       if (eventCount === 0) {
-        setTimeout(function () {
+        (0, _timer.setTimeout)(function () {
           eventCount = 0;
         }, _tools.ONE_MINUTE);
       }

package/cjs/helper/errorTools.js

@@ -14,6 +14,8 @@ exports.toStackTraceString = toStackTraceString;
 
 var _tools = require("./tools");
 
+var _jsonStringify = require("../helper/serialisation/jsonStringify");
+
 var _tracekit = require("../tracekit");
 
 var ErrorSource = {
@@ -41,7 +43,7 @@ function computeRawError(data) {
       source: source,
       handling: handling,
       originalError: originalError,
-      message: nonErrorPrefix + ' ' + (0, _tools.jsonStringify)(originalError),
+      message: nonErrorPrefix + ' ' + (0, _jsonStringify.jsonStringify)(originalError),
       stack: 'No stack, consider using an instance of Error',
       handlingStack: handlingStack,
       type: stackTrace && stackTrace.name
@@ -64,7 +66,7 @@ function computeRawError(data) {
 function formatUnknownError(stackTrace, errorObject, nonErrorPrefix, handlingStack) {
   if (!stackTrace || stackTrace.message === undefined && !(errorObject instanceof Error)) {
     return {
-      message: nonErrorPrefix + '' + (0, _tools.jsonStringify)(errorObject),
+      message: nonErrorPrefix + '' + (0, _jsonStringify.jsonStringify)(errorObject),
       stack: 'No stack, consider using an instance of Error',
       handlingStack: handlingStack,
       type: stackTrace && stackTrace.name

package/cjs/helper/instrumentMethod.js

@@ -9,7 +9,7 @@ exports.instrumentSetter = instrumentSetter;
 
 var _tools = require("./tools");
 
-var _getZoneJsOriginalValue = require("./getZoneJsOriginalValue");
+var _timer = require("./timer");
 
 function instrumentMethod(object, method, instrumentationFactory) {
   var original = object[method];
@@ -70,11 +70,9 @@ function instrumentSetter(object, property, after) {
   // component, see issue RUMF-1443
 
 
-  var setTimeout = (0, _getZoneJsOriginalValue.getZoneJsOriginalValue)(window, 'setTimeout');
-
   var instrumentation = function instrumentation(thisObject, value) {
     // put hooked setter into event loop to avoid of set latency
-    setTimeout(function () {
+    (0, _timer.setTimeout)(function () {
       after(thisObject, value);
     }, 0);
   };

package/cjs/helper/serialisation/contextManager.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BYTES_COMPUTATION_THROTTLING_DELAY = void 0;
+exports.createContextManager = createContextManager;
+
+var _byteUtils = require("../byteUtils");
+
+var _tools = require("../tools");
+
+var _jsonStringify = require("./jsonStringify");
+
+var _heavyCustomerDataWarning = require("./heavyCustomerDataWarning");
+
+var BYTES_COMPUTATION_THROTTLING_DELAY = 200;
+exports.BYTES_COMPUTATION_THROTTLING_DELAY = BYTES_COMPUTATION_THROTTLING_DELAY;
+
+function createContextManager(customerDataType, computeBytesCountImpl) {
+  if (typeof computeBytesCountImpl === 'undefined') {
+    computeBytesCountImpl = _byteUtils.computeBytesCount;
+  }
+
+  var context = {};
+  var bytesCountCache;
+  var alreadyWarned = false; // Throttle the bytes computation to minimize the impact on performance.
+  // Especially useful if the user call context APIs synchronously multiple times in a row
+
+  var computeBytesCountThrottled = (0, _tools.throttle)(function (context) {
+    bytesCountCache = computeBytesCountImpl((0, _jsonStringify.jsonStringify)(context));
+
+    if (!alreadyWarned) {
+      alreadyWarned = (0, _heavyCustomerDataWarning.warnIfCustomerDataLimitReached)(bytesCountCache, customerDataType);
+    }
+  }, BYTES_COMPUTATION_THROTTLING_DELAY).throttled;
+  return {
+    getBytesCount: function getBytesCount() {
+      return bytesCountCache;
+    },
+
+    /** @deprecated use getContext instead */
+    get: function get() {
+      return context;
+    },
+
+    /** @deprecated use setContextProperty instead */
+    add: function add(key, value) {
+      context[key] = value;
+      computeBytesCountThrottled(context);
+    },
+
+    /** @deprecated renamed to removeContextProperty */
+    remove: function remove(key) {
+      delete context[key];
+      computeBytesCountThrottled(context);
+    },
+
+    /** @deprecated use setContext instead */
+    set: function set(newContext) {
+      context = newContext;
+      computeBytesCountThrottled(context);
+    },
+    getContext: function getContext() {
+      return (0, _tools.deepClone)(context);
+    },
+    setContext: function setContext(newContext) {
+      context = (0, _tools.deepClone)(newContext);
+      computeBytesCountThrottled(context);
+    },
+    setContextProperty: function setContextProperty(key, property) {
+      context[key] = (0, _tools.deepClone)(property);
+      computeBytesCountThrottled(context);
+    },
+    removeContextProperty: function removeContextProperty(key) {
+      delete context[key];
+      computeBytesCountThrottled(context);
+    },
+    clearContext: function clearContext() {
+      context = {};
+      bytesCountCache = 0;
+    }
+  };
+}

package/cjs/helper/serialisation/heavyCustomerDataWarning.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CustomerDataType = exports.CUSTOMER_DATA_BYTES_LIMIT = void 0;
+exports.warnIfCustomerDataLimitReached = warnIfCustomerDataLimitReached;
+
+var _byteUtils = require("../byteUtils");
+
+var _display = require("../display");
+
+// RUM and logs batch bytes limit is 16KB
+// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
+// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
+var CUSTOMER_DATA_BYTES_LIMIT = 3 * _byteUtils.ONE_KIBI_BYTE;
+exports.CUSTOMER_DATA_BYTES_LIMIT = CUSTOMER_DATA_BYTES_LIMIT;
+var CustomerDataType = {
+  FeatureFlag: 'feature flag evaluation',
+  User: 'user',
+  GlobalContext: 'global context',
+  LoggerContext: 'logger context'
+};
+exports.CustomerDataType = CustomerDataType;
+
+function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {
+  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {
+    _display.display.warn('The ' + customerDataType + 'data is over ' + CUSTOMER_DATA_BYTES_LIMIT / _byteUtils.ONE_KIBI_BYTE + " KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth.");
+
+    return true;
+  }
+
+  return false;
+}

package/cjs/helper/serialisation/jsonStringify.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.detachToJsonMethod = detachToJsonMethod;
+exports.jsonStringify = jsonStringify;
+
+var _tools = require("../tools");
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+/**
+ * Custom implementation of JSON.stringify that ignores some toJSON methods. We need to do that
+ * because some sites badly override toJSON on certain objects. Removing all toJSON methods from
+ * nested values would be too costly, so we just detach them from the root value, and native classes
+ * used to build JSON values (Array and Object).
+ *
+ * Note: this still assumes that JSON.stringify is correct.
+ */
+function jsonStringify(value, replacer, space) {
+  if (_typeof(value) !== 'object' || value === null) {
+    return JSON.stringify(value);
+  } // Note: The order matter here. We need to detach toJSON methods on parent classes before their
+  // subclasses.
+
+
+  var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);
+  var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype);
+  var restoreValuePrototypeToJson = detachToJsonMethod(Object.getPrototypeOf(value));
+  var restoreValueToJson = detachToJsonMethod(value);
+
+  try {
+    return JSON.stringify(value, replacer, space);
+  } catch (_unused) {
+    return '<error: unable to serialize object>';
+  } finally {
+    restoreObjectPrototypeToJson();
+    restoreArrayPrototypeToJson();
+    restoreValuePrototypeToJson();
+    restoreValueToJson();
+  }
+}
+
+function detachToJsonMethod(value) {
+  var object = value;
+  var objectToJson = object.toJSON;
+
+  if (objectToJson) {
+    delete object.toJSON;
+    return function () {
+      object.toJSON = objectToJson;
+    };
+  }
+
+  return _tools.noop;
+}

package/cjs/helper/serialisation/rowData.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.escapeFieldValueStr = escapeFieldValueStr;
+exports.escapeJsonValue = escapeJsonValue;
+exports.escapeRowData = escapeRowData;
+exports.escapeRowField = escapeRowField;
+
+var _jsonStringify = require("./jsonStringify");
+
+var _tools = require("../tools");
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function escapeRowData(str) {
+  if (_typeof(str) === 'object' && str) {
+    str = (0, _jsonStringify.jsonStringify)(str);
+  } else if (!(0, _tools.isString)(str)) {
+    return str;
+  }
+
+  var reg = /[\s=,"]/g;
+  return String(str).replace(reg, function (word) {
+    return '\\' + word;
+  });
+}
+
+function escapeJsonValue(value) {
+  if ((0, _tools.isString)(value)) {
+    return value;
+  } else {
+    return (0, _jsonStringify.jsonStringify)(value);
+  }
+}
+
+function escapeFieldValueStr(str) {
+  return '"' + str.replace(/\\/g, '\\\\').replace(/[\\]*"/g, '"').replace(/"/g, '\\"') + '"';
+}
+
+function escapeRowField(value) {
+  if (_typeof(value) === 'object' && value) {
+    return escapeFieldValueStr((0, _jsonStringify.jsonStringify)(value));
+  } else if ((0, _tools.isString)(value)) {
+    return escapeFieldValueStr(value);
+  } else {
+    return value;
+  }
+}

package/cjs/helper/timer.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clearInterval = clearInterval;
+exports.clearTimeout = clearTimeout;
+exports.setInterval = setInterval;
+exports.setTimeout = setTimeout;
+
+var _getZoneJsOriginalValue = require("./getZoneJsOriginalValue");
+
+var _init = require("../init");
+
+function setTimeout(callback, delay) {
+  return (0, _getZoneJsOriginalValue.getZoneJsOriginalValue)((0, _init.getGlobalObject)(), 'setTimeout')(callback, delay);
+}
+
+function clearTimeout(timeoutId) {
+  (0, _getZoneJsOriginalValue.getZoneJsOriginalValue)((0, _init.getGlobalObject)(), 'clearTimeout')(timeoutId);
+}
+
+function setInterval(callback, delay) {
+  return (0, _getZoneJsOriginalValue.getZoneJsOriginalValue)(window, 'setInterval')(callback, delay);
+}
+
+function clearInterval(timeoutId) {
+  (0, _getZoneJsOriginalValue.getZoneJsOriginalValue)(window, 'clearInterval')(timeoutId);
+}