@cloudcare/browser-core 1.1.3 → 1.2.1

package/esm/dataMap.js

@@ -1,11 +1,12 @@
 import { RumEventType } from './helper/enums';
 export var commonTags = {
+  action_id: 'action.id',
   sdk_name: '_dd.sdk_name',
   sdk_version: '_dd.sdk_version',
   app_id: 'application.id',
-  env: '_dd.env',
-  service: '_dd.service',
-  version: '_dd.version',
+  env: 'env',
+  service: 'service',
+  version: 'version',
   userid: 'user.id',
   user_email: 'user.email',
   user_name: 'user.name',
@@ -92,27 +93,31 @@ export var dataMap = {
   error: {
     type: RumEventType.ERROR,
     tags: {
+      error_id: 'error.id',
       trace_id: '_dd.trace_id',
       span_id: '_dd.span_id',
       error_source: 'error.source',
       error_type: 'error.type',
-      error_handling: 'error.handling',
-      resource_url: 'error.resource.url',
-      resource_url_host: 'error.resource.url_host',
-      resource_url_path: 'error.resource.url_path',
-      resource_url_path_group: 'error.resource.url_path_group',
-      resource_status: 'error.resource.status',
-      resource_status_group: 'error.resource.status_group',
-      resource_method: 'error.resource.method'
+      error_handling: 'error.handling' //   resource_url: 'error.resource.url',
+      //   resource_url_host: 'error.resource.url_host',
+      //   resource_url_path: 'error.resource.url_path',
+      //   resource_url_path_group: 'error.resource.url_path_group',
+      //   resource_status: 'error.resource.status',
+      //   resource_status_group: 'error.resource.status_group',
+      //   resource_method: 'error.resource.method'
+
     },
     fields: {
       error_message: ['string', 'error.message'],
-      error_stack: ['string', 'error.stack']
+      error_stack: ['string', 'error.stack'],
+      error_causes: ['string', 'error.causes']
     }
   },
   long_task: {
     type: RumEventType.LONG_TASK,
-    tags: {},
+    tags: {
+      long_task_id: 'long_task.id'
+    },
     fields: {
       duration: 'long_task.duration'
     }
@@ -120,7 +125,6 @@ export var dataMap = {
   action: {
     type: RumEventType.ACTION,
     tags: {
-      action_id: 'action.id',
       action_name: 'action.target.name',
       action_type: 'action.type'
     },
@@ -128,6 +132,7 @@ export var dataMap = {
       duration: 'action.loading_time',
       action_error_count: 'action.error.count',
       action_resource_count: 'action.resource.count',
+      action_frustration_types: 'action.frustration.type',
       action_long_task_count: 'action.long_task.count'
     }
   },
@@ -136,13 +141,13 @@ export var dataMap = {
     tags: {
       error_source: 'error.source',
       error_type: 'error.type',
-      error_resource_url: 'resource.url',
-      error_resource_url_host: 'resource.url_host',
-      error_resource_url_path: 'resource.url_path',
-      error_resource_url_path_group: 'resource.url_path_group',
-      error_resource_status: 'resource.status',
-      error_resource_status_group: 'resource.status_group',
-      error_resource_method: 'resource.method',
+      error_resource_url: 'http.url',
+      error_resource_url_host: 'http.url_host',
+      error_resource_url_path: 'http.url_path',
+      error_resource_url_path_group: 'http.url_path_group',
+      error_resource_status: 'http.status_code',
+      error_resource_status_group: 'http.status_group',
+      error_resource_method: 'http.method',
       action_id: 'user_action.id',
       service: 'service',
       status: 'status'

package/esm/error/trackRuntimeError.js

@@ -0,0 +1,16 @@
+import { ErrorSource, computeRawError } from '../helper/errorTools';
+import { clocksNow } from '../helper/tools';
+import { ErrorHandling } from '../helper/enums';
+import { startUnhandledErrorCollection } from '../tracekit';
+export function trackRuntimeError(errorObservable) {
+  return startUnhandledErrorCollection(function (stackTrace, originalError) {
+    errorObservable.notify(computeRawError({
+      stackTrace: stackTrace,
+      originalError: originalError,
+      startClocks: clocksNow(),
+      nonErrorPrefix: 'Uncaught',
+      source: ErrorSource.SOURCE,
+      handling: ErrorHandling.UNHANDLED
+    }));
+  });
+}

package/esm/helper/catchUserErrors.js

@@ -0,0 +1,12 @@
+import { display } from './display';
+export function catchUserErrors(fn, errorMsg) {
+  return function () {
+    var args = [].slice.call(arguments);
+
+    try {
+      return fn.apply(this, args);
+    } catch (err) {
+      display.error(errorMsg, err);
+    }
+  };
+}

package/esm/helper/contextHistory.js

@@ -0,0 +1,106 @@
+import { relativeNow, ONE_MINUTE, filter, map } from './tools';
+var END_OF_TIMES = Infinity;
+export var CLEAR_OLD_CONTEXTS_INTERVAL = ONE_MINUTE;
+export 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;
+  }
+
+  for (var entry of this.entries) {
+    if (entry.startTime <= startTime) {
+      if (startTime <= entry.endTime) {
+        return entry.context;
+      }
+
+      break;
+    }
+  }
+};
+/**
+ * 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 = filter(this.entries, function (entry) {
+    return entry.startTime <= startTime && startTime <= entry.endTime;
+  });
+  return 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 = relativeNow() - this.expireDelay;
+
+  while (this.entries.length > 0 && this.entries[this.entries.length - 1].endTime < oldTimeThreshold) {
+    this.entries.pop();
+  }
+};

package/esm/helper/createEventRateLimiter.js

@@ -0,0 +1,38 @@
+import { ErrorSource } from './errorTools';
+import { clocksNow, ONE_MINUTE } from './tools';
+export function createEventRateLimiter(eventType, limit, onLimitReached) {
+  var eventCount = 0;
+  var allowNextEvent = false;
+  return {
+    isLimitReached: function isLimitReached() {
+      if (eventCount === 0) {
+        setTimeout(function () {
+          eventCount = 0;
+        }, 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: ErrorSource.AGENT,
+            startClocks: clocksNow()
+          });
+        } finally {
+          allowNextEvent = false;
+        }
+      }
+
+      return true;
+    }
+  };
+}

package/esm/helper/deviceInfo.js

@@ -1,10 +1,11 @@
+import { display } from '../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']
   }
 }; // 方法库
@@ -22,12 +23,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,
@@ -53,14 +49,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,
@@ -69,20 +64,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,
@@ -170,7 +151,7 @@ var MethodLibrary = {
     if (osVersion[_this.os]) {
       _this.osVersion = osVersion[_this.os]();
 
-      if (_this.osVersion == u) {
+      if (_this.osVersion === u) {
         _this.osVersion = '';
       }
     }
@@ -537,7 +518,7 @@ var MethodLibrary = {
       callback(position);
     }, // 位置获取失败
     function (error) {
-      console.log(error);
+      display.warn(error);
     });
   }
 };

package/esm/helper/display.js

@@ -0,0 +1,21 @@
+export var ConsoleApiName = {
+  log: 'log',
+  debug: 'debug',
+  info: 'info',
+  warn: 'warn',
+  error: 'error'
+};
+export 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);
+};
+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/esm/helper/enums.js

@@ -1,11 +1,14 @@
 export 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',
@@ -13,7 +16,19 @@ export 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'
 };
 export var ResourceType = {
   DOCUMENT: 'document',
@@ -31,6 +46,11 @@ export var ActionType = {
   CLICK: 'click',
   CUSTOM: 'custom'
 };
+export var FrustrationType = {
+  RAGE_CLICK: 'rage_click',
+  ERROR_CLICK: 'error_click',
+  DEAD_CLICK: 'dead_click'
+};
 export var RumEventType = {
   ACTION: 'action',
   ERROR: 'error',
@@ -39,6 +59,10 @@ export var RumEventType = {
   RESOURCE: 'resource',
   LOGGER: 'logger'
 };
+export var ViewLoadingType = {
+  INITIAL_LOAD: 'initial_load',
+  ROUTE_CHANGE: 'route_change'
+};
 export var RequestType = {
   FETCH: ResourceType.FETCH,
   XHR: ResourceType.XHR

package/esm/helper/errorTools.js

@@ -1,4 +1,4 @@
-import { each, noop } from './tools';
+import { each, noop, jsonStringify } from './tools';
 import { computeStackTrace } from '../tracekit';
 export var ErrorSource = {
   AGENT: 'agent',
@@ -8,10 +8,44 @@ export var ErrorSource = {
   LOGGER: 'logger',
   CUSTOM: 'custom'
 };
+export 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 + ' ' + 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)
+  };
+}
 export function formatUnknownError(stackTrace, errorObject, nonErrorPrefix, handlingStack) {
   if (!stackTrace || stackTrace.message === undefined && !(errorObject instanceof Error)) {
     return {
-      message: nonErrorPrefix + '' + JSON.stringify(errorObject),
+      message: nonErrorPrefix + '' + jsonStringify(errorObject),
       stack: 'No stack, consider using an instance of Error',
       handlingStack: handlingStack,
       type: stackTrace && stackTrace.name
@@ -58,7 +92,7 @@ export function createHandlingStack() {
   return formattedStack;
 }
 export function toStackTraceString(stack) {
-  var result = stack.name || 'Error' + ': ' + stack.message;
+  var result = formatErrorMessage(stack);
   each(stack.stack, function (frame) {
     var func = frame.func === '?' ? '<anonymous>' : frame.func;
     var args = frame.args && frame.args.length > 0 ? '(' + frame.args.join(', ') + ')' : '';
@@ -70,4 +104,25 @@ export function toStackTraceString(stack) {
 }
 export function formatErrorMessage(stack) {
   return (stack.name || 'Error') + ': ' + stack.message;
+}
+export function getFileFromStackTraceString(stack) {
+  var execResult = /@ (.+)/.exec(stack);
+  return execResult && execResult[1];
+}
+export function flattenErrorCauses(error, parentSource) {
+  var currentError = error;
+  var causes = [];
+
+  while (currentError && currentError.cause instanceof Error && causes.length < 10) {
+    var stackTrace = 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/esm/helper/instrumentMethod.js

@@ -0,0 +1,81 @@
+import { noop } from './tools';
+export 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;
+      }
+    }
+  };
+}
+export 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;
+    };
+  });
+}
+export function instrumentSetter(object, property, after) {
+  var originalDescriptor = Object.getOwnPropertyDescriptor(object, property);
+
+  if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {
+    return {
+      stop: 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 = noop;
+      }
+    }
+  };
+}

package/esm/helper/lifeCycle.js

@@ -1,13 +1,13 @@
 import { each, filter } from './tools';
 export 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',
@@ -16,7 +16,9 @@ export 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'
 };
 export function LifeCycle() {
   this.callbacks = [];

package/esm/helper/observable.js

@@ -1,12 +1,32 @@
-import { each } from './tools';
+import { each, filter, map } from './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 = filter(_this.observers, function (other) {
+          return f !== other;
+        });
+
+        if (!_this.observers.length && _this.onLastUnsubscribe) {
+          _this.onLastUnsubscribe();
+        }
+      }
+    };
   },
   notify: function notify(data) {
     each(this.observers, function (observer) {
@@ -14,4 +34,20 @@ _Observable.prototype = {
     });
   }
 };
-export var Observable = _Observable;
+export var Observable = _Observable;
+export function mergeObservables() {
+  var observables = [].slice.call(arguments);
+  var globalObservable = new Observable(function () {
+    var subscriptions = map(observables, function (observable) {
+      return observable.subscribe(function (data) {
+        return globalObservable.notify(data);
+      });
+    });
+    return function () {
+      return each(subscriptions, function (subscription) {
+        return subscription.unsubscribe();
+      });
+    };
+  });
+  return globalObservable;
+}