@std/log@0.218.2

Built and signed on GitHub Actions

Built and signed on GitHub Actions

import * as log from "@std/log";

// Simple default logger out of the box. You can customize it
// by overriding logger and handler named "default", or providing
// additional logger configurations. You can log any data type.
log.debug("Hello world");
log.info(123456);
log.warn(true);
log.error({ foo: "bar", fizz: "bazz" });
log.critical("500 Internal server error");

// custom configuration with 2 loggers (the default and `tasks` loggers).
log.setup({
  handlers: {
    console: new log.ConsoleHandler("DEBUG"),

    file: new log.FileHandler("WARN", {
      filename: "./log.txt",
      // you can change format of output message using any keys in `LogRecord`.
      formatter: (record) => `${record.levelName} ${record.msg}`,
    }),
  },

  loggers: {
    // configure default logger available via short-hand methods above.
    default: {
      level: "DEBUG",
      handlers: ["console", "file"],
    },

    tasks: {
      level: "ERROR",
      handlers: ["console"],
    },
  },
});

let logger;

// get default logger.
logger = log.getLogger();
logger.debug("fizz"); // logs to `console`, because `file` handler requires "WARN" level.
logger.warn(41256); // logs to both `console` and `file` handlers.

// get custom logger
logger = log.getLogger("tasks");
logger.debug("fizz"); // won't get output because this logger has "ERROR" level.
logger.error({ productType: "book", value: "126.11" }); // log to `console`.

// if you try to use a logger that hasn't been configured
// you're good to go, it gets created automatically with level set to 0
// so no message is logged.
const unknownLogger = log.getLogger("mystery");
unknownLogger.info("foobar"); // no-op

import * as log from "@std/log";

log.setup({
  handlers: {
    stringFmt: new log.ConsoleHandler("DEBUG", {
      formatter: (record) => `[${record.levelName}] ${record.msg}`,
    }),

    functionFmt: new log.ConsoleHandler("DEBUG", {
      formatter: (logRecord) => {
        let msg = `${logRecord.level} ${logRecord.msg}`;

        logRecord.args.forEach((arg, index) => {
          msg += `, arg${index}: ${arg}`;
        });

        return msg;
      },
    }),

    anotherFmt: new log.ConsoleHandler("DEBUG", {
      formatter: (record) => `[${record.loggerName}] - ${record.levelName} ${record.msg}`,
    }),
  },

  loggers: {
    default: {
      level: "DEBUG",
      handlers: ["stringFmt", "functionFmt"],
    },
    dataLogger: {
      level: "INFO",
      handlers: ["anotherFmt"],
    },
  },
});

// calling:
log.debug("Hello, world!", 1, "two", [3, 4, 5]);
// results in: [DEBUG] Hello, world!
// output from "stringFmt" handler.
// 10 Hello, world!, arg0: 1, arg1: two, arg3: [3, 4, 5] // output from "functionFmt" formatter.

// calling:
log.getLogger("dataLogger").error("oh no!");
// results in:
// [dataLogger] - ERROR oh no! // output from anotherFmt handler.

import * as log from "@std/log";

log.setup({
  handlers: {
    jsonStdout: new log.ConsoleHandler("DEBUG", {
      formatter: log.formatters.jsonFormatter,
      useColors: false,
    }),
  },

  loggers: {
    default: {
      level: "DEBUG",
      handlers: ["jsonStdout"],
    },
  },
});

// calling:
log.info("Hey");
// results in:
// {"level":"INFO","datetime":1702481922294,"message":"Hey"}

// calling:
log.info("Hey", { product: "nail" });
// results in:
// {"level":"INFO","datetime":1702484111115,"message":"Hey","args":{"product":"nail"}}

// calling:
log.info("Hey", 1, "two", [3, 4, 5]);
// results in:
// {"level":"INFO","datetime":1702481922294,"message":"Hey","args":[1,"two",[3,4,5]]}

import * as log from "@std/log";

log.setup({
  handlers: {
    customJsonFmt: new log.ConsoleHandler("DEBUG", {
      formatter: (record) => JSON.stringify({
        lvl: record.level,
        msg: record.msg,
        time: record.datetime.toISOString(),
        name: record.loggerName,
      }),
      useColors: false,
    }),
  },

  loggers: {
    default: {
      level: "DEBUG",
      handlers: ["customJsonFmt"],
    },
  },
});

// calling:
log.info("complete");
// results in:
// {"lvl":20,"msg":"complete","time":"2023-12-13T16:38:27.328Z","name":"default"}

import * as logger from "@std/log";

const stringData: string = logger.debug("hello world");
const booleanData: boolean = logger.debug(true, 1, "abc");
const fn = (): number => {
  return 123;
};
const resolvedFunctionData: number = logger.debug(fn());
console.log(stringData); // 'hello world'
console.log(booleanData); // true
console.log(resolvedFunctionData); // 123

import * as log from "@std/log";

log.setup({
  handlers: {
    console: new log.ConsoleHandler("DEBUG"),
  },

  loggers: {
    tasks: {
      level: "ERROR",
      handlers: ["console"],
    },
  },
});

function someExpensiveFn(num: number, bool: boolean) {
  // do some expensive computation
}

// not logged, as debug < error.
const data = log.debug(() => someExpensiveFn(5, true));
console.log(data); // undefined

Handlers are responsible for actual output of log messages. When a handler is called by a logger, it firstly checks that LogRecord's level is not lower than level of the handler. If level check passes, handlers formats log record into string and outputs it to target.

Custom handlers

Custom handlers can be implemented by subclassing BaseHandler or WriterHandler.

BaseHandler is bare-bones handler that has no output logic at all,

WriterHandler is an abstract class that supports any target with Writer interface.

During setup async hooks setup and destroy are called, you can use them to open and close file/HTTP connection or any other action you might need.

For examples check source code of FileHandlerandTestHandler`.