Class Logger

Interface that allows you to log records. This records are treated by handlers

Constructors

constructor

Properties

displayName? key

Methods

addRecord alert child context critical debug debugFail debugSuccess enter error exit extendsContext fail fatal getContextObject info infoFail infoSuccess infoSuccessTimeEnd infoTime infoTimeEnd inspectValue inspectVar log notice setContext success time timeEnd trace warn wrap

Constructors

constructor

Properties

Optional ReadonlydisplayName

displayName?: string

Readonlykey

key: string

Methods

addRecord

alert

child

context

  • context(context): Logger

  • Create a new Logger with the same key a this attached context

    Parameters

    • context: Record<string, unknown>

    Returns Logger

    Example

    const loggerMyService = new Logger('app:myService');
    function someAction(arg1) {
        const logger = loggerMyService.context({ arg1 });
        logger.enter(someAction);
        // do stuff
        logger.info('info');
        // do stuff
        logger.exit(someAction);
    }

critical

debug

debugFail

debugSuccess

enter

  • enter<T, Fn>(fn, metadata?, metadataStyles?): void

  • Log an enter in a function

    Type Parameters

    • T extends Metadata
    • Fn extends ((...args: unknown[]) => unknown)

    Parameters

    • fn: Fn
    • Optionalmetadata: T
    • OptionalmetadataStyles: MetadataStyles<ExtendedFunctionNameMetadata & T>

    Returns void

    Example

    class A {
      method(arg1) {
        logger.enter(method, { arg1 });
        // Do your stuff
      }
    }

error

  • error<T>(messageOrError, metadata?, metadataStyles?): void

  • Log an error message

    Type Parameters

    • T extends Metadata

    Parameters

    • messageOrError: string | Error
    • Optionalmetadata: T
    • OptionalmetadataStyles: MetadataStyles<T>

    Returns void

    Example

    const logger = new Logger('something');
    try {
      throw new Error('Always throws here');
    } catch (error) {
      logger.error('caught error', { error });
    }

exit

  • exit<T, Fn>(fn, metadata?, metadataStyles?): void

  • Log an exit in a function

    Type Parameters

    • T extends Metadata
    • Fn extends ((...args: unknown[]) => unknown)

    Parameters

    • fn: Fn
    • Optionalmetadata: T
    • OptionalmetadataStyles: MetadataStyles<ExtendedFunctionNameMetadata & T>

    Returns void

    Example

    const logger = new Logger('myNamespace:A');
    class A {
      method(arg1) {
        // Do your stuff
        logger.exit(method, { arg1 });
      }
    }

extendsContext

fail

fatal

  • fatal<T>(messageOrError, metadata?, metadataStyles?): void

  • Log a fatal message

    Type Parameters

    • T extends Metadata

    Parameters

    • messageOrError: string | Error
    • Optionalmetadata: T
    • OptionalmetadataStyles: MetadataStyles<T>

    Returns void

    Example

    const logger = new Logger('something');
    try {
      throw new Error('Always throws here');
    } catch (error) {
      logger.error('caught error', { error });
      process.exit(1);

getContextObject

info

infoFail

infoSuccess

infoSuccessTimeEnd

  • infoSuccessTimeEnd<T>(time, message, metadata?, metadataStyles?): void

  • Like timeEnd, but with INFO level

    Type Parameters

    • T extends Metadata

    Parameters

    • time: number
    • message: string
    • Optionalmetadata: T
    • OptionalmetadataStyles: MetadataStyles<T>

    Returns void

infoTime

infoTimeEnd

inspectValue

inspectVar

log

notice

setContext

success

time

  • time<T>(message?, metadata?, metadataStyles?, level?): number

  • Type Parameters

    • T extends Metadata

    Parameters

    • Optionalmessage: string
    • Optionalmetadata: T
    • OptionalmetadataStyles: MetadataStyles<T>
    • Optionallevel: number

    Returns number

    time to pass to timeEnd

timeEnd

  • timeEnd<T>(startTime, message, metadata?, metadataStyles?, level?, options?): void

  • Finds difference between when this method was called and when the respective time method was called, then logs out the difference and deletes the original record

    Type Parameters

    • T extends Metadata

    Parameters

    • startTime: number
    • message: string
    • Optionalmetadata: T
    • OptionalmetadataStyles: MetadataStyles<T>
    • Optionallevel: number
    • Optionaloptions: Options<T>

    Returns void

trace

warn

wrap

  • wrap<Fn>(fn, callback): void

  • Wrap around a function to log enter and exit of a function

    Type Parameters

    • Fn extends ((...args: unknown[]) => unknown)

    Parameters

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

        • Returns void

    Returns void

    Example

    const logger = new Logger('myNamespace:A');
    class A {
      method() {
        logger.wrap(method, () => {
          // Do your stuff
        });
      }
    }
  • wrap<T, Fn>(fn, metadata, callback): void

  • Type Parameters

    • T extends Metadata
    • Fn extends ((...args: unknown[]) => unknown)

    Parameters

    • fn: Fn
    • metadata: T
    • callback: (() => void)
        • (): void

        • Returns void

    Returns void

  • wrap<T, Fn>(fn, metadata, metadataStyles, callback): void

  • Type Parameters

    • T extends Metadata
    • Fn extends ((...args: unknown[]) => unknown)

    Parameters

    • fn: Fn
    • metadata: T
    • metadataStyles: MetadataStyles<T>
    • callback: (() => void)
        • (): void

        • Returns void

    Returns void

Settings

Member Visibility

On This Page

Constructors
Properties
Methods