pino-pretty

The customPrettifiers option allows you to define custom formatting functions for specific log properties. This includes standard keys like time, hostname, pid, name, caller, and level, as well as any arbitrary key in your log object.

Each prettifier function follows this signature: (output, keyName, logObj, extras) => string

• output: The value of the property being prettified.
• keyName: The name of the property.
• logObj: The full log object.
• extras: An object containing additional context. For level prettifiers, it includes label, labelColorized, and a colors object (a Colorette instance).

You can use pino-pretty as a stream by calling the pretty() function and passing the resulting stream to the pino constructor.

If you need to provide Pino configuration options (like level) while using a stream, pass the Pino options as the first argument and the pino-pretty stream as the second argument.

To use the pino-pretty CLI tool, install it globally using npm:

npm install -g pino-pretty

When using Pino v7+ transports, options passed via the transport configuration must be serializable. If you need to use non-serializable options (such as a messageFormat function), you must wrap pino-pretty in a custom module that acts as the transport target.

// main.js
const pino = require('pino')

const logger = pino({
  transport: {
    target: './pino-pretty-transport',
    options: {
      colorize: true
    }
  },
})

logger.info('world')

// pino-pretty-transport.js
module.exports = opts => require('pino-pretty')({
  ...opts,
  messageFormat: (log, messageKey) => `hello ${log[messageKey]}`
})

Logging with Jest can be problematic because the framework requires no asynchronous operations to continue after a test finishes. To use pino-pretty with Jest, you must use the sync: true option to ensure logs are written synchronously.

import pino from 'pino'
import pretty from 'pino-pretty'

test('test pino-pretty', () => {
  const logger = pino(pretty({ sync: true }));
  logger.info('Info');
  logger.error('Error');
});

The recommended way to use pino-pretty is to pipe the output of your pino logger directly to the pino-pretty CLI tool in your terminal. This allows you to keep your application producing standard NDJSON logs while viewing prettified logs during development.

node app.js | pino-pretty

To use pino-pretty within your application code, it is recommended to install it as a development dependency. You can integrate it using the Pino transport option by setting the target to 'pino-pretty'. You can also pass a configuration object to the options key to customize the output.

Note: It is recommended to only activate pino-pretty when the output is a TTY (e.g., in development mode) to avoid performance issues in production.

const pino = require('pino')
const logger = pino({
  transport: {
    target: 'pino-pretty',
    options: {
      colorize: true
    }
  },
})

logger.info('hi')

To make logs from journalctl more human-readable and remove redundant metadata, combine journalctl -o cat with specific pino-pretty flags:

• -t: Formats the timestamp into a human-readable string.
• -i <keys>: Filters out specific keys (like pid or hostname) from the output.

Example command:

journalctl -u monitor -f -o cat | pino-pretty -t -i pid,hostname

This results in a clean, readable format such as: [2020-04-24 05:42:24.836 +0000] INFO : TT 21

When running a Node.js process via Systemd and viewing logs with journalctl, metadata like timestamps, hostnames, and PIDs may appear twice: once from journalctl and once from pino-pretty.

To prevent this duplication, use the -o cat option with journalctl to output only the raw log content before piping it to pino-pretty.

Example workflow:

1. Problematic (duplicated data): journalctl -u monitor -f | pino-pretty
2. Correct (clean output): journalctl -u monitor -f -o cat | pino-pretty

Instead of passing many CLI arguments, you can specify a path to a JSON file containing your pino-pretty configuration using the -C or --config flag.

cat log | pino-pretty --config=/path/to/config.json

You can use the pino-pretty command-line tool to format raw Pino logs. The most common usage pattern is to pipe a log file or a log stream into the command.

cat log | pino-pretty