@cloudcare/browser-core 2.0.3 → 2.0.5

package/src/browser/runOnReadyState.js

@@ -0,0 +1,16 @@
+import { addEventListener } from './addEventListener'
+import { DOM_EVENT } from '../helper/enums'
+export function runOnReadyState(expectedReadyState, callback) {
+  if (
+    document.readyState === expectedReadyState ||
+    document.readyState === 'complete'
+  ) {
+    callback()
+  } else {
+    var eventName =
+      expectedReadyState === 'complete'
+        ? DOM_EVENT.LOAD
+        : DOM_EVENT.DOM_CONTENT_LOADED
+    addEventListener(window, eventName, callback, { once: true })
+  }
+}

package/src/browser/xhrObservable.js

@@ -1,8 +1,15 @@
 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'
-
+import {
+  shallowClone,
+  elapsed,
+  relativeNow,
+  clocksNow,
+  timeStampNow,
+  UUID
+} from '../helper/tools'
+import { addEventListener } from '../browser/addEventListener'
 var xhrObservable
 var xhrContexts = {}
 var DATA_FLUX_REQUEST_ID_KEY = '_DATAFLUX_REQUEST_UUID'
@@ -14,22 +21,34 @@ export function initXhrObservable() {
 }
 
 function createXhrObservable() {
-  var observable = new Observable(function(){
-    var openInstrumentMethod = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'open', {
-      before: openXhr,
-    })
+  var observable = new Observable(function () {
+    var openInstrumentMethod = instrumentMethodAndCallOriginal(
+      XMLHttpRequest.prototype,
+      'open',
+      {
+        before: openXhr
+      }
+    )
 
-    var sendInstrumentMethod = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'send', {
-      before: function() {
-        sendXhr.call(this, observable)
-      },
-    })
+    var sendInstrumentMethod = instrumentMethodAndCallOriginal(
+      XMLHttpRequest.prototype,
+      'send',
+      {
+        before: function () {
+          sendXhr.call(this, observable)
+        }
+      }
+    )
 
-    var abortInstrumentMethod = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'abort', {
-      before:abortXhr,
-    })
+    var abortInstrumentMethod = instrumentMethodAndCallOriginal(
+      XMLHttpRequest.prototype,
+      'abort',
+      {
+        before: abortXhr
+      }
+    )
 
-    return function() {
+    return function () {
       openInstrumentMethod.stop()
       sendInstrumentMethod.stop()
       abortInstrumentMethod.stop()
@@ -44,7 +63,7 @@ function openXhr(method, url) {
   xhrContexts[requestUUID] = {
     state: 'open',
     method: method,
-    url: normalizeUrl(String(url)),
+    url: normalizeUrl(String(url))
   }
 }
 
@@ -60,34 +79,40 @@ function sendXhr(observable) {
   startContext.isAborted = false
   startContext.xhr = this
   var hasBeenReported = false
-  var onreadyStateChangeInstrumentMethod = instrumentMethodAndCallOriginal(this, 'onreadystatechange', {
-    before: function() {
-      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 stopInstrumentingOnReadyStateChange = instrumentMethodAndCallOriginal(
+    this,
+    'onreadystatechange',
+    {
+      before: function () {
+        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)
+        }
       }
-    },
-  })
+    }
+  ).stop
 
-  var onEnd = function() {
-    this.removeEventListener('loadend', onEnd)
-    onreadyStateChangeInstrumentMethod.stop()
+  var onEnd = function () {
+    unsubscribeLoadEndListener()
+    stopInstrumentingOnReadyStateChange()
     if (hasBeenReported) {
       return
     }
     hasBeenReported = true
     var completeContext = context
     completeContext.state = 'complete'
-    completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow())
+    completeContext.duration = elapsed(
+      startContext.startClocks.timeStamp,
+      timeStampNow()
+    )
     completeContext.status = this.status
     observable.notify(shallowClone(completeContext))
     clearRequestId.call(this)
   }
-  this.addEventListener('loadend', onEnd)
+  var unsubscribeLoadEndListener = addEventListener(this, 'loadend', onEnd).stop
   observable.notify(startContext)
 }
 function clearRequestId() {

package/src/configuration/configuration.js

@@ -4,10 +4,10 @@ import { display } from '../helper/display'
 import {
   assign,
   isPercentage,
-  ONE_KIBI_BYTE,
   ONE_SECOND,
   isNullUndefinedDefaultValue
 } from '../helper/tools'
+import { ONE_KIBI_BYTE } from '../helper/byteUtils'
 import { computeTransportConfiguration } from './transportConfiguration'
 
 export var DefaultPrivacyLevel = {

package/src/console/consoleObservable.js

@@ -1,14 +1,18 @@
 import { computeStackTrace } from '../tracekit'
-import { createHandlingStack, formatErrorMessage, toStackTraceString } from '../helper/errorTools'
+import {
+  createHandlingStack,
+  formatErrorMessage,
+  toStackTraceString
+} from '../helper/errorTools'
 import { mergeObservables, Observable } from '../helper/observable'
-import { find, jsonStringify, map } from '../helper/tools'
+import { find, map } from '../helper/tools'
+import { jsonStringify } from '../helper/serialisation/jsonStringify'
 import { ConsoleApiName } from '../helper/display'
 
-
 var consoleObservablesByApi = {}
 
 export function initConsoleObservable(apis) {
-  var consoleObservables = map(apis, function(api) {
+  var consoleObservables = map(apis, function (api) {
     if (!consoleObservablesByApi[api]) {
       consoleObservablesByApi[api] = createConsoleObservable(api)
     }
@@ -20,15 +24,15 @@ export function initConsoleObservable(apis) {
 
 /* eslint-disable no-console */
 function createConsoleObservable(api) {
-  var observable = new Observable(function(){
+  var observable = new Observable(function () {
     var originalConsoleApi = console[api]
-    console[api] = function() {
+    console[api] = function () {
       var params = [].slice.call(arguments)
       originalConsoleApi.apply(console, arguments)
       var handlingStack = createHandlingStack()
       observable.notify(buildConsoleLog(params, api, handlingStack))
     }
-    return function() {
+    return function () {
       console[api] = originalConsoleApi
     }
   })
@@ -37,20 +41,26 @@ function createConsoleObservable(api) {
 
 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 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
+    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,
+    handlingStack: handlingStack
   }
 }
 

package/src/dataMap.js

@@ -47,6 +47,7 @@ export var dataMap = {
     },
     fields: {
       session_replay_stats: '_dd.replay_stats',
+      session_is_active: 'session.is_active',
       view_error_count: 'view.error.count',
       view_resource_count: 'view.resource.count',
       view_long_task_count: 'view.long_task.count',

package/src/helper/byteUtils.js

@@ -0,0 +1,17 @@
+export var ONE_KIBI_BYTE = 1024
+export var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE
+// eslint-disable-next-line no-control-regex
+var HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/
+
+export function computeBytesCount(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
+}

package/src/helper/contextHistory.js

@@ -1,5 +1,5 @@
 import { relativeNow, ONE_MINUTE, filter, map } from './tools'
-
+import { setInterval, clearInterval } from './timer'
 var END_OF_TIMES = Infinity
 
 export var CLEAR_OLD_CONTEXTS_INTERVAL = ONE_MINUTE

package/src/helper/createEventRateLimiter.js

@@ -1,16 +1,13 @@
 import { ErrorSource } from './errorTools'
 import { clocksNow, ONE_MINUTE } from './tools'
-export function createEventRateLimiter(
-  eventType,
-  limit,
-  onLimitReached
-) {
+import { setTimeout } from './timer'
+export function createEventRateLimiter(eventType, limit, onLimitReached) {
   var eventCount = 0
   var allowNextEvent = false
   return {
-    isLimitReached: function() {
+    isLimitReached: function () {
       if (eventCount === 0) {
-        setTimeout(function(){
+        setTimeout(function () {
           eventCount = 0
         }, ONE_MINUTE)
       }
@@ -23,9 +20,10 @@ export function createEventRateLimiter(
         allowNextEvent = true
         try {
           onLimitReached({
-            message: 'Reached max number of ' + eventType +'s by minute: ' + limit,
+            message:
+              'Reached max number of ' + eventType + 's by minute: ' + limit,
             source: ErrorSource.AGENT,
-            startClocks: clocksNow(),
+            startClocks: clocksNow()
           })
         } finally {
           allowNextEvent = false

package/src/helper/errorTools.js

@@ -1,4 +1,5 @@
-import { each, noop, jsonStringify } from './tools'
+import { each, noop } from './tools'
+import { jsonStringify } from '../helper/serialisation/jsonStringify'
 import { computeStackTrace } from '../tracekit'
 
 export var ErrorSource = {

package/src/helper/instrumentMethod.js

@@ -1,5 +1,5 @@
 import { noop } from './tools'
-import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
+import { setTimeout } from './timer'
 export function instrumentMethod(object, method, instrumentationFactory) {
   var original = object[method]
 
@@ -54,7 +54,6 @@ export function instrumentSetter(object, property, after) {
   }
   // Using the patched `setTimeout` from Zone.js triggers a rendering loop in some Angular
   // component, see issue RUMF-1443
-  var setTimeout = getZoneJsOriginalValue(window, 'setTimeout')
   var instrumentation = function (thisObject, value) {
     // put hooked setter into event loop to avoid of set latency
     setTimeout(function () {

package/src/helper/serialisation/contextManager.js

@@ -0,0 +1,79 @@
+import { computeBytesCount } from '../byteUtils'
+import { deepClone, throttle } from '../tools'
+import { jsonStringify } from './jsonStringify'
+import { warnIfCustomerDataLimitReached } from './heavyCustomerDataWarning'
+
+export var BYTES_COMPUTATION_THROTTLING_DELAY = 200
+
+export function createContextManager(customerDataType, computeBytesCountImpl) {
+  if (typeof computeBytesCountImpl === 'undefined') {
+    computeBytesCountImpl = computeBytesCount
+  }
+  var context = {}
+  var bytesCountCache
+  var alreadyWarned = false
+
+  // 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
+      )
+    }
+  }, BYTES_COMPUTATION_THROTTLING_DELAY).throttled
+
+  return {
+    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)
+    },
+
+    /** @deprecated renamed to removeContextProperty */
+    remove: function (key) {
+      delete context[key]
+      computeBytesCountThrottled(context)
+    },
+
+    /** @deprecated use setContext instead */
+    set: function (newContext) {
+      context = newContext
+      computeBytesCountThrottled(context)
+    },
+
+    getContext: function () {
+      return deepClone(context)
+    },
+
+    setContext: function (newContext) {
+      context = deepClone(newContext)
+      computeBytesCountThrottled(context)
+    },
+
+    setContextProperty: function (key, property) {
+      context[key] = deepClone(property)
+      computeBytesCountThrottled(context)
+    },
+
+    removeContextProperty: function (key) {
+      delete context[key]
+      computeBytesCountThrottled(context)
+    },
+
+    clearContext: function () {
+      context = {}
+      bytesCountCache = 0
+    }
+  }
+}

package/src/helper/serialisation/heavyCustomerDataWarning.js

@@ -0,0 +1,28 @@
+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
+}

package/src/helper/serialisation/jsonStringify.js

@@ -0,0 +1,47 @@
+import { noop } from '../tools'
+
+/**
+ * Custom implementation of JSON.stringify that ignores some toJSON methods. We need to do that
+ * because some sites badly override toJSON on certain objects. Removing all toJSON methods from
+ * nested values would be too costly, so we just detach them from the root value, and native classes
+ * used to build JSON values (Array and Object).
+ *
+ * Note: this still assumes that JSON.stringify is correct.
+ */
+export function jsonStringify(value, replacer, space) {
+  if (typeof value !== 'object' || value === null) {
+    return JSON.stringify(value)
+  }
+
+  // Note: The order matter here. We need to detach toJSON methods on parent classes before their
+  // subclasses.
+  var restoreObjectPrototypeToJson = detachToJsonMethod(Object.prototype)
+  var restoreArrayPrototypeToJson = detachToJsonMethod(Array.prototype)
+  var restoreValuePrototypeToJson = detachToJsonMethod(
+    Object.getPrototypeOf(value)
+  )
+  var restoreValueToJson = detachToJsonMethod(value)
+
+  try {
+    return JSON.stringify(value, replacer, space)
+  } catch {
+    return '<error: unable to serialize object>'
+  } finally {
+    restoreObjectPrototypeToJson()
+    restoreArrayPrototypeToJson()
+    restoreValuePrototypeToJson()
+    restoreValueToJson()
+  }
+}
+
+export function detachToJsonMethod(value) {
+  const object = value
+  const objectToJson = object.toJSON
+  if (objectToJson) {
+    delete object.toJSON
+    return () => {
+      object.toJSON = objectToJson
+    }
+  }
+  return noop
+}

package/src/helper/serialisation/rowData.js

@@ -0,0 +1,41 @@
+import { jsonStringify } from './jsonStringify'
+import { isString } from '../tools'
+export function escapeRowData(str) {
+  if (typeof str === 'object' && str) {
+    str = jsonStringify(str)
+  } else if (!isString(str)) {
+    return str
+  }
+  var reg = /[\s=,"]/g
+  return String(str).replace(reg, function (word) {
+    return '\\' + word
+  })
+}
+
+export function escapeJsonValue(value) {
+  if (isString(value)) {
+    return value
+  } else {
+    return jsonStringify(value)
+  }
+}
+
+export function escapeFieldValueStr(str) {
+  return (
+    '"' +
+    str
+      .replace(/\\/g, '\\\\')
+      .replace(/[\\]*"/g, '"')
+      .replace(/"/g, '\\"') +
+    '"'
+  )
+}
+export function escapeRowField(value) {
+  if (typeof value === 'object' && value) {
+    return escapeFieldValueStr(jsonStringify(value))
+  } else if (isString(value)) {
+    return escapeFieldValueStr(value)
+  } else {
+    return value
+  }
+}

package/src/helper/timer.js

@@ -0,0 +1,21 @@
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
+import { getGlobalObject } from '../init'
+
+export function setTimeout(callback, delay) {
+  return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(
+    callback,
+    delay
+  )
+}
+
+export function clearTimeout(timeoutId) {
+  getZoneJsOriginalValue(getGlobalObject(), 'clearTimeout')(timeoutId)
+}
+
+export function setInterval(callback, delay) {
+  return getZoneJsOriginalValue(window, 'setInterval')(callback, delay)
+}
+
+export function clearInterval(timeoutId) {
+  getZoneJsOriginalValue(window, 'clearInterval')(timeoutId)
+}