@cloudcare/browser-core 1.1.3 → 1.2.1

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

@@ -5,51 +5,16 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.COOKIE_ACCESS_DELAY = void 0;
 exports.areCookiesAuthorized = areCookiesAuthorized;
-exports.cacheCookieAccess = cacheCookieAccess;
+exports.deleteCookie = deleteCookie;
 exports.getCookie = getCookie;
 exports.getCurrentSite = getCurrentSite;
 exports.setCookie = setCookie;
 
-var _tools = require("./helper/tools");
+var _tools = require("../helper/tools");
 
 var COOKIE_ACCESS_DELAY = _tools.ONE_SECOND;
 exports.COOKIE_ACCESS_DELAY = COOKIE_ACCESS_DELAY;
 
-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;
-    }
-  };
-}
-
 function setCookie(name, value, expireDelay, options) {
   var date = new Date();
   date.setTime(date.getTime() + expireDelay);
@@ -64,6 +29,10 @@ function getCookie(name) {
   return (0, _tools.findCommaSeparatedValue)(document.cookie, name);
 }
 
+function deleteCookie(name, options) {
+  setCookie(name, '', 0, options);
+}
+
 function areCookiesAuthorized(options) {
   if (document.cookie === undefined || document.cookie === null) {
     return false;

package/cjs/browser/fetchObservable.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initFetchObservable = initFetchObservable;
+
+var _instrumentMethod = require("../helper/instrumentMethod");
+
+var _observable = require("../helper/observable");
+
+var _tools = require("../helper/tools");
+
+var _urlPolyfill = require("../helper/urlPolyfill");
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var fetchObservable;
+
+function initFetchObservable() {
+  if (!fetchObservable) {
+    fetchObservable = createFetchObservable();
+  }
+
+  return fetchObservable;
+}
+
+function createFetchObservable() {
+  var observable = new _observable.Observable(function () {
+    if (!window.fetch) {
+      return;
+    }
+
+    var fetchMethod = (0, _instrumentMethod.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 = (0, _urlPolyfill.normalizeUrl)(_typeof(input) === 'object' && input.url || input);
+  var startClocks = (0, _tools.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 = (0, _tools.elapsed)(context.startClocks.timeStamp, (0, _tools.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/cjs/browser/xhrObservable.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initXhrObservable = initXhrObservable;
+
+var _instrumentMethod = require("../helper/instrumentMethod");
+
+var _observable = require("../helper/observable");
+
+var _urlPolyfill = require("../helper/urlPolyfill");
+
+var _tools = require("../helper/tools");
+
+var xhrObservable;
+var xhrContexts = {};
+var DATA_FLUX_REQUEST_ID_KEY = '_DATAFLUX_REQUEST_UUID';
+
+function initXhrObservable() {
+  if (!xhrObservable) {
+    xhrObservable = createXhrObservable();
+  }
+
+  return xhrObservable;
+}
+
+function createXhrObservable() {
+  var observable = new _observable.Observable(function () {
+    var openInstrumentMethod = (0, _instrumentMethod.instrumentMethodAndCallOriginal)(XMLHttpRequest.prototype, 'open', {
+      before: openXhr
+    });
+    var sendInstrumentMethod = (0, _instrumentMethod.instrumentMethodAndCallOriginal)(XMLHttpRequest.prototype, 'send', {
+      before: function before() {
+        sendXhr.call(this, observable);
+      }
+    });
+    var abortInstrumentMethod = (0, _instrumentMethod.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] || (0, _tools.UUID)();
+  this[DATA_FLUX_REQUEST_ID_KEY] = requestUUID;
+  xhrContexts[requestUUID] = {
+    state: 'open',
+    method: method,
+    url: (0, _urlPolyfill.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 = (0, _tools.relativeNow)();
+  startContext.startClocks = (0, _tools.clocksNow)();
+  startContext.isAborted = false;
+  startContext.xhr = this;
+  var hasBeenReported = false;
+  var onreadyStateChangeInstrumentMethod = (0, _instrumentMethod.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 = (0, _tools.elapsed)(startContext.startClocks.timeStamp, (0, _tools.timeStampNow)());
+    completeContext.status = this.status;
+    observable.notify((0, _tools.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/cjs/configuration/configuration.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCookieOptions = buildCookieOptions;
+exports.validateAndBuildConfiguration = validateAndBuildConfiguration;
+
+var _cookie = require("../browser/cookie");
+
+var _catchUserErrors = require("../helper/catchUserErrors");
+
+var _display = require("../helper/display");
+
+var _tools = require("../helper/tools");
+
+var _transportConfiguration = require("./transportConfiguration");
+
+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');
+
+    return;
+  }
+
+  return (0, _tools.assign)({
+    beforeSend: initConfiguration.beforeSend && (0, _catchUserErrors.catchUserErrors)(initConfiguration.beforeSend, 'beforeSend threw an error:'),
+    cookieOptions: buildCookieOptions(initConfiguration),
+    sampleRate: (0, _tools.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 * _tools.ONE_KIBI_BYTE,
+    eventRateLimiterThreshold: 3000,
+
+    /**
+     * flush automatically, aim to be lower than ALB connection timeout
+     * to maximize connection reuse.
+     */
+    flushTimeout: 30 * _tools.ONE_SECOND,
+
+    /**
+     * Logs intake limit
+     */
+    batchMessagesLimit: 50,
+    messageBytesLimit: 256 * _tools.ONE_KIBI_BYTE
+  }, (0, _transportConfiguration.computeTransportConfiguration)(initConfiguration));
+}
+
+function buildCookieOptions(initConfiguration) {
+  var cookieOptions = {};
+  cookieOptions.secure = mustUseSecureCookie(initConfiguration);
+  cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie;
+
+  if (initConfiguration.trackSessionAcrossSubdomains) {
+    cookieOptions.domain = (0, _cookie.getCurrentSite)();
+  }
+
+  return cookieOptions;
+}
+
+function mustUseSecureCookie(initConfiguration) {
+  return !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie;
+}

package/cjs/configuration/transportConfiguration.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeTransportConfiguration = computeTransportConfiguration;
+exports.isIntakeRequest = isIntakeRequest;
+
+var _tools = require("../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';
+}
+
+function computeTransportConfiguration(initConfiguration) {
+  var isIntakeUrl = function isIntakeUrl(url) {
+    return false;
+  };
+
+  if ('isIntakeUrl' in initConfiguration && (0, _tools.isFunction)(initConfiguration.isIntakeUrl) && (0, _tools.isBoolean)(initConfiguration.isIntakeUrl())) {
+    isIntakeUrl = initConfiguration.isIntakeUrl;
+  }
+
+  var isServerError = function isServerError(request) {
+    return false;
+  };
+
+  if ('isServerError' in initConfiguration && (0, _tools.isFunction)(initConfiguration.isServerError) && (0, _tools.isBoolean)(initConfiguration.isServerError())) {
+    isServerError = initConfiguration.isServerError;
+  }
+
+  return {
+    datakitUrl: getDatakitUrl(initConfiguration.datakitUrl || initConfiguration.datakitOrigin),
+    logsEndpoint: getLogsEndPoint(initConfiguration.datakitOrigin),
+    isIntakeUrl: isIntakeUrl,
+    isServerError: isServerError
+  };
+}
+
+function isIntakeRequest(url, configuration) {
+  // return haveSameOrigin(url, configuration.datakitUrl)
+  var notTakeRequest = [configuration.datakitUrl];
+
+  if (configuration.logsEndpoint) {
+    notTakeRequest.push(configuration.logsEndpoint);
+  } // datakit 地址，log 地址，以及客户自定义过滤方法定义url
+
+
+  return (0, _tools.some)(notTakeRequest, function (takeUrl) {
+    return url.indexOf(takeUrl) === 0;
+  }) || configuration.isIntakeUrl(url);
+}

package/cjs/console/consoleObservable.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initConsoleObservable = initConsoleObservable;
+
+var _tracekit = require("../tracekit");
+
+var _errorTools = require("../helper/errorTools");
+
+var _observable = require("../helper/observable");
+
+var _tools = require("../helper/tools");
+
+var _display = require("../helper/display");
+
+var consoleObservablesByApi = {};
+
+function initConsoleObservable(apis) {
+  var consoleObservables = (0, _tools.map)(apis, function (api) {
+    if (!consoleObservablesByApi[api]) {
+      consoleObservablesByApi[api] = createConsoleObservable(api);
+    }
+
+    return consoleObservablesByApi[api];
+  });
+  return _observable.mergeObservables.apply(this, consoleObservables);
+}
+/* eslint-disable no-console */
+
+
+function createConsoleObservable(api) {
+  var observable = new _observable.Observable(function () {
+    var originalConsoleApi = console[api];
+
+    console[api] = function () {
+      var params = [].slice.call(arguments);
+      originalConsoleApi.apply(console, arguments);
+      var handlingStack = (0, _errorTools.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 = (0, _tools.map)(params, function (param) {
+    return formatConsoleParameters(param);
+  }).join(' ');
+  var stack;
+
+  if (api === _display.ConsoleApiName.error) {
+    var firstErrorParam = (0, _tools.find)(params, function (param) {
+      return param instanceof Error;
+    });
+    stack = firstErrorParam ? (0, _errorTools.toStackTraceString)((0, _tracekit.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 (0, _errorTools.formatErrorMessage)((0, _tracekit.computeStackTrace)(param));
+  }
+
+  return (0, _tools.jsonStringify)(param, undefined, 2);
+}

package/cjs/dataMap.js

@@ -8,12 +8,13 @@ exports.dataMap = exports.commonTags = 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',
-  env: '_dd.env',
-  service: '_dd.service',
-  version: '_dd.version',
+  env: 'env',
+  service: 'service',
+  version: 'version',
   userid: 'user.id',
   user_email: 'user.email',
   user_name: 'user.name',
@@ -101,27 +102,31 @@ var dataMap = {
   error: {
     type: _enums.RumEventType.ERROR,
     tags: {
+      error_id: 'error.id',
       trace_id: '_dd.trace_id',
       span_id: '_dd.span_id',
       error_source: 'error.source',
       error_type: 'error.type',
-      error_handling: 'error.handling',
-      resource_url: 'error.resource.url',
-      resource_url_host: 'error.resource.url_host',
-      resource_url_path: 'error.resource.url_path',
-      resource_url_path_group: 'error.resource.url_path_group',
-      resource_status: 'error.resource.status',
-      resource_status_group: 'error.resource.status_group',
-      resource_method: 'error.resource.method'
+      error_handling: 'error.handling' //   resource_url: 'error.resource.url',
+      //   resource_url_host: 'error.resource.url_host',
+      //   resource_url_path: 'error.resource.url_path',
+      //   resource_url_path_group: 'error.resource.url_path_group',
+      //   resource_status: 'error.resource.status',
+      //   resource_status_group: 'error.resource.status_group',
+      //   resource_method: 'error.resource.method'
+
     },
     fields: {
       error_message: ['string', 'error.message'],
-      error_stack: ['string', 'error.stack']
+      error_stack: ['string', 'error.stack'],
+      error_causes: ['string', 'error.causes']
     }
   },
   long_task: {
     type: _enums.RumEventType.LONG_TASK,
-    tags: {},
+    tags: {
+      long_task_id: 'long_task.id'
+    },
     fields: {
       duration: 'long_task.duration'
     }
@@ -129,7 +134,6 @@ var dataMap = {
   action: {
     type: _enums.RumEventType.ACTION,
     tags: {
-      action_id: 'action.id',
       action_name: 'action.target.name',
       action_type: 'action.type'
     },
@@ -137,6 +141,7 @@ var dataMap = {
       duration: 'action.loading_time',
       action_error_count: 'action.error.count',
       action_resource_count: 'action.resource.count',
+      action_frustration_types: 'action.frustration.type',
       action_long_task_count: 'action.long_task.count'
     }
   },
@@ -145,13 +150,13 @@ var dataMap = {
     tags: {
       error_source: 'error.source',
       error_type: 'error.type',
-      error_resource_url: 'resource.url',
-      error_resource_url_host: 'resource.url_host',
-      error_resource_url_path: 'resource.url_path',
-      error_resource_url_path_group: 'resource.url_path_group',
-      error_resource_status: 'resource.status',
-      error_resource_status_group: 'resource.status_group',
-      error_resource_method: 'resource.method',
+      error_resource_url: 'http.url',
+      error_resource_url_host: 'http.url_host',
+      error_resource_url_path: 'http.url_path',
+      error_resource_url_path_group: 'http.url_path_group',
+      error_resource_status: 'http.status_code',
+      error_resource_status_group: 'http.status_group',
+      error_resource_method: 'http.method',
       action_id: 'user_action.id',
       service: 'service',
       status: 'status'

package/cjs/error/trackRuntimeError.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.trackRuntimeError = trackRuntimeError;
+
+var _errorTools = require("../helper/errorTools");
+
+var _tools = require("../helper/tools");
+
+var _enums = require("../helper/enums");
+
+var _tracekit = require("../tracekit");
+
+function trackRuntimeError(errorObservable) {
+  return (0, _tracekit.startUnhandledErrorCollection)(function (stackTrace, originalError) {
+    errorObservable.notify((0, _errorTools.computeRawError)({
+      stackTrace: stackTrace,
+      originalError: originalError,
+      startClocks: (0, _tools.clocksNow)(),
+      nonErrorPrefix: 'Uncaught',
+      source: _errorTools.ErrorSource.SOURCE,
+      handling: _enums.ErrorHandling.UNHANDLED
+    }));
+  });
+}

package/cjs/helper/catchUserErrors.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.catchUserErrors = catchUserErrors;
+
+var _display = require("./display");
+
+function catchUserErrors(fn, errorMsg) {
+  return function () {
+    var args = [].slice.call(arguments);
+
+    try {
+      return fn.apply(this, args);
+    } catch (err) {
+      _display.display.error(errorMsg, err);
+    }
+  };
+}