tdb-alcorn/nice-logger

nice-logger

A logger with levels and a nice format.

Example

var Logger = require("nice-logger");

var log = new Logger("main", "error");

try {
    log.debug("Uh oh.");
    /* Something dangerous. */
} catch (error) {
    log.error(error);  // Stack trace is automatically logged for Error objects.
}

Usage

Use it like log.<level>(arg1, arg2, ...). You can pass in as many arguments as you'd like. Anything that is not an Error or a String will be JSON stringified.

The logger normally writes to process.stdout. If any of the arguments is an Error object, the logger will write the whole message to stderr instead of stdout (so call error.toString() first if you'd like the logger to write to stdout.

Levels

The five allowed levels are, in descending order of priority:

1. critical
2. error
3. warning
4. info
5. debug

You can (optionally) pass in a level as the second argument of the Logger constructor. This will set the default level. If you pass in something unrecognized, or don't pass in anything at all, the default level is set lower than debug. In other words, everything will get logged by default.

Methods

Logging methods:

• #critical(...): Log a message at the critical level.
• #error(...): Log a message at the critical level.
• #warning(...): Log a message at the warning level.
• #info(...): Log a message at the info level.
• #debug(...): Log a message at the debug level.

Other methods:

• #out(String): Write to process.stdout.
• #err(String): Write to process.stderr.
• #setLevel(level): Change the logger level.

nice-logger's Issues

Use util.inspect to represent objects

Maybe set the default options based on log level. E.g. for debug level you want more detail so set showHidden: true etc.

Functions are not printed when they are attributes of objects

var obj = {x: 1, y: "foo", z: function() { return true; }};
log.info(obj);
>> {"x": 1, "y": "foo"}

This occurs because the logger defaults to calling JSON.stringify on anything that isn't a String or an Error, and JSON.stringify does not serialize functions because it is intended as a wire serialization format.

Add an object stringifier (that makes an effort to print everything, including functions), and call it in a new case for handling objects.

Errors where the constructor is not `Error` are swallowed.

For example, TypeErrors fall through to the default handler (which JSON.stringifys them, effectively swallowing them). The handler should instead check err instanceof Error, or possibly just check for the existence of the .stack key.

Prints entire function definition, which is obnoxiously long in many cases.

The logger should print only function names, and maybe signatures, and perhaps file/line number where the definition can be found. Full definitions tend to clutter up the logs.

Output JSON

Create an option to output json logs for use with a service like loggly.

Objects without a .constructor cause logger to throw an error.

Catch it!

Use util.debuglog as output function to adhere to NODE_DEBUG convention