@cloudcare/browser-core 3.2.11 → 3.2.15

package/src/helper/serialisation/contextManager.js

@@ -1,94 +1,71 @@
-import { computeBytesCount } from '../byteUtils'
-import { deepClone, throttle, getType } from '../tools'
+import { deepClone, getType } from '../tools'
 import { sanitize } from '../sanitize'
-import { jsonStringify } from './jsonStringify'
 import { Observable } from '../observable'
-import { warnIfCustomerDataLimitReached } from './heavyCustomerDataWarning'
+import { display } from '../display'
 
-export var BYTES_COMPUTATION_THROTTLING_DELAY = 200
+function ensureProperties(context, propertiesConfig, name) {
+  const newContext = { ...context }
 
-export function createContextManager(customerDataType, computeBytesCountImpl) {
-  if (typeof computeBytesCountImpl === 'undefined') {
-    computeBytesCountImpl = computeBytesCount
-  }
-  var context = {}
-  var bytesCountCache
-  var alreadyWarned = false
-  var changeObservable = new Observable()
-  // Throttle the bytes computation to minimize the impact on performance.
-  // Especially useful if the user call context APIs synchronously multiple times in a row
-  var computeBytesCountThrottled = throttle(function (context) {
-    bytesCountCache = computeBytesCountImpl(jsonStringify(context))
-    if (!alreadyWarned) {
-      alreadyWarned = warnIfCustomerDataLimitReached(
-        bytesCountCache,
-        customerDataType
-      )
+  for (const [key, { required, type }] of Object.entries(propertiesConfig)) {
+    /**
+     * Ensure specified properties are strings as defined here:
+     */
+    if (type === 'string' && key in newContext) {
+      newContext[key] = String(newContext[key])
     }
-  }, BYTES_COMPUTATION_THROTTLING_DELAY).throttled
-
-  var contextManager = {
-    getBytesCount: function () {
-      return bytesCountCache
-    },
-    /** @deprecated use getContext instead */
-    get: function () {
-      return context
-    },
 
-    /** @deprecated use setContextProperty instead */
-    add: function (key, value) {
-      context[key] = value
-      computeBytesCountThrottled(context)
-      changeObservable.notify()
-    },
+    if (required && !(key in context)) {
+      display.warn(
+        `The property ${key} of ${name} context is required; context will not be sent to the intake.`
+      )
+    }
+  }
 
-    /** @deprecated renamed to removeContextProperty */
-    remove: function (key) {
-      delete context[key]
-      computeBytesCountThrottled(context)
-      changeObservable.notify()
-    },
+  return newContext
+}
 
-    /** @deprecated use setContext instead */
-    set: function (newContext) {
-      context = newContext
-      computeBytesCountThrottled(context)
-      changeObservable.notify()
-    },
+export function createContextManager(
+  name = '',
+  { customerDataTracker, propertiesConfig = {} } = {}
+) {
+  let context = {}
+  const changeObservable = new Observable()
 
-    getContext: function () {
-      return deepClone(context)
-    },
+  const contextManager = {
+    getContext: () => deepClone(context),
 
-    setContext: function (newContext) {
+    setContext: (newContext) => {
       if (getType(newContext) === 'object') {
-        context = sanitize(newContext)
-        computeBytesCountThrottled(context)
+        context = sanitize(ensureProperties(newContext, propertiesConfig, name))
+        customerDataTracker?.updateCustomerData(context)
       } else {
         contextManager.clearContext()
       }
       changeObservable.notify()
     },
 
-    setContextProperty: function (key, property) {
-      context[key] = deepClone(property)
-      computeBytesCountThrottled(context)
+    setContextProperty: (key, property) => {
+      context[key] = sanitize(
+        ensureProperties({ [key]: property }, propertiesConfig, name)[key]
+      )
+      customerDataTracker?.updateCustomerData(context)
       changeObservable.notify()
     },
 
-    removeContextProperty: function (key) {
+    removeContextProperty: (key) => {
       delete context[key]
-      computeBytesCountThrottled(context)
+      customerDataTracker?.updateCustomerData(context)
+      ensureProperties(context, propertiesConfig, name)
       changeObservable.notify()
     },
 
-    clearContext: function () {
+    clearContext: () => {
       context = {}
-      bytesCountCache = 0
+      customerDataTracker?.resetCustomerData()
       changeObservable.notify()
     },
-    changeObservable: changeObservable
+
+    changeObservable
   }
   return contextManager
 }

package/src/helper/serialisation/customerDataTracker.js

@@ -0,0 +1,139 @@
+import { ONE_KIBI_BYTE, computeBytesCount } from '../byteUtils'
+import { throttle, isEmptyObject } from '../tools'
+import { jsonStringify } from './jsonStringify'
+import { display } from '../display'
+
+// RUM and logs batch bytes limit is 16KB
+// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
+// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
+export const CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE
+
+// We observed that the compression ratio is around 8 in general, but we also want to keep a margin
+// because some data might not be compressed (ex: last view update on page exit). We chose 16KiB
+// because it is also the limit of the 'batchBytesCount' that we use for RUM and Logs data, but this
+// is a bit arbitrary.
+export const CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT = 16 * ONE_KIBI_BYTE
+
+export const BYTES_COMPUTATION_THROTTLING_DELAY = 200
+
+export const CustomerDataCompressionStatus = {
+  Unknown: 0,
+  Enabled: 1,
+  Disabled: 2
+}
+
+export function createCustomerDataTrackerManager(
+  compressionStatus = CustomerDataCompressionStatus.Disabled
+) {
+  const customerDataTrackers = new Map()
+
+  let alreadyWarned = false
+  function checkCustomerDataLimit(initialBytesCount = 0) {
+    if (
+      alreadyWarned ||
+      compressionStatus === CustomerDataCompressionStatus.Unknown
+    ) {
+      return
+    }
+
+    const bytesCountLimit =
+      compressionStatus === CustomerDataCompressionStatus.Disabled
+        ? CUSTOMER_DATA_BYTES_LIMIT
+        : CUSTOMER_COMPRESSED_DATA_BYTES_LIMIT
+
+    let bytesCount = initialBytesCount
+    customerDataTrackers.forEach((tracker) => {
+      bytesCount += tracker.getBytesCount()
+    })
+
+    if (bytesCount > bytesCountLimit) {
+      displayCustomerDataLimitReachedWarning(bytesCountLimit)
+      alreadyWarned = true
+    }
+  }
+
+  return {
+    /**
+     * Creates a detached tracker. The manager will not store a reference to that tracker, and the
+     * bytes count will be counted independently from other detached trackers.
+     *
+     * This is particularly useful when we don't know when the tracker will be unused, so we don't
+     * leak memory (ex: when used in Logger instances).
+     */
+    createDetachedTracker: () => {
+      const tracker = createCustomerDataTracker(() =>
+        checkCustomerDataLimit(tracker.getBytesCount())
+      )
+      return tracker
+    },
+
+    /**
+     * Creates a tracker if it doesn't exist, and returns it.
+     */
+    getOrCreateTracker: (type) => {
+      if (!customerDataTrackers.has(type)) {
+        customerDataTrackers.set(
+          type,
+          createCustomerDataTracker(checkCustomerDataLimit)
+        )
+      }
+      return customerDataTrackers.get(type)
+    },
+
+    setCompressionStatus: (newCompressionStatus) => {
+      if (compressionStatus === CustomerDataCompressionStatus.Unknown) {
+        compressionStatus = newCompressionStatus
+        checkCustomerDataLimit()
+      }
+    },
+
+    getCompressionStatus: () => compressionStatus,
+
+    stop: () => {
+      customerDataTrackers.forEach((tracker) => tracker.stop())
+      customerDataTrackers.clear()
+    }
+  }
+}
+
+export function createCustomerDataTracker(checkCustomerDataLimit) {
+  let bytesCountCache = 0
+
+  // Throttle the bytes computation to minimize the impact on performance.
+  // Especially useful if the user call context APIs synchronously multiple times in a row
+  const {
+    throttled: computeBytesCountThrottled,
+    cancel: cancelComputeBytesCount
+  } = throttle((context) => {
+    bytesCountCache = computeBytesCount(jsonStringify(context))
+    checkCustomerDataLimit()
+  }, BYTES_COMPUTATION_THROTTLING_DELAY)
+
+  const resetBytesCount = () => {
+    cancelComputeBytesCount()
+    bytesCountCache = 0
+  }
+
+  return {
+    updateCustomerData: (context) => {
+      if (isEmptyObject(context)) {
+        resetBytesCount()
+      } else {
+        computeBytesCountThrottled(context)
+      }
+    },
+    resetCustomerData: resetBytesCount,
+    getBytesCount: () => bytesCountCache,
+    stop: () => {
+      cancelComputeBytesCount()
+    }
+  }
+}
+
+function displayCustomerDataLimitReachedWarning(bytesCountLimit) {
+  display.warn(
+    `Customer data exceeds the recommended ${
+      bytesCountLimit / ONE_KIBI_BYTE
+    }KiB threshold.`
+  )
+}

package/src/index.js

@@ -51,10 +51,11 @@ export * from './transport'
 export * from './synthetics/syntheticsWorkerValues'
 
 export * from './helper/serialisation/contextManager'
-export * from './helper/serialisation/heavyCustomerDataWarning'
+export * from './helper/serialisation/const'
 export * from './helper/serialisation/jsonStringify'
 export * from './helper/serialisation/rowData'
 export * from './helper/serialisation/storedContextManager'
+export * from './helper/serialisation/customerDataTracker'
 export * from './helper/encoder'
 export * from './user'
 export * from './helper/polyfills'

package/cjs/helper/serialisation/heavyCustomerDataWarning.js

@@ -1,29 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.CustomerDataType = exports.CUSTOMER_DATA_BYTES_LIMIT = void 0;
-exports.warnIfCustomerDataLimitReached = warnIfCustomerDataLimitReached;
-var _byteUtils = require("../byteUtils");
-var _display = require("../display");
-// RUM and logs batch bytes limit is 16KB
-// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
-// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
-var CUSTOMER_DATA_BYTES_LIMIT = 3 * _byteUtils.ONE_KIBI_BYTE;
-exports.CUSTOMER_DATA_BYTES_LIMIT = CUSTOMER_DATA_BYTES_LIMIT;
-var CustomerDataType = {
-  FeatureFlag: 'feature flag evaluation',
-  User: 'user',
-  GlobalContext: 'global context',
-  LoggerContext: 'logger context'
-};
-exports.CustomerDataType = CustomerDataType;
-function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {
-  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {
-    _display.display.warn('The ' + customerDataType + 'data is over ' + CUSTOMER_DATA_BYTES_LIMIT / _byteUtils.ONE_KIBI_BYTE + " KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth.");
-    return true;
-  }
-  return false;
-}
-//# sourceMappingURL=heavyCustomerDataWarning.js.map

package/cjs/helper/serialisation/heavyCustomerDataWarning.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"heavyCustomerDataWarning.js","names":["_byteUtils","require","_display","CUSTOMER_DATA_BYTES_LIMIT","ONE_KIBI_BYTE","exports","CustomerDataType","FeatureFlag","User","GlobalContext","LoggerContext","warnIfCustomerDataLimitReached","bytesCount","customerDataType","display","warn"],"sources":["../../../src/helper/serialisation/heavyCustomerDataWarning.js"],"sourcesContent":["import { ONE_KIBI_BYTE } from '../byteUtils'\nimport { display } from '../display'\n\n// RUM and logs batch bytes limit is 16KB\n// ensure that we leave room for other event attributes and maintain a decent amount of event per batch\n// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB\nexport var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE\n\nexport var CustomerDataType = {\n  FeatureFlag: 'feature flag evaluation',\n  User: 'user',\n  GlobalContext: 'global context',\n  LoggerContext: 'logger context'\n}\n\nexport function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {\n  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {\n    display.warn(\n      'The ' +\n        customerDataType +\n        'data is over ' +\n        CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE +\n        \" KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth.\"\n    )\n    return true\n  }\n  return false\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,QAAA,GAAAD,OAAA;AAEA;AACA;AACA;AACO,IAAIE,yBAAyB,GAAG,CAAC,GAAGC,wBAAa;AAAAC,OAAA,CAAAF,yBAAA,GAAAA,yBAAA;AAEjD,IAAIG,gBAAgB,GAAG;EAC5BC,WAAW,EAAE,yBAAyB;EACtCC,IAAI,EAAE,MAAM;EACZC,aAAa,EAAE,gBAAgB;EAC/BC,aAAa,EAAE;AACjB,CAAC;AAAAL,OAAA,CAAAC,gBAAA,GAAAA,gBAAA;AAEM,SAASK,8BAA8BA,CAACC,UAAU,EAAEC,gBAAgB,EAAE;EAC3E,IAAID,UAAU,GAAGT,yBAAyB,EAAE;IAC1CW,gBAAO,CAACC,IAAI,CACV,MAAM,GACJF,gBAAgB,GAChB,eAAe,GACfV,yBAAyB,GAAGC,wBAAa,GACzC,8FACJ,CAAC;IACD,OAAO,IAAI;EACb;EACA,OAAO,KAAK;AACd","ignoreList":[]}

package/esm/helper/serialisation/heavyCustomerDataWarning.js

@@ -1,21 +0,0 @@
-import { ONE_KIBI_BYTE } from '../byteUtils';
-import { display } from '../display';
-
-// RUM and logs batch bytes limit is 16KB
-// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
-// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
-export var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE;
-export var CustomerDataType = {
-  FeatureFlag: 'feature flag evaluation',
-  User: 'user',
-  GlobalContext: 'global context',
-  LoggerContext: 'logger context'
-};
-export function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {
-  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {
-    display.warn('The ' + customerDataType + 'data is over ' + CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE + " KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth.");
-    return true;
-  }
-  return false;
-}
-//# sourceMappingURL=heavyCustomerDataWarning.js.map

package/esm/helper/serialisation/heavyCustomerDataWarning.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"heavyCustomerDataWarning.js","names":["ONE_KIBI_BYTE","display","CUSTOMER_DATA_BYTES_LIMIT","CustomerDataType","FeatureFlag","User","GlobalContext","LoggerContext","warnIfCustomerDataLimitReached","bytesCount","customerDataType","warn"],"sources":["../../../src/helper/serialisation/heavyCustomerDataWarning.js"],"sourcesContent":["import { ONE_KIBI_BYTE } from '../byteUtils'\nimport { display } from '../display'\n\n// RUM and logs batch bytes limit is 16KB\n// ensure that we leave room for other event attributes and maintain a decent amount of event per batch\n// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB\nexport var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE\n\nexport var CustomerDataType = {\n  FeatureFlag: 'feature flag evaluation',\n  User: 'user',\n  GlobalContext: 'global context',\n  LoggerContext: 'logger context'\n}\n\nexport function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {\n  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {\n    display.warn(\n      'The ' +\n        customerDataType +\n        'data is over ' +\n        CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE +\n        \" KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth.\"\n    )\n    return true\n  }\n  return false\n}\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,cAAc;AAC5C,SAASC,OAAO,QAAQ,YAAY;;AAEpC;AACA;AACA;AACA,OAAO,IAAIC,yBAAyB,GAAG,CAAC,GAAGF,aAAa;AAExD,OAAO,IAAIG,gBAAgB,GAAG;EAC5BC,WAAW,EAAE,yBAAyB;EACtCC,IAAI,EAAE,MAAM;EACZC,aAAa,EAAE,gBAAgB;EAC/BC,aAAa,EAAE;AACjB,CAAC;AAED,OAAO,SAASC,8BAA8BA,CAACC,UAAU,EAAEC,gBAAgB,EAAE;EAC3E,IAAID,UAAU,GAAGP,yBAAyB,EAAE;IAC1CD,OAAO,CAACU,IAAI,CACV,MAAM,GACJD,gBAAgB,GAChB,eAAe,GACfR,yBAAyB,GAAGF,aAAa,GACzC,8FACJ,CAAC;IACD,OAAO,IAAI;EACb;EACA,OAAO,KAAK;AACd","ignoreList":[]}

package/src/helper/serialisation/heavyCustomerDataWarning.js

@@ -1,28 +0,0 @@
-import { ONE_KIBI_BYTE } from '../byteUtils'
-import { display } from '../display'
-
-// RUM and logs batch bytes limit is 16KB
-// ensure that we leave room for other event attributes and maintain a decent amount of event per batch
-// (3KB (customer data) + 1KB (other attributes)) * 4 (events per batch) = 16KB
-export var CUSTOMER_DATA_BYTES_LIMIT = 3 * ONE_KIBI_BYTE
-
-export var CustomerDataType = {
-  FeatureFlag: 'feature flag evaluation',
-  User: 'user',
-  GlobalContext: 'global context',
-  LoggerContext: 'logger context'
-}
-
-export function warnIfCustomerDataLimitReached(bytesCount, customerDataType) {
-  if (bytesCount > CUSTOMER_DATA_BYTES_LIMIT) {
-    display.warn(
-      'The ' +
-        customerDataType +
-        'data is over ' +
-        CUSTOMER_DATA_BYTES_LIMIT / ONE_KIBI_BYTE +
-        " KiB. On low connectivity, the SDK has the potential to exhaust the user's upload bandwidth."
-    )
-    return true
-  }
-  return false
-}