Interface LoggerOptions


  • LoggerOptions


base?: null | { [key: string]: any }

key-value object added as child logger to each log line. If set to null the base child logger is not added

browser?: { asObject?: boolean; serialize?: boolean | string[]; transmit?: { level?: string; send: ((level: Level, logEvent: LogEvent) => void) }; write?: WriteFn | { debug?: WriteFn; error?: WriteFn; fatal?: WriteFn; info?: WriteFn; trace?: WriteFn; warn?: WriteFn } & { [logLevel: string]: WriteFn } }

Type declaration

  • Optional asObject?: boolean

    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'hi') // creates and logs {msg: 'hi', level: 30, time: <ts>}
  • Optional serialize?: boolean | string[]

    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 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 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


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


    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{custom: 'a', another: 'b'})


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

  • Optional transmit?: { level?: string; send: ((level: Level, logEvent: LogEvent) => void) }

    Options for transmission of logs.


    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

    } })

    • Optional level?: string

      Specifies the minimum level (inclusive) of when the send function should be called, if not supplied the send function will be called based on the main logging level (set via options.level, defaulting to info).

    • send: ((level: Level, logEvent: LogEvent) => void)
        • (level: Level, logEvent: LogEvent): void
        • Remotely record log messages.


          Called after writing the log message.


          • level: Level
          • logEvent: LogEvent

          Returns void

  • Optional write?: WriteFn | { debug?: WriteFn; error?: WriteFn; fatal?: WriteFn; info?: WriteFn; trace?: WriteFn; warn?: WriteFn } & { [logLevel: string]: WriteFn }

    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.


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


    const pino = require('pino')({
    browser: {
    write: {
    info: function (o) {
    //process info log object
    error: function (o) {
    //process error log object
changeLevelName?: string

(DEPRECATED, use levelKey) Changes the property level to any string value you pass in. Default: 'level'

customLevels?: { [key: string]: number }

Use this option to define additional logging levels. The keys of the object correspond the namespace of the log level, and the values should be the numerical value of the level.

Type declaration

  • [key: string]: number
enabled?: boolean

Enables logging. Default: true.

formatters?: { bindings?: ((bindings: Bindings) => object); level?: ((label: string, number: number) => object); log?: ((object: Record<string, unknown>) => object) }

An object containing functions for formatting the shape of the log lines. These functions should return a JSONifiable object and should never throw. These functions allow for full customization of the resulting log lines. For example, they can be used to change the level key name or to enrich the default metadata.

Type declaration

  • Optional bindings?: ((bindings: Bindings) => object)
      • (bindings: Bindings): object
      • 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.


        • bindings: Bindings

        Returns object

  • Optional level?: ((label: string, number: number) => object)
      • (label: string, number: number): object
      • 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).


        • label: string
        • number: number

        Returns object

  • Optional log?: ((object: Record<string, unknown>) => object)
      • (object: Record<string, unknown>): object
      • 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.


        • object: Record<string, unknown>

        Returns object

hooks?: { logMethod?: ((args: any[], method: LogFn, level: number) => void) }

An object mapping to hook functions. Hook functions allow for customizing internal logger operations. Hook functions must be synchronous functions.

Type declaration

  • Optional logMethod?: ((args: any[], method: LogFn, level: number) => void)
      • (args: any[], method: LogFn, level: number): void
      • 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).


        • args: any[]
        • method: LogFn
        • level: number

        Returns void

level?: string

One of the supported levels or silent to disable logging. Any other value defines a custom level and requires supplying a level value via levelVal. Default: 'info'.

levelKey?: string

Changes the property level to any string value you pass in. Default: 'level'

levelVal?: number

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".

mixin?: MixinFn

If provided, the mixin function is called each time one of the active logging methods is called. The function must synchronously return an object. The properties of the returned object will be added to the logged JSON.

name?: string

The name of the logger. Default: undefined.

nestedKey?: string

The string key to place any logged object under.

prettifier?: any

Allows to optionally define which prettifier module to use.

prettyPrint?: boolean | PrettyOptions


use pino.transport(). See

Enables pino.pretty. This is intended for non-production configurations. This may be set to a configuration object as outlined in Default: false.

redact?: string[] | redactOptions

As an array, the redact option specifies paths that should have their values redacted from any log output.

Each path must be a string using a syntax which corresponds to JavaScript dot and bracket notation.

If an object is supplied, three options can be specified:

 paths (String[]): 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
safe?: boolean

Avoid error causes by circular references in the object tree. Default: true.

serializers?: { [key: string]: SerializerFn }

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.

Type declaration

  • [key: string]: SerializerFn
timestamp?: boolean | TimeFn

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. 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.

useLevelLabels?: boolean

Outputs the level as a string instead of integer. Default: false.

useOnlyCustomLevels?: boolean

Use this option to only use defined customLevels and omit Pino's levels. Logger's default level must be changed to a value in customLevels in order to use useOnlyCustomLevels Warning: this option may not be supported by downstream transports.


  • onTerminated(eventName: string, err: any): void
  • This function will be invoked during process shutdown when extreme is set to true. 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 for more detail.


    • eventName: string
    • err: any

    Returns void

Generated using TypeDoc