---

---

Why Pail?

• Easy to use
• Hackable to the core
• Integrated timers
• Custom pluggable processors and reporters
• TypeScript support
• Interactive and regular modes
• Secrets & sensitive information filtering
• Filename, date and timestamp support
• Scoped loggers and timers
• Scaled logging levels mechanism
• String interpolation support
• Object and error interpolation
• Stack trace and pretty errors
• Simple and minimal syntax
• Spam prevention by throttling logs
• Browser and Server support
• Redirect console and stdout/stderr to pail and easily restore redirect.
• Pretty or JSON output
• CJS & ESM with tree shaking support
• Supports circular structures
• Fast and powerful, see the benchmarks

Install

1npm install @visulima/pail

1yarn add @visulima/pail

1pnpm add @visulima/pail

Concepts

Most importantly, pail adheres to the log levels defined in [RFC 5424][rfc-5424] extended with trace level. This means that you can use the log levels to filter out messages that are not important to you.

Log Levels

Pail supports the logging levels described by [RFC 5424][rfc-5424].

• DEBUG: Detailed debug information.

• INFO: Interesting events. Examples: User logs in, SQL logs.

• NOTICE: Normal but significant events.

• TRACE: Very detailed and fine-grained informational events.

• WARNING: Exceptional occurrences that are not errors. Examples: Use of deprecated APIs, poor use of an API, undesirable things that are not necessarily wrong.

• ERROR: Runtime errors that do not require immediate action but should typically be logged and monitored.

• CRITICAL: Critical conditions. Example: Application component unavailable, unexpected exception.

• ALERT: Action must be taken immediately. Example: Entire website down, database unavailable, etc. This should trigger the SMS alerts and wake you up.

• EMERGENCY: Emergency: system is unusable.

Reporters

Reporters are responsible for writing the log messages to the console or a file. pail comes with a few built-in reporters:

Browser (console.{function})	Server (stdout or stderr)
JsonReporter	JsonReporter
PrettyReporter	PrettyReporter
x	SimpleReporter
x	FileReporter

Processors

Processors are responsible for processing the log message (Meta Object) before it's written to the console or a file. This usually means that they add some metadata to the record's context property.

A processor can be added to a logger directly (and is subsequently applied to log records before they reach any handler).

pail comes with a few built-in processors:

• CallerProcessor - adds the caller information to the log message
  • The Meta Object is extended with a file name, line number and column number
• RedactProcessor - redacts sensitive information from the log message

  The redact processor needs the "@visulima/redact" package to work. Use npm install @visulima/redact, pnpm add @visulima/redact or yarn add @visulima/redact to install it.

• MessageFormatterProcessor - formats the log message (Util.format-like unescaped string formatting utility) [@visulima/fmt][fmt]
• ErrorProcessor - serializes the error with cause object to a std error object that can be serialized.

Usage

1import { pail } from "@visulima/pail";
2
3pail.success("Operation successful");
4pail.debug("Hello", "from", "L59");
5pail.pending("Write release notes for %s", "1.2.0");
6pail.fatal(new Error("Unable to acquire lock"));
7pail.watch("Recursively watching build directory...");
8pail.complete({
9    prefix: "[task]",
10    message: "Fix issue #59",
11    suffix: "(@prisis)",
12});

Custom Loggers

To create a custom logger define an options object yielding a types field with the logger data and pass it as argument to the createPail function.

1import { createPail } from "@visulima/pail";
2
3const custom = createPail({
4    types: {
5        remind: {
6            badge: "**",
7            color: "yellow",
8            label: "reminder",
9            logLevel: "info",
10        },
11        santa: {
12            badge: "🎅",
13            color: "red",
14            label: "santa",
15            logLevel: "info",
16        },
17    },
18});
19
20custom.remind("Improve documentation.");
21custom.santa("Hoho! You have an unused variable on L45.");

Here is an example where we override the default error and success loggers.

1import { pail, createPail } from "@visulima/pail";
2
3pail.error("Default Error Log");
4pail.success("Default Success Log");
5
6const custom = createPail({
7    scope: "custom",
8    types: {
9        error: {
10            badge: "!!",
11            label: "fatal error",
12        },
13        success: {
14            badge: "++",
15            label: "huge success",
16        },
17    },
18});
19
20custom.error("Custom Error Log");
21custom.success("Custom Success Log");

Scoped Loggers

To create a scoped logger from scratch, define the scope field inside the options object and pass it as argument to the createPail function.

1import { createPail } from "@visulima/pail";
2
3const mayAppLogger = createPail({
4    scope: "my-app",
5});
6
7mayAppLogger.info("Hello from my app");

To create a scoped logger based on an already existing one, use the scope() function, which will return a new pail instance, inheriting all custom loggers, timers, secrets, streams, configuration, log level, interactive mode & disabled statuses from the initial one.

1import { pail } from "@visulima/pail";
2
3const global = pail.scope("global scope");
4
5global.success("Hello from the global scope");
6
7function foo() {
8    const outer = global.scope("outer", "scope");
9    outer.success("Hello from the outer scope");
10
11    setTimeout(() => {
12        const inner = outer.scope("inner", "scope");
13        inner.success("Hello from the inner scope");
14    }, 500);
15}
16
17foo();

Interactive Loggers (Only on if stdout and stderr is a TTY)

To initialize an interactive logger, create a new pail instance with the interactive attribute set to true. While into the interactive mode, previously logged messages originating from an interactive logger, will be overridden only by new ones originating from the same or a different interactive logger. Note that regular messages originating from regular loggers are not overridden by the interactive ones.

1import { createPail } from "@visulima/pail";
2
3console.log("\n");
4
5const pail = createPail();
6
7const interactive = createPail({ interactive: true });
8
9pail.info("This is a log message 1");
10
11setTimeout(() => {
12    interactive.await("[%d/4] - Process A", 1);
13    setTimeout(() => {
14        interactive.success("[%d/4] - Process A", 2);
15        setTimeout(() => {
16            interactive.await("[%d/4] - Process B", 3);
17            setTimeout(() => {
18                interactive.error("[%d/4] - Process B", 4);
19            }, 1000);
20        }, 1000);
21    }, 1000);
22});
23
24pail.info("This is a log message 2");
25pail.info("This is a log message 3");
26pail.info("This is a log message 4");

For a more complex example, use can use the getInteractiveManager function, see the following code:

1import { createPail } from "@visulima/pail";
2
3const interactive = createPail({ interactive: true });
4
5const TICKS = 60;
6const TIMEOUT = 80;
7const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
8const messages = ["Swapping time and space...", "Have a good day.", "Don't panic...", "Updating Updater...", "42"];
9let ticks = TICKS;
10let i = 0;
11
12const interactiveManager = interactive.getInteractiveManager();
13
14interactiveManager.hook();
15
16// eslint-disable-next-line no-console
17console.log(" - log message");
18// eslint-disable-next-line no-console
19console.error(" - error message");
20// eslint-disable-next-line no-console
21console.warn(" - warn message");
22
23const id = setInterval(() => {
24    if (--ticks < 0) {
25        clearInterval(id);
26
27        interactiveManager.update(["✔ Success", "", "Messages:", "this line will be deleted!!!"]);
28        interactiveManager.erase(1);
29        interactiveManager.unhook(false);
30    } else {
31        const frame = frames[(i = ++i % frames.length)];
32        const index = Math.round(ticks / 10) % messages.length;
33        const message = messages[index];
34
35        if (message) {
36            interactiveManager.update([`${frame} Some process...`, message]);
37        }
38    }
39}, TIMEOUT);

Timers

Timer are managed by the time(), timeLog() and timeEnd() functions. A unique label can be used to identify a timer on initialization, though if none is provided the timer will be assigned one automatically. In addition, calling the timeEnd() function without a specified label will have as effect the termination of the most recently initialized timer, that was created without providing a label.

1import { pail } from "@visulima/pail";
2
3pail.time("test");
4pail.time();
5pail.timeLog("default", "Hello");
6
7setTimeout(() => {
8    pail.timeEnd();
9    pail.timeEnd("test");
10}, 500);

Its also possible to change the text inside time() and timeEnd() by using the options object.

1import { createPail } from "@visulima/pail";
2
3const pail = createPail({
4    messages: {
5        timerStart: "Start Timer:",
6        timerEnd: "End Timer:",
7    },
8});
9
10pail.time("test");
11pail.timeEnd("test");

Disable and Enable Loggers

To disable a logger, use the disable() function, which will prevent any log messages from being written to the console or a file.

1import { pail } from "@visulima/pail";
2
3pail.disable();
4pail.success("This message will not be logged");

To enable a logger, use the enable() function, which will allow log messages to be written to the console or a file.

1import { pail } from "@visulima/pail";
2
3pail.disable();
4pail.success("This message will not be logged");
5pail.enable();
6pail.success("This message will be logged");

Api

Supported Node.js Versions

Libraries in this ecosystem make the best effort to track Node.js’ release schedule. Here’s a post on why we think this is important.

Contributing

If you would like to help take a look at the list of issues and check our Contributing guild.

Note: please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.

Credits

• Daniel Bannert
• All Contributors

About

Related Projects

• pino - 🌲 super fast, all natural json logger
• winston - A logger for just about everything.
• signale - Highly configurable logging utility
• consola - 🐨 Elegant Console Logger for Node.js and Browser

License

The visulima pail is open-sourced software licensed under the [MIT][license-url]

[typescript-url]: https://www.typescriptlang.org/ "TypeScript" "typescript" [license-image]: https://img.shields.io/npm/l/@visulima/pail?color=blueviolet&style=for-the-badge [license-url]: LICENSE.md "license" [npm-image]: https://img.shields.io/npm/v/@visulima/pail/latest.svg?style=for-the-badge&logo=npm [npm-url]: https://www.npmjs.com/package/@visulima/pail/v/latest "npm" [rfc-5424]: https://datatracker.ietf.org/doc/html/rfc5424#page-36 [fmt]: https://github.com/visulima/visulima/tree/main/packages/fmt