@cloudcare/browser-core 3.0.23 → 3.1.0

package/src/helper/enums.js

@@ -86,3 +86,7 @@ export var ErrorHandling = {
   HANDLED: 'handled',
   UNHANDLED: 'unhandled'
 }
+export var NonErrorPrefix = {
+  UNCAUGHT: 'Uncaught',
+  PROVIDED: 'Provided'
+}

package/src/helper/errorTools.js

@@ -1,7 +1,9 @@
 import { each, noop } from './tools'
 import { jsonStringify } from '../helper/serialisation/jsonStringify'
 import { computeStackTrace } from '../tracekit'
-
+import { callMonitored } from '../helper/monitor'
+export var NO_ERROR_STACK_PRESENT_MESSAGE =
+  'No stack, consider using an instance of Error'
 export var ErrorSource = {
   AGENT: 'agent',
   CONSOLE: 'console',
@@ -19,34 +21,62 @@ export function computeRawError(data) {
   var nonErrorPrefix = data.nonErrorPrefix
   var source = data.source
   var handling = data.handling
-  if (
-    !stackTrace ||
-    (stackTrace.message === undefined && !(originalError instanceof Error))
-  ) {
-    return {
-      startClocks: startClocks,
-      source: source,
-      handling: handling,
-      originalError: originalError,
-      message: nonErrorPrefix + ' ' + jsonStringify(originalError),
-      stack: 'No stack, consider using an instance of Error',
-      handlingStack: handlingStack,
-      type: stackTrace && stackTrace.name
-    }
-  }
+  var isErrorInstance = originalError instanceof Error
+  var message = computeMessage(
+    stackTrace,
+    isErrorInstance,
+    nonErrorPrefix,
+    originalError
+  )
+  var stack = hasUsableStack(isErrorInstance, stackTrace)
+    ? toStackTraceString(stackTrace)
+    : NO_ERROR_STACK_PRESENT_MESSAGE
+  var causes = isErrorInstance
+    ? flattenErrorCauses(originalError, source)
+    : undefined
+  var type = stackTrace && stackTrace.name
 
   return {
     startClocks: startClocks,
     source: source,
     handling: handling,
     originalError: originalError,
-    message: stackTrace.message || 'Empty message',
-    stack: toStackTraceString(stackTrace),
+    message: message,
+    stack: stack,
     handlingStack: handlingStack,
-    type: stackTrace.name,
-    causes: flattenErrorCauses(originalError, source)
+    type: type,
+    causes: causes
   }
 }
+function computeMessage(
+  stackTrace,
+  isErrorInstance,
+  nonErrorPrefix,
+  originalError
+) {
+  // Favor stackTrace message only if tracekit has really been able to extract something meaningful (message + name)
+  // TODO rework tracekit integration to avoid scattering error building logic
+  return stackTrace && stackTrace.message && stackTrace && stackTrace.name
+    ? stackTrace.message
+    : !isErrorInstance
+    ? nonErrorPrefix + ' ' + jsonStringify(sanitize(originalError))
+    : 'Empty message'
+}
+function hasUsableStack(isErrorInstance, stackTrace) {
+  if (stackTrace === undefined) {
+    return false
+  }
+  if (isErrorInstance) {
+    return true
+  }
+  // handle cases where tracekit return stack = [] or stack = [{url: undefined, line: undefined, column: undefined}]
+  // TODO rework tracekit integration to avoid generating those unusable stack
+  return (
+    stackTrace.stack.length > 0 &&
+    (stackTrace.stack.length > 1 || stackTrace.stack[0].url !== undefined)
+  )
+}
+
 export function formatUnknownError(
   stackTrace,
   errorObject,
@@ -97,10 +127,11 @@ export function createHandlingStack() {
       noop()
     }
   }
-
-  var stackTrace = computeStackTrace(error)
-  stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip)
-  formattedStack = toStackTraceString(stackTrace)
+  callMonitored(function () {
+    var stackTrace = computeStackTrace(error)
+    stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip)
+    formattedStack = toStackTraceString(stackTrace)
+  })
 
   return formattedStack
 }

package/src/helper/instrumentMethod.js

@@ -1,5 +1,6 @@
 import { noop } from './tools'
 import { setTimeout } from './timer'
+import { callMonitored } from './monitor'
 export function instrumentMethod(object, method, instrumentationFactory) {
   var original = object[method]
 
@@ -29,14 +30,16 @@ export function instrumentMethodAndCallOriginal(object, method, aliasOption) {
     return function () {
       var result
       if (aliasOption && aliasOption.before) {
-        aliasOption.before.apply(this, arguments)
+        callMonitored(aliasOption.before, this, arguments)
+        // aliasOption.before.apply(this, arguments)
       }
       if (typeof original === 'function') {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         result = original.apply(this, arguments)
       }
       if (aliasOption && aliasOption.after) {
-        aliasOption.after.apply(this, arguments)
+        callMonitored(aliasOption.after, this, arguments)
+        // aliasOption.after.apply(this, arguments)
       }
       return result
     }

package/src/helper/monitor.js

@@ -0,0 +1,44 @@
+import { ConsoleApiName, display } from './display'
+var onMonitorErrorCollected
+var debugMode = false
+
+export function startMonitorErrorCollection(newOnMonitorErrorCollected) {
+  onMonitorErrorCollected = newOnMonitorErrorCollected
+}
+
+export function setDebugMode(newDebugMode) {
+  debugMode = newDebugMode
+}
+
+export function resetMonitor() {
+  onMonitorErrorCollected = undefined
+  debugMode = false
+}
+
+export function monitor(fn) {
+  return function () {
+    return callMonitored(fn, this, arguments)
+  }
+}
+
+export function callMonitored(fn, context, args) {
+  try {
+    return fn.apply(context, args)
+  } catch (e) {
+    displayIfDebugEnabled(ConsoleApiName.error, e)
+    if (onMonitorErrorCollected) {
+      try {
+        onMonitorErrorCollected(e)
+      } catch (e) {
+        displayIfDebugEnabled(ConsoleApiName.error, e)
+      }
+    }
+  }
+}
+
+export function displayIfDebugEnabled(api) {
+  var args = [].slice.call(arguments, 1)
+  if (debugMode) {
+    display.apply(null, [api, '[MONITOR]'].concat(args))
+  }
+}

package/src/helper/observable.js

@@ -12,14 +12,14 @@ _Observable.prototype = {
     this.observers.push(f)
     var _this = this
     return {
-      unsubscribe: function() {
-        _this.observers = filter(_this.observers, function(other) {
+      unsubscribe: function () {
+        _this.observers = filter(_this.observers, function (other) {
           return f !== other
         })
         if (!_this.observers.length && _this.onLastUnsubscribe) {
           _this.onLastUnsubscribe()
         }
-      },
+      }
     }
   },
   notify: function (data) {
@@ -32,12 +32,14 @@ export var Observable = _Observable
 
 export function mergeObservables() {
   var observables = [].slice.call(arguments)
-  var globalObservable = new Observable(function(){
-    var subscriptions = map(observables, function(observable) {
-     return observable.subscribe(function(data) { return globalObservable.notify(data) })
+  var globalObservable = new Observable(function () {
+    var subscriptions = map(observables, function (observable) {
+      return observable.subscribe(function (data) {
+        return globalObservable.notify(data)
+      })
     })
-    return function() {
-      return each(subscriptions, function(subscription) {
+    return function () {
+      return each(subscriptions, function (subscription) {
         return subscription.unsubscribe()
       })
     }

package/src/helper/readBytesFromStream.js

@@ -1,5 +1,5 @@
 import { noop, each } from './tools'
-
+import { monitor } from './monitor'
 /**
  * Read bytes from a ReadableStream until at least `limit` bytes have been read (or until the end of
  * the stream). The callback is invoked with the at most `limit` bytes, and indicates that the limit
@@ -14,7 +14,7 @@ export function readBytesFromStream(stream, callback, options) {
 
   function readMore() {
     reader.read().then(
-      function (result) {
+      monitor(function (result) {
         if (result.done) {
           onDone()
           return
@@ -30,10 +30,10 @@ export function readBytesFromStream(stream, callback, options) {
         } else {
           readMore()
         }
-      },
-      function (error) {
+      }),
+      monitor(function (error) {
         callback(error)
-      }
+      })
     )
   }
 

package/src/helper/timer.js

@@ -1,9 +1,9 @@
 import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
 import { getGlobalObject } from '../init'
-
+import { monitor } from './monitor'
 export function setTimeout(callback, delay) {
   return getZoneJsOriginalValue(getGlobalObject(), 'setTimeout')(
-    callback,
+    monitor(callback),
     delay
   )
 }
@@ -13,7 +13,7 @@ export function clearTimeout(timeoutId) {
 }
 
 export function setInterval(callback, delay) {
-  return getZoneJsOriginalValue(window, 'setInterval')(callback, delay)
+  return getZoneJsOriginalValue(window, 'setInterval')(monitor(callback), delay)
 }
 
 export function clearInterval(timeoutId) {

package/src/helper/tools.js

@@ -232,6 +232,7 @@ export var matchList = function (list, value, useStartsWith) {
 }
 // https://github.com/jquery/jquery/blob/a684e6ba836f7c553968d7d026ed7941e1a612d8/src/selector/escapeSelector.js
 export var cssEscape = function (str) {
+  str = str + ''
   if (window.CSS && window.CSS.escape) {
     return window.CSS.escape(str)
   }
@@ -1649,23 +1650,6 @@ export function isNullUndefinedDefaultValue(data, defaultValue) {
   }
 }
 
-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
-  // fallback on 'requestAnimationFrame' will still ensure the mutations are processed after any
-  // browser rendering process (Layout, Recalculate Style, etc.), so we can serialize DOM nodes
-  // efficiently.
-  if (window.requestIdleCallback) {
-    var id = window.requestIdleCallback(callback, opts)
-    return function () {
-      return window.cancelIdleCallback(id)
-    }
-  }
-  var id = window.requestAnimationFrame(callback)
-  return function () {
-    return window.cancelAnimationFrame(id)
-  }
-}
 export function objectHasValue(object, value) {
   return some(keys(object), function (key) {
     return object[key] === value
@@ -1689,6 +1673,7 @@ export function tryToClone(response) {
 }
 export function isHashAnAnchor(hash) {
   var correspondingId = hash.substr(1)
+  if (!correspondingId) return false
   return !!document.getElementById(correspondingId)
 }
 export function getPathFromHash(hash) {

package/src/index.js

@@ -9,6 +9,7 @@ export * from './error/trackRuntimeError'
 export * from './console/consoleObservable'
 export * from './report/reportObservable'
 export * from './helper/display'
+export * from './helper/monitor'
 export * from './helper/sanitize'
 export * from './helper/eventEmitter'
 export * from './helper/lifeCycle'
@@ -31,6 +32,7 @@ export * from './browser/pageExitObservable'
 export * from './browser/htmlDomUtils'
 export * from './browser/addEventListener'
 export * from './browser/runOnReadyState'
+export * from './browser/scroll'
 
 export * from './dataMap'
 export * from './init'
@@ -46,3 +48,5 @@ export * from './helper/serialisation/heavyCustomerDataWarning'
 export * from './helper/serialisation/jsonStringify'
 export * from './helper/serialisation/rowData'
 export * from './user'
+
+export * from './telemetry/telemetry'

package/src/init.js

@@ -1,27 +1,25 @@
-import { extend, each } from './helper/tools'
-export function makeGlobal(stub) {
-  var global = extend({}, stub, {
-    onReady: function (callback) {
-      callback()
-    }
-  })
-  return global
-}
+import { each, assign } from './helper/tools'
+import { setDebugMode } from './helper/monitor'
+import { catchUserErrors } from './helper/catchUserErrors'
+
 export function makePublicApi(stub) {
-  var publicApi = extend({}, stub, {
-    onReady: function (callback) {
-      callback()
-    }
-  })
+  var publicApi = assign(
+    {
+      onReady: function (callback) {
+        callback()
+      }
+    },
+    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
 }
@@ -30,7 +28,7 @@ export function defineGlobal(global, name, api) {
   global[name] = api
   if (existingGlobalVariable && existingGlobalVariable.q) {
     each(existingGlobalVariable.q, function (fn) {
-      fn()
+      catchUserErrors(fn, 'onReady callback threw an error:')()
     })
   }
 }

package/src/report/reportObservable.js

@@ -3,16 +3,17 @@ import { mergeObservables, Observable } from '../helper/observable'
 import { includes, safeTruncate, filter, each } from '../helper/tools'
 import { addEventListener } from '../browser/addEventListener'
 import { DOM_EVENT } from '../helper/enums'
+import { monitor } from '../helper/monitor'
 export var RawReportType = {
   intervention: 'intervention',
   deprecation: 'deprecation',
   cspViolation: 'csp_violation'
 }
-export function initReportObservable(apis) {
+export function initReportObservable(configuration, apis) {
   var observables = []
 
   if (includes(apis, RawReportType.cspViolation)) {
-    observables.push(createCspViolationReportObservable())
+    observables.push(createCspViolationReportObservable(configuration))
   }
 
   var reportTypes = filter(apis, function (api) {
@@ -30,11 +31,11 @@ function createReportObservable(reportTypes) {
       return
     }
 
-    var handleReports = function (reports) {
+    var handleReports = monitor(function (reports) {
       each(reports, function (report) {
         observable.notify(buildRawReportFromReport(report))
       })
-    }
+    })
 
     var observer = new window.ReportingObserver(handleReports, {
       types: reportTypes,
@@ -50,7 +51,7 @@ function createReportObservable(reportTypes) {
   return observable
 }
 
-function createCspViolationReportObservable() {
+function createCspViolationReportObservable(configuration) {
   var observable = new Observable(function () {
     var handleCspViolation = function (event) {
       observable.notify(buildRawReportFromCspViolation(event))

package/src/telemetry/telemetry.js

@@ -0,0 +1,164 @@
+import { ConsoleApiName } from '../helper/display'
+import {
+  toStackTraceString,
+  NO_ERROR_STACK_PRESENT_MESSAGE
+} from '../helper/errorTools'
+import { computeStackTrace } from '../tracekit'
+import { Observable } from '../helper/observable'
+import {
+  displayIfDebugEnabled,
+  startMonitorErrorCollection
+} from '..//helper/monitor'
+import {
+  startsWith,
+  assign,
+  performDraw,
+  timeStampNow,
+  extend2Lev
+} from '../helper/tools'
+import { jsonStringify } from '../helper/serialisation/jsonStringify'
+import { NonErrorPrefix } from '../helper/enums'
+import { TelemetryStatusType, TelemetryType } from './types'
+
+const ALLOWED_FRAME_URLS = [
+  'https://static.guance.com',
+  'http://localhost',
+  '<anonymous>'
+]
+
+export var TelemetryService = {
+  LOGS: 'browser-logs-sdk',
+  RUM: 'browser-rum-sdk'
+}
+
+var telemetryConfiguration = {
+  maxEventsPerPage: 0,
+  sentEventCount: 0,
+  telemetryEnabled: false
+}
+
+var onRawTelemetryEventCollected
+
+export function startTelemetry(telemetryService, configuration) {
+  let contextProvider
+  var observable = new Observable()
+  telemetryConfiguration.telemetryEnabled =
+    configuration.telemetryEnabled &&
+    performDraw(configuration.telemetrySampleRate)
+
+  onRawTelemetryEventCollected = function (rawEvent) {
+    if (telemetryConfiguration.telemetryEnabled) {
+      var event = toTelemetryEvent(telemetryService, rawEvent)
+      observable.notify(event)
+    }
+  }
+  startMonitorErrorCollection(addTelemetryError)
+
+  assign(telemetryConfiguration, {
+    maxEventsPerPage: configuration.maxTelemetryEventsPerPage,
+    sentEventCount: 0
+  })
+
+  function toTelemetryEvent(telemetryService, event) {
+    return extend2Lev(
+      {
+        type: 'telemetry',
+        date: timeStampNow(),
+        service: telemetryService,
+        version: __BUILD_ENV__SDK_VERSION__,
+        source: 'browser',
+        telemetry: event // https://github.com/microsoft/TypeScript/issues/48457
+      },
+      contextProvider !== undefined ? contextProvider() : {}
+    )
+  }
+
+  return {
+    setContextProvider: function (provider) {
+      contextProvider = provider
+    },
+    observable: observable,
+    enabled: telemetryConfiguration.telemetryEnabled
+  }
+}
+
+export function resetTelemetry() {
+  onRawTelemetryEventCollected = undefined
+}
+
+export function addTelemetryDebug(message, context) {
+  displayIfDebugEnabled(ConsoleApiName.debug, message, context)
+  addTelemetry(
+    assign(
+      {
+        type: TelemetryType.log,
+        message: message,
+        status: TelemetryStatusType.debug
+      },
+      context
+    )
+  )
+}
+
+export function addTelemetryError(e, context) {
+  addTelemetry(
+    assign(
+      {
+        type: TelemetryType.log,
+        status: TelemetryStatusType.error
+      },
+      formatError(e),
+      context
+    )
+  )
+}
+
+export function addTelemetryConfiguration(configuration) {
+  if (telemetryConfiguration.telemetryEnabled) {
+    addTelemetry({
+      type: TelemetryType.configuration,
+      configuration: configuration
+    })
+  }
+}
+
+function addTelemetry(event) {
+  if (
+    onRawTelemetryEventCollected &&
+    telemetryConfiguration.sentEventCount <
+      telemetryConfiguration.maxEventsPerPage
+  ) {
+    telemetryConfiguration.sentEventCount += 1
+    onRawTelemetryEventCollected(event)
+  }
+}
+
+export function formatError(e) {
+  if (e instanceof Error) {
+    var stackTrace = computeStackTrace(e)
+    return {
+      error: {
+        kind: stackTrace.name,
+        stack: toStackTraceString(scrubCustomerFrames(stackTrace))
+      },
+      message: stackTrace.message
+    }
+  }
+  return {
+    error: {
+      stack: NO_ERROR_STACK_PRESENT_MESSAGE
+    },
+    message: NonErrorPrefix.UNCAUGHT + ' ' + jsonStringify(e)
+  }
+}
+
+export function scrubCustomerFrames(stackTrace) {
+  stackTrace.stack = stackTrace.stack.filter(
+    (frame) =>
+      !frame.url ||
+      ALLOWED_FRAME_URLS.some(function (allowedFrameUrl) {
+        return startsWith(frame.url, allowedFrameUrl)
+      })
+  )
+  return stackTrace
+}

package/src/telemetry/types.js

@@ -0,0 +1,9 @@
+export var TelemetryType = {
+  log: 'log',
+  configuration: 'configuration'
+}
+
+export var TelemetryStatusType = {
+  debug: 'debug',
+  error: 'error'
+}

package/src/transport/batch.js

@@ -76,13 +76,13 @@ export var processedMessageByDataMap = function (message) {
         }
       })
       if (
-        message.tags &&
-        isObject(message.tags) &&
-        !isEmptyObject(message.tags)
+        message.context &&
+        isObject(message.context) &&
+        !isEmptyObject(message.context)
       ) {
         // 自定义tag， 存储成field
         var _tagKeys = []
-        each(message.tags, function (_value, _key) {
+        each(message.context, function (_value, _key) {
           // 如果和之前tag重名，则舍弃
           if (filterFileds.indexOf(_key) > -1) return
           filterFileds.push(_key)

package/src/transport/httpRequest.js

@@ -1,5 +1,6 @@
 import { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy'
 import { addEventListener } from '../browser/addEventListener'
+import { monitor } from '../helper/monitor'
 /**
  * Use POST request without content type to:
  * - avoid CORS preflight requests
@@ -74,15 +75,15 @@ export function fetchKeepAliveStrategy(
       keepalive: true,
       mode: 'cors'
     }).then(
-      function (response) {
+      monitor(function (response) {
         if (typeof onResponse === 'function') {
           onResponse({ status: response.status, type: response.type })
         }
-      },
-      function () {
+      }),
+      monitor(function () {
         // failed to queue the request
         sendXHR(url, data, onResponse)
-      }
+      })
     )
   } else {
     sendXHR(url, data, onResponse)