@cloudcare/browser-core 1.1.3 → 1.2.1

package/cjs/tracekit/index.js

@@ -9,25 +9,13 @@ Object.defineProperty(exports, "computeStackTrace", {
     return _computeStackTrace.computeStackTrace;
   }
 });
-Object.defineProperty(exports, "report", {
+Object.defineProperty(exports, "startUnhandledErrorCollection", {
   enumerable: true,
   get: function get() {
-    return _report.report;
-  }
-});
-Object.defineProperty(exports, "subscribe", {
-  enumerable: true,
-  get: function get() {
-    return _report.subscribe;
-  }
-});
-Object.defineProperty(exports, "unsubscribe", {
-  enumerable: true,
-  get: function get() {
-    return _report.unsubscribe;
+    return _tracekit.startUnhandledErrorCollection;
   }
 });
 
 var _computeStackTrace = require("./computeStackTrace");
 
-var _report = require("./report");
+var _tracekit = require("./tracekit");

package/cjs/tracekit/tracekit.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startUnhandledErrorCollection = startUnhandledErrorCollection;
+
+var _instrumentMethod = require("../helper/instrumentMethod");
+
+var _computeStackTrace = require("./computeStackTrace");
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types
+var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/;
+/**
+ * Cross-browser collection of unhandled errors
+ *
+ * Supports:
+ * - Firefox: full stack trace with line numbers, plus column number
+ * on top frame; column number is not guaranteed
+ * - Opera: full stack trace with line and column numbers
+ * - Chrome: full stack trace with line and column numbers
+ * - Safari: line and column number for the top frame only; some frames
+ * may be missing, and column number is not guaranteed
+ * - IE: line and column number for the top frame only; some frames
+ * may be missing, and column number is not guaranteed
+ *
+ * In theory, TraceKit should work on all of the following versions:
+ * - IE5.5+ (only 8.0 tested)
+ * - Firefox 0.9+ (only 3.5+ tested)
+ * - Opera 7+ (only 10.50 tested; versions 9 and earlier may require
+ * Exceptions Have Stacktrace to be enabled in opera:config)
+ * - Safari 3+ (only 4+ tested)
+ * - Chrome 1+ (only 5+ tested)
+ * - Konqueror 3.5+ (untested)
+ *
+ * Tries to catch all unhandled errors and report them to the
+ * callback.
+ *
+ * Callbacks receive a StackTrace object as described in the
+ * computeStackTrace docs.
+ *
+ * @memberof TraceKit
+ * @namespace
+ */
+
+function startUnhandledErrorCollection(callback) {
+  var _instrumentOnError = instrumentOnError(callback);
+
+  var _instrumentUnhandledRejection = instrumentUnhandledRejection(callback);
+
+  return {
+    stop: function stop() {
+      _instrumentOnError.stop();
+
+      _instrumentUnhandledRejection.stop();
+    }
+  };
+}
+/**
+ * Install a global onerror handler
+ */
+
+
+function instrumentOnError(callback) {
+  return (0, _instrumentMethod.instrumentMethodAndCallOriginal)(window, 'onerror', {
+    before: function before(message, url, lineNo, columnNo, errorObj) {
+      var stack;
+
+      if (errorObj) {
+        stack = (0, _computeStackTrace.computeStackTrace)(errorObj);
+        callback(stack, errorObj);
+      } else {
+        var location = {
+          url: url,
+          column: columnNo,
+          line: lineNo
+        };
+        var name;
+        var msg = message;
+
+        if ({}.toString.call(message) === '[object String]') {
+          var groups = ERROR_TYPES_RE.exec(msg);
+
+          if (groups) {
+            name = groups[1];
+            msg = groups[2];
+          }
+        }
+
+        stack = {
+          name: name,
+          message: typeof msg === 'string' ? msg : undefined,
+          stack: [location]
+        };
+        callback(stack, message);
+      }
+    }
+  });
+}
+/**
+ * Install a global onunhandledrejection handler
+ */
+
+
+function instrumentUnhandledRejection(callback) {
+  return (0, _instrumentMethod.instrumentMethodAndCallOriginal)(window, 'onunhandledrejection', {
+    before: function before(e) {
+      var reason = e.reason || 'Empty reason';
+      var stack = (0, _computeStackTrace.computeStackTrace)(reason);
+      callback(stack, reason);
+    }
+  });
+}

package/cjs/transport/batch.js

@@ -0,0 +1,332 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.processedMessageByDataMap = exports.Batch = void 0;
+
+var _display = require("../helper/display");
+
+var _tools = require("../helper/tools");
+
+var _dataMap = require("../dataMap");
+
+var _enums = require("../helper/enums");
+
+// https://en.wikipedia.org/wiki/UTF-8
+// eslint-disable-next-line no-control-regex
+var HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/;
+var CUSTOM_KEYS = 'custom_keys';
+
+var processedMessageByDataMap = function processedMessageByDataMap(message) {
+  if (!message || !message.type) return {
+    rowStr: '',
+    rowData: undefined
+  };
+  var rowData = {
+    tags: {},
+    fields: {}
+  };
+  var hasFileds = false;
+  var rowStr = '';
+  (0, _tools.each)(_dataMap.dataMap, function (value, key) {
+    if (value.type === message.type) {
+      rowStr += key + ',';
+      rowData.measurement = key;
+      var tagsStr = [];
+      var tags = (0, _tools.extend)({}, _dataMap.commonTags, value.tags);
+      var filterFileds = ['date', 'type', CUSTOM_KEYS]; // 已经在datamap中定义过的fields和tags
+
+      (0, _tools.each)(tags, function (value_path, _key) {
+        var _value = (0, _tools.findByPath)(message, value_path);
+
+        filterFileds.push(_key);
+
+        if (_value || (0, _tools.isNumber)(_value)) {
+          rowData.tags[_key] = (0, _tools.escapeJsonValue)(_value);
+          tagsStr.push((0, _tools.escapeRowData)(_key) + '=' + (0, _tools.escapeRowData)(_value));
+        }
+      });
+      var fieldsStr = [];
+      (0, _tools.each)(value.fields, function (_value, _key) {
+        if ((0, _tools.isArray)(_value) && _value.length === 2) {
+          var type = _value[0],
+              value_path = _value[1];
+
+          var _valueData = (0, _tools.findByPath)(message, value_path);
+
+          filterFileds.push(_key);
+
+          if (_valueData || (0, _tools.isNumber)(_valueData)) {
+            rowData.fields[_key] = _valueData; // 这里不需要转译
+            // _valueData =
+            //   type === 'string'
+            //     ? '"' +
+            //       _valueData.replace(/[\\]*"/g, '"').replace(/"/g, '\\"') +
+            //       '"'
+            //     : escapeRowData(_valueData)
+
+            fieldsStr.push((0, _tools.escapeRowData)(_key) + '=' + (0, _tools.escapeRowField)(_valueData));
+          }
+        } else if ((0, _tools.isString)(_value)) {
+          var _valueData = (0, _tools.findByPath)(message, _value);
+
+          filterFileds.push(_key);
+
+          if (_valueData || (0, _tools.isNumber)(_valueData)) {
+            rowData.fields[_key] = _valueData; // 这里不需要转译
+
+            fieldsStr.push((0, _tools.escapeRowData)(_key) + '=' + (0, _tools.escapeRowField)(_valueData));
+          }
+        }
+      });
+
+      if (message.tags && (0, _tools.isObject)(message.tags) && !(0, _tools.isEmptyObject)(message.tags)) {
+        // 自定义tag， 存储成field
+        var _tagKeys = [];
+        (0, _tools.each)(message.tags, function (_value, _key) {
+          // 如果和之前tag重名，则舍弃
+          if (filterFileds.indexOf(_key) > -1) return;
+          filterFileds.push(_key);
+
+          if (_value || (0, _tools.isNumber)(_value)) {
+            _tagKeys.push(_key);
+
+            rowData.fields[_key] = _value; // 这里不需要转译
+
+            fieldsStr.push((0, _tools.escapeRowData)(_key) + '=' + (0, _tools.escapeRowField)(_value));
+          }
+        });
+
+        if (_tagKeys.length) {
+          rowData.fields[CUSTOM_KEYS] = (0, _tools.escapeRowField)(_tagKeys);
+          fieldsStr.push((0, _tools.escapeRowData)(CUSTOM_KEYS) + '=' + (0, _tools.escapeRowField)(_tagKeys));
+        }
+      }
+
+      if (message.type === _enums.RumEventType.LOGGER) {
+        // 这里处理日志类型数据自定义字段
+        (0, _tools.each)(message, function (value, key) {
+          if (filterFileds.indexOf(key) === -1 && ((0, _tools.isNumber)(value) || (0, _tools.isString)(value) || (0, _tools.isBoolean)(value))) {
+            rowData.fields[key] = value; // 这里不需要转译
+
+            fieldsStr.push((0, _tools.escapeRowData)(key) + '=' + (0, _tools.escapeRowField)(value));
+          }
+        });
+      }
+
+      if (tagsStr.length) {
+        rowStr += tagsStr.join(',');
+      }
+
+      if (fieldsStr.length) {
+        rowStr += ' ';
+        rowStr += fieldsStr.join(',');
+        hasFileds = true;
+      }
+
+      rowStr = rowStr + ' ' + message.date;
+      rowData.time = (0, _tools.toServerDuration)(message.date); // 这里不需要转译
+    }
+  });
+  return {
+    rowStr: hasFileds ? rowStr : '',
+    rowData: hasFileds ? rowData : undefined
+  };
+};
+
+exports.processedMessageByDataMap = processedMessageByDataMap;
+
+var batch = function batch(request, batchMessagesLimit, batchBytesLimit, messageBytesLimit, flushTimeout, beforeUnloadCallback) {
+  this.pushOnlyBuffer = [];
+  this.upsertBuffer = {};
+  this.bufferBytesCount = 0;
+  this.bufferMessagesCount = 0;
+  this.request = request;
+  this.batchMessagesLimit = batchMessagesLimit;
+  this.batchBytesLimit = batchBytesLimit;
+  this.messageBytesLimit = messageBytesLimit;
+  this.flushTimeout = flushTimeout;
+
+  if (typeof beforeUnloadCallback === 'function') {
+    this.beforeUnloadCallback = beforeUnloadCallback;
+  } else {
+    this.beforeUnloadCallback = _tools.noop;
+  }
+
+  this.setupFlushOnExit();
+  this.flushPeriodically();
+};
+
+batch.prototype.add = function (message) {
+  this.addOrUpdate(message);
+};
+
+batch.prototype.upsert = function (message, key) {
+  this.addOrUpdate(message, key);
+};
+
+batch.prototype.flush = function (sendFn) {
+  if (typeof sendFn !== 'function') {
+    sendFn = this.request.send;
+  }
+
+  if (this.bufferMessagesCount !== 0) {
+    var messages = this.pushOnlyBuffer.concat((0, _tools.values)(this.upsertBuffer));
+    var bytesCount = this.bufferBytesCount;
+    this.pushOnlyBuffer = [];
+    this.upsertBuffer = {};
+    this.bufferBytesCount = 0;
+    this.bufferMessagesCount = 0;
+
+    if (messages.length > 0) {
+      sendFn({
+        data: messages.join('\n'),
+        bytesCount: bytesCount
+      });
+    }
+  }
+};
+
+batch.prototype.flushOnExit = function () {
+  this.flush(this.request.sendOnExit);
+};
+
+batch.prototype.computeBytesCount = function (candidate) {
+  // Accurate bytes count computations can degrade performances when there is a lot of events to process
+  if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {
+    return candidate.length;
+  }
+
+  if (window.TextEncoder !== undefined) {
+    return new TextEncoder().encode(candidate).length;
+  }
+
+  return new Blob([candidate]).size;
+};
+
+batch.prototype.addOrUpdate = function (message, key) {
+  var _process = this.process(message);
+
+  var processedMessage = _process.processedMessage;
+  var messageBytesCount = _process.messageBytesCount;
+
+  if (messageBytesCount >= this.messageBytesLimit) {
+    _display.display.warn('Discarded a message whose size was bigger than the maximum allowed size ' + this.messageBytesLimit + 'KB.');
+
+    return;
+  }
+
+  if (this.hasMessageFor(key)) {
+    this.remove(key);
+  }
+
+  if (this.willReachedBytesLimitWith(messageBytesCount)) {
+    this.flush();
+  }
+
+  this.push(processedMessage, messageBytesCount, key);
+
+  if (this.isFull()) {
+    this.flush();
+  }
+};
+
+batch.prototype.process = function (message) {
+  var processedMessage = processedMessageByDataMap(message).rowStr;
+  var messageBytesCount = this.computeBytesCount(processedMessage);
+  return {
+    processedMessage: processedMessage,
+    messageBytesCount: messageBytesCount
+  };
+};
+
+batch.prototype.push = function (processedMessage, messageBytesCount, key) {
+  if (this.bufferMessagesCount > 0) {
+    // \n separator at serialization
+    this.bufferBytesCount += 1;
+  }
+
+  if (key !== undefined) {
+    this.upsertBuffer[key] = processedMessage;
+  } else {
+    this.pushOnlyBuffer.push(processedMessage);
+  }
+
+  this.bufferBytesCount += messageBytesCount;
+  this.bufferMessagesCount += 1;
+};
+
+batch.prototype.remove = function (key) {
+  var removedMessage = this.upsertBuffer[key];
+  delete this.upsertBuffer[key];
+  var messageBytesCount = this.computeBytesCount(removedMessage);
+  this.bufferBytesCount -= messageBytesCount;
+  this.bufferMessagesCount -= 1;
+
+  if (this.bufferMessagesCount > 0) {
+    this.bufferBytesCount -= 1;
+  }
+};
+
+batch.prototype.hasMessageFor = function (key) {
+  return key !== undefined && this.upsertBuffer[key] !== undefined;
+};
+
+batch.prototype.willReachedBytesLimitWith = function (messageBytesCount) {
+  // byte of the separator at the end of the message
+  return this.bufferBytesCount + messageBytesCount + 1 >= this.batchBytesLimit;
+};
+
+batch.prototype.isFull = function () {
+  return this.bufferMessagesCount === this.batchMessagesLimit || this.bufferBytesCount >= this.batchBytesLimit;
+};
+
+batch.prototype.flushPeriodically = function () {
+  var _this = this;
+
+  setTimeout(function () {
+    _this.flush();
+
+    _this.flushPeriodically();
+  }, 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
+     */
+    (0, _tools.addEventListener)(window, _enums.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.
+     */
+
+    (0, _tools.addEventListener)(document, _enums.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)
+     */
+
+    (0, _tools.addEventListener)(window, _enums.DOM_EVENT.BEFORE_UNLOAD, function () {
+      return _this.flushOnExit();
+    });
+  }
+};
+
+var Batch = batch;
+exports.Batch = Batch;

package/cjs/transport/httpRequest.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createHttpRequest = createHttpRequest;
+exports.fetchKeepAliveStrategy = fetchKeepAliveStrategy;
+
+var _sendWithRetryStrategy = require("./sendWithRetryStrategy");
+
+/**
+ * Use POST request without content type to:
+ * - avoid CORS preflight requests
+ * - allow usage of sendBeacon
+ *
+ * multiple elements are sent separated by \n in order
+ * to be parsed correctly without content type header
+ */
+function addBatchPrecision(url) {
+  if (!url) return url;
+  return url + (url.indexOf('?') === -1 ? '?' : '&') + 'precision=ms';
+}
+
+function createHttpRequest(endpointUrl, bytesLimit, reportError) {
+  var retryState = (0, _sendWithRetryStrategy.newRetryState)();
+
+  var sendStrategyForRetry = function sendStrategyForRetry(payload, onResponse) {
+    return fetchKeepAliveStrategy(endpointUrl, bytesLimit, payload, onResponse);
+  };
+
+  return {
+    send: function send(payload) {
+      (0, _sendWithRetryStrategy.sendWithRetryStrategy)(payload, retryState, sendStrategyForRetry, reportError);
+    },
+
+    /**
+     * Since fetch keepalive behaves like regular fetch on Firefox,
+     * keep using sendBeaconStrategy on exit
+     */
+    sendOnExit: function sendOnExit(payload) {
+      sendBeaconStrategy(endpointUrl, bytesLimit, payload);
+    }
+  };
+}
+
+function sendBeaconStrategy(endpointUrl, bytesLimit, payload) {
+  var data = payload.data;
+  var bytesCount = payload.bytesCount;
+  var url = addBatchPrecision(endpointUrl);
+  var canUseBeacon = !!navigator.sendBeacon && bytesCount < bytesLimit;
+
+  if (canUseBeacon) {
+    try {
+      var isQueued = navigator.sendBeacon(url, data);
+
+      if (isQueued) {
+        return;
+      }
+    } catch (e) {// reportBeaconError(e)
+    }
+  }
+
+  sendXHR(url, data);
+}
+
+function fetchKeepAliveStrategy(endpointUrl, bytesLimit, payload, onResponse) {
+  var data = payload.data;
+  var bytesCount = payload.bytesCount;
+  var url = addBatchPrecision(endpointUrl);
+  var canUseKeepAlive = isKeepAliveSupported() && bytesCount < bytesLimit;
+
+  if (canUseKeepAlive) {
+    fetch(url, {
+      method: 'POST',
+      body: data,
+      keepalive: true
+    }).then(function (response) {
+      if (typeof onResponse === 'function') {
+        onResponse({
+          status: response.status
+        });
+      }
+    }, function () {
+      // failed to queue the request
+      sendXHR(url, data, onResponse);
+    });
+  } else {
+    sendXHR(url, data, onResponse);
+  }
+}
+
+function isKeepAliveSupported() {
+  // Request can throw, cf https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#errors
+  try {
+    return window.Request && 'keepalive' in new Request('http://a');
+  } catch (_unused) {
+    return false;
+  }
+}
+
+function sendXHR(url, data, onResponse) {
+  var request = new XMLHttpRequest();
+  request.open('POST', url, true);
+  request.send(data);
+  request.addEventListener('loadend', function () {
+    if (typeof onResponse === 'function') {
+      onResponse({
+        status: request.status
+      });
+    }
+  });
+}

package/cjs/transport/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Batch", {
+  enumerable: true,
+  get: function get() {
+    return _batch.Batch;
+  }
+});
+Object.defineProperty(exports, "createHttpRequest", {
+  enumerable: true,
+  get: function get() {
+    return _httpRequest.createHttpRequest;
+  }
+});
+Object.defineProperty(exports, "startBatchWithReplica", {
+  enumerable: true,
+  get: function get() {
+    return _startBatchWithReplica.startBatchWithReplica;
+  }
+});
+
+var _httpRequest = require("./httpRequest");
+
+var _batch = require("./batch");
+
+var _startBatchWithReplica = require("./startBatchWithReplica");