@cloudcare/browser-core 1.2.11 → 2.0.0

package/esm/dataMap.js

@@ -1,6 +1,5 @@
 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',
@@ -13,6 +12,7 @@ export 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',
@@ -32,6 +32,10 @@ export var commonTags = {
   // 冗余一个字段
   view_path_group: 'view.path_group',
   view_url_query: 'view.url_query'
+};
+export var commonFields = {
+  action_id: 'action.id',
+  view_in_foreground: 'view.in_foreground'
 }; // 需要用双引号将字符串类型的field value括起来， 这里有数组标示[string, path]
 
 export var dataMap = {
@@ -43,6 +47,7 @@ export 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',
@@ -63,7 +68,9 @@ export 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/esm/helper/contextHistory.js

@@ -1,4 +1,4 @@
-import { relativeNow, ONE_MINUTE, filter, map, each } from './tools';
+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) {

package/esm/helper/deviceInfo.js

@@ -188,8 +188,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/esm/helper/enums.js

@@ -10,6 +10,9 @@ export 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/esm/helper/getZoneJsOriginalValue.js

@@ -0,0 +1,27 @@
+/**
+ * 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
+ */
+export 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/esm/helper/instrumentMethod.js

@@ -1,4 +1,5 @@
 import { noop } from './tools';
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue';
 export function instrumentMethod(object, method, instrumentationFactory) {
   var original = object[method];
   var instrumentation = instrumentationFactory(original);
@@ -52,7 +53,11 @@ export function instrumentSetter(object, property, after) {
     return {
       stop: noop
     };
-  }
+  } // Using the patched `setTimeout` from Zone.js triggers a rendering loop in some Angular
+  // component, see issue RUMF-1443
+
+
+  var setTimeout = getZoneJsOriginalValue(window, 'setTimeout');
 
   var instrumentation = function instrumentation(thisObject, value) {
     // put hooked setter into event loop to avoid of set latency

package/esm/helper/lifeCycle.js

@@ -1,27 +1,23 @@
 import { each, filter } from './tools';
 export 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'
 };
 export function LifeCycle() {
-  this.callbacks = [];
+  this.callbacks = {};
 }
 LifeCycle.prototype = {
   notify: function notify(eventType, data) {

package/esm/helper/readBytesFromStream.js

@@ -0,0 +1,67 @@
+import { noop, each } from './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.
+ */
+
+export 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
+    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;
+        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);
+  }
+}

package/esm/helper/tools.js

@@ -1,3 +1,5 @@
+import { DOM_EVENT } from './enums';
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue';
 var ArrayProto = Array.prototype;
 var FuncProto = Function.prototype;
 var ObjProto = Object.prototype;
@@ -386,49 +388,42 @@ export var getScreenOrientation = function getScreenOrientation() {
 export var now = Date.now || function () {
   return new Date().getTime();
 };
-export var throttle = function throttle(func, wait, options) {
-  var timeout, context, args, result;
-  var previous = 0;
-  if (!options) options = {};
-
-  var later = function later() {
-    previous = options.leading === false ? 0 : new Date().getTime();
-    timeout = null;
-    result = func.apply(context, args);
-    if (!timeout) context = args = null;
-  };
-
-  var throttled = function throttled() {
-    args = arguments;
-    var now = new Date().getTime();
-    if (!previous && options.leading === false) previous = now; //下次触发 func 剩余的时间
-
-    var remaining = wait - (now - previous);
-    context = this; // 如果没有剩余的时间了或者你改了系统时间
-
-    if (remaining <= 0 || remaining > wait) {
-      if (timeout) {
-        clearTimeout(timeout);
-        timeout = null;
+export var throttle = function throttle(fn, wait, options) {
+  var needLeadingExecution = options && options.leading !== undefined ? options.leading : true;
+  var needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true;
+  var inWaitPeriod = false;
+  var pendingExecutionWithParameters;
+  var pendingTimeoutId;
+  var context = this;
+  return {
+    throttled: function throttled() {
+      if (inWaitPeriod) {
+        pendingExecutionWithParameters = arguments;
+        return;
       }
 
-      previous = now;
-      result = func.apply(context, args);
-      if (!timeout) context = args = null;
-    } else if (!timeout && options.trailing !== false) {
-      timeout = setTimeout(later, remaining);
-    }
+      if (needLeadingExecution) {
+        fn.apply(context, arguments);
+      } else {
+        pendingExecutionWithParameters = arguments;
+      }
 
-    return result;
-  };
+      inWaitPeriod = true;
+      pendingTimeoutId = setTimeout(function () {
+        if (needTrailingExecution && pendingExecutionWithParameters) {
+          fn.apply(context, pendingExecutionWithParameters);
+        }
 
-  throttled.cancel = function () {
-    clearTimeout(timeout);
-    previous = 0;
-    timeout = null;
+        inWaitPeriod = false;
+        pendingExecutionWithParameters = undefined;
+      }, wait);
+    },
+    cancel: function cancel() {
+      clearTimeout(pendingTimeoutId);
+      inWaitPeriod = false;
+      pendingExecutionWithParameters = undefined;
+    }
   };
-
-  return throttled;
 };
 export var hashCode = function hashCode(str) {
   if (typeof str !== 'string') {
@@ -1661,6 +1656,9 @@ export function currentDrift() {
   // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
   return Math.round(dateNow() - (getNavigationStart() + performance.now()));
 }
+export function addDuration(a, b) {
+  return a + b;
+}
 
 function getCorrectedTimeStamp(relativeTime) {
   var correctedOrigin = dateNow() - performance.now(); // apply correction only for positive drift
@@ -1712,8 +1710,8 @@ export function safeTruncate(candidate, length) {
 
   return candidate.slice(0, length);
 }
-export function addEventListener(emitter, event, listener, options) {
-  return addEventListeners(emitter, [event], listener, options);
+export function addEventListener(eventTarget, event, listener, options) {
+  return addEventListeners(eventTarget, [event], listener, options);
 }
 /**
  * Add event listeners to an event emitter object (Window, Element, mock object...).  This provides
@@ -1731,8 +1729,8 @@ export function addEventListener(emitter, event, listener, options) {
  *   listened
  */
 
-export function addEventListeners(emitter, events, listener, options) {
-  var wrapedListener = options && options.once ? function (event) {
+export function addEventListeners(eventTarget, events, listener, options) {
+  var wrappedListener = options && options.once ? function (event) {
     stop();
     listener(event);
   } : listener;
@@ -1740,13 +1738,15 @@ export function addEventListeners(emitter, events, listener, options) {
     capture: options.capture,
     passive: options.passive
   } : options && options.capture;
+  var add = getZoneJsOriginalValue(eventTarget, 'addEventListener');
   each(events, function (event) {
-    emitter.addEventListener(event, wrapedListener, options);
+    add.call(eventTarget, event, wrappedListener, options);
   });
 
   var stop = function stop() {
+    var remove = getZoneJsOriginalValue(eventTarget, 'removeEventListener');
     each(events, function (event) {
-      emitter.removeEventListener(event, wrapedListener, options);
+      remove.call(eventTarget, event, wrappedListener, options);
     });
   };
 
@@ -1926,4 +1926,59 @@ export function isNullUndefinedDefaultValue(data, defaultValue) {
   } else {
     return defaultValue;
   }
+}
+export function runOnReadyState(expectedReadyState, callback) {
+  if (document.readyState === expectedReadyState || document.readyState === 'complete') {
+    callback();
+  } else {
+    var eventName = expectedReadyState === 'complete' ? DOM_EVENT.LOAD : DOM_EVENT.DOM_CONTENT_LOADED;
+    addEventListener(window, eventName, callback, {
+      once: true
+    });
+  }
+}
+export function requestIdleCallback(callback, opts) {
+  // Use 'requestIdleCallback' when available: it will throttle the mutation processing if the
+  // browser is busy rendering frames (ex: when frames are below 60fps). When not available, the
+  // fallback on 'requestAnimationFrame' will still ensure the mutations are processed after any
+  // browser rendering process (Layout, Recalculate Style, etc.), so we can serialize DOM nodes
+  // efficiently.
+  if (window.requestIdleCallback) {
+    var id = window.requestIdleCallback(callback, opts);
+    return function () {
+      return window.cancelIdleCallback(id);
+    };
+  }
+
+  var id = window.requestAnimationFrame(callback);
+  return function () {
+    return window.cancelAnimationFrame(id);
+  };
+}
+export function objectHasValue(object, value) {
+  return some(keys(object), function (key) {
+    return object[key] === value;
+  });
+}
+export function startsWith(candidate, search) {
+  return candidate.slice(0, search.length) === search;
+}
+export function endsWith(candidate, search) {
+  return candidate.slice(-search.length) === search;
+}
+export function tryToClone(response) {
+  try {
+    return response.clone();
+  } catch (e) {
+    // clone can throw if the response has already been used by another instrumentation or is disturbed
+    return;
+  }
+}
+export function isHashAnAnchor(hash) {
+  var correspondingId = hash.substr(1);
+  return !!document.getElementById(correspondingId);
+}
+export function getPathFromHash(hash) {
+  var index = hash.indexOf('?');
+  return index < 0 ? hash : hash.slice(0, index);
 }

package/esm/index.js

@@ -16,12 +16,16 @@ export * from './helper/observable';
 export * from './helper/tools';
 export * from './helper/urlPolyfill';
 export * from './helper/mobileUtil';
+export * from './helper/getZoneJsOriginalValue';
+export * from './helper/readBytesFromStream';
 export * from './tracekit';
 export * from './configuration/configuration';
 export * from './configuration/transportConfiguration';
 export * from './browser/cookie';
 export * from './browser/fetchObservable';
 export * from './browser/xhrObservable';
+export * from './browser/pageExitObservable';
+export * from './browser/htmlDomUtils';
 export * from './dataMap';
 export * from './init';
 export * from './session/sessionManagement';

package/esm/session/sessionStore.js

@@ -125,7 +125,7 @@ export function startSessionStore(options, productKey, computeSessionState) {
   }
 
   return {
-    expandOrRenewSession: throttle(expandOrRenewSession, COOKIE_ACCESS_DELAY),
+    expandOrRenewSession: throttle(expandOrRenewSession, COOKIE_ACCESS_DELAY).throttled,
     expandSession: expandSession,
     getSession: function getSession() {
       return sessionCache;

package/esm/transport/batch.js

@@ -1,6 +1,6 @@
 import { display } from '../helper/display';
 import { addEventListener, noop, values, findByPath, escapeRowData, each, isNumber, isArray, extend, isString, toServerDuration, isBoolean, isEmptyObject, isObject, escapeJsonValue, escapeRowField } from '../helper/tools';
-import { commonTags, dataMap } from '../dataMap';
+import { commonTags, dataMap, commonFields } from '../dataMap';
 import { DOM_EVENT, RumEventType } from '../helper/enums'; // https://en.wikipedia.org/wiki/UTF-8
 // eslint-disable-next-line no-control-regex
 
@@ -36,7 +36,8 @@ export var processedMessageByDataMap = function processedMessageByDataMap(messag
         }
       });
       var fieldsStr = [];
-      each(value.fields, function (_value, _key) {
+      var fields = extend({}, commonFields, value.fields);
+      each(fields, function (_value, _key) {
         if (isArray(_value) && _value.length === 2) {
           var type = _value[0],
               value_path = _value[1];
@@ -123,7 +124,7 @@ export var processedMessageByDataMap = function processedMessageByDataMap(messag
   };
 };
 
-var batch = function batch(request, batchMessagesLimit, batchBytesLimit, messageBytesLimit, flushTimeout, beforeUnloadCallback) {
+var batch = function batch(request, batchMessagesLimit, batchBytesLimit, messageBytesLimit, flushTimeout, pageExitObservable) {
   this.pushOnlyBuffer = [];
   this.upsertBuffer = {};
   this.bufferBytesCount = 0;
@@ -134,13 +135,11 @@ var batch = function batch(request, batchMessagesLimit, batchBytesLimit, message
   this.messageBytesLimit = messageBytesLimit;
   this.flushTimeout = flushTimeout;
 
-  if (typeof beforeUnloadCallback === 'function') {
-    this.beforeUnloadCallback = beforeUnloadCallback;
-  } else {
-    this.beforeUnloadCallback = noop;
-  }
+  var _this = this;
 
-  this.setupFlushOnExit();
+  pageExitObservable.subscribe(function () {
+    _this.flush(_this.request.sendOnExit);
+  });
   this.flushPeriodically();
 };
 
@@ -277,40 +276,4 @@ batch.prototype.flushPeriodically = function () {
   }, this.flushTimeout);
 };
 
-batch.prototype.setupFlushOnExit = function () {
-  /**
-   * With sendBeacon, requests are guaranteed to be successfully sent during document unload
-   */
-  // @ts-ignore this function is not always defined
-  var _this = this;
-
-  if (navigator.sendBeacon) {
-    /**
-     * beforeunload is called before visibilitychange
-     * register first to be sure to be called before flush on beforeunload
-     * caveat: unload can still be canceled by another listener
-     */
-    addEventListener(window, DOM_EVENT.BEFORE_UNLOAD, this.beforeUnloadCallback);
-    /**
-     * 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.
-     */
-
-    addEventListener(document, DOM_EVENT.VISIBILITY_CHANGE, function () {
-      if (document.visibilityState === 'hidden') {
-        _this.flushOnExit();
-      }
-    });
-    /**
-     * 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)
-     */
-
-    addEventListener(window, DOM_EVENT.BEFORE_UNLOAD, function () {
-      return _this.flushOnExit();
-    });
-  }
-};
-
 export var Batch = batch;

package/esm/transport/httpRequest.js

@@ -65,11 +65,13 @@ export function fetchKeepAliveStrategy(endpointUrl, bytesLimit, payload, onRespo
     fetch(url, {
       method: 'POST',
       body: data,
-      keepalive: true
+      keepalive: true,
+      mode: 'cors'
     }).then(function (response) {
       if (typeof onResponse === 'function') {
         onResponse({
-          status: response.status
+          status: response.status,
+          type: response.type
         });
       }
     }, function () {

package/esm/transport/sendWithRetryStrategy.js

@@ -6,13 +6,13 @@ export var MAX_QUEUE_BYTES_COUNT = 3 * ONE_MEBI_BYTE;
 export var MAX_BACKOFF_TIME = 256 * ONE_SECOND;
 export var INITIAL_BACKOFF_TIME = ONE_SECOND;
 var TransportStatus = {
-  UP: 'UP',
-  FAILURE_DETECTED: 'FAILURE_DETECTED',
-  DOWN: 'DOWN'
+  UP: 0,
+  FAILURE_DETECTED: 1,
+  DOWN: 2
 };
 var RetryReason = {
-  AFTER_SUCCESS: 'AFTER_SUCCESS',
-  AFTER_RESUME: 'AFTER_RESUME'
+  AFTER_SUCCESS: 0,
+  AFTER_RESUME: 1
 };
 export function sendWithRetryStrategy(payload, state, sendStrategy, reportError) {
   if (state.transportStatus === TransportStatus.UP && state.queuedPayloads.size() === 0 && state.bandwidthMonitor.canHandle(payload)) {
@@ -63,7 +63,7 @@ function send(payload, state, sendStrategy, responseData) {
   sendStrategy(payload, function (response) {
     state.bandwidthMonitor.remove(payload);
 
-    if (wasRequestSuccessful(response)) {
+    if (!shouldRetryRequest(response)) {
       state.transportStatus = TransportStatus.UP;
       onSuccess();
     } else {
@@ -93,8 +93,8 @@ function retryQueuedPayloads(reason, state, sendStrategy, reportError) {
   }
 }
 
-function wasRequestSuccessful(response) {
-  return response.status !== 0 && response.status < 500;
+function shouldRetryRequest(response) {
+  return response.type !== 'opaque' && (response.status === 0 && !navigator.onLine || response.status === 408 || response.status === 429 || response.status >= 500);
 }
 
 export function newRetryState() {

package/esm/transport/startBatchWithReplica.js

@@ -1,10 +1,10 @@
 import { Batch } from './batch';
 import { createHttpRequest } from './httpRequest';
-export function startBatchWithReplica(configuration, endpointUrl, reportError) {
+export function startBatchWithReplica(configuration, endpointUrl, reportError, pageExitObservable) {
   var primaryBatch = createBatch(endpointUrl);
 
   function createBatch(endpointUrl) {
-    return new Batch(createHttpRequest(endpointUrl, configuration.batchBytesLimit, reportError), configuration.batchMessagesLimit, configuration.batchBytesLimit, configuration.messageBytesLimit, configuration.flushTimeout);
+    return new Batch(createHttpRequest(endpointUrl, configuration.batchBytesLimit, reportError), configuration.batchMessagesLimit, configuration.batchBytesLimit, configuration.messageBytesLimit, configuration.flushTimeout, pageExitObservable);
   }
 
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudcare/browser-core",
-  "version": "1.2.11",
+  "version": "2.0.0",
   "main": "cjs/index.js",
   "module": "esm/index.js",
   "scripts": {
@@ -20,5 +20,5 @@
   "author": "dataflux",
   "license": "MIT",
   "description": "DataFlux RUM Web 端数据指标监控",
-  "gitHead": "7a7a643e72002ffafff9ce0f6c1b1c2f904eeebe"
+  "gitHead": "bc7a044056367a5f9a0bc941462cb4e1d4d1d925"
 }