Class ConsoleHandler

Default logger that outputs log messages to the console via console.log.

Example: Usage

import { ConsoleHandler } from "@std/log/console-handler";

const handler = new ConsoleHandler("INFO");
handler.log("Hello, world!"); // Prints "Hello, world!"
Hierarchy

Constructors

constructor

Properties

formatter

Accessors

level levelName

Methods

[dispose] destroy format handle log setup

Constructors

constructor

Properties

formatter

formatter: FormatterFunction

The function that formats log records.

Example: Usage

import { BaseHandler } from "@std/log/base-handler";
import { LogRecord } from "@std/log/logger";
import { LogLevels } from "@std/log/levels";
import { assertEquals } from "@std/assert/equals";

class MyHandler extends BaseHandler {
 log(msg: string) {
  console.log(msg);
}
}

const handler = new MyHandler("INFO");
const record = new LogRecord({
  msg: "Hello, world!",
  args: ["foo", "bar"],
  level: LogLevels.INFO,
  loggerName: "example",
});
const formatted = handler.formatter(record);
assertEquals(formatted, "INFO Hello, world!");

Accessors

level

  • get level(): LogLevel

  • Getter for the log level that this handler will handle.

    Returns LogLevel

    The log level to handle.

    Example: Usage

    import { BaseHandler } from "@std/log/base-handler";
    import { LogLevels } from "@std/log/levels";
    import { assertEquals } from "@std/assert/equals";

    class MyHandler extends BaseHandler {
      log(msg: string) {
        console.log(msg);
      }
    }

    const handler = new MyHandler("INFO");
    assertEquals(handler.level, LogLevels.INFO);
  • set level(level): void

  • Setter for the log level that this handler will handle.

    Parameters

    • level: LogLevel

      The log level to handle.

    Returns void

    Example: Usage

    import { BaseHandler } from "@std/log/base-handler";
    import { LogLevels } from "@std/log/levels";
    import { assertEquals } from "@std/assert/equals";

    class MyHandler extends BaseHandler {
      log(msg: string) {
        console.log(msg);
      }
    }

    const handler = new MyHandler("INFO");
    handler.level = LogLevels.DEBUG;
    assertEquals(handler.level, LogLevels.DEBUG);

levelName

  • get levelName(): LevelName

  • Getter for the name of the log level that this handler will handle.

    Returns LevelName

    The name of the log level to handle.

    Example: Usage

    import { BaseHandler } from "@std/log/base-handler";
    import { assertEquals } from "@std/assert/equals";

    class MyHandler extends BaseHandler {
      log(msg: string) {
        console.log(msg);
      }
    }

    const handler = new MyHandler("INFO");
    assertEquals(handler.levelName, "INFO");
  • set levelName(levelName): void

  • Setter for the name of the log level that this handler will handle.

    Parameters

    • levelName: LevelName

      The name of the log level to handle.

    Returns void

    Example: Usage

    import { BaseHandler } from "@std/log/base-handler";
    import { assertEquals } from "@std/assert/equals";

    class MyHandler extends BaseHandler {
      log(msg: string) {
        console.log(msg);
      }
    }

    const handler = new MyHandler("INFO");
    handler.levelName = "DEBUG";
    assertEquals(handler.levelName, "DEBUG");

Methods

[dispose]

  • [dispose](): void

  • Automatically disposes of the handler when instantiated with the using keyword by calling the BaseHandler.destroy method.

    Returns void

    Example: Usage

    import { BaseHandler } from "@std/log/base-handler";
    import { LogRecord } from "@std/log/logger";
    import { assertInstanceOf } from "@std/assert/instance-of";

    class MyHandler extends BaseHandler {
      log(msg: string) {
        console.log(msg);
      }
    }

    using handler = new MyHandler("INFO");
    assertInstanceOf(handler, BaseHandler);

destroy

  • destroy(): void

  • Destroys the handler, performing any cleanup that is required.

    This method is called when the handler is removed from a logger. It can be used to perform any cleanup that is required by the handler.

    Returns void

    Example: Usage

    import { BaseHandler } from "@std/log/base-handler";
    import { assertInstanceOf } from "@std/assert/instance-of";

    class MyHandler extends BaseHandler {
      log(msg: string) {
        console.log(msg);
      }

      override destroy() {
        console.log("Handler destroyed!");
      }
    }

    const handler = new MyHandler("INFO");
    handler.destroy(); // Prints "Handler destroyed!"
    assertInstanceOf(handler, BaseHandler);

format

  • format(logRecord): string

  • Formats a log record into a string.

    Parameters

    • logRecord: LogRecord

      The log record to format.

    Returns string

    The formatted log record.

    Example: Usage

    import { ConsoleHandler } from "@std/log/console-handler";
    import { LogRecord } from "@std/log/logger";
    import { LogLevels } from "@std/log/levels";
    import { assertEquals } from "@std/assert/equals";
    import { blue } from "@std/fmt/colors";

    const handler = new ConsoleHandler("INFO");
    const logRecord = new LogRecord({
      msg: "Hello, world!",
      args: ["foo", "bar"],
      level: LogLevels.INFO,
      loggerName: "my-logger",
    });
    const result = handler.format(logRecord);

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

handle

  • handle(logRecord): void

  • Handles a log record.

    Parameters

    • logRecord: LogRecord

      The log record to handle.

    Returns void

    Example: Usage

    import { BaseHandler } from "@std/log/base-handler";
    import { LogRecord } from "@std/log/logger";
    import { LogLevels } from "@std/log/levels";
    import { assertInstanceOf } from "@std/assert/instance-of";

    class MyHandler extends BaseHandler {
      log(msg: string) {
        console.log(msg);
      }
    }

    const handler = new MyHandler("INFO");
    const record = new LogRecord({
      msg: "Hello, world!",
      args: ["foo", "bar"],
      level: LogLevels.INFO,
      loggerName: "example",
    });
    handler.handle(record);

    assertInstanceOf(handler, BaseHandler);

log

  • log(msg): void

  • Logs a message to the console.

    Parameters

    • msg: string

      The message to log.

    Returns void

    Example: Usage

    import { ConsoleHandler } from "@std/log/console-handler";

    const handler = new ConsoleHandler("INFO");
    handler.log("Hello, world!"); // Prints "Hello, world!"

setup

  • setup(): void

  • Initializes the handler.

    This method is called when the handler is added to a logger. It can be used to perform any setup that is required by the handler.

    Returns void

    Example: Usage

    import { BaseHandler } from "@std/log/base-handler";
    import { assertInstanceOf } from "@std/assert/instance-of";

    class MyHandler extends BaseHandler {
      log(msg: string) {
        console.log(msg);
      }

      override setup() {
        console.log("Handler setup!");
      }
    }

    const handler = new MyHandler("INFO");
    handler.setup(); // Prints "Handler setup!"

    assertInstanceOf(handler, BaseHandler);

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods