@cloudcare/browser-core 2.0.14 → 2.0.16

package/cjs/dataMap.js

@@ -8,8 +8,8 @@ exports.dataMap = exports.commonTags = exports.commonFields = void 0;
 var _enums = require("./helper/enums");
 
 var commonTags = {
-  sdk_name: '_dd.sdk_name',
-  sdk_version: '_dd.sdk_version',
+  sdk_name: '_gc.sdk_name',
+  sdk_version: '_gc.sdk_version',
   app_id: 'application.id',
   env: 'env',
   service: 'service',
@@ -57,7 +57,7 @@ var dataMap = {
     },
     fields: {
       is_active: 'view.is_active',
-      session_replay_stats: '_dd.replay_stats',
+      session_replay_stats: '_gc.replay_stats',
       session_is_active: 'session.is_active',
       view_error_count: 'view.error.count',
       view_resource_count: 'view.resource.count',
@@ -86,8 +86,8 @@ var dataMap = {
   resource: {
     type: _enums.RumEventType.RESOURCE,
     tags: {
-      trace_id: '_dd.trace_id',
-      span_id: '_dd.span_id',
+      trace_id: '_gc.trace_id',
+      span_id: '_gc.span_id',
       resource_url: 'resource.url',
       resource_url_host: 'resource.url_host',
       resource_url_path: 'resource.url_path',
@@ -120,8 +120,8 @@ var dataMap = {
     type: _enums.RumEventType.ERROR,
     tags: {
       error_id: 'error.id',
-      trace_id: '_dd.trace_id',
-      span_id: '_dd.span_id',
+      trace_id: '_gc.trace_id',
+      span_id: '_gc.span_id',
       error_source: 'error.source',
       error_type: 'error.type',
       error_handling: 'error.handling' //   resource_url: 'error.resource.url',
@@ -160,8 +160,8 @@ var dataMap = {
       action_resource_count: 'action.resource.count',
       action_frustration_types: 'action.frustration.type',
       action_long_task_count: 'action.long_task.count',
-      action_target: '_dd.action.target',
-      action_position: '_dd.action.position'
+      action_target: '_gc.action.target',
+      action_position: '_gc.action.position'
     }
   },
   browser_log: {

package/cjs/helper/enums.js

@@ -88,6 +88,7 @@ var TraceType = {
   ZIPKIN_MULTI_HEADER: 'zipkin',
   ZIPKIN_SINGLE_HEADER: 'zipkin_single_header',
   W3C_TRACEPARENT: 'w3c_traceparent',
+  W3C_TRACEPARENT_64: 'w3c_traceparent_64bit',
   SKYWALKING_V3: 'skywalking_v3',
   JAEGER: 'jaeger'
 };

package/cjs/helper/limitModification.js

@@ -7,22 +7,31 @@ exports.limitModification = limitModification;
 
 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); }
+var _sanitize = require("./sanitize");
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
 /**
- * Current limitations:
+ * Current limitation:
  * - field path do not support array, 'a.b.c' only
- * - modifiable fields type must be string
  */
 function limitModification(object, modifiableFieldPaths, modifier) {
-  var clone = (0, _tools.extend2Lev)({}, object);
+  var clone = (0, _tools.deepClone)(object);
   var result = modifier(clone);
-  (0, _tools.each)(modifiableFieldPaths, function (path) {
-    var originalValue = get(object, path);
-    var newValue = get(clone, path);
+  (0, _tools.each)((0, _tools.objectEntries)(modifiableFieldPaths), function (filedPaths) {
+    var fieldPath = filedPaths[0];
+    var fieldType = filedPaths[1];
+    var newValue = get(clone, fieldPath);
+    var newType = (0, _tools.getType)(newValue);
 
-    if (typeof originalValue === 'string' && typeof newValue === 'string') {
-      set(object, path, newValue);
+    if (newType === fieldType) {
+      set(object, fieldPath, (0, _sanitize.sanitize)(newValue));
+    } else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {
+      set(object, fieldPath, {});
     }
   });
   return result;
@@ -30,16 +39,24 @@ function limitModification(object, modifiableFieldPaths, modifier) {
 
 function get(object, path) {
   var current = object;
-  var fields = path.split('.');
 
-  for (var i = 0; i < fields.length; i++) {
-    var field = fields[i];
+  var _iterator = _createForOfIteratorHelper(path.split('.')),
+      _step;
 
-    if (!isValidObjectContaining(current, field)) {
-      return;
-    }
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var field = _step.value;
+
+      if (!isValidObjectContaining(current, field)) {
+        return;
+      }
 
-    current = current[field];
+      current = current[field];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
 
   return current;
@@ -52,7 +69,7 @@ function set(object, path, value) {
   for (var i = 0; i < fields.length; i += 1) {
     var field = fields[i];
 
-    if (!isValidObjectContaining(current, field)) {
+    if (!isValidObject(current)) {
       return;
     }
 
@@ -64,6 +81,10 @@ function set(object, path, value) {
   }
 }
 
+function isValidObject(object) {
+  return (0, _tools.getType)(object) === 'object';
+}
+
 function isValidObjectContaining(object, field) {
-  return _typeof(object) === 'object' && object !== null && field in object;
+  return isValidObject(object) && Object.prototype.hasOwnProperty.call(object, field);
 }

package/cjs/helper/sanitize.js

@@ -0,0 +1,239 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sanitize = sanitize;
+
+var _display = require("./display");
+
+var _byteUtils = require("./byteUtils");
+
+var _jsonStringify = require("./serialisation/jsonStringify");
+
+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); }
+
+// The maximum size of a single event is 256KiB. By default, we ensure that user-provided data
+// going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...
+var SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * _byteUtils.ONE_KIBI_BYTE; // Symbol for the root element of the JSONPath used for visited objects
+
+var JSON_PATH_ROOT_ELEMENT = '$'; // When serializing (using JSON.stringify) a key of an object, { key: 42 } gets wrapped in quotes as "key".
+// With the separator (:), we need to add 3 characters to the count.
+
+var KEY_DECORATION_LENGTH = 3;
+/**
+ * Ensures user-provided data is 'safe' for the SDK
+ * - Deep clones data
+ * - Removes cyclic references
+ * - Transforms unserializable types to a string representation
+ *
+ * LIMITATIONS:
+ * - Size is in characters, not byte count (may differ according to character encoding)
+ * - Size does not take into account indentation that can be applied to JSON.stringify
+ * - Non-numerical properties of Arrays are ignored. Same behavior as JSON.stringify
+ *
+ * @param source              User-provided data meant to be serialized using JSON.stringify
+ * @param maxCharacterCount   Maximum number of characters allowed in serialized form
+ */
+
+function sanitize(source, maxCharacterCount) {
+  if (maxCharacterCount === undefined) {
+    maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT;
+  } // Unbind any toJSON function we may have on [] or {} prototypes
+
+
+  var restoreObjectPrototypeToJson = (0, _jsonStringify.detachToJsonMethod)(Object.prototype);
+  var restoreArrayPrototypeToJson = (0, _jsonStringify.detachToJsonMethod)(Array.prototype); // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object
+
+  var containerQueue = [];
+  var visitedObjectsWithPath = new WeakMap();
+  var sanitizedData = sanitizeProcessor(source, JSON_PATH_ROOT_ELEMENT, undefined, containerQueue, visitedObjectsWithPath);
+  var accumulatedCharacterCount = JSON.stringify(sanitizedData) && JSON.stringify(sanitizedData).length || 0;
+
+  if (accumulatedCharacterCount > maxCharacterCount) {
+    warnOverCharacterLimit(maxCharacterCount, 'discarded', source);
+    return undefined;
+  }
+
+  while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {
+    var containerToProcess = containerQueue.shift();
+    var separatorLength = 0; // 0 for the first element, 1 for subsequent elements
+    // Arrays and Objects have to be handled distinctly to ensure
+    // we do not pick up non-numerical properties from Arrays
+
+    if (Array.isArray(containerToProcess.source)) {
+      for (var key = 0; key < containerToProcess.source.length; key++) {
+        var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);
+
+        if (targetData !== undefined) {
+          accumulatedCharacterCount += JSON.stringify(targetData).length;
+        } else {
+          // When an element of an Array (targetData) is undefined, it is serialized as null:
+          // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters
+          accumulatedCharacterCount += 4;
+        }
+
+        accumulatedCharacterCount += separatorLength;
+        separatorLength = 1;
+
+        if (accumulatedCharacterCount > maxCharacterCount) {
+          warnOverCharacterLimit(maxCharacterCount, 'truncated', source);
+          break;
+        }
+
+        containerToProcess.target[key] = targetData;
+      }
+    } else {
+      for (var key in containerToProcess.source) {
+        if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {
+          var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath); // When a property of an object has an undefined value, it will be dropped during serialization:
+          // JSON.stringify({a:undefined}) => '{}'
+
+          if (targetData !== undefined) {
+            accumulatedCharacterCount += JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH;
+            separatorLength = 1;
+          }
+
+          if (accumulatedCharacterCount > maxCharacterCount) {
+            warnOverCharacterLimit(maxCharacterCount, 'truncated', source);
+            break;
+          }
+
+          containerToProcess.target[key] = targetData;
+        }
+      }
+    }
+  } // Rebind detached toJSON functions
+
+
+  restoreObjectPrototypeToJson();
+  restoreArrayPrototypeToJson();
+  return sanitizedData;
+}
+/**
+ * Internal function to factorize the process common to the
+ * initial call to sanitize, and iterations for Arrays and Objects
+ *
+ */
+
+
+function sanitizeProcessor(source, parentPath, key, queue, visitedObjectsWithPath) {
+  // Start by handling toJSON, as we want to sanitize its output
+  var sourceToSanitize = tryToApplyToJSON(source);
+
+  if (!sourceToSanitize || _typeof(sourceToSanitize) !== 'object') {
+    return sanitizePrimitivesAndFunctions(sourceToSanitize);
+  }
+
+  var sanitizedSource = sanitizeObjects(sourceToSanitize);
+
+  if (sanitizedSource !== '[Object]' && sanitizedSource !== '[Array]' && sanitizedSource !== '[Error]') {
+    return sanitizedSource;
+  } // Handle potential cyclic references
+  // We need to use source as sourceToSanitize could be a reference to a new object
+  // At this stage, we know the source is an object type
+
+
+  var sourceAsObject = source;
+
+  if (visitedObjectsWithPath.has(sourceAsObject)) {
+    return '[Reference seen at ' + visitedObjectsWithPath.get(sourceAsObject) + ']';
+  } // Add processed source to queue
+
+
+  var currentPath = key !== undefined ? parentPath + '.' + key : parentPath;
+  var target = Array.isArray(sourceToSanitize) ? [] : {};
+  visitedObjectsWithPath.set(sourceAsObject, currentPath);
+  queue.push({
+    source: sourceToSanitize,
+    target: target,
+    path: currentPath
+  });
+  return target;
+}
+/**
+ * Handles sanitization of simple, non-object types
+ *
+ */
+
+
+function sanitizePrimitivesAndFunctions(value) {
+  // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation
+  if (typeof value === 'bigint') {
+    return '[BigInt] ' + value.toString();
+  } // Functions cannot be serialized by JSON.stringify(). Moreover, if a faulty toJSON is present, it needs to be converted
+  // so it won't prevent stringify from serializing later
+
+
+  if (typeof value === 'function') {
+    return '[Function] ' + value.name || 'unknown';
+  } // JSON.stringify() does not serialize symbols.
+
+
+  if (_typeof(value) === 'symbol') {
+    // symbol.description is part of ES2019+
+    return '[Symbol] ' + value.description || value.toString();
+  }
+
+  return value;
+}
+/**
+ * Handles sanitization of object types
+ *
+ * LIMITATIONS
+ * - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.
+ * To avoid this, a toJSON method can be defined.
+ * - IE11 does not return a distinct type for objects such as Map, WeakMap, ... These objects will pass through and their
+ * properties enumerated if any.
+ *
+ */
+
+
+function sanitizeObjects(value) {
+  try {
+    // Handle events - Keep a simple implementation to avoid breaking changes
+    if (value instanceof Event) {
+      return {
+        isTrusted: value.isTrusted
+      };
+    } // Handle all remaining object types in a generic way
+
+
+    var result = Object.prototype.toString.call(value);
+    var match = result.match(/\[object (.*)\]/);
+
+    if (match && match[1]) {
+      return '[' + match[1] + ']';
+    }
+  } catch (_unused) {// If the previous serialization attempts failed, and we cannot convert using
+    // Object.prototype.toString, declare the value unserializable
+  }
+
+  return '[Unserializable]';
+}
+/**
+ * Checks if a toJSON function exists and tries to execute it
+ *
+ */
+
+
+function tryToApplyToJSON(value) {
+  var object = value;
+
+  if (object && typeof object.toJSON === 'function') {
+    try {
+      return object.toJSON();
+    } catch (_unused2) {// If toJSON fails, we continue by trying to serialize the value manually
+    }
+  }
+
+  return value;
+}
+/**
+ * Helper function to display the warning when the accumulated character count is over the limit
+ */
+
+
+function warnOverCharacterLimit(maxCharacterCount, changeType, source) {
+  _display.display.warn('The data provided has been ' + changeType + ' as it is over the limit of ' + maxCharacterCount + ' characters:', source);
+}

package/cjs/helper/tools.js

@@ -48,6 +48,7 @@ exports.isFunction = exports.isEmptyObject = exports.isElement = exports.isDate
 exports.isHashAnAnchor = isHashAnAnchor;
 exports.isIE = isIE;
 exports.isJSONString = void 0;
+exports.isMatchOption = isMatchOption;
 exports.isNullUndefinedDefaultValue = isNullUndefinedDefaultValue;
 exports.isObject = exports.isNumber = void 0;
 exports.isPercentage = isPercentage;
@@ -1889,6 +1890,11 @@ function safeTruncate(candidate, length) {
   return candidate.slice(0, length);
 }
 
+function isMatchOption(item) {
+  var itemType = getType(item);
+  return itemType === 'string' || itemType === 'function' || item instanceof RegExp;
+}
+
 function includes(candidate, search) {
   // tslint:disable-next-line: no-unsafe-any
   return candidate.indexOf(search) !== -1;

package/cjs/index.js

@@ -147,6 +147,19 @@ Object.keys(_display).forEach(function (key) {
   });
 });
 
+var _sanitize = require("./helper/sanitize");
+
+Object.keys(_sanitize).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _sanitize[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _sanitize[key];
+    }
+  });
+});
+
 var _eventEmitter = require("./helper/eventEmitter");
 
 Object.keys(_eventEmitter).forEach(function (key) {

package/esm/dataMap.js

@@ -1,7 +1,7 @@
 import { RumEventType } from './helper/enums';
 export var commonTags = {
-  sdk_name: '_dd.sdk_name',
-  sdk_version: '_dd.sdk_version',
+  sdk_name: '_gc.sdk_name',
+  sdk_version: '_gc.sdk_version',
   app_id: 'application.id',
   env: 'env',
   service: 'service',
@@ -47,7 +47,7 @@ export var dataMap = {
     },
     fields: {
       is_active: 'view.is_active',
-      session_replay_stats: '_dd.replay_stats',
+      session_replay_stats: '_gc.replay_stats',
       session_is_active: 'session.is_active',
       view_error_count: 'view.error.count',
       view_resource_count: 'view.resource.count',
@@ -76,8 +76,8 @@ export var dataMap = {
   resource: {
     type: RumEventType.RESOURCE,
     tags: {
-      trace_id: '_dd.trace_id',
-      span_id: '_dd.span_id',
+      trace_id: '_gc.trace_id',
+      span_id: '_gc.span_id',
       resource_url: 'resource.url',
       resource_url_host: 'resource.url_host',
       resource_url_path: 'resource.url_path',
@@ -110,8 +110,8 @@ export var dataMap = {
     type: RumEventType.ERROR,
     tags: {
       error_id: 'error.id',
-      trace_id: '_dd.trace_id',
-      span_id: '_dd.span_id',
+      trace_id: '_gc.trace_id',
+      span_id: '_gc.span_id',
       error_source: 'error.source',
       error_type: 'error.type',
       error_handling: 'error.handling' //   resource_url: 'error.resource.url',
@@ -150,8 +150,8 @@ export var dataMap = {
       action_resource_count: 'action.resource.count',
       action_frustration_types: 'action.frustration.type',
       action_long_task_count: 'action.long_task.count',
-      action_target: '_dd.action.target',
-      action_position: '_dd.action.position'
+      action_target: '_gc.action.target',
+      action_position: '_gc.action.position'
     }
   },
   browser_log: {

package/esm/helper/enums.js

@@ -75,6 +75,7 @@ export var TraceType = {
   ZIPKIN_MULTI_HEADER: 'zipkin',
   ZIPKIN_SINGLE_HEADER: 'zipkin_single_header',
   W3C_TRACEPARENT: 'w3c_traceparent',
+  W3C_TRACEPARENT_64: 'w3c_traceparent_64bit',
   SKYWALKING_V3: 'skywalking_v3',
   JAEGER: 'jaeger'
 };

package/esm/helper/limitModification.js

@@ -1,19 +1,23 @@
-import { extend2Lev, each } from './tools';
+import { extend2Lev, each, objectEntries, getType, deepClone } from './tools';
+import { sanitize } from './sanitize';
 /**
- * Current limitations:
+ * Current limitation:
  * - field path do not support array, 'a.b.c' only
- * - modifiable fields type must be string
  */
 
 export function limitModification(object, modifiableFieldPaths, modifier) {
-  var clone = extend2Lev({}, object);
+  var clone = deepClone(object);
   var result = modifier(clone);
-  each(modifiableFieldPaths, function (path) {
-    var originalValue = get(object, path);
-    var newValue = get(clone, path);
+  each(objectEntries(modifiableFieldPaths), function (filedPaths) {
+    var fieldPath = filedPaths[0];
+    var fieldType = filedPaths[1];
+    var newValue = get(clone, fieldPath);
+    var newType = getType(newValue);
 
-    if (typeof originalValue === 'string' && typeof newValue === 'string') {
-      set(object, path, newValue);
+    if (newType === fieldType) {
+      set(object, fieldPath, sanitize(newValue));
+    } else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {
+      set(object, fieldPath, {});
     }
   });
   return result;
@@ -21,11 +25,8 @@ export function limitModification(object, modifiableFieldPaths, modifier) {
 
 function get(object, path) {
   var current = object;
-  var fields = path.split('.');
-
-  for (var i = 0; i < fields.length; i++) {
-    var field = fields[i];
 
+  for (var field of path.split('.')) {
     if (!isValidObjectContaining(current, field)) {
       return;
     }
@@ -43,7 +44,7 @@ function set(object, path, value) {
   for (var i = 0; i < fields.length; i += 1) {
     var field = fields[i];
 
-    if (!isValidObjectContaining(current, field)) {
+    if (!isValidObject(current)) {
       return;
     }
 
@@ -55,6 +56,10 @@ function set(object, path, value) {
   }
 }
 
+function isValidObject(object) {
+  return getType(object) === 'object';
+}
+
 function isValidObjectContaining(object, field) {
-  return typeof object === 'object' && object !== null && field in object;
+  return isValidObject(object) && Object.prototype.hasOwnProperty.call(object, field);
 }

package/esm/helper/sanitize.js

@@ -0,0 +1,226 @@
+import { display } from './display';
+import { ONE_KIBI_BYTE } from './byteUtils';
+import { detachToJsonMethod } from './serialisation/jsonStringify'; // The maximum size of a single event is 256KiB. By default, we ensure that user-provided data
+// going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...
+
+var SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE; // Symbol for the root element of the JSONPath used for visited objects
+
+var JSON_PATH_ROOT_ELEMENT = '$'; // When serializing (using JSON.stringify) a key of an object, { key: 42 } gets wrapped in quotes as "key".
+// With the separator (:), we need to add 3 characters to the count.
+
+var KEY_DECORATION_LENGTH = 3;
+/**
+ * Ensures user-provided data is 'safe' for the SDK
+ * - Deep clones data
+ * - Removes cyclic references
+ * - Transforms unserializable types to a string representation
+ *
+ * LIMITATIONS:
+ * - Size is in characters, not byte count (may differ according to character encoding)
+ * - Size does not take into account indentation that can be applied to JSON.stringify
+ * - Non-numerical properties of Arrays are ignored. Same behavior as JSON.stringify
+ *
+ * @param source              User-provided data meant to be serialized using JSON.stringify
+ * @param maxCharacterCount   Maximum number of characters allowed in serialized form
+ */
+
+export function sanitize(source, maxCharacterCount) {
+  if (maxCharacterCount === undefined) {
+    maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT;
+  } // Unbind any toJSON function we may have on [] or {} prototypes
+
+
+  var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype);
+  var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype); // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object
+
+  var containerQueue = [];
+  var visitedObjectsWithPath = new WeakMap();
+  var sanitizedData = sanitizeProcessor(source, JSON_PATH_ROOT_ELEMENT, undefined, containerQueue, visitedObjectsWithPath);
+  var accumulatedCharacterCount = JSON.stringify(sanitizedData) && JSON.stringify(sanitizedData).length || 0;
+
+  if (accumulatedCharacterCount > maxCharacterCount) {
+    warnOverCharacterLimit(maxCharacterCount, 'discarded', source);
+    return undefined;
+  }
+
+  while (containerQueue.length > 0 && accumulatedCharacterCount < maxCharacterCount) {
+    var containerToProcess = containerQueue.shift();
+    var separatorLength = 0; // 0 for the first element, 1 for subsequent elements
+    // Arrays and Objects have to be handled distinctly to ensure
+    // we do not pick up non-numerical properties from Arrays
+
+    if (Array.isArray(containerToProcess.source)) {
+      for (var key = 0; key < containerToProcess.source.length; key++) {
+        var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath);
+
+        if (targetData !== undefined) {
+          accumulatedCharacterCount += JSON.stringify(targetData).length;
+        } else {
+          // When an element of an Array (targetData) is undefined, it is serialized as null:
+          // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters
+          accumulatedCharacterCount += 4;
+        }
+
+        accumulatedCharacterCount += separatorLength;
+        separatorLength = 1;
+
+        if (accumulatedCharacterCount > maxCharacterCount) {
+          warnOverCharacterLimit(maxCharacterCount, 'truncated', source);
+          break;
+        }
+
+        containerToProcess.target[key] = targetData;
+      }
+    } else {
+      for (var key in containerToProcess.source) {
+        if (Object.prototype.hasOwnProperty.call(containerToProcess.source, key)) {
+          var targetData = sanitizeProcessor(containerToProcess.source[key], containerToProcess.path, key, containerQueue, visitedObjectsWithPath); // When a property of an object has an undefined value, it will be dropped during serialization:
+          // JSON.stringify({a:undefined}) => '{}'
+
+          if (targetData !== undefined) {
+            accumulatedCharacterCount += JSON.stringify(targetData).length + separatorLength + key.length + KEY_DECORATION_LENGTH;
+            separatorLength = 1;
+          }
+
+          if (accumulatedCharacterCount > maxCharacterCount) {
+            warnOverCharacterLimit(maxCharacterCount, 'truncated', source);
+            break;
+          }
+
+          containerToProcess.target[key] = targetData;
+        }
+      }
+    }
+  } // Rebind detached toJSON functions
+
+
+  restoreObjectPrototypeToJson();
+  restoreArrayPrototypeToJson();
+  return sanitizedData;
+}
+/**
+ * Internal function to factorize the process common to the
+ * initial call to sanitize, and iterations for Arrays and Objects
+ *
+ */
+
+function sanitizeProcessor(source, parentPath, key, queue, visitedObjectsWithPath) {
+  // Start by handling toJSON, as we want to sanitize its output
+  var sourceToSanitize = tryToApplyToJSON(source);
+
+  if (!sourceToSanitize || typeof sourceToSanitize !== 'object') {
+    return sanitizePrimitivesAndFunctions(sourceToSanitize);
+  }
+
+  var sanitizedSource = sanitizeObjects(sourceToSanitize);
+
+  if (sanitizedSource !== '[Object]' && sanitizedSource !== '[Array]' && sanitizedSource !== '[Error]') {
+    return sanitizedSource;
+  } // Handle potential cyclic references
+  // We need to use source as sourceToSanitize could be a reference to a new object
+  // At this stage, we know the source is an object type
+
+
+  var sourceAsObject = source;
+
+  if (visitedObjectsWithPath.has(sourceAsObject)) {
+    return '[Reference seen at ' + visitedObjectsWithPath.get(sourceAsObject) + ']';
+  } // Add processed source to queue
+
+
+  var currentPath = key !== undefined ? parentPath + '.' + key : parentPath;
+  var target = Array.isArray(sourceToSanitize) ? [] : {};
+  visitedObjectsWithPath.set(sourceAsObject, currentPath);
+  queue.push({
+    source: sourceToSanitize,
+    target,
+    path: currentPath
+  });
+  return target;
+}
+/**
+ * Handles sanitization of simple, non-object types
+ *
+ */
+
+
+function sanitizePrimitivesAndFunctions(value) {
+  // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation
+  if (typeof value === 'bigint') {
+    return '[BigInt] ' + value.toString();
+  } // Functions cannot be serialized by JSON.stringify(). Moreover, if a faulty toJSON is present, it needs to be converted
+  // so it won't prevent stringify from serializing later
+
+
+  if (typeof value === 'function') {
+    return '[Function] ' + value.name || 'unknown';
+  } // JSON.stringify() does not serialize symbols.
+
+
+  if (typeof value === 'symbol') {
+    // symbol.description is part of ES2019+
+    return '[Symbol] ' + value.description || value.toString();
+  }
+
+  return value;
+}
+/**
+ * Handles sanitization of object types
+ *
+ * LIMITATIONS
+ * - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.
+ * To avoid this, a toJSON method can be defined.
+ * - IE11 does not return a distinct type for objects such as Map, WeakMap, ... These objects will pass through and their
+ * properties enumerated if any.
+ *
+ */
+
+
+function sanitizeObjects(value) {
+  try {
+    // Handle events - Keep a simple implementation to avoid breaking changes
+    if (value instanceof Event) {
+      return {
+        isTrusted: value.isTrusted
+      };
+    } // Handle all remaining object types in a generic way
+
+
+    var result = Object.prototype.toString.call(value);
+    var match = result.match(/\[object (.*)\]/);
+
+    if (match && match[1]) {
+      return '[' + match[1] + ']';
+    }
+  } catch (_unused) {// If the previous serialization attempts failed, and we cannot convert using
+    // Object.prototype.toString, declare the value unserializable
+  }
+
+  return '[Unserializable]';
+}
+/**
+ * Checks if a toJSON function exists and tries to execute it
+ *
+ */
+
+
+function tryToApplyToJSON(value) {
+  var object = value;
+
+  if (object && typeof object.toJSON === 'function') {
+    try {
+      return object.toJSON();
+    } catch (_unused2) {// If toJSON fails, we continue by trying to serialize the value manually
+    }
+  }
+
+  return value;
+}
+/**
+ * Helper function to display the warning when the accumulated character count is over the limit
+ */
+
+
+function warnOverCharacterLimit(maxCharacterCount, changeType, source) {
+  display.warn('The data provided has been ' + changeType + ' as it is over the limit of ' + maxCharacterCount + ' characters:', source);
+}

package/esm/helper/tools.js

@@ -1558,6 +1558,10 @@ export function safeTruncate(candidate, length) {
 
   return candidate.slice(0, length);
 }
+export function isMatchOption(item) {
+  var itemType = getType(item);
+  return itemType === 'string' || itemType === 'function' || item instanceof RegExp;
+}
 export function includes(candidate, search) {
   // tslint:disable-next-line: no-unsafe-any
   return candidate.indexOf(search) !== -1;

package/esm/index.js

@@ -9,6 +9,7 @@ export * from './error/trackRuntimeError';
 export * from './console/consoleObservable';
 export * from './report/reportObservable';
 export * from './helper/display';
+export * from './helper/sanitize';
 export * from './helper/eventEmitter';
 export * from './helper/lifeCycle';
 export * from './helper/limitModification';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cloudcare/browser-core",
-    "version": "2.0.14",
+    "version": "2.0.16",
     "main": "cjs/index.js",
     "module": "esm/index.js",
     "scripts": {
@@ -20,5 +20,5 @@
     "author": "dataflux",
     "license": "MIT",
     "description": "DataFlux RUM Web 端数据指标监控",
-    "gitHead": "1aee6e645bb9cfe3f31fe88008e83c74087ce41c"
+    "gitHead": "d68cc2e25637dbe6a09461ca4186b882f878c169"
 }

package/src/dataMap.js

@@ -1,7 +1,7 @@
 import { RumEventType } from './helper/enums'
 export var commonTags = {
-  sdk_name: '_dd.sdk_name',
-  sdk_version: '_dd.sdk_version',
+  sdk_name: '_gc.sdk_name',
+  sdk_version: '_gc.sdk_version',
   app_id: 'application.id',
   env: 'env',
   service: 'service',
@@ -46,7 +46,7 @@ export var dataMap = {
     },
     fields: {
       is_active: 'view.is_active',
-      session_replay_stats: '_dd.replay_stats',
+      session_replay_stats: '_gc.replay_stats',
       session_is_active: 'session.is_active',
       view_error_count: 'view.error.count',
       view_resource_count: 'view.resource.count',
@@ -75,8 +75,8 @@ export var dataMap = {
   resource: {
     type: RumEventType.RESOURCE,
     tags: {
-      trace_id: '_dd.trace_id',
-      span_id: '_dd.span_id',
+      trace_id: '_gc.trace_id',
+      span_id: '_gc.span_id',
       resource_url: 'resource.url',
       resource_url_host: 'resource.url_host',
       resource_url_path: 'resource.url_path',
@@ -109,8 +109,8 @@ export var dataMap = {
     type: RumEventType.ERROR,
     tags: {
       error_id: 'error.id',
-      trace_id: '_dd.trace_id',
-      span_id: '_dd.span_id',
+      trace_id: '_gc.trace_id',
+      span_id: '_gc.span_id',
       error_source: 'error.source',
       error_type: 'error.type',
       error_handling: 'error.handling'
@@ -149,8 +149,8 @@ export var dataMap = {
       action_resource_count: 'action.resource.count',
       action_frustration_types: 'action.frustration.type',
       action_long_task_count: 'action.long_task.count',
-      action_target: '_dd.action.target',
-      action_position: '_dd.action.position'
+      action_target: '_gc.action.target',
+      action_position: '_gc.action.position'
     }
   },
   browser_log: {

package/src/helper/enums.js

@@ -78,6 +78,7 @@ export var TraceType = {
   ZIPKIN_MULTI_HEADER: 'zipkin',
   ZIPKIN_SINGLE_HEADER: 'zipkin_single_header',
   W3C_TRACEPARENT: 'w3c_traceparent',
+  W3C_TRACEPARENT_64: 'w3c_traceparent_64bit',
   SKYWALKING_V3: 'skywalking_v3',
   JAEGER: 'jaeger'
 }

package/src/helper/limitModification.js

@@ -1,18 +1,25 @@
-import { extend2Lev, each } from './tools'
+import { extend2Lev, each, objectEntries, getType, deepClone } from './tools'
+import { sanitize } from './sanitize'
 
 /**
- * Current limitations:
+ * Current limitation:
  * - field path do not support array, 'a.b.c' only
- * - modifiable fields type must be string
  */
 export function limitModification(object, modifiableFieldPaths, modifier) {
-  var clone = extend2Lev({}, object)
+  var clone = deepClone(object)
   var result = modifier(clone)
-  each(modifiableFieldPaths, function (path) {
-    var originalValue = get(object, path)
-    var newValue = get(clone, path)
-    if (typeof originalValue === 'string' && typeof newValue === 'string') {
-      set(object, path, newValue)
+  each(objectEntries(modifiableFieldPaths), function (filedPaths) {
+    var fieldPath = filedPaths[0]
+    var fieldType = filedPaths[1]
+    var newValue = get(clone, fieldPath)
+    var newType = getType(newValue)
+    if (newType === fieldType) {
+      set(object, fieldPath, sanitize(newValue))
+    } else if (
+      fieldType === 'object' &&
+      (newType === 'undefined' || newType === 'null')
+    ) {
+      set(object, fieldPath, {})
     }
   })
 
@@ -21,15 +28,12 @@ export function limitModification(object, modifiableFieldPaths, modifier) {
 
 function get(object, path) {
   var current = object
-  var fields = path.split('.')
-  for (var i = 0; i < fields.length; i++) {
-    var field = fields[i]
+  for (var field of path.split('.')) {
     if (!isValidObjectContaining(current, field)) {
       return
     }
     current = current[field]
   }
-
   return current
 }
 
@@ -38,7 +42,7 @@ function set(object, path, value) {
   var fields = path.split('.')
   for (var i = 0; i < fields.length; i += 1) {
     var field = fields[i]
-    if (!isValidObjectContaining(current, field)) {
+    if (!isValidObject(current)) {
       return
     }
     if (i !== fields.length - 1) {
@@ -49,6 +53,12 @@ function set(object, path, value) {
   }
 }
 
+function isValidObject(object) {
+  return getType(object) === 'object'
+}
+
 function isValidObjectContaining(object, field) {
-  return typeof object === 'object' && object !== null && field in object
+  return (
+    isValidObject(object) && Object.prototype.hasOwnProperty.call(object, field)
+  )
 }

package/src/helper/sanitize.js

@@ -0,0 +1,260 @@
+import { display } from './display'
+import { ONE_KIBI_BYTE } from './byteUtils'
+import { detachToJsonMethod } from './serialisation/jsonStringify'
+
+// The maximum size of a single event is 256KiB. By default, we ensure that user-provided data
+// going through sanitize fits inside our events, while leaving room for other contexts, metadata, ...
+var SANITIZE_DEFAULT_MAX_CHARACTER_COUNT = 220 * ONE_KIBI_BYTE
+
+// Symbol for the root element of the JSONPath used for visited objects
+var JSON_PATH_ROOT_ELEMENT = '$'
+
+// When serializing (using JSON.stringify) a key of an object, { key: 42 } gets wrapped in quotes as "key".
+// With the separator (:), we need to add 3 characters to the count.
+var KEY_DECORATION_LENGTH = 3
+
+/**
+ * Ensures user-provided data is 'safe' for the SDK
+ * - Deep clones data
+ * - Removes cyclic references
+ * - Transforms unserializable types to a string representation
+ *
+ * LIMITATIONS:
+ * - Size is in characters, not byte count (may differ according to character encoding)
+ * - Size does not take into account indentation that can be applied to JSON.stringify
+ * - Non-numerical properties of Arrays are ignored. Same behavior as JSON.stringify
+ *
+ * @param source              User-provided data meant to be serialized using JSON.stringify
+ * @param maxCharacterCount   Maximum number of characters allowed in serialized form
+ */
+
+export function sanitize(source, maxCharacterCount) {
+  if (maxCharacterCount === undefined) {
+    maxCharacterCount = SANITIZE_DEFAULT_MAX_CHARACTER_COUNT
+  }
+  // Unbind any toJSON function we may have on [] or {} prototypes
+  var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype)
+  var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype)
+
+  // Initial call to sanitizeProcessor - will populate containerQueue if source is an Array or a plain Object
+  var containerQueue = []
+  var visitedObjectsWithPath = new WeakMap()
+  var sanitizedData = sanitizeProcessor(
+    source,
+    JSON_PATH_ROOT_ELEMENT,
+    undefined,
+    containerQueue,
+    visitedObjectsWithPath
+  )
+  var accumulatedCharacterCount =
+    (JSON.stringify(sanitizedData) && JSON.stringify(sanitizedData).length) || 0
+  if (accumulatedCharacterCount > maxCharacterCount) {
+    warnOverCharacterLimit(maxCharacterCount, 'discarded', source)
+    return undefined
+  }
+
+  while (
+    containerQueue.length > 0 &&
+    accumulatedCharacterCount < maxCharacterCount
+  ) {
+    var containerToProcess = containerQueue.shift()
+    var separatorLength = 0 // 0 for the first element, 1 for subsequent elements
+
+    // Arrays and Objects have to be handled distinctly to ensure
+    // we do not pick up non-numerical properties from Arrays
+    if (Array.isArray(containerToProcess.source)) {
+      for (var key = 0; key < containerToProcess.source.length; key++) {
+        var targetData = sanitizeProcessor(
+          containerToProcess.source[key],
+          containerToProcess.path,
+          key,
+          containerQueue,
+          visitedObjectsWithPath
+        )
+
+        if (targetData !== undefined) {
+          accumulatedCharacterCount += JSON.stringify(targetData).length
+        } else {
+          // When an element of an Array (targetData) is undefined, it is serialized as null:
+          // JSON.stringify([undefined]) => '[null]' - This accounts for 4 characters
+          accumulatedCharacterCount += 4
+        }
+        accumulatedCharacterCount += separatorLength
+        separatorLength = 1
+        if (accumulatedCharacterCount > maxCharacterCount) {
+          warnOverCharacterLimit(maxCharacterCount, 'truncated', source)
+          break
+        }
+        containerToProcess.target[key] = targetData
+      }
+    } else {
+      for (var key in containerToProcess.source) {
+        if (
+          Object.prototype.hasOwnProperty.call(containerToProcess.source, key)
+        ) {
+          var targetData = sanitizeProcessor(
+            containerToProcess.source[key],
+            containerToProcess.path,
+            key,
+            containerQueue,
+            visitedObjectsWithPath
+          )
+          // When a property of an object has an undefined value, it will be dropped during serialization:
+          // JSON.stringify({a:undefined}) => '{}'
+          if (targetData !== undefined) {
+            accumulatedCharacterCount +=
+              JSON.stringify(targetData).length +
+              separatorLength +
+              key.length +
+              KEY_DECORATION_LENGTH
+            separatorLength = 1
+          }
+          if (accumulatedCharacterCount > maxCharacterCount) {
+            warnOverCharacterLimit(maxCharacterCount, 'truncated', source)
+            break
+          }
+          containerToProcess.target[key] = targetData
+        }
+      }
+    }
+  }
+
+  // Rebind detached toJSON functions
+  restoreObjectPrototypeToJson()
+  restoreArrayPrototypeToJson()
+
+  return sanitizedData
+}
+
+/**
+ * Internal function to factorize the process common to the
+ * initial call to sanitize, and iterations for Arrays and Objects
+ *
+ */
+function sanitizeProcessor(
+  source,
+  parentPath,
+  key,
+  queue,
+  visitedObjectsWithPath
+) {
+  // Start by handling toJSON, as we want to sanitize its output
+  var sourceToSanitize = tryToApplyToJSON(source)
+
+  if (!sourceToSanitize || typeof sourceToSanitize !== 'object') {
+    return sanitizePrimitivesAndFunctions(sourceToSanitize)
+  }
+
+  var sanitizedSource = sanitizeObjects(sourceToSanitize)
+  if (
+    sanitizedSource !== '[Object]' &&
+    sanitizedSource !== '[Array]' &&
+    sanitizedSource !== '[Error]'
+  ) {
+    return sanitizedSource
+  }
+
+  // Handle potential cyclic references
+  // We need to use source as sourceToSanitize could be a reference to a new object
+  // At this stage, we know the source is an object type
+  var sourceAsObject = source
+  if (visitedObjectsWithPath.has(sourceAsObject)) {
+    return (
+      '[Reference seen at ' + visitedObjectsWithPath.get(sourceAsObject) + ']'
+    )
+  }
+
+  // Add processed source to queue
+  var currentPath = key !== undefined ? parentPath + '.' + key : parentPath
+  var target = Array.isArray(sourceToSanitize) ? [] : {}
+  visitedObjectsWithPath.set(sourceAsObject, currentPath)
+  queue.push({ source: sourceToSanitize, target, path: currentPath })
+
+  return target
+}
+
+/**
+ * Handles sanitization of simple, non-object types
+ *
+ */
+function sanitizePrimitivesAndFunctions(value) {
+  // BigInt cannot be serialized by JSON.stringify(), convert it to a string representation
+  if (typeof value === 'bigint') {
+    return '[BigInt] ' + value.toString()
+  }
+  // Functions cannot be serialized by JSON.stringify(). Moreover, if a faulty toJSON is present, it needs to be converted
+  // so it won't prevent stringify from serializing later
+  if (typeof value === 'function') {
+    return '[Function] ' + value.name || 'unknown'
+  }
+  // JSON.stringify() does not serialize symbols.
+  if (typeof value === 'symbol') {
+    // symbol.description is part of ES2019+
+    return '[Symbol] ' + value.description || value.toString()
+  }
+
+  return value
+}
+
+/**
+ * Handles sanitization of object types
+ *
+ * LIMITATIONS
+ * - If a class defines a toStringTag Symbol, it will fall in the catch-all method and prevent enumeration of properties.
+ * To avoid this, a toJSON method can be defined.
+ * - IE11 does not return a distinct type for objects such as Map, WeakMap, ... These objects will pass through and their
+ * properties enumerated if any.
+ *
+ */
+function sanitizeObjects(value) {
+  try {
+    // Handle events - Keep a simple implementation to avoid breaking changes
+    if (value instanceof Event) {
+      return {
+        isTrusted: value.isTrusted
+      }
+    }
+
+    // Handle all remaining object types in a generic way
+    var result = Object.prototype.toString.call(value)
+    var match = result.match(/\[object (.*)\]/)
+    if (match && match[1]) {
+      return '[' + match[1] + ']'
+    }
+  } catch {
+    // If the previous serialization attempts failed, and we cannot convert using
+    // Object.prototype.toString, declare the value unserializable
+  }
+  return '[Unserializable]'
+}
+
+/**
+ * Checks if a toJSON function exists and tries to execute it
+ *
+ */
+function tryToApplyToJSON(value) {
+  var object = value
+  if (object && typeof object.toJSON === 'function') {
+    try {
+      return object.toJSON()
+    } catch {
+      // If toJSON fails, we continue by trying to serialize the value manually
+    }
+  }
+
+  return value
+}
+
+/**
+ * Helper function to display the warning when the accumulated character count is over the limit
+ */
+function warnOverCharacterLimit(maxCharacterCount, changeType, source) {
+  display.warn(
+    'The data provided has been ' +
+      changeType +
+      ' as it is over the limit of ' +
+      maxCharacterCount +
+      ' characters:',
+    source
+  )
+}

package/src/helper/tools.js

@@ -1542,7 +1542,12 @@ export function safeTruncate(candidate, length) {
   }
   return candidate.slice(0, length)
 }
-
+export function isMatchOption(item) {
+  const itemType = getType(item)
+  return (
+    itemType === 'string' || itemType === 'function' || item instanceof RegExp
+  )
+}
 export function includes(candidate, search) {
   // tslint:disable-next-line: no-unsafe-any
   return candidate.indexOf(search) !== -1

package/src/index.js

@@ -9,6 +9,7 @@ export * from './error/trackRuntimeError'
 export * from './console/consoleObservable'
 export * from './report/reportObservable'
 export * from './helper/display'
+export * from './helper/sanitize'
 export * from './helper/eventEmitter'
 export * from './helper/lifeCycle'
 export * from './helper/limitModification'