@cloudcare/rum-uniapp 2.1.16 → 2.1.17

package/cjs/boot/buildEnv.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.buildEnv = void 0;
 var buildEnv = {
-  sdkVersion: '2.1.16',
+  sdkVersion: '2.1.17',
   sdkName: 'df_uniapp_rum_sdk'
 };
 exports.buildEnv = buildEnv;

package/cjs/boot/rum.entry.js

@@ -11,16 +11,48 @@ var _rum = require("./rum");
 
 var _enums = require("../helper/enums");
 
-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 _commonContext = require("../helper/commonContext");
+
+var _boundedBuffer = require("../core/boundedBuffer");
+
+var _contextManager = require("../core/contextManager");
+
+var _heavyCustomerDataWarning = require("../core/heavyCustomerDataWarning");
+
+var _user = require("../core/user");
+
+var _sdk = require("../core/sdk");
 
 var makeRum = function makeRum(startRumImpl) {
   var isAlreadyInitialized = false;
-  var globalContextManager = (0, _utils.createContextManager)();
-  var user = {};
+  var globalContextManager = (0, _contextManager.createContextManager)(_heavyCustomerDataWarning.CustomerDataType.GlobalContext);
+  var userContextManager = (0, _contextManager.createContextManager)(_heavyCustomerDataWarning.CustomerDataType.User); //   var user = {}
+
+  var getInternalContextStrategy = function getInternalContextStrategy() {
+    return undefined;
+  };
+
+  var bufferApiCalls = new _boundedBuffer.BoundedBuffer();
+
+  var _addActionStrategy = function addActionStrategy(action, commonContext) {
+    if (typeof commonContext == 'undefined') {
+      commonContext = (0, _commonContext.buildCommonContext)(globalContextManager, userContextManager);
+    }
 
-  var _getInternalContext = function getInternalContext() {};
+    bufferApiCalls.add(function () {
+      return _addActionStrategy(action, commonContext);
+    });
+  };
 
-  var addActionStrategy = function addActionStrategy() {};
+  var _addErrorStrategy = function addErrorStrategy(providedError, commonContext) {
+    if (typeof commonContext == 'undefined') {
+      commonContext = (0, _commonContext.buildCommonContext)(globalContextManager, userContextManager);
+    }
+
+    bufferApiCalls.add(function () {
+      return _addErrorStrategy(providedError, commonContext);
+    });
+  };
 
   var rumGlobal = {
     init: function init(Vue, userConfiguration) {
@@ -35,54 +67,66 @@ var makeRum = function makeRum(startRumImpl) {
       }
 
       var _startRumImpl = startRumImpl(Vue, userConfiguration, function () {
-        return {
-          user: user,
-          context: globalContextManager.get()
-        };
+        return (0, _commonContext.buildCommonContext)(globalContextManager, userContextManager);
       });
 
-      _getInternalContext = _startRumImpl.getInternalContext;
-      addActionStrategy = _startRumImpl.addAction;
+      getInternalContextStrategy = _startRumImpl.getInternalContext;
+      _addActionStrategy = _startRumImpl.addAction;
+      _addErrorStrategy = _startRumImpl.addError;
+      bufferApiCalls.drain();
       isAlreadyInitialized = true;
     },
     initVue3: function initVue3(userConfiguration) {
-      this.init({}, (0, _utils.extend)({
+      this.init({}, extend({
         isVue2: false
       }, userConfiguration));
     },
     getInternalContext: function getInternalContext(startTime) {
-      return _getInternalContext(startTime);
+      return getInternalContextStrategy(startTime);
     },
-    addRumGlobalContext: globalContextManager.add,
-    removeRumGlobalContext: globalContextManager.remove,
-    getRumGlobalContext: globalContextManager.get,
-    setRumGlobalContext: globalContextManager.set,
+    addRumGlobalContext: globalContextManager.setContextProperty,
+    removeRumGlobalContext: globalContextManager.removeContextProperty,
+    getRumGlobalContext: globalContextManager.getContext,
+    setRumGlobalContext: globalContextManager.setContext,
+    clearRumGlobalContext: globalContextManager.clearContext,
     addAction: function addAction(name, context) {
-      if ((0, _utils.isObject)(context) && (0, _utils.isString)(name)) {
-        addActionStrategy({
-          name: name,
-          context: (0, _utils.extend2Lev)({}, context),
-          startClocks: (0, _utils.now)(),
-          type: _enums.ActionType.custom
-        });
-      }
+      _addActionStrategy({
+        name: name,
+        context: (0, _utils.deepClone)(context),
+        startClocks: (0, _utils.now)(),
+        type: _enums.ActionType.custom
+      });
+    },
+    addError: function addError(error, context) {
+      _addErrorStrategy({
+        error: error,
+        context: (0, _utils.extend2Lev)({}, context),
+        startTime: (0, _utils.now)()
+      });
     },
+    setUserProperty: function setUserProperty(key, property) {
+      var newUser = {};
+      newUser[key] = property;
+      var sanitizedProperty = (0, _user.sanitizeUser)(newUser)[key];
+      userContextManager.setContextProperty(key, sanitizedProperty);
+    },
+    removeUserProperty: userContextManager.removeContextProperty,
     setUser: function setUser(newUser) {
-      var sanitizedUser = sanitizeUser(newUser);
-
-      if (sanitizedUser) {
-        user = sanitizedUser;
-      } else {
-        console.error('Unsupported user:', newUser);
+      if ((0, _user.checkUser)(newUser)) {
+        userContextManager.setContext((0, _user.sanitizeUser)(newUser));
       }
     },
-    removeUser: function removeUser() {
-      user = {};
-    }
+    getUser: userContextManager.getContext,
+    removeUser: userContextManager.clearContext
   };
   return rumGlobal;
 
   function canInitRum(userConfiguration) {
+    if (!_sdk.sdk) {
+      console.error('DATAFLUX_RUM unsupport platform, Fail to start.');
+      return false;
+    }
+
     if (isAlreadyInitialized) {
       console.error('DATAFLUX_RUM is already initialized.');
       return false;
@@ -105,28 +149,6 @@ var makeRum = function makeRum(startRumImpl) {
 
     return true;
   }
-
-  function sanitizeUser(newUser) {
-    if (_typeof(newUser) !== 'object' || !newUser) {
-      return;
-    }
-
-    var result = (0, _utils.extend2Lev)({}, newUser);
-
-    if ('id' in result) {
-      result.id = String(result.id);
-    }
-
-    if ('name' in result) {
-      result.name = String(result.name);
-    }
-
-    if ('email' in result) {
-      result.email = String(result.email);
-    }
-
-    return result;
-  }
 };
 
 exports.makeRum = makeRum;

package/cjs/boot/rum.js

@@ -37,8 +37,6 @@ var _sessionManagement = require("../core/sessionManagement");
 
 var _internalContext = require("../rumEventsCollection/internalContext");
 
-var _sdk = require("../core/sdk");
-
 var startRum = function startRum(Vue, userConfiguration, getCommonContext) {
   var configuration = (0, _configuration.commonInit)(userConfiguration, _buildEnv.buildEnv);
   var lifeCycle = new _lifeCycle.LifeCycle();
@@ -49,7 +47,9 @@ var startRum = function startRum(Vue, userConfiguration, getCommonContext) {
   (0, _appCollection.startAppCollection)(lifeCycle, configuration);
   (0, _resourceCollection.startResourceCollection)(lifeCycle, configuration);
   (0, _viewCollection.startViewCollection)(lifeCycle, configuration, Vue);
-  (0, _errorCollection.startErrorCollection)(lifeCycle, configuration);
+
+  var _startErrorCollection = (0, _errorCollection.startErrorCollection)(lifeCycle, configuration);
+
   (0, _requestCollection.startRequestCollection)(lifeCycle, configuration);
   (0, _performanceCollection.startPagePerformanceObservable)(lifeCycle, configuration);
   (0, _setDataCollection.startSetDataColloction)(lifeCycle, Vue);
@@ -59,6 +59,7 @@ var startRum = function startRum(Vue, userConfiguration, getCommonContext) {
   var internalContext = (0, _internalContext.startInternalContext)(userConfiguration.applicationId, session, parentContexts);
   return {
     addAction: _startActionCollection.addAction,
+    addError: _startErrorCollection.addError,
     getInternalContext: internalContext.get
   };
 };

package/cjs/core/baseInfo.js

@@ -40,7 +40,7 @@ var BaseInfo = /*#__PURE__*/function () {
           osVersion = osInfo[0] || '';
         }
 
-        var osVersionMajor = osVersion.split('.').length && osVersion.split('.')[0];
+        var osVersionMajor = osVersion && osVersion.split('.').length && osVersion.split('.')[0];
         this.deviceInfo = {
           screenSize: "".concat(deviceInfo.screenWidth, "*").concat(deviceInfo.screenHeight, " "),
           platform: deviceInfo.platform,
@@ -87,6 +87,20 @@ var BaseInfo = /*#__PURE__*/function () {
         _this.deviceInfo.network = e.networkType ? e.networkType : 'unknown';
       });
     }
+  }, {
+    key: "getLaunchOptions",
+    value: function getLaunchOptions() {
+      if (_sdk.sdk.getLaunchOptionsSync) {
+        var res = _sdk.sdk.getLaunchOptionsSync();
+
+        return {
+          query: res && res.query || {},
+          referrerInfo: res && res.referrerInfo || {}
+        };
+      } else {
+        return {};
+      }
+    }
   }]);
 
   return BaseInfo;

package/cjs/core/boundedBuffer.js

@@ -5,21 +5,25 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.BoundedBuffer = void 0;
 
+var _utils = require("../helper/utils");
+
+var BUFFER_LIMIT = 500;
+
 var _BoundedBuffer = function _BoundedBuffer() {
   this.buffer = [];
 };
 
 _BoundedBuffer.prototype = {
-  add: function add(item) {
-    var length = this.buffer.push(item);
+  add: function add(callback) {
+    var length = this.buffer.push(callback);
 
-    if (length > this.limit) {
+    if (length > BUFFER_LIMIT) {
       this.buffer.splice(0, 1);
     }
   },
-  drain: function drain(fn) {
-    this.buffer.forEach(function (item) {
-      fn(item);
+  drain: function drain() {
+    (0, _utils.each)(this.buffer, function (callback) {
+      callback();
     });
     this.buffer.length = 0;
   }

package/cjs/core/contextManager.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createContextManager = createContextManager;
+exports.BYTES_COMPUTATION_THROTTLING_DELAY = void 0;
+
+var _byteUtils = require("../helper/byteUtils");
+
+var _utils = require("../helper/utils");
+
+var _jsonStringify = require("../helper/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, _utils.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, _utils.deepClone)(context);
+    },
+    setContext: function setContext(newContext) {
+      context = (0, _utils.deepClone)(newContext);
+      computeBytesCountThrottled(context);
+    },
+    setContextProperty: function setContextProperty(key, property) {
+      context[key] = (0, _utils.deepClone)(property);
+      computeBytesCountThrottled(context);
+    },
+    removeContextProperty: function removeContextProperty(key) {
+      delete context[key];
+      computeBytesCountThrottled(context);
+    },
+    clearContext: function clearContext() {
+      context = {};
+      bytesCountCache = 0;
+    }
+  };
+}

package/cjs/core/dataMap.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.dataMap = exports.commonTags = void 0;
+exports.dataMap = exports.commonFields = exports.commonTags = void 0;
 
 var _enums = require("../helper/enums");
 
@@ -38,6 +38,11 @@ var commonTags = {
   view_referer: 'page.referer'
 };
 exports.commonTags = commonTags;
+var commonFields = {
+  app_launch_query: 'app.launch.query',
+  app_launch_referrer_info: 'app.launch.referrer_info'
+};
+exports.commonFields = commonFields;
 var dataMap = {
   view: {
     type: _enums.RumEventType.VIEW,

package/cjs/core/heavyCustomerDataWarning.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.warnIfCustomerDataLimitReached = warnIfCustomerDataLimitReached;
+exports.CustomerDataType = exports.CUSTOMER_DATA_BYTES_LIMIT = void 0;
+
+var _byteUtils = require("../helper/byteUtils");
+
+// 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) {
+    console.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/core/transport.js

@@ -9,6 +9,8 @@ var _utils = require("../helper/utils");
 
 var _sdk = require("../core/sdk");
 
+var _byteUtils = require("../helper/byteUtils");
+
 var _lifeCycle = require("../core/lifeCycle");
 
 var _dataMap = require("./dataMap");
@@ -78,8 +80,9 @@ var processedMessageByDataMap = function processedMessageByDataMap(message) {
           tagsStr.push((0, _utils.escapeRowData)(_key) + '=' + (0, _utils.escapeRowData)(_value));
         }
       });
+      var fields = (0, _utils.extend)({}, _dataMap.commonFields, value.fields);
       var fieldsStr = [];
-      (0, _utils.each)(value.fields, function (_value, _key) {
+      (0, _utils.each)(fields, function (_value, _key) {
         if ((0, _utils.isArray)(_value) && _value.length === 2) {
           var type = _value[0],
               value_path = _value[1];
@@ -186,31 +189,6 @@ batch.prototype = {
   processSendData: function processSendData(message) {
     return processedMessageByDataMap(message).rowStr;
   },
-  sizeInBytes: function sizeInBytes(candidate) {
-    // Accurate byte size computations can degrade performances when there is a lot of events to process
-    if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {
-      return candidate.length;
-    }
-
-    var total = 0,
-        charCode; // utf-8编码
-
-    for (var i = 0, len = candidate.length; i < len; i++) {
-      charCode = candidate.charCodeAt(i);
-
-      if (charCode <= 0x007f) {
-        total += 1;
-      } else if (charCode <= 0x07ff) {
-        total += 2;
-      } else if (charCode <= 0xffff) {
-        total += 3;
-      } else {
-        total += 4;
-      }
-    }
-
-    return total;
-  },
   addOrUpdate: function addOrUpdate(message, key) {
     var process = this.process(message);
     if (!process.processedMessage || process.processedMessage === '') return;
@@ -236,7 +214,7 @@ batch.prototype = {
   },
   process: function process(message) {
     var processedMessage = this.processSendData(message);
-    var messageBytesSize = this.sizeInBytes(processedMessage);
+    var messageBytesSize = (0, _byteUtils.computeBytesCount)(processedMessage);
     return {
       processedMessage: processedMessage,
       messageBytesSize: messageBytesSize
@@ -260,7 +238,7 @@ batch.prototype = {
   remove: function remove(key) {
     var removedMessage = this.upsertBuffer[key];
     delete this.upsertBuffer[key];
-    var messageBytesSize = this.sizeInBytes(removedMessage);
+    var messageBytesSize = (0, _byteUtils.computeBytesCount)(removedMessage);
     this.bufferBytesSize -= messageBytesSize;
     this.bufferMessageCount -= 1;
 

package/cjs/core/user.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sanitizeUser = sanitizeUser;
+exports.checkUser = checkUser;
+
+var _utils = require("../helper/utils");
+
+/**
+ * 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, _utils.extend)({}, newUser);
+  var keys = ['id', 'name', 'email'];
+  (0, _utils.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, _utils.getType)(newUser) === 'object';
+
+  if (!isValid) {
+    console.error('Unsupported user:', newUser);
+  }
+
+  return isValid;
+}

package/cjs/helper/byteUtils.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeBytesCount = computeBytesCount;
+exports.ONE_MEBI_BYTE = exports.ONE_KIBI_BYTE = void 0;
+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 byte size computations can degrade performances when there is a lot of events to process
+  if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {
+    return candidate.length;
+  }
+
+  var total = 0,
+      charCode; // utf-8编码
+
+  for (var i = 0, len = candidate.length; i < len; i++) {
+    charCode = candidate.charCodeAt(i);
+
+    if (charCode <= 0x007f) {
+      total += 1;
+    } else if (charCode <= 0x07ff) {
+      total += 2;
+    } else if (charCode <= 0xffff) {
+      total += 3;
+    } else {
+      total += 4;
+    }
+  }
+
+  return total;
+}

package/cjs/helper/commonContext.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCommonContext = buildCommonContext;
+
+function buildCommonContext(globalContextManager, userContextManager) {
+  return {
+    context: globalContextManager.getContext(),
+    user: userContextManager.getContext() // hasReplay: recorderApi.isRecording() ? true : undefined,
+
+  };
+}

package/cjs/helper/jsonStringify.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsonStringify = jsonStringify;
+exports.detachToJsonMethod = detachToJsonMethod;
+
+var _utils = require("./utils");
+
+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 (error) {
+    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 _utils.noop;
+}