module.exports

pino([options], [stream])

Parameters:

options (object):
- safe (boolean): avoid error caused by circular references in the object tree. Default: true.
- name (string): the name of the logger. Default: undefined.
- serializers (object): an object containing functions for custom serialization of objects. These functions should return an JSONifiable object and they should never throw. When logging an object, each top-level property matching the exact key of a serializer will be serialized using the defined serializer. Alternatively, it is possible to register a serializer under the key Symbol.for('pino.*') which will act upon the complete log object, i.e. every property.
- redact (array|object): As an array, the redact option specifies paths that should have their values redacted from any log output. Each path must be a string, and the syntax for declaring paths corresponds to JavaScript dot and bracket notation. See the redaction documentation for examples and more information. WARNING: Never allow user input to define redacted paths. See fast-redact#caveat for details. If an object is supplied, three options can be specified:
  - paths (array): Required. An array of paths
  - censor (string): Optional. A value to overwrite key which are to be redacted. Default: '[Redacted]'
  - remove (boolean): Optional. Instead of censoring the value, remove both the key and the value. Default: false
- timestamp (boolean|function): Enables or disables the inclusion of a timestamp in the log message. If a function is supplied, it must synchronously return a JSON string representation of the time, e.g. ,"time":1493426328206 (which is the default). If set to false, no timestamp will be included in the output. See stdTimeFunctions for a set of available functions for passing in as a value for this option. Caution: any sort of formatted time will significantly slow down Pino's performance.
- level (string): one of 'fatal', 'error', 'warn', 'info', 'debug', 'trace'; also 'silent' is supported to disable logging. Any other value defines a custom level and requires supplying a level value via levelVal. Default: 'info'.
- levelVal (integer): when defining a custom log level via level, set to an integer value to define the new level. Default: undefined.
- messageKey (string): the string key for the 'message' in the JSON object. Default msg.
- prettyPrint (boolean|object): enables pretty printing log logs. This is intended for non-production configurations. This may be set to a configuration object as outlined in the pino-pretty documentation. The options object may additionally contain a prettifier property to define which prettifier module to use. When not present, prettifier defaults to 'pino-pretty'. Regardless of the value, the specified prettifier module must be installed as a separate dependency. Default: false.
- onTerminated (function): this function will be invoked during process shutdown when extreme is set to true. The signature of the function is onTerminated(eventName, err). If you do not specify a function, Pino will invoke process.exit(0) when no error has occurred, and process.exit(1) otherwise. If you do specify a function, it is up to you to terminate the process; you must perform only synchronous operations at this point. See Extreme mode explained for more detail.
- enabled (boolean): enables logging. Default: true
- browser (Object): browser only, may have asObject and write keys, see Pino in the Browser
- base (Object): key-value object added as child logger to each log line. If set to null the base child logger is not added . Default:
  - pid (process.pid)
  - hostname (os.hostname)
  - name of logger if supplied as option
- crlf (boolean): logs newline delimited JSON with \r\n instead of \n. Default: false.
stream (Writable): a writable stream where the logs will be written. It can also receive some log-line metadata, if the relative protocol is enabled. Default: process.stdout

Example:

'use strict'

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

Discussion:

Returns a new logger instance.

Logger

.pino

Exposes the current version of Pino.

Example:

var log = require('pino')()
if ('pino' in child) console.log(`pino version: ${log.pino}`)

.child(bindings)

Parameters:

bindings (object): an object of key-value pairs to include in log lines as properties.

Example:

logger.child({ a: 'property' }).info('hello child!')
// generates
// {"pid":46497,"hostname":"MacBook-Pro-di-Matteo.local","level":30,"msg":"hello child!","time":1458124707120,"v":0,"a":"property"}

Discussion:

Creates a child logger, setting all key-value pairs in bindings as properties in the log lines. All serializers will be applied to the given pair.

Child loggers use the same output stream as the parent and inherit the current log level of the parent at the time they are spawned.

From v2.x.x the log level of a child is mutable (whereas in v1.x.x it was immutable), and can be set independently of the parent. If a level property is present in the object passed to child it will override the child logger level.

For example:

var logger = pino()
logger.level = 'error'
logger.info('nope') //does not log
var child = logger.child({foo: 'bar'})
child.info('nope again') //does not log
child.level = 'info'
child.info('hooray') //will log
logger.info('nope nope nope') //will not log, level is still set to error
logger.child({ foo: 'bar', level: 'debug' }).debug('debug!')

Child loggers inherit the serializers from the parent logger but it is possible to override them.

For example:

var pino = require('./pino')

var customSerializers = {
  test: function () {
    return 'this is my serializer'
  }
}
var child = pino().child({serializers: customSerializers})

child.info({test: 'should not show up'})

Will produce the following output:

{"pid":7971,"hostname":"mycomputer.local","level":30,"time":1469488147985,"test":"this is my serializer","v":1}

Also from version 2.x.x we can spawn child loggers from child loggers, for instance:

var logger = pino()
var child = logger.child({father: true})
var childChild = child.child({baby: true})

Child logger creation is fast:

benchBunyanCreation*10000: 1291.332ms
benchBoleCreation*10000: 1630.542ms
benchPinoCreation*10000: 352.330ms
benchPinoExtremeCreation*10000: 102.282ms

Logging through a child logger has little performance penalty:

benchBunyanChild*10000: 1343.933ms
benchBoleChild*10000: 1605.969ms
benchPinoChild*10000: 334.573ms
benchPinoExtremeChild*10000: 152.792ms

Spawning children from children has negligible overhead:

benchBunyanChildChild*10000: 1397.202ms
benchPinoChildChild*10000: 338.930ms
benchPinoExtremeChildChild*10000: 150.143ms

.level

Example:

logger.level = 'info'

Discussion:

Set this property to the desired logging level. In order of priority, available levels are:

'fatal'
'error'
'warn'
'info'
'debug'
'trace'

The logging level is a minimum level. For instance if logger.level is 'info' then all 'fatal', 'error', 'warn', and 'info' logs will be enabled.

You can pass 'silent' to disable logging.

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

Parameters:

obj (object): object to be serialized
msg (string): the log message to write
... (*): format string values when msg is a format string

Discussion:

Log at 'fatal' level the given msg. The msg may contain up to 10 format string tokens (given that the method accetps up to 11 arguments total). The subsequent parameters passed will be used to fill in these placeholder tokens with the associated value. Any extra parameters will be silently ignored. For example, log.fatal('%s', 'a', 'b') will only log the string a and ignore the 'b' parameter.