@cloudcare/browser-core 1.1.3 → 1.2.0

package/cjs/helper/contextHistory.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CLEAR_OLD_CONTEXTS_INTERVAL = void 0;
+exports.ContextHistory = ContextHistory;
+
+var _tools = require("./tools");
+
+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; }
+
+var END_OF_TIMES = Infinity;
+var CLEAR_OLD_CONTEXTS_INTERVAL = _tools.ONE_MINUTE;
+exports.CLEAR_OLD_CONTEXTS_INTERVAL = CLEAR_OLD_CONTEXTS_INTERVAL;
+
+function ContextHistory(expireDelay) {
+  this.expireDelay = expireDelay;
+  this.entries = [];
+
+  var _this = this;
+
+  this.clearOldContextsInterval = setInterval(function () {
+    _this.clearOldContexts();
+  }, CLEAR_OLD_CONTEXTS_INTERVAL);
+}
+
+ContextHistory.prototype.add = function (context, startTime) {
+  var _this = this;
+
+  var entry = {
+    context: context,
+    startTime: startTime,
+    endTime: END_OF_TIMES,
+    remove: function remove() {
+      var index = _this.entries.indexOf(entry);
+
+      if (index >= 0) {
+        _this.entries.splice(index, 1);
+      }
+    },
+    close: function close(endTime) {
+      entry.endTime = endTime;
+    }
+  };
+  this.entries.unshift(entry);
+  return entry;
+};
+
+ContextHistory.prototype.find = function (startTime) {
+  if (typeof startTime === 'undefined') {
+    startTime = END_OF_TIMES;
+  }
+
+  var _iterator = _createForOfIteratorHelper(this.entries),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var entry = _step.value;
+
+      if (entry.startTime <= startTime) {
+        if (startTime <= entry.endTime) {
+          return entry.context;
+        }
+
+        break;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+};
+/**
+ * Helper function to close the currently active context, if any. This method assumes that entries
+ * are not overlapping.
+ */
+
+
+ContextHistory.prototype.closeActive = function (endTime) {
+  var latestEntry = this.entries[0];
+
+  if (latestEntry && latestEntry.endTime === END_OF_TIMES) {
+    latestEntry.close(endTime);
+  }
+};
+/**
+ * Return all contexts that were active during `startTime`, or all currently active contexts if no
+ * `startTime` is provided.
+ */
+
+
+ContextHistory.prototype.findAll = function (startTime) {
+  if (typeof startTime === 'undefined') {
+    startTime = END_OF_TIMES;
+  }
+
+  var result = (0, _tools.filter)(this.entries, function (entry) {
+    return entry.startTime <= startTime && startTime <= entry.endTime;
+  });
+  return (0, _tools.map)(result, function (entry) {
+    return entry.context;
+  });
+};
+/**
+ * Remove all entries from this collection.
+ */
+
+
+ContextHistory.prototype.reset = function () {
+  this.entries = [];
+};
+/**
+ * Stop internal garbage collection of past entries.
+ */
+
+
+ContextHistory.prototype.stop = function () {
+  clearInterval(this.clearOldContextsInterval);
+};
+
+ContextHistory.prototype.clearOldContexts = function () {
+  var oldTimeThreshold = (0, _tools.relativeNow)() - this.expireDelay;
+
+  while (this.entries.length > 0 && this.entries[this.entries.length - 1].endTime < oldTimeThreshold) {
+    this.entries.pop();
+  }
+};

package/cjs/helper/createEventRateLimiter.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEventRateLimiter = createEventRateLimiter;
+
+var _errorTools = require("./errorTools");
+
+var _tools = require("./tools");
+
+function createEventRateLimiter(eventType, limit, onLimitReached) {
+  var eventCount = 0;
+  var allowNextEvent = false;
+  return {
+    isLimitReached: function isLimitReached() {
+      if (eventCount === 0) {
+        setTimeout(function () {
+          eventCount = 0;
+        }, _tools.ONE_MINUTE);
+      }
+
+      eventCount += 1;
+
+      if (eventCount <= limit || allowNextEvent) {
+        allowNextEvent = false;
+        return false;
+      }
+
+      if (eventCount === limit + 1) {
+        allowNextEvent = true;
+
+        try {
+          onLimitReached({
+            message: 'Reached max number of ' + eventType + 's by minute: ' + limit,
+            source: _errorTools.ErrorSource.AGENT,
+            startClocks: (0, _tools.clocksNow)()
+          });
+        } finally {
+          allowNextEvent = false;
+        }
+      }
+
+      return true;
+    }
+  };
+}

package/cjs/helper/deviceInfo.js

@@ -4,13 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.deviceInfo = void 0;
+
+var _display = require("../helper/display");
+
 var VariableLibrary = {
   navigator: typeof window.navigator != 'undefined' ? window.navigator : {},
   // 信息map
   infoMap: {
     engine: ['WebKit', 'Trident', 'Gecko', 'Presto'],
     browser: ['Safari', 'Chrome', 'Edge', 'IE', 'IE 11', 'IE 10', 'IE 9', 'IE 8', 'IE 7', 'Firefox', 'Firefox Focus', 'Chromium', 'Opera', 'Vivaldi', 'Yandex', 'Arora', 'Lunascape', 'QupZilla', 'Coc Coc', 'Kindle', 'Iceweasel', 'Konqueror', 'Iceape', 'SeaMonkey', 'Epiphany', '360', '360SE', '360EE', 'UC', 'QQBrowser', 'QQ', 'Baidu', 'Maxthon', 'Sogou', 'LBBROWSER', '2345Explorer', 'TheWorld', 'XiaoMi', 'Quark', 'Qiyu', 'Wechat',, 'WechatWork', 'Taobao', 'Alipay', 'Weibo', 'Douban', 'Suning', 'iQiYi'],
-    os: ['Windows', 'Windows 2000', 'Windows XP', 'Windows Vista', 'Windows 7', 'Windows 8', 'Windows 8.1', 'Windows Server 2003', 'Windows ME', 'Windows 10', 'Windows 98', 'Windows 95', 'Windows NT 4.0', 'Windows CE', 'Windows 3.11', 'Linux', 'Mac OS', 'Android', 'Ubuntu', 'FreeBSD', 'Debian', 'iOS', 'Windows Phone', 'BlackBerry', 'MeeGo', 'Symbian', 'Chrome OS', 'WebOS'],
+    os: ['Windows', 'Linux', 'Mac OS', 'Android', 'Ubuntu', 'FreeBSD', 'Debian', 'iOS', 'Windows Phone', 'BlackBerry', 'MeeGo', 'Symbian', 'Chrome OS', 'WebOS'],
     device: ['Mobile', 'Tablet', 'iPad']
   }
 }; // 方法库
@@ -28,12 +31,7 @@ var MethodLibrary = {
       Safari: u.indexOf('Safari') > -1,
       Chrome: u.indexOf('Chrome') > -1 || u.indexOf('CriOS') > -1,
       IE: u.indexOf('MSIE') > -1 || u.indexOf('Trident') > -1,
-      'IE 11': u.indexOf('Trident') > -1 && u.indexOf('rv:11.0') > -1,
-      'IE 10': u.indexOf('MSIE 10.0') > -1 && u.indexOf('Trident') > -1,
-      'IE 9': u.indexOf('MSIE 9.0') > -1 && u.indexOf('Trident') > -1,
-      'IE 8': u.indexOf('MSIE 9.0') > -1 && u.indexOf('Trident') > -1,
-      'IE 7': u.indexOf('MSIE 7.0') > -1 && u.indexOf('Trident') > -1,
-      Edge: u.indexOf('Edg') > -1 || u.indexOf('Edge') > -1,
+      Edge: u.indexOf('Edge') > -1,
       Firefox: u.indexOf('Firefox') > -1 || u.indexOf('FxiOS') > -1,
       'Firefox Focus': u.indexOf('Focus') > -1,
       Chromium: u.indexOf('Chromium') > -1,
@@ -59,14 +57,13 @@ var MethodLibrary = {
       Baidu: u.indexOf('Baidu') > -1 || u.indexOf('BIDUBrowser') > -1,
       Maxthon: u.indexOf('Maxthon') > -1,
       Sogou: u.indexOf('MetaSr') > -1 || u.indexOf('Sogou') > -1,
-      LBBROWSER: u.indexOf('LBBROWSER') > -1 || u.indexOf('LieBaoFast') > -1,
+      LBBROWSER: u.indexOf('LBBROWSER') > -1,
       '2345Explorer': u.indexOf('2345Explorer') > -1,
       TheWorld: u.indexOf('TheWorld') > -1,
       XiaoMi: u.indexOf('MiuiBrowser') > -1,
       Quark: u.indexOf('Quark') > -1,
       Qiyu: u.indexOf('Qiyu') > -1,
       Wechat: u.indexOf('MicroMessenger') > -1,
-      WechatWork: u.indexOf('wxwork/') > -1,
       Taobao: u.indexOf('AliApp(TB') > -1,
       Alipay: u.indexOf('AliApp(AP') > -1,
       Weibo: u.indexOf('Weibo') > -1,
@@ -75,20 +72,6 @@ var MethodLibrary = {
       iQiYi: u.indexOf('IqiyiApp') > -1,
       // 系统或平台
       Windows: u.indexOf('Windows') > -1,
-      'Windows 2000': u.indexOf('Windows NT 5.0') > -1 || u.indexOf('Windows 2000') > -1,
-      'Windows XP': u.indexOf('Windows NT 5.1') > -1 || u.indexOf('Windows XP') > -1,
-      'Windows Server 2003': u.indexOf('Windows NT 5.2') > -1,
-      'Windows Vista': u.indexOf('Windows NT 6.0') > -1,
-      'Windows 7': u.indexOf('Windows 7') > -1 || u.indexOf('Windows NT 6.1') > -1,
-      'Windows 8': u.indexOf('Windows 8') > -1 || u.indexOf('Windows NT 6.2') > -1,
-      'Windows 8.1': u.indexOf('Windows 8.1') > -1 || u.indexOf('Windows NT 6.3') > -1,
-      'Windows ME': u.indexOf('Win 9x 4.90') > -1 || u.indexOf('Windows ME') > -1,
-      'Windows 10': u.indexOf('Windows 10.0') > -1 || u.indexOf('Windows NT 10.0') > -1,
-      'Windows 98': u.indexOf('Windows 98') > -1 || u.indexOf('Win98') > -1,
-      'Windows 95': u.indexOf('Windows 95') > -1 || u.indexOf('Win95') > -1 || u.indexOf('Windows_95') > -1,
-      'Windows NT 4.0': u.indexOf('Windows NT 4.0') > -1 || u.indexOf('WinNT4.0') > -1 || u.indexOf('WinNT') > -1,
-      'Windows CE': u.indexOf('Windows CE') > -1,
-      'Windows 3.11': u.indexOf('Win16') > -1,
       Linux: u.indexOf('Linux') > -1 || u.indexOf('X11') > -1,
       'Mac OS': u.indexOf('Macintosh') > -1,
       Android: u.indexOf('Android') > -1 || u.indexOf('Adr') > -1,
@@ -176,7 +159,7 @@ var MethodLibrary = {
     if (osVersion[_this.os]) {
       _this.osVersion = osVersion[_this.os]();
 
-      if (_this.osVersion == u) {
+      if (_this.osVersion === u) {
         _this.osVersion = '';
       }
     }
@@ -543,7 +526,7 @@ var MethodLibrary = {
       callback(position);
     }, // 位置获取失败
     function (error) {
-      console.log(error);
+      _display.display.warn(error);
     });
   }
 };

package/cjs/helper/display.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.display = exports.ConsoleApiName = void 0;
+var ConsoleApiName = {
+  log: 'log',
+  debug: 'debug',
+  info: 'info',
+  warn: 'warn',
+  error: 'error'
+};
+exports.ConsoleApiName = ConsoleApiName;
+
+var display = function display(api) {
+  var args = [].slice.call(arguments, 1);
+
+  if (!Object.prototype.hasOwnProperty.call(ConsoleApiName, api)) {
+    api = ConsoleApiName.log;
+  }
+
+  display[api].apply(display, args);
+};
+
+exports.display = display;
+display.debug = console.debug.bind(console);
+display.log = console.log.bind(console);
+display.info = console.info.bind(console);
+display.warn = console.warn.bind(console);
+display.error = console.error.bind(console);

package/cjs/helper/enums.js

@@ -3,15 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TraceType = exports.RumEventType = exports.ResourceType = exports.RequestType = exports.ErrorHandling = exports.DOM_EVENT = exports.ActionType = void 0;
+exports.ViewLoadingType = exports.TraceType = exports.RumEventType = exports.ResourceType = exports.RequestType = exports.FrustrationType = exports.ErrorHandling = exports.DOM_EVENT = exports.ActionType = void 0;
 var DOM_EVENT = {
   BEFORE_UNLOAD: 'beforeunload',
   CLICK: 'click',
+  DBL_CLICK: 'dblclick',
   KEY_DOWN: 'keydown',
   LOAD: 'load',
   POP_STATE: 'popstate',
   SCROLL: 'scroll',
   TOUCH_START: 'touchstart',
+  TOUCH_END: 'touchend',
+  TOUCH_MOVE: 'touchmove',
   VISIBILITY_CHANGE: 'visibilitychange',
   DOM_CONTENT_LOADED: 'DOMContentLoaded',
   POINTER_DOWN: 'pointerdown',
@@ -19,7 +22,19 @@ var DOM_EVENT = {
   POINTER_CANCEL: 'pointercancel',
   HASH_CHANGE: 'hashchange',
   PAGE_HIDE: 'pagehide',
-  MOUSE_DOWN: 'mousedown'
+  MOUSE_DOWN: 'mousedown',
+  MOUSE_UP: 'mouseup',
+  MOUSE_MOVE: 'mousemove',
+  FOCUS: 'focus',
+  BLUR: 'blur',
+  CONTEXT_MENU: 'contextmenu',
+  RESIZE: 'resize',
+  CHANGE: 'change',
+  INPUT: 'input',
+  PLAY: 'play',
+  PAUSE: 'pause',
+  SECURITY_POLICY_VIOLATION: 'securitypolicyviolation',
+  SELECTION_CHANGE: 'selectionchange'
 };
 exports.DOM_EVENT = DOM_EVENT;
 var ResourceType = {
@@ -40,6 +55,12 @@ var ActionType = {
   CUSTOM: 'custom'
 };
 exports.ActionType = ActionType;
+var FrustrationType = {
+  RAGE_CLICK: 'rage_click',
+  ERROR_CLICK: 'error_click',
+  DEAD_CLICK: 'dead_click'
+};
+exports.FrustrationType = FrustrationType;
 var RumEventType = {
   ACTION: 'action',
   ERROR: 'error',
@@ -49,6 +70,11 @@ var RumEventType = {
   LOGGER: 'logger'
 };
 exports.RumEventType = RumEventType;
+var ViewLoadingType = {
+  INITIAL_LOAD: 'initial_load',
+  ROUTE_CHANGE: 'route_change'
+};
+exports.ViewLoadingType = ViewLoadingType;
 var RequestType = {
   FETCH: ResourceType.FETCH,
   XHR: ResourceType.XHR

package/cjs/helper/errorTools.js

@@ -4,9 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ErrorSource = void 0;
+exports.computeRawError = computeRawError;
 exports.createHandlingStack = createHandlingStack;
+exports.flattenErrorCauses = flattenErrorCauses;
 exports.formatErrorMessage = formatErrorMessage;
 exports.formatUnknownError = formatUnknownError;
+exports.getFileFromStackTraceString = getFileFromStackTraceString;
 exports.toStackTraceString = toStackTraceString;
 
 var _tools = require("./tools");
@@ -23,10 +26,45 @@ var ErrorSource = {
 };
 exports.ErrorSource = ErrorSource;
 
+function computeRawError(data) {
+  var stackTrace = data.stackTrace;
+  var originalError = data.originalError;
+  var handlingStack = data.handlingStack;
+  var startClocks = data.startClocks;
+  var nonErrorPrefix = data.nonErrorPrefix;
+  var source = data.source;
+  var handling = data.handling;
+
+  if (!stackTrace || stackTrace.message === undefined && !(originalError instanceof Error)) {
+    return {
+      startClocks: startClocks,
+      source: source,
+      handling: handling,
+      originalError: originalError,
+      message: nonErrorPrefix + ' ' + (0, _tools.jsonStringify)(originalError),
+      stack: 'No stack, consider using an instance of Error',
+      handlingStack: handlingStack,
+      type: stackTrace && stackTrace.name
+    };
+  }
+
+  return {
+    startClocks: startClocks,
+    source: source,
+    handling: handling,
+    originalError: originalError,
+    message: stackTrace.message || 'Empty message',
+    stack: toStackTraceString(stackTrace),
+    handlingStack: handlingStack,
+    type: stackTrace.name,
+    causes: flattenErrorCauses(originalError, source)
+  };
+}
+
 function formatUnknownError(stackTrace, errorObject, nonErrorPrefix, handlingStack) {
   if (!stackTrace || stackTrace.message === undefined && !(errorObject instanceof Error)) {
     return {
-      message: nonErrorPrefix + '' + JSON.stringify(errorObject),
+      message: nonErrorPrefix + '' + (0, _tools.jsonStringify)(errorObject),
       stack: 'No stack, consider using an instance of Error',
       handlingStack: handlingStack,
       type: stackTrace && stackTrace.name
@@ -75,7 +113,7 @@ function createHandlingStack() {
 }
 
 function toStackTraceString(stack) {
-  var result = stack.name || 'Error' + ': ' + stack.message;
+  var result = formatErrorMessage(stack);
   (0, _tools.each)(stack.stack, function (frame) {
     var func = frame.func === '?' ? '<anonymous>' : frame.func;
     var args = frame.args && frame.args.length > 0 ? '(' + frame.args.join(', ') + ')' : '';
@@ -88,4 +126,27 @@ function toStackTraceString(stack) {
 
 function formatErrorMessage(stack) {
   return (stack.name || 'Error') + ': ' + stack.message;
+}
+
+function getFileFromStackTraceString(stack) {
+  var execResult = /@ (.+)/.exec(stack);
+  return execResult && execResult[1];
+}
+
+function flattenErrorCauses(error, parentSource) {
+  var currentError = error;
+  var causes = [];
+
+  while (currentError && currentError.cause instanceof Error && causes.length < 10) {
+    var stackTrace = (0, _tracekit.computeStackTrace)(currentError.cause);
+    causes.push({
+      message: currentError.cause.message,
+      source: parentSource,
+      type: stackTrace && stackTrace.name,
+      stack: stackTrace && toStackTraceString(stackTrace)
+    });
+    currentError = currentError.cause;
+  }
+
+  return causes.length ? causes : undefined;
 }

package/cjs/helper/instrumentMethod.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.instrumentMethod = instrumentMethod;
+exports.instrumentMethodAndCallOriginal = instrumentMethodAndCallOriginal;
+exports.instrumentSetter = instrumentSetter;
+
+var _tools = require("./tools");
+
+function instrumentMethod(object, method, instrumentationFactory) {
+  var original = object[method];
+  var instrumentation = instrumentationFactory(original);
+
+  var instrumentationWrapper = function instrumentationWrapper() {
+    if (typeof instrumentation !== 'function') {
+      return undefined;
+    } // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+
+
+    return instrumentation.apply(this, arguments);
+  };
+
+  object[method] = instrumentationWrapper;
+  return {
+    stop: function stop() {
+      if (object[method] === instrumentationWrapper) {
+        object[method] = original;
+      } else {
+        instrumentation = original;
+      }
+    }
+  };
+}
+
+function instrumentMethodAndCallOriginal(object, method, aliasOption) {
+  return instrumentMethod(object, method, function (original) {
+    return function () {
+      var result;
+
+      if (aliasOption && aliasOption.before) {
+        aliasOption.before.apply(this, arguments);
+      }
+
+      if (typeof original === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        result = original.apply(this, arguments);
+      }
+
+      if (aliasOption && aliasOption.after) {
+        aliasOption.after.apply(this, arguments);
+      }
+
+      return result;
+    };
+  });
+}
+
+function instrumentSetter(object, property, after) {
+  var originalDescriptor = Object.getOwnPropertyDescriptor(object, property);
+
+  if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {
+    return {
+      stop: _tools.noop
+    };
+  }
+
+  var instrumentation = function instrumentation(thisObject, value) {
+    // put hooked setter into event loop to avoid of set latency
+    setTimeout(function () {
+      after(thisObject, value);
+    }, 0);
+  };
+
+  var instrumentationWrapper = function instrumentationWrapper(value) {
+    originalDescriptor.set.call(this, value);
+    instrumentation(this, value);
+  };
+
+  Object.defineProperty(object, property, {
+    set: instrumentationWrapper
+  });
+  return {
+    stop: function stop() {
+      if (Object.getOwnPropertyDescriptor(object, property) && Object.getOwnPropertyDescriptor(object, property).set === instrumentationWrapper) {
+        Object.defineProperty(object, property, originalDescriptor);
+      } else {
+        instrumentation = _tools.noop;
+      }
+    }
+  };
+}

package/cjs/helper/lifeCycle.js

@@ -9,14 +9,14 @@ exports.LifeCycleEventType = void 0;
 var _tools = require("./tools");
 
 var LifeCycleEventType = {
-  PERFORMANCE_ENTRY_COLLECTED: 'PERFORMANCE_ENTRY_COLLECTED',
+  PERFORMANCE_ENTRIES_COLLECTED: 'PERFORMANCE_ENTRIES_COLLECTED',
   AUTO_ACTION_CREATED: 'AUTO_ACTION_CREATED',
   AUTO_ACTION_COMPLETED: 'AUTO_ACTION_COMPLETED',
-  AUTO_ACTION_DISCARDED: 'AUTO_ACTION_DISCARDED',
   VIEW_CREATED: 'VIEW_CREATED',
   VIEW_UPDATED: 'VIEW_UPDATED',
   VIEW_ENDED: 'VIEW_ENDED',
   SESSION_RENEWED: 'SESSION_RENEWED',
+  SESSION_EXPIRED: 'SESSION_EXPIRED',
   DOM_MUTATED: 'DOM_MUTATED',
   BEFORE_UNLOAD: 'BEFORE_UNLOAD',
   REQUEST_STARTED: 'REQUEST_STARTED',
@@ -25,7 +25,9 @@ var LifeCycleEventType = {
   RUM_EVENT_COLLECTED: 'RUM_EVENT_COLLECTED',
   RAW_ERROR_COLLECTED: 'RAW_ERROR_COLLECTED',
   RECORD_STARTED: 'RECORD_STARTED',
-  RECORD_STOPPED: 'RECORD_STOPPED'
+  RECORD_STOPPED: 'RECORD_STOPPED',
+  RAW_LOG_COLLECTED: 'RAW_LOG_COLLECTED',
+  LOG_COLLECTED: 'LOG_COLLECTED'
 };
 exports.LifeCycleEventType = LifeCycleEventType;
 

package/cjs/helper/observable.js

@@ -4,16 +4,37 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Observable = void 0;
+exports.mergeObservables = mergeObservables;
 
 var _tools = require("./tools");
 
-var _Observable = function _Observable() {
+var _Observable = function _Observable(onFirstSubscribe) {
   this.observers = [];
+  this.onLastUnsubscribe = undefined;
+  this.onFirstSubscribe = onFirstSubscribe;
 };
 
 _Observable.prototype = {
   subscribe: function subscribe(f) {
+    if (!this.observers.length && this.onFirstSubscribe) {
+      this.onLastUnsubscribe = this.onFirstSubscribe() || undefined;
+    }
+
     this.observers.push(f);
+
+    var _this = this;
+
+    return {
+      unsubscribe: function unsubscribe() {
+        _this.observers = (0, _tools.filter)(_this.observers, function (other) {
+          return f !== other;
+        });
+
+        if (!_this.observers.length && _this.onLastUnsubscribe) {
+          _this.onLastUnsubscribe();
+        }
+      }
+    };
   },
   notify: function notify(data) {
     (0, _tools.each)(this.observers, function (observer) {
@@ -22,4 +43,21 @@ _Observable.prototype = {
   }
 };
 var Observable = _Observable;
-exports.Observable = Observable;
+exports.Observable = Observable;
+
+function mergeObservables() {
+  var observables = [].slice.call(arguments);
+  var globalObservable = new Observable(function () {
+    var subscriptions = (0, _tools.map)(observables, function (observable) {
+      return observable.subscribe(function (data) {
+        return globalObservable.notify(data);
+      });
+    });
+    return function () {
+      return (0, _tools.each)(subscriptions, function (subscription) {
+        return subscription.unsubscribe();
+      });
+    };
+  });
+  return globalObservable;
+}