@cloudcare/browser-core 1.2.11 → 2.0.0

package/src/transport/batch.js

@@ -1,8 +1,8 @@
 import { display } from '../helper/display'
-import { 
-  addEventListener, 
-  noop, 
-  values, 
+import {
+  addEventListener,
+  noop,
+  values,
   findByPath,
   escapeRowData,
   each,
@@ -15,20 +15,21 @@ import {
   isEmptyObject,
   isObject,
   escapeJsonValue,
-  escapeRowField 
+  escapeRowField
 } from '../helper/tools'
-import { commonTags, dataMap } from '../dataMap'
+import { commonTags, dataMap, commonFields } 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
-  }
-  
+  if (!message || !message.type)
+    return {
+      rowStr: '',
+      rowData: undefined
+    }
+
   var rowData = { tags: {}, fields: {} }
   var hasFileds = false
   var rowStr = ''
@@ -47,9 +48,10 @@ export var processedMessageByDataMap = function (message) {
           tagsStr.push(escapeRowData(_key) + '=' + escapeRowData(_value))
         }
       })
-      
+
       var fieldsStr = []
-      each(value.fields, function (_value, _key) {
+      var fields = extend({}, commonFields, value.fields)
+      each(fields, function (_value, _key) {
         if (isArray(_value) && _value.length === 2) {
           var type = _value[0],
             value_path = _value[1]
@@ -63,18 +65,26 @@ export var processedMessageByDataMap = function (message) {
             //       _valueData.replace(/[\\]*"/g, '"').replace(/"/g, '\\"') +
             //       '"'
             //     : escapeRowData(_valueData)
-            fieldsStr.push(escapeRowData(_key) + '=' + escapeRowField(_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))
+            fieldsStr.push(
+              escapeRowData(_key) + '=' + escapeRowField(_valueData)
+            )
           }
         }
       })
-      if (message.tags && isObject(message.tags) && !isEmptyObject(message.tags)) {
+      if (
+        message.tags &&
+        isObject(message.tags) &&
+        !isEmptyObject(message.tags)
+      ) {
         // 自定义tag， 存储成field
         var _tagKeys = []
         each(message.tags, function (_value, _key) {
@@ -89,7 +99,9 @@ export var processedMessageByDataMap = function (message) {
         })
         if (_tagKeys.length) {
           rowData.fields[CUSTOM_KEYS] = escapeRowField(_tagKeys)
-          fieldsStr.push(escapeRowData(CUSTOM_KEYS) + '=' + escapeRowField(_tagKeys))
+          fieldsStr.push(
+            escapeRowData(CUSTOM_KEYS) + '=' + escapeRowField(_tagKeys)
+          )
         }
       }
       if (message.type === RumEventType.LOGGER) {
@@ -121,7 +133,14 @@ export var processedMessageByDataMap = function (message) {
     rowData: hasFileds ? rowData : undefined
   }
 }
-var batch = function (request, batchMessagesLimit, batchBytesLimit, messageBytesLimit, flushTimeout,beforeUnloadCallback) {
+var batch = function (
+  request,
+  batchMessagesLimit,
+  batchBytesLimit,
+  messageBytesLimit,
+  flushTimeout,
+  pageExitObservable
+) {
   this.pushOnlyBuffer = []
   this.upsertBuffer = {}
   this.bufferBytesCount = 0
@@ -131,24 +150,22 @@ var batch = function (request, batchMessagesLimit, batchBytesLimit, messageBytes
   this.batchBytesLimit = batchBytesLimit
   this.messageBytesLimit = messageBytesLimit
   this.flushTimeout = flushTimeout
-  if (typeof beforeUnloadCallback === 'function') {
-    this.beforeUnloadCallback = beforeUnloadCallback
-  } else {
-    this.beforeUnloadCallback = noop
-  }
-  this.setupFlushOnExit()
+  var _this = this
+  pageExitObservable.subscribe(function () {
+    _this.flush(_this.request.sendOnExit)
+  })
   this.flushPeriodically()
 }
-batch.prototype.add = function(message) {
+batch.prototype.add = function (message) {
   this.addOrUpdate(message)
 }
-batch.prototype.upsert = function(message, key) {
+batch.prototype.upsert = function (message, key) {
   this.addOrUpdate(message, key)
 }
-batch.prototype.flush = function(sendFn) {
+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
@@ -161,10 +178,10 @@ batch.prototype.flush = function(sendFn) {
     }
   }
 }
-batch.prototype.flushOnExit = function() {
+batch.prototype.flushOnExit = function () {
   this.flush(this.request.sendOnExit)
 }
-batch.prototype.computeBytesCount = function(candidate) {
+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
@@ -176,13 +193,15 @@ batch.prototype.computeBytesCount = function(candidate) {
 
   return new Blob([candidate]).size
 }
-batch.prototype.addOrUpdate = function(message, key) {
+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.'
+      'Discarded a message whose size was bigger than the maximum allowed size ' +
+        this.messageBytesLimit +
+        'KB.'
     )
     return
   }
@@ -198,13 +217,16 @@ batch.prototype.addOrUpdate = function(message, key) {
     this.flush()
   }
 }
-batch.prototype.process = function(message) {
+batch.prototype.process = function (message) {
   var processedMessage = processedMessageByDataMap(message).rowStr
   var messageBytesCount = this.computeBytesCount(processedMessage)
-  return { processedMessage: processedMessage, messageBytesCount:messageBytesCount }
+  return {
+    processedMessage: processedMessage,
+    messageBytesCount: messageBytesCount
+  }
 }
 
-batch.prototype.push = function(processedMessage, messageBytesCount, key) {
+batch.prototype.push = function (processedMessage, messageBytesCount, key) {
   if (this.bufferMessagesCount > 0) {
     // \n separator at serialization
     this.bufferBytesCount += 1
@@ -218,7 +240,7 @@ batch.prototype.push = function(processedMessage, messageBytesCount, key) {
   this.bufferMessagesCount += 1
 }
 
-batch.prototype.remove = function(key) {
+batch.prototype.remove = function (key) {
   var removedMessage = this.upsertBuffer[key]
   delete this.upsertBuffer[key]
   var messageBytesCount = this.computeBytesCount(removedMessage)
@@ -229,61 +251,28 @@ batch.prototype.remove = function(key) {
   }
 }
 
-batch.prototype.hasMessageFor = function(key) {
+batch.prototype.hasMessageFor = function (key) {
   return key !== undefined && this.upsertBuffer[key] !== undefined
 }
 
-batch.prototype.willReachedBytesLimitWith = function(messageBytesCount) {
+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.isFull = function () {
+  return (
+    this.bufferMessagesCount === this.batchMessagesLimit ||
+    this.bufferBytesCount >= this.batchBytesLimit
+  )
 }
 
-batch.prototype.flushPeriodically = function() {
+batch.prototype.flushPeriodically = function () {
   var _this = this
-  setTimeout(
-    function(){
-      _this.flush()
-      _this.flushPeriodically()
-    },
-    this.flushTimeout
-  )
+  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

@@ -12,27 +12,28 @@ function addBatchPrecision(url) {
   if (!url) return url
   return url + (url.indexOf('?') === -1 ? '?' : '&') + 'precision=ms'
 }
-export function createHttpRequest(
-  endpointUrl,
-  bytesLimit,
-  reportError
-) {
+export function createHttpRequest(endpointUrl, bytesLimit, reportError) {
   var retryState = newRetryState()
-  var sendStrategyForRetry = function(payload, onResponse) {
+  var sendStrategyForRetry = function (payload, onResponse) {
     return fetchKeepAliveStrategy(endpointUrl, bytesLimit, payload, onResponse)
   }
-    
+
   return {
-    send: function(payload) {
-      sendWithRetryStrategy(payload, retryState, sendStrategyForRetry, reportError)
+    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) {
+    sendOnExit: function (payload) {
       sendBeaconStrategy(endpointUrl, bytesLimit, payload)
-    },
+    }
   }
 }
 
@@ -55,8 +56,6 @@ function sendBeaconStrategy(endpointUrl, bytesLimit, payload) {
   sendXHR(url, data)
 }
 
-
-
 export function fetchKeepAliveStrategy(
   endpointUrl,
   bytesLimit,
@@ -68,14 +67,18 @@ export function fetchKeepAliveStrategy(
   var url = addBatchPrecision(endpointUrl)
   var canUseKeepAlive = isKeepAliveSupported() && bytesCount < bytesLimit
   if (canUseKeepAlive) {
-    fetch(url, { method: 'POST', body: data, keepalive: true })
-    .then(
-      function(response) {
+    fetch(url, {
+      method: 'POST',
+      body: data,
+      keepalive: true,
+      mode: 'cors'
+    }).then(
+      function (response) {
         if (typeof onResponse === 'function') {
-          onResponse({ status: response.status })
+          onResponse({ status: response.status, type: response.type })
         }
       },
-      function() {
+      function () {
         // failed to queue the request
         sendXHR(url, data, onResponse)
       }
@@ -98,12 +101,9 @@ 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 })
-      }
+  request.addEventListener('loadend', function () {
+    if (typeof onResponse === 'function') {
+      onResponse({ status: request.status })
     }
-  )
+  })
 }

package/src/transport/sendWithRetryStrategy.js

@@ -13,14 +13,14 @@ 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'
+  UP: 0,
+  FAILURE_DETECTED: 1,
+  DOWN: 2
 }
 
 var RetryReason = {
-  AFTER_SUCCESS: 'AFTER_SUCCESS',
-  AFTER_RESUME: 'AFTER_RESUME'
+  AFTER_SUCCESS: 0,
+  AFTER_RESUME: 1
 }
 
 export function sendWithRetryStrategy(
@@ -92,7 +92,7 @@ function send(payload, state, sendStrategy, responseData) {
   state.bandwidthMonitor.add(payload)
   sendStrategy(payload, function (response) {
     state.bandwidthMonitor.remove(payload)
-    if (wasRequestSuccessful(response)) {
+    if (!shouldRetryRequest(response)) {
       state.transportStatus = TransportStatus.UP
       onSuccess()
     } else {
@@ -135,10 +135,15 @@ function retryQueuedPayloads(reason, state, sendStrategy, reportError) {
   }
 }
 
-function wasRequestSuccessful(response) {
-  return response.status !== 0 && response.status < 500
+function shouldRetryRequest(response) {
+  return (
+    response.type !== 'opaque' &&
+    ((response.status === 0 && !navigator.onLine) ||
+      response.status === 408 ||
+      response.status === 429 ||
+      response.status >= 500)
+  )
 }
-
 export function newRetryState() {
   return {
     transportStatus: TransportStatus.UP,

package/src/transport/startBatchWithReplica.js

@@ -4,23 +4,29 @@ import { createHttpRequest } from './httpRequest'
 export function startBatchWithReplica(
   configuration,
   endpointUrl,
-  reportError
+  reportError,
+  pageExitObservable
 ) {
   var primaryBatch = createBatch(endpointUrl)
 
   function createBatch(endpointUrl) {
     return new Batch(
-      createHttpRequest(endpointUrl, configuration.batchBytesLimit, reportError),
+      createHttpRequest(
+        endpointUrl,
+        configuration.batchBytesLimit,
+        reportError
+      ),
       configuration.batchMessagesLimit,
       configuration.batchBytesLimit,
       configuration.messageBytesLimit,
-      configuration.flushTimeout
+      configuration.flushTimeout,
+      pageExitObservable
     )
   }
 
   return {
-    add: function(message) {
+    add: function (message) {
       primaryBatch.add(message)
-    },
+    }
   }
 }