@cloudcare/browser-core 1.2.9 → 2.0.0

package/cjs/browser/fetchObservable.js

@@ -70,21 +70,20 @@ function beforeSend(observable, input, init) {
 function afterSend(observable, responsePromise, startContext) {
   var reportFetch = function reportFetch(response) {
     var context = startContext;
-    context.state = 'complete';
-    context.duration = (0, _tools.elapsed)(context.startClocks.timeStamp, (0, _tools.timeStampNow)());
+    context.state = 'resolve'; // context.duration = elapsed(context.startClocks.timeStamp, timeStampNow())
 
     if ('stack' in response || response instanceof Error) {
       context.status = 0;
       context.isAborted = response instanceof DOMException && response.code === DOMException.ABORT_ERR;
       context.error = response;
-      observable.notify(context);
     } else if ('status' in response) {
       context.response = response;
       context.responseType = response.type;
       context.status = response.status;
       context.isAborted = false;
-      observable.notify(context);
     }
+
+    observable.notify(context);
   };
 
   responsePromise.then(reportFetch, reportFetch);

package/cjs/browser/htmlDomUtils.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getChildNodes = getChildNodes;
+exports.getParentNode = getParentNode;
+exports.isCommentNode = isCommentNode;
+exports.isElementNode = isElementNode;
+exports.isNodeShadowHost = isNodeShadowHost;
+exports.isNodeShadowRoot = isNodeShadowRoot;
+exports.isTextNode = isTextNode;
+
+function isTextNode(node) {
+  return node.nodeType === Node.TEXT_NODE;
+}
+
+function isCommentNode(node) {
+  return node.nodeType === Node.COMMENT_NODE;
+}
+
+function isElementNode(node) {
+  return node.nodeType === Node.ELEMENT_NODE;
+}
+
+function isNodeShadowHost(node) {
+  return isElementNode(node) && Boolean(node.shadowRoot);
+}
+
+function isNodeShadowRoot(node) {
+  var shadowRoot = node;
+  return !!shadowRoot.host && shadowRoot.nodeType === Node.DOCUMENT_FRAGMENT_NODE && isElementNode(shadowRoot.host);
+}
+
+function getChildNodes(node) {
+  return isNodeShadowHost(node) ? node.shadowRoot.childNodes : node.childNodes;
+}
+/**
+ * Return `host` in case if the current node is a shadow root otherwise will return the `parentNode`
+ */
+
+
+function getParentNode(node) {
+  return isNodeShadowRoot(node) ? node.host : node.parentNode;
+}

package/cjs/browser/pageExitObservable.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PageExitReason = void 0;
+exports.createPageExitObservable = createPageExitObservable;
+exports.isPageExitReason = isPageExitReason;
+
+var _observable = require("../helper/observable");
+
+var _tools = require("../helper/tools");
+
+var _enums = require("../helper/enums");
+
+var PageExitReason = {
+  HIDDEN: 'visibility_hidden',
+  UNLOADING: 'before_unload',
+  PAGEHIDE: 'page_hide',
+  FROZEN: 'page_frozen'
+};
+exports.PageExitReason = PageExitReason;
+
+function createPageExitObservable() {
+  var observable = new _observable.Observable(function () {
+    /**
+     * Only event that guarantee to fire on mobile devices when the page transitions to background state
+     * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.
+     */
+    var visibilityChangeListener = (0, _tools.addEventListeners)(document, [_enums.DOM_EVENT.VISIBILITY_CHANGE, _enums.DOM_EVENT.FREEZE, _enums.DOM_EVENT.PAGE_HIDE], function (event) {
+      if (event.type === _enums.DOM_EVENT.VISIBILITY_CHANGE && document.visibilityState === 'hidden') {
+        /**
+         * Only event that guarantee to fire on mobile devices when the page transitions to background state
+         * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.
+         */
+        observable.notify({
+          reason: PageExitReason.HIDDEN
+        });
+      } else if (event.type === _enums.DOM_EVENT.FREEZE) {
+        /**
+         * After transitioning in background a tab can be freezed to preserve resources. (cf: https://developer.chrome.com/blog/page-lifecycle-api)
+         * Allow to collect events happening between hidden and frozen state.
+         */
+        observable.notify({
+          reason: PageExitReason.FROZEN
+        });
+      }
+    }, {
+      capture: true
+    });
+    /**
+     * Safari does not support yet to send a request during:
+     * - a visibility change during doc unload (cf: https://bugs.webkit.org/show_bug.cgi?id=194897)
+     * - a page hide transition (cf: https://bugs.webkit.org/show_bug.cgi?id=188329)
+     */
+
+    var beforeUnloadListener = (0, _tools.addEventListener)(window, _enums.DOM_EVENT.BEFORE_UNLOAD, function () {
+      observable.notify({
+        reason: PageExitReason.UNLOADING
+      });
+    });
+    return function () {
+      visibilityChangeListener.stop();
+      beforeUnloadListener.stop();
+    };
+  });
+  return observable;
+}
+
+function isPageExitReason(reason) {
+  return (0, _tools.includes)((0, _tools.values)(PageExitReason), reason);
+}

package/cjs/configuration/configuration.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.DefaultPrivacyLevel = void 0;
 exports.buildCookieOptions = buildCookieOptions;
 exports.validateAndBuildConfiguration = validateAndBuildConfiguration;
 
@@ -16,6 +17,13 @@ var _tools = require("../helper/tools");
 
 var _transportConfiguration = require("./transportConfiguration");
 
+var DefaultPrivacyLevel = {
+  ALLOW: 'allow',
+  MASK: 'mask',
+  MASK_USER_INPUT: 'mask-user-input'
+};
+exports.DefaultPrivacyLevel = DefaultPrivacyLevel;
+
 function validateAndBuildConfiguration(initConfiguration) {
   if (initConfiguration.sampleRate !== undefined && !(0, _tools.isPercentage)(initConfiguration.sampleRate)) {
     _display.display.error('Sample Rate should be a number between 0 and 100');

package/cjs/configuration/transportConfiguration.js

@@ -24,6 +24,12 @@ function getLogsEndPoint(url) {
   return trim(url) + '/v1/write/logging';
 }
 
+function getSessionReplayEndPoint(url) {
+  //   return 'http://localhost:3002/write_data'
+  if (url.lastIndexOf('/') === url.length - 1) return trim(url) + 'v1/write/rum/replay';
+  return trim(url) + '/v1/write/rum/replay';
+}
+
 function computeTransportConfiguration(initConfiguration) {
   var isIntakeUrl = function isIntakeUrl(url) {
     return false;
@@ -44,6 +50,7 @@ function computeTransportConfiguration(initConfiguration) {
   return {
     datakitUrl: getDatakitUrl(initConfiguration.datakitUrl || initConfiguration.datakitOrigin),
     logsEndpoint: getLogsEndPoint(initConfiguration.datakitOrigin),
+    sessionReplayEndPoint: getSessionReplayEndPoint(initConfiguration.datakitOrigin),
     isIntakeUrl: isIntakeUrl,
     isServerError: isServerError
   };

package/cjs/dataMap.js

@@ -3,12 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.dataMap = exports.commonTags = void 0;
+exports.dataMap = exports.commonTags = exports.commonFields = void 0;
 
 var _enums = require("./helper/enums");
 
 var commonTags = {
-  action_id: 'action.id',
   sdk_name: '_dd.sdk_name',
   sdk_version: '_dd.sdk_version',
   app_id: 'application.id',
@@ -21,6 +20,7 @@ var commonTags = {
   session_id: 'session.id',
   session_type: 'session.type',
   session_sampling: 'session.is_sampling',
+  session_has_replay: 'session.has_replay',
   is_signin: 'user.is_signin',
   os: 'device.os',
   os_version: 'device.os_version',
@@ -40,9 +40,14 @@ var commonTags = {
   // 冗余一个字段
   view_path_group: 'view.path_group',
   view_url_query: 'view.url_query'
+};
+exports.commonTags = commonTags;
+var commonFields = {
+  action_id: 'action.id',
+  view_in_foreground: 'view.in_foreground'
 }; // 需要用双引号将字符串类型的field value括起来， 这里有数组标示[string, path]
 
-exports.commonTags = commonTags;
+exports.commonFields = commonFields;
 var dataMap = {
   view: {
     type: _enums.RumEventType.VIEW,
@@ -52,6 +57,7 @@ var dataMap = {
       is_active: 'view.is_active'
     },
     fields: {
+      session_replay_stats: '_dd.replay_stats',
       view_error_count: 'view.error.count',
       view_resource_count: 'view.resource.count',
       view_long_task_count: 'view.long_task.count',
@@ -72,7 +78,9 @@ var dataMap = {
       time_to_interactive: 'view.tti',
       dom: 'view.dom',
       dom_ready: 'view.dom_ready',
-      time_spent: 'view.time_spent'
+      time_spent: 'view.time_spent',
+      in_foreground_periods: 'view.in_foreground_periods',
+      frustration_count: 'view.frustration.count'
     }
   },
   resource: {

package/cjs/helper/deviceInfo.js

@@ -196,8 +196,50 @@ var MethodLibrary = {
   },
   // 获取网络状态
   getNetwork: function getNetwork() {
-    var netWork = navigator && navigator.connection && navigator.connection.effectiveType;
-    return netWork;
+    var connection = window.navigator.connection || window.navigator.mozConnection || window.navigator.webkitConnection;
+    var result = 'unknown';
+    var type = connection ? connection.type || connection.effectiveType : null;
+
+    if (type && typeof type === 'string') {
+      switch (type) {
+        // possible type values
+        case 'bluetooth':
+        case 'cellular':
+          result = 'cellular';
+          break;
+
+        case 'none':
+          result = 'none';
+          break;
+
+        case 'ethernet':
+        case 'wifi':
+        case 'wimax':
+          result = 'wifi';
+          break;
+
+        case 'other':
+        case 'unknown':
+          result = 'unknown';
+          break;
+        // possible effectiveType values
+
+        case 'slow-2g':
+        case '2g':
+        case '3g':
+          result = 'cellular';
+          break;
+
+        case '4g':
+          result = 'wifi';
+          break;
+
+        default:
+          break;
+      }
+    }
+
+    return result;
   },
   // 获取当前语言
   getLanguage: function getLanguage() {

package/cjs/helper/enums.js

@@ -16,6 +16,9 @@ var DOM_EVENT = {
   TOUCH_END: 'touchend',
   TOUCH_MOVE: 'touchmove',
   VISIBILITY_CHANGE: 'visibilitychange',
+  PAGE_SHOW: 'pageshow',
+  FREEZE: 'freeze',
+  RESUME: 'resume',
   DOM_CONTENT_LOADED: 'DOMContentLoaded',
   POINTER_DOWN: 'pointerdown',
   POINTER_UP: 'pointerup',

package/cjs/helper/getZoneJsOriginalValue.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getZoneJsOriginalValue = getZoneJsOriginalValue;
+
+/**
+ * Gets the original value for a DOM API that was potentially patched by Zone.js.
+ *
+ * Zone.js[1] is a library that patches a bunch of JS and DOM APIs. It usually stores the original
+ * value of the patched functions/constructors/methods in a hidden property prefixed by
+ * __zone_symbol__.
+ *
+ * In multiple occasions, we observed that Zone.js is the culprit of important issues leading to
+ * browser resource exhaustion (memory leak, high CPU usage). This method is used as a workaround to
+ * use the original DOM API instead of the one patched by Zone.js.
+ *
+ * [1]: https://github.com/angular/angular/tree/main/packages/zone.js
+ */
+function getZoneJsOriginalValue(target, name) {
+  var browserWindow = window;
+  var original;
+
+  if (browserWindow.Zone && typeof browserWindow.Zone.__symbol__ === 'function') {
+    original = target[browserWindow.Zone.__symbol__(name)];
+  }
+
+  if (!original) {
+    original = target[name];
+  }
+
+  return original;
+}

package/cjs/helper/instrumentMethod.js

@@ -9,6 +9,8 @@ exports.instrumentSetter = instrumentSetter;
 
 var _tools = require("./tools");
 
+var _getZoneJsOriginalValue = require("./getZoneJsOriginalValue");
+
 function instrumentMethod(object, method, instrumentationFactory) {
   var original = object[method];
   var instrumentation = instrumentationFactory(original);
@@ -64,7 +66,11 @@ function instrumentSetter(object, property, after) {
     return {
       stop: _tools.noop
     };
-  }
+  } // Using the patched `setTimeout` from Zone.js triggers a rendering loop in some Angular
+  // component, see issue RUMF-1443
+
+
+  var setTimeout = (0, _getZoneJsOriginalValue.getZoneJsOriginalValue)(window, 'setTimeout');
 
   var instrumentation = function instrumentation(thisObject, value) {
     // put hooked setter into event loop to avoid of set latency

package/cjs/helper/lifeCycle.js

@@ -10,29 +10,25 @@ var _tools = require("./tools");
 
 var LifeCycleEventType = {
   PERFORMANCE_ENTRIES_COLLECTED: 'PERFORMANCE_ENTRIES_COLLECTED',
-  AUTO_ACTION_CREATED: 'AUTO_ACTION_CREATED',
   AUTO_ACTION_COMPLETED: 'AUTO_ACTION_COMPLETED',
   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',
+  PAGE_EXITED: 'PAGE_EXITED',
   REQUEST_STARTED: 'REQUEST_STARTED',
   REQUEST_COMPLETED: 'REQUEST_COMPLETED',
   RAW_RUM_EVENT_COLLECTED: 'RAW_RUM_EVENT_COLLECTED',
   RUM_EVENT_COLLECTED: 'RUM_EVENT_COLLECTED',
   RAW_ERROR_COLLECTED: 'RAW_ERROR_COLLECTED',
-  RECORD_STARTED: 'RECORD_STARTED',
-  RECORD_STOPPED: 'RECORD_STOPPED',
   RAW_LOG_COLLECTED: 'RAW_LOG_COLLECTED',
   LOG_COLLECTED: 'LOG_COLLECTED'
 };
 exports.LifeCycleEventType = LifeCycleEventType;
 
 function LifeCycle() {
-  this.callbacks = [];
+  this.callbacks = {};
 }
 
 LifeCycle.prototype = {

package/cjs/helper/readBytesFromStream.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readBytesFromStream = readBytesFromStream;
+
+var _tools = require("./tools");
+
+/**
+ * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of
+ * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit
+ * has been exceeded if more bytes were available.
+ */
+function readBytesFromStream(stream, callback, options) {
+  var reader = stream.getReader();
+  var chunks = [];
+  var readBytesCount = 0;
+  readMore();
+
+  function readMore() {
+    reader.read().then(function (result) {
+      if (result.done) {
+        onDone();
+        return;
+      }
+
+      if (options.collectStreamBody) {
+        chunks.push(result.value);
+      }
+
+      readBytesCount += result.value.length;
+
+      if (readBytesCount > options.bytesLimit) {
+        onDone();
+      } else {
+        readMore();
+      }
+    }, function (error) {
+      callback(error);
+    });
+  }
+
+  function onDone() {
+    reader.cancel()["catch"]( // we don't care if cancel fails, but we still need to catch the error to avoid reporting it
+    // as an unhandled rejection
+    _tools.noop);
+    var bytes;
+    var limitExceeded;
+
+    if (options.collectStreamBody) {
+      var completeBuffer;
+
+      if (chunks.length === 1) {
+        // optimization: if the response is small enough to fit in a single buffer (provided by the browser), just
+        // use it directly.
+        completeBuffer = chunks[0];
+      } else {
+        // else, we need to copy buffers into a larger buffer to concatenate them.
+        completeBuffer = new Uint8Array(readBytesCount);
+        var offset = 0;
+        (0, _tools.each)(chunks, function (chunk) {
+          completeBuffer.set(chunk, offset);
+          offset += chunk.length;
+        });
+      }
+
+      bytes = completeBuffer.slice(0, options.bytesLimit);
+      limitExceeded = completeBuffer.length > options.bytesLimit;
+    }
+
+    callback(undefined, bytes, limitExceeded);
+  }
+}