@cloudcare/browser-core 1.1.2 → 1.2.0

package/esm/tracekit/tracekit.js

@@ -0,0 +1,103 @@
+import { instrumentMethodAndCallOriginal } from '../helper/instrumentMethod';
+import { computeStackTrace } from './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
+ */
+
+export 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 instrumentMethodAndCallOriginal(window, 'onerror', {
+    before: function before(message, url, lineNo, columnNo, errorObj) {
+      var stack;
+
+      if (errorObj) {
+        stack = 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 instrumentMethodAndCallOriginal(window, 'onunhandledrejection', {
+    before: function before(e) {
+      var reason = e.reason || 'Empty reason';
+      var stack = computeStackTrace(reason);
+      callback(stack, reason);
+    }
+  });
+}

package/esm/transport/batch.js

@@ -0,0 +1,316 @@
+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 { DOM_EVENT, RumEventType } from '../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';
+export var processedMessageByDataMap = function processedMessageByDataMap(message) {
+  if (!message || !message.type) return {
+    rowStr: '',
+    rowData: undefined
+  };
+  var rowData = {
+    tags: {},
+    fields: {}
+  };
+  var hasFileds = false;
+  var rowStr = '';
+  each(dataMap, function (value, key) {
+    if (value.type === message.type) {
+      rowStr += key + ',';
+      rowData.measurement = key;
+      var tagsStr = [];
+      var tags = extend({}, commonTags, value.tags);
+      var filterFileds = ['date', 'type', CUSTOM_KEYS]; // 已经在datamap中定义过的fields和tags
+
+      each(tags, function (value_path, _key) {
+        var _value = findByPath(message, value_path);
+
+        filterFileds.push(_key);
+
+        if (_value || isNumber(_value)) {
+          rowData.tags[_key] = escapeJsonValue(_value);
+          tagsStr.push(escapeRowData(_key) + '=' + escapeRowData(_value));
+        }
+      });
+      var fieldsStr = [];
+      each(value.fields, function (_value, _key) {
+        if (isArray(_value) && _value.length === 2) {
+          var type = _value[0],
+              value_path = _value[1];
+
+          var _valueData = findByPath(message, value_path);
+
+          filterFileds.push(_key);
+
+          if (_valueData || isNumber(_valueData)) {
+            rowData.fields[_key] = _valueData; // 这里不需要转译
+            // _valueData =
+            //   type === 'string'
+            //     ? '"' +
+            //       _valueData.replace(/[\\]*"/g, '"').replace(/"/g, '\\"') +
+            //       '"'
+            //     : escapeRowData(_valueData)
+
+            fieldsStr.push(escapeRowData(_key) + '=' + escapeRowField(_valueData));
+          }
+        } else if (isString(_value)) {
+          var _valueData = findByPath(message, _value);
+
+          filterFileds.push(_key);
+
+          if (_valueData || isNumber(_valueData)) {
+            rowData.fields[_key] = _valueData; // 这里不需要转译
+
+            fieldsStr.push(escapeRowData(_key) + '=' + escapeRowField(_valueData));
+          }
+        }
+      });
+
+      if (message.tags && isObject(message.tags) && !isEmptyObject(message.tags)) {
+        // 自定义tag， 存储成field
+        var _tagKeys = [];
+        each(message.tags, function (_value, _key) {
+          // 如果和之前tag重名，则舍弃
+          if (filterFileds.indexOf(_key) > -1) return;
+          filterFileds.push(_key);
+
+          if (_value || isNumber(_value)) {
+            _tagKeys.push(_key);
+
+            rowData.fields[_key] = _value; // 这里不需要转译
+
+            fieldsStr.push(escapeRowData(_key) + '=' + escapeRowField(_value));
+          }
+        });
+
+        if (_tagKeys.length) {
+          rowData.fields[CUSTOM_KEYS] = escapeRowField(_tagKeys);
+          fieldsStr.push(escapeRowData(CUSTOM_KEYS) + '=' + escapeRowField(_tagKeys));
+        }
+      }
+
+      if (message.type === RumEventType.LOGGER) {
+        // 这里处理日志类型数据自定义字段
+        each(message, function (value, key) {
+          if (filterFileds.indexOf(key) === -1 && (isNumber(value) || isString(value) || isBoolean(value))) {
+            rowData.fields[key] = value; // 这里不需要转译
+
+            fieldsStr.push(escapeRowData(key) + '=' + escapeRowField(value));
+          }
+        });
+      }
+
+      if (tagsStr.length) {
+        rowStr += tagsStr.join(',');
+      }
+
+      if (fieldsStr.length) {
+        rowStr += ' ';
+        rowStr += fieldsStr.join(',');
+        hasFileds = true;
+      }
+
+      rowStr = rowStr + ' ' + message.date;
+      rowData.time = toServerDuration(message.date); // 这里不需要转译
+    }
+  });
+  return {
+    rowStr: hasFileds ? rowStr : '',
+    rowData: hasFileds ? rowData : undefined
+  };
+};
+
+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 = 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(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.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
+     */
+    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

@@ -0,0 +1,104 @@
+import { newRetryState, sendWithRetryStrategy } from './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';
+}
+
+export function createHttpRequest(endpointUrl, bytesLimit, reportError) {
+  var retryState = newRetryState();
+
+  var sendStrategyForRetry = function sendStrategyForRetry(payload, onResponse) {
+    return fetchKeepAliveStrategy(endpointUrl, bytesLimit, payload, onResponse);
+  };
+
+  return {
+    send: function send(payload) {
+      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);
+}
+
+export 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/esm/transport/index.js

@@ -0,0 +1,3 @@
+export { createHttpRequest } from './httpRequest';
+export { Batch } from './batch';
+export { startBatchWithReplica } from './startBatchWithReplica';

package/esm/transport/sendWithRetryStrategy.js

@@ -0,0 +1,165 @@
+import { clocksNow, ONE_KIBI_BYTE, ONE_MEBI_BYTE, ONE_SECOND } from '../helper/tools';
+import { ErrorSource } from '../helper/errorTools';
+export var MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE;
+export var MAX_ONGOING_REQUESTS = 32;
+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'
+};
+var RetryReason = {
+  AFTER_SUCCESS: 'AFTER_SUCCESS',
+  AFTER_RESUME: 'AFTER_RESUME'
+};
+export function sendWithRetryStrategy(payload, state, sendStrategy, reportError) {
+  if (state.transportStatus === TransportStatus.UP && state.queuedPayloads.size() === 0 && state.bandwidthMonitor.canHandle(payload)) {
+    send(payload, state, sendStrategy, {
+      onSuccess: function onSuccess() {
+        return retryQueuedPayloads(RetryReason.AFTER_SUCCESS, state, sendStrategy, reportError);
+      },
+      onFailure: function onFailure() {
+        state.queuedPayloads.enqueue(payload);
+        scheduleRetry(state, sendStrategy, reportError);
+      }
+    });
+  } else {
+    state.queuedPayloads.enqueue(payload);
+  }
+}
+
+function scheduleRetry(state, sendStrategy, reportError) {
+  if (state.transportStatus !== TransportStatus.DOWN) {
+    return;
+  }
+
+  setTimeout(function () {
+    var payload = state.queuedPayloads.first();
+    send(payload, state, sendStrategy, {
+      onSuccess: function onSuccess() {
+        state.queuedPayloads.dequeue(); // if (state.lastFailureStatus !== 0) {
+        //   addTelemetryDebug('resuming after transport down', {
+        //     failureStatus: state.lastFailureStatus,
+        //   })
+        // }
+
+        state.currentBackoffTime = INITIAL_BACKOFF_TIME;
+        retryQueuedPayloads(RetryReason.AFTER_RESUME, state, sendStrategy, reportError);
+      },
+      onFailure: function onFailure() {
+        state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2);
+        scheduleRetry(state, sendStrategy, reportError);
+      }
+    });
+  }, state.currentBackoffTime);
+}
+
+function send(payload, state, sendStrategy, responseData) {
+  var onSuccess = responseData.onSuccess;
+  var onFailure = responseData.onFailure;
+  state.bandwidthMonitor.add(payload);
+  sendStrategy(payload, function (response) {
+    state.bandwidthMonitor.remove(payload);
+
+    if (wasRequestSuccessful(response)) {
+      state.transportStatus = TransportStatus.UP;
+      onSuccess();
+    } else {
+      // do not consider transport down if another ongoing request could succeed
+      state.transportStatus = state.bandwidthMonitor.ongoingRequestCount > 0 ? TransportStatus.FAILURE_DETECTED : TransportStatus.DOWN;
+      state.lastFailureStatus = response.status;
+      onFailure();
+    }
+  });
+}
+
+function retryQueuedPayloads(reason, state, sendStrategy, reportError) {
+  if (reason === RetryReason.AFTER_SUCCESS && state.queuedPayloads.isFull() && !state.queueFullReported) {
+    reportError({
+      message: 'Reached max events size queued for upload: ' + MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE + 'MiB',
+      source: ErrorSource.AGENT,
+      startClocks: clocksNow()
+    });
+    state.queueFullReported = true;
+  }
+
+  var previousQueue = state.queuedPayloads;
+  state.queuedPayloads = newPayloadQueue();
+
+  while (previousQueue.size() > 0) {
+    sendWithRetryStrategy(previousQueue.dequeue(), state, sendStrategy, reportError);
+  }
+}
+
+function wasRequestSuccessful(response) {
+  return response.status !== 0 && response.status < 500;
+}
+
+export function newRetryState() {
+  return {
+    transportStatus: TransportStatus.UP,
+    lastFailureStatus: 0,
+    currentBackoffTime: INITIAL_BACKOFF_TIME,
+    bandwidthMonitor: newBandwidthMonitor(),
+    queuedPayloads: newPayloadQueue(),
+    queueFullReported: false
+  };
+}
+
+function newPayloadQueue() {
+  var queue = [];
+  return {
+    bytesCount: 0,
+    enqueue: function enqueue(payload) {
+      if (this.isFull()) {
+        return;
+      }
+
+      queue.push(payload);
+      this.bytesCount += payload.bytesCount;
+    },
+
+    first() {
+      return queue[0];
+    },
+
+    dequeue() {
+      var payload = queue.shift();
+
+      if (payload) {
+        this.bytesCount -= payload.bytesCount;
+      }
+
+      return payload;
+    },
+
+    size() {
+      return queue.length;
+    },
+
+    isFull() {
+      return this.bytesCount >= MAX_QUEUE_BYTES_COUNT;
+    }
+
+  };
+}
+
+function newBandwidthMonitor() {
+  return {
+    ongoingRequestCount: 0,
+    ongoingByteCount: 0,
+    canHandle: function canHandle(payload) {
+      return this.ongoingRequestCount === 0 || this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT && this.ongoingRequestCount < MAX_ONGOING_REQUESTS;
+    },
+    add: function add(payload) {
+      this.ongoingRequestCount += 1;
+      this.ongoingByteCount += payload.bytesCount;
+    },
+    remove: function remove(payload) {
+      this.ongoingRequestCount -= 1;
+      this.ongoingByteCount -= payload.bytesCount;
+    }
+  };
+}

package/esm/transport/startBatchWithReplica.js

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