Interface LoggerOptions<CustomLevels, UseOnlyCustomLevels>

The asObject option will create a pino-like log object instead of passing all arguments to a console method. When write is set, asObject will always be true.

Example

pino.info('hi') // creates and logs {msg: 'hi', level: 30, time: <ts>}
Copy

Instead of passing log messages to console.log they can be passed to a supplied function. If write is set to a single function, all logging objects are passed to this function. If write is an object, it can have methods that correspond to the levels. When a message is logged at a given level, the corresponding method is called. If a method isn't present, the logging falls back to using the console.

Example

const pino = require('pino')({
  browser: {
    write: (o) => {
      // do something with o
    }
  }
})
Copy

Example

const pino = require('pino')({
  browser: {
    write: {
      info: function (o) {
        //process info log object
      },
      error: function (o) {
        //process error log object
      }
    }
  }
})
Copy

The serializers provided to pino are ignored by default in the browser, including the standard serializers provided with Pino. Since the default destination for log messages is the console, values such as Error objects are enhanced for inspection, which they otherwise wouldn't be if the Error serializer was enabled. We can turn all serializers on or we can selectively enable them via an array.

When serialize is true the standard error serializer is also enabled (see https://github.com/pinojs/pino/blob/master/docs/api.md#pino-stdserializers). This is a global serializer which will apply to any Error objects passed to the logger methods.

If serialize is an array the standard error serializer is also automatically enabled, it can be explicitly disabled by including a string in the serialize array: !stdSerializers.err (see example).

The serialize array also applies to any child logger serializers (see https://github.com/pinojs/pino/blob/master/docs/api.md#bindingsserializers-object for how to set child-bound serializers).

Unlike server pino the serializers apply to every object passed to the logger method, if the asObject option is true, this results in the serializers applying to the first object (as in server pino).

For more info on serializers see https://github.com/pinojs/pino/blob/master/docs/api.md#serializers-object.

Example

const pino = require('pino')({
  browser: {
    serialize: true
  }
})
Copy

Example

const pino = require('pino')({
  serializers: {
    custom: myCustomSerializer,
    another: anotherSerializer
  },
  browser: {
    serialize: ['custom']
  }
})
// following will apply myCustomSerializer to the custom property,
// but will not apply anotherSerializer to another key
pino.info({custom: 'a', another: 'b'})
Copy

Example

const pino = require('pino')({
  serializers: {
    custom: myCustomSerializer,
    another: anotherSerializer
  },
  browser: {
    serialize: ['!stdSerializers.err', 'custom'] //will not serialize Errors, will serialize `custom` keys
  }
})
Copy

Options for transmission of logs.

Example

const pino = require('pino')({
  browser: {
    transmit: {
      level: 'warn',
      send: function (level, logEvent) {
        if (level === 'warn') {
          // maybe send the logEvent to a separate endpoint
          // or maybe analyse the messages further before sending
        }
        // we could also use the `logEvent.level.value` property to determine
        // numerical value
        if (logEvent.level.value >= 50) { // covers error and fatal

          // send the logEvent somewhere
        }
      }
    }
  }
})
Copy

The disabled option will disable logging in browser if set to true, by default it is set to false.

Example

const pino = require('pino')({browser: {disabled: true}})
Copy

Changes the shape of the log level. The default shape is { level: number }. The function takes two arguments, the label of the level (e.g. 'info') and the numeric value (e.g. 30).

Changes the shape of the bindings. The default shape is { pid, hostname }. The function takes a single argument, the bindings object. It will be called every time a child logger is created.

Changes the shape of the log object. This function will be called every time one of the log methods (such as .info) is called. All arguments passed to the log method, except the message, will be pass to this function. By default it does not change the shape of the log object.

Allows for manipulating the parameters passed to logger methods. The signature for this hook is logMethod (args, method, level) {}, where args is an array of the arguments that were passed to the log method and method is the log method itself, and level is the log level. This hook must invoke the method function by using apply, like so: method.apply(this, newArgumentsArray).