@cloudcare/browser-core 1.1.2 → 1.2.0

package/cjs/transport/sendWithRetryStrategy.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MAX_QUEUE_BYTES_COUNT = exports.MAX_ONGOING_REQUESTS = exports.MAX_ONGOING_BYTES_COUNT = exports.MAX_BACKOFF_TIME = exports.INITIAL_BACKOFF_TIME = void 0;
+exports.newRetryState = newRetryState;
+exports.sendWithRetryStrategy = sendWithRetryStrategy;
+
+var _tools = require("../helper/tools");
+
+var _errorTools = require("../helper/errorTools");
+
+var MAX_ONGOING_BYTES_COUNT = 80 * _tools.ONE_KIBI_BYTE;
+exports.MAX_ONGOING_BYTES_COUNT = MAX_ONGOING_BYTES_COUNT;
+var MAX_ONGOING_REQUESTS = 32;
+exports.MAX_ONGOING_REQUESTS = MAX_ONGOING_REQUESTS;
+var MAX_QUEUE_BYTES_COUNT = 3 * _tools.ONE_MEBI_BYTE;
+exports.MAX_QUEUE_BYTES_COUNT = MAX_QUEUE_BYTES_COUNT;
+var MAX_BACKOFF_TIME = 256 * _tools.ONE_SECOND;
+exports.MAX_BACKOFF_TIME = MAX_BACKOFF_TIME;
+var INITIAL_BACKOFF_TIME = _tools.ONE_SECOND;
+exports.INITIAL_BACKOFF_TIME = INITIAL_BACKOFF_TIME;
+var TransportStatus = {
+  UP: 'UP',
+  FAILURE_DETECTED: 'FAILURE_DETECTED',
+  DOWN: 'DOWN'
+};
+var RetryReason = {
+  AFTER_SUCCESS: 'AFTER_SUCCESS',
+  AFTER_RESUME: 'AFTER_RESUME'
+};
+
+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 / _tools.ONE_MEBI_BYTE + 'MiB',
+      source: _errorTools.ErrorSource.AGENT,
+      startClocks: (0, _tools.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;
+}
+
+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: function first() {
+      return queue[0];
+    },
+    dequeue: function dequeue() {
+      var payload = queue.shift();
+
+      if (payload) {
+        this.bytesCount -= payload.bytesCount;
+      }
+
+      return payload;
+    },
+    size: function size() {
+      return queue.length;
+    },
+    isFull: function 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/cjs/transport/startBatchWithReplica.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startBatchWithReplica = startBatchWithReplica;
+
+var _batch = require("./batch");
+
+var _httpRequest = require("./httpRequest");
+
+function startBatchWithReplica(configuration, endpointUrl, reportError) {
+  var primaryBatch = createBatch(endpointUrl);
+
+  function createBatch(endpointUrl) {
+    return new _batch.Batch((0, _httpRequest.createHttpRequest)(endpointUrl, configuration.batchBytesLimit, reportError), configuration.batchMessagesLimit, configuration.batchBytesLimit, configuration.messageBytesLimit, configuration.flushTimeout);
+  }
+
+  return {
+    add: function add(message) {
+      primaryBatch.add(message);
+    }
+  };
+}

package/esm/{cookie.js → browser/cookie.js}

@@ -1,39 +1,5 @@
-import { findCommaSeparatedValue, UUID, ONE_SECOND } from './helper/tools';
+import { findCommaSeparatedValue, UUID, ONE_SECOND } from '../helper/tools';
 export var COOKIE_ACCESS_DELAY = ONE_SECOND;
-export function cacheCookieAccess(name, options) {
-  var timeout;
-  var cache;
-  var hasCache = false;
-
-  var cacheAccess = function cacheAccess() {
-    hasCache = true;
-    window.clearTimeout(timeout);
-    timeout = window.setTimeout(function () {
-      hasCache = false;
-    }, COOKIE_ACCESS_DELAY);
-  };
-
-  return {
-    get: function get() {
-      if (hasCache) {
-        return cache;
-      }
-
-      cache = getCookie(name);
-      cacheAccess();
-      return cache;
-    },
-    set: function set(value, expireDelay) {
-      setCookie(name, value, expireDelay, options);
-      cache = value;
-      cacheAccess();
-    },
-    clearCache: function clearCache() {
-      window.clearTimeout(timeout);
-      hasCache = false;
-    }
-  };
-}
 export function setCookie(name, value, expireDelay, options) {
   var date = new Date();
   date.setTime(date.getTime() + expireDelay);
@@ -46,6 +12,9 @@ export function setCookie(name, value, expireDelay, options) {
 export function getCookie(name) {
   return findCommaSeparatedValue(document.cookie, name);
 }
+export function deleteCookie(name, options) {
+  setCookie(name, '', 0, options);
+}
 export function areCookiesAuthorized(options) {
   if (document.cookie === undefined || document.cookie === null) {
     return false;

package/esm/browser/fetchObservable.js

@@ -0,0 +1,77 @@
+import { instrumentMethod } from '../helper/instrumentMethod';
+import { Observable } from '../helper/observable';
+import { elapsed, clocksNow, timeStampNow } from '../helper/tools';
+import { normalizeUrl } from '../helper/urlPolyfill';
+var fetchObservable;
+export function initFetchObservable() {
+  if (!fetchObservable) {
+    fetchObservable = createFetchObservable();
+  }
+
+  return fetchObservable;
+}
+
+function createFetchObservable() {
+  var observable = new Observable(function () {
+    if (!window.fetch) {
+      return;
+    }
+
+    var fetchMethod = instrumentMethod(window, 'fetch', function (originalFetch) {
+      return function (input, init) {
+        var responsePromise;
+        var context = beforeSend(observable, input, init);
+
+        if (context) {
+          responsePromise = originalFetch.call(this, context.input, context.init);
+          afterSend(observable, responsePromise, context);
+        } else {
+          responsePromise = originalFetch.call(this, input, init);
+        }
+
+        return responsePromise;
+      };
+    });
+    return fetchMethod.stop;
+  });
+  return observable;
+}
+
+function beforeSend(observable, input, init) {
+  var method = init && init.method || typeof input === 'object' && input.method || 'GET';
+  var url = normalizeUrl(typeof input === 'object' && input.url || input);
+  var startClocks = clocksNow();
+  var context = {
+    state: 'start',
+    init: init,
+    input: input,
+    method: method,
+    startClocks: startClocks,
+    url: url
+  };
+  observable.notify(context);
+  return context;
+}
+
+function afterSend(observable, responsePromise, startContext) {
+  var reportFetch = function reportFetch(response) {
+    var context = startContext;
+    context.state = 'complete';
+    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);
+    }
+  };
+
+  responsePromise.then(reportFetch, reportFetch);
+}

package/esm/browser/xhrObservable.js

@@ -0,0 +1,106 @@
+import { instrumentMethodAndCallOriginal } from '../helper/instrumentMethod';
+import { Observable } from '../helper/observable';
+import { normalizeUrl } from '../helper/urlPolyfill';
+import { shallowClone, elapsed, relativeNow, clocksNow, timeStampNow, UUID } from '../helper/tools';
+var xhrObservable;
+var xhrContexts = {};
+var DATA_FLUX_REQUEST_ID_KEY = '_DATAFLUX_REQUEST_UUID';
+export function initXhrObservable() {
+  if (!xhrObservable) {
+    xhrObservable = createXhrObservable();
+  }
+
+  return xhrObservable;
+}
+
+function createXhrObservable() {
+  var observable = new Observable(function () {
+    var openInstrumentMethod = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'open', {
+      before: openXhr
+    });
+    var sendInstrumentMethod = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'send', {
+      before: function before() {
+        sendXhr.call(this, observable);
+      }
+    });
+    var abortInstrumentMethod = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'abort', {
+      before: abortXhr
+    });
+    return function () {
+      openInstrumentMethod.stop();
+      sendInstrumentMethod.stop();
+      abortInstrumentMethod.stop();
+    };
+  });
+  return observable;
+}
+
+function openXhr(method, url) {
+  var requestUUID = this[DATA_FLUX_REQUEST_ID_KEY] || UUID();
+  this[DATA_FLUX_REQUEST_ID_KEY] = requestUUID;
+  xhrContexts[requestUUID] = {
+    state: 'open',
+    method: method,
+    url: normalizeUrl(String(url))
+  };
+}
+
+function sendXhr(observable) {
+  var context = xhrContexts[this[DATA_FLUX_REQUEST_ID_KEY]];
+
+  if (!context) {
+    return;
+  }
+
+  var startContext = context;
+  startContext.state = 'start';
+  startContext.startTime = relativeNow();
+  startContext.startClocks = clocksNow();
+  startContext.isAborted = false;
+  startContext.xhr = this;
+  var hasBeenReported = false;
+  var onreadyStateChangeInstrumentMethod = instrumentMethodAndCallOriginal(this, 'onreadystatechange', {
+    before: function before() {
+      if (this.readyState === XMLHttpRequest.DONE) {
+        // Try to report the XHR as soon as possible, because the XHR may be mutated by the
+        // application during a future event. For example, Angular is calling .abort() on
+        // completed requests during a onreadystatechange event, so the status becomes '0'
+        // before the request is collected.
+        onEnd.call(this);
+      }
+    }
+  });
+
+  var onEnd = function onEnd() {
+    this.removeEventListener('loadend', onEnd);
+    onreadyStateChangeInstrumentMethod.stop();
+
+    if (hasBeenReported) {
+      return;
+    }
+
+    hasBeenReported = true;
+    var completeContext = context;
+    completeContext.state = 'complete';
+    completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow());
+    completeContext.status = this.status;
+    observable.notify(shallowClone(completeContext));
+    clearRequestId.call(this);
+  };
+
+  this.addEventListener('loadend', onEnd);
+  observable.notify(startContext);
+}
+
+function clearRequestId() {
+  delete xhrContexts[this[DATA_FLUX_REQUEST_ID_KEY]];
+  delete this[DATA_FLUX_REQUEST_ID_KEY];
+}
+
+function abortXhr() {
+  var context = xhrContexts[this[DATA_FLUX_REQUEST_ID_KEY]];
+
+  if (context) {
+    context.isAborted = true;
+  }
+}

package/esm/configuration/configuration.js

@@ -0,0 +1,55 @@
+import { getCurrentSite } from '../browser/cookie';
+import { catchUserErrors } from '../helper/catchUserErrors';
+import { display } from '../helper/display';
+import { assign, isPercentage, ONE_KIBI_BYTE, ONE_SECOND, isNullUndefinedDefaultValue } from '../helper/tools';
+import { computeTransportConfiguration } from './transportConfiguration';
+export function validateAndBuildConfiguration(initConfiguration) {
+  if (initConfiguration.sampleRate !== undefined && !isPercentage(initConfiguration.sampleRate)) {
+    display.error('Sample Rate should be a number between 0 and 100');
+    return;
+  }
+
+  return assign({
+    beforeSend: initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),
+    cookieOptions: buildCookieOptions(initConfiguration),
+    sampleRate: isNullUndefinedDefaultValue(initConfiguration.sampleRate, 100),
+    service: initConfiguration.service,
+    version: initConfiguration.version,
+    env: initConfiguration.env,
+    silentMultipleInit: !!initConfiguration.silentMultipleInit,
+
+    /**
+     * beacon payload max queue size implementation is 64kb
+     * ensure that we leave room for logs, rum and potential other users
+     */
+    batchBytesLimit: 16 * ONE_KIBI_BYTE,
+    eventRateLimiterThreshold: 3000,
+
+    /**
+     * flush automatically, aim to be lower than ALB connection timeout
+     * to maximize connection reuse.
+     */
+    flushTimeout: 30 * ONE_SECOND,
+
+    /**
+     * Logs intake limit
+     */
+    batchMessagesLimit: 50,
+    messageBytesLimit: 256 * ONE_KIBI_BYTE
+  }, computeTransportConfiguration(initConfiguration));
+}
+export function buildCookieOptions(initConfiguration) {
+  var cookieOptions = {};
+  cookieOptions.secure = mustUseSecureCookie(initConfiguration);
+  cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie;
+
+  if (initConfiguration.trackSessionAcrossSubdomains) {
+    cookieOptions.domain = getCurrentSite();
+  }
+
+  return cookieOptions;
+}
+
+function mustUseSecureCookie(initConfiguration) {
+  return !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie;
+}

package/esm/configuration/transportConfiguration.js

@@ -0,0 +1,54 @@
+import { isFunction, isBoolean, some } from '../helper/tools';
+var TRIM_REGIX = /^\s+|\s+$/g;
+
+function getDatakitUrl(url) {
+  if (url.lastIndexOf('/') === url.length - 1) return trim(url) + 'v1/write/rum';
+  return trim(url) + '/v1/write/rum';
+}
+
+function trim(str) {
+  return str.replace(TRIM_REGIX, '');
+}
+
+function getLogsEndPoint(url) {
+  if (url.lastIndexOf('/') === url.length - 1) return trim(url) + 'v1/write/logging';
+  return trim(url) + '/v1/write/logging';
+}
+
+export function computeTransportConfiguration(initConfiguration) {
+  var isIntakeUrl = function isIntakeUrl(url) {
+    return false;
+  };
+
+  if ('isIntakeUrl' in initConfiguration && isFunction(initConfiguration.isIntakeUrl) && isBoolean(initConfiguration.isIntakeUrl())) {
+    isIntakeUrl = initConfiguration.isIntakeUrl;
+  }
+
+  var isServerError = function isServerError(request) {
+    return false;
+  };
+
+  if ('isServerError' in initConfiguration && isFunction(initConfiguration.isServerError) && isBoolean(initConfiguration.isServerError())) {
+    isServerError = initConfiguration.isServerError;
+  }
+
+  return {
+    datakitUrl: getDatakitUrl(initConfiguration.datakitUrl || initConfiguration.datakitOrigin),
+    logsEndpoint: getLogsEndPoint(initConfiguration.datakitOrigin),
+    isIntakeUrl: isIntakeUrl,
+    isServerError: isServerError
+  };
+}
+export function isIntakeRequest(url, configuration) {
+  // return haveSameOrigin(url, configuration.datakitUrl)
+  var notTakeRequest = [configuration.datakitUrl];
+
+  if (configuration.logsEndpoint) {
+    notTakeRequest.push(configuration.logsEndpoint);
+  } // datakit 地址，log 地址，以及客户自定义过滤方法定义url
+
+
+  return some(notTakeRequest, function (takeUrl) {
+    return url.indexOf(takeUrl) === 0;
+  }) || configuration.isIntakeUrl(url);
+}

package/esm/console/consoleObservable.js

@@ -0,0 +1,70 @@
+import { computeStackTrace } from '../tracekit';
+import { createHandlingStack, formatErrorMessage, toStackTraceString } from '../helper/errorTools';
+import { mergeObservables, Observable } from '../helper/observable';
+import { find, jsonStringify, map } from '../helper/tools';
+import { ConsoleApiName } from '../helper/display';
+var consoleObservablesByApi = {};
+export function initConsoleObservable(apis) {
+  var consoleObservables = map(apis, function (api) {
+    if (!consoleObservablesByApi[api]) {
+      consoleObservablesByApi[api] = createConsoleObservable(api);
+    }
+
+    return consoleObservablesByApi[api];
+  });
+  return mergeObservables.apply(this, consoleObservables);
+}
+/* eslint-disable no-console */
+
+function createConsoleObservable(api) {
+  var observable = new Observable(function () {
+    var originalConsoleApi = console[api];
+
+    console[api] = function () {
+      var params = [].slice.call(arguments);
+      originalConsoleApi.apply(console, arguments);
+      var handlingStack = createHandlingStack();
+      observable.notify(buildConsoleLog(params, api, handlingStack));
+    };
+
+    return function () {
+      console[api] = originalConsoleApi;
+    };
+  });
+  return observable;
+}
+
+function buildConsoleLog(params, api, handlingStack) {
+  // Todo: remove console error prefix in the next major version
+  var message = map(params, function (param) {
+    return formatConsoleParameters(param);
+  }).join(' ');
+  var stack;
+
+  if (api === ConsoleApiName.error) {
+    var firstErrorParam = find(params, function (param) {
+      return param instanceof Error;
+    });
+    stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined;
+    message = 'console error: ' + message;
+  }
+
+  return {
+    api: api,
+    message: message,
+    stack: stack,
+    handlingStack: handlingStack
+  };
+}
+
+function formatConsoleParameters(param) {
+  if (typeof param === 'string') {
+    return param;
+  }
+
+  if (param instanceof Error) {
+    return formatErrorMessage(computeStackTrace(param));
+  }
+
+  return jsonStringify(param, undefined, 2);
+}