@cloudcare/browser-logs 3.1.23 → 3.2.0

package/src/boot/logsPublicApi.js

@@ -1,81 +1,30 @@
 import {
-  BoundedBuffer,
   createContextManager,
   makePublicApi,
   CustomerDataType,
-  display,
-  deepClone,
-  timeStampNow,
   checkUser,
   sanitizeUser,
   monitor,
-  storeContextManager
+  storeContextManager,
+  displayAlreadyInitializedError,
+  assign
 } from '@cloudcare/browser-core'
-import { validateAndBuildLogsConfiguration } from '../domain/configuration'
 import { Logger } from '../domain/logger'
+import { buildCommonContext } from '../domain/contexts/commonContext'
+import { createPreStartStrategy } from './preStartLogs'
 var LOGS_STORAGE_KEY = 'logs'
 export function makeLogsPublicApi(startLogsImpl) {
-  var isAlreadyInitialized = false
-
   var globalContextManager = createContextManager(
     CustomerDataType.GlobalContext
   )
   var userContextManager = createContextManager(CustomerDataType.User)
-  var customLoggers = {}
-  var getInternalContextStrategy = function () {
-    return undefined
-  }
-
-  var beforeInitLoggerLog = new BoundedBuffer()
-
-  var handleLogStrategy = function (
-    logsMessage,
-    logger,
-    savedCommonContext,
-    date
-  ) {
-    if (typeof savedCommonContext === 'undefined') {
-      savedCommonContext = deepClone(buildCommonContext())
-    }
-    if (typeof date === 'undefined') {
-      date = timeStampNow()
-    }
-    beforeInitLoggerLog.add(function () {
-      return handleLogStrategy(logsMessage, logger, savedCommonContext, date)
-    })
-  }
 
-  var getInitConfigurationStrategy = function () {
-    return undefined
+  function getCommonContext() {
+    return buildCommonContext(globalContextManager, userContextManager)
   }
-
-  var mainLogger = new Logger(function () {
-    return handleLogStrategy.apply(this, arguments)
-  })
-
-  function buildCommonContext() {
-    return {
-      view: {
-        referrer: document.referrer,
-        url: window.location.href
-      },
-      context: globalContextManager.getContext(),
-      user: userContextManager.getContext()
-    }
-  }
-
-  return makePublicApi({
-    logger: mainLogger,
-
-    init: monitor(function (initConfiguration) {
-      if (!canInitLogs(initConfiguration)) {
-        return
-      }
-
-      var configuration = validateAndBuildLogsConfiguration(initConfiguration)
-      if (!configuration) {
-        return
-      }
+  var strategy = createPreStartStrategy(
+    getCommonContext,
+    function (initConfiguration, configuration) {
       if (initConfiguration.storeContextsToLocal) {
         storeContextManager(
           configuration,
@@ -90,19 +39,28 @@ export function makeLogsPublicApi(startLogsImpl) {
           CustomerDataType.User
         )
       }
-      var _startLogsImpl = startLogsImpl(
+
+      var startLogsResult = startLogsImpl(
+        initConfiguration,
         configuration,
-        buildCommonContext,
-        mainLogger
+        getCommonContext
       )
-      handleLogStrategy = _startLogsImpl.handleLog
-      getInternalContextStrategy = _startLogsImpl.getInternalContext
-      getInitConfigurationStrategy = function () {
-        return deepClone(initConfiguration)
-      }
-      beforeInitLoggerLog.drain()
 
-      isAlreadyInitialized = true
+      strategy = createPostStartStrategy(initConfiguration, startLogsResult)
+      return startLogsResult
+    }
+  )
+  var customLoggers = {}
+
+  var mainLogger = new Logger(function () {
+    return strategy.handleLog.apply(this, arguments)
+  })
+
+  return makePublicApi({
+    logger: mainLogger,
+
+    init: monitor(function (initConfiguration) {
+      return strategy.init(initConfiguration)
     }),
 
     getGlobalContext: monitor(function () {
@@ -131,12 +89,12 @@ export function makeLogsPublicApi(startLogsImpl) {
       }
       customLoggers[name] = new Logger(
         function () {
-          return handleLogStrategy(this.arguments)
+          return strategy.handleLog.apply(this, arguments)
         },
-        name,
+        sanitize(name),
         conf.handler,
         conf.level,
-        conf.context
+        sanitize(conf.context)
       )
       return customLoggers[name]
     }),
@@ -146,11 +104,11 @@ export function makeLogsPublicApi(startLogsImpl) {
     }),
 
     getInitConfiguration: monitor(function () {
-      return getInitConfigurationStrategy()
+      return strategy.getInitConfiguration()
     }),
 
     getInternalContext: monitor(function (startTime) {
-      return getInternalContextStrategy(startTime)
+      return strategy.getInternalContext(startTime)
     }),
     setUser: monitor(function (newUser) {
       if (checkUser(newUser)) {
@@ -163,19 +121,27 @@ export function makeLogsPublicApi(startLogsImpl) {
     removeUserProperty: monitor(function (key) {
       return userContextManager.removeContextProperty(key)
     }),
+    setUserProperty: monitor(function (key, property) {
+      var newUser = {}
+      newUser[key] = property
+      var sanitizedProperty = sanitizeUser(newUser)[key]
+      userContextManager.setContextProperty(key, sanitizedProperty)
+    }),
     clearUser: monitor(function () {
       return userContextManager.clearContext()
     })
   })
-
-  function canInitLogs(initConfiguration) {
-    if (isAlreadyInitialized) {
-      if (!initConfiguration.silentMultipleInit) {
-        display.error('DD_LOGS is already initialized.')
+}
+function createPostStartStrategy(initConfiguration, startLogsResult) {
+  return assign(
+    {
+      init: function (initConfiguration) {
+        displayAlreadyInitializedError('DATAFLUX_LOGS', initConfiguration)
+      },
+      getInitConfiguration: function () {
+        return initConfiguration
       }
-      return false
-    }
-
-    return true
-  }
+    },
+    startLogsResult
+  )
 }

package/src/boot/preStartLogs.js

@@ -0,0 +1,94 @@
+import {
+  createBoundedBuffer,
+  assign,
+  canUseEventBridge,
+  display,
+  displayAlreadyInitializedError,
+  initFetchObservable,
+  noop,
+  timeStampNow
+} from '@cloudcare/browser-core'
+import { validateAndBuildLogsConfiguration } from '../domain/configuration'
+
+export function createPreStartStrategy(getCommonContext, doStartLogs) {
+  const bufferApiCalls = createBoundedBuffer()
+  let cachedInitConfiguration
+  let cachedConfiguration
+
+  function tryStartLogs() {
+    if (!cachedConfiguration || !cachedInitConfiguration) {
+      return
+    }
+
+    var startLogsResult = doStartLogs(
+      cachedInitConfiguration,
+      cachedConfiguration
+    )
+    bufferApiCalls.drain(startLogsResult)
+  }
+
+  return {
+    init: function (initConfiguration) {
+      if (!initConfiguration) {
+        display.error('Missing configuration')
+        return
+      }
+      // Set the experimental feature flags as early as possible, so we can use them in most places
+
+      if (canUseEventBridge()) {
+        initConfiguration =
+          overrideInitConfigurationForBridge(initConfiguration)
+      }
+
+      // Expose the initial configuration regardless of initialization success.
+      cachedInitConfiguration = initConfiguration
+
+      if (cachedConfiguration) {
+        displayAlreadyInitializedError('DATAFLUX_LOGS', initConfiguration)
+        return
+      }
+
+      const configuration = validateAndBuildLogsConfiguration(initConfiguration)
+      if (!configuration) {
+        return
+      }
+
+      cachedConfiguration = configuration
+      // Instrumuent fetch to track network requests
+      // This is needed in case the consent is not granted and some cutsomer
+      // library (Apollo Client) is storing uninstrumented fetch to be used later
+      // The subscrption is needed so that the instrumentation process is completed
+      initFetchObservable().subscribe(noop)
+
+      tryStartLogs()
+    },
+
+    getInitConfiguration: function () {
+      return cachedInitConfiguration
+    },
+
+    getInternalContext: noop,
+
+    handleLog: function (message, statusType, handlingStack, context, date) {
+      if (context === undefined) {
+        context = getCommonContext()
+      }
+      if (date === undefined) {
+        date = timeStampNow()
+      }
+      bufferApiCalls.add(function (startLogsResult) {
+        startLogsResult.handleLog(
+          message,
+          statusType,
+          handlingStack,
+          context,
+          date
+        )
+      })
+    }
+  }
+}
+
+function overrideInitConfigurationForBridge(initConfiguration) {
+  return assign({}, initConfiguration, { clientToken: 'empty' })
+}

package/src/boot/startLogs.js

@@ -1,13 +1,16 @@
 import {
-  ErrorSource,
   LifeCycle,
-  LifeCycleEventType,
   createPageExitObservable,
   areCookiesAuthorized,
+  willSyntheticsInjectRum,
   startTelemetry,
   startBatchWithReplica,
   canUseEventBridge,
-  TelemetryService
+  TelemetryService,
+  drainPreStartTelemetry,
+  createIdentityEncoder,
+  addTelemetryConfiguration,
+  deepClone
 } from '@cloudcare/browser-core'
 import {
   startLogsSessionManager,
@@ -20,60 +23,28 @@ import { startNetworkErrorCollection } from '../domain/logsCollection/networkErr
 import { startRuntimeErrorCollection } from '../domain/logsCollection/rumtimeError/runtimeErrorCollection'
 import { startLoggerCollection } from '../domain/logsCollection/logger/loggerCollection'
 import { startLogsBatch } from '../transport/startLogsBatch'
-import { StatusType } from '../domain/logger'
-import { startInternalContext } from '../domain/internalContext'
-
-export function startLogs(configuration, buildCommonContext, mainLogger) {
+import { startInternalContext } from '../domain/contexts/internalContext'
+import { startReportError } from '../domain/reportError'
+export function startLogs(initConfiguration, configuration, getCommonContext) {
   var lifeCycle = new LifeCycle()
-
-  var reportError = function (error) {
-    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
-      rawLogsEvent: {
-        message: error.message,
-        date: error.startClocks.timeStamp,
-        error: {
-          origin: ErrorSource.AGENT
-        },
-        origin: ErrorSource.AGENT,
-        status: StatusType.error
-      }
-    })
-  }
+  var cleanupTasks = []
+  var reportError = startReportError(lifeCycle)
   var pageExitObservable = createPageExitObservable()
-  var session = areCookiesAuthorized(configuration.cookieOptions)
-    ? startLogsSessionManager(configuration)
-    : startLogsSessionManagerStub(configuration)
+  var session =
+    areCookiesAuthorized(configuration.cookieOptions) &&
+    !canUseEventBridge() &&
+    !willSyntheticsInjectRum()
+      ? startLogsSessionManager(configuration)
+      : startLogsSessionManagerStub(configuration)
   const telemetry = startLogsTelemetry(
+    initConfiguration,
     configuration,
     reportError,
     pageExitObservable,
-    session.expireObservable
+    session
   )
-  telemetry.setContextProvider(function () {
-    var RUMInternalContext = getRUMInternalContext()
-    return {
-      application: {
-        id:
-          RUMInternalContext &&
-          RUMInternalContext.application &&
-          RUMInternalContext.application.id
-      },
-      session: {
-        id: session.findTrackedSession() && session.findTrackedSession().id
-      },
-      view: {
-        id:
-          RUMInternalContext &&
-          RUMInternalContext.view &&
-          RUMInternalContext.view.id
-      },
-      action: {
-        id:
-          RUMInternalContext &&
-          RUMInternalContext.userAction &&
-          RUMInternalContext.userAction.id
-      }
-    }
+  cleanupTasks.push(function () {
+    telemetry.stop()
   })
   startNetworkErrorCollection(configuration, lifeCycle)
   startRuntimeErrorCollection(configuration, lifeCycle)
@@ -85,45 +56,97 @@ export function startLogs(configuration, buildCommonContext, mainLogger) {
     session,
     configuration,
     lifeCycle,
-    buildCommonContext,
-    mainLogger,
+    getCommonContext,
     reportError
   )
   if (!canUseEventBridge()) {
-    startLogsBatch(
+    var _startLogsBatch = startLogsBatch(
       configuration,
       lifeCycle,
       reportError,
       pageExitObservable,
-      session.expireObservable
+      session
     )
+    cleanupTasks.push(function () {
+      _startLogsBatch.stop()
+    })
   }
 
   var internalContext = startInternalContext(session)
 
   return {
     handleLog: _startLoggerCollection.handleLog,
-    getInternalContext: internalContext.get
+    getInternalContext: internalContext.get,
+    stop: function () {
+      cleanupTasks.forEach(function (task) {
+        task()
+      })
+    }
   }
 }
 function startLogsTelemetry(
+  initConfiguration,
   configuration,
   reportError,
   pageExitObservable,
-  sessionExpireObservable
+  session
 ) {
   const telemetry = startTelemetry(TelemetryService.LOGS, configuration)
+  telemetry.setContextProvider(function () {
+    var RUMInternalContext = getRUMInternalContext()
+    return {
+      application: {
+        id:
+          RUMInternalContext &&
+          RUMInternalContext.application &&
+          RUMInternalContext.application.id
+      },
+      session: {
+        id: session.findTrackedSession() && session.findTrackedSession().id
+      },
+      view: {
+        id:
+          RUMInternalContext &&
+          RUMInternalContext.view &&
+          RUMInternalContext.view.id
+      },
+      action: {
+        id:
+          RUMInternalContext &&
+          RUMInternalContext.userAction &&
+          RUMInternalContext.userAction.id
+      }
+    }
+  })
+  var cleanupTasks = []
   if (!canUseEventBridge()) {
     var telemetryBatch = startBatchWithReplica(
       configuration,
-      configuration.rumEndpoint,
+      { endpoint: configuration.rumEndpoint, encoder: createIdentityEncoder() },
       reportError,
       pageExitObservable,
-      sessionExpireObservable
+      session.expireObservable
     )
-    telemetry.observable.subscribe(function (event) {
+    cleanupTasks.push(function () {
+      telemetryBatch.stop()
+    })
+    var telemetrySubscription = telemetry.observable.subscribe(function (
+      event
+    ) {
       telemetryBatch.add(event)
     })
+    cleanupTasks.push(function () {
+      telemetrySubscription.unsubscribe()
+    })
+  }
+  drainPreStartTelemetry()
+  addTelemetryConfiguration(deepClone(initConfiguration))
+  return {
+    telemetry: telemetry,
+    stop: function () {
+      cleanupTasks.forEach(function (task) {
+        task()
+      })
+    }
   }
-  return telemetry
 }

package/src/domain/assembly.js

@@ -12,15 +12,13 @@ import {
   isNullUndefinedDefaultValue
 } from '@cloudcare/browser-core'
 
-import { STATUSES, HandlerType } from './logger'
-import { isAuthorized } from './logsCollection/logger/loggerCollection'
+import { STATUSES } from './logger'
 
 export function startLogsAssembly(
   sessionManager,
   configuration,
   lifeCycle,
-  buildCommonContext,
-  mainLogger,
+  getCommonContext,
   reportError
 ) {
   var statusWithCustom = STATUSES.concat(['custom'])
@@ -33,18 +31,17 @@ export function startLogsAssembly(
     )
   })
   lifeCycle.subscribe(LifeCycleEventType.RAW_LOG_COLLECTED, function (data) {
-    // { rawLogsEvent, messageContext = undefined, savedCommonContext = undefined, logger = mainLogger }
     var rawLogsEvent = data.rawLogsEvent
     var messageContext = data.messageContext || undefined
     var savedCommonContext = data.savedCommonContext || undefined
-    var logger = data.logger || mainLogger
+    var domainContext = data.domainContext
     var startTime = getRelativeTime(rawLogsEvent.date)
     var session = sessionManager.findTrackedSession(startTime)
 
     if (!session) {
       return
     }
-    var commonContext = savedCommonContext || buildCommonContext()
+    var commonContext = savedCommonContext || getCommonContext()
     var log = extend2Lev(
       {
         service: configuration.service || 'browser',
@@ -67,15 +64,13 @@ export function startLogsAssembly(
       commonContext.context,
       getRUMInternalContext(startTime),
       rawLogsEvent,
-      logger.getContext(),
       messageContext
     )
 
     if (
-      !isAuthorized(rawLogsEvent.status, HandlerType.http, logger) ||
-      (configuration.beforeSend && configuration.beforeSend(log) === false) ||
-      (log.error &&
-        log.error.origin !== ErrorSource.AGENT &&
+      (configuration.beforeSend &&
+        configuration.beforeSend(log, domainContext) === false) ||
+      (log.origin !== ErrorSource.AGENT &&
         isNullUndefinedDefaultValue(
           logRateLimiters[log.status],
           logRateLimiters['custom']

package/src/domain/contexts/commonContext.js

@@ -0,0 +1,10 @@
+export function buildCommonContext(globalContextManager, userContextManager) {
+  return {
+    view: {
+      referrer: document.referrer,
+      url: window.location.href
+    },
+    context: globalContextManager.getContext(),
+    user: userContextManager.getContext()
+  }
+}

package/src/domain/createErrorFieldFromRawError.js

@@ -0,0 +1,13 @@
+export function createErrorFieldFromRawError(rawError, options) {
+  if (options === undefined) {
+    options = {}
+  }
+  var includeMessage = options.includeMessage || false
+  return {
+    stack: rawError.stack,
+    kind: rawError.type,
+    message: includeMessage ? rawError.message : undefined,
+    causes: rawError.causes,
+    handling: rawError.handling
+  }
+}