@cloudcare/rum-uniapp 2.1.15 → 2.1.17

package/esm/boot/rum.entry.js

@@ -1,14 +1,42 @@
-import { isPercentage, extend2Lev, extend, now, createContextManager, defineGlobal, getGlobalObject, isString, isObject } from '../helper/utils';
+import { isPercentage, extend2Lev, defineGlobal, getGlobalObject, now, deepClone } from '../helper/utils';
 import { startRum } from './rum';
 import { ActionType } from '../helper/enums';
+import { buildCommonContext } from '../helper/commonContext';
+import { BoundedBuffer } from '../core/boundedBuffer';
+import { createContextManager } from '../core/contextManager';
+import { CustomerDataType } from '../core/heavyCustomerDataWarning';
+import { checkUser, sanitizeUser } from '../core/user';
+import { sdk } from '../core/sdk';
 export var makeRum = function makeRum(startRumImpl) {
   var isAlreadyInitialized = false;
-  var globalContextManager = createContextManager();
-  var user = {};
+  var globalContextManager = createContextManager(CustomerDataType.GlobalContext);
+  var userContextManager = createContextManager(CustomerDataType.User); //   var user = {}
 
-  var _getInternalContext = function getInternalContext() {};
+  var getInternalContextStrategy = function getInternalContextStrategy() {
+    return undefined;
+  };
+
+  var bufferApiCalls = new BoundedBuffer();
+
+  var _addActionStrategy = function addActionStrategy(action, commonContext) {
+    if (typeof commonContext == 'undefined') {
+      commonContext = buildCommonContext(globalContextManager, userContextManager);
+    }
 
-  var addActionStrategy = function addActionStrategy() {};
+    bufferApiCalls.add(function () {
+      return _addActionStrategy(action, commonContext);
+    });
+  };
+
+  var _addErrorStrategy = function addErrorStrategy(providedError, commonContext) {
+    if (typeof commonContext == 'undefined') {
+      commonContext = buildCommonContext(globalContextManager, userContextManager);
+    }
+
+    bufferApiCalls.add(function () {
+      return _addErrorStrategy(providedError, commonContext);
+    });
+  };
 
   var rumGlobal = {
     init: function init(Vue, userConfiguration) {
@@ -23,14 +51,13 @@ export var makeRum = function makeRum(startRumImpl) {
       }
 
       var _startRumImpl = startRumImpl(Vue, userConfiguration, function () {
-        return {
-          user: user,
-          context: globalContextManager.get()
-        };
+        return 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) {
@@ -39,38 +66,51 @@ export var makeRum = function makeRum(startRumImpl) {
       }, 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 (isObject(context) && isString(name)) {
-        addActionStrategy({
-          name: name,
-          context: extend2Lev({}, context),
-          startClocks: now(),
-          type: ActionType.custom
-        });
-      }
+      _addActionStrategy({
+        name: name,
+        context: deepClone(context),
+        startClocks: now(),
+        type: ActionType.custom
+      });
     },
+    addError: function addError(error, context) {
+      _addErrorStrategy({
+        error: error,
+        context: extend2Lev({}, context),
+        startTime: now()
+      });
+    },
+    setUserProperty: function setUserProperty(key, property) {
+      var newUser = {};
+      newUser[key] = property;
+      var sanitizedProperty = 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 (checkUser(newUser)) {
+        userContextManager.setContext(sanitizeUser(newUser));
       }
     },
-    removeUser: function removeUser() {
-      user = {};
-    }
+    getUser: userContextManager.getContext,
+    removeUser: userContextManager.clearContext
   };
   return rumGlobal;
 
   function canInitRum(userConfiguration) {
+    if (!sdk) {
+      console.error('DATAFLUX_RUM unsupport platform, Fail to start.');
+      return false;
+    }
+
     if (isAlreadyInitialized) {
       console.error('DATAFLUX_RUM is already initialized.');
       return false;
@@ -93,28 +133,6 @@ export var makeRum = function makeRum(startRumImpl) {
 
     return true;
   }
-
-  function sanitizeUser(newUser) {
-    if (typeof newUser !== 'object' || !newUser) {
-      return;
-    }
-
-    var result = 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;
-  }
 };
 export var datafluxRum = makeRum(startRum);
 defineGlobal(getGlobalObject(), 'DATAFLUX_RUM_MIN', datafluxRum);

package/esm/boot/rum.js

@@ -14,7 +14,6 @@ import { startSetDataColloction } from '../rumEventsCollection/setDataCollection
 import { startActionCollection } from '../rumEventsCollection/action/actionCollection';
 import { sessionManagement } from '../core/sessionManagement';
 import { startInternalContext } from '../rumEventsCollection/internalContext';
-import { sdk } from '../core/sdk';
 export var startRum = function startRum(Vue, userConfiguration, getCommonContext) {
   var configuration = commonInit(userConfiguration, buildEnv);
   var lifeCycle = new LifeCycle();
@@ -25,7 +24,9 @@ export var startRum = function startRum(Vue, userConfiguration, getCommonContext
   startAppCollection(lifeCycle, configuration);
   startResourceCollection(lifeCycle, configuration);
   startViewCollection(lifeCycle, configuration, Vue);
-  startErrorCollection(lifeCycle, configuration);
+
+  var _startErrorCollection = startErrorCollection(lifeCycle, configuration);
+
   startRequestCollection(lifeCycle, configuration);
   startPagePerformanceObservable(lifeCycle, configuration);
   startSetDataColloction(lifeCycle, Vue);
@@ -35,6 +36,7 @@ export var startRum = function startRum(Vue, userConfiguration, getCommonContext
   var internalContext = startInternalContext(userConfiguration.applicationId, session, parentContexts);
   return {
     addAction: _startActionCollection.addAction,
+    addError: _startErrorCollection.addError,
     getInternalContext: internalContext.get
   };
 };

package/esm/core/baseInfo.js

@@ -20,7 +20,7 @@ class BaseInfo {
         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,
@@ -62,6 +62,18 @@ class BaseInfo {
     });
   }
 
+  getLaunchOptions() {
+    if (sdk.getLaunchOptionsSync) {
+      var res = sdk.getLaunchOptionsSync();
+      return {
+        query: res && res.query || {},
+        referrerInfo: res && res.referrerInfo || {}
+      };
+    } else {
+      return {};
+    }
+  }
+
 }
 
 export default new BaseInfo();

package/esm/core/boundedBuffer.js

@@ -1,18 +1,21 @@
+import { each } from '../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() {
+    each(this.buffer, function (callback) {
+      callback();
     });
     this.buffer.length = 0;
   }

package/esm/core/contextManager.js

@@ -0,0 +1,70 @@
+import { computeBytesCount } from '../helper/byteUtils';
+import { deepClone, throttle } from '../helper/utils';
+import { jsonStringify } from '../helper/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/core/dataMap.js

@@ -29,6 +29,10 @@ export var commonTags = {
   view_name: 'page.route',
   view_referer: 'page.referer'
 };
+export var commonFields = {
+  app_launch_query: 'app.launch.query',
+  app_launch_referrer_info: 'app.launch.referrer_info'
+};
 export var dataMap = {
   view: {
     type: RumEventType.VIEW,

package/esm/core/heavyCustomerDataWarning.js

@@ -0,0 +1,19 @@
+import { ONE_KIBI_BYTE } from '../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
+
+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) {
+    console.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/core/transport.js

@@ -1,7 +1,8 @@
 import { findByPath, escapeRowData, isNumber, each, isString, values, extend, isObject, isEmptyObject, isArray, escapeRowField, escapeJsonValue, toServerDuration } from '../helper/utils';
 import { sdk } from '../core/sdk';
+import { computeBytesCount } from '../helper/byteUtils';
 import { LifeCycleEventType } from '../core/lifeCycle';
-import { commonTags, dataMap } from './dataMap'; // https://en.wikipedia.org/wiki/UTF-8
+import { commonTags, dataMap, commonFields } from './dataMap'; // https://en.wikipedia.org/wiki/UTF-8
 
 var HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/;
 var CUSTOM_KEYS = 'custom_keys';
@@ -64,8 +65,9 @@ export var processedMessageByDataMap = function processedMessageByDataMap(messag
           tagsStr.push(escapeRowData(_key) + '=' + escapeRowData(_value));
         }
       });
+      var fields = extend({}, commonFields, value.fields);
       var fieldsStr = [];
-      each(value.fields, function (_value, _key) {
+      each(fields, function (_value, _key) {
         if (isArray(_value) && _value.length === 2) {
           var type = _value[0],
               value_path = _value[1];
@@ -170,31 +172,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;
@@ -220,7 +197,7 @@ batch.prototype = {
   },
   process: function process(message) {
     var processedMessage = this.processSendData(message);
-    var messageBytesSize = this.sizeInBytes(processedMessage);
+    var messageBytesSize = computeBytesCount(processedMessage);
     return {
       processedMessage: processedMessage,
       messageBytesSize: messageBytesSize
@@ -244,7 +221,7 @@ batch.prototype = {
   remove: function remove(key) {
     var removedMessage = this.upsertBuffer[key];
     delete this.upsertBuffer[key];
-    var messageBytesSize = this.sizeInBytes(removedMessage);
+    var messageBytesSize = computeBytesCount(removedMessage);
     this.bufferBytesSize -= messageBytesSize;
     this.bufferMessageCount -= 1;
 

package/esm/core/user.js

@@ -0,0 +1,31 @@
+import { extend, getType, each } from '../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
+ */
+
+export function sanitizeUser(newUser) {
+  // We shallow clone only to prevent mutation of user data.
+  var user = extend({}, newUser);
+  var keys = ['id', 'name', 'email'];
+  each(keys, function (key) {
+    if (key in user) {
+      user[key] = String(user[key]);
+    }
+  });
+  return user;
+}
+/**
+ * Simple check to ensure user is valid
+ */
+
+export function checkUser(newUser) {
+  var isValid = getType(newUser) === 'object';
+
+  if (!isValid) {
+    console.error('Unsupported user:', newUser);
+  }
+
+  return isValid;
+}

package/esm/core/xhrProxy.js

@@ -46,27 +46,23 @@ function proxyXhr(userConfiguration) {
     dataflux_xhr.startTime = now();
     var originalSuccess = arguments[0].success;
 
-    if (typeof originalSuccess === 'function') {
-      arguments[0].success = function () {
-        reportXhr(arguments[0]);
+    arguments[0].success = function () {
+      reportXhr(arguments[0]);
 
-        if (originalSuccess) {
-          originalSuccess.apply(_this, arguments);
-        }
-      };
-    }
+      if (typeof originalSuccess === 'function') {
+        originalSuccess.apply(_this, arguments);
+      }
+    };
 
     var originalFail = arguments[0].fail;
 
-    if (typeof originalFail === 'function') {
-      arguments[0].fail = function () {
-        reportXhr(arguments[0]);
+    arguments[0].fail = function () {
+      reportXhr(arguments[0]);
 
-        if (originalFail) {
-          originalFail.apply(_this, arguments);
-        }
-      };
-    }
+      if (typeof originalFail === 'function') {
+        originalFail.apply(_this, arguments);
+      }
+    };
 
     var hasBeenReported = false;
 
@@ -92,7 +88,7 @@ function proxyXhr(userConfiguration) {
     var result = originalXhrRequest.call(this, dataflux_xhr.option); // 判断结果是否为promise
 
     var isPromise = function isPromise(obj) {
-      return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+      return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
     };
 
     if (isPromise(result) && userConfiguration.isVue2) {

package/esm/helper/byteUtils.js

@@ -0,0 +1,29 @@
+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 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/esm/helper/commonContext.js

@@ -0,0 +1,7 @@
+export function buildCommonContext(globalContextManager, userContextManager) {
+  return {
+    context: globalContextManager.getContext(),
+    user: userContextManager.getContext() // hasReplay: recorderApi.isRecording() ? true : undefined,
+
+  };
+}

package/esm/helper/jsonStringify.js

@@ -0,0 +1,46 @@
+import { noop } from './utils';
+/**
+ * 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 (error) {
+    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/tracekit.js

@@ -81,6 +81,7 @@ export var report = function reportModuleWrapper() {
     installGlobalUnhandledRejectionHandler();
     installGlobalOnPageNotFoundHandler();
     installGlobalOnMemoryWarningHandler();
+    installGlobalOnLazyLoadErrorHandler();
     handlers.push(handler);
   }
   /**
@@ -128,7 +129,8 @@ export var report = function reportModuleWrapper() {
   var onErrorHandlerInstalled;
   var onUnhandledRejectionHandlerInstalled;
   var onPageNotFoundHandlerInstalled;
-  var onOnMemoryWarningHandlerInstalled;
+  var onMemoryWarningHandlerInstalled;
+  var onLazyLoadErrorHandlerInstalled;
   /**
    * Ensures all global unhandled exceptions are recorded.
    * Supported by Gecko and IE.
@@ -261,7 +263,7 @@ export var report = function reportModuleWrapper() {
   }
 
   function installGlobalOnMemoryWarningHandler() {
-    if (onOnMemoryWarningHandlerInstalled || !sdk.onMemoryWarning) {
+    if (onMemoryWarningHandlerInstalled || !sdk.onMemoryWarning) {
       return;
     }
 
@@ -294,7 +296,23 @@ export var report = function reportModuleWrapper() {
         name: '内存不足告警'
       }, true, {});
     });
-    onOnMemoryWarningHandlerInstalled = true;
+    onMemoryWarningHandlerInstalled = true;
+  }
+
+  function installGlobalOnLazyLoadErrorHandler() {
+    if (onLazyLoadErrorHandlerInstalled || !sdk.onLazyLoadError) {
+      return;
+    }
+
+    sdk.onLazyLoadError(res => {
+      var subpackage = res.subpackage || [];
+      notifyHandlers({
+        message: res.errMsg || '',
+        type: 'lazyloaderror',
+        name: subpackage.join(',') + 'load error'
+      }, true, {});
+    });
+    onLazyLoadErrorHandlerInstalled = true;
   }
   /**
    * Reports an unhandled Error.
@@ -904,7 +922,7 @@ export var computeStackTrace = function computeStackTraceWrapper() {
 var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/;
 
 function extractMessage(ex) {
-  var message = ex && ex.message;
+  var message = ex && ex.message; // console.log('message',message)
 
   if (!message) {
     return 'No error message';