@cloudcare/browser-logs 3.1.8 → 3.1.11

package/src/boot/startLogs.js

@@ -32,7 +32,7 @@ export function startLogs(configuration, buildCommonContext, mainLogger) {
         message: error.message,
         date: error.startClocks.timeStamp,
         error: {
-          origin: ErrorSource.AGENT // Todo: Remove in the next major release
+          origin: ErrorSource.AGENT
         },
         origin: ErrorSource.AGENT,
         status: StatusType.error

package/src/domain/assembly.js

@@ -72,7 +72,6 @@ export function startLogsAssembly(
     )
 
     if (
-      // Todo: [RUMF-1230] Move this check to the logger collection in the next major release
       !isAuthorized(rawLogsEvent.status, HandlerType.http, logger) ||
       (configuration.beforeSend && configuration.beforeSend(log) === false) ||
       (log.error &&

package/src/domain/logger.js

@@ -80,7 +80,8 @@ Logger.prototype = {
         origin: ErrorSource.LOGGER, // Remove in next major
         stack: rawError.stack,
         kind: rawError.type,
-        message: rawError.message
+        message: rawError.message,
+        causes: rawError.causes
       }
     }
 
@@ -139,7 +140,9 @@ Logger.prototype = {
   removeContext: function (key) {
     this.contextManager.remove(key)
   },
-
+  clearContext() {
+    this.contextManager.clearContext()
+  },
   setHandler: function (handler) {
     this.handlerType = handler
   },

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

@@ -1,16 +1,23 @@
-import { timeStampNow, ConsoleApiName, ErrorSource, initConsoleObservable, LifeCycleEventType } from '@cloudcare/browser-core'
+import {
+  timeStampNow,
+  ConsoleApiName,
+  ErrorSource,
+  initConsoleObservable,
+  LifeCycleEventType
+} from '@cloudcare/browser-core'
 import { StatusType } from '../../logger'
 
-
 var LogStatusForApi = {
   [ConsoleApiName.log]: StatusType.info,
   [ConsoleApiName.debug]: StatusType.debug,
   [ConsoleApiName.info]: StatusType.info,
   [ConsoleApiName.warn]: StatusType.warn,
-  [ConsoleApiName.error]: StatusType.error,
+  [ConsoleApiName.error]: StatusType.error
 }
 export function startConsoleCollection(configuration, lifeCycle) {
-  var consoleSubscription = initConsoleObservable(configuration.forwardConsoleLogs).subscribe(function(log) {
+  var consoleSubscription = initConsoleObservable(
+    configuration.forwardConsoleLogs
+  ).subscribe(function (log) {
     lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
       rawLogsEvent: {
         date: timeStampNow(),
@@ -19,18 +26,19 @@ export function startConsoleCollection(configuration, lifeCycle) {
         error:
           log.api === ConsoleApiName.error
             ? {
-                origin: ErrorSource.CONSOLE, // Todo: Remove in the next major release
+                origin: ErrorSource.CONSOLE,
                 stack: log.stack,
+                causes: log.causes
               }
             : undefined,
-        status: LogStatusForApi[log.api],
-      },
+        status: LogStatusForApi[log.api]
+      }
     })
   })
 
   return {
-    stop: function(){
+    stop: function () {
       consoleSubscription.unsubscribe()
-    },
+    }
   }
 }

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

@@ -69,11 +69,11 @@ export function startNetworkErrorCollection(configuration, lifeCycle) {
             format(type) + ' error ' + request.method + ' ' + request.url,
           date: request.startClocks.timeStamp,
           error: {
-            origin: ErrorSource.NETWORK, // Todo: Remove in the next major release
+            origin: ErrorSource.NETWORK,
             stack: responseData || 'Failed to load'
           },
           http: {
-            method: request.method, // Cast resource method because of case mismatch cf issue RUMF-1152
+            method: request.method,
             status_code: request.status,
             url: request.url,
             statusGroup: getStatusGroup(request.status),
@@ -96,11 +96,6 @@ export function startNetworkErrorCollection(configuration, lifeCycle) {
   }
 }
 
-// TODO: ideally, computeXhrResponseData should always call the callback with a string instead of
-// `unknown`. But to keep backward compatibility, in the case of XHR with a `responseType` different
-// than "text", the response data should be whatever `xhr.response` is. This is a bit confusing as
-// Logs event 'stack' is expected to be a string. This should be changed in a future major version
-// as it could be a breaking change.
 export function computeXhrResponseData(xhr, configuration, callback) {
   if (typeof xhr.response === 'string') {
     callback(truncateResponseText(xhr.response, configuration))

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

@@ -25,7 +25,7 @@ export function startReportCollection(configuration, lifeCycle) {
     if (status === StatusType.error) {
       error = {
         kind: report.subtype,
-        origin: ErrorSource.REPORT, // Todo: Remove in the next major release
+        origin: ErrorSource.REPORT,
         stack: report.stack
       }
     } else if (report.stack) {

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

@@ -1,4 +1,10 @@
-import { noop, ErrorSource, trackRuntimeError, Observable, LifeCycleEventType } from '@cloudcare/browser-core'
+import {
+  noop,
+  ErrorSource,
+  trackRuntimeError,
+  Observable,
+  LifeCycleEventType
+} from '@cloudcare/browser-core'
 import { StatusType } from '../../logger'
 
 export function startRuntimeErrorCollection(configuration, lifeCycle) {
@@ -10,26 +16,26 @@ export function startRuntimeErrorCollection(configuration, lifeCycle) {
 
   var _trackRuntimeError = trackRuntimeError(rawErrorObservable)
 
-  var rawErrorSubscription = rawErrorObservable.subscribe(function(rawError) {
+  var rawErrorSubscription = rawErrorObservable.subscribe(function (rawError) {
     lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
       rawLogsEvent: {
         message: rawError.message,
         date: rawError.startClocks.timeStamp,
         error: {
           kind: rawError.type,
-          origin: ErrorSource.SOURCE, // Todo: Remove in the next major release
           stack: rawError.stack,
+          causes: rawError.causes
         },
         origin: ErrorSource.SOURCE,
-        status: StatusType.error,
-      },
+        status: StatusType.error
+      }
     })
   })
 
   return {
-    stop: function() {
+    stop: function () {
       _trackRuntimeError.stop()
       rawErrorSubscription.unsubscribe()
-    },
+    }
   }
 }

package/types/configuration.d.ts

@@ -0,0 +1,12 @@
+import type {
+  InitConfiguration,
+  ConsoleApiName,
+  RawReportType
+} from '@cloudcare/browser-core'
+export interface LogsInitConfiguration extends InitConfiguration {
+  beforeSend?: ((event: any) => boolean) | undefined
+  forwardErrorsToLogs?: boolean | undefined
+  forwardConsoleLogs?: ConsoleApiName[] | 'all' | undefined
+  forwardReports?: RawReportType[] | 'all' | undefined
+  requestErrorResponseLengthLimit: number
+}

package/types/index.d.ts

@@ -0,0 +1,30 @@
+import type { Logger, LoggerConfiguration } from './logger'
+import type { LogsInitConfiguration } from './configuration'
+import type { InitConfiguration, User, Context } from '@cloudcare/browser-core'
+export interface InternalContext {
+  session: {
+    id: string | undefined
+  }
+}
+export declare const datafluxLogs: {
+  logger: Logger
+  init: (initConfiguration: LogsInitConfiguration) => void
+  getGlobalContext: () => Context
+  setGlobalContext: (context: any) => void
+  setGlobalContextProperty: (key: any, value: any) => void
+  removeGlobalContextProperty: (key: any) => void
+  clearGlobalContext: () => void
+  createLogger: (name: string, conf?: LoggerConfiguration) => Logger
+  getLogger: (name: string) => Logger | undefined
+  getInitConfiguration: () => InitConfiguration | undefined
+  getInternalContext: (
+    startTime?: number | undefined
+  ) => InternalContext | undefined
+  setUser: (newUser: User) => void
+  getUser: () => Context
+  setUserProperty: (key: any, property: any) => void
+  removeUserProperty: (key: any) => void
+  clearUser: () => void
+} & {
+  onReady(callback: () => void): void
+}

package/types/logger.d.ts

@@ -0,0 +1,71 @@
+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'
+  readonly info: 'info'
+  readonly warn: 'warn'
+}
+export type StatusType = (typeof StatusType)[keyof typeof StatusType]
+export declare const HandlerType: {
+  readonly console: 'console'
+  readonly http: 'http'
+  readonly silent: 'silent'
+}
+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,
+    name?: string,
+    handlerType?: HandlerType | HandlerType[],
+    level?: StatusType,
+    loggerContext?: object
+  )
+  log(
+    message: string,
+    messageContext?: object,
+    status?: StatusType,
+    error?: Error
+  ): void
+  debug(message: string, messageContext?: object, error?: Error): void
+  info(message: string, messageContext?: object, error?: Error): void
+  warn(message: string, messageContext?: object, error?: Error): void
+  error(message: string, messageContext?: object, error?: Error): void
+  setContext(context: object): void
+  getContext(): Context
+  addContext(key: string, value: any): void
+  removeContext(key: string): void
+  clearContext(): void
+  setHandler(handler: HandlerType | HandlerType[]): void
+  getHandler(): HandlerType | HandlerType[]
+  setLevel(level: StatusType): void
+  getLevel(): StatusType
+}