Class BaseHandlerAbstract

constructor

• new BaseHandler(levelName, options?): BaseHandler

• Constructs a new instance.

  Parameters

  • levelName: LevelName

    The name of the log level to handle.
  • Optionaloptions: BaseHandlerOptions

    Options for the handler.

  Returns BaseHandler

formatter

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!");
Copy

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);
  Copy

• 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);
  Copy

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");
  Copy

• 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");
  Copy

[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);
  Copy

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);
  Copy

format

• format(logRecord): string

• Formats a log record.

  Parameters

  • logRecord: LogRecord

    The log record to format.

  Returns string

  A string representation of the log record.

  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.format(record);
  assertEquals(formatted, "INFO Hello, world!");
  Copy

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);
  Copy

Abstractlog

• log(msg): void

• Logs a message.

  This method should be implemented by subclasses to handle the log record.

  Parameters

  • msg: string

    The message to log.

  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);
    }
  }
  
  const handler = new MyHandler("INFO");
  handler.log("Hello, world!"); // Prints "Hello, world!"
  
  assertInstanceOf(handler, BaseHandler);
  Copy

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);
  Copy