@cloudcare/browser-core 1.1.2 → 1.2.0

package/src/tracekit/tracekit.js

@@ -0,0 +1,100 @@
+import { instrumentMethodAndCallOriginal } from '../helper/instrumentMethod'
+import { computeStackTrace } from './computeStackTrace'
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types
+var ERROR_TYPES_RE =
+  /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/
+
+/**
+ * Cross-browser collection of unhandled errors
+ *
+ * Supports:
+ * - Firefox: full stack trace with line numbers, plus column number
+ * on top frame; column number is not guaranteed
+ * - Opera: full stack trace with line and column numbers
+ * - Chrome: full stack trace with line and column numbers
+ * - Safari: line and column number for the top frame only; some frames
+ * may be missing, and column number is not guaranteed
+ * - IE: line and column number for the top frame only; some frames
+ * may be missing, and column number is not guaranteed
+ *
+ * In theory, TraceKit should work on all of the following versions:
+ * - IE5.5+ (only 8.0 tested)
+ * - Firefox 0.9+ (only 3.5+ tested)
+ * - Opera 7+ (only 10.50 tested; versions 9 and earlier may require
+ * Exceptions Have Stacktrace to be enabled in opera:config)
+ * - Safari 3+ (only 4+ tested)
+ * - Chrome 1+ (only 5+ tested)
+ * - Konqueror 3.5+ (untested)
+ *
+ * Tries to catch all unhandled errors and report them to the
+ * callback.
+ *
+ * Callbacks receive a StackTrace object as described in the
+ * computeStackTrace docs.
+ *
+ * @memberof TraceKit
+ * @namespace
+ */
+
+export function startUnhandledErrorCollection(callback) {
+  var _instrumentOnError = instrumentOnError(callback)
+  var _instrumentUnhandledRejection = instrumentUnhandledRejection(callback)
+  return {
+    stop: function() {
+      _instrumentOnError.stop()
+      _instrumentUnhandledRejection.stop()
+    },
+  }
+}
+
+/**
+ * Install a global onerror handler
+ */
+function instrumentOnError(callback) {
+  return instrumentMethodAndCallOriginal(window, 'onerror', {
+    before: function(message, url, lineNo, columnNo, errorObj) {
+      var stack
+      if (errorObj) {
+        stack = computeStackTrace(errorObj)
+        callback(stack, errorObj)
+      } else {
+        var location = {
+          url: url,
+          column: columnNo,
+          line: lineNo,
+        }
+        var name
+        var msg = message
+        if ({}.toString.call(message) === '[object String]') {
+          var groups = ERROR_TYPES_RE.exec(msg)
+          if (groups) {
+            name = groups[1]
+            msg = groups[2]
+          }
+        }
+
+        stack = {
+          name: name,
+          message: typeof msg === 'string' ? msg : undefined,
+          stack: [location],
+        }
+
+        callback(stack, message)
+      }
+    },
+  })
+}
+
+/**
+ * Install a global onunhandledrejection handler
+ */
+function instrumentUnhandledRejection(callback) {
+  return instrumentMethodAndCallOriginal(window, 'onunhandledrejection', {
+    before: function(e) {
+      var reason = e.reason || 'Empty reason'
+      var stack = computeStackTrace(reason)
+      callback(stack, reason)
+    },
+  })
+}

package/src/transport/batch.js

@@ -0,0 +1,289 @@
+import { display } from '../helper/display'
+import { 
+  addEventListener, 
+  noop, 
+  values, 
+  findByPath,
+  escapeRowData,
+  each,
+  isNumber,
+  isArray,
+  extend,
+  isString,
+  toServerDuration,
+  isBoolean,
+  isEmptyObject,
+  isObject,
+  escapeJsonValue,
+  escapeRowField 
+} from '../helper/tools'
+import { commonTags, dataMap } from '../dataMap'
+import { DOM_EVENT, RumEventType } from '../helper/enums'
+// https://en.wikipedia.org/wiki/UTF-8
+// eslint-disable-next-line no-control-regex
+var HAS_MULTI_BYTES_CHARACTERS = /[^\u0000-\u007F]/
+var CUSTOM_KEYS = 'custom_keys'
+export var processedMessageByDataMap = function (message) {
+  if (!message || !message.type) return {
+    rowStr: '',
+    rowData: undefined
+  }
+  
+  var rowData = { tags: {}, fields: {} }
+  var hasFileds = false
+  var rowStr = ''
+  each(dataMap, function (value, key) {
+    if (value.type === message.type) {
+      rowStr += key + ','
+      rowData.measurement = key
+      var tagsStr = []
+      var tags = extend({}, commonTags, value.tags)
+      var filterFileds = ['date', 'type', CUSTOM_KEYS] // 已经在datamap中定义过的fields和tags
+      each(tags, function (value_path, _key) {
+        var _value = findByPath(message, value_path)
+        filterFileds.push(_key)
+        if (_value || isNumber(_value)) {
+          rowData.tags[_key] = escapeJsonValue(_value)
+          tagsStr.push(escapeRowData(_key) + '=' + escapeRowData(_value))
+        }
+      })
+      
+      var fieldsStr = []
+      each(value.fields, function (_value, _key) {
+        if (isArray(_value) && _value.length === 2) {
+          var type = _value[0],
+            value_path = _value[1]
+          var _valueData = findByPath(message, value_path)
+          filterFileds.push(_key)
+          if (_valueData || isNumber(_valueData)) {
+            rowData.fields[_key] = _valueData // 这里不需要转译
+            // _valueData =
+            //   type === 'string'
+            //     ? '"' +
+            //       _valueData.replace(/[\\]*"/g, '"').replace(/"/g, '\\"') +
+            //       '"'
+            //     : escapeRowData(_valueData)
+            fieldsStr.push(escapeRowData(_key) + '=' + escapeRowField(_valueData))
+          }
+        } else if (isString(_value)) {
+          var _valueData = findByPath(message, _value)
+          filterFileds.push(_key)
+          if (_valueData || isNumber(_valueData)) {
+            rowData.fields[_key] = _valueData // 这里不需要转译
+            fieldsStr.push(escapeRowData(_key) + '=' + escapeRowField(_valueData))
+          }
+        }
+      })
+      if (message.tags && isObject(message.tags) && !isEmptyObject(message.tags)) {
+        // 自定义tag， 存储成field
+        var _tagKeys = []
+        each(message.tags, function (_value, _key) {
+          // 如果和之前tag重名，则舍弃
+          if (filterFileds.indexOf(_key) > -1) return
+          filterFileds.push(_key)
+          if (_value || isNumber(_value)) {
+            _tagKeys.push(_key)
+            rowData.fields[_key] = _value // 这里不需要转译
+            fieldsStr.push(escapeRowData(_key) + '=' + escapeRowField(_value))
+          }
+        })
+        if (_tagKeys.length) {
+          rowData.fields[CUSTOM_KEYS] = escapeRowField(_tagKeys)
+          fieldsStr.push(escapeRowData(CUSTOM_KEYS) + '=' + escapeRowField(_tagKeys))
+        }
+      }
+      if (message.type === RumEventType.LOGGER) {
+        // 这里处理日志类型数据自定义字段
+        each(message, function (value, key) {
+          if (
+            filterFileds.indexOf(key) === -1 &&
+            (isNumber(value) || isString(value) || isBoolean(value))
+          ) {
+            rowData.fields[key] = value // 这里不需要转译
+            fieldsStr.push(escapeRowData(key) + '=' + escapeRowField(value))
+          }
+        })
+      }
+      if (tagsStr.length) {
+        rowStr += tagsStr.join(',')
+      }
+      if (fieldsStr.length) {
+        rowStr += ' '
+        rowStr += fieldsStr.join(',')
+        hasFileds = true
+      }
+      rowStr = rowStr + ' ' + message.date
+      rowData.time = toServerDuration(message.date) // 这里不需要转译
+    }
+  })
+  return {
+    rowStr: hasFileds ? rowStr : '',
+    rowData: hasFileds ? rowData : undefined
+  }
+}
+var batch = function (request, batchMessagesLimit, batchBytesLimit, messageBytesLimit, flushTimeout,beforeUnloadCallback) {
+  this.pushOnlyBuffer = []
+  this.upsertBuffer = {}
+  this.bufferBytesCount = 0
+  this.bufferMessagesCount = 0
+  this.request = request
+  this.batchMessagesLimit = batchMessagesLimit
+  this.batchBytesLimit = batchBytesLimit
+  this.messageBytesLimit = messageBytesLimit
+  this.flushTimeout = flushTimeout
+  if (typeof beforeUnloadCallback === 'function') {
+    this.beforeUnloadCallback = beforeUnloadCallback
+  } else {
+    this.beforeUnloadCallback = noop
+  }
+  this.setupFlushOnExit()
+  this.flushPeriodically()
+}
+batch.prototype.add = function(message) {
+  this.addOrUpdate(message)
+}
+batch.prototype.upsert = function(message, key) {
+  this.addOrUpdate(message, key)
+}
+batch.prototype.flush = function(sendFn) {
+  if (typeof sendFn !== 'function') {
+    sendFn = this.request.send
+  } 
+  if (this.bufferMessagesCount !== 0) {
+    var messages = this.pushOnlyBuffer.concat(values(this.upsertBuffer))
+    var bytesCount = this.bufferBytesCount
+    this.pushOnlyBuffer = []
+    this.upsertBuffer = {}
+    this.bufferBytesCount = 0
+    this.bufferMessagesCount = 0
+    if (messages.length > 0) {
+      sendFn({ data: messages.join('\n'), bytesCount: bytesCount })
+    }
+  }
+}
+batch.prototype.flushOnExit = function() {
+  this.flush(this.request.sendOnExit)
+}
+batch.prototype.computeBytesCount = function(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
+}
+batch.prototype.addOrUpdate = function(message, key) {
+  var _process = this.process(message)
+  var processedMessage = _process.processedMessage
+  var messageBytesCount = _process.messageBytesCount
+  if (messageBytesCount >= this.messageBytesLimit) {
+    display.warn(
+      'Discarded a message whose size was bigger than the maximum allowed size ' + this.messageBytesLimit + 'KB.'
+    )
+    return
+  }
+  if (this.hasMessageFor(key)) {
+    this.remove(key)
+  }
+  if (this.willReachedBytesLimitWith(messageBytesCount)) {
+    this.flush()
+  }
+
+  this.push(processedMessage, messageBytesCount, key)
+  if (this.isFull()) {
+    this.flush()
+  }
+}
+batch.prototype.process = function(message) {
+  var processedMessage = processedMessageByDataMap(message).rowStr
+  var messageBytesCount = this.computeBytesCount(processedMessage)
+  return { processedMessage: processedMessage, messageBytesCount:messageBytesCount }
+}
+
+batch.prototype.push = function(processedMessage, messageBytesCount, key) {
+  if (this.bufferMessagesCount > 0) {
+    // \n separator at serialization
+    this.bufferBytesCount += 1
+  }
+  if (key !== undefined) {
+    this.upsertBuffer[key] = processedMessage
+  } else {
+    this.pushOnlyBuffer.push(processedMessage)
+  }
+  this.bufferBytesCount += messageBytesCount
+  this.bufferMessagesCount += 1
+}
+
+batch.prototype.remove = function(key) {
+  var removedMessage = this.upsertBuffer[key]
+  delete this.upsertBuffer[key]
+  var messageBytesCount = this.computeBytesCount(removedMessage)
+  this.bufferBytesCount -= messageBytesCount
+  this.bufferMessagesCount -= 1
+  if (this.bufferMessagesCount > 0) {
+    this.bufferBytesCount -= 1
+  }
+}
+
+batch.prototype.hasMessageFor = function(key) {
+  return key !== undefined && this.upsertBuffer[key] !== undefined
+}
+
+batch.prototype.willReachedBytesLimitWith = function(messageBytesCount) {
+  // byte of the separator at the end of the message
+  return this.bufferBytesCount + messageBytesCount + 1 >= this.batchBytesLimit
+}
+
+batch.prototype.isFull = function() {
+  return this.bufferMessagesCount === this.batchMessagesLimit || this.bufferBytesCount >= this.batchBytesLimit
+}
+
+batch.prototype.flushPeriodically = function() {
+  var _this = this
+  setTimeout(
+    function(){
+      _this.flush()
+      _this.flushPeriodically()
+    },
+    this.flushTimeout
+  )
+}
+
+batch.prototype.setupFlushOnExit = function() {
+  /**
+   * With sendBeacon, requests are guaranteed to be successfully sent during document unload
+   */
+  // @ts-ignore this function is not always defined
+  var  _this = this
+  if (navigator.sendBeacon) {
+    /**
+     * beforeunload is called before visibilitychange
+     * register first to be sure to be called before flush on beforeunload
+     * caveat: unload can still be canceled by another listener
+     */
+    addEventListener(window, DOM_EVENT.BEFORE_UNLOAD, this.beforeUnloadCallback)
+
+    /**
+     * Only event that guarantee to fire on mobile devices when the page transitions to background state
+     * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.
+     */
+    addEventListener(document, DOM_EVENT.VISIBILITY_CHANGE, function() {
+      if (document.visibilityState === 'hidden') {
+        _this.flushOnExit()
+      }
+    })
+    /**
+     * Safari does not support yet to send a request during:
+     * - a visibility change during doc unload (cf: https://bugs.webkit.org/show_bug.cgi?id=194897)
+     * - a page hide transition (cf: https://bugs.webkit.org/show_bug.cgi?id=188329)
+     */
+    addEventListener(window, DOM_EVENT.BEFORE_UNLOAD, function() {
+      return _this.flushOnExit()
+    })
+  }
+}
+export var Batch = batch

package/src/transport/httpRequest.js

@@ -0,0 +1,109 @@
+import { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy'
+
+/**
+ * Use POST request without content type to:
+ * - avoid CORS preflight requests
+ * - allow usage of sendBeacon
+ *
+ * multiple elements are sent separated by \n in order
+ * to be parsed correctly without content type header
+ */
+function addBatchPrecision(url) {
+  if (!url) return url
+  return url + (url.indexOf('?') === -1 ? '?' : '&') + 'precision=ms'
+}
+export function createHttpRequest(
+  endpointUrl,
+  bytesLimit,
+  reportError
+) {
+  var retryState = newRetryState()
+  var sendStrategyForRetry = function(payload, onResponse) {
+    return fetchKeepAliveStrategy(endpointUrl, bytesLimit, payload, onResponse)
+  }
+    
+  return {
+    send: function(payload) {
+      sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, reportError)
+    },
+    /**
+     * Since fetch keepalive behaves like regular fetch on Firefox,
+     * keep using sendBeaconStrategy on exit
+     */
+    sendOnExit: function(payload) {
+      sendBeaconStrategy(endpointUrl, bytesLimit, payload)
+    },
+  }
+}
+
+function sendBeaconStrategy(endpointUrl, bytesLimit, payload) {
+  var data = payload.data
+  var bytesCount = payload.bytesCount
+  var url = addBatchPrecision(endpointUrl)
+  var canUseBeacon = !!navigator.sendBeacon && bytesCount < bytesLimit
+  if (canUseBeacon) {
+    try {
+      var isQueued = navigator.sendBeacon(url, data)
+
+      if (isQueued) {
+        return
+      }
+    } catch (e) {
+      // reportBeaconError(e)
+    }
+  }
+  sendXHR(url, data)
+}
+
+
+
+export function fetchKeepAliveStrategy(
+  endpointUrl,
+  bytesLimit,
+  payload,
+  onResponse
+) {
+  var data = payload.data
+  var bytesCount = payload.bytesCount
+  var url = addBatchPrecision(endpointUrl)
+  var canUseKeepAlive = isKeepAliveSupported() && bytesCount < bytesLimit
+  if (canUseKeepAlive) {
+    fetch(url, { method: 'POST', body: data, keepalive: true })
+    .then(
+      function(response) {
+        if (typeof onResponse === 'function') {
+          onResponse({ status: response.status })
+        }
+      },
+      function() {
+        // failed to queue the request
+        sendXHR(url, data, onResponse)
+      }
+    )
+  } else {
+    sendXHR(url, data, onResponse)
+  }
+}
+
+function isKeepAliveSupported() {
+  // Request can throw, cf https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#errors
+  try {
+    return window.Request && 'keepalive' in new Request('http://a')
+  } catch {
+    return false
+  }
+}
+
+function sendXHR(url, data, onResponse) {
+  const request = new XMLHttpRequest()
+  request.open('POST', url, true)
+  request.send(data)
+  request.addEventListener(
+    'loadend',
+    function(){
+      if (typeof onResponse === 'function') {
+        onResponse({ status: request.status })
+      }
+    }
+  )
+}

package/src/transport/index.js

@@ -0,0 +1,3 @@
+export { createHttpRequest } from './httpRequest'
+export { Batch } from './batch'
+export { startBatchWithReplica } from './startBatchWithReplica'

package/src/transport/sendWithRetryStrategy.js

@@ -0,0 +1,186 @@
+import { clocksNow, ONE_KIBI_BYTE, ONE_MEBI_BYTE, ONE_SECOND } from '../helper/tools'
+import { ErrorSource } from '../helper/errorTools'
+
+export var MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE
+export var MAX_ONGOING_REQUESTS = 32
+export var MAX_QUEUE_BYTES_COUNT = 3 * ONE_MEBI_BYTE
+export var MAX_BACKOFF_TIME = 256 * ONE_SECOND
+export var INITIAL_BACKOFF_TIME = ONE_SECOND
+
+var TransportStatus = {
+  UP: 'UP',
+  FAILURE_DETECTED: 'FAILURE_DETECTED',
+  DOWN: 'DOWN',
+}
+
+var RetryReason = {
+  AFTER_SUCCESS: 'AFTER_SUCCESS',
+  AFTER_RESUME: 'AFTER_RESUME',
+}
+
+export function sendWithRetryStrategy(
+  payload,
+  state,
+  sendStrategy,
+  reportError
+) {
+  if (
+    state.transportStatus === TransportStatus.UP &&
+    state.queuedPayloads.size() === 0 &&
+    state.bandwidthMonitor.canHandle(payload)
+  ) {
+    send(payload, state, sendStrategy, {
+      onSuccess: function()  { return retryQueuedPayloads(RetryReason.AFTER_SUCCESS, state, sendStrategy, reportError) },
+      onFailure: function()  {
+        state.queuedPayloads.enqueue(payload)
+        scheduleRetry(state, sendStrategy, reportError)
+      },
+    })
+  } else {
+    state.queuedPayloads.enqueue(payload)
+  }
+}
+
+function scheduleRetry(
+  state,
+  sendStrategy,
+  reportError
+) {
+  if (state.transportStatus !== TransportStatus.DOWN) {
+    return
+  }
+  setTimeout(
+    function(){
+      var payload = state.queuedPayloads.first()
+      send(payload, state, sendStrategy, {
+        onSuccess: function() {
+          state.queuedPayloads.dequeue()
+          // if (state.lastFailureStatus !== 0) {
+          //   addTelemetryDebug('resuming after transport down', {
+          //     failureStatus: state.lastFailureStatus,
+          //   })
+          // }
+          state.currentBackoffTime = INITIAL_BACKOFF_TIME
+          retryQueuedPayloads(RetryReason.AFTER_RESUME, state, sendStrategy, reportError)
+        },
+        onFailure: function() {
+          state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2)
+          scheduleRetry(state, sendStrategy, reportError)
+        },
+      })
+    },
+    state.currentBackoffTime
+  )
+}
+
+function send(
+  payload,
+  state,
+  sendStrategy,
+  responseData
+) {
+  var onSuccess = responseData.onSuccess
+  var onFailure = responseData.onFailure
+  state.bandwidthMonitor.add(payload)
+  sendStrategy(payload, function(response) {
+    state.bandwidthMonitor.remove(payload)
+    if (wasRequestSuccessful(response)) {
+      state.transportStatus = TransportStatus.UP
+      onSuccess()
+    } else {
+      // do not consider transport down if another ongoing request could succeed
+      state.transportStatus =
+        state.bandwidthMonitor.ongoingRequestCount > 0 ? TransportStatus.FAILURE_DETECTED : TransportStatus.DOWN
+      state.lastFailureStatus = response.status
+      onFailure()
+    }
+  })
+}
+
+function retryQueuedPayloads(
+  reason,
+  state,
+  sendStrategy,
+  reportError
+) {
+  if (reason === RetryReason.AFTER_SUCCESS && state.queuedPayloads.isFull() && !state.queueFullReported) {
+    reportError({
+      message: 'Reached max events size queued for upload: '+ MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE + 'MiB',
+      source: ErrorSource.AGENT,
+      startClocks: clocksNow(),
+    })
+    state.queueFullReported = true
+  }
+  var previousQueue = state.queuedPayloads
+  state.queuedPayloads = newPayloadQueue()
+  while (previousQueue.size() > 0) {
+    sendWithRetryStrategy(previousQueue.dequeue(), state, sendStrategy, reportError)
+  }
+}
+
+function wasRequestSuccessful(response) {
+  return response.status !== 0 && response.status < 500
+}
+
+export function newRetryState() {
+  return {
+    transportStatus: TransportStatus.UP,
+    lastFailureStatus: 0,
+    currentBackoffTime: INITIAL_BACKOFF_TIME,
+    bandwidthMonitor: newBandwidthMonitor(),
+    queuedPayloads: newPayloadQueue(),
+    queueFullReported: false,
+  }
+}
+
+function newPayloadQueue() {
+  var queue = []
+  return {
+    bytesCount: 0,
+    enqueue: function(payload) {
+      if (this.isFull()) {
+        return
+      }
+      queue.push(payload)
+      this.bytesCount += payload.bytesCount
+    },
+    first() {
+      return queue[0]
+    },
+    dequeue() {
+      var payload = queue.shift()
+      if (payload) {
+        this.bytesCount -= payload.bytesCount
+      }
+      return payload
+    },
+    size() {
+      return queue.length
+    },
+    isFull() {
+      return this.bytesCount >= MAX_QUEUE_BYTES_COUNT
+    },
+  }
+}
+
+function newBandwidthMonitor() {
+  return {
+    ongoingRequestCount: 0,
+    ongoingByteCount: 0,
+    canHandle: function(payload) {
+      return (
+        this.ongoingRequestCount === 0 ||
+        (this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT &&
+          this.ongoingRequestCount < MAX_ONGOING_REQUESTS)
+      )
+    },
+    add: function(payload) {
+      this.ongoingRequestCount += 1
+      this.ongoingByteCount += payload.bytesCount
+    },
+    remove:function(payload) {
+      this.ongoingRequestCount -= 1
+      this.ongoingByteCount -= payload.bytesCount
+    },
+  }
+}