pino

property debug

debug: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string

property error

error: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string

property fatal

fatal: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string

property info

info: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string

property level

level: pino.LevelWithSilentOrString;

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

property silent

silent: pino.LogFn;

• Noop function.

property trace

trace: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string

property warn

warn: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string

property customLevels

customLevels?: { [level in CustomLevels]: number };

property formatters

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

property level

level?: LevelOrString;

property msgPrefix

msgPrefix?: string;

property redact

redact?: string[] | redactOptions;

property serializers

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

method write

write: (msg: string) => void;

property [symbols.needsMetadataGsym]

[symbols.needsMetadataGsym]: true;

property lastLevel

lastLevel: number;

property lastLogger

lastLogger: pino.Logger;

property lastMsg

lastMsg: string;

property lastObj

lastObj: object;

property lastTime

lastTime: string;

property labels

labels: { [level: number]: string };

• Returns the mappings of level internal level numbers to their string representations.

property values

values: { [level: string]: number };

• Returns the mappings of level names to their respective internal number representation.

property bindings

bindings: Bindings[];

• Represents each child logger (if any), and the relevant bindings.

  For instance, given logger.child({a: 1}).child({b: 2}).info({c: 3}), the bindings array would hold [{a: 1}, {b: 2}] and the messages array would be [{c: 3}]. The bindings are ordered according to their position in the child logger hierarchy, with the lowest index being the top of the hierarchy.

property level

level: {
    label: string;
    value: number;
};

• Holds the label (for instance info), and the corresponding numerical value (for instance 30). This could be important in cases where client side level values and labels differ from server side.

property messages

messages: any[];

• All arguments passed to logger method, (for instance logger.info('a', 'b', 'c') would result in messages array ['a', 'b', 'c']).

property ts

ts: number;

• Unix epoch timestamp in milliseconds, the time is taken from the moment the logger method is called.

call signature

<T extends object>(obj: T, msg?: string, ...args: any[]): void;

call signature

(obj: unknown, msg?: string, ...args: any[]): void;

call signature

(msg: string, ...args: any[]): void;

property base

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

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

property browser

browser?: {
    /**
     * 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>}
     */
    asObject?: boolean;
    formatters?: {
        /**
         * Changes the shape of the log level.
         * The default shape is { level: number }.
         */
        level?: (label: string, number: number) => object;
        /**
         * Changes the shape of the log object.
         */
        log?: (object: Record<string, unknown>) => Record<string, unknown>;
    };
    /**
     * 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
     *     }
     *   }
     * })
     *
     * @example
     * const pino = require('pino')({
     *   browser: {
     *     write: {
     *       info: function (o) {
     *         //process info log object
     *       },
     *       error: function (o) {
     *         //process error log object
     *       }
     *     }
     *   }
     * })
     */
    write?:
        | WriteFn
        | ({
              fatal?: WriteFn;
              error?: WriteFn;
              warn?: WriteFn;
              info?: WriteFn;
              debug?: WriteFn;
              trace?: WriteFn;
          } & { [logLevel: string]: WriteFn });

    /**
     * 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
     * {@link 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
     * {@link 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
     * {@link https://github.com/pinojs/pino/blob/master/docs/api.md#serializers-object}.
     *
     * @example
     * const pino = require('pino')({
     *   browser: {
     *     serialize: true
     *   }
     * })
     *
     * @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'})
     *
     * @example
     * const pino = require('pino')({
     *   serializers: {
     *     custom: myCustomSerializer,
     *     another: anotherSerializer
     *   },
     *   browser: {
     *     serialize: ['!stdSerializers.err', 'custom'] //will not serialize Errors, will serialize `custom` keys
     *   }
     * })
     */
    serialize?: boolean | string[];

    /**
     * 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
     *         }
     *       }
     *     }
     *   }
     * })
     */
    transmit?: {
        /**
         * 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`).
         */
        level?: LevelOrString;
        /**
         * Remotely record log messages.
         *
         * @description Called after writing the log message.
         */
        send: (level: Level, logEvent: LogEvent) => void;
    };
    /**
     * 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}})
     */
    disabled?: boolean;
};

• Browser only, see http://getpino.io/#/docs/browser.

property crlf

crlf?: boolean;

• logs newline delimited JSON with \r\n instead of \n. Default: false.

property customLevels

customLevels?: { [level in CustomLevels]: 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.

property depthLimit

depthLimit?: number;

• Stringification limit at a specific nesting depth when logging circular object. Default: 5.

property edgeLimit

edgeLimit?: number;

• Stringification limit of properties/elements when logging a specific object/array with circular references. Default: 100.

property enabled

enabled?: boolean;

• Enables logging. Default: true.

property errorKey

errorKey?: string;

• The string key for the 'error' in the JSON object. Default: "err".

property formatters

formatters?: {
    /**
     * 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).
     */
    level?: (label: string, number: number) => 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: Bindings) => 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.
     */
    log?: (object: Record<string, unknown>) => Record<string, unknown>;
};

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

property hooks

hooks?: {
    /**
     * 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).
     */
    logMethod?: (
        this: Logger,
        args: Parameters<LogFn>,
        method: LogFn,
        level: number
    ) => void;

    /**
     * Allows for manipulating the stringified JSON log output just before writing to various transports.
     * This function must return a string and must be valid JSON.
     */
    streamWrite?: (s: string) => string;
};

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

property level

level?: LevelWithSilentOrString;

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

property levelComparison

levelComparison?:
    | 'ASC'
    | 'DESC'
    | ((current: number, expected: number) => boolean);

• Use this option to define custom comparison of log levels. Useful to compare custom log levels or non-standard level values. Default: "ASC"

property levelVal

levelVal?: number;

• When defining a custom log level via level, set to an integer value to define the new level. Default: undefined.

property messageKey

messageKey?: string;

• The string key for the 'message' in the JSON object. Default: "msg".

property mixin

mixin?: MixinFn<CustomLevels>;

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

property mixinMergeStrategy

mixinMergeStrategy?: MixinMergeStrategyFn;

• If provided, the mixinMergeStrategy function is called each time one of the active logging methods is called. The first parameter is the value mergeObject or an empty object, the second parameter is the value resulting from mixin() or an empty object. The function must synchronously return an object.

property msgPrefix

msgPrefix?: string;

• A string that would be prefixed to every message (and child message)

property name

name?: string;

• The name of the logger. Default: undefined.

property nestedKey

nestedKey?: string;

• The string key to place any logged object under.

property onChild

onChild?: OnChildCallback<CustomLevels>;

• Optional child creation callback.

property redact

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

property safe

safe?: boolean;

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

property serializers

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.

property timestamp

timestamp?: TimeFn | boolean;

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

property transport

transport?:
    | TransportSingleOptions
    | TransportMultiOptions
    | TransportPipelineOptions;

property useOnlyCustomLevels

useOnlyCustomLevels?: UseOnlyCustomLevels;

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

property dedupe

dedupe?: boolean;

property levels

levels?: Record<string, number>;

property add

add: <TLevel = Level>(
    dest: StreamEntry<TLevel> | DestinationStream
) => MultiStreamRes<TOriginLevel & TLevel>;

property flushSync

flushSync: () => void;

property minLevel

minLevel: number;

property streams

streams: StreamEntry<TOriginLevel>[];

property write

write: (data: any) => void;

method clone

clone: <TLevel = Level>(level: TLevel) => MultiStreamRes<TLevel>;

property level

level?: TLevel;

property stream

stream: DestinationStream;

property options

options?: TransportOptions;

property worker

worker?: WorkerOptions & { autoEnd?: boolean };

property dedupe

dedupe?: boolean;

property levels

levels?: Record<string, number>;

property targets

targets: readonly (
    | TransportTargetOptions<TransportOptions>
    | TransportPipelineOptions<TransportOptions>
)[];

property level

level?: LevelWithSilentOrString;

property pipeline

pipeline: TransportSingleOptions<TransportOptions>[];

property target

target: string;

property level

level?: LevelWithSilentOrString;

property options

options?: TransportOptions;

property target

target: string;

property debug

debug: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string

property error

error: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string

property fatal

fatal: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string

property info

info: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string

property level

level: pino.LevelWithSilentOrString;

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

property silent

silent: pino.LogFn;

• Noop function.

property trace

trace: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string

property warn

warn: pino.LogFn;

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

  Parameter obj

  : object to be serialized

  Parameter msg

  : the log message to write

  Parameter

  ...args: format string values when msg is a format string