Class Logger

A logger that can log messages at different levels.

Example: Usage

import { Logger } from "@std/log/logger";
import { assertEquals } from "@std/assert/equals";

const logger = new Logger("example", "INFO");
const result = logger.info("Hello, world!");

assertEquals(result, "Hello, world!");

Constructors

constructor

Properties

handlers

Accessors

level levelName loggerName

Methods

critical debug error info warn

Constructors

constructor

  • new Logger(loggerName, levelName, options?): Logger

  • Constructs a new instance.

    Parameters

    • loggerName: string

      The name of the logger.

    • levelName: LevelName

      The name of the log level.

    • options: LoggerOptions = {}

      The options to create a new logger.

    Returns Logger

Properties

handlers

handlers: BaseHandler[]

The handlers to use for the logger.

Example: Usage

import { Logger } from "@std/log/logger";
import { ConsoleHandler } from "@std/log/console-handler";
import { assertEquals } from "@std/assert/equals";

const handler = new ConsoleHandler("INFO");
const logger = new Logger("example", "INFO", {
 handlers: [handler],
});

assertEquals(logger.handlers, [handler]);

Accessors

level

  • get level(): LogLevel

  • Getter for the log level.

    Returns LogLevel

    The log level.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { LogLevels } from "@std/log/levels";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");
    assertEquals(logger.level, LogLevels.INFO);
  • set level(level): void

  • Setter for the log level.

    Parameters

    Returns void

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { LogLevels } from "@std/log/levels";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");
    logger.level = LogLevels.DEBUG;

    assertEquals(logger.level, LogLevels.DEBUG);

levelName

  • get levelName(): LevelName

  • Getter for the name of the log level.

    Returns LevelName

    The name of the log level.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");
    assertEquals(logger.levelName, "INFO");
  • set levelName(levelName): void

  • Setter for the name of the log level.

    Parameters

    • levelName: LevelName

      The name of the log level to set.

    Returns void

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { LogLevels } from "@std/log/levels";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");
    logger.levelName = "DEBUG";

    assertEquals(logger.level, LogLevels.DEBUG);

loggerName

  • get loggerName(): string

  • Getter for the name of the logger.

    Returns string

    The name of the logger.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");

    assertEquals(logger.loggerName, "example");

Methods

critical

  • critical<T>(msg, ...args): undefined | T

  • Log at the critical level.

    Type Parameters

    • T

      The type of the message to log.

    Parameters

    • msg: (() => T)

      The message to log.

        • (): T

        • Returns T

    • Rest...args: unknown[]

      Arguments to be formatted into the message.

    Returns undefined | T

    The message that was logged.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");

    assertEquals(logger.critical("Hello, world!"), "Hello, world!");

    assertEquals(logger.critical(() => "Hello, world!"), "Hello, world!");
  • critical<T>(msg, ...args): T

  • Log at the critical level.

    Type Parameters

    • T

      The type of the message to log.

    Parameters

    • msg: T extends GenericFunction
          ? never
          : T

      The message to log.

    • Rest...args: unknown[]

      Arguments to be formatted into the message.

    Returns T

    The message that was logged.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");

    assertEquals(logger.critical("Hello, world!"), "Hello, world!");

    assertEquals(logger.critical(() => "Hello, world!"), "Hello, world!");

debug

  • debug<T>(msg, ...args): undefined | T

  • Log at the debug level.

    Type Parameters

    • T

      The type of the message to log.

    Parameters

    • msg: (() => T)

      The message to log.

        • (): T

        • Returns T

    • Rest...args: unknown[]

      Arguments to be formatted into the message.

    Returns undefined | T

    The message that was logged.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");

    assertEquals(logger.debug("Hello, world!"), "Hello, world!");

    assertEquals(logger.debug(() => "Hello, world!"), undefined);
  • debug<T>(msg, ...args): T

  • Log at the debug level.

    Type Parameters

    • T

      The type of the message to log.

    Parameters

    • msg: T extends GenericFunction
          ? never
          : T

      The message to log.

    • Rest...args: unknown[]

      Arguments to be formatted into the message.

    Returns T

    The message that was logged.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");

    assertEquals(logger.debug("Hello, world!"), "Hello, world!");

    assertEquals(logger.debug(() => "Hello, world!"), undefined);

error

  • error<T>(msg, ...args): undefined | T

  • Log at the error level.

    Type Parameters

    • T

      The type of the message to log.

    Parameters

    • msg: (() => T)

      The message to log.

        • (): T

        • Returns T

    • Rest...args: unknown[]

      Arguments to be formatted into the message.

    Returns undefined | T

    The message that was logged.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");

    assertEquals(logger.error("Hello, world!"), "Hello, world!");

    assertEquals(logger.error(() => "Hello, world!"), "Hello, world!");
  • error<T>(msg, ...args): T

  • Log at the error level.

    Type Parameters

    • T

      The type of the message to log.

    Parameters

    • msg: T extends GenericFunction
          ? never
          : T

      The message to log.

    • Rest...args: unknown[]

      Arguments to be formatted into the message.

    Returns T

    The message that was logged.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");

    assertEquals(logger.error("Hello, world!"), "Hello, world!");

    assertEquals(logger.error(() => "Hello, world!"), "Hello, world!");

info

  • info<T>(msg, ...args): undefined | T

  • Log at the info level.

    Type Parameters

    • T

      The type of the message to log.

    Parameters

    • msg: (() => T)

      The message to log.

        • (): T

        • Returns T

    • Rest...args: unknown[]

      Arguments to be formatted into the message.

    Returns undefined | T

    The message that was logged.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");

    assertEquals(logger.info("Hello, world!"), "Hello, world!");

    assertEquals(logger.info(() => "Hello, world!"), "Hello, world!");
  • info<T>(msg, ...args): T

  • Log at the info level.

    Type Parameters

    • T

      The type of the message to log.

    Parameters

    • msg: T extends GenericFunction
          ? never
          : T

      The message to log.

    • Rest...args: unknown[]

      Arguments to be formatted into the message.

    Returns T

    The message that was logged.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");

    assertEquals(logger.info("Hello, world!"), "Hello, world!");

    assertEquals(logger.info(() => "Hello, world!"), "Hello, world!");

warn

  • warn<T>(msg, ...args): undefined | T

  • Log at the warning level.

    Type Parameters

    • T

      The type of the message to log.

    Parameters

    • msg: (() => T)

      The message to log.

        • (): T

        • Returns T

    • Rest...args: unknown[]

      Arguments to be formatted into the message.

    Returns undefined | T

    The message that was logged.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");

    assertEquals(logger.warn("Hello, world!"), "Hello, world!");

    assertEquals(logger.warn(() => "Hello, world!"), "Hello, world!");
  • warn<T>(msg, ...args): T

  • Log at the warning level.

    Type Parameters

    • T

      The type of the message to log.

    Parameters

    • msg: T extends GenericFunction
          ? never
          : T

      The message to log.

    • Rest...args: unknown[]

      Arguments to be formatted into the message.

    Returns T

    The message that was logged.

    Example: Usage

    import { Logger } from "@std/log/logger";
    import { assertEquals } from "@std/assert/equals";

    const logger = new Logger("example", "INFO");

    assertEquals(logger.warn("Hello, world!"), "Hello, world!");

    assertEquals(logger.warn(() => "Hello, world!"), "Hello, world!");

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods