pino

debug: pino.LogFn;

error: pino.LogFn;

fatal: pino.LogFn;

info: pino.LogFn;

level: pino.LevelWithSilentOrString;

silent: pino.LogFn;

trace: pino.LogFn;

warn: pino.LogFn;

get msgPrefix(): string | undefined;

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

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

level?: LevelOrString;

msgPrefix?: string;

redact?: string[] | redactOptions;

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

write: (msg: string) => void;

[symbols.needsMetadataGsym]: true;

lastLevel: number;

lastLogger: pino.Logger;

lastMsg: string;

lastObj: object;

lastTime: string;

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

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

bindings: Bindings[];

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

messages: any[];

ts: number;

<T, TMsg extends string = string>(
    obj: T,
    msg?: T extends string ? never : TMsg,
    ...args: ParseLogFnArgs<TMsg> | []
): void;

<_, TMsg extends string = string>(
    msg: TMsg,
    ...args: ParseLogFnArgs<TMsg> | []
): void;

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

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;
    /**
     * The `asObjectBindingsOnly` option is similar to `asObject` but will keep the message and arguments
     * unformatted. This allows to defer formatting the message to the actual call to `console` methods,
     * where browsers then have richer formatting in their devtools than when pino will format the message to
     * a string first.
     *
     * @example
     * pino.info('hello %s', 'world') // creates and logs {level: 30, time: <ts>}, 'hello %s', 'world'
     */
    asObjectBindingsOnly?: 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;
};

crlf?: boolean;

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

depthLimit?: number;

edgeLimit?: number;

enabled?: boolean;

errorKey?: string;

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

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

level?: LevelWithSilentOrString;

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

levelVal?: number;

messageKey?: string;

mixin?: MixinFn<CustomLevels>;

mixinMergeStrategy?: MixinMergeStrategyFn;

msgPrefix?: string;

name?: string;

nestedKey?: string;

onChild?: OnChildCallback<CustomLevels>;

redact?: string[] | redactOptions;

safe?: boolean;

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

timestamp?: TimeFn | boolean;

transport?:
    | TransportSingleOptions
    | TransportMultiOptions
    | TransportPipelineOptions;

useOnlyCustomLevels?: UseOnlyCustomLevels;

dedupe?: boolean;

levels?: Record<string, number>;

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

flushSync: () => void;

minLevel: number;

streams: StreamEntry<TOriginLevel>[];

write: (data: any) => void;

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

level?: TLevel;

stream: DestinationStream;

options?: TransportOptions;

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

dedupe?: boolean;

levels?: Record<string, number>;

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

level?: LevelWithSilentOrString;

pipeline: TransportSingleOptions<TransportOptions>[];

target: string;

level?: LevelWithSilentOrString;

options?: TransportOptions;

target: string;