How to use pino - 10 common examples

const p: Logger = pino();

p.info("hello world");
p.error("this is at error level");
p.info("the answer is %d", 42);
p.info({ obj: 42 }, "hello world");
p.info({ obj: 42, b: 2 }, "hello world");
p.info({ obj: { aa: "bbb" } }, "another");
setImmediate(p.info, "after setImmediate");
p.error(new Error("an error"));

// $ExpectError
p("no log level");

const pretty = pino.pretty();
pretty.pipe(process.stdout);
const log = pino(
  {
    name: "app",
    safe: true
  },
  pretty
);

log.child({ widget: "foo" }).info("hello");
log.child({ widget: "bar" }).warn("hello 2");

// @flow

import pino from "pino";
import type { Logger } from "pino";

(pino.LOG_VERSION: number);

const p: Logger = pino();

p.info("hello world");
p.error("this is at error level");
p.info("the answer is %d", 42);
p.info({ obj: 42 }, "hello world");
p.info({ obj: 42, b: 2 }, "hello world");
p.info({ obj: { aa: "bbb" } }, "another");
setImmediate(p.info, "after setImmediate");
p.error(new Error("an error"));

// $ExpectError
p("no log level");

const pretty = pino.pretty();

import { buildJs, BuildJsCompilationError } from "./commands/buildJs";
import { buildSoy, BuildSoyConfig } from "./commands/buildSoy";
import { cleanDeps } from "./commands/cleanDeps";
import { cleanSoy, CleanSoyConfig } from "./commands/cleanSoy";
import { serve } from "./commands/serve";
import { DuckConfig, loadConfig } from "./duckconfig";
import { setGlobalLogger } from "./logger";
import { ErrorReason, reportTestResults } from "./report";

assertNodeVersionGte(process.version, 10);

/**
 * Transform ndjson (Newline Delimited JSON) stream to JSON object stream.
 */
const logStream = split(JSON.parse);
const logger = pino(logStream);
setGlobalLogger(logger);

/**
 * Task wrapper that conbines the log stream with the promise to make an
 * observable that does not "complete" until the promise is resolved,
 * because listr can accept only one of Promise, Stream and Observable.
 */
function wrap(task: () => Promise): () => Observable {
  return () => {
    // Run the task in the next tick to register the observable to listr before the first logging.
    const await = Promise.resolve().then(task);
    return streamToObservable(logStream, { await, endEvent: false }).pipe(
      map(obj => {
        if (obj.msg) {
          return String(obj.msg);
        } else {

import pino from "pino";
import url from "url";
import { Application } from "./application";
import { requestTwilioTurnServer } from "./turn";
import { Win } from "./win";

// we'll export this and use it for testing
// it won't impact the runtime as the runtime ignores it
let runtimeIgnoredExportSuccess: () => void;
let runtimeIgnoredExportFailure: (err: Error) => void;
const runtimeIgnoredExportValue: Promise = new Promise((resolve, reject) => {
  runtimeIgnoredExportSuccess = resolve;
  runtimeIgnoredExportFailure = reject;
});

const logger = pino();

/**
 * Configure dotenv - Supported values:
 * + SERVICE_URL (string) - the web service address (to render)
 * + TURN_URL (string) - a turn address
 * + TURN_USERNAME (string) - a turn username
 * + TURN_PASSWORD (string) - a turn password credential
 * + POLL_URL (string) - a signaling server base address
 * + POLL_INTERVAL (number) - a signaling poll interval in ms
 * + HEIGHT (number) - the window height
 * + WIDTH (number) - the window width
 * + EXP_HIDE_STREAMER (boolean) - experiment flag for hiding the streamer window
 * + TWILIO_ACCOUNT_SID (string) - a Twilio AccountSid required to get a Network Traversal Service Token
 * + TWILIO_AUTH_TOKEN (string) - a Twilio AuthToken required to get a Network Traversal Service Token
 */
const dotenv = config();

/**
 * Simple logging with bunyan
 * @ignore
 */

import pino from 'pino'
import { createWriteStream } from 'fs-extra'
import { PassThrough } from 'stream'
import { stdout } from 'process'

import { electronVersion, isDev, LOG_FILE } from './consts'

const logThrough = new PassThrough()

const logger = pino( {
  prettyPrint: isDev && { colorize: true, ignore: 'hostname,pid', translateTime: 'HH:MM:ss.l' },
}, logThrough )

// Only write to file in electron production builds
if ( electronVersion && !isDev ) logThrough.pipe( createWriteStream( LOG_FILE, { flags: 'a' } ) )

// Pipe all log output to stdout in dev only
if ( isDev ) logThrough.pipe( stdout )

export default logger

type: 'string',
  }).argv

// instantiate logger
const loggerConfig = {
  level: args.logLevel,
  prettyPrint: args.prettyLogs,
}

// If the stdout is used for a data output, save all logs to a log file.
// pino writes logs to stdout by default
let logDestination
if (args.output === process.stdout)
  logDestination = fs.createWriteStream(args.logFile)

const logger = pino(loggerConfig, logDestination)

// print errors to stderr if we use stdout for data output
// if we save data to output file errors are already logged by pino
const logError = error => {
  const errorFormatter = new PrettyError()

  if (args.logLevel === 'debug')
    process.stderr.write(`ERR: ${errorFormatter.render(error)}`)
  else process.stderr.write(`ERR: ${error.message || error}`)
}

const errorHandler = errors => {
  if (Array.isArray(errors)) errors.forEach(logError)
  else logError(errors)

  process.exitCode = 1

type: 'string',
  }).argv

// instantiate logger
const loggerConfig = {
  level: args.logLevel,
  prettyPrint: args.prettyLogs,
}

// If the stdout is used for a data output, save all logs to a log file.
// pino writes logs to stdout by default
let logDestination
if (args.output === process.stdout)
  logDestination = fs.createWriteStream(args.logFile)

const logger = pino(loggerConfig, logDestination)

// print errors to stderr if we use stdout for data output
// if we save data to output file errors are already logged by pino
const logError = error => {
  const errorFormatter = new PrettyError()

  if (args.logLevel === 'debug')
    process.stderr.write(`ERR: ${errorFormatter.render(error)}`)
  else process.stderr.write(`ERR: ${error.message || error}`)
}

const errorHandler = errors => {
  if (Array.isArray(errors)) errors.forEach(logError)
  else logError(errors)

  process.exitCode = 1

async function register (server, options) {
  // clone all user options to account for internal mutations, except for existing stream and pino instances
  options = Object.assign(Hoek.clone(options), {
    stream: options.stream,
    instance: options.instance
  })

  options.serializers = options.serializers || {}
  options.serializers.req = stdSerializers.wrapRequestSerializer(options.serializers.req || stdSerializers.req)
  options.serializers.res = stdSerializers.wrapResponseSerializer(options.serializers.res || stdSerializers.res)
  options.serializers.err = options.serializers.err || pino.stdSerializers.err

  if (options.logEvents === undefined) {
    options.logEvents = ['onPostStart', 'onPostStop', 'response', 'request-error']
  }

  var logger
  if (options.instance) {
    logger = options.instance
    const overrideDefaultErrorSerializer =
      typeof options.serializers.err === 'function' && logger[serializersSym].err === stdSerializers.err
    logger[serializersSym] = Object.assign({}, options.serializers, logger[serializersSym])
    if (overrideDefaultErrorSerializer) {
      logger[serializersSym].err = options.serializers.err
    }
  } else {
    options.stream = options.stream || process.stdout

exports.log = function esLogger (config = {}) {
  // config is the object passed to the client constructor.
  const logger = pino({
    name: 'Leaistic ↔ ElasticSearch',
    serializers: {
      err: pino.stdSerializers.err
    },
    level: ES_LOG_THRESHOLD,
    ...config
  })

  this.error = (message, object, ...rest) => logger.error(object, message, ...rest)
  this.warning = (message, object, ...rest) => logger.warn(object, message, ...rest)
  this.info = (message, object, ...rest) => logger.info(object, message, ...rest)
  this.debug = (message, object, ...rest) => logger.debug(object, message, ...rest)

  // ES trace mode is used to track HTTP requests, which tends to be actually more important than `debug` level content
  // pino has some standard format ( from default serializers) for `req` and `res` that we can leverage to have nice looking logs
  this.trace = (method, req, body, responseBody, statusCode) => {
    const level = statusCode < 500 ? ES_LOG_LEVEL_OK : ES_LOG_LEVEL_ERROR
    const {protocol, hostname, port, path, headers} = req
    const message = 'request completed'

const SecretsManagerBackend = require('../lib/backends/secrets-manager-backend')
const SystemManagerBackend = require('../lib/backends/system-manager-backend')
const VaultBackend = require('../lib/backends/vault-backend')

// Get document, or throw exception on error
// eslint-disable-next-line security/detect-non-literal-fs-filename
const customResourceManifest = yaml.safeLoad(fs.readFileSync(path.resolve(__dirname, '../crd.yaml'), 'utf8'))

const kubeconfig = new kube.KubeConfig()
kubeconfig.loadFromDefault()
const kubeBackend = new KubeRequest({ kubeconfig })
const kubeClient = new kube.Client({ backend: kubeBackend })

const logger = pino({
  serializers: {
    err: pino.stdSerializers.err
  },
  level: envConfig.logLevel
})

const customResourceManager = new CustomResourceManager({
  kubeClient,
  logger
})

const secretsManagerBackend = new SecretsManagerBackend({
  clientFactory: awsConfig.secretsManagerFactory,
  assumeRole: awsConfig.assumeRole,
  logger
})
const systemManagerBackend = new SystemManagerBackend({
  clientFactory: awsConfig.systemManagerFactory,