@cloudcare/browser-core 2.0.4 → 2.0.6

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)
+}

package/src/helper/tools.js

@@ -1,6 +1,5 @@
 import { DOM_EVENT } from './enums'
-import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
-
+import { setTimeout, clearTimeout } from './timer'
 var ArrayProto = Array.prototype
 var FuncProto = Function.prototype
 var ObjProto = Object.prototype
@@ -735,109 +734,7 @@ export function elementMatches(element, selector) {
   }
   return false
 }
-export var addEvent = function () {
-  function fixEvent(event) {
-    if (event) {
-      event.preventDefault = fixEvent.preventDefault
-      event.stopPropagation = fixEvent.stopPropagation
-      event._getPath = fixEvent._getPath
-    }
-    return event
-  }
-  fixEvent._getPath = function () {
-    var ev = this
-    var polyfill = function () {
-      try {
-        var element = ev.target
-        var pathArr = [element]
-        if (element === null || element.parentElement === null) {
-          return []
-        }
-        while (element.parentElement !== null) {
-          element = element.parentElement
-          pathArr.unshift(element)
-        }
-        return pathArr
-      } catch (error) {
-        return []
-      }
-    }
-    return (
-      this.path || (this.composedPath() && this.composedPath()) || polyfill()
-    )
-  }
-  fixEvent.preventDefault = function () {
-    this.returnValue = false
-  }
-  fixEvent.stopPropagation = function () {
-    this.cancelBubble = true
-  }
-  var register_event = function (element, type, handle) {
-    if (element && element.addEventListener) {
-      element.addEventListener(
-        type,
-        function (e) {
-          e._getPath = fixEvent._getPath
-          handler.call(this, e)
-        },
-        false
-      )
-    } else {
-      var ontype = 'on' + type
-      var old_handler = element[ontype]
-      element[ontype] = makeHandler(element, handler, old_handler)
-    }
-  }
-  function makeHandler(element, new_handler, old_handlers) {
-    var handler = function (event) {
-      event = event || fixEvent(window.event)
-      if (!event) {
-        return undefined
-      }
-      event.target = event.srcElement
 
-      var ret = true
-      var old_result, new_result
-      if (typeof old_handlers === 'function') {
-        old_result = old_handlers(event)
-      }
-      new_result = new_handler.call(element, event)
-      if (false === old_result || false === new_result) {
-        ret = false
-      }
-      return ret
-    }
-    return handler
-  }
-
-  register_event.apply(null, arguments)
-}
-export var addHashEvent = function (callback) {
-  var hashEvent = 'pushState' in window.history ? 'popstate' : 'hashchange'
-  addEvent(window, hashEvent, callback)
-}
-export var addSinglePageEvent = function (callback) {
-  var current_url = location.href
-  var historyPushState = window.history.pushState
-  var historyReplaceState = window.history.replaceState
-
-  window.history.pushState = function () {
-    historyPushState.apply(window.history, arguments)
-    callback(current_url)
-    current_url = location.href
-  }
-  window.history.replaceState = function () {
-    historyReplaceState.apply(window.history, arguments)
-    callback(current_url)
-    current_url = location.href
-  }
-
-  var singlePageEvent = historyPushState ? 'popstate' : 'hashchange'
-  addEvent(window, singlePageEvent, function () {
-    callback(current_url)
-    current_url = location.href
-  })
-}
 export var cookie = {
   get: function (name) {
     var nameEQ = name + '='
@@ -1493,51 +1390,6 @@ export var getReferrer = function () {
 export var typeDecide = function (o, type) {
   return toString.call(o) === '[object ' + type + ']'
 }
-export function jsonStringify(value, replacer, space) {
-  if (value === null || value === undefined) {
-    return JSON.stringify(value)
-  }
-  var originalToJSON = [false, undefined]
-  if (hasToJSON(value)) {
-    // We need to add a flag and not rely on the truthiness of value.toJSON
-    // because it can be set but undefined and that's actually significant.
-    originalToJSON = [true, value.toJSON]
-    delete value.toJSON
-  }
-
-  var originalProtoToJSON = [false, undefined]
-  var prototype
-  if (typeof value === 'object') {
-    prototype = Object.getPrototypeOf(value)
-    if (hasToJSON(prototype)) {
-      originalProtoToJSON = [true, prototype.toJSON]
-      delete prototype.toJSON
-    }
-  }
-
-  var result
-  try {
-    result = JSON.stringify(value, undefined, space)
-  } catch (e) {
-    result = '<error: unable to serialize object>'
-  } finally {
-    if (originalToJSON[0]) {
-      value.toJSON = originalToJSON[1]
-    }
-    if (originalProtoToJSON[0]) {
-      prototype.toJSON = originalProtoToJSON[1]
-    }
-  }
-  return result
-}
-
-function hasToJSON(value) {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    value.hasOwnProperty('toJSON')
-  )
-}
 
 export function noop() {}
 
@@ -1546,8 +1398,7 @@ export var ONE_MINUTE = 60 * ONE_SECOND
 export var ONE_HOUR = 60 * ONE_MINUTE
 export var ONE_DAY = 24 * ONE_HOUR
 export var ONE_YEAR = 365 * ONE_DAY
-export var ONE_KIBI_BYTE = 1024
-export var ONE_MEBI_BYTE = 1024 * ONE_KIBI_BYTE
+
 /**
  * Return true if the draw is successful
  * @param threshold between 0 and 100
@@ -1679,108 +1530,11 @@ export function safeTruncate(candidate, length) {
   return candidate.slice(0, length)
 }
 
-export function addEventListener(eventTarget, event, listener, options) {
-  return addEventListeners(eventTarget, [event], listener, options)
-}
-
-/**
- * Add event listeners to an event emitter object (Window, Element, mock object...).  This provides
- * a few conveniences compared to using `element.addEventListener` directly:
- *
- * * supports IE11 by:
- *   * using an option object only if needed
- *   * emulating the `once` option
- *
- * * wraps the listener with a `monitor` function
- *
- * * returns a `stop` function to remove the listener
- *
- * * with `once: true`, the listener will be called at most once, even if different events are
- *   listened
- */
-
-export function addEventListeners(eventTarget, events, listener, options) {
-  var wrappedListener =
-    options && options.once
-      ? function (event) {
-          stop()
-          listener(event)
-        }
-      : listener
-
-  options =
-    options && options.passive
-      ? { capture: options.capture, passive: options.passive }
-      : options && options.capture
-  var add = getZoneJsOriginalValue(eventTarget, 'addEventListener')
-
-  each(events, function (event) {
-    add.call(eventTarget, event, wrappedListener, options)
-  })
-  var stop = function () {
-    var remove = getZoneJsOriginalValue(eventTarget, 'removeEventListener')
-    each(events, function (event) {
-      remove.call(eventTarget, event, wrappedListener, options)
-    })
-  }
-  return {
-    stop: stop
-  }
-}
-
 export function includes(candidate, search) {
   // tslint:disable-next-line: no-unsafe-any
   return candidate.indexOf(search) !== -1
 }
 
-export function createContextManager() {
-  var context = {}
-
-  return {
-    get: function () {
-      return context
-    },
-
-    add: function (key, value) {
-      if (isString(key)) {
-        context[key] = value
-      } else {
-        console.error('key 需要传递字符串类型')
-      }
-    },
-
-    remove: function (key) {
-      delete context[key]
-    },
-
-    set: function (newContext) {
-      if (isObject(newContext)) {
-        context = newContext
-      } else {
-        console.error('content 需要传递对象类型数据')
-      }
-    },
-    getContext: function () {
-      return deepClone(context)
-    },
-
-    setContext: function (newContext) {
-      context = deepClone(newContext)
-    },
-
-    setContextProperty: function (key, property) {
-      context[key] = deepClone(property)
-    },
-
-    removeContextProperty: function (key) {
-      delete context[key]
-    },
-
-    clearContext: function () {
-      context = {}
-    }
-  }
-}
 export function find(array, predicate) {
   for (var i = 0; i < array.length; i += 1) {
     var item = array[i]
@@ -1871,44 +1625,6 @@ export function toSnakeCase(word) {
     .replace(/-/g, '_')
 }
 
-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
-  }
-}
 export function isNullUndefinedDefaultValue(data, defaultValue) {
   if (data !== null && data !== void 0) {
     return data
@@ -1917,21 +1633,6 @@ export function isNullUndefinedDefaultValue(data, defaultValue) {
   }
 }
 
-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 })
-  }
-}
-
 export function requestIdleCallback(callback, opts) {
   // Use 'requestIdleCallback' when available: it will throttle the mutation processing if the
   // browser is busy rendering frames (ex: when frames are below 60fps). When not available, the

package/src/index.js

@@ -4,6 +4,7 @@ export * from './helper/deviceInfo'
 export * from './helper/enums'
 export * from './helper/instrumentMethod'
 export * from './helper/errorTools'
+export * from './helper/byteUtils'
 export * from './error/trackRuntimeError'
 export * from './console/consoleObservable'
 export * from './report/reportObservable'
@@ -17,6 +18,7 @@ export * from './helper/tools'
 export * from './helper/urlPolyfill'
 export * from './helper/mobileUtil'
 export * from './helper/getZoneJsOriginalValue'
+export * from './helper/timer'
 export * from './helper/readBytesFromStream'
 export * from './tracekit'
 export * from './configuration/configuration'
@@ -26,6 +28,9 @@ export * from './browser/fetchObservable'
 export * from './browser/xhrObservable'
 export * from './browser/pageExitObservable'
 export * from './browser/htmlDomUtils'
+export * from './browser/addEventListener'
+export * from './browser/runOnReadyState'
+
 export * from './dataMap'
 export * from './init'
 export * from './session/sessionManagement'
@@ -34,3 +39,9 @@ export * from './session/sessionCookieStore'
 export * from './session/sessionStore'
 export * from './transport'
 export * from './synthetics/syntheticsWorkerValues'
+
+export * from './helper/serialisation/contextManager'
+export * from './helper/serialisation/heavyCustomerDataWarning'
+export * from './helper/serialisation/jsonStringify'
+export * from './helper/serialisation/rowData'
+export * from './user'

package/src/init.js

@@ -16,12 +16,12 @@ export function makePublicApi(stub) {
 
   // Add an "hidden" property to set debug mode. We define it that way to hide it
   // as much as possible but of course it's not a real protection.
-  Object.defineProperty(publicApi, '_setDebug', {
-    get: function () {
-      return setDebugMode
-    },
-    enumerable: false
-  })
+  //   Object.defineProperty(publicApi, '_setDebug', {
+  //     get: function () {
+  //       return setDebugMode
+  //     },
+  //     enumerable: false
+  //   })
 
   return publicApi
 }