@cloudcare/browser-core 2.0.4 → 2.0.6

package/esm/browser/fetchObservable.js

@@ -38,8 +38,8 @@ function createFetchObservable() {
 }
 
 function beforeSend(observable, input, init) {
-  var method = init && init.method || typeof input === 'object' && input.method || 'GET';
-  var url = normalizeUrl(typeof input === 'object' && input.url || input);
+  var method = init && init.method || input instanceof Request && input.method || 'GET';
+  var url = input instanceof Request ? input.url : normalizeUrl(String(input));
   var startClocks = clocksNow();
   var context = {
     state: 'start',
@@ -64,7 +64,8 @@ function afterSend(observable, responsePromise, startContext) {
       context.error = response;
     } else if ('status' in response) {
       context.response = response;
-      context.responseType = response.type;
+      context.responseType = response instanceof Response && response.type || ''; // issue The Response type getter can only be used on instances of Response
+
       context.status = response.status;
       context.isAborted = false;
     }

package/esm/browser/pageExitObservable.js

@@ -1,6 +1,7 @@
 import { Observable } from '../helper/observable';
-import { addEventListener, addEventListeners, includes, values } from '../helper/tools';
+import { includes, values } from '../helper/tools';
 import { DOM_EVENT } from '../helper/enums';
+import { addEventListener, addEventListeners } from '../browser/addEventListener';
 export var PageExitReason = {
   HIDDEN: 'visibility_hidden',
   UNLOADING: 'before_unload',

package/esm/browser/runOnReadyState.js

@@ -0,0 +1,12 @@
+import { addEventListener } from './addEventListener';
+import { DOM_EVENT } from '../helper/enums';
+export function runOnReadyState(expectedReadyState, callback) {
+  if (document.readyState === expectedReadyState || document.readyState === 'complete') {
+    callback();
+  } else {
+    var eventName = expectedReadyState === 'complete' ? DOM_EVENT.LOAD : DOM_EVENT.DOM_CONTENT_LOADED;
+    addEventListener(window, eventName, callback, {
+      once: true
+    });
+  }
+}

package/esm/browser/xhrObservable.js

@@ -2,6 +2,7 @@ import { instrumentMethodAndCallOriginal } from '../helper/instrumentMethod';
 import { Observable } from '../helper/observable';
 import { normalizeUrl } from '../helper/urlPolyfill';
 import { shallowClone, elapsed, relativeNow, clocksNow, timeStampNow, UUID } from '../helper/tools';
+import { addEventListener } from '../browser/addEventListener';
 var xhrObservable;
 var xhrContexts = {};
 var DATA_FLUX_REQUEST_ID_KEY = '_DATAFLUX_REQUEST_UUID';
@@ -59,7 +60,7 @@ function sendXhr(observable) {
   startContext.isAborted = false;
   startContext.xhr = this;
   var hasBeenReported = false;
-  var onreadyStateChangeInstrumentMethod = instrumentMethodAndCallOriginal(this, 'onreadystatechange', {
+  var stopInstrumentingOnReadyStateChange = 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
@@ -69,11 +70,11 @@ function sendXhr(observable) {
         onEnd.call(this);
       }
     }
-  });
+  }).stop;
 
   var onEnd = function onEnd() {
-    this.removeEventListener('loadend', onEnd);
-    onreadyStateChangeInstrumentMethod.stop();
+    unsubscribeLoadEndListener();
+    stopInstrumentingOnReadyStateChange();
 
     if (hasBeenReported) {
       return;
@@ -88,7 +89,7 @@ function sendXhr(observable) {
     clearRequestId.call(this);
   };
 
-  this.addEventListener('loadend', onEnd);
+  var unsubscribeLoadEndListener = addEventListener(this, 'loadend', onEnd).stop;
   observable.notify(startContext);
 }
 

package/esm/configuration/configuration.js

@@ -1,7 +1,8 @@
 import { getCurrentSite } from '../browser/cookie';
 import { catchUserErrors } from '../helper/catchUserErrors';
 import { display } from '../helper/display';
-import { assign, isPercentage, ONE_KIBI_BYTE, ONE_SECOND, isNullUndefinedDefaultValue } from '../helper/tools';
+import { assign, isPercentage, ONE_SECOND, isNullUndefinedDefaultValue } from '../helper/tools';
+import { ONE_KIBI_BYTE } from '../helper/byteUtils';
 import { computeTransportConfiguration } from './transportConfiguration';
 export var DefaultPrivacyLevel = {
   ALLOW: 'allow',

package/esm/console/consoleObservable.js

@@ -1,7 +1,8 @@
 import { computeStackTrace } from '../tracekit';
 import { createHandlingStack, formatErrorMessage, toStackTraceString } from '../helper/errorTools';
 import { mergeObservables, Observable } from '../helper/observable';
-import { find, jsonStringify, map } from '../helper/tools';
+import { find, map } from '../helper/tools';
+import { jsonStringify } from '../helper/serialisation/jsonStringify';
 import { ConsoleApiName } from '../helper/display';
 var consoleObservablesByApi = {};
 export function initConsoleObservable(apis) {

package/esm/dataMap.js

@@ -48,6 +48,7 @@ export 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/esm/helper/byteUtils.js

@@ -0,0 +1,16 @@
+export var ONE_KIBI_BYTE = 1024;
+export var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE; // eslint-disable-next-line no-control-regex
+
+var HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/;
+export 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/esm/helper/contextHistory.js

@@ -1,4 +1,5 @@
 import { relativeNow, ONE_MINUTE, filter, map } from './tools';
+import { setInterval, clearInterval } from './timer';
 var END_OF_TIMES = Infinity;
 export var CLEAR_OLD_CONTEXTS_INTERVAL = ONE_MINUTE;
 export function ContextHistory(expireDelay) {

package/esm/helper/createEventRateLimiter.js

@@ -1,5 +1,6 @@
 import { ErrorSource } from './errorTools';
 import { clocksNow, ONE_MINUTE } from './tools';
+import { setTimeout } from './timer';
 export function createEventRateLimiter(eventType, limit, onLimitReached) {
   var eventCount = 0;
   var allowNextEvent = false;

package/esm/helper/errorTools.js

@@ -1,4 +1,5 @@
-import { each, noop, jsonStringify } from './tools';
+import { each, noop } from './tools';
+import { jsonStringify } from '../helper/serialisation/jsonStringify';
 import { computeStackTrace } from '../tracekit';
 export var ErrorSource = {
   AGENT: 'agent',

package/esm/helper/instrumentMethod.js

@@ -1,5 +1,5 @@
 import { noop } from './tools';
-import { getZoneJsOriginalValue } from './getZoneJsOriginalValue';
+import { setTimeout } from './timer';
 export function instrumentMethod(object, method, instrumentationFactory) {
   var original = object[method];
   var instrumentation = instrumentationFactory(original);
@@ -57,8 +57,6 @@ export function instrumentSetter(object, property, after) {
   // component, see issue RUMF-1443
 
 
-  var setTimeout = getZoneJsOriginalValue(window, 'setTimeout');
-
   var instrumentation = function instrumentation(thisObject, value) {
     // put hooked setter into event loop to avoid of set latency
     setTimeout(function () {

package/esm/helper/serialisation/contextManager.js

@@ -0,0 +1,70 @@
+import { computeBytesCount } from '../byteUtils';
+import { deepClone, throttle } from '../tools';
+import { jsonStringify } from './jsonStringify';
+import { warnIfCustomerDataLimitReached } from './heavyCustomerDataWarning';
+export var BYTES_COMPUTATION_THROTTLING_DELAY = 200;
+export function createContextManager(customerDataType, computeBytesCountImpl) {
+  if (typeof computeBytesCountImpl === 'undefined') {
+    computeBytesCountImpl = 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 = throttle(function (context) {
+    bytesCountCache = computeBytesCountImpl(jsonStringify(context));
+
+    if (!alreadyWarned) {
+      alreadyWarned = 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 deepClone(context);
+    },
+    setContext: function setContext(newContext) {
+      context = deepClone(newContext);
+      computeBytesCountThrottled(context);
+    },
+    setContextProperty: function setContextProperty(key, property) {
+      context[key] = deepClone(property);
+      computeBytesCountThrottled(context);
+    },
+    removeContextProperty: function removeContextProperty(key) {
+      delete context[key];
+      computeBytesCountThrottled(context);
+    },
+    clearContext: function clearContext() {
+      context = {};
+      bytesCountCache = 0;
+    }
+  };
+}

package/esm/helper/serialisation/heavyCustomerDataWarning.js

@@ -0,0 +1,20 @@
+import { ONE_KIBI_BYTE } from '../byteUtils';
+import { display } from '../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
+
+export var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE;
+export var CustomerDataType = {
+  FeatureFlag: 'feature flag evaluation',
+  User: 'user',
+  GlobalContext: 'global context',
+  LoggerContext: 'logger context'
+};
+export function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {
+  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {
+    display.warn('The ' + customerDataType + 'data is over ' + CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE + " KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth.");
+    return true;
+  }
+
+  return false;
+}

package/esm/helper/serialisation/jsonStringify.js

@@ -0,0 +1,46 @@
+import { noop } from '../tools';
+/**
+ * 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.
+ */
+
+export 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();
+  }
+}
+export function detachToJsonMethod(value) {
+  var object = value;
+  var objectToJson = object.toJSON;
+
+  if (objectToJson) {
+    delete object.toJSON;
+    return () => {
+      object.toJSON = objectToJson;
+    };
+  }
+
+  return noop;
+}

package/esm/helper/serialisation/rowData.js

@@ -0,0 +1,33 @@
+import { jsonStringify } from './jsonStringify';
+import { isString } from '../tools';
+export function escapeRowData(str) {
+  if (typeof str === 'object' && str) {
+    str = jsonStringify(str);
+  } else if (!isString(str)) {
+    return str;
+  }
+
+  var reg = /[\s=,"]/g;
+  return String(str).replace(reg, function (word) {
+    return '\\' + word;
+  });
+}
+export function escapeJsonValue(value) {
+  if (isString(value)) {
+    return value;
+  } else {
+    return jsonStringify(value);
+  }
+}
+export function escapeFieldValueStr(str) {
+  return '"' + str.replace(/\\/g, '\\\\').replace(/[\\]*"/g, '"').replace(/"/g, '\\"') + '"';
+}
+export function escapeRowField(value) {
+  if (typeof value === 'object' && value) {
+    return escapeFieldValueStr(jsonStringify(value));
+  } else if (isString(value)) {
+    return escapeFieldValueStr(value);
+  } else {
+    return value;
+  }
+}

package/esm/helper/timer.js

@@ -0,0 +1,14 @@
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue';
+import { getGlobalObject } from '../init';
+export function setTimeout(callback, delay) {
+  return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(callback, delay);
+}
+export function clearTimeout(timeoutId) {
+  getZoneJsOriginalValue(getGlobalObject(), 'clearTimeout')(timeoutId);
+}
+export function setInterval(callback, delay) {
+  return getZoneJsOriginalValue(window, 'setInterval')(callback, delay);
+}
+export function clearInterval(timeoutId) {
+  getZoneJsOriginalValue(window, 'clearInterval')(timeoutId);
+}