@cloudcare/browser-core 1.1.2 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudcare/browser-core",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "main": "cjs/index.js",
   "module": "esm/index.js",
   "scripts": {
@@ -20,5 +20,5 @@
   "author": "dataflux",
   "license": "MIT",
   "description": "DataFlux RUM Web 端数据指标监控",
-  "gitHead": "5cbe53e30874a6c365a4e1e31353da8b02d0e0f3"
+  "gitHead": "12b759bde16de07678f898b82c1bcf11c403eabe"
 }

package/src/{cookie.js → browser/cookie.js}

@@ -1,38 +1,5 @@
-import { findCommaSeparatedValue, UUID, ONE_SECOND } from './helper/tools'
+import { findCommaSeparatedValue, UUID, ONE_SECOND } from '../helper/tools'
 export var COOKIE_ACCESS_DELAY = ONE_SECOND
-export function cacheCookieAccess(name, options) {
-  var timeout
-  var cache
-  var hasCache = false
-
-  var cacheAccess = function () {
-    hasCache = true
-    window.clearTimeout(timeout)
-    timeout = window.setTimeout(function () {
-      hasCache = false
-    }, COOKIE_ACCESS_DELAY)
-  }
-
-  return {
-    get: function () {
-      if (hasCache) {
-        return cache
-      }
-      cache = getCookie(name)
-      cacheAccess()
-      return cache
-    },
-    set: function (value, expireDelay) {
-      setCookie(name, value, expireDelay, options)
-      cache = value
-      cacheAccess()
-    },
-    clearCache: function() {
-      window.clearTimeout(timeout)
-      hasCache = false
-    },
-  }
-}
 
 export function setCookie(name, value, expireDelay, options) {
   var date = new Date()
@@ -57,6 +24,11 @@ export function getCookie(name) {
   return findCommaSeparatedValue(document.cookie, name)
 }
 
+export function deleteCookie(name, options) {
+  setCookie(name, '', 0, options)
+}
+
+
 export function areCookiesAuthorized(options) {
   if (document.cookie === undefined || document.cookie === null) {
     return false

package/src/browser/fetchObservable.js

@@ -0,0 +1,86 @@
+import { instrumentMethod } from '../helper/instrumentMethod'
+import { Observable } from '../helper/observable'
+import { elapsed, clocksNow, timeStampNow } from '../helper/tools'
+import { normalizeUrl } from '../helper/urlPolyfill'
+
+var fetchObservable
+
+export function initFetchObservable() {
+  if (!fetchObservable) {
+    fetchObservable = createFetchObservable()
+  }
+  return fetchObservable
+}
+
+function createFetchObservable() {
+  var observable = new Observable(function() {
+    if (!window.fetch) {
+      return
+    }
+
+    var fetchMethod = instrumentMethod(
+      window,
+      'fetch',
+      function(originalFetch) {
+        return function (input, init) {
+          var responsePromise
+          var context = beforeSend(observable, input, init)
+          if (context) {
+            responsePromise = originalFetch.call(this, context.input, context.init)
+            afterSend(observable, responsePromise, context)
+          } else {
+            responsePromise = originalFetch.call(this, input, init)
+          }
+          return responsePromise
+        }
+      }   
+    )
+    return fetchMethod.stop
+  })
+
+  return observable
+}
+
+function beforeSend(observable, input, init) {
+  var method = (init && init.method) || (typeof input === 'object' && input.method) || 'GET'
+  var url = normalizeUrl((typeof input === 'object' && input.url) || input)
+  var startClocks = clocksNow()
+
+  var context = {
+    state: 'start',
+    init: init,
+    input: input,
+    method: method,
+    startClocks: startClocks,
+    url: url,
+  }
+
+  observable.notify(context)
+
+  return context
+}
+
+function afterSend(
+  observable,
+  responsePromise,
+  startContext
+) {
+  var reportFetch = function(response) {
+    var context = startContext
+    context.state = 'complete'
+    context.duration = elapsed(context.startClocks.timeStamp, timeStampNow())
+    if ('stack' in response || response instanceof Error) {
+      context.status = 0
+      context.isAborted = response instanceof DOMException && response.code === DOMException.ABORT_ERR
+      context.error = response
+      observable.notify(context)
+    } else if ('status' in response) {
+      context.response = response
+      context.responseType = response.type
+      context.status = response.status
+      context.isAborted = false
+      observable.notify(context)
+    }
+  }
+  responsePromise.then(reportFetch, reportFetch)
+}

package/src/browser/xhrObservable.js

@@ -0,0 +1,102 @@
+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'
+
+var xhrObservable
+var xhrContexts = {}
+var DATA_FLUX_REQUEST_ID_KEY = '_DATAFLUX_REQUEST_UUID'
+export function initXhrObservable() {
+  if (!xhrObservable) {
+    xhrObservable = createXhrObservable()
+  }
+  return xhrObservable
+}
+
+function createXhrObservable() {
+  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 abortInstrumentMethod = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'abort', {
+      before:abortXhr,
+    })
+
+    return function() {
+      openInstrumentMethod.stop()
+      sendInstrumentMethod.stop()
+      abortInstrumentMethod.stop()
+    }
+  })
+  return observable
+}
+
+function openXhr(method, url) {
+  var requestUUID = this[DATA_FLUX_REQUEST_ID_KEY] || UUID()
+  this[DATA_FLUX_REQUEST_ID_KEY] = requestUUID
+  xhrContexts[requestUUID] = {
+    state: 'open',
+    method: method,
+    url: normalizeUrl(String(url)),
+  }
+}
+
+function sendXhr(observable) {
+  var context = xhrContexts[this[DATA_FLUX_REQUEST_ID_KEY]]
+  if (!context) {
+    return
+  }
+  var startContext = context
+  startContext.state = 'start'
+  startContext.startTime = relativeNow()
+  startContext.startClocks = clocksNow()
+  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 onEnd = function() {
+    this.removeEventListener('loadend', onEnd)
+    onreadyStateChangeInstrumentMethod.stop()
+    if (hasBeenReported) {
+      return
+    }
+    hasBeenReported = true
+    var completeContext = context
+    completeContext.state = 'complete'
+    completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow())
+    completeContext.status = this.status
+    observable.notify(shallowClone(completeContext))
+    clearRequestId.call(this)
+  }
+  this.addEventListener('loadend', onEnd)
+  observable.notify(startContext)
+}
+function clearRequestId() {
+  delete xhrContexts[this[DATA_FLUX_REQUEST_ID_KEY]]
+  delete this[DATA_FLUX_REQUEST_ID_KEY]
+}
+function abortXhr() {
+  var context = xhrContexts[this[DATA_FLUX_REQUEST_ID_KEY]]
+  if (context) {
+    context.isAborted = true
+  }
+}

package/src/configuration/configuration.js

@@ -0,0 +1,61 @@
+import { getCurrentSite } from '../browser/cookie'
+import { catchUserErrors } from '../helper/catchUserErrors'
+import { display } from '../helper/display'
+import { assign, isPercentage, ONE_KIBI_BYTE, ONE_SECOND, isNullUndefinedDefaultValue } from '../helper/tools'
+import { computeTransportConfiguration } from './transportConfiguration'
+export function validateAndBuildConfiguration(initConfiguration){
+  if (initConfiguration.sampleRate !== undefined && !isPercentage(initConfiguration.sampleRate)) {
+    display.error('Sample Rate should be a number between 0 and 100')
+    return
+  }
+  return assign(
+    {
+      beforeSend:
+        initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),
+      cookieOptions: buildCookieOptions(initConfiguration),
+      sampleRate: isNullUndefinedDefaultValue(initConfiguration.sampleRate, 100),
+      service: initConfiguration.service,
+      version: initConfiguration.version,
+      env: initConfiguration.env,
+      silentMultipleInit: !!initConfiguration.silentMultipleInit,
+
+      /**
+       * beacon payload max queue size implementation is 64kb
+       * ensure that we leave room for logs, rum and potential other users
+       */
+      batchBytesLimit: 16 * ONE_KIBI_BYTE,
+
+      eventRateLimiterThreshold: 3000,
+
+      /**
+       * flush automatically, aim to be lower than ALB connection timeout
+       * to maximize connection reuse.
+       */
+      flushTimeout: 30 * ONE_SECOND,
+
+      /**
+       * Logs intake limit
+       */
+      batchMessagesLimit: 50,
+      messageBytesLimit: 256 * ONE_KIBI_BYTE,
+    },
+    computeTransportConfiguration(initConfiguration)
+  )
+}
+
+export function buildCookieOptions(initConfiguration) {
+  var cookieOptions = {}
+
+  cookieOptions.secure = mustUseSecureCookie(initConfiguration)
+  cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie
+
+  if (initConfiguration.trackSessionAcrossSubdomains) {
+    cookieOptions.domain = getCurrentSite()
+  }
+
+  return cookieOptions
+}
+
+function mustUseSecureCookie(initConfiguration) {
+  return !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie
+}

package/src/configuration/transportConfiguration.js

@@ -0,0 +1,42 @@
+import { isFunction, isBoolean, some } from '../helper/tools'
+var TRIM_REGIX = /^\s+|\s+$/g
+function getDatakitUrl(url) {
+  if (url.lastIndexOf('/') === url.length - 1) return trim(url) + 'v1/write/rum'
+  return trim(url) + '/v1/write/rum'
+}
+function trim(str) {
+  return str.replace(TRIM_REGIX, '')
+}
+function getLogsEndPoint(url) {
+  if (url.lastIndexOf('/') === url.length - 1)
+    return trim(url) + 'v1/write/logging'
+  return trim(url) + '/v1/write/logging'
+}
+export function computeTransportConfiguration(initConfiguration) {
+  var isIntakeUrl = function(url) { return false }
+  if ('isIntakeUrl' in initConfiguration && isFunction(initConfiguration.isIntakeUrl) && isBoolean(initConfiguration.isIntakeUrl())) {
+    isIntakeUrl = initConfiguration.isIntakeUrl
+  }
+  var isServerError = function(request) { return false }
+  if ('isServerError' in initConfiguration && isFunction(initConfiguration.isServerError) && isBoolean(initConfiguration.isServerError())) {
+    isServerError = initConfiguration.isServerError
+  }
+  return {
+    datakitUrl: getDatakitUrl(
+      initConfiguration.datakitUrl || initConfiguration.datakitOrigin
+    ),
+    logsEndpoint: getLogsEndPoint(initConfiguration.datakitOrigin),
+    isIntakeUrl: isIntakeUrl,
+    isServerError: isServerError
+  }
+  
+}
+export function isIntakeRequest(url, configuration) {
+  // return haveSameOrigin(url, configuration.datakitUrl)
+  var notTakeRequest = [configuration.datakitUrl]
+  if (configuration.logsEndpoint) {
+    notTakeRequest.push(configuration.logsEndpoint)
+  }
+  // datakit 地址，log 地址，以及客户自定义过滤方法定义url
+  return some(notTakeRequest, function(takeUrl) { return url.indexOf(takeUrl) === 0 }) || configuration.isIntakeUrl(url)
+}

package/src/console/consoleObservable.js

@@ -0,0 +1,65 @@
+import { computeStackTrace } from '../tracekit'
+import { createHandlingStack, formatErrorMessage, toStackTraceString } from '../helper/errorTools'
+import { mergeObservables, Observable } from '../helper/observable'
+import { find, jsonStringify, map } from '../helper/tools'
+import { ConsoleApiName } from '../helper/display'
+
+
+var consoleObservablesByApi = {}
+
+export function initConsoleObservable(apis) {
+  var consoleObservables = map(apis, function(api) {
+    if (!consoleObservablesByApi[api]) {
+      consoleObservablesByApi[api] = createConsoleObservable(api)
+    }
+    return consoleObservablesByApi[api]
+  })
+
+  return mergeObservables.apply(this, consoleObservables)
+}
+
+/* eslint-disable no-console */
+function createConsoleObservable(api) {
+  var observable = new Observable(function(){
+    var originalConsoleApi = console[api]
+    console[api] = function() {
+      var params = [].slice.call(arguments)
+      originalConsoleApi.apply(console, arguments)
+      var handlingStack = createHandlingStack()
+      observable.notify(buildConsoleLog(params, api, handlingStack))
+    }
+    return function() {
+      console[api] = originalConsoleApi
+    }
+  })
+  return observable
+}
+
+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 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
+  }
+
+  return {
+    api: api,
+    message: message,
+    stack: stack,
+    handlingStack: handlingStack,
+  }
+}
+
+function formatConsoleParameters(param) {
+  if (typeof param === 'string') {
+    return param
+  }
+  if (param instanceof Error) {
+    return formatErrorMessage(computeStackTrace(param))
+  }
+  return jsonStringify(param, undefined, 2)
+}

package/src/dataMap.js

@@ -1,11 +1,12 @@
 import { RumEventType } from './helper/enums'
 export var commonTags = {
+  action_id: 'action.id',
   sdk_name: '_dd.sdk_name',
   sdk_version: '_dd.sdk_version',
   app_id: 'application.id',
-  env: '_dd.env',
-  service: '_dd.service',
-  version: '_dd.version',
+  env: 'env',
+  service: 'service',
+  version: 'version',
   userid: 'user.id',
   user_email: 'user.email',
   user_name: 'user.name',
@@ -92,27 +93,31 @@ export var dataMap = {
   error: {
     type: RumEventType.ERROR,
     tags: {
+      error_id: 'error.id',
       trace_id: '_dd.trace_id',
       span_id: '_dd.span_id',
       error_source: 'error.source',
       error_type: 'error.type',
-      error_handling: 'error.handling',
-      resource_url: 'error.resource.url',
-      resource_url_host: 'error.resource.url_host',
-      resource_url_path: 'error.resource.url_path',
-      resource_url_path_group: 'error.resource.url_path_group',
-      resource_status: 'error.resource.status',
-      resource_status_group: 'error.resource.status_group',
-      resource_method: 'error.resource.method',
+      error_handling: 'error.handling'
+      //   resource_url: 'error.resource.url',
+      //   resource_url_host: 'error.resource.url_host',
+      //   resource_url_path: 'error.resource.url_path',
+      //   resource_url_path_group: 'error.resource.url_path_group',
+      //   resource_status: 'error.resource.status',
+      //   resource_status_group: 'error.resource.status_group',
+      //   resource_method: 'error.resource.method'
     },
     fields: {
       error_message: ['string', 'error.message'],
-      error_stack: ['string', 'error.stack']
+      error_stack: ['string', 'error.stack'],
+      error_causes: ['string', 'error.causes']
     }
   },
   long_task: {
     type: RumEventType.LONG_TASK,
-    tags: {},
+    tags: {
+      long_task_id: 'long_task.id'
+    },
     fields: {
       duration: 'long_task.duration'
     }
@@ -120,7 +125,6 @@ export var dataMap = {
   action: {
     type: RumEventType.ACTION,
     tags: {
-      action_id: 'action.id',
       action_name: 'action.target.name',
       action_type: 'action.type'
     },
@@ -128,6 +132,7 @@ export var dataMap = {
       duration: 'action.loading_time',
       action_error_count: 'action.error.count',
       action_resource_count: 'action.resource.count',
+      action_frustration_types: 'action.frustration.type',
       action_long_task_count: 'action.long_task.count'
     }
   },
@@ -136,13 +141,13 @@ export var dataMap = {
     tags: {
       error_source: 'error.source',
       error_type: 'error.type',
-      error_resource_url: 'resource.url',
-      error_resource_url_host: 'resource.url_host',
-      error_resource_url_path: 'resource.url_path',
-      error_resource_url_path_group: 'resource.url_path_group',
-      error_resource_status: 'resource.status',
-      error_resource_status_group: 'resource.status_group',
-      error_resource_method: 'resource.method',
+      error_resource_url: 'http.url',
+      error_resource_url_host: 'http.url_host',
+      error_resource_url_path: 'http.url_path',
+      error_resource_url_path_group: 'http.url_path_group',
+      error_resource_status: 'http.status_code',
+      error_resource_status_group: 'http.status_group',
+      error_resource_method: 'http.method',
       action_id: 'user_action.id',
       service: 'service',
       status: 'status'

package/src/error/trackRuntimeError.js

@@ -0,0 +1,19 @@
+import { ErrorSource, computeRawError } from '../helper/errorTools'
+import { clocksNow } from '../helper/tools'
+import { ErrorHandling } from '../helper/enums'
+import { startUnhandledErrorCollection } from '../tracekit'
+
+export function trackRuntimeError(errorObservable) {
+  return startUnhandledErrorCollection(function (stackTrace, originalError) {
+    errorObservable.notify(
+      computeRawError({
+        stackTrace: stackTrace,
+        originalError: originalError,
+        startClocks: clocksNow(),
+        nonErrorPrefix: 'Uncaught',
+        source: ErrorSource.SOURCE,
+        handling: ErrorHandling.UNHANDLED
+      })
+    )
+  })
+}

package/src/helper/catchUserErrors.js

@@ -0,0 +1,12 @@
+import { display } from './display'
+
+export function catchUserErrors(fn, errorMsg) {
+  return function() {
+    var args = [].slice.call(arguments)
+    try {
+      return fn.apply(this, args)
+    } catch (err) {
+      display.error(errorMsg, err)
+    }
+  }
+}

package/src/helper/contextHistory.js

@@ -0,0 +1,85 @@
+import { relativeNow, ONE_MINUTE, filter, map} from './tools'
+
+var END_OF_TIMES = Infinity
+
+export var CLEAR_OLD_CONTEXTS_INTERVAL = ONE_MINUTE
+export function ContextHistory(expireDelay) {
+  this.expireDelay = expireDelay 
+  this.entries = []
+  var _this = this
+  this.clearOldContextsInterval = setInterval(function(){
+    _this.clearOldContexts()
+  }, CLEAR_OLD_CONTEXTS_INTERVAL);
+}
+ContextHistory.prototype.add = function(context, startTime) {
+  var _this = this
+  var entry = {
+    context: context,
+    startTime: startTime,
+    endTime: END_OF_TIMES,
+    remove: function() {
+      var index = _this.entries.indexOf(entry)
+      if (index >= 0) {
+        _this.entries.splice(index, 1)
+      }
+    },
+    close: function(endTime){
+      entry.endTime = endTime
+    },
+  }
+  this.entries.unshift(entry)
+  return entry
+}
+ContextHistory.prototype.find = function(startTime) {
+  if (typeof startTime === 'undefined') {
+    startTime = END_OF_TIMES
+  }
+  for (var entry of this.entries) {
+    if (entry.startTime <= startTime) {
+      if (startTime <= entry.endTime) {
+        return entry.context
+      }
+      break
+    }
+  }
+}
+/**
+ * Helper function to close the currently active context, if any. This method assumes that entries
+ * are not overlapping.
+ */
+ContextHistory.prototype.closeActive = function(endTime) {
+  var latestEntry = this.entries[0]
+  if (latestEntry && latestEntry.endTime === END_OF_TIMES) {
+    latestEntry.close(endTime)
+  }
+}
+/**
+ * Return all contexts that were active during `startTime`, or all currently active contexts if no
+ * `startTime` is provided.
+ */
+ContextHistory.prototype.findAll = function(startTime){
+  if (typeof startTime === 'undefined') {
+    startTime = END_OF_TIMES
+  }
+  var result = filter(this.entries, function(entry) { return entry.startTime <= startTime && startTime <= entry.endTime })   
+  return map(result, function(entry) { return entry.context })   
+}
+/**
+ * Remove all entries from this collection.
+ */
+ContextHistory.prototype.reset = function  () {
+  this.entries = []
+}
+/**
+ * Stop internal garbage collection of past entries.
+ */
+ContextHistory.prototype.stop = function() {
+  clearInterval(this.clearOldContextsInterval)
+}
+ContextHistory.prototype.clearOldContexts = function() {
+  var oldTimeThreshold = relativeNow() - this.expireDelay
+  while (this.entries.length > 0 && this.entries[this.entries.length - 1].endTime < oldTimeThreshold) {
+    this.entries.pop()
+  }
+}
+

package/src/helper/createEventRateLimiter.js

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