pino

What is pino?

Pino is a very low overhead Node.js logger, which is inspired by Bunyan. It is designed to be as minimal as possible and to perform logging tasks with a very small performance overhead. Pino provides a simple to use API for structured logging and can be easily integrated with different transports for log processing.

What are pino's main functionalities?

Basic Logging

This feature allows you to perform basic logging tasks, such as logging informational messages.

const pino = require('pino');
const logger = pino();
logger.info('Hello, this is an info message!');

Logging with Different Levels

Pino allows you to log messages with different severity levels, such as error, warn, and debug.

const logger = pino();
logger.error('This is an error message');
logger.warn('This is a warning message');
logger.debug('This is a debug message');

Child Loggers

You can create child loggers from a parent logger, which can inherit the configuration of the parent and can also have additional properties.

const parentLogger = pino();
const childLogger = parentLogger.child({ a: 'property' });
childLogger.info('Hello from child logger');

Custom Serializers

Pino allows you to define custom serializers for logging objects in a specific way.

const logger = pino({
  serializers: {
    req: (req) => ({ method: req.method, url: req.url })
  }
});
logger.info({ req: requestObject }, 'Request log message');

Pretty Printing

For development purposes, Pino can be combined with the 'pino-pretty' module to format logs in a more readable way.

const pino = require('pino');
const pretty = require('pino-pretty');
const logger = pino(pretty());
logger.info('This will be pretty printed');

Other packages similar to pino

winston

Winston is a multi-transport async logging library for Node.js. It is designed to be a simple and universal logging library with support for multiple transports. Compared to Pino, Winston is more feature-rich and configurable but can be heavier on performance.

bunyan

Bunyan is a simple and fast JSON logging library for Node.js services. Like Pino, it is inspired by the Unix philosophy and focuses on structured logging. Bunyan is more similar to Pino in terms of philosophy, but Pino claims to be faster and more efficient.

log4js

Log4js is a logging framework for Node.js, which provides flexible configuration and supports multiple appenders. It is similar to the Log4j library for Java. Compared to Pino, Log4js offers more traditional logging features but may not be as performance-optimized.

README

pino

Extremely fast node.js logger, inspired by Bunyan. It also includes a shell utility to pretty-print its log files.

• Installation
• Usage
• API
• Benchmarks
• How do I rotate log files?
• Acknowledgements
• License

Install

npm install pino --save

Usage

'use strict'

var pino = require('pino')(
  // or any other stream
  // defaults to stdout
  process.stdout
)
var info = pino.info
var error = pino.error

info('hello world')
info('the answer is %d', 42)
info({ obj: 42 }, 'hello world')
setImmediate(info, 'wrapped')
error(new Error('something bad happened'))

This produces:

{"pid":12244,"hostname":"MBP-di-Matteo","level":30,"msg":"hello world","time":"2016-03-05T16:00:45.858Z","v":0}
{"pid":12244,"hostname":"MBP-di-Matteo","level":50,"msg":"this is at error level","time":"2016-03-05T16:00:45.860Z","v":0}
{"pid":12244,"hostname":"MBP-di-Matteo","level":30,"msg":"the answer is 42","time":"2016-03-05T16:00:45.861Z","v":0}
{"pid":12244,"hostname":"MBP-di-Matteo","level":30,"msg":"hello world","time":"2016-03-05T16:00:45.861Z","v":0,"obj":42}
{"pid":12244,"hostname":"MBP-di-Matteo","level":30,"msg":"hello world","time":"2016-03-05T16:00:45.862Z","v":0,"obj":42,"b":2}
{"pid":12244,"hostname":"MBP-di-Matteo","level":30,"msg":"another","time":"2016-03-05T16:00:45.862Z","v":0,"obj":{"aa":"bbb"}}
{"pid":12244,"hostname":"MBP-di-Matteo","level":50,"msg":"an error","time":"2016-03-05T16:00:45.863Z","v":0,"type":"Error","stack":"Error: an error\n    at Object.<anonymous> (/Users/matteo/Repositories/pino/example.js:14:7)\n    at Module._compile (module.js:435:26)\n    at Object.Module._extensions..js (module.js:442:10)\n    at Module.load (module.js:356:32)\n    at Function.Module._load (module.js:313:12)\n    at Function.Module.runMain (module.js:467:10)\n    at startup (node.js:136:18)\n    at node.js:963:3"}
{"pid":12244,"hostname":"MBP-di-Matteo","level":30,"msg":"after setImmediate","time":"2016-03-05T16:00:45.865Z","v":0}

## API

• pino()
• logger.level
• logger.fatal()
• logger.error()
• logger.warn()
• logger.info()
• logger.debug()
• logger.trace()
• pino.stdSerializers.req
• pino.stdSerializers.res

pino([opts], [stream])

Returns a new logger. Allowed options are:

• safe: avoid error causes by circular references in the object tree, default true
• name: the name of the logger, default undefined
• serializers: an object containing functions for custom serialization of objects. These functions should return an jsonificable object and they should never throw.

stream is a Writable stream, defaults to process.stdout.

Example:

'use strict'

var pino = require('pino')
var instance = pino({
  name: 'myapp',
  safe: true,
  serializers: {
    req: pino.stdSerializers.req
    res: pino.stdSerializers.res
  }
}

logger.level

Property to read and write the current level of the logger. In order of priotity, avaliable levels are:

1. 'fatal'
2. 'error'
3. 'warn'
4. 'info'
5. 'debug'
6. 'trace'

By setting a given level (e.g. logger.level = 'info') you enable all the levels including and above the passed one (in the example, info, warn, error and fatal). The default is info.

logger.fatal([obj], msg, [...])

Log at 'fatal' level the given msg. If the first argument is an object, all its properties will be included in the JSON line. If more args follows msg, these will be used to format msg using util.format

logger.error([obj], msg, [...])

Log at 'error' level the given msg. If the first argument is an object, all its properties will be included in the JSON line. If more args follows msg, these will be used to format msg using util.format

logger.warn([obj], msg, [...])

Log at 'warn' level the given msg. If the first argument is an object, all its properties will be included in the JSON line. If more args follows msg, these will be used to format msg using util.format

logger.info([obj], msg, [...])

Log at 'info' level the given msg. If the first argument is an object, all its properties will be included in the JSON line. If more args follows msg, these will be used to format msg using util.format

logger.debug([obj], msg, [...])

Log at 'debug' level the given msg. If the first argument is an object, all its properties will be included in the JSON line. If more args follows msg, these will be used to format msg using util.format

logger.trace([obj], msg, [...])

Log at 'trace' level the given msg. If the first argument is an object, all its properties will be included in the JSON line. If more args follows msg, these will be used to format msg using util.format

pino.stdSerializers.req

Function to generate a jsonificable object out of an HTTP request from node HTTP server.

It returns an object in the form:

{
  pid: 93535,
  hostname: 'your host',
  level: 30,
  msg: 'my request',
  time: '2016-03-07T12:21:48.766Z',
  v: 0,
  req: {
    method: 'GET',
    url: '/',
    headers: {
      host: 'localhost:50201',
      connection: 'close'
    },
    remoteAddress: '::ffff:127.0.0.1',
    remotePort: 50202
  }
}

pino.stdSerializers.res

Function to generate a jsonificable object out of an HTTP response from node HTTP server.

It returns an object in the form:

{
  pid: 93581,
  hostname: 'myhost',
  level: 30,
  msg: 'my response',
  time: '2016-03-07T12:23:18.041Z',
  v: 0,
  res: {
    statusCode: 200,
    header: 'HTTP/1.1 200 OK\r\nDate: Mon, 07 Mar 2016 12:23:18 GMT\r\nConnection: close\r\nContent-Length: 5\r\n\r\n'
  }
}

Benchmarks

As far as I know, it is the fastest logger in town:

benchBunyan*10000: 1116.721ms
benchWinston*10000: 1783.362ms
benchBole*10000: 1496.580ms
benchPino*10000: 363.430ms
benchBunyanObj*10000: 1228.538ms
benchWinstonObj*10000: 1895.251ms
benchPinoObj*10000: 427.989ms
benchBoleObj*10000: 1487.543ms
benchBunyan*10000: 1088.231ms
benchWinston*10000: 1733.589ms
benchBole*10000: 1514.004ms
benchPino*10000: 377.418ms
benchBunyanObj*10000: 1205.833ms
benchWinstonObj*10000: 1800.594ms
benchPinoObj*10000: 412.170ms
benchBoleObj*10000: 1522.469ms

How do I rotate log files

You should configure logrotate to rotate your log files, and just redirect the standard output of your application to a file, like so:

node server.js > /var/log/myapp.log

In order to rotate your log files, add in /etc/logrotate.d/myapp:

/var/log/myapp.log {
       su root
       daily
       rotate 7
       delaycompress
       compress
       notifempty
       missingok
       copytruncate
}

Acknowledgements

This project was kindly sponsored by nearForm.

License

MIT