@cloudcare/browser-logs 3.1.23 → 3.2.0

package/src/domain/logger.js

@@ -1,5 +1,4 @@
 import {
-  assign,
   extend2Lev,
   createContextManager,
   ErrorSource,
@@ -11,15 +10,21 @@ import {
   clocksNow,
   ErrorHandling,
   monitor,
-  NonErrorPrefix
+  NonErrorPrefix,
+  createHandlingStack
 } from '@cloudcare/browser-core'
-
+import { isAuthorized } from './logsCollection/logger/loggerCollection'
+import { createErrorFieldFromRawError } from './createErrorFieldFromRawError'
 export var StatusType = {
+  ok: 'ok',
   debug: 'debug',
-  error: 'error',
   info: 'info',
+  notice: 'notice',
   warn: 'warn',
-  critical: 'critical'
+  error: 'error',
+  critical: 'critical',
+  alert: 'alert',
+  emerg: 'emerg'
 }
 
 export var HandlerType = {
@@ -37,7 +42,6 @@ export function Logger(
   level,
   loggerContext
 ) {
-  this.contextManager = createContextManager(CustomerDataType.LoggerContext)
   if (typeof handlerType === 'undefined') {
     handlerType = HandlerType.http
   }
@@ -47,96 +51,93 @@ export function Logger(
   if (typeof loggerContext === 'undefined') {
     loggerContext = {}
   }
+  this.contextManager = createContextManager(CustomerDataType.LoggerContext)
   this.handleLogStrategy = handleLogStrategy
   this.handlerType = handlerType
   this.level = level
-  this.contextManager.set(
-    assign({}, loggerContext, name ? { logger: { name: name } } : undefined)
-  )
+  this.contextManager.setContext(loggerContext)
+  if (name) {
+    this.contextManager.setContextProperty('logger', { name: name })
+  }
 }
 Logger.prototype = {
-  log: monitor(function (message, messageContext, status, error) {
-    if (typeof status === 'undefined') {
+  logImplementation: monitor(function (
+    message,
+    messageContext,
+    status,
+    error,
+    handlingStack
+  ) {
+    if (status === undefined) {
       status = StatusType.info
     }
-    var errorContext
-    if (status === StatusType.error) {
-      // Always add origin if status is error (backward compatibility - Remove in next major)
-      errorContext = { origin: ErrorSource.LOGGER }
-    }
+    var sanitizedMessageContext = sanitize(messageContext)
+    var context
+
     if (error !== undefined && error !== null) {
-      var stackTrace =
-        error instanceof Error ? computeStackTrace(error) : undefined
       var rawError = computeRawError({
-        stackTrace: stackTrace,
+        stackTrace:
+          error instanceof Error ? computeStackTrace(error) : undefined,
         originalError: error,
         nonErrorPrefix: NonErrorPrefix.PROVIDED,
         source: ErrorSource.LOGGER,
         handling: ErrorHandling.HANDLED,
         startClocks: clocksNow()
       })
-
-      errorContext = {
-        origin: ErrorSource.LOGGER, // Remove in next major
-        stack: rawError.stack,
-        kind: rawError.type,
-        message: rawError.message,
-        causes: rawError.causes
-      }
+      context = extend2Lev(
+        {
+          error: createErrorFieldFromRawError(rawError, {
+            includeMessage: true
+          })
+        },
+        sanitizedMessageContext
+      )
+    } else {
+      context = sanitizedMessageContext
     }
 
-    var sanitizedMessageContext = sanitize(messageContext)
-
-    var context = errorContext
-      ? extend2Lev({ error: errorContext }, sanitizedMessageContext)
-      : sanitizedMessageContext
-
     this.handleLogStrategy(
-      { message: message, context: context, status: status },
-      this
+      {
+        message: sanitize(message),
+        context: context,
+        status: status
+      },
+      this,
+      handlingStack
     )
   }),
+  log: function (message, messageContext, status, error) {
+    var handlingStack
 
-  debug: function (message, messageContext, error) {
-    this.log(message, messageContext, StatusType.debug, error)
-  },
-
-  info: function (message, messageContext, error) {
-    this.log(message, messageContext, StatusType.info, error)
-  },
-
-  warn: function (message, messageContext, error) {
-    this.log(message, messageContext, StatusType.warn, error)
-  },
-  critical: function (message, messageContext, error) {
-    this.log(message, messageContext, StatusType.critical, error)
-  },
-  error: function (message, messageContext, error) {
-    var errorOrigin = {
-      error: {
-        origin: ErrorSource.LOGGER
-      }
+    if (isAuthorized(status, HandlerType.http, this)) {
+      handlingStack = createHandlingStack()
     }
-    this.log(
+
+    this.logImplementation(
       message,
-      extend2Lev(errorOrigin, messageContext),
-      StatusType.error,
-      error
+      messageContext,
+      status,
+      error,
+      handlingStack
     )
   },
 
   setContext: function (context) {
-    this.contextManager.set(context)
+    this.contextManager.setContext(context)
   },
 
   getContext: function () {
-    return this.contextManager.get()
+    return this.contextManager.getContext()
+  },
+  setContextProperty: function (key, value) {
+    this.contextManager.setContextProperty(key, value)
   },
-
   addContext: function (key, value) {
-    this.contextManager.add(key, value)
+    this.contextManager.setContextProperty(key, value)
+  },
+  removeContextProperty(key) {
+    this.contextManager.removeContextProperty(key)
   },
-
   removeContext: function (key) {
     this.contextManager.remove(key)
   },
@@ -157,3 +158,28 @@ Logger.prototype = {
     return this.level
   }
 }
+Logger.prototype.ok = createLoggerMethod(StatusType.ok)
+Logger.prototype.debug = createLoggerMethod(StatusType.debug)
+Logger.prototype.info = createLoggerMethod(StatusType.info)
+Logger.prototype.notice = createLoggerMethod(StatusType.notice)
+Logger.prototype.warn = createLoggerMethod(StatusType.warn)
+Logger.prototype.error = createLoggerMethod(StatusType.error)
+Logger.prototype.critical = createLoggerMethod(StatusType.critical)
+Logger.prototype.alert = createLoggerMethod(StatusType.alert)
+Logger.prototype.emerg = createLoggerMethod(StatusType.emerg)
+function createLoggerMethod(status) {
+  return function (message, messageContext, error) {
+    var handlingStack
+
+    if (isAuthorized(status, HandlerType.http, this)) {
+      handlingStack = createHandlingStack()
+    }
+    this.logImplementation(
+      message,
+      messageContext,
+      status,
+      error,
+      handlingStack
+    )
+  }
+}

package/src/domain/logsCollection/console/consoleCollection.js

@@ -6,7 +6,7 @@ import {
   LifeCycleEventType
 } from '@cloudcare/browser-core'
 import { StatusType } from '../../logger'
-
+import { createErrorFieldFromRawError } from '../../createErrorFieldFromRawError'
 var LogStatusForApi = {
   [ConsoleApiName.log]: StatusType.info,
   [ConsoleApiName.debug]: StatusType.debug,
@@ -23,15 +23,11 @@ export function startConsoleCollection(configuration, lifeCycle) {
         date: timeStampNow(),
         message: log.message,
         origin: ErrorSource.CONSOLE,
-        error:
-          log.api === ConsoleApiName.error
-            ? {
-                origin: ErrorSource.CONSOLE,
-                stack: log.stack,
-                causes: log.causes
-              }
-            : undefined,
+        error: log.error && createErrorFieldFromRawError(log.error),
         status: LogStatusForApi[log.api]
+      },
+      domainContext: {
+        handlingStack: log.handlingStack
       }
     })
   })

package/src/domain/logsCollection/logger/loggerCollection.js

@@ -1,42 +1,54 @@
 import {
   includes,
-  display,
   extend2Lev,
   ErrorSource,
   timeStampNow,
   LifeCycleEventType,
-  isArray
+  isArray,
+  originalConsoleMethods
 } from '@cloudcare/browser-core'
-import { StatusType, HandlerType } from '../../logger'
+import { HandlerType } from '../../logger'
 
 export var STATUS_PRIORITIES = {
-  [StatusType.debug]: 0,
-  [StatusType.info]: 1,
-  [StatusType.warn]: 2,
-  [StatusType.error]: 3
+  ok: 0,
+  debug: 1,
+  info: 2,
+  notice: 4,
+  warn: 5,
+  error: 6,
+  critical: 7,
+  alert: 8,
+  emerg: 9
 }
 
 export function startLoggerCollection(lifeCycle) {
-  function handleLog(logsMessage, logger, savedCommonContext, savedDate) {
-    var messageContext = logsMessage.context
+  function handleLog(
+    logsMessage,
+    logger,
+    handlingStack,
+    savedCommonContext,
+    savedDate
+  ) {
+    var messageContext = extend2Lev(logger.getContext(), logsMessage.context)
     if (isAuthorized(logsMessage.status, HandlerType.console, logger)) {
-      display(
-        logsMessage.status,
-        logsMessage.message,
-        extend2Lev(logger.getContext(), messageContext)
-      )
+      displayInConsole(logsMessage, messageContext)
+    }
+    if (isAuthorized(logsMessage.status, HandlerType.http, logger)) {
+      var rawLogEventData = {
+        rawLogsEvent: {
+          date: savedDate || timeStampNow(),
+          message: logsMessage.message,
+          status: logsMessage.status,
+          origin: ErrorSource.LOGGER
+        },
+        messageContext: messageContext,
+        savedCommonContext: savedCommonContext
+      }
+      if (handlingStack) {
+        rawLogEventData.domainContext = { handlingStack }
+      }
+      lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, rawLogEventData)
     }
-    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
-      rawLogsEvent: {
-        date: savedDate || timeStampNow(),
-        message: logsMessage.message,
-        status: logsMessage.status,
-        origin: ErrorSource.LOGGER
-      },
-      messageContext: messageContext,
-      savedCommonContext: savedCommonContext,
-      logger: logger
-    })
   }
 
   return {
@@ -54,3 +66,12 @@ export function isAuthorized(status, handlerType, logger) {
     includes(sanitizedHandlerType, handlerType)
   )
 }
+function displayInConsole(data, messageContext) {
+  var status = data.status
+  var message = data.message
+  originalConsoleMethods[loggerToConsoleApiName[status]].call(
+    globalConsole,
+    message,
+    messageContext
+  )
+}

package/src/domain/logsCollection/networkError/networkErrorCollection.js

@@ -6,7 +6,6 @@ import {
   computeStackTrace,
   toStackTraceString,
   noop,
-  each,
   LifeCycleEventType,
   getStatusGroup,
   urlParse,
@@ -25,16 +24,16 @@ export function startNetworkErrorCollection(configuration, lifeCycle) {
 
   var xhrSubscription = initXhrObservable().subscribe(function (context) {
     if (context.state === 'complete') {
-      handleCompleteRequest(RequestType.XHR, context)
+      handleResponse(RequestType.XHR, context)
     }
   })
   var fetchSubscription = initFetchObservable().subscribe(function (context) {
     if (context.state === 'resolve') {
-      handleCompleteRequest(RequestType.FETCH, context)
+      handleResponse(RequestType.FETCH, context)
     }
   })
 
-  function handleCompleteRequest(type, request) {
+  function handleResponse(type, request) {
     if (
       !isIntakeRequest(request.url, configuration) &&
       (isRejected(request) ||
@@ -63,6 +62,10 @@ export function startNetworkErrorCollection(configuration, lifeCycle) {
     }
 
     function onResponseDataAvailable(responseData) {
+      var domainContext = {
+        isAborted: request.isAborted,
+        handlingStack: request.handlingStack
+      }
       var urlObj = urlParse(request.url).getParse()
       lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
         rawLogsEvent: {
@@ -70,8 +73,8 @@ export function startNetworkErrorCollection(configuration, lifeCycle) {
             format(type) + ' error ' + request.method + ' ' + request.url,
           date: request.startClocks.timeStamp,
           error: {
-            origin: ErrorSource.NETWORK,
-            stack: responseData || 'Failed to load'
+            stack: responseData || 'Failed to load',
+            handing: undefined
           },
           http: {
             method: request.method,
@@ -84,7 +87,8 @@ export function startNetworkErrorCollection(configuration, lifeCycle) {
           },
           status: StatusType.error,
           origin: ErrorSource.NETWORK
-        }
+        },
+        domainContext: domainContext
       })
     }
   }

package/src/domain/logsCollection/report/reportCollection.js

@@ -1,35 +1,28 @@
 import {
   timeStampNow,
   ErrorSource,
-  RawReportType,
   getFileFromStackTraceString,
   initReportObservable,
   LifeCycleEventType
 } from '@cloudcare/browser-core'
 import { StatusType } from '../../logger'
-
-var LogStatusForReport = {
-  [RawReportType.cspViolation]: StatusType.error,
-  [RawReportType.intervention]: StatusType.error,
-  [RawReportType.deprecation]: StatusType.warn
-}
+import { createErrorFieldFromRawError } from '../../createErrorFieldFromRawError'
 
 export function startReportCollection(configuration, lifeCycle) {
   var reportSubscription = initReportObservable(
     configuration,
     configuration.forwardReports
-  ).subscribe(function (report) {
-    var message = report.message
-    var status = LogStatusForReport[report.type]
+  ).subscribe(function (rawError) {
+    var message = rawError.message
+    var status =
+      rawError.originalError.type === 'deprecation'
+        ? StatusType.warn
+        : StatusType.error
     var error
     if (status === StatusType.error) {
-      error = {
-        kind: report.subtype,
-        origin: ErrorSource.REPORT,
-        stack: report.stack
-      }
+      error = createErrorFieldFromRawError(rawError)
     } else if (report.stack) {
-      message += ' Found in ' + getFileFromStackTraceString(report.stack)
+      message += ' Found in ' + getFileFromStackTraceString(rawError.stack)
     }
 
     lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {

package/src/domain/logsCollection/rumtimeError/runtimeErrorCollection.js

@@ -6,7 +6,7 @@ import {
   LifeCycleEventType
 } from '@cloudcare/browser-core'
 import { StatusType } from '../../logger'
-
+import { createErrorFieldFromRawError } from '../../createErrorFieldFromRawError'
 export function startRuntimeErrorCollection(configuration, lifeCycle) {
   if (!configuration.forwardErrorsToLogs) {
     return { stop: noop }
@@ -21,11 +21,7 @@ export function startRuntimeErrorCollection(configuration, lifeCycle) {
       rawLogsEvent: {
         message: rawError.message,
         date: rawError.startClocks.timeStamp,
-        error: {
-          kind: rawError.type,
-          stack: rawError.stack,
-          causes: rawError.causes
-        },
+        error: createErrorFieldFromRawError(rawError),
         origin: ErrorSource.SOURCE,
         status: StatusType.error
       }

package/src/domain/reportError.js

@@ -0,0 +1,21 @@
+import {
+  ErrorSource,
+  LifeCycleEventType,
+  addTelemetryDebug
+} from '@cloudcare/browser-core'
+import { StatusType } from './logger'
+export function startReportError(lifeCycle) {
+  return function (error) {
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        message: error.message,
+        date: error.startClocks.timeStamp,
+        origin: ErrorSource.AGENT,
+        status: StatusType.error
+      }
+    })
+    addTelemetryDebug('Error reported to customer', {
+      'error.message': error.message
+    })
+  }
+}

package/src/transport/startLogsBatch.js

@@ -1,6 +1,7 @@
 import {
   startBatchWithReplica,
-  LifeCycleEventType
+  LifeCycleEventType,
+  createIdentityEncoder
 } from '@cloudcare/browser-core'
 
 export function startLogsBatch(
@@ -8,14 +9,14 @@ export function startLogsBatch(
   lifeCycle,
   reportError,
   pageExitObservable,
-  sessionExpireObservable
+  session
 ) {
   var batch = startBatchWithReplica(
     configuration,
-    configuration.logsEndpoint,
+    { endpoint: configuration.logsEndpoint, encoder: createIdentityEncoder() },
     reportError,
     pageExitObservable,
-    sessionExpireObservable
+    session.expireObservable
   )
 
   lifeCycle.subscribe(
@@ -24,4 +25,5 @@ export function startLogsBatch(
       batch.add(serverLogsEvent)
     }
   )
+  return batch
 }

package/types/configuration.d.ts

@@ -7,8 +7,8 @@ import type {
 } from '@cloudcare/browser-core'
 export interface LogsBaseInitConfiguration extends InitConfiguration {
   forwardErrorsToLogs?: boolean | undefined
-  forwardConsoleLogs?: ConsoleApiName[] | 'all' | undefined
-  forwardReports?: RawReportType[] | 'all' | undefined
+  forwardConsoleLogs?: ConsoleApiName[] | undefined
+  forwardReports?: RawReportType[] | undefined
   requestErrorResponseLengthLimit?: number
 }
 

package/types/logger.d.ts

@@ -1,18 +1,9 @@
 import type { Context } from '@cloudcare/browser-core'
-export interface CommonContext {
-  view: {
-    referrer: string
-    url: string
-  }
-  context: Context
-  user: User
-}
 export interface LogsMessage {
   message: string
   status: StatusType
   context?: Context
 }
-export type TimeStamp = number & { t: 'Epoch time' }
 export declare const StatusType: {
   readonly debug: 'debug'
   readonly error: 'error'
@@ -27,23 +18,13 @@ export declare const HandlerType: {
 }
 export type HandlerType = (typeof HandlerType)[keyof typeof HandlerType]
 export declare const STATUSES: StatusType[]
-export interface LoggerConfiguration {
-  level?: StatusType
-  handler?: HandlerType | HandlerType[]
-  context?: object
-}
 export declare class Logger {
   private handleLogStrategy
   private handlerType
   private level
   private contextManager
   constructor(
-    handleLogStrategy: (
-      logsMessage: LogsMessage,
-      logger: Logger,
-      savedCommonContext?: CommonContext,
-      savedDate?: TimeStamp
-    ) => void,
+    handleLogStrategy: (logsMessage: LogsMessage, logger: Logger) => void,
     name?: string,
     handlerType?: HandlerType | HandlerType[],
     level?: StatusType,
@@ -61,8 +42,8 @@ export declare class Logger {
   error(message: string, messageContext?: object, error?: Error): void
   setContext(context: object): void
   getContext(): Context
-  addContext(key: string, value: any): void
-  removeContext(key: string): void
+  setContextProperty(key: string, value: any): void
+  removeContextProperty(key: string): void
   clearContext(): void
   setHandler(handler: HandlerType | HandlerType[]): void
   getHandler(): HandlerType | HandlerType[]

package/cjs/domain/internalContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"internalContext.js","names":["startInternalContext","sessionManager","get","startTime","trackedSession","findTrackedSession","session","id"],"sources":["../../src/domain/internalContext.js"],"sourcesContent":["\nexport function startInternalContext(sessionManager) {\n  return {\n    get: function(startTime) {\n      var trackedSession = sessionManager.findTrackedSession(startTime)\n      if (trackedSession) {\n        return {\n          session: {\n            id: trackedSession.id\n          },\n        }\n      }\n    },\n  }\n}\n"],"mappings":";;;;;;AACO,SAASA,oBAAoBA,CAACC,cAAc,EAAE;EACnD,OAAO;IACLC,GAAG,EAAE,SAAAA,IAASC,SAAS,EAAE;MACvB,IAAIC,cAAc,GAAGH,cAAc,CAACI,kBAAkB,CAACF,SAAS,CAAC;MACjE,IAAIC,cAAc,EAAE;QAClB,OAAO;UACLE,OAAO,EAAE;YACPC,EAAE,EAAEH,cAAc,CAACG;UACrB;QACF,CAAC;MACH;IACF;EACF,CAAC;AACH","ignoreList":[]}

package/esm/domain/internalContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"internalContext.js","names":["startInternalContext","sessionManager","get","startTime","trackedSession","findTrackedSession","session","id"],"sources":["../../src/domain/internalContext.js"],"sourcesContent":["\nexport function startInternalContext(sessionManager) {\n  return {\n    get: function(startTime) {\n      var trackedSession = sessionManager.findTrackedSession(startTime)\n      if (trackedSession) {\n        return {\n          session: {\n            id: trackedSession.id\n          },\n        }\n      }\n    },\n  }\n}\n"],"mappings":"AACA,OAAO,SAASA,oBAAoBA,CAACC,cAAc,EAAE;EACnD,OAAO;IACLC,GAAG,EAAE,SAAAA,IAASC,SAAS,EAAE;MACvB,IAAIC,cAAc,GAAGH,cAAc,CAACI,kBAAkB,CAACF,SAAS,CAAC;MACjE,IAAIC,cAAc,EAAE;QAClB,OAAO;UACLE,OAAO,EAAE;YACPC,EAAE,EAAEH,cAAc,CAACG;UACrB;QACF,CAAC;MACH;IACF;EACF,CAAC;AACH","ignoreList":[]}