@cloudcare/browser-core 3.1.24 → 3.2.0

package/src/helper/boundedBuffer.js

@@ -1,22 +1,29 @@
-import { each } from './tools'
+import { removeItem } from './tools'
 var BUFFER_LIMIT = 500
+export function createBoundedBuffer() {
+  var buffer = []
 
-var _BoundedBuffer = function () {
-  this.buffer = []
-}
-_BoundedBuffer.prototype = {
-  add: function (callback) {
-    var length = this.buffer.push(callback)
+  var add = function (callback) {
+    var length = buffer.push(callback)
     if (length > BUFFER_LIMIT) {
-      this.buffer.splice(0, 1)
+      buffer.splice(0, 1)
     }
-  },
+  }
+
+  var remove = function (callback) {
+    removeItem(buffer, callback)
+  }
 
-  drain: function () {
-    each(this.buffer, function (callback) {
-      callback()
+  const drain = function (arg) {
+    buffer.forEach(function (callback) {
+      callback(arg)
     })
-    this.buffer.length = 0
+    buffer.length = 0
+  }
+
+  return {
+    add: add,
+    remove: add,
+    drain: drain
   }
 }
-export var BoundedBuffer = _BoundedBuffer

package/src/helper/connectivity.js

@@ -0,0 +1,11 @@
+export function getConnectivity() {
+  var navigator = window.navigator
+  return {
+    status: navigator.onLine ? 'connected' : 'not_connected',
+    interfaces:
+      navigator.connection && navigator.connection.type
+        ? [navigator.connection.type]
+        : undefined,
+    effective_type: navigator.connection?.effectiveType
+  }
+}

package/src/helper/display.js

@@ -1,21 +1,23 @@
-
 export var ConsoleApiName = {
   log: 'log',
   debug: 'debug',
   info: 'info',
   warn: 'warn',
-  error: 'error',
-}
-export var display = function(api) {
-  var args = [].slice.call(arguments, 1)
-  if (!Object.prototype.hasOwnProperty.call(ConsoleApiName, api)) {
-    api = ConsoleApiName.log
-  }
-  display[api].apply(display,args)
+  error: 'error'
 }
+export var globalConsole = console
+
+export var originalConsoleMethods = {}
+Object.keys(ConsoleApiName).forEach(function (name) {
+  originalConsoleMethods[name] = globalConsole[name]
+})
 
-display.debug = console.debug.bind(console)
-display.log = console.log.bind(console)
-display.info = console.info.bind(console)
-display.warn = console.warn.bind(console)
-display.error = console.error.bind(console)
+var PREFIX = 'GUANCE Browser SDK:'
+
+export var display = {
+  debug: originalConsoleMethods.debug.bind(globalConsole, PREFIX),
+  log: originalConsoleMethods.log.bind(globalConsole, PREFIX),
+  info: originalConsoleMethods.info.bind(globalConsole, PREFIX),
+  warn: originalConsoleMethods.warn.bind(globalConsole, PREFIX),
+  error: originalConsoleMethods.error.bind(globalConsole, PREFIX)
+}

package/src/helper/displayAlreadyInitializedError.js

@@ -0,0 +1,7 @@
+import { display } from './display'
+
+export function displayAlreadyInitializedError(sdkName, initConfiguration) {
+  if (!initConfiguration.silentMultipleInit) {
+    display.error(sdkName + ' is already initialized.')
+  }
+}

package/src/helper/encoder.js

@@ -0,0 +1,43 @@
+import { computeBytesCount } from './byteUtils'
+
+export function createIdentityEncoder() {
+  var output = ''
+  var outputBytesCount = 0
+
+  return {
+    isAsync: false,
+
+    isEmpty: function () {
+      return !output
+    },
+
+    write: function (data, callback) {
+      var additionalEncodedBytesCount = computeBytesCount(data)
+      outputBytesCount += additionalEncodedBytesCount
+      output += data
+      if (callback) {
+        callback(additionalEncodedBytesCount)
+      }
+    },
+
+    finish: function (callback) {
+      callback(this.finishSync())
+    },
+
+    finishSync: function () {
+      var result = {
+        output: output,
+        outputBytesCount: outputBytesCount,
+        rawBytesCount: outputBytesCount,
+        pendingData: ''
+      }
+      output = ''
+      outputBytesCount = 0
+      return result
+    },
+
+    estimateEncodedBytesCount: function (data) {
+      return data.length
+    }
+  }
+}

package/src/helper/lifeCycle.js

@@ -1,6 +1,5 @@
 import { each, filter } from './tools'
 export var LifeCycleEventType = {
-  PERFORMANCE_ENTRIES_COLLECTED: 'PERFORMANCE_ENTRIES_COLLECTED',
   AUTO_ACTION_COMPLETED: 'AUTO_ACTION_COMPLETED',
   BEFORE_VIEW_CREATED: 'BEFORE_VIEW_CREATED',
   VIEW_CREATED: 'VIEW_CREATED',

package/src/helper/monitor.js

@@ -25,21 +25,21 @@ export function callMonitored(fn, context, args) {
   try {
     return fn.apply(context, args)
   } catch (e) {
-    displayIfDebugEnabled(ConsoleApiName.error, e)
+    displayIfDebugEnabled(e)
     if (onMonitorErrorCollected) {
       try {
         onMonitorErrorCollected(e)
       } catch (e) {
-        displayIfDebugEnabled(ConsoleApiName.error, e)
+        displayIfDebugEnabled(e)
       }
     }
   }
 }
 
-export function displayIfDebugEnabled(api) {
-  var args = [].slice.call(arguments, 1)
-  //   display.apply(null, [api, '[MONITOR]'].concat(args))
+export function displayIfDebugEnabled() {
+  var args = [].slice.call(arguments)
+  //   display.error.apply(null, ['[MONITOR]'].concat(args))
   if (debugMode) {
-    display.apply(null, [api, '[MONITOR]'].concat(args))
+    display.error.apply(null, ['[MONITOR]'].concat(args))
   }
 }

package/src/helper/serialisation/jsonStringify.js

@@ -39,7 +39,7 @@ export function detachToJsonMethod(value) {
   const objectToJson = object.toJSON
   if (objectToJson) {
     delete object.toJSON
-    return () => {
+    return function () {
       object.toJSON = objectToJson
     }
   }

package/src/index.js

@@ -48,7 +48,10 @@ export * from './helper/serialisation/heavyCustomerDataWarning'
 export * from './helper/serialisation/jsonStringify'
 export * from './helper/serialisation/rowData'
 export * from './helper/serialisation/storedContextManager'
+export * from './helper/encoder'
 export * from './user'
 export * from './helper/polyfills'
 export * from './telemetry/telemetry'
 export * from './helper/catchUserErrors'
+export * from './helper/connectivity'
+export * from './helper/displayAlreadyInitializedError'

package/src/report/reportObservable.js

@@ -1,6 +1,13 @@
 import { toStackTraceString } from '../helper/errorTools'
 import { mergeObservables, Observable } from '../helper/observable'
-import { includes, safeTruncate, filter, each } from '../helper/tools'
+import {
+  includes,
+  safeTruncate,
+  filter,
+  each,
+  assign,
+  clocksNow
+} from '../helper/tools'
 import { addEventListener } from '../browser/addEventListener'
 import { DOM_EVENT } from '../helper/enums'
 import { monitor } from '../helper/monitor'
@@ -33,7 +40,7 @@ function createReportObservable(reportTypes) {
 
     var handleReports = monitor(function (reports) {
       each(reports, function (report) {
-        observable.notify(buildRawReportFromReport(report))
+        observable.notify(buildRawReportErrorFromReport(report))
       })
     })
 
@@ -47,34 +54,29 @@ function createReportObservable(reportTypes) {
       observer.disconnect()
     }
   })
-
-  return observable
 }
 
 function createCspViolationReportObservable(configuration) {
   return new Observable(function (observable) {
-    var handleCspViolation = function (event) {
-      observable.notify(buildRawReportFromCspViolation(event))
-    }
-
     var _addEventListener = addEventListener(
       document,
       DOM_EVENT.SECURITY_POLICY_VIOLATION,
-      handleCspViolation
+      function (event) {
+        observable.notify(buildRawReportErrorFromCspViolation(event))
+      }
     )
 
     return _addEventListener.stop
   })
-  return observable
 }
 
-function buildRawReportFromReport(report) {
+function buildRawReportErrorFromReport(report) {
   var body = report.body
   var type = report.type
-  return {
-    type: type,
-    subtype: body.id,
+  return buildRawReportError({
+    type: body.id,
     message: type + ': ' + body.message,
+    originalError: report,
     stack: buildStack(
       body.id,
       body.message,
@@ -82,32 +84,46 @@ function buildRawReportFromReport(report) {
       body.lineNumber,
       body.columnNumber
     )
-  }
+  })
 }
-
-function buildRawReportFromCspViolation(event) {
-  var type = RawReportType.cspViolation
+function buildRawReportError(partial) {
+  return assign(
+    {
+      startClocks: clocksNow(),
+      source: ErrorSource.REPORT,
+      handling: ErrorHandling.UNHANDLED
+    },
+    partial
+  )
+}
+function buildRawReportErrorFromCspViolation(event) {
   var message =
     "'" +
     event.blockedURI +
     "' blocked by '" +
     event.effectiveDirective +
     "' directive"
-  return {
-    type: RawReportType.cspViolation,
-    subtype: event.effectiveDirective,
-    message: type + ': ' + message,
+  return buildRawReportError({
+    type: event.effectiveDirective,
+    message: RawReportType.cspViolation + ': ' + message,
+    originalError: event,
+    csp: {
+      disposition: event.disposition
+    },
     stack: buildStack(
       event.effectiveDirective,
-      message +
-        ' of the policy "' +
-        safeTruncate(event.originalPolicy, 100, '...') +
-        '"',
+      event.originalPolicy
+        ? `${message} of the policy "${safeTruncate(
+            event.originalPolicy,
+            100,
+            '...'
+          )}"`
+        : 'no policy',
       event.sourceFile,
       event.lineNumber,
       event.columnNumber
     )
-  }
+  })
 }
 
 function buildStack(name, message, sourceFile, lineNumber, columnNumber) {

package/src/telemetry/telemetry.js

@@ -3,8 +3,10 @@ import {
   toStackTraceString,
   NO_ERROR_STACK_PRESENT_MESSAGE
 } from '../helper/errorTools'
+import { createBoundedBuffer } from '../helper/boundedBuffer'
 import { computeStackTrace } from '../tracekit'
 import { Observable } from '../helper/observable'
+import { getConnectivity } from '../helper/connectivity'
 import {
   displayIfDebugEnabled,
   startMonitorErrorCollection
@@ -31,35 +33,37 @@ export var TelemetryService = {
   RUM: 'browser-rum-sdk'
 }
 
-var telemetryConfiguration = {
-  maxEventsPerPage: 0,
-  sentEventCount: 0,
-  telemetryEnabled: false
+// eslint-disable-next-line local-rules/disallow-side-effects
+var preStartTelemetryBuffer = createBoundedBuffer()
+var onRawTelemetryEventCollected = function (event) {
+  preStartTelemetryBuffer.add(function () {
+    onRawTelemetryEventCollected(event)
+  })
 }
 
-var onRawTelemetryEventCollected
-
 export function startTelemetry(telemetryService, configuration) {
   let contextProvider
   var observable = new Observable()
-  telemetryConfiguration.telemetryEnabled =
+  const alreadySentEvents = new Set()
+  const telemetryEnabled =
     configuration.telemetryEnabled &&
     performDraw(configuration.telemetrySampleRate)
-
+  const runtimeEnvInfo = getRuntimeEnvInfo()
   onRawTelemetryEventCollected = function (rawEvent) {
-    if (telemetryConfiguration.telemetryEnabled) {
-      var event = toTelemetryEvent(telemetryService, rawEvent)
+    const stringifiedEvent = jsonStringify(rawEvent)
+    if (
+      telemetryEnabled &&
+      alreadySentEvents.size < configuration.maxTelemetryEventsPerPage &&
+      !alreadySentEvents.has(stringifiedEvent)
+    ) {
+      var event = toTelemetryEvent(telemetryService, rawEvent, runtimeEnvInfo)
       observable.notify(event)
+      alreadySentEvents.add(stringifiedEvent)
     }
   }
   startMonitorErrorCollection(addTelemetryError)
 
-  assign(telemetryConfiguration, {
-    maxEventsPerPage: configuration.maxTelemetryEventsPerPage,
-    sentEventCount: 0
-  })
-
-  function toTelemetryEvent(telemetryService, event) {
+  function toTelemetryEvent(telemetryService, event, runtimeEnvInfo) {
     return extend2Lev(
       {
         type: 'telemetry',
@@ -67,7 +71,10 @@ export function startTelemetry(telemetryService, configuration) {
         service: telemetryService,
         version: __BUILD_ENV__SDK_VERSION__,
         source: 'browser',
-        telemetry: event // https://github.com/microsoft/TypeScript/issues/48457
+        telemetry: extend2Lev(event, {
+          runtime_env: runtimeEnvInfo,
+          connectivity: getConnectivity()
+        })
       },
       contextProvider !== undefined ? contextProvider() : {}
     )
@@ -78,17 +85,39 @@ export function startTelemetry(telemetryService, configuration) {
       contextProvider = provider
     },
     observable: observable,
-    enabled: telemetryConfiguration.telemetryEnabled
+    enabled: telemetryEnabled
   }
 }
+function getRuntimeEnvInfo() {
+  return {
+    is_local_file: window.location.protocol === 'file:',
+    is_worker: 'WorkerGlobalScope' in self
+  }
+}
+export function startFakeTelemetry() {
+  const events = []
+
+  onRawTelemetryEventCollected = function (event) {
+    events.push(event)
+  }
 
+  return events
+}
+export function drainPreStartTelemetry() {
+  preStartTelemetryBuffer.drain()
+}
 export function resetTelemetry() {
-  onRawTelemetryEventCollected = undefined
+  preStartTelemetryBuffer = createBoundedBuffer()
+  onRawTelemetryEventCollected = function (event) {
+    preStartTelemetryBuffer.add(function () {
+      onRawTelemetryEventCollected(event)
+    })
+  }
 }
 
 export function addTelemetryDebug(message, context) {
-  displayIfDebugEnabled(ConsoleApiName.debug, message, context)
-  addTelemetry(
+  displayIfDebugEnabled(message, context)
+  onRawTelemetryEventCollected(
     assign(
       {
         type: TelemetryType.log,
@@ -101,7 +130,7 @@ export function addTelemetryDebug(message, context) {
 }
 
 export function addTelemetryError(e, context) {
-  addTelemetry(
+  onRawTelemetryEventCollected(
     assign(
       {
         type: TelemetryType.log,
@@ -114,23 +143,17 @@ export function addTelemetryError(e, context) {
 }
 
 export function addTelemetryConfiguration(configuration) {
-  if (telemetryConfiguration.telemetryEnabled) {
-    addTelemetry({
-      type: TelemetryType.configuration,
-      configuration: configuration
-    })
-  }
+  onRawTelemetryEventCollected({
+    type: TelemetryType.configuration,
+    configuration: configuration
+  })
 }
 
-function addTelemetry(event) {
-  if (
-    onRawTelemetryEventCollected &&
-    telemetryConfiguration.sentEventCount <
-      telemetryConfiguration.maxEventsPerPage
-  ) {
-    telemetryConfiguration.sentEventCount += 1
-    onRawTelemetryEventCollected(event)
-  }
+export function addTelemetryUsage(usage) {
+  onRawTelemetryEventCollected({
+    type: TelemetryType.usage,
+    usage: usage
+  })
 }
 
 export function formatError(e) {

package/src/telemetry/types.js

@@ -1,6 +1,7 @@
 export var TelemetryType = {
   log: 'log',
-  configuration: 'configuration'
+  configuration: 'configuration',
+  usage: 'usage'
 }
 
 export var TelemetryStatusType = {