Class Logger

Logger that can be used to emit traces.

The class supports adding multiple loggers for different targets. A default logger (identifier "default") is added on startup which logs to "console".

Usage:

const facility = Logger.get("loggerName"); facility.debug("My debug message", "my extra value to log");

The configuration of the default logger can be adjusted by using the static properties of the Logger class:

  • Logger.defaultLogLevel sets the default log level for all the facility
  • Logger.logLevels = { loggerName: Level.DEBUG } can set the level for the specific loggers
  • Logger.format = Format.ANSI enables colorization via ANSI escape sequences in default formatter

For additional loggers, use Logger.addLogger() to add a new logger with a specific identifier. Afterwards the configuration of these can be adjusted using static methods with the identifier as first parameter:

  • Logger.setFormatForLogger("loggerName", Format.ANSI)
  • Logger.setLogLevelsForLogger("loggerName", { loggerName: Level.DEBUG })
  • Logger.setDefaultLoglevelForLogger("loggerName", Level.DEBUG)

Constructors

constructor

Properties

debug error fatal info notice warn logger nestingLevel

Accessors

defaultLogLevel format level log logFormatter logLevels

Methods

addLogger capture get getLoggerforIdentifier maskString nest nestAsync removeLogger reportUnhandledError setDefaultLoglevelForLogger setFormatForLogger setLogFormatterForLogger setLogger setLogLevelsForLogger toJSON

Constructors

constructor

  • new Logger(name): Logger

  • Parameters

    • name: string

    Returns Logger

Properties

debug

debug: ((...values: any[]) => void)

error

error: ((...values: any[]) => void)

fatal

fatal: ((...values: any[]) => void)

info

info: ((...values: any[]) => void)

notice

notice: ((...values: any[]) => void)

warn

warn: ((...values: any[]) => void)

Staticlogger

logger: LoggerDefinition[]

StaticnestingLevel

nestingLevel: number

Accessors

StaticdefaultLogLevel

  • get defaultLogLevel(): Level

  • Get default loglevel for the default logger.

    Returns Level

  • set defaultLogLevel(level): void

  • Set default loglevel for the default logger.

    Parameters

    • level: Level

      The level to set

    Returns void

Staticformat

  • set format(format): void

  • Set logFormatter using configuration-style format name.

    Parameters

    • format: string

      the name of the formatter (see Format enum)

    Returns void

Staticlevel

  • set level(level): void

  • Set log level using configuration-style level name for the default logger.

    Parameters

    • level: string | number

    Returns void

Staticlog

  • get log(): ((level: Level, formattedLog: string) => void)

  • Get the log function for the default logger.

    Returns ((level: Level, formattedLog: string) => void)

      • (level, formattedLog): void

      • Parameters

        • level: Level
        • formattedLog: string

        Returns void

  • set log(log): void

  • Set the log function for the default logger.

    Parameters

    • log: ((level: Level, formattedLog: string) => void)

      The log function to set

        • (level, formattedLog): void

        • Parameters

          • level: Level
          • formattedLog: string

          Returns void

    Returns void

StaticlogFormatter

  • get logFormatter(): ((now: Date, level: Level, facility: string, nestingPrefix: string, values: any[]) => string)

  • Get the log formatter for the default logger.

    Returns ((now: Date, level: Level, facility: string, nestingPrefix: string, values: any[]) => string)

      • (now, level, facility, nestingPrefix, values): string

      • Parameters

        • now: Date
        • level: Level
        • facility: string
        • nestingPrefix: string
        • values: any[]

        Returns string

  • set logFormatter(logFormatter): void

  • Set the log formatter for the default logger.

    Parameters

    • logFormatter: ((now: Date, level: Level, facility: string, nestingPrefix: string, values: any[]) => string)
        • (now, level, facility, nestingPrefix, values): string

        • Parameters

          • now: Date
          • level: Level
          • facility: string
          • nestingPrefix: string
          • values: any[]

          Returns string

    Returns void

StaticlogLevels

  • get logLevels(): {
        [facility: string]: Level;
    }

  • Get facility loglevels for the default logger.

    Returns {
        [facility: string]: Level;
    }

    • [facility: string]: Level
  • set logLevels(levels): void

  • Set facility loglevels for the default logger.

    Parameters

    • levels: {
          [facility: string]: Level;
      }

      The levels to set

      • [facility: string]: Level

    Returns void

Methods

StaticaddLogger

  • addLogger(identifier, logger, options?): void

  • Add additional logger to the list of loggers including the default configuration.

    Parameters

    • identifier: string
    • logger: ((level: Level, formattedLog: string) => void)
        • (level, formattedLog): void

        • Parameters

          • level: Level
          • formattedLog: string

          Returns void

    • Optionaloptions: {
          defaultLogLevel?: Level;
          logFormat?: string;
          logLevels?: {
              [facility: string]: Level;
          };
      }
      • OptionaldefaultLogLevel?: Level
      • OptionallogFormat?: string
      • OptionallogLevels?: {
            [facility: string]: Level;
        }
        • [facility: string]: Level

    Returns void

Staticcapture

  • capture(fn, fromLogger?): {
        level: Level;
        message: string;
    }[]

  • Invoke logic and return any log messages produced.

    Parameters

    • fn: (() => void)
        • (): void

        • Returns void

    • OptionalfromLogger: string

    Returns {
        level: Level;
        message: string;
    }[]

Staticget

  • get(name): Logger

  • Create a new facility.

    Parameters

    • name: string

      the name of the facility

    Returns Logger

    a new facility

StaticgetLoggerforIdentifier

  • getLoggerforIdentifier(identifier): LoggerDefinition

  • Get the logger with the matching identifier.

    Parameters

    • identifier: string

      The identifier of the logger

    Returns LoggerDefinition

StaticmaskString

  • maskString(str, maskChar?, unmaskedLength?): string

  • Mask a string with a given character. If unmaskedLength is provided then these number of characters will be shown unmasked.

    Parameters

    • str: string

      String to mask

    • OptionalmaskChar: string

      character to mask with

    • OptionalunmaskedLength: number

      number of characters to show unmasked in the beginning

    Returns string

Staticnest

  • nest<T>(context): T

  • Perform operations in a nested logging context. Messages will be indented while the context executes.

    Type Parameters

    • T

    Parameters

    • context: (() => T)
        • (): T

        • Returns T

    Returns T

StaticnestAsync

  • nestAsync(context): Promise<any>

  • Async version of nest().

    Parameters

    • context: (() => Promise<any>)
        • (): Promise<any>

        • Returns Promise<any>

    Returns Promise<any>

StaticremoveLogger

  • removeLogger(identifier): void

  • Parameters

    • identifier: string

    Returns void

StaticreportUnhandledError

  • reportUnhandledError(error): void

  • Unhandled error reporter.

    Some environments do not report full error details such as Error#cause and AggregateError#errors.

    To ensure these details are always recorded somewhere, unhandled errors may be reported here.

    To disable this behavior replace this function.

    Parameters

    • error: Error

    Returns void

StaticsetDefaultLoglevelForLogger

  • setDefaultLoglevelForLogger(identifier, level): void

  • Set default loglevel for the logger with the matching identifier.

    Parameters

    • identifier: string

      The identifier of the logger

    • level: Level

      The level to set

    Returns void

StaticsetFormatForLogger

  • setFormatForLogger(identifier, format): void

  • Set logFormatter using configuration-style format name for the logger with the matching identifier.

    Parameters

    • identifier: string

      The identifier of the logger

    • format: string

      the name of the formatter (see Format enum)

    Returns void

StaticsetLogFormatterForLogger

  • setLogFormatterForLogger(identifier, logFormatter): void

  • Set the log formatter for the logger with the matching identifier.

    Parameters

    • identifier: string

      The identifier of the logger

    • logFormatter: ((now: Date, level: Level, facility: string, nestingPrefix: string, values: any[]) => string)

      The log formatter to set

        • (now, level, facility, nestingPrefix, values): string

        • Parameters

          • now: Date
          • level: Level
          • facility: string
          • nestingPrefix: string
          • values: any[]

          Returns string

    Returns void

StaticsetLogger

  • setLogger(identifier, log): void

  • Set the log function for the logger with the matching identifier.

    Parameters

    • identifier: string

      The identifier of the logger

    • log: ((level: Level, formattedLog: string) => void)

      The log function to set

        • (level, formattedLog): void

        • Parameters

          • level: Level
          • formattedLog: string

          Returns void

    Returns void

StaticsetLogLevelsForLogger

  • setLogLevelsForLogger(identifier, levels): void

  • Set facility loglevels for the logger with the matching identifier.

    Parameters

    • identifier: string

      The identifier of the logger

    • levels: {
          [facility: string]: Level;
      }

      The levels to set

      • [facility: string]: Level

    Returns void

StatictoJSON

  • toJSON(data): string

  • Stringify a value (BigInt aware) as JSON.

    Parameters

    • data: any

      the value to stringify

    Returns string

    the stringified value

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods