@cloudcare/browser-core 1.1.2 → 1.2.0

package/esm/xhrProxy.js

@@ -1,110 +0,0 @@
-import { normalizeUrl } from './helper/urlPolyfill';
-import { each, relativeNow, clocksNow, elapsed, extend } from './helper/tools';
-var xhrProxySingleton;
-var beforeSendCallbacks = [];
-var onRequestCompleteCallbacks = [];
-var originalXhrOpen;
-var originalXhrSend;
-var originalXhrAbort;
-export function startXhrProxy() {
-  if (!xhrProxySingleton) {
-    proxyXhr();
-    xhrProxySingleton = {
-      beforeSend: function beforeSend(callback) {
-        beforeSendCallbacks.push(callback);
-      },
-      onRequestComplete: function onRequestComplete(callback) {
-        onRequestCompleteCallbacks.push(callback);
-      }
-    };
-  }
-
-  return xhrProxySingleton;
-}
-export function resetXhrProxy() {
-  if (xhrProxySingleton) {
-    xhrProxySingleton = undefined;
-    beforeSendCallbacks.length = 0;
-    onRequestCompleteCallbacks.length = 0;
-    XMLHttpRequest.prototype.open = originalXhrOpen;
-    XMLHttpRequest.prototype.send = originalXhrSend;
-    XMLHttpRequest.prototype.abort = originalXhrAbort;
-  }
-}
-
-function proxyXhr() {
-  originalXhrOpen = XMLHttpRequest.prototype.open;
-  originalXhrSend = XMLHttpRequest.prototype.send;
-  originalXhrAbort = XMLHttpRequest.prototype.abort;
-
-  XMLHttpRequest.prototype.open = function (method, url) {
-    // WARN: since this data structure is tied to the instance, it is shared by both logs and rum
-    // and can be used by different code versions depending on customer setup
-    // so it should stay compatible with older versions
-    this._dataflux_xhr = {
-      method: method,
-      startTime: -1,
-      // computed in send call
-      url: normalizeUrl(url)
-    };
-    return originalXhrOpen.apply(this, arguments);
-  };
-
-  XMLHttpRequest.prototype.send = function (body) {
-    var _this = this;
-
-    if (this._dataflux_xhr) {
-      var xhrPendingContext = this._dataflux_xhr;
-      xhrPendingContext.startTime = relativeNow();
-      xhrPendingContext.startClocks = clocksNow();
-      xhrPendingContext.isAborted = false;
-      var originalOnreadystatechange = this.onreadystatechange;
-
-      this.onreadystatechange = function () {
-        if (this.readyState === XMLHttpRequest.DONE) {
-          reportXhr();
-        }
-
-        if (originalOnreadystatechange) {
-          originalOnreadystatechange.apply(this, arguments);
-        }
-      };
-
-      var hasBeenReported = false;
-
-      var reportXhr = function reportXhr() {
-        _this.removeEventListener('loadend', reportXhr);
-
-        if (hasBeenReported) {
-          return;
-        }
-
-        hasBeenReported = true;
-        var xhrCompleteContext = extend({}, xhrPendingContext, {
-          duration: elapsed(xhrPendingContext.startClocks.relative, relativeNow()),
-          response: _this.response,
-          status: _this.status
-        });
-        each(onRequestCompleteCallbacks, function (callback) {
-          callback(xhrCompleteContext, _this);
-        });
-      };
-
-      _this.addEventListener('loadend', reportXhr);
-
-      each(beforeSendCallbacks, function (callback) {
-        callback(xhrPendingContext, _this);
-      });
-    }
-
-    return originalXhrSend.apply(_this, arguments);
-  };
-
-  XMLHttpRequest.prototype.abort = function () {
-    if (this._dataflux_xhr) {
-      this._dataflux_xhr.isAborted = true;
-    }
-
-    return originalXhrAbort.apply(this, arguments);
-  };
-}

package/src/configuration.js

@@ -1,156 +0,0 @@
-import {
-  ONE_KILO_BYTE,
-  ONE_SECOND,
-  extend2Lev,
-  isArray,
-  includes,
-  isFunction,
-  isBoolean,
-  values
-} from './helper/tools'
-import { getCurrentSite } from './cookie'
-import { haveSameOrigin } from './helper/urlPolyfill'
-import { TraceType } from './helper/enums'
-var TRIM_REGIX = /^\s+|\s+$/g
-export var DEFAULT_CONFIGURATION = {
-  resourceSampleRate: 100,
-  sampleRate: 100,
-  flushTimeout: 30 * ONE_SECOND,
-  maxErrorsByMinute: 3000,
-  /**
-   * Logs intake limit
-   */
-  maxBatchSize: 50,
-  maxMessageSize: 256 * ONE_KILO_BYTE,
-  /**
-   * arbitrary value, byte precision not needed
-   */
-  requestErrorResponseLengthLimit: 32 * ONE_KILO_BYTE,
-
-  /**
-   * beacon payload max queue size implementation is 64kb
-   * ensure that we leave room for logs, rum and potential other users
-   */
-  batchBytesLimit: 16 * ONE_KILO_BYTE,
-  datakitUrl: '',
-  logsEndpoint: '',
-  traceType: TraceType.DDTRACE,
-  traceId128Bit: false,
-  trackInteractions: false, //是否开启交互action收集
-  allowedDDTracingOrigins: [], //废弃
-  allowedTracingOrigins:[], // 新增
-  isServiceSampling: false, // 是否不抛弃采样是数据， 采用在服务端菜样的方式
-  isJsBirdge: false,// 是否需要对webview 发送数据，需要装我们对应ios sdk
-  isLineProtocolToJson: false,
-  beforeSend: function (event) {},
-  isServerError: function(request) {return false}  // 判断请求是否为error 请求
-}
-function trim(str) {
-  return str.replace(TRIM_REGIX, '')
-}
-export function buildCookieOptions(userConfiguration) {
-  var cookieOptions = {}
-
-  cookieOptions.secure = mustUseSecureCookie(userConfiguration)
-  cookieOptions.crossSite = !!userConfiguration.useCrossSiteSessionCookie
-
-  if (!!userConfiguration.trackSessionAcrossSubdomains) {
-    cookieOptions.domain = getCurrentSite()
-  }
-
-  return cookieOptions
-}
-function getDatakitUrl(url) {
-  if (url.lastIndexOf('/') === url.length - 1) return trim(url) + 'v1/write/rum'
-  return trim(url) + '/v1/write/rum'
-}
-function getLogsEndPoint(url) {
-  if (url.lastIndexOf('/') === url.length - 1)
-    return trim(url) + 'v1/write/logging'
-  return trim(url) + '/v1/write/logging'
-}
-export function commonInit(userConfiguration, buildEnv) {
-  var enableExperimentalFeatures = isArray(
-    userConfiguration.enableExperimentalFeatures
-  )
-    ? userConfiguration.enableExperimentalFeatures
-    : []
-  var transportConfiguration = {
-    applicationId: userConfiguration.applicationId,
-    env: userConfiguration.env || '',
-    version: userConfiguration.version || '',
-    service: userConfiguration.service || 'browser',
-    sdkVersion: buildEnv.sdkVersion,
-    sdkName: buildEnv.sdkName,
-    datakitUrl: getDatakitUrl(
-      userConfiguration.datakitUrl || userConfiguration.datakitOrigin
-    ),
-    logsEndpoint: getLogsEndPoint(userConfiguration.datakitOrigin),
-    isEnabled: function(feature) {return includes(enableExperimentalFeatures, feature)},
-    cookieOptions: buildCookieOptions(userConfiguration)
-  }
-  if ('isJsBirdge' in userConfiguration) {
-    transportConfiguration.isJsBirdge = userConfiguration.isJsBirdge
-  }
-  if ('isLineProtocolToJson' in userConfiguration) {
-    transportConfiguration.isLineProtocolToJson = userConfiguration.isLineProtocolToJson
-  }
-  if ('allowedDDTracingOrigins' in userConfiguration) {
-    transportConfiguration.allowedTracingOrigins =
-      userConfiguration.allowedDDTracingOrigins
-  }
-  if ('allowedTracingOrigins' in userConfiguration) {
-    transportConfiguration.allowedTracingOrigins = userConfiguration.allowedTracingOrigins
-  }
-  if ('sampleRate' in userConfiguration) {
-    transportConfiguration.sampleRate = userConfiguration.sampleRate
-  }
-
-  if ('resourceSampleRate' in userConfiguration) {
-    transportConfiguration.resourceSampleRate =
-      userConfiguration.resourceSampleRate
-  }
-
-  if ('trackInteractions' in userConfiguration) {
-    transportConfiguration.trackInteractions = !!userConfiguration.trackInteractions
-  }
-  if ('isServerError' in userConfiguration && isFunction(userConfiguration.isServerError) && isBoolean(userConfiguration.isServerError())) {
-    transportConfiguration.isServerError = userConfiguration.isServerError
-  }
-  if ('traceId128Bit' in userConfiguration) {
-    transportConfiguration.traceId128Bit = !!userConfiguration.traceId128Bit
-  }
-  if ('traceType' in userConfiguration && hasTraceType(userConfiguration.traceType)) {
-    transportConfiguration.traceType = userConfiguration.traceType
-  }
-  if ('isServiceSampling' in userConfiguration && isBoolean(userConfiguration.isServiceSampling)) {
-    transportConfiguration.isServiceSampling = userConfiguration.isServiceSampling
-  }
-  return extend2Lev({}, DEFAULT_CONFIGURATION, transportConfiguration)
-}
-function hasTraceType(traceType) {
-  if (traceType && values(TraceType).indexOf(traceType) > -1) return true
-  return false
-}
-function mustUseSecureCookie(userConfiguration) {
-  return (
-    !!userConfiguration.useSecureSessionCookie ||
-    !!userConfiguration.useCrossSiteSessionCookie
-  )
-}
-
-export function isIntakeRequest(url, configuration) {
-  // return haveSameOrigin(url, configuration.datakitUrl)
-  var notTakeRequest = [configuration.datakitUrl]
-  if (configuration.logsEndpoint) {
-    notTakeRequest.push(configuration.logsEndpoint)
-  }
-  var isIntake = false
-  for(var _url of notTakeRequest) {
-    if (url.indexOf(_url) === 0) {
-      isIntake = true
-      break;
-    }
-  }
-  return isIntake
-}

package/src/errorCollection.js

@@ -1,170 +0,0 @@
-import {
-  toArray,
-  jsonStringify,
-  find,
-  clocksNow,
-  map,
-  extend
-} from './helper/tools'
-import {
-  ErrorSource,
-  formatUnknownError,
-  toStackTraceString,
-  formatErrorMessage,
-  createHandlingStack
-} from './helper/errorTools'
-import { computeStackTrace, subscribe, unsubscribe } from './tracekit'
-import { Observable } from './helper/observable'
-import { isIntakeRequest } from './configuration'
-import { RequestType, ErrorHandling } from './helper/enums'
-import { resetXhrProxy, startXhrProxy } from './xhrProxy'
-import { resetFetchProxy, startFetchProxy } from './fetchProxy'
-
-var errorObservable
-
-export function startAutomaticErrorCollection(configuration) {
-  if (!errorObservable) {
-    errorObservable = new Observable()
-    trackNetworkError(configuration, errorObservable)
-    startConsoleTracking(errorObservable)
-    startRuntimeErrorTracking(errorObservable)
-  }
-  return errorObservable
-}
-
-var originalConsoleError
-
-export function startConsoleTracking(errorObservable) {
-  originalConsoleError = console.error
-  console.error = function () {
-    originalConsoleError.apply(console, arguments)
-    const handlingStack = createHandlingStack()
-    errorObservable.notify(
-      extend({}, buildErrorFromParams(toArray(arguments), handlingStack), {
-        source: ErrorSource.CONSOLE,
-        startClocks: clocksNow(),
-        handling: ErrorHandling.HANDLED
-      })
-    )
-  }
-}
-
-function buildErrorFromParams(params, handlingStack) {
-  var firstErrorParam = find(params, function (param) {
-    return param instanceof Error
-  })
-  var message = ''
-  message = map(['console error:'].concat(params), function (param) {
-    return formatConsoleParameters(param)
-  }).join(' ')
-  return {
-    message: message,
-    stack: firstErrorParam
-      ? toStackTraceString(computeStackTrace(firstErrorParam))
-      : undefined,
-    handlingStack: handlingStack
-  }
-}
-
-export function stopConsoleTracking() {
-  console.error = originalConsoleError
-}
-
-function formatConsoleParameters(param) {
-  if (typeof param === 'string') {
-    return param
-  }
-  if (param instanceof Error) {
-    return formatErrorMessage(computeStackTrace(param))
-  }
-  return jsonStringify(param, undefined, 2)
-}
-
-var traceKitReportHandler
-
-export function startRuntimeErrorTracking(errorObservable) {
-  traceKitReportHandler = function (stackTrace, _, errorObject) {
-    var error = formatUnknownError(stackTrace, errorObject, 'Uncaught')
-    errorObservable.notify({
-      message: error.message,
-      stack: error.stack,
-      type: error.type,
-      source: ErrorSource.SOURCE,
-      startClocks: clocksNow(),
-      handling: ErrorHandling.UNHANDLED
-    })
-  }
-
-  subscribe(traceKitReportHandler)
-}
-
-export function stopRuntimeErrorTracking() {
-  unsubscribe(traceKitReportHandler)
-}
-
-export function trackNetworkError(configuration, errorObservable) {
-  startXhrProxy().onRequestComplete(function (context) {
-    handleCompleteRequest(RequestType.XHR, context)
-  })
-  startFetchProxy().onRequestComplete(function (context) {
-    handleCompleteRequest(RequestType.FETCH, context)
-  })
-
-  function handleCompleteRequest(type, request) {
-    if (
-      !isIntakeRequest(request.url, configuration) &&
-      !request.isAborted &&
-      (isRejected(request) || isServerError(request) || configuration.isServerError(request))
-    ) {
-      errorObservable.notify({
-        message: format(type) + ' error ' + request.method + ' ' + request.url,
-        resource: {
-          method: request.method,
-          statusCode: request.status,
-          url: request.url,
-          traceId: request.traceId,
-          spanId: request.spanId,
-        },
-        source: ErrorSource.NETWORK,
-        stack:
-          truncateResponse(request.response, configuration) || 'Failed to load',
-        startClocks: request.startClocks
-      })
-    }
-  }
-
-  return {
-    stop: () => {
-      resetXhrProxy()
-      resetFetchProxy()
-    }
-  }
-}
-
-function isRejected(request) {
-  return request.status === 0 && request.responseType !== 'opaque'
-}
-
-function isServerError(request) {
-  return request.status >= 500
-}
-
-function truncateResponse(response, configuration) {
-  if (
-    response &&
-    response.length > configuration.requestErrorResponseLengthLimit
-  ) {
-    return (
-      response.substring(0, configuration.requestErrorResponseLengthLimit) +
-      '...'
-    )
-  }
-  return response
-}
-
-function format(type) {
-  if (RequestType.XHR === type) {
-    return 'XHR'
-  }
-  return 'Fetch'
-}

package/src/fetchProxy.js

@@ -1,109 +0,0 @@
-import { each, relativeNow, clocksNow, elapsed } from './helper/tools'
-import { computeStackTrace } from './tracekit'
-import { toStackTraceString } from './helper/errorTools'
-import { normalizeUrl } from './helper/urlPolyfill'
-var fetchProxySingleton
-var originalFetch
-var beforeSendCallbacks = []
-var onRequestCompleteCallbacks = []
-
-export function startFetchProxy() {
-  if (!fetchProxySingleton) {
-    proxyFetch()
-    fetchProxySingleton = {
-      beforeSend: function (callback) {
-        beforeSendCallbacks.push(callback)
-      },
-      onRequestComplete: function (callback) {
-        onRequestCompleteCallbacks.push(callback)
-      }
-    }
-  }
-  return fetchProxySingleton
-}
-
-export function resetFetchProxy() {
-  if (fetchProxySingleton) {
-    fetchProxySingleton = undefined
-    beforeSendCallbacks.splice(0, beforeSendCallbacks.length)
-    onRequestCompleteCallbacks.splice(0, onRequestCompleteCallbacks.length)
-    window.fetch = originalFetch
-  }
-}
-function proxyFetch() {
-  if (!window.fetch) {
-    return
-  }
-
-  originalFetch = window.fetch
-
-  window.fetch = function (input, init) {
-    var responsePromise
-    var context = beforeSend.apply(null, [input, init])
-    if (context) {
-      responsePromise = originalFetch.call(this, context.input, context.init)
-      afterSend.apply(null, [responsePromise, context])
-    } else {
-      responsePromise = originalFetch.call(this, input, init)
-    }
-
-    return responsePromise
-  }
-}
-
-function beforeSend(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 = {
-    init: init,
-    input: input,
-    method: method,
-    startTime: relativeNow(),
-    startClocks: startClocks,
-    url: url
-  }
-  each(beforeSendCallbacks, function (callback) {
-    callback(context)
-  })
-
-  return context
-}
-
-function afterSend(responsePromise, context) {
-  var reportFetch = async function (response) {
-    context.duration = elapsed(context.startClocks.relative, relativeNow())
-
-    if ('stack' in response || response instanceof Error) {
-      context.status = 0
-      context.response = toStackTraceString(computeStackTrace(response))
-      context.headers = response.headers
-      context.isAborted =
-        response instanceof DOMException &&
-        response.code === DOMException.ABORT_ERR
-      each(onRequestCompleteCallbacks, function (callback) {
-        callback(context)
-      })
-    } else if ('status' in response) {
-      var text
-      try {
-        text = await response.clone().text()
-      } catch (e) {
-        text = 'Unable to retrieve response: ' + e
-      }
-      context.response = text
-      context.responseType = response.type
-      context.status = response.status
-      context.headers = response.headers
-      context.isAborted = false
-      each(onRequestCompleteCallbacks, function (callback) {
-        callback(context)
-      })
-    }
-  }
-  responsePromise.then(reportFetch, reportFetch)
-}

package/src/helper/errorFilter.js

@@ -1,38 +0,0 @@
-import { ErrorSource } from './errorTools'
-import { ONE_MINUTE, clocksNow } from './tools'
-
-export function createErrorFilter(configuration, onLimitReached) {
-  var errorCount = 0
-  var allowNextError = false
-
-  return {
-    isLimitReached: function () {
-      if (errorCount === 0) {
-        setTimeout(function () {
-          errorCount = 0
-        }, ONE_MINUTE)
-      }
-
-      errorCount += 1
-      if (errorCount <= configuration.maxErrorsByMinute || allowNextError) {
-        allowNextError = false
-        return false
-      }
-
-      if (errorCount === configuration.maxErrorsByMinute + 1) {
-        allowNextError = true
-        try {
-          onLimitReached({
-            message: `Reached max number of errors by minute: ${configuration.maxErrorsByMinute}`,
-            source: ErrorSource.AGENT,
-            startClocks: clocksNow()
-          })
-        } finally {
-          allowNextError = false
-        }
-      }
-
-      return true
-    }
-  }
-}