@cloudcare/browser-core 1.1.2 → 1.2.0

package/cjs/report/reportObservable.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RawReportType = void 0;
+exports.initReportObservable = initReportObservable;
+
+var _errorTools = require("../helper/errorTools");
+
+var _observable = require("../helper/observable");
+
+var _tools = require("../helper/tools");
+
+var _enums = require("../helper/enums");
+
+var RawReportType = {
+  intervention: 'intervention',
+  deprecation: 'deprecation',
+  cspViolation: 'csp_violation'
+};
+exports.RawReportType = RawReportType;
+
+function initReportObservable(apis) {
+  var observables = [];
+
+  if ((0, _tools.includes)(apis, RawReportType.cspViolation)) {
+    observables.push(createCspViolationReportObservable());
+  }
+
+  var reportTypes = (0, _tools.filter)(apis, function (api) {
+    return api !== RawReportType.cspViolation;
+  });
+
+  if (reportTypes.length) {
+    observables.push(createReportObservable(reportTypes));
+  }
+
+  return _observable.mergeObservables.apply(this, observables);
+}
+
+function createReportObservable(reportTypes) {
+  var observable = new _observable.Observable(function () {
+    if (!window.ReportingObserver) {
+      return;
+    }
+
+    var handleReports = function handleReports(reports) {
+      (0, _tools.each)(reports, function (report) {
+        observable.notify(buildRawReportFromReport(report));
+      });
+    };
+
+    var observer = new window.ReportingObserver(handleReports, {
+      types: reportTypes,
+      buffered: true
+    });
+    observer.observe();
+    return function () {
+      observer.disconnect();
+    };
+  });
+  return observable;
+}
+
+function createCspViolationReportObservable() {
+  var observable = new _observable.Observable(function () {
+    var handleCspViolation = function handleCspViolation(event) {
+      observable.notify(buildRawReportFromCspViolation(event));
+    };
+
+    var _addEventListener = (0, _tools.addEventListener)(document, _enums.DOM_EVENT.SECURITY_POLICY_VIOLATION, handleCspViolation);
+
+    return _addEventListener.stop;
+  });
+  return observable;
+}
+
+function buildRawReportFromReport(report) {
+  var body = report.body;
+  var type = report.type;
+  return {
+    type: type,
+    subtype: body.id,
+    message: type + ': ' + body.message,
+    stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber)
+  };
+}
+
+function buildRawReportFromCspViolation(event) {
+  var type = RawReportType.cspViolation;
+  var message = '\'' + event.blockedURI + '\' blocked by \'' + event.effectiveDirective + '\' directive';
+  return {
+    type: RawReportType.cspViolation,
+    subtype: event.effectiveDirective,
+    message: type + ': ' + message,
+    stack: buildStack(event.effectiveDirective, message + ' of the policy "' + (0, _tools.safeTruncate)(event.originalPolicy, 100, '...') + '"', event.sourceFile, event.lineNumber, event.columnNumber)
+  };
+}
+
+function buildStack(name, message, sourceFile, lineNumber, columnNumber) {
+  return sourceFile && (0, _errorTools.toStackTraceString)({
+    name: name,
+    message: message,
+    stack: [{
+      func: '?',
+      url: sourceFile,
+      line: lineNumber,
+      column: columnNumber
+    }]
+  });
+}

package/cjs/session/sessionConstants.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SESSION_TIME_OUT_DELAY = exports.SESSION_EXPIRATION_DELAY = void 0;
+
+var _tools = require("../helper/tools");
+
+var SESSION_TIME_OUT_DELAY = 4 * _tools.ONE_HOUR;
+exports.SESSION_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;
+var SESSION_EXPIRATION_DELAY = 15 * _tools.ONE_MINUTE;
+exports.SESSION_EXPIRATION_DELAY = SESSION_EXPIRATION_DELAY;

package/cjs/session/sessionCookieStore.js

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SESSION_COOKIE_NAME = exports.MAX_NUMBER_OF_LOCK_RETRIES = exports.LOCK_RETRY_DELAY = void 0;
+exports.persistSession = persistSession;
+exports.retrieveSession = retrieveSession;
+exports.toSessionString = toSessionString;
+exports.withCookieLockAccess = withCookieLockAccess;
+
+var _cookie = require("../browser/cookie");
+
+var _tools = require("../helper/tools");
+
+var _sessionConstants = require("./sessionConstants");
+
+var SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/;
+var SESSION_ENTRY_SEPARATOR = '&';
+var SESSION_COOKIE_NAME = '_dataflux_s'; // arbitrary values
+
+exports.SESSION_COOKIE_NAME = SESSION_COOKIE_NAME;
+var LOCK_RETRY_DELAY = 10;
+exports.LOCK_RETRY_DELAY = LOCK_RETRY_DELAY;
+var MAX_NUMBER_OF_LOCK_RETRIES = 100;
+exports.MAX_NUMBER_OF_LOCK_RETRIES = MAX_NUMBER_OF_LOCK_RETRIES;
+var bufferedOperations = [];
+var ongoingOperations;
+
+function withCookieLockAccess(operations, numberOfRetries) {
+  if (typeof numberOfRetries === 'undefined') {
+    numberOfRetries = 0;
+  }
+
+  if (!ongoingOperations) {
+    ongoingOperations = operations;
+  }
+
+  if (operations !== ongoingOperations) {
+    bufferedOperations.push(operations);
+    return;
+  }
+
+  if (numberOfRetries >= MAX_NUMBER_OF_LOCK_RETRIES) {
+    next();
+    return;
+  }
+
+  var currentLock;
+  var currentSession = retrieveSession();
+
+  if (isCookieLockEnabled()) {
+    // if someone has lock, retry later
+    if (currentSession.lock) {
+      retryLater(operations, numberOfRetries);
+      return;
+    } // acquire lock
+
+
+    currentLock = (0, _tools.UUID)();
+    currentSession.lock = currentLock;
+    setSession(currentSession, operations.options); // if lock is not acquired, retry later
+
+    currentSession = retrieveSession();
+
+    if (currentSession.lock !== currentLock) {
+      retryLater(operations, numberOfRetries);
+      return;
+    }
+  }
+
+  var processedSession = operations.process(currentSession);
+
+  if (isCookieLockEnabled()) {
+    // if lock corrupted after process, retry later
+    currentSession = retrieveSession();
+
+    if (currentSession.lock !== currentLock) {
+      retryLater(operations, numberOfRetries);
+      return;
+    }
+  }
+
+  if (processedSession) {
+    persistSession(processedSession, operations.options);
+  }
+
+  if (isCookieLockEnabled()) {
+    // correctly handle lock around expiration would require to handle this case properly at several levels
+    // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it
+    if (!(processedSession && isExpiredState(processedSession))) {
+      // if lock corrupted after persist, retry later
+      currentSession = retrieveSession();
+
+      if (currentSession.lock !== currentLock) {
+        retryLater(operations, numberOfRetries);
+        return;
+      }
+
+      delete currentSession.lock;
+      setSession(currentSession, operations.options);
+      processedSession = currentSession;
+    }
+  } // call after even if session is not persisted in order to perform operations on
+  // up-to-date cookie value, the value could have been modified by another tab
+
+
+  if (operations.after) {
+    operations.after(processedSession || currentSession);
+  }
+
+  next();
+}
+/**
+ * Cookie lock strategy allows mitigating issues due to concurrent access to cookie.
+ * This issue concerns only chromium browsers and enabling this on firefox increase cookie write failures.
+ */
+
+
+function isCookieLockEnabled() {
+  return (0, _tools.isChromium)();
+}
+
+function retryLater(operations, currentNumberOfRetries) {
+  setTimeout(function () {
+    withCookieLockAccess(operations, currentNumberOfRetries + 1);
+  }, LOCK_RETRY_DELAY);
+}
+
+function next() {
+  ongoingOperations = undefined;
+  var nextOperations = bufferedOperations.shift();
+
+  if (nextOperations) {
+    withCookieLockAccess(nextOperations);
+  }
+}
+
+function persistSession(session, options) {
+  if (isExpiredState(session)) {
+    clearSession(options);
+    return;
+  }
+
+  session.expire = String((0, _tools.dateNow)() + _sessionConstants.SESSION_EXPIRATION_DELAY);
+  setSession(session, options);
+}
+
+function setSession(session, options) {
+  (0, _cookie.setCookie)(SESSION_COOKIE_NAME, toSessionString(session), _sessionConstants.SESSION_EXPIRATION_DELAY, options);
+}
+
+function toSessionString(session) {
+  return (0, _tools.map)((0, _tools.objectEntries)(session), function (item) {
+    return item[0] + '=' + item[1];
+  }).join(SESSION_ENTRY_SEPARATOR);
+}
+
+function retrieveSession() {
+  var sessionString = (0, _cookie.getCookie)(SESSION_COOKIE_NAME);
+  var session = {};
+
+  if (isValidSessionString(sessionString)) {
+    (0, _tools.each)(sessionString.split(SESSION_ENTRY_SEPARATOR), function (entry) {
+      var matches = SESSION_ENTRY_REGEXP.exec(entry);
+
+      if (matches !== null) {
+        var key = matches[1];
+        var value = matches[2];
+        session[key] = value;
+      }
+    });
+  }
+
+  return session;
+}
+
+function isValidSessionString(sessionString) {
+  return sessionString !== undefined && (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString));
+}
+
+function isExpiredState(session) {
+  return (0, _tools.isEmptyObject)(session);
+}
+
+function clearSession(options) {
+  (0, _cookie.setCookie)(SESSION_COOKIE_NAME, '', 0, options);
+}

package/cjs/session/sessionManagement.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startSessionManager = exports.VISIBILITY_CHECK_DELAY = void 0;
+exports.stopSessionManager = stopSessionManager;
+
+var _tools = require("../helper/tools");
+
+var _contextHistory = require("../helper/contextHistory");
+
+var _sessionStore = require("./sessionStore");
+
+var _sessionConstants = require("./sessionConstants");
+
+var _enums = require("../helper/enums");
+
+var VISIBILITY_CHECK_DELAY = _tools.ONE_MINUTE;
+exports.VISIBILITY_CHECK_DELAY = VISIBILITY_CHECK_DELAY;
+var SESSION_CONTEXT_TIMEOUT_DELAY = _sessionConstants.SESSION_TIME_OUT_DELAY;
+var stopCallbacks = [];
+
+var startSessionManager = function startSessionManager(options, productKey, computeSessionState) {
+  var sessionStore = (0, _sessionStore.startSessionStore)(options, productKey, computeSessionState);
+  stopCallbacks.push(function () {
+    return sessionStore.stop();
+  });
+  var sessionContextHistory = new _contextHistory.ContextHistory(SESSION_CONTEXT_TIMEOUT_DELAY);
+  stopCallbacks.push(function () {
+    return sessionContextHistory.stop();
+  });
+  sessionStore.renewObservable.subscribe(function () {
+    sessionContextHistory.add(buildSessionContext(), (0, _tools.relativeNow)());
+  });
+  sessionStore.expireObservable.subscribe(function () {
+    sessionContextHistory.closeActive((0, _tools.relativeNow)());
+  });
+  sessionStore.expandOrRenewSession();
+  sessionContextHistory.add(buildSessionContext(), (0, _tools.clocksOrigin)().relative);
+  trackActivity(function () {
+    return sessionStore.expandOrRenewSession();
+  });
+  trackVisibility(function () {
+    return sessionStore.expandSession();
+  });
+
+  function buildSessionContext() {
+    return {
+      id: sessionStore.getSession().id,
+      trackingType: sessionStore.getSession()[productKey]
+    };
+  }
+
+  return {
+    findActiveSession: function findActiveSession(startTime) {
+      return sessionContextHistory.find(startTime);
+    },
+    renewObservable: sessionStore.renewObservable,
+    expireObservable: sessionStore.expireObservable
+  };
+};
+
+exports.startSessionManager = startSessionManager;
+
+function stopSessionManager() {
+  (0, _tools.each)(stopCallbacks, function (e) {
+    return e();
+  });
+  stopCallbacks = [];
+}
+
+function trackActivity(expandOrRenewSession) {
+  var _addEventListeners = (0, _tools.addEventListeners)(window, [_enums.DOM_EVENT.CLICK, _enums.DOM_EVENT.TOUCH_START, _enums.DOM_EVENT.KEY_DOWN, _enums.DOM_EVENT.SCROLL], expandOrRenewSession, {
+    capture: true,
+    passive: true
+  });
+
+  stopCallbacks.push(_addEventListeners.stop);
+}
+
+function trackVisibility(expandSession) {
+  var expandSessionWhenVisible = function expandSessionWhenVisible() {
+    if (document.visibilityState === 'visible') {
+      expandSession();
+    }
+  };
+
+  var _addEventListener = (0, _tools.addEventListener)(document, _enums.DOM_EVENT.VISIBILITY_CHANGE, expandSessionWhenVisible);
+
+  stopCallbacks.push(_addEventListener.stop);
+  var visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);
+  stopCallbacks.push(function () {
+    clearInterval(visibilityCheckInterval);
+  });
+}

package/cjs/session/sessionStore.js

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startSessionStore = startSessionStore;
+
+var _cookie = require("../browser/cookie");
+
+var _observable = require("../helper/observable");
+
+var _tools = require("../helper/tools");
+
+var _sessionConstants = require("./sessionConstants");
+
+var _sessionCookieStore = require("./sessionCookieStore");
+
+/**
+ * Different session concepts:
+ * - tracked, the session has an id and is updated along the user navigation
+ * - not tracked, the session does not have an id but it is updated along the user navigation
+ * - inactive, no session in store or session expired, waiting for a renew session
+ */
+function startSessionStore(options, productKey, computeSessionState) {
+  var renewObservable = new _observable.Observable();
+  var expireObservable = new _observable.Observable();
+  var watchSessionTimeoutId = setInterval(watchSession, _cookie.COOKIE_ACCESS_DELAY);
+  var sessionCache = retrieveActiveSession();
+
+  function expandOrRenewSession() {
+    var isTracked;
+    (0, _sessionCookieStore.withCookieLockAccess)({
+      options: options,
+      process: function process(cookieSession) {
+        var synchronizedSession = synchronizeSession(cookieSession);
+        isTracked = expandOrRenewCookie(synchronizedSession);
+        return synchronizedSession;
+      },
+      after: function after(cookieSession) {
+        if (isTracked && !hasSessionInCache()) {
+          renewSession(cookieSession);
+        }
+
+        sessionCache = cookieSession;
+      }
+    });
+  }
+
+  function expandSession() {
+    (0, _sessionCookieStore.withCookieLockAccess)({
+      options: options,
+      process: function process(cookieSession) {
+        return hasSessionInCache() ? synchronizeSession(cookieSession) : undefined;
+      }
+    });
+  }
+  /**
+   * allows two behaviors:
+   * - if the session is active, synchronize the session cache without updating the session cookie
+   * - if the session is not active, clear the session cookie and expire the session cache
+   */
+
+
+  function watchSession() {
+    (0, _sessionCookieStore.withCookieLockAccess)({
+      options: options,
+      process: function process(cookieSession) {
+        return !isActiveSession(cookieSession) ? {} : undefined;
+      },
+      after: synchronizeSession
+    });
+  }
+
+  function synchronizeSession(cookieSession) {
+    if (!isActiveSession(cookieSession)) {
+      cookieSession = {};
+    }
+
+    if (hasSessionInCache()) {
+      if (isSessionInCacheOutdated(cookieSession)) {
+        expireSession();
+      } else {
+        sessionCache = cookieSession;
+      }
+    }
+
+    return cookieSession;
+  }
+
+  function expandOrRenewCookie(cookieSession) {
+    var sessionState = computeSessionState(cookieSession[productKey]);
+    var trackingType = sessionState.trackingType;
+    var isTracked = sessionState.isTracked;
+    cookieSession[productKey] = trackingType;
+
+    if (isTracked && !cookieSession.id) {
+      cookieSession.id = (0, _tools.UUID)();
+      cookieSession.created = String((0, _tools.dateNow)());
+    }
+
+    return isTracked;
+  }
+
+  function hasSessionInCache() {
+    return sessionCache[productKey] !== undefined;
+  }
+
+  function isSessionInCacheOutdated(cookieSession) {
+    return sessionCache.id !== cookieSession.id || sessionCache[productKey] !== cookieSession[productKey];
+  }
+
+  function expireSession() {
+    sessionCache = {};
+    expireObservable.notify();
+  }
+
+  function renewSession(cookieSession) {
+    sessionCache = cookieSession;
+    renewObservable.notify();
+  }
+
+  function retrieveActiveSession() {
+    var session = (0, _sessionCookieStore.retrieveSession)();
+
+    if (isActiveSession(session)) {
+      return session;
+    }
+
+    return {};
+  }
+
+  function isActiveSession(session) {
+    // created and expire can be undefined for versions which was not storing them
+    // these checks could be removed when older versions will not be available/live anymore
+    return (session.created === undefined || (0, _tools.dateNow)() - Number(session.created) < _sessionConstants.SESSION_TIME_OUT_DELAY) && (session.expire === undefined || (0, _tools.dateNow)() < Number(session.expire));
+  }
+
+  return {
+    expandOrRenewSession: (0, _tools.throttle)(expandOrRenewSession, _cookie.COOKIE_ACCESS_DELAY),
+    expandSession: expandSession,
+    getSession: function getSession() {
+      return sessionCache;
+    },
+    renewObservable: renewObservable,
+    expireObservable: expireObservable,
+    stop: function stop() {
+      clearInterval(watchSessionTimeoutId);
+    }
+  };
+}

package/cjs/synthetics/syntheticsWorkerValues.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SYNTHETICS_TEST_ID_COOKIE_NAME = exports.SYNTHETICS_RESULT_ID_COOKIE_NAME = exports.SYNTHETICS_INJECTS_RUM_COOKIE_NAME = void 0;
+exports.getSyntheticsResultId = getSyntheticsResultId;
+exports.getSyntheticsTestId = getSyntheticsTestId;
+exports.willSyntheticsInjectRum = willSyntheticsInjectRum;
+
+var _cookie = require("../browser/cookie");
+
+var SYNTHETICS_TEST_ID_COOKIE_NAME = 'guance-synthetics-public-id';
+exports.SYNTHETICS_TEST_ID_COOKIE_NAME = SYNTHETICS_TEST_ID_COOKIE_NAME;
+var SYNTHETICS_RESULT_ID_COOKIE_NAME = 'guance-synthetics-result-id';
+exports.SYNTHETICS_RESULT_ID_COOKIE_NAME = SYNTHETICS_RESULT_ID_COOKIE_NAME;
+var SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'guance-synthetics-injects-rum';
+exports.SYNTHETICS_INJECTS_RUM_COOKIE_NAME = SYNTHETICS_INJECTS_RUM_COOKIE_NAME;
+
+function willSyntheticsInjectRum() {
+  return Boolean(window._GUANCE_SYNTHETICS_INJECTS_RUM || (0, _cookie.getCookie)(SYNTHETICS_INJECTS_RUM_COOKIE_NAME));
+}
+
+function getSyntheticsTestId() {
+  var value = window._GUANCE_SYNTHETICS_PUBLIC_ID || (0, _cookie.getCookie)(SYNTHETICS_TEST_ID_COOKIE_NAME);
+  return typeof value === 'string' ? value : undefined;
+}
+
+function getSyntheticsResultId() {
+  var value = window._GUANCE_SYNTHETICS_RESULT_ID || (0, _cookie.getCookie)(SYNTHETICS_RESULT_ID_COOKIE_NAME);
+  return typeof value === 'string' ? value : undefined;
+}

package/cjs/synthetics/usr.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startCacheUsrCache = exports.ANONYMOUS_ID_EXPIRATION = exports.ANONYMOUS_ID_COOKIE_NAME = void 0;
+
+var _cookie = require("../browser/cookie");
+
+var _tools = require("../helper/tools");
+
+var ANONYMOUS_ID_COOKIE_NAME = '_dataflulx_usr_id';
+exports.ANONYMOUS_ID_COOKIE_NAME = ANONYMOUS_ID_COOKIE_NAME;
+var ANONYMOUS_ID_EXPIRATION = 60 * 24 * _tools.ONE_HOUR;
+exports.ANONYMOUS_ID_EXPIRATION = ANONYMOUS_ID_EXPIRATION;
+
+var startCacheUsrCache = function startCacheUsrCache(configuration) {
+  var usrCacheId = (0, _cookie.getCookie)(ANONYMOUS_ID_COOKIE_NAME);
+
+  if (!usrCacheId) {
+    usrCacheId = (0, _tools.UUID)();
+    (0, _cookie.setCookie)(ANONYMOUS_ID_COOKIE_NAME, usrCacheId, ANONYMOUS_ID_EXPIRATION, configuration.cookieOptions);
+  }
+
+  return {
+    getUsrId: function getUsrId() {
+      return usrCacheId;
+    }
+  };
+};
+
+exports.startCacheUsrCache = startCacheUsrCache;