modified

node_modules/pino/LICENSE

@@ -0,0 +1,24 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-2019 Matteo Collina, David Mark Clements and the Pino contributors
+
+Pino contributors listed at https://github.com/pinojs/pino#the-team and in
+the README file.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/pino/README.md

@@ -0,0 +1,152 @@
+![banner](pino-banner.png)
+
+# pino
+[![npm version](https://img.shields.io/npm/v/pino)](https://www.npmjs.com/package/pino)
+[![Build Status](https://img.shields.io/github/workflow/status/pinojs/pino/CI)](https://github.com/pinojs/pino/actions)
+[![Known Vulnerabilities](https://snyk.io/test/github/pinojs/pino/badge.svg)](https://snyk.io/test/github/pinojs/pino)
+[![Coverage Status](https://coveralls.io/repos/github/pinojs/pino/badge.svg?branch=master)](https://coveralls.io/github/pinojs/pino?branch=master)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
+[![TypeScript definitions on DefinitelyTyped](https://img.shields.io/badge/DefinitelyTyped-.d.ts-brightgreen.svg?style=flat)](https://definitelytyped.org)
+
+[Very low overhead](#low-overhead) Node.js logger.
+
+This README and linked documentation covers pino v6.x,
+you can find all related docs in: https://github.com/pinojs/pino/tree/v6.x.
+
+## Documentation
+
+* [Benchmarks ⇗](/docs/benchmarks.md)
+* [API ⇗](/docs/api.md)
+* [Browser API ⇗](/docs/browser.md)
+* [Redaction ⇗](/docs/redaction.md)
+* [Child Loggers ⇗](/docs/child-loggers.md)
+* [Transports ⇗](/docs/transports.md)
+* [Web Frameworks ⇗](/docs/web.md)
+* [Pretty Printing ⇗](/docs/pretty.md)
+* [Asynchronous Logging ⇗](/docs/asynchronous.md)
+* [Ecosystem ⇗](/docs/ecosystem.md)
+* [Legacy](/docs/legacy.md)
+* [Help ⇗](/docs/help.md)
+* [Long Term Support Policy ⇗](/docs/lts.md)
+
+## Install
+
+```
+$ npm install pino@six
+```
+
+## Usage
+
+```js
+const logger = require('pino')()
+
+logger.info('hello world')
+
+const child = logger.child({ a: 'property' })
+child.info('hello child!')
+```
+
+This produces:
+
+```
+{"level":30,"time":1531171074631,"msg":"hello world","pid":657,"hostname":"Davids-MBP-3.fritz.box"}
+{"level":30,"time":1531171082399,"msg":"hello child!","pid":657,"hostname":"Davids-MBP-3.fritz.box","a":"property"}
+```
+
+For using Pino with a web framework see:
+
+* [Pino with Fastify](docs/web.md#fastify)
+* [Pino with Express](docs/web.md#express)
+* [Pino with Hapi](docs/web.md#hapi)
+* [Pino with Restify](docs/web.md#restify)
+* [Pino with Koa](docs/web.md#koa)
+* [Pino with Node core `http`](docs/web.md#http)
+* [Pino with Nest](docs/web.md#nest)
+
+
+<a name="essentials"></a>
+## Essentials
+
+### Development Formatting
+
+The [`pino-pretty`](https://github.com/pinojs/pino-pretty) module can be used to
+format logs during development:
+
+![pretty demo](pretty-demo.png)
+
+### Transports & Log Processing
+
+Due to Node's single-threaded event-loop, it's highly recommended that sending,
+alert triggering, reformatting and all forms of log processing
+is conducted in a separate process. In Pino parlance we call all log processors
+"transports", and recommend that the transports be run as separate
+processes, piping the stdout of the application to the stdin of the transport.
+
+For more details see our [Transports⇗](docs/transports.md) document.
+
+### Low overhead
+
+Using minimum resources for logging is very important. Log messages
+tend to get added over time and this can lead to a throttling effect
+on applications – such as reduced requests per second.
+
+In many cases, Pino is over 5x faster than alternatives.
+
+See the [Benchmarks](docs/benchmarks.md) document for comparisons.
+
+<a name="team"></a>
+## The Team
+
+### Matteo Collina
+
+<https://github.com/pinojs>
+
+<https://www.npmjs.com/~matteo.collina>
+
+<https://twitter.com/matteocollina>
+
+### David Mark Clements
+
+<https://github.com/davidmarkclements>
+
+<https://www.npmjs.com/~davidmarkclements>
+
+<https://twitter.com/davidmarkclem>
+
+### James Sumners
+
+<https://github.com/jsumners>
+
+<https://www.npmjs.com/~jsumners>
+
+<https://twitter.com/jsumners79>
+
+### Thomas Watson Steen
+
+<https://github.com/watson>
+
+<https://www.npmjs.com/~watson>
+
+<https://twitter.com/wa7son>
+
+## Contributing
+
+Pino is an **OPEN Open Source Project**. This means that:
+
+> Individuals making significant and valuable contributions are given commit-access to the project to contribute as they see fit. This project is more like an open wiki than a standard guarded open source project.
+
+See the [CONTRIBUTING.md](https://github.com/pinojs/pino/blob/master/CONTRIBUTING.md) file for more details.
+
+<a name="acknowledgements"></a>
+## Acknowledgements
+
+This project was kindly sponsored by [nearForm](https://nearform.com).
+
+Logo and identity designed by Cosmic Fox Design: https://www.behance.net/cosmicfox.
+
+## License
+
+Licensed under [MIT](./LICENSE).
+
+[elasticsearch]: https://www.elastic.co/products/elasticsearch
+[kibana]: https://www.elastic.co/products/kibana

node_modules/pino/bin.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+console.error(
+  '`pino` cli has been removed. Use `pino-pretty` cli instead.\n' +
+  '\nSee: https://github.com/pinojs/pino-pretty'
+)
+process.exit(1)

node_modules/pino/browser.js

@@ -0,0 +1,358 @@
+'use strict'
+
+const format = require('quick-format-unescaped')
+
+module.exports = pino
+
+const _console = pfGlobalThisOrFallback().console || {}
+const stdSerializers = {
+  mapHttpRequest: mock,
+  mapHttpResponse: mock,
+  wrapRequestSerializer: passthrough,
+  wrapResponseSerializer: passthrough,
+  wrapErrorSerializer: passthrough,
+  req: mock,
+  res: mock,
+  err: asErrValue
+}
+
+function shouldSerialize (serialize, serializers) {
+  if (Array.isArray(serialize)) {
+    const hasToFilter = serialize.filter(function (k) {
+      return k !== '!stdSerializers.err'
+    })
+    return hasToFilter
+  } else if (serialize === true) {
+    return Object.keys(serializers)
+  }
+
+  return false
+}
+
+function pino (opts) {
+  opts = opts || {}
+  opts.browser = opts.browser || {}
+
+  const transmit = opts.browser.transmit
+  if (transmit && typeof transmit.send !== 'function') { throw Error('pino: transmit option must have a send function') }
+
+  const proto = opts.browser.write || _console
+  if (opts.browser.write) opts.browser.asObject = true
+  const serializers = opts.serializers || {}
+  const serialize = shouldSerialize(opts.browser.serialize, serializers)
+  let stdErrSerialize = opts.browser.serialize
+
+  if (
+    Array.isArray(opts.browser.serialize) &&
+    opts.browser.serialize.indexOf('!stdSerializers.err') > -1
+  ) stdErrSerialize = false
+
+  const levels = ['error', 'fatal', 'warn', 'info', 'debug', 'trace']
+
+  if (typeof proto === 'function') {
+    proto.error = proto.fatal = proto.warn =
+    proto.info = proto.debug = proto.trace = proto
+  }
+  if (opts.enabled === false) opts.level = 'silent'
+  const level = opts.level || 'info'
+  const logger = Object.create(proto)
+  if (!logger.log) logger.log = noop
+
+  Object.defineProperty(logger, 'levelVal', {
+    get: getLevelVal
+  })
+  Object.defineProperty(logger, 'level', {
+    get: getLevel,
+    set: setLevel
+  })
+
+  const setOpts = {
+    transmit,
+    serialize,
+    asObject: opts.browser.asObject,
+    levels,
+    timestamp: getTimeFunction(opts)
+  }
+  logger.levels = pino.levels
+  logger.level = level
+
+  logger.setMaxListeners = logger.getMaxListeners =
+  logger.emit = logger.addListener = logger.on =
+  logger.prependListener = logger.once =
+  logger.prependOnceListener = logger.removeListener =
+  logger.removeAllListeners = logger.listeners =
+  logger.listenerCount = logger.eventNames =
+  logger.write = logger.flush = noop
+  logger.serializers = serializers
+  logger._serialize = serialize
+  logger._stdErrSerialize = stdErrSerialize
+  logger.child = child
+
+  if (transmit) logger._logEvent = createLogEventShape()
+
+  function getLevelVal () {
+    return this.level === 'silent'
+      ? Infinity
+      : this.levels.values[this.level]
+  }
+
+  function getLevel () {
+    return this._level
+  }
+  function setLevel (level) {
+    if (level !== 'silent' && !this.levels.values[level]) {
+      throw Error('unknown level ' + level)
+    }
+    this._level = level
+
+    set(setOpts, logger, 'error', 'log') // <-- must stay first
+    set(setOpts, logger, 'fatal', 'error')
+    set(setOpts, logger, 'warn', 'error')
+    set(setOpts, logger, 'info', 'log')
+    set(setOpts, logger, 'debug', 'log')
+    set(setOpts, logger, 'trace', 'log')
+  }
+
+  function child (bindings, childOptions) {
+    if (!bindings) {
+      throw new Error('missing bindings for child Pino')
+    }
+    childOptions = childOptions || {}
+    if (serialize && bindings.serializers) {
+      childOptions.serializers = bindings.serializers
+    }
+    const childOptionsSerializers = childOptions.serializers
+    if (serialize && childOptionsSerializers) {
+      var childSerializers = Object.assign({}, serializers, childOptionsSerializers)
+      var childSerialize = opts.browser.serialize === true
+        ? Object.keys(childSerializers)
+        : serialize
+      delete bindings.serializers
+      applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize)
+    }
+    function Child (parent) {
+      this._childLevel = (parent._childLevel | 0) + 1
+      this.error = bind(parent, bindings, 'error')
+      this.fatal = bind(parent, bindings, 'fatal')
+      this.warn = bind(parent, bindings, 'warn')
+      this.info = bind(parent, bindings, 'info')
+      this.debug = bind(parent, bindings, 'debug')
+      this.trace = bind(parent, bindings, 'trace')
+      if (childSerializers) {
+        this.serializers = childSerializers
+        this._serialize = childSerialize
+      }
+      if (transmit) {
+        this._logEvent = createLogEventShape(
+          [].concat(parent._logEvent.bindings, bindings)
+        )
+      }
+    }
+    Child.prototype = this
+    return new Child(this)
+  }
+  return logger
+}
+
+pino.levels = {
+  values: {
+    fatal: 60,
+    error: 50,
+    warn: 40,
+    info: 30,
+    debug: 20,
+    trace: 10
+  },
+  labels: {
+    10: 'trace',
+    20: 'debug',
+    30: 'info',
+    40: 'warn',
+    50: 'error',
+    60: 'fatal'
+  }
+}
+
+pino.stdSerializers = stdSerializers
+pino.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime })
+
+function set (opts, logger, level, fallback) {
+  const proto = Object.getPrototypeOf(logger)
+  logger[level] = logger.levelVal > logger.levels.values[level]
+    ? noop
+    : (proto[level] ? proto[level] : (_console[level] || _console[fallback] || noop))
+
+  wrap(opts, logger, level)
+}
+
+function wrap (opts, logger, level) {
+  if (!opts.transmit && logger[level] === noop) return
+
+  logger[level] = (function (write) {
+    return function LOG () {
+      const ts = opts.timestamp()
+      const args = new Array(arguments.length)
+      const proto = (Object.getPrototypeOf && Object.getPrototypeOf(this) === _console) ? _console : this
+      for (var i = 0; i < args.length; i++) args[i] = arguments[i]
+
+      if (opts.serialize && !opts.asObject) {
+        applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize)
+      }
+      if (opts.asObject) write.call(proto, asObject(this, level, args, ts))
+      else write.apply(proto, args)
+
+      if (opts.transmit) {
+        const transmitLevel = opts.transmit.level || logger.level
+        const transmitValue = pino.levels.values[transmitLevel]
+        const methodValue = pino.levels.values[level]
+        if (methodValue < transmitValue) return
+        transmit(this, {
+          ts,
+          methodLevel: level,
+          methodValue,
+          transmitLevel,
+          transmitValue: pino.levels.values[opts.transmit.level || logger.level],
+          send: opts.transmit.send,
+          val: logger.levelVal
+        }, args)
+      }
+    }
+  })(logger[level])
+}
+
+function asObject (logger, level, args, ts) {
+  if (logger._serialize) applySerializers(args, logger._serialize, logger.serializers, logger._stdErrSerialize)
+  const argsCloned = args.slice()
+  let msg = argsCloned[0]
+  const o = {}
+  if (ts) {
+    o.time = ts
+  }
+  o.level = pino.levels.values[level]
+  let lvl = (logger._childLevel | 0) + 1
+  if (lvl < 1) lvl = 1
+  // deliberate, catching objects, arrays
+  if (msg !== null && typeof msg === 'object') {
+    while (lvl-- && typeof argsCloned[0] === 'object') {
+      Object.assign(o, argsCloned.shift())
+    }
+    msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : undefined
+  } else if (typeof msg === 'string') msg = format(argsCloned.shift(), argsCloned)
+  if (msg !== undefined) o.msg = msg
+  return o
+}
+
+function applySerializers (args, serialize, serializers, stdErrSerialize) {
+  for (const i in args) {
+    if (stdErrSerialize && args[i] instanceof Error) {
+      args[i] = pino.stdSerializers.err(args[i])
+    } else if (typeof args[i] === 'object' && !Array.isArray(args[i])) {
+      for (const k in args[i]) {
+        if (serialize && serialize.indexOf(k) > -1 && k in serializers) {
+          args[i][k] = serializers[k](args[i][k])
+        }
+      }
+    }
+  }
+}
+
+function bind (parent, bindings, level) {
+  return function () {
+    const args = new Array(1 + arguments.length)
+    args[0] = bindings
+    for (var i = 1; i < args.length; i++) {
+      args[i] = arguments[i - 1]
+    }
+    return parent[level].apply(this, args)
+  }
+}
+
+function transmit (logger, opts, args) {
+  const send = opts.send
+  const ts = opts.ts
+  const methodLevel = opts.methodLevel
+  const methodValue = opts.methodValue
+  const val = opts.val
+  const bindings = logger._logEvent.bindings
+
+  applySerializers(
+    args,
+    logger._serialize || Object.keys(logger.serializers),
+    logger.serializers,
+    logger._stdErrSerialize === undefined ? true : logger._stdErrSerialize
+  )
+  logger._logEvent.ts = ts
+  logger._logEvent.messages = args.filter(function (arg) {
+    // bindings can only be objects, so reference equality check via indexOf is fine
+    return bindings.indexOf(arg) === -1
+  })
+
+  logger._logEvent.level.label = methodLevel
+  logger._logEvent.level.value = methodValue
+
+  send(methodLevel, logger._logEvent, val)
+
+  logger._logEvent = createLogEventShape(bindings)
+}
+
+function createLogEventShape (bindings) {
+  return {
+    ts: 0,
+    messages: [],
+    bindings: bindings || [],
+    level: { label: '', value: 0 }
+  }
+}
+
+function asErrValue (err) {
+  const obj = {
+    type: err.constructor.name,
+    msg: err.message,
+    stack: err.stack
+  }
+  for (const key in err) {
+    if (obj[key] === undefined) {
+      obj[key] = err[key]
+    }
+  }
+  return obj
+}
+
+function getTimeFunction (opts) {
+  if (typeof opts.timestamp === 'function') {
+    return opts.timestamp
+  }
+  if (opts.timestamp === false) {
+    return nullTime
+  }
+  return epochTime
+}
+
+function mock () { return {} }
+function passthrough (a) { return a }
+function noop () {}
+
+function nullTime () { return false }
+function epochTime () { return Date.now() }
+function unixTime () { return Math.round(Date.now() / 1000.0) }
+function isoTime () { return new Date(Date.now()).toISOString() } // using Date.now() for testability
+
+/* eslint-disable */
+/* istanbul ignore next */
+function pfGlobalThisOrFallback () {
+  function defd (o) { return typeof o !== 'undefined' && o }
+  try {
+    if (typeof globalThis !== 'undefined') return globalThis
+    Object.defineProperty(Object.prototype, 'globalThis', {
+      get: function () {
+        delete Object.prototype.globalThis
+        return (this.globalThis = this)
+      },
+      configurable: true
+    })
+    return globalThis
+  } catch (e) {
+    return defd(self) || defd(window) || defd(this) || {}
+  }
+}
+/* eslint-enable */

node_modules/pino/docs/asynchronous.md

@@ -0,0 +1,108 @@
+# Asynchronous Logging
+
+In essence, asynchronous logging enables even faster performance by Pino.
+
+In Pino's standard mode of operation log messages are directly written to the
+output stream as the messages are generated with a _blocking_ operation.
+Asynchronous logging works by buffering
+log messages and writing them in larger chunks.
+
+```js
+const pino = require('pino')
+const logger = pino(pino.destination({
+  dest: './my-file', // omit for stdout
+  minLength: 4096, // Buffer before writing
+  sync: false // Asynchronous logging
+}))
+```
+
+* See [`pino.destination`](/docs/api.md#pino-destination)
+* `pino.destination` is implemented on [`sonic-boom` ⇗](https://github.com/mcollina/sonic-boom).
+
+## Caveats
+
+This has a couple of important caveats:
+
+* 4KB of spare RAM will be needed for logging
+* As opposed to the default mode, there is not a one-to-one relationship between
+  calls to logging methods (e.g. `logger.info`) and writes to a log file
+* There is a possibility of the most recently buffered log messages being lost
+  (up to 4KB of logs)
+  * For instance, a power cut will mean up to 4KB of buffered logs will be lost
+
+So in summary, use asynchronous logging only when performing an extreme amount of
+logging, and it is acceptable to potentially lose the most recent logs.
+
+* Pino will register handlers for the following process events/signals so that
+  Pino can flush the asynchronous logger buffer:
+
+  + `beforeExit`
+  + `exit`
+  + `uncaughtException`
+  + `SIGHUP`
+  + `SIGINT`
+  + `SIGQUIT`
+  + `SIGTERM`
+
+  In all of these cases, except `SIGHUP`, the process is in a state that it
+  *must* terminate. Thus, if an `onTerminated` function isn't registered when
+  constructing a Pino instance (see [pino#constructor](api.md#constructor)),
+  then Pino will invoke `process.exit(0)` when no error has occurred, or
+  `process.exit(1)` otherwise. If an `onTerminated` function is supplied, it
+  is the responsibility of the `onTerminated` function to manually exit the process.
+
+  In the case of `SIGHUP`, we will look to see if any other handlers are
+  registered for the event. If not, we will proceed as we do with all other
+  signals. If there are more handlers registered than just our own, we will
+  simply flush the asynchronous logging buffer.
+
+### AWS Lambda
+
+On AWS Lambda we recommend to call `dest.flushSync()` at the end
+of each function execution to avoid losing data.
+
+## Usage
+
+The `pino.destination({ sync: false })` method will provide an asynchronous destination.
+
+```js
+const pino = require('pino')
+const dest = pino.destination({ sync: false }) // logs to stdout with no args
+const logger = pino(dest)
+```
+
+<a id='log-loss-prevention'></a>
+## Log loss prevention
+
+The following strategy can be used to minimize log loss:
+
+```js
+const pino = require('pino')
+const dest = pino.destination({ sync: false })
+const logger = pino(dest)
+
+// asynchronously flush every 10 seconds to keep the buffer empty
+// in periods of low activity
+setInterval(function () {
+  logger.flush()
+}, 10000).unref()
+
+// use pino.final to create a special logger that
+// guarantees final tick writes
+const handler = pino.final(logger, (err, finalLogger, evt) => {
+  finalLogger.info(`${evt} caught`)
+  if (err) finalLogger.error(err, 'error caused exit')
+  process.exit(err ? 1 : 0)
+})
+// catch all the ways node might exit
+process.on('beforeExit', () => handler(null, 'beforeExit'))
+process.on('exit', () => handler(null, 'exit'))
+process.on('uncaughtException', (err) => handler(err, 'uncaughtException'))
+process.on('SIGINT', () => handler(null, 'SIGINT'))
+process.on('SIGQUIT', () => handler(null, 'SIGQUIT'))
+process.on('SIGTERM', () => handler(null, 'SIGTERM'))
+```
+
+* See [`pino.destination` api](/docs/api.md#pino-destination)
+* See [`pino.final` api](/docs/api.md#pino-final)
+* See [`destination` parameter](/docs/api.md#destination)

node_modules/pino/docs/benchmarks.md

@@ -0,0 +1,58 @@
+# Benchmarks
+
+The following values show the time spent to call each function 100000 times. 
+
+`pino.info('hello world')`:
+
+```
+BASIC benchmark averages
+Bunyan average: 662.904ms
+Winston average: 564.752ms
+Bole average: 301.894ms
+Debug average: 361.052ms
+LogLevel average: 330.394ms
+Pino average: 246.336ms
+PinoAsync average: 129.507ms
+PinoNodeStream average: 276.479ms
+```
+
+`pino.info({'hello': 'world'})`:
+
+```
+OBJECT benchmark averages
+BunyanObj average: 678.477ms
+WinstonObj average: 563.154ms
+BoleObj average: 364.748ms
+LogLevelObject average: 627.196ms
+PinoObj average: 237.543ms
+PinoAsyncObj average: 125.532ms
+PinoNodeStreamObj average: 310.614ms
+```
+
+`pino.info(aBigDeeplyNestedObject)`:
+
+```
+DEEPOBJECT benchmark averages
+BunyanDeepObj average: 1838.970ms
+WinstonDeepObj average: 3173.947ms
+BoleDeepObj average: 2888.894ms
+LogLevelDeepObj average: 7426.592ms
+PinoDeepObj average: 3074.177ms
+PinoAsyncDeepObj average: 2987.925ms
+PinoNodeStreamDeepObj average: 3459.883ms
+```
+
+`pino.info('hello %s %j %d', 'world', {obj: true}, 4, {another: 'obj'})`:
+
+```
+BunyanInterpolateExtra average: 971.019ms
+WinstonInterpolateExtra average: 535.009ms
+BoleInterpolateExtra average: 575.668ms
+PinoInterpolateExtra average: 332.099ms
+PinoAsyncInterpolateExtra average: 209.552ms
+PinoNodeStreamInterpolateExtra average: 413.195ms
+```
+
+For a fair comparison, [LogLevel](https://npm.im/loglevel) was extended
+to include a timestamp and [bole](https://npm.im/bole) had
+`fastTime` mode switched on.

node_modules/pino/docs/browser.md

@@ -0,0 +1,199 @@
+# Browser API
+
+Pino is compatible with [`browserify`](https://npm.im/browserify) for browser side usage:
+
+This can be useful with isomorphic/universal JavaScript code.
+
+By default, in the browser,
+`pino` uses corresponding [Log4j](https://en.wikipedia.org/wiki/Log4j) `console` methods (`console.error`, `console.warn`, `console.info`, `console.debug`, `console.trace`) and uses `console.error` for any `fatal` level logs.
+
+## Options
+
+Pino can be passed a `browser` object in the options object,
+which can have the following properties:
+
+### `asObject` (Boolean)
+
+```js
+const pino = require('pino')({browser: {asObject: true}})
+```
+
+The `asObject` option will create a pino-like log object instead of
+passing all arguments to a console method, for instance:
+
+```js
+pino.info('hi') // creates and logs {msg: 'hi', level: 30, time: <ts>}
+```
+
+When `write` is set, `asObject` will always be `true`.
+
+### `write` (Function | Object)
+
+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.
+
+```js
+const pino = require('pino')({
+  browser: {
+    write: (o) => {
+      // do something with o
+    }
+  }
+})
+```
+
+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`.
+
+
+```js
+const pino = require('pino')({
+  browser: {
+    write: {
+      info: function (o) {
+        //process info log object
+      },
+      error: function (o) {
+        //process error log object
+      }
+    }
+  }
+})
+```
+
+### `serialize`: (Boolean | Array)
+
+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,
+
+```js
+const pino = require('pino')({
+  browser: {
+    serialize: true
+  }
+})
+```
+
+Or we can selectively enable them via an array:
+
+```js
+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'})
+```
+
+When `serialize` is `true` the standard error serializer is also enabled (see https://github.com/pinojs/pino/blob/master/docs/api.md#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`, like so:
+
+```js
+const pino = require('pino')({
+  serializers: {
+    custom: myCustomSerializer,
+    another: anotherSerializer
+  },
+  browser: {
+    serialize: ['!stdSerializers.err', 'custom'] //will not serialize Errors, will serialize `custom` keys
+  }
+})
+```
+
+The `serialize` array also applies to any child logger serializers (see https://github.com/pinojs/pino/blob/master/docs/api.md#discussion-2
+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#parameters.
+
+### `transmit` (Object)
+
+An object with `send` and `level` properties.
+
+The `transmit.level` property specifies the minimum level (inclusive) of when the `send` function
+should be called, if not supplied the `send` function be called based on the main logging `level`
+(set via `options.level`, defaulting to `info`).
+
+The `transmit` object must have a `send` function which will be called after
+writing the log message. The `send` function is passed the level of the log
+message and a `logEvent` object.
+
+The `logEvent` object is a data structure representing a log message, it represents
+the arguments passed to a logger statement, the level
+at which they were logged and the hierarchy of child bindings.
+
+The `logEvent` format is structured like so:
+
+```js
+{
+  ts = Number,
+  messages = Array,
+  bindings = Array,
+  level: { label = String, value = Number}
+}
+```
+
+The `ts` property is a unix epoch timestamp in milliseconds, the time is taken from the moment the
+logger method is called.
+
+The `messages` array is all arguments passed to logger method, (for instance `logger.info('a', 'b', 'c')`
+would result in `messages` array `['a', 'b', 'c']`).
+
+The `bindings` array 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.
+
+By default serializers are not applied to log output in the browser, but they will *always* be
+applied to `messages` and `bindings` in the `logEvent` object. This allows us to ensure a consistent
+format for all values between server and client.
+
+The `level` 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.
+
+The point of the `send` function is to remotely record log messages:
+
+```js
+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
+        }
+      }
+    }
+  }
+})
+```

node_modules/pino/docs/child-loggers.md

@@ -0,0 +1,95 @@
+# Child loggers
+
+Let's assume we want to have `"module":"foo"` added to every log within a
+module `foo.js`.
+
+To accomplish this, simply use a child logger:
+
+```js
+'use strict'
+// imports a pino logger instance of `require('pino')()`
+const parentLogger = require('./lib/logger')
+const log = parentLogger.child({module: 'foo'})
+
+function doSomething () {
+  log.info('doSomething invoked')
+}
+
+module.exports = {
+  doSomething
+}
+```
+
+## Cost of child logging
+
+Child logger creation is fast:
+
+```
+benchBunyanCreation*10000: 564.514ms
+benchBoleCreation*10000: 283.276ms
+benchPinoCreation*10000: 258.745ms
+benchPinoExtremeCreation*10000: 150.506ms
+```
+
+Logging through a child logger has little performance penalty:
+
+```
+benchBunyanChild*10000: 556.275ms
+benchBoleChild*10000: 288.124ms
+benchPinoChild*10000: 231.695ms
+benchPinoExtremeChild*10000: 122.117ms
+```
+
+Logging via the child logger of a child logger also has negligible overhead:
+
+```
+benchBunyanChildChild*10000: 559.082ms
+benchPinoChildChild*10000: 229.264ms
+benchPinoExtremeChildChild*10000: 127.753ms
+```
+
+## Duplicate keys caveat
+
+It's possible for naming conflicts to arise between child loggers and
+children of child loggers.
+
+This isn't as bad as it sounds, even if the same keys between
+parent and child loggers are used, Pino resolves the conflict in the sanest way.
+
+For example, consider the following:
+
+```js
+const pino = require('pino')
+pino(pino.destination('./my-log'))
+  .child({a: 'property'})
+  .child({a: 'prop'})
+  .info('howdy')
+```
+
+```sh
+$ cat my-log
+{"pid":95469,"hostname":"MacBook-Pro-3.home","level":30,"msg":"howdy","time":1459534114473,"a":"property","a":"prop"}
+```
+
+Notice how there's two key's named `a` in the JSON output. The sub-childs properties
+appear after the parent child properties.
+
+At some point the logs will most likely be processed (for instance with a [transport](transports.md)),
+and this generally involves parsing. `JSON.parse` will return an object where the conflicting
+namespace holds the final value assigned to it:
+
+```sh
+$ cat my-log | node -e "process.stdin.once('data', (line) => console.log(JSON.stringify(JSON.parse(line))))"
+{"pid":95469,"hostname":"MacBook-Pro-3.home","level":30,"msg":"howdy","time":"2016-04-01T18:08:34.473Z","a":"prop"}
+```
+
+Ultimately the conflict is resolved by taking the last value, which aligns with Bunyans child logging
+behavior.
+
+There may be cases where this edge case becomes problematic if a JSON parser with alternative behavior
+is used to process the logs. It's recommended to be conscious of namespace conflicts with child loggers,
+in light of an expected log processing approach.
+
+One of Pino's performance tricks is to avoid building objects and stringifying
+them, so we're building strings instead. This is why duplicate keys between
+parents and children will end up in log output.

node_modules/pino/docs/ecosystem.md

@@ -0,0 +1,73 @@
+# Pino Ecosystem
+
+This is a list of ecosystem modules that integrate with `pino`.
+
+Modules listed under [Core](#core) are maintained by the Pino team. Modules
+listed under [Community](#community) are maintained by independent community
+members.
+
+Please send a PR to add new modules!
+
+<a id="core"></a>
+## Core
+
++ [`express-pino-logger`](https://github.com/pinojs/express-pino-logger): use
+Pino to log requests within [express](https://expressjs.com/).
++ [`koa-pino-logger`](https://github.com/pinojs/koa-pino-logger): use Pino to
+log requests within [Koa](https://koajs.com/).
++ [`pino-arborsculpture`](https://github.com/pinojs/pino-arborsculpture): change
+log levels at runtime.
++ [`pino-caller`](https://github.com/pinojs/pino-caller): add callsite to the log line.
++ [`pino-clf`](https://github.com/pinojs/pino-clf): reformat Pino logs into
+Common Log Format.
++ [`pino-debug`](https://github.com/pinojs/pino-debug): use Pino to interpret
+[`debug`](https://npm.im/debug) logs.
++ [`pino-elasticsearch`](https://github.com/pinojs/pino-elasticsearch): send
+Pino logs to an Elasticsearch instance.
++ [`pino-eventhub`](https://github.com/pinojs/pino-eventhub): send Pino logs
+to an [Event Hub](https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-what-is-event-hubs).
++ [`pino-filter`](https://github.com/pinojs/pino-filter): filter Pino logs in
+the same fashion as the [`debug`](https://npm.im/debug) module.
++ [`pino-gelf`](https://github.com/pinojs/pino-gelf): reformat Pino logs into
+GELF format for Graylog.
++ [`pino-hapi`](https://github.com/pinojs/hapi-pino): use Pino as the logger
+for [Hapi](https://hapijs.com/).
++ [`pino-http`](https://github.com/pinojs/pino-http): easily use Pino to log
+requests with the core `http` module.
++ [`pino-http-print`](https://github.com/pinojs/pino-http-print): reformat Pino
+logs into traditional [HTTPD](https://httpd.apache.org/) style request logs.
++ [`pino-multi-stream`](https://github.com/pinojs/pino-multi-stream): send
+logs to multiple destination streams (slow!).
++ [`pino-mongodb`](https://github.com/pinojs/pino-mongodb): store Pino logs
+in a MongoDB database.
++ [`pino-noir`](https://github.com/pinojs/pino-noir): redact sensitive information
+in logs.
++ [`pino-pretty`](https://github.com/pinojs/pino-pretty): basic prettifier to
+make log lines human readable.
++ [`pino-socket`](https://github.com/pinojs/pino-socket): send logs to TCP or UDP
+destinations.
++ [`pino-std-serializers`](https://github.com/pinojs/pino-std-serializers): the
+core object serializers used within Pino.
++ [`pino-syslog`](https://github.com/pinojs/pino-syslog): reformat Pino logs
+to standard syslog format.
++ [`pino-tee`](https://github.com/pinojs/pino-tee): pipe Pino logs into files
+based upon log levels.
++ [`pino-toke`](https://github.com/pinojs/pino-toke): reformat Pino logs
+according to a given format string.
++ [`restify-pino-logger`](https://github.com/pinojs/restify-pino-logger): use
+Pino to log requests within [restify](http://restify.com/).
++ [`rill-pino-logger`](https://github.com/pinojs/rill-pino-logger): use Pino as
+the logger for the [Rill framework](https://rill.site/).
+
+<a id="community"></a>
+## Community
+
++ [`pino-colada`](https://github.com/lrlna/pino-colada): cute ndjson formatter for pino.
++ [`pino-fluentd`](https://github.com/davidedantonio/pino-fluentd): send Pino logs to Elasticsearch, 
+MongoDB and many [others](https://www.fluentd.org/dataoutputs) via Fluentd.
++ [`pino-pretty-min`](https://github.com/unjello/pino-pretty-min): a minimal
+prettifier inspired by the [logrus](https://github.com/sirupsen/logrus) logger.
++ [`pino-rotating-file`](https://github.com/homeaway/pino-rotating-file): a hapi-pino log transport for splitting logs into separate, automatically rotating files.
++ [`cls-proxify`](https://github.com/keenondrums/cls-proxify): integration of pino and [CLS](https://github.com/jeff-lewis/cls-hooked). Useful for creating dynamically configured child loggers (e.g. with added trace ID) for each request. 
++ [`pino-tiny`](https://github.com/holmok/pino-tiny): a tiny (and exentsible?) little log formatter for pino.
++ [`pino-dev`](https://github.com/dnjstrom/pino-dev): simple prettifier for pino with built-in support for common ecosystem packages.

node_modules/pino/docs/help.md

@@ -0,0 +1,316 @@
+# Help
+
+* [Exit logging](#exit-logging)
+* [Log rotation](#rotate)
+* [Reopening log files](#reopening)
+* [Saving to multiple files](#multiple)
+* [Log filtering](#filter-logs)
+* [Transports and systemd](#transport-systemd)
+* [Log to different streams](#multi-stream)
+* [Duplicate keys](#dupe-keys)
+* [Log levels as labels instead of numbers](#level-string)
+* [Pino with `debug`](#debug)
+* [Unicode and Windows terminal](#windows)
+* [Mapping Pino Log Levels to Google Cloud Logging (Stackdriver) Serverity Levels](#stackdriver)
+* [Avoid Message Conflict](#avoid-message-conflict)
+
+<a id="exit-logging"></a>
+## Exit logging
+
+When a Node process crashes from uncaught exception, exits due to a signal,
+or exits of it's own accord we may want to write some final logs – particularly
+in cases of error.
+
+Writing to a Node.js stream on exit is not necessarily guaranteed, and naively writing
+to an asynchronous logger on exit will definitely lead to lost logs.
+
+To write logs in an exit handler, create the handler with [`pino.final`](/docs/api.md#pino-final):
+
+```js
+process.on('uncaughtException', pino.final(logger, (err, finalLogger) => {
+  finalLogger.error(err, 'uncaughtException')
+  process.exit(1)
+}))
+
+process.on('unhandledRejection', pino.final(logger, (err, finalLogger) => {
+  finalLogger.error(err, 'unhandledRejection')
+  process.exit(1)
+}))
+```
+
+The `finalLogger` is a special logger instance that will synchronously and reliably
+flush every log line. This is important in exit handlers, since no more asynchronous
+activity may be scheduled.
+
+<a id="rotate"></a>
+## Log rotation
+
+Use a separate tool for log rotation:
+We recommend [logrotate](https://github.com/logrotate/logrotate).
+Consider we output our logs to `/var/log/myapp.log` like so:
+
+```
+$ node server.js > /var/log/myapp.log
+```
+
+We would rotate our log files with logrotate, by adding the following to `/etc/logrotate.d/myapp`:
+
+```
+/var/log/myapp.log {
+       su root
+       daily
+       rotate 7
+       delaycompress
+       compress
+       notifempty
+       missingok
+       copytruncate
+}
+```
+
+The `copytruncate` configuration has a very slight possibility of lost log lines due
+to a gap between copying and truncating - the truncate may occur after additional lines
+have been written. To perform log rotation without `copytruncate`, see the [Reopening log files](#reopening)
+help.
+
+<a id="reopening"></a>
+## Reopening log files
+
+In cases where a log rotation tool doesn't offer a copy-truncate capabilities,
+or where using them is deemed inappropriate, `pino.destination`
+is able to reopen file paths after a file has been moved away.
+
+One way to use this is to set up a `SIGUSR2` or `SIGHUP` signal handler that
+reopens the log file destination, making sure to write the process PID out
+somewhere so the log rotation tool knows where to send the signal.
+
+```js
+// write the process pid to a well known location for later
+const fs = require('fs')
+fs.writeFileSync('/var/run/myapp.pid', process.pid)
+
+const dest = pino.destination('/log/file')
+const logger = require('pino')(dest)
+process.on('SIGHUP', () => dest.reopen())
+```
+
+The log rotation tool can then be configured to send this signal to the process
+after a log rotation event has occurred.
+
+Given a similar scenario as in the [Log rotation](#rotate) section a basic
+`logrotate` config that aligns with this strategy would look similar to the following:
+
+```
+/var/log/myapp.log {
+       su root
+       daily
+       rotate 7
+       delaycompress
+       compress
+       notifempty
+       missingok
+       postrotate
+           kill -HUP `cat /var/run/myapp.pid`
+       endscript
+}
+```
+
+<a id="multiple"></a>
+## Saving to multiple files
+
+Let's assume we want to store all error messages to a separate log file.
+
+Install [pino-tee](https://npm.im/pino-tee) with:
+
+```bash
+npm i pino-tee -g
+```
+
+The following writes the log output of `app.js` to `./all-logs`, while
+writing only warnings and errors to `./warn-log:
+
+```bash
+node app.js | pino-tee warn ./warn-logs > ./all-logs
+```
+
+<a id="filter-logs"></a>
+## Log Filtering
+The Pino philosophy advocates common, pre-existing, system utilities.
+
+Some recommendations in line with this philosophy are:
+
+1. Use [`grep`](https://linux.die.net/man/1/grep):
+    ```sh
+    $ # View all "INFO" level logs
+    $ node app.js | grep '"level":30'
+    ```
+1. Use [`jq`](https://stedolan.github.io/jq/):
+    ```sh
+    $ # View all "ERROR" level logs
+    $ node app.js | jq 'select(.level == 50)'
+    ```
+
+<a id="transport-systemd"></a>
+## Transports and systemd
+`systemd` makes it complicated to use pipes in services. One method for overcoming
+this challenge is to use a subshell:
+
+```
+ExecStart=/bin/sh -c '/path/to/node app.js | pino-transport'
+```
+
+<a id="multi-stream"></a>
+## Log to different streams
+
+Pino's default log destination is the singular destination of `stdout`. While
+not recommended for performance reasons, multiple destinations can be targeted
+by using [`pino-multi-stream`](https://github.com/pinojs/pino-multi-stream).
+
+In this example we use `stderr` for `error` level logs and `stdout` as default
+for all other levels (e.g. `debug`, `info`, and `warn`).
+
+```js
+const pino = require('pino')
+const { multistream } = require('pino-multi-stream')
+var streams = [
+  {level: 'debug', stream: process.stdout},
+  {level: 'error', stream: process.stderr},
+  {level: 'fatal', stream: process.stderr}
+]
+
+const logger = pino({
+  name: 'my-app',
+  level: 'info',
+}, multistream(streams))
+```
+
+
+<a id="dupe-keys"></a>
+## How Pino handles duplicate keys
+
+Duplicate keys are possibly when a child logger logs an object with a key that
+collides with a key in the child loggers bindings.
+
+See the [child logger duplicate keys caveat](/docs/child-loggers.md#duplicate-keys-caveat)
+for information on this is handled.
+
+<a id="level-string"></a>
+## Log levels as labels instead of numbers
+Pino log lines are meant to be parseable. Thus, Pino's default mode of operation
+is to print the level value instead of the string name. However, while it is
+possible to set the `useLevelLabels` option, we recommend using one of these
+options instead if you are able:
+
+1. If the only change desired is the name then a transport can be used. One such
+transport is [`pino-text-level-transport`](https://npm.im/pino-text-level-transport).
+1. Use a prettifier like [`pino-pretty`](https://npm.im/pino-pretty) to make
+the logs human friendly.
+
+<a id="debug"></a>
+## Pino with `debug`
+
+The popular [`debug`](https://npm.im/debug) is used in many modules across the ecosystem.
+
+The [`pino-debug`](https://github.com/pinojs/pino-debug) module
+can capture calls to `debug` loggers and run them
+through `pino` instead. This results in a 10x (20x in asynchronous mode)
+performance improvement - even though `pino-debug` is logging additional
+data and wrapping it in JSON.
+
+To quickly enable this install [`pino-debug`](https://github.com/pinojs/pino-debug)
+and preload it with the `-r` flag, enabling any `debug` logs with the
+`DEBUG` environment variable:
+
+```sh
+$ npm i pino-debug
+$ DEBUG=* node -r pino-debug app.js
+```
+
+[`pino-debug`](https://github.com/pinojs/pino-debug) also offers fine grain control to map specific `debug`
+namespaces to `pino` log levels. See [`pino-debug`](https://github.com/pinojs/pino-debug)
+for more.
+
+<a id="windows"></a>
+## Unicode and Windows terminal
+
+Pino uses [sonic-boom](https://github.com/mcollina/sonic-boom) to speed
+up logging. Internally, it uses [`fs.write`](https://nodejs.org/dist/latest-v10.x/docs/api/fs.html#fs_fs_write_fd_string_position_encoding_callback) to write log lines directly to a file
+descriptor. On Windows, unicode output is not handled properly in the
+terminal (both `cmd.exe` and powershell), and as such the output could
+be visualized incorrectly if the log lines include utf8 characters. It
+is possible to configure the terminal to visualize those characters
+correctly with the use of [`chcp`](https://ss64.com/nt/chcp.html) by
+executing in the terminal `chcp 65001`. This is a known limitation of
+Node.js.
+
+<a id="stackdriver"></a>
+## Mapping Pino Log Levels to Google Cloud Logging (Stackdriver) Serverity Levels
+
+Google Cloud Logging uses `severity` levels instead log levels. As a result, all logs may show as INFO
+level logs while completely ignoring the level set in the pino log. Google Cloud Logging also prefers that
+log data is present inside a `message` key instead of the default `msg` key that Pino uses. Use a technique
+similar to the one below to retain log levels in Google Clould Logging
+
+```js
+const pino = require('pino')
+
+// https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#logseverity
+const PinoLevelToSeverityLookup = {
+  trace: 'DEBUG',
+  debug: 'DEBUG',
+  info: 'INFO',
+  warn: 'WARNING',
+  error: 'ERROR',
+  fatal: 'CRITICAL',
+};
+
+const defaultPinoConf = {
+  messageKey: 'message',
+  formatters: {
+    level(label, number) {
+      return {
+        severity: PinoLevelToSeverityLookup[label] || PinoLevelToSeverityLookup['info'],
+        level: number,
+      }
+    },
+    log(message) {
+      return { message }
+    }
+  },
+}
+
+module.exports = function createLogger(options) {
+  return pino(Object.assign({}, options, defaultPinoConf))
+}
+```
+
+<a id="avoid-message-conflict"></a>
+## Avoid Message Conflict
+
+As described in the [`message` documentation](/docs/api.md#message), when a log
+is written like `log.info({ msg: 'a message' }, 'another message')` then the
+final output JSON will have `"msg":"another message"` and the `'a message'`
+string will be lost. To overcome this, the [`logMethod` hook](/docs/api.md#logmethod)
+can be used:
+
+```js
+'use strict'
+
+const log = require('pino')({
+  level: 'debug',
+  hooks: {
+    logMethod (inputArgs, method) {
+      if (inputArgs.length === 2 && inputArgs[0].msg) {
+       inputArgs[0].originalMsg = inputArgs[0].msg
+      }
+      return method.apply(this, inputArgs)
+    }
+  }
+})
+
+log.info('no original message')
+log.info({ msg: 'mapped to originalMsg' }, 'a message')
+
+// {"level":30,"time":1596313323106,"pid":63739,"hostname":"foo","msg":"no original message"}
+// {"level":30,"time":1596313323107,"pid":63739,"hostname":"foo","msg":"a message","originalMsg":"mapped to originalMsg"}
+```

node_modules/pino/docs/legacy.md

@@ -0,0 +1,167 @@
+# Legacy
+
+## Legacy Node Support
+
+### Node v4
+
+Node v4 is supported on the [Pino v4](#pino-v4-documentation) line.
+
+### Node v0.10-v0.12
+
+Node v0.10 or Node v0.12 is supported on the [Pino v2](#pino-v2-documentation) line.
+
+## Documentation
+
+### Pino v4 Documentation
+
+<https://github.com/pinojs/pino/tree/v4.x.x/docs>
+
+### Pino v3 Documentation
+
+<https://github.com/pinojs/pino/tree/v3.x.x/docs>
+
+### Pino v2 Documentation
+
+<https://github.com/pinojs/pino/tree/v2.x.x/docs>
+
+## Migration
+
+### Pino v4 to Pino v5
+
+#### Logging Destination
+
+In Pino v4 the destination could be set by passing a stream as the
+second parameter to the exported `pino` function. This is still the
+case in v5. However it's strongly recommended to use `pino.destination`
+which will write logs ~30% faster.
+
+##### v4
+
+```js
+const stdoutLogger = require('pino')()
+const stderrLogger = require('pino')(process.stderr)
+const fileLogger = require('pino')(fs.createWriteStream('/log/path'))
+```
+
+##### v5
+
+```js
+const stdoutLogger = require('pino')() // pino.destination by default
+const stderrLogger = require('pino')(pino.destination(2))
+const fileLogger = require('pino')(pino.destination('/log/path'))
+```
+
+Note: This is not a breaking change, `WritableStream` instances are still
+supported, but are slower than `pino.destination` which
+uses the high speed [`sonic-boom` ⇗](https://github.com/mcollina/sonic-boom) library.
+
+* See [`destination` parameter](/docs/api.md#destination)
+
+#### Extreme Mode
+
+The `extreme` setting does not exist as an option in Pino v5, instead use
+a `pino.extreme` destination.
+
+##### v4
+
+```js
+const stdoutLogger = require('pino')({extreme: true})
+const stderrLogger = require('pino')({extreme: true}, process.stderr)
+const fileLogger = require('pino')({extreme: true}, fs.createWriteStream('/log/path'))
+```
+
+##### v5
+
+```js
+const stdoutLogger = require('pino')(pino.extreme())
+const stderrLogger = require('pino')(pino.extreme(2))
+const fileLogger = require('pino')(pino.extreme('/log/path'))
+```
+
+* See [pino.extreme](/docs/api.md#pino-extreme)
+* See [Extreme mode ⇗](/docs/extreme.md)
+
+
+#### Pino CLI is now pino-pretty CLI
+
+The Pino CLI is provided with Pino v4 for basic log prettification.
+
+From Pino v5 the CLI is installed separately with `pino-pretty`.
+
+##### v4
+```sh
+$ npm install -g pino
+$ node app.js | pino
+```
+
+##### v5
+```sh
+$ npm install -g pino-pretty
+$ node app.js | pino-pretty
+```
+
+* See [Pretty Printing documentation](/docs/pretty.md)
+
+#### Programmatic Pretty Printing
+
+The [`pino.pretty()`](https://github.com/pinojs/pino/blob/v4.x.x/docs/API.md#prettyoptions)
+method has also been removed from Pino v5.
+
+##### v4
+
+```js
+var pino = require('pino')
+var pretty = pino.pretty()
+pretty.pipe(process.stdout)
+```
+
+##### v5
+
+Instead use the `prettyPrint` option (also available in v4):
+
+```js
+const logger = require('pino')({
+  prettyPrint: process.env.NODE_ENV !== 'production'
+})
+```
+
+In v5 the `pretty-print` module must be installed to use the `prettyPrint` option:
+
+```sh
+npm install --save-dev pino-pretty
+```
+
+* See [prettyPrint option](/docs/api.md#prettyPrint)
+* See [Pretty Printing documentation](/docs/pretty.md)
+
+#### Slowtime
+
+In Pino v4 a `slowtime` option was supplied, which allowed for full ISO dates
+in the timestamps instead of milliseconds since the Epoch. In Pino v5 this
+has been completely removed, along with the `pino.stdTimeFunctions.slowTime`
+function. In order to achieve the equivalent in v5, a custom
+time function should be supplied:
+
+##### v4
+
+```js
+const pino = require('pino')
+const logger = pino({slowtime: true})
+// following avoids deprecation warning in v4:
+const loggerAlt = pino({timestamp: pino.stdTimeFunctions.slowTime})
+```
+
+##### v5
+
+```js
+const logger = require('pino')({
+  timestamp: () => ',"time":"' + (new Date()).toISOString() + '"'
+})
+```
+
+The practice of creating ISO dates in-process for logging purposes is strongly
+recommended against. Instead consider post-processing the logs or using a transport
+to convert the timestamps.
+
+
+* See [timestamp option](/docs/api.md#timestamp)

node_modules/pino/docs/lts.md

@@ -0,0 +1,61 @@
+## Long Term Support
+
+Pino's Long Term Support (LTS) is provided according to the schedule laid
+out in this document:
+
+1. Major releases, "X" release of [semantic versioning][semver] X.Y.Z release
+   versions, are supported for a minimum period of six months from their release
+   date. The release date of any specific version can be found at
+   [https://github.com/pinojs/pino/releases](https://github.com/pinojs/pino/releases).
+
+1. Major releases will receive security updates for an additional six months
+   from the release of the next major release. After this period
+   we will still review and release security fixes as long as they are
+   provided by the community and they do not violate other constraints,
+   e.g. minimum supported Node.js version.
+
+1. Major releases will be tested and verified against all Node.js
+   release lines that are supported by the
+   [Node.js LTS policy](https://github.com/nodejs/Release) within the
+   LTS period of that given Pino release line. This implies that only
+   the latest Node.js release of a given line is supported.
+
+A "month" is defined as 30 consecutive days.
+
+> ## Security Releases and Semver
+>
+> As a consequence of providing long-term support for major releases, there
+> are occasions where we need to release breaking changes as a _minor_
+> version release. Such changes will _always_ be noted in the
+> [release notes](https://github.com/pinojs/pino/releases).
+>
+> To avoid automatically receiving breaking security updates it is possible to use
+> the tilde (`~`) range qualifier. For example, to get patches for the 6.1
+> release, and avoid automatically updating to the 6.1 release, specify
+> the dependency as `"pino": "~6.1.x"`. This will leave your application vulnerable,
+> so please use with caution.
+
+[semver]: https://semver.org/
+
+<a name="lts-schedule"></a>
+
+### Schedule
+
+| Version | Release Date | End Of LTS Date | Node.js              |
+| :------ | :----------- | :-------------- | :------------------- |
+| 6.x     | 2020-03-07   | TBD             | 10, 12, 14, 16       |
+
+<a name="supported-os"></a>
+
+### CI tested operating systems
+
+Pino uses GitHub Actions for CI testing, please refer to
+[GitHub's documentation regarding workflow runners](https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#supported-runners-and-hardware-resources)
+for further details on what the latest virtual environment is in relation to
+the YAML workflow labels below:
+
+| OS      | YAML Workflow Label    | Node.js      |
+|---------|------------------------|--------------|
+| Linux   | `ubuntu-latest`        | 10,12,14,16  |
+| Windows | `windows-latest`       | 10,12,14,16  |
+| MacOS   | `macos-latest`         | 10,12,14,16  |

node_modules/pino/docs/pretty.md

@@ -0,0 +1,101 @@
+# Pretty Printing
+
+By default, Pino log lines are newline delimited JSON (NDJSON). This is perfect
+for production usage and long term storage. It's not so great for development
+environments. Thus, Pino logs can be prettified by using a Pino prettifier
+module like [`pino-pretty`][pp]:
+
+```sh
+$ cat app.log | pino-pretty
+```
+
+For almost all situations, this is the recommended way to prettify logs. The
+programmatic API, described in the next section, is primarily for integration
+purposes with other CLI based prettifiers.
+
+## Prettifier API
+
+Pino prettifier modules are extra modules that provide a CLI for parsing NDJSON
+log lines piped via `stdin` and expose an API which conforms to the Pino
+[metadata streams](/docs/api.md#metadata) API.
+
+The API requires modules provide a factory function which returns a prettifier
+function. This prettifier function must accept either a string of NDJSON or
+a Pino log object. A pseudo-example of such a prettifier is:
+
+The uninitialized Pino instance is passed as `this` into prettifier factory function,
+so it can be accessed via closure by the returned prettifier function.
+
+```js
+module.exports = function myPrettifier (options) {
+  // `this` is bound to the pino instance
+  // Deal with whatever options are supplied.
+  return function prettifier (inputData) {
+    let logObject
+    if (typeof inputData === 'string') {
+      logObject = someJsonParser(inputData)
+    } else if (isObject(inputData)) {
+      logObject = inputData
+    }
+    if (!logObject) return inputData
+    // implement prettification
+  }
+
+  function isObject (input) {
+    return Object.prototype.toString.apply(input) === '[object Object]'
+  }
+}
+```
+
+The reference implementation of such a module is the [`pino-pretty`][pp] module.
+To learn more about creating a custom prettifier module, refer to the
+`pino-pretty` source code.
+
+Note: if the prettifier returns `undefined`, instead of a formatted line, nothing
+will be written to the destination stream.
+
+### API Example
+
+> #### NOTE:
+> For general usage, it is highly recommended that logs are piped into
+> the prettifier instead. Prettified logs are not easily parsed and cannot
+> be easily investigated at a later date.
+
+1. Install a prettifier module as a separate dependency, e.g. `npm install pino-pretty`.
+1. Instantiate the logger with pretty printing enabled:
+  ```js
+  const pino = require('pino')
+  const log = pino({
+    prettyPrint: {
+      levelFirst: true
+    },
+    prettifier: require('pino-pretty')
+  })
+  ```
+  Note: the default prettifier module is `pino-pretty`, so the preceding
+  example could be:
+  ```js
+  const pino = require('pino')
+  const log = pino({
+    prettyPrint: {
+      levelFirst: true
+    }
+  })
+  ```
+  See the [`pino-pretty` documentation][pp] for more information on the options
+  that can be passed via `prettyPrint`.
+   
+The default prettifier write stream does not guarantee final log writes.
+Correspondingly, a warning is written to logs on first synchronous flushing.
+This warning may be suppressed by passing `suppressFlushSyncWarning : true` to
+`prettyPrint`:
+  ```js
+  const pino = require('pino')
+  const log = pino({
+    prettyPrint: {
+      suppressFlushSyncWarning: true
+    }
+  })
+  ```
+
+  [pp]: https://github.com/pinojs/pino-pretty

node_modules/pino/docs/redaction.md

@@ -0,0 +1,135 @@
+# Redaction
+
+> Redaction is not supported in the browser [#670](https://github.com/pinojs/pino/issues/670)
+
+To redact sensitive information, supply paths to keys that hold sensitive data
+using the `redact` option. Note that paths which contain hypens need to use
+brackets in order to access the hyphenated property:
+
+```js
+const logger = require('.')({
+  redact: ['key', 'path.to.key', 'stuff.thats[*].secret', 'path["with-hyphen"]']
+})
+
+logger.info({
+  key: 'will be redacted',
+  path: {
+    to: {key: 'sensitive', another: 'thing'}
+  },
+  stuff: {
+    thats: [
+      {secret: 'will be redacted', logme: 'will be logged'},
+      {secret: 'as will this', logme: 'as will this'}
+    ]
+  }
+})
+```
+
+This will output:
+
+```JSON
+{"level":30,"time":1527777350011,"pid":3186,"hostname":"Davids-MacBook-Pro-3.local","key":"[Redacted]","path":{"to":{"key":"[Redacted]","another":"thing"}},"stuff":{"thats":[{"secret":"[Redacted]","logme":"will be logged"},{"secret":"[Redacted]","logme":"as will this"}]}}
+```
+
+The `redact` option can take an array (as shown in the above example) or
+an object. This allows control over *how* information is redacted.
+
+For instance, setting the censor:
+
+```js
+const logger = require('.')({
+  redact: {
+    paths: ['key', 'path.to.key', 'stuff.thats[*].secret'],
+    censor: '**GDPR COMPLIANT**'
+  }
+})
+
+logger.info({
+  key: 'will be redacted',
+  path: {
+    to: {key: 'sensitive', another: 'thing'}
+  },
+  stuff: {
+    thats: [
+      {secret: 'will be redacted', logme: 'will be logged'},
+      {secret: 'as will this', logme: 'as will this'}
+    ]
+  }
+})
+```
+
+This will output:
+
+```JSON
+{"level":30,"time":1527778563934,"pid":3847,"hostname":"Davids-MacBook-Pro-3.local","key":"**GDPR COMPLIANT**","path":{"to":{"key":"**GDPR COMPLIANT**","another":"thing"}},"stuff":{"thats":[{"secret":"**GDPR COMPLIANT**","logme":"will be logged"},{"secret":"**GDPR COMPLIANT**","logme":"as will this"}]}}
+```
+
+The `redact.remove` option also allows for the key and value to be removed from output:
+
+```js
+const logger = require('.')({
+  redact: {
+    paths: ['key', 'path.to.key', 'stuff.thats[*].secret'],
+    remove: true
+  }
+})
+
+logger.info({
+  key: 'will be redacted',
+  path: {
+    to: {key: 'sensitive', another: 'thing'}
+  },
+  stuff: {
+    thats: [
+      {secret: 'will be redacted', logme: 'will be logged'},
+      {secret: 'as will this', logme: 'as will this'}
+    ]
+  }
+})
+```
+
+This will output
+
+```JSON
+{"level":30,"time":1527782356751,"pid":5758,"hostname":"Davids-MacBook-Pro-3.local","path":{"to":{"another":"thing"}},"stuff":{"thats":[{"logme":"will be logged"},{"logme":"as will this"}]}}
+```
+
+See [pino options in API](/docs/api.md#redact-array-object) for `redact` API details.
+
+<a name="paths"></a>
+## Path Syntax
+
+The syntax for paths supplied to the `redact` option conform to the syntax in path lookups
+in standard EcmaScript, with two additions:
+
+* paths may start with bracket notation
+* paths may contain the asterisk `*` to denote a wildcard
+* paths are **case sensitive**
+
+By way of example, the following are all valid paths:
+
+* `a.b.c`
+* `a["b-c"].d`
+* `["a-b"].c`
+* `a.b.*`
+* `a[*].b`
+
+## Overhead
+
+Pino's redaction functionality is built on top of [`fast-redact`](https://github.com/davidmarkclements/fast-redact)
+which adds about 2% overhead to `JSON.stringify` when using paths without wildcards.
+
+When used with pino logger with a single redacted path, any overhead is within noise -
+a way to deterministically measure it's effect has not been found. This is because its not a bottleneck.
+
+However, wildcard redaction does carry a non-trivial cost relative to explicitly declaring the keys
+(50% in a case where four keys are redacted across two objects). See
+the [`fast-redact` benchmarks](https://github.com/davidmarkclements/fast-redact#benchmarks) for details.
+
+## Safety
+
+The `redact` option is intended as an initialization time configuration option.
+It's extremely important that path strings do not originate from user input.
+The `fast-redact` module uses a VM context to syntax check the paths, user input
+should never be combined with such an approach. See the [`fast-redact` Caveat](https://github.com/davidmarkclements/fast-redact#caveat)
+and the [`fast-redact` Approach](https://github.com/davidmarkclements/fast-redact#approach) for in-depth information.

node_modules/pino/docs/transports.md

@@ -0,0 +1,455 @@
+# Transports
+
+A "transport" for Pino is a supplementary tool which consumes Pino logs.
+
+Consider the following example:
+
+```js
+const split = require('split2')
+const pump = require('pump')
+const through = require('through2')
+
+const myTransport = through.obj(function (chunk, enc, cb) {
+  // do the necessary
+  console.log(chunk)
+  cb()
+})
+
+pump(process.stdin, split(JSON.parse), myTransport)
+```
+
+The above defines our "transport" as the file `my-transport-process.js`.
+
+Logs can now be consumed using shell piping:
+
+```sh
+node my-app-which-logs-stuff-to-stdout.js | node my-transport-process.js
+```
+
+Ideally, a transport should consume logs in a separate process to the application,
+Using transports in the same process causes unnecessary load and slows down
+Node's single threaded event loop.
+
+## In-process transports
+
+> **Pino *does not* natively support in-process transports.**
+
+Pino does not support in-process transports because Node processes are
+single threaded processes (ignoring some technical details). Given this
+restriction, one of the methods Pino employs to achieve its speed is to
+purposefully offload the handling of logs, and their ultimate destination, to
+external processes so that the threading capabilities of the OS can be
+used (or other CPUs).
+
+One consequence of this methodology is that "error" logs do not get written to
+`stderr`. However, since Pino logs are in a parsable format, it is possible to
+use tools like [pino-tee][pino-tee] or [jq][jq] to work with the logs. For
+example, to view only logs marked as "error" logs:
+
+```
+$ node an-app.js | jq 'select(.level == 50)'
+```
+
+In short, the way Pino generates logs:
+
+1. Reduces the impact of logging on an application to the absolute minimum.
+2. Gives greater flexibility in how logs are processed and stored.
+
+Given all of the above, Pino recommends out-of-process log processing.
+
+However, it is possible to wrap Pino and perform processing in-process.
+For an example of this, see [pino-multi-stream][pinoms].
+
+[pino-tee]: https://npm.im/pino-tee
+[jq]: https://stedolan.github.io/jq/
+[pinoms]: https://npm.im/pino-multi-stream
+
+## Known Transports
+
+PR's to this document are welcome for any new transports!
+
++ [pino-applicationinsights](#pino-applicationinsights)
++ [pino-azuretable](#pino-azuretable)
++ [pino-cloudwatch](#pino-cloudwatch)
++ [pino-couch](#pino-couch)
++ [pino-datadog](#pino-datadog)
++ [pino-elasticsearch](#pino-elasticsearch)
++ [pino-gelf](#pino-gelf)
++ [pino-http-send](#pino-http-send)
++ [pino-kafka](#pino-kafka)
++ [pino-logdna](#pino-logdna)
++ [pino-logflare](#pino-logflare)
++ [pino-mq](#pino-mq)
++ [pino-mysql](#pino-mysql)
++ [pino-papertrail](#pino-papertrail)
++ [pino-pg](#pino-pg)
++ [pino-redis](#pino-redis)
++ [pino-sentry](#pino-sentry)
++ [pino-seq](#pino-seq)
++ [pino-socket](#pino-socket)
++ [pino-stackdriver](#pino-stackdriver)
++ [pino-syslog](#pino-syslog)
++ [pino-websocket](#pino-websocket)
+
+
+
+<a id="pino-applicationinsights"></a>
+### pino-applicationinsights
+The [pino-applicationinsights](https://www.npmjs.com/package/pino-applicationinsights) module is a transport that will forward logs to [Azure Application Insights](https://docs.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview).
+
+Given an application `foo` that logs via pino, you would use `pino-applicationinsights` like so:
+
+``` sh
+$ node foo | pino-applicationinsights --key blablabla
+```
+
+For full documentation of command line switches read [readme](https://github.com/ovhemert/pino-applicationinsights#readme)
+
+<a id="pino-azuretable"></a>
+### pino-azuretable
+The [pino-azuretable](https://www.npmjs.com/package/pino-azuretable) module is a transport that will forward logs to the [Azure Table Storage](https://azure.microsoft.com/en-us/services/storage/tables/).
+
+Given an application `foo` that logs via pino, you would use `pino-azuretable` like so:
+
+``` sh
+$ node foo | pino-azuretable --account storageaccount --key blablabla
+```
+
+For full documentation of command line switches read [readme](https://github.com/ovhemert/pino-azuretable#readme)
+
+<a id="pino-cloudwatch"></a>
+### pino-cloudwatch
+
+[pino-cloudwatch][pino-cloudwatch] is a transport that buffers and forwards logs to [Amazon CloudWatch][].
+
+```sh
+$ node app.js | pino-cloudwatch --group my-log-group
+```
+
+[pino-cloudwatch]: https://github.com/dbhowell/pino-cloudwatch
+[Amazon CloudWatch]: https://aws.amazon.com/cloudwatch/
+
+<a id="pino-couch"></a>
+### pino-couch
+
+[pino-couch][pino-couch] uploads each log line as a [CouchDB][CouchDB] document.
+
+```sh
+$ node app.js | pino-couch -U https://couch-server -d mylogs
+```
+
+[pino-couch]: https://github.com/IBM/pino-couch
+[CouchDB]: https://couchdb.apache.org
+
+<a id="pino-datadog"></a>
+### pino-datadog
+The [pino-datadog](https://www.npmjs.com/package/pino-datadog) module is a transport that will forward logs to [DataDog](https://www.datadoghq.com/) through it's API.
+
+Given an application `foo` that logs via pino, you would use `pino-datadog` like so:
+
+``` sh
+$ node foo | pino-datadog --key blablabla
+```
+
+For full documentation of command line switches read [readme](https://github.com/ovhemert/pino-datadog#readme)
+
+<a id="pino-elasticsearch"></a>
+### pino-elasticsearch
+
+[pino-elasticsearch][pino-elasticsearch] uploads the log lines in bulk
+to [Elasticsearch][elasticsearch], to be displayed in [Kibana][kibana].
+
+It is extremely simple to use and setup
+
+```sh
+$ node app.js | pino-elasticsearch
+```
+
+Assuming Elasticsearch is running on localhost.
+
+To connect to an external elasticsearch instance (recommended for production):
+
+* Check that `network.host` is defined in the `elasticsearch.yml` configuration file. See [elasticsearch Network Settings documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-network.html#common-network-settings) for more details.
+* Launch:
+
+```sh
+$ node app.js | pino-elasticsearch --node http://192.168.1.42:9200
+```
+
+Assuming Elasticsearch is running on `192.168.1.42`.
+
+To connect to AWS Elasticsearch:
+
+```sh
+$ node app.js | pino-elasticsearch --node https://es-url.us-east-1.es.amazonaws.com --es-version 6
+```
+
+Then [create an index pattern](https://www.elastic.co/guide/en/kibana/current/setup.html) on `'pino'` (the default index key for `pino-elasticsearch`) on the Kibana instance.
+
+[pino-elasticsearch]: https://github.com/pinojs/pino-elasticsearch
+[elasticsearch]: https://www.elastic.co/products/elasticsearch
+[kibana]: https://www.elastic.co/products/kibana
+
+<a id="pino-gelf"></a>
+### pino-gelf
+
+Pino GELF ([pino-gelf]) is a transport for the Pino logger. Pino GELF receives Pino logs from stdin and transforms them into [GELF format][gelf] before sending them to a remote [Graylog server][graylog] via UDP.
+
+```sh
+$ node your-app.js | pino-gelf log
+```
+
+[pino-gelf]: https://github.com/pinojs/pino-gelf
+[gelf]: https://docs.graylog.org/en/2.1/pages/gelf.html
+[graylog]: https://www.graylog.org/
+
+<a id="pino-http-send"></a>
+### pino-http-send
+
+[pino-http-send](https://npmjs.com/package/pino-http-send) is a configurable and low overhead
+transport that will batch logs and send to a specified URL.
+
+```console
+$ node app.js | pino-http-send -u http://localhost:8080/logs
+```
+
+<a id="pino-kafka"></a>
+### pino-kafka
+
+[pino-kafka](https://github.com/ayZagen/pino-kafka) transport to send logs to [Apache Kafka](https://kafka.apache.org/).
+
+```sh
+$ node index.js | pino-kafka -b 10.10.10.5:9200 -d mytopic
+```
+
+<a id="pino-logdna"></a>
+### pino-logdna
+
+[pino-logdna](https://github.com/logdna/pino-logdna) transport to send logs to [LogDNA](https://logdna.com).
+
+```sh
+$ node index.js | pino-logdna --key YOUR_INGESTION_KEY
+```
+
+Tags and other metadata can be included using the available command line options. See the [pino-logdna readme](https://github.com/logdna/pino-logdna#options) for a full list.
+
+<a id="pino-logflare"></a>
+### pino-logflare
+
+[pino-logflare](https://github.com/Logflare/pino-logflare) transport to send logs to a [Logflare](https://logflare.app) `source`.
+
+```sh
+$ node index.js | pino-logflare --key YOUR_KEY --source YOUR_SOURCE
+```
+
+<a id="pino-mq"></a>
+### pino-mq
+
+The `pino-mq` transport will take all messages received on `process.stdin` and send them over a message bus using JSON serialization.
+
+This useful for:
+
+* moving backpressure from application to broker
+* transforming messages pressure to another component
+
+```
+node app.js | pino-mq -u "amqp://guest:guest@localhost/" -q "pino-logs"
+```
+
+Alternatively a configuration file can be used:
+
+```
+node app.js | pino-mq -c pino-mq.json
+```
+
+A base configuration file can be initialized with:
+
+```
+pino-mq -g
+```
+
+For full documentation of command line switches and configuration see [the `pino-mq` readme](https://github.com/itavy/pino-mq#readme)
+
+<a id="pino-papertrail"></a>
+### pino-papertrail
+pino-papertrail is a transport that will forward logs to the [papertrail](https://papertrailapp.com) log service through an UDPv4 socket.
+
+Given an application `foo` that logs via pino, and a papertrail destination that collects logs on port UDP `12345` on address `bar.papertrailapp.com`, you would use `pino-papertrail`
+like so:
+
+```
+node yourapp.js | pino-papertrail --host bar.papertrailapp.com --port 12345 --appname foo
+```
+
+
+for full documentation of command line switches read [readme](https://github.com/ovhemert/pino-papertrail#readme)
+
+<a id="pino-pg"></a>
+### pino-pg
+[pino-pg](https://www.npmjs.com/package/pino-pg) stores logs into PostgreSQL.
+Full documentation in the [readme](https://github.com/Xstoudi/pino-pg).
+
+<a id="pino-mysql"></a>
+### pino-mysql
+
+[pino-mysql][pino-mysql] loads pino logs into [MySQL][MySQL] and [MariaDB][MariaDB].
+
+```sh
+$ node app.js | pino-mysql -c db-configuration.json
+```
+
+`pino-mysql` can extract and save log fields into corresponding database field
+and/or save the entire log stream as a [JSON Data Type][JSONDT].
+
+For full documentation and command line switches read the [readme][pino-mysql].
+
+[pino-mysql]: https://www.npmjs.com/package/pino-mysql
+[MySQL]: https://www.mysql.com/
+[MariaDB]: https://mariadb.org/
+[JSONDT]: https://dev.mysql.com/doc/refman/8.0/en/json.html
+
+<a id="pino-redis"></a>
+### pino-redis
+
+[pino-redis][pino-redis] loads pino logs into [Redis][Redis].
+
+```sh
+$ node app.js | pino-redis -U redis://username:password@localhost:6379
+```
+
+[pino-redis]: https://github.com/buianhthang/pino-redis
+[Redis]: https://redis.io/
+
+<a id="pino-sentry"></a>
+### pino-sentry
+
+[pino-sentry][pino-sentry] loads pino logs into [Sentry][Sentry].
+
+```sh
+$ node app.js | pino-sentry --dsn=https://******@sentry.io/12345
+```
+
+For full documentation of command line switches see the [pino-sentry readme](https://github.com/aandrewww/pino-sentry/blob/master/README.md)
+
+[pino-sentry]: https://www.npmjs.com/package/pino-sentry
+[Sentry]: https://sentry.io/
+
+
+<a id="pino-seq"></a>
+### pino-seq
+
+[pino-seq][pino-seq] supports both out-of-process and in-process log forwarding to [Seq][Seq].
+
+```sh
+$ node app.js | pino-seq --serverUrl http://localhost:5341 --apiKey 1234567890 --property applicationName=MyNodeApp
+```
+
+[pino-seq]: https://www.npmjs.com/package/pino-seq
+[Seq]: https://datalust.co/seq
+
+<a id="pino-socket"></a>
+### pino-socket
+
+[pino-socket][pino-socket] is a transport that will forward logs to a IPv4
+UDP or TCP socket.
+
+As an example, use `socat` to fake a listener:
+
+```sh
+$ socat -v udp4-recvfrom:6000,fork exec:'/bin/cat'
+```
+
+Then run an application that uses `pino` for logging:
+
+```sh
+$ node app.js | pino-socket -p 6000
+```
+
+Logs from the application should be observed on both consoles.
+
+[pino-socket]: https://www.npmjs.com/package/pino-socket
+
+#### Logstash
+
+The [pino-socket][pino-socket] module can also be used to upload logs to
+[Logstash][logstash] via:
+
+```
+$ node app.js | pino-socket -a 127.0.0.1 -p 5000 -m tcp
+```
+
+Assuming logstash is running on the same host and configured as
+follows:
+
+```
+input {
+  tcp {
+    port => 5000
+  }
+}
+
+filter {
+  json {
+    source => "message"
+  }
+}
+
+output {
+  elasticsearch {
+    hosts => "127.0.0.1:9200"
+  }
+}
+```
+
+See <https://www.elastic.co/guide/en/kibana/current/setup.html> to learn
+how to setup [Kibana][kibana].
+
+For Docker users, see
+https://github.com/deviantony/docker-elk to setup an ELK stack.
+
+<a id="pino-stackdriver"></a>
+### pino-stackdriver
+The [pino-stackdriver](https://www.npmjs.com/package/pino-stackdriver) module is a transport that will forward logs to the [Google Stackdriver](https://cloud.google.com/logging/) log service through it's API.
+
+Given an application `foo` that logs via pino, a stackdriver log project `bar` and credentials in the file `/credentials.json`, you would use `pino-stackdriver`
+like so:
+
+``` sh
+$ node foo | pino-stackdriver --project bar --credentials /credentials.json
+```
+
+For full documentation of command line switches read [readme](https://github.com/ovhemert/pino-stackdriver#readme)
+
+<a id="pino-syslog"></a>
+### pino-syslog
+
+[pino-syslog][pino-syslog] is a transforming transport that converts
+`pino` NDJSON logs to [RFC3164][rfc3164] compatible log messages. The `pino-syslog` module does not
+forward the logs anywhere, it merely re-writes the messages to `stdout`. But
+when used in combination with `pino-socket` the log messages can be relayed to a syslog server:
+
+```sh
+$ node app.js | pino-syslog | pino-socket -a syslog.example.com
+```
+
+Example output for the "hello world" log:
+
+```
+<134>Apr  1 16:44:58 MacBook-Pro-3 none[94473]: {"pid":94473,"hostname":"MacBook-Pro-3","level":30,"msg":"hello world","time":1459529098958}
+```
+
+[pino-syslog]: https://www.npmjs.com/package/pino-syslog
+[rfc3164]: https://tools.ietf.org/html/rfc3164
+[logstash]: https://www.elastic.co/products/logstash
+
+
+<a id="pino-websocket"></a>
+### pino-websocket
+
+[pino-websocket](https://www.npmjs.com/package/@abeai/pino-websocket) is a transport that will forward each log line to a websocket server.
+
+```sh
+$ node app.js | pino-websocket -a my-websocket-server.example.com -p 3004
+```
+
+For full documentation of command line switches read the [README](https://github.com/abeai/pino-websocket#readme).

node_modules/pino/docs/web.md

@@ -0,0 +1,229 @@
+# Web Frameworks
+
+Since HTTP logging is a primary use case, Pino has first class support for the Node.js
+web framework ecosystem.
+
+- [Web Frameworks](#web-frameworks)
+  - [Pino with Fastify](#pino-with-fastify)
+  - [Pino with Express](#pino-with-express)
+  - [Pino with Hapi](#pino-with-hapi)
+  - [Pino with Restify](#pino-with-restify)
+  - [Pino with Koa](#pino-with-koa)
+  - [Pino with Node core `http`](#pino-with-node-core-http)
+  - [Pino with Nest](#pino-with-nest)
+
+<a id="fastify"></a>
+## Pino with Fastify
+
+The Fastify web framework comes bundled with Pino by default, simply set Fastify's
+`logger` option to `true` and use `request.log` or `reply.log` for log messages that correspond
+to each individual request:
+
+```js
+const fastify = require('fastify')({
+  logger: true
+})
+fastify.get('/', async (request, reply) => {
+  request.log.info('something')
+  return { hello: 'world' }
+})
+```
+
+The `logger` option can also be set to an object, which will be passed through directly
+as the [`pino` options object](/docs/api.md#options-object).
+
+See the [fastify documentation](https://www.fastify.io/docs/latest/Logging/) for more information.
+
+<a id="express"></a>
+## Pino with Express
+
+```sh
+npm install pino-http
+```
+
+```js
+const app = require('express')()
+const pino = require('pino-http')()
+
+app.use(pino)
+
+app.get('/', function (req, res) {
+  req.log.info('something')
+  res.send('hello world')
+})
+
+app.listen(3000)
+```
+
+See the [pino-http readme](https://npm.im/pino-http) for more info.
+
+<a id="hapi"></a>
+## Pino with Hapi
+
+```sh
+npm install hapi-pino
+```
+
+```js
+'use strict'
+
+require('make-promises-safe')
+
+const Hapi = require('hapi')
+
+async function start () {
+  // Create a server with a host and port
+  const server = Hapi.server({
+    host: 'localhost',
+    port: 3000
+  })
+
+  // Add the route
+  server.route({
+    method: 'GET',
+    path: '/',
+    handler: async function (request, h) {
+      // request.log is HAPI standard way of logging
+      request.log(['a', 'b'], 'Request into hello world')
+
+      // a pino instance can also be used, which will be faster
+      request.logger.info('In handler %s', request.path)
+
+      return 'hello world'
+    }
+  })
+
+  await server.register({
+    plugin: require('.'),
+    options: {
+      prettyPrint: process.env.NODE_ENV !== 'production'
+    }
+  })
+
+  // also as a decorated API
+  server.logger().info('another way for accessing it')
+
+  // and through Hapi standard logging system
+  server.log(['subsystem'], 'third way for accessing it')
+
+  await server.start()
+
+  return server
+}
+
+start().catch((err) => {
+  console.log(err)
+  process.exit(1)
+})
+```
+
+See the [hapi-pino readme](https://npm.im/hapi-pino) for more info.
+
+<a id="restify"></a>
+## Pino with Restify
+
+```sh
+npm install restify-pino-logger
+```
+
+```js
+const server = require('restify').createServer({name: 'server'})
+const pino = require('restify-pino-logger')()
+
+server.use(pino)
+
+server.get('/', function (req, res) {
+  req.log.info('something')
+  res.send('hello world')
+})
+
+server.listen(3000)
+```
+
+See the [restify-pino-logger readme](https://npm.im/restify-pino-logger) for more info.
+
+<a id="koa"></a>
+## Pino with Koa
+
+```sh
+npm install koa-pino-logger
+```
+
+```js
+const Koa = require('koa')
+const app = new Koa()
+const pino = require('koa-pino-logger')()
+
+app.use(pino)
+
+app.use((ctx) => {
+  ctx.log.info('something else')
+  ctx.body = 'hello world'
+})
+
+app.listen(3000)
+```
+
+See the [koa-pino-logger readme](https://github.com/pinojs/koa-pino-logger) for more info.
+
+<a id="http"></a>
+## Pino with Node core `http`
+
+```sh
+npm install pino-http
+```
+
+```js
+const http = require('http')
+const server = http.createServer(handle)
+const logger = require('pino-http')()
+
+function handle (req, res) {
+  logger(req, res)
+  req.log.info('something else')
+  res.end('hello world')
+}
+
+server.listen(3000)
+```
+
+See the [pino-http readme](https://npm.im/pino-http) for more info.
+
+
+<a id="nest"></a>
+## Pino with Nest
+
+```sh
+npm install nestjs-pino
+```
+
+```ts
+import { NestFactory } from '@nestjs/core'
+import { Controller, Get, Module } from '@nestjs/common'
+import { LoggerModule, Logger } from 'nestjs-pino'
+
+@Controller()
+export class AppController {
+  constructor(private readonly logger: Logger) {}
+
+  @Get()
+  getHello() {
+    this.logger.log('something')
+    return `Hello world`
+  }
+}
+
+@Module({
+  controllers: [AppController],
+  imports: [LoggerModule.forRoot()]
+})
+class MyModule {}
+
+async function bootstrap() {
+  const app = await NestFactory.create(MyModule)
+  await app.listen(3000)
+}
+bootstrap()
+```
+
+See the [nestjs-pino readme](https://npm.im/nestjs-pino) for more info.

node_modules/pino/example.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const pino = require('./')()
+
+pino.info('hello world')
+pino.error('this is at error level')
+pino.info('the answer is %d', 42)
+pino.info({ obj: 42 }, 'hello world')
+pino.info({ obj: 42, b: 2 }, 'hello world')
+pino.info({ nested: { obj: 42 } }, 'nested')
+setImmediate(() => {
+  pino.info('after setImmediate')
+})
+pino.error(new Error('an error'))
+
+const child = pino.child({ a: 'property' })
+child.info('hello child!')
+
+const childsChild = child.child({ another: 'property' })
+childsChild.info('hello baby..')
+
+pino.debug('this should be mute')
+
+pino.level = 'trace'
+
+pino.debug('this is a debug statement')
+
+pino.child({ another: 'property' }).debug('this is a debug statement via child')
+pino.trace('this is a trace statement')
+
+pino.debug('this is a "debug" statement with "')
+
+pino.info(new Error('kaboom'))
+pino.info(null)
+
+pino.info(new Error('kaboom'), 'with', 'a', 'message')

node_modules/pino/lib/deprecations.js

@@ -0,0 +1,14 @@
+'use strict'
+
+const warning = require('process-warning')()
+module.exports = warning
+
+const warnName = 'PinoWarning'
+
+warning.create(warnName, 'PINODEP004', 'bindings.serializers is deprecated, use options.serializers option instead')
+
+warning.create(warnName, 'PINODEP005', 'bindings.formatters is deprecated, use options.formatters option instead')
+
+warning.create(warnName, 'PINODEP006', 'bindings.customLevels is deprecated, use options.customLevels option instead')
+
+warning.create(warnName, 'PINODEP007', 'bindings.level is deprecated, use options.level option instead')

node_modules/pino/lib/levels.js

@@ -0,0 +1,193 @@
+'use strict'
+/* eslint no-prototype-builtins: 0 */
+const flatstr = require('flatstr')
+const {
+  lsCacheSym,
+  levelValSym,
+  useOnlyCustomLevelsSym,
+  streamSym,
+  formattersSym,
+  hooksSym
+} = require('./symbols')
+const { noop, genLog } = require('./tools')
+
+const levels = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60
+}
+const levelMethods = {
+  fatal: (hook) => {
+    const logFatal = genLog(levels.fatal, hook)
+    return function (...args) {
+      const stream = this[streamSym]
+      logFatal.call(this, ...args)
+      if (typeof stream.flushSync === 'function') {
+        try {
+          stream.flushSync()
+        } catch (e) {
+          // https://github.com/pinojs/pino/pull/740#discussion_r346788313
+        }
+      }
+    }
+  },
+  error: (hook) => genLog(levels.error, hook),
+  warn: (hook) => genLog(levels.warn, hook),
+  info: (hook) => genLog(levels.info, hook),
+  debug: (hook) => genLog(levels.debug, hook),
+  trace: (hook) => genLog(levels.trace, hook)
+}
+
+const nums = Object.keys(levels).reduce((o, k) => {
+  o[levels[k]] = k
+  return o
+}, {})
+
+const initialLsCache = Object.keys(nums).reduce((o, k) => {
+  o[k] = flatstr('{"level":' + Number(k))
+  return o
+}, {})
+
+function genLsCache (instance) {
+  const formatter = instance[formattersSym].level
+  const { labels } = instance.levels
+  const cache = {}
+  for (const label in labels) {
+    const level = formatter(labels[label], Number(label))
+    cache[label] = JSON.stringify(level).slice(0, -1)
+  }
+  instance[lsCacheSym] = cache
+  return instance
+}
+
+function isStandardLevel (level, useOnlyCustomLevels) {
+  if (useOnlyCustomLevels) {
+    return false
+  }
+
+  switch (level) {
+    case 'fatal':
+    case 'error':
+    case 'warn':
+    case 'info':
+    case 'debug':
+    case 'trace':
+      return true
+    default:
+      return false
+  }
+}
+
+function setLevel (level) {
+  const { labels, values } = this.levels
+  if (typeof level === 'number') {
+    if (labels[level] === undefined) throw Error('unknown level value' + level)
+    level = labels[level]
+  }
+  if (values[level] === undefined) throw Error('unknown level ' + level)
+  const preLevelVal = this[levelValSym]
+  const levelVal = this[levelValSym] = values[level]
+  const useOnlyCustomLevelsVal = this[useOnlyCustomLevelsSym]
+  const hook = this[hooksSym].logMethod
+
+  for (const key in values) {
+    if (levelVal > values[key]) {
+      this[key] = noop
+      continue
+    }
+    this[key] = isStandardLevel(key, useOnlyCustomLevelsVal) ? levelMethods[key](hook) : genLog(values[key], hook)
+  }
+
+  this.emit(
+    'level-change',
+    level,
+    levelVal,
+    labels[preLevelVal],
+    preLevelVal
+  )
+}
+
+function getLevel (level) {
+  const { levels, levelVal } = this
+  // protection against potential loss of Pino scope from serializers (edge case with circular refs - https://github.com/pinojs/pino/issues/833)
+  return (levels && levels.labels) ? levels.labels[levelVal] : ''
+}
+
+function isLevelEnabled (logLevel) {
+  const { values } = this.levels
+  const logLevelVal = values[logLevel]
+  return logLevelVal !== undefined && (logLevelVal >= this[levelValSym])
+}
+
+function mappings (customLevels = null, useOnlyCustomLevels = false) {
+  const customNums = customLevels
+    /* eslint-disable */
+    ? Object.keys(customLevels).reduce((o, k) => {
+        o[customLevels[k]] = k
+        return o
+      }, {})
+    : null
+    /* eslint-enable */
+
+  const labels = Object.assign(
+    Object.create(Object.prototype, { Infinity: { value: 'silent' } }),
+    useOnlyCustomLevels ? null : nums,
+    customNums
+  )
+  const values = Object.assign(
+    Object.create(Object.prototype, { silent: { value: Infinity } }),
+    useOnlyCustomLevels ? null : levels,
+    customLevels
+  )
+  return { labels, values }
+}
+
+function assertDefaultLevelFound (defaultLevel, customLevels, useOnlyCustomLevels) {
+  if (typeof defaultLevel === 'number') {
+    const values = [].concat(
+      Object.keys(customLevels || {}).map(key => customLevels[key]),
+      useOnlyCustomLevels ? [] : Object.keys(nums).map(level => +level),
+      Infinity
+    )
+    if (!values.includes(defaultLevel)) {
+      throw Error(`default level:${defaultLevel} must be included in custom levels`)
+    }
+    return
+  }
+
+  const labels = Object.assign(
+    Object.create(Object.prototype, { silent: { value: Infinity } }),
+    useOnlyCustomLevels ? null : levels,
+    customLevels
+  )
+  if (!(defaultLevel in labels)) {
+    throw Error(`default level:${defaultLevel} must be included in custom levels`)
+  }
+}
+
+function assertNoLevelCollisions (levels, customLevels) {
+  const { labels, values } = levels
+  for (const k in customLevels) {
+    if (k in values) {
+      throw Error('levels cannot be overridden')
+    }
+    if (customLevels[k] in labels) {
+      throw Error('pre-existing level values cannot be used for new levels')
+    }
+  }
+}
+
+module.exports = {
+  initialLsCache,
+  genLsCache,
+  levelMethods,
+  getLevel,
+  setLevel,
+  isLevelEnabled,
+  mappings,
+  assertNoLevelCollisions,
+  assertDefaultLevelFound
+}

node_modules/pino/lib/meta.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const { version } = require('../package.json')
+
+module.exports = { version }

node_modules/pino/lib/proto.js

@@ -0,0 +1,233 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const { EventEmitter } = require('events')
+const SonicBoom = require('sonic-boom')
+const flatstr = require('flatstr')
+const warning = require('./deprecations')
+const {
+  lsCacheSym,
+  levelValSym,
+  setLevelSym,
+  getLevelSym,
+  chindingsSym,
+  parsedChindingsSym,
+  mixinSym,
+  asJsonSym,
+  writeSym,
+  mixinMergeStrategySym,
+  timeSym,
+  timeSliceIndexSym,
+  streamSym,
+  serializersSym,
+  formattersSym,
+  useOnlyCustomLevelsSym,
+  needsMetadataGsym,
+  redactFmtSym,
+  stringifySym,
+  formatOptsSym,
+  stringifiersSym
+} = require('./symbols')
+const {
+  getLevel,
+  setLevel,
+  isLevelEnabled,
+  mappings,
+  initialLsCache,
+  genLsCache,
+  assertNoLevelCollisions
+} = require('./levels')
+const {
+  asChindings,
+  asJson,
+  buildFormatters,
+  stringify
+} = require('./tools')
+const {
+  version
+} = require('./meta')
+const redaction = require('./redaction')
+
+// note: use of class is satirical
+// https://github.com/pinojs/pino/pull/433#pullrequestreview-127703127
+const constructor = class Pino {}
+const prototype = {
+  constructor,
+  child,
+  bindings,
+  setBindings,
+  flush,
+  isLevelEnabled,
+  version,
+  get level () { return this[getLevelSym]() },
+  set level (lvl) { this[setLevelSym](lvl) },
+  get levelVal () { return this[levelValSym] },
+  set levelVal (n) { throw Error('levelVal is read-only') },
+  [lsCacheSym]: initialLsCache,
+  [writeSym]: write,
+  [asJsonSym]: asJson,
+  [getLevelSym]: getLevel,
+  [setLevelSym]: setLevel
+}
+
+Object.setPrototypeOf(prototype, EventEmitter.prototype)
+
+// exporting and consuming the prototype object using factory pattern fixes scoping issues with getters when serializing
+module.exports = function () {
+  return Object.create(prototype)
+}
+
+const resetChildingsFormatter = bindings => bindings
+function child (bindings, options) {
+  if (!bindings) {
+    throw Error('missing bindings for child Pino')
+  }
+  options = options || {} // default options to empty object
+  const serializers = this[serializersSym]
+  const formatters = this[formattersSym]
+  const instance = Object.create(this)
+
+  if (bindings.hasOwnProperty('serializers') === true) {
+    warning.emit('PINODEP004')
+    options.serializers = bindings.serializers
+  }
+  if (bindings.hasOwnProperty('formatters') === true) {
+    warning.emit('PINODEP005')
+    options.formatters = bindings.formatters
+  }
+  if (bindings.hasOwnProperty('customLevels') === true) {
+    warning.emit('PINODEP006')
+    options.customLevels = bindings.customLevels
+  }
+  if (bindings.hasOwnProperty('level') === true) {
+    warning.emit('PINODEP007')
+    options.level = bindings.level
+  }
+  if (options.hasOwnProperty('serializers') === true) {
+    instance[serializersSym] = Object.create(null)
+
+    for (const k in serializers) {
+      instance[serializersSym][k] = serializers[k]
+    }
+    const parentSymbols = Object.getOwnPropertySymbols(serializers)
+    /* eslint no-var: off */
+    for (var i = 0; i < parentSymbols.length; i++) {
+      const ks = parentSymbols[i]
+      instance[serializersSym][ks] = serializers[ks]
+    }
+
+    for (const bk in options.serializers) {
+      instance[serializersSym][bk] = options.serializers[bk]
+    }
+    const bindingsSymbols = Object.getOwnPropertySymbols(options.serializers)
+    for (var bi = 0; bi < bindingsSymbols.length; bi++) {
+      const bks = bindingsSymbols[bi]
+      instance[serializersSym][bks] = options.serializers[bks]
+    }
+  } else instance[serializersSym] = serializers
+  if (options.hasOwnProperty('formatters')) {
+    const { level, bindings: chindings, log } = options.formatters
+    instance[formattersSym] = buildFormatters(
+      level || formatters.level,
+      chindings || resetChildingsFormatter,
+      log || formatters.log
+    )
+  } else {
+    instance[formattersSym] = buildFormatters(
+      formatters.level,
+      resetChildingsFormatter,
+      formatters.log
+    )
+  }
+  if (options.hasOwnProperty('customLevels') === true) {
+    assertNoLevelCollisions(this.levels, options.customLevels)
+    instance.levels = mappings(options.customLevels, instance[useOnlyCustomLevelsSym])
+    genLsCache(instance)
+  }
+
+  // redact must place before asChindings and only replace if exist
+  if ((typeof options.redact === 'object' && options.redact !== null) || Array.isArray(options.redact)) {
+    instance.redact = options.redact // replace redact directly
+    const stringifiers = redaction(instance.redact, stringify)
+    const formatOpts = { stringify: stringifiers[redactFmtSym] }
+    instance[stringifySym] = stringify
+    instance[stringifiersSym] = stringifiers
+    instance[formatOptsSym] = formatOpts
+  }
+
+  instance[chindingsSym] = asChindings(instance, bindings)
+  const childLevel = options.level || this.level
+  instance[setLevelSym](childLevel)
+
+  return instance
+}
+
+function bindings () {
+  const chindings = this[chindingsSym]
+  const chindingsJson = `{${chindings.substr(1)}}` // at least contains ,"pid":7068,"hostname":"myMac"
+  const bindingsFromJson = JSON.parse(chindingsJson)
+  delete bindingsFromJson.pid
+  delete bindingsFromJson.hostname
+  return bindingsFromJson
+}
+
+function setBindings (newBindings) {
+  const chindings = asChindings(this, newBindings)
+  this[chindingsSym] = chindings
+  delete this[parsedChindingsSym]
+}
+
+/**
+ * Default strategy for creating `mergeObject` from arguments and the result from `mixin()`.
+ * Fields from `mergeObject` have higher priority in this strategy.
+ *
+ * @param {Object} mergeObject The object a user has supplied to the logging function.
+ * @param {Object} mixinObject The result of the `mixin` method.
+ * @return {Object}
+ */
+function defaultMixinMergeStrategy (mergeObject, mixinObject) {
+  return Object.assign(mixinObject, mergeObject)
+}
+
+function write (_obj, msg, num) {
+  const t = this[timeSym]()
+  const mixin = this[mixinSym]
+  const mixinMergeStrategy = this[mixinMergeStrategySym] || defaultMixinMergeStrategy
+  const objError = _obj instanceof Error
+  let obj
+
+  if (_obj === undefined || _obj === null) {
+    obj = mixin ? mixin({}) : {}
+  } else {
+    obj = mixinMergeStrategy(_obj, mixin ? mixin(_obj) : {})
+    if (!msg && objError) {
+      msg = _obj.message
+    }
+
+    if (objError) {
+      obj.stack = _obj.stack
+      if (!obj.type) {
+        obj.type = 'Error'
+      }
+    }
+  }
+
+  const s = this[asJsonSym](obj, msg, num, t)
+
+  const stream = this[streamSym]
+  if (stream[needsMetadataGsym] === true) {
+    stream.lastLevel = num
+    stream.lastObj = obj
+    stream.lastMsg = msg
+    stream.lastTime = t.slice(this[timeSliceIndexSym])
+    stream.lastLogger = this // for child loggers
+  }
+  if (stream instanceof SonicBoom) stream.write(s)
+  else stream.write(flatstr(s))
+}
+
+function flush () {
+  const stream = this[streamSym]
+  if ('flush' in stream) stream.flush()
+}

node_modules/pino/lib/redaction.js

@@ -0,0 +1,118 @@
+'use strict'
+
+const fastRedact = require('fast-redact')
+const { redactFmtSym, wildcardFirstSym } = require('./symbols')
+const { rx, validator } = fastRedact
+
+const validate = validator({
+  ERR_PATHS_MUST_BE_STRINGS: () => 'pino – redacted paths must be strings',
+  ERR_INVALID_PATH: (s) => `pino – redact paths array contains an invalid path (${s})`
+})
+
+const CENSOR = '[Redacted]'
+const strict = false // TODO should this be configurable?
+
+function redaction (opts, serialize) {
+  const { paths, censor } = handle(opts)
+
+  const shape = paths.reduce((o, str) => {
+    rx.lastIndex = 0
+    const first = rx.exec(str)
+    const next = rx.exec(str)
+
+    // ns is the top-level path segment, brackets + quoting removed.
+    let ns = first[1] !== undefined
+      ? first[1].replace(/^(?:"|'|`)(.*)(?:"|'|`)$/, '$1')
+      : first[0]
+
+    if (ns === '*') {
+      ns = wildcardFirstSym
+    }
+
+    // top level key:
+    if (next === null) {
+      o[ns] = null
+      return o
+    }
+
+    // path with at least two segments:
+    // if ns is already redacted at the top level, ignore lower level redactions
+    if (o[ns] === null) {
+      return o
+    }
+
+    const { index } = next
+    const nextPath = `${str.substr(index, str.length - 1)}`
+
+    o[ns] = o[ns] || []
+
+    // shape is a mix of paths beginning with literal values and wildcard
+    // paths [ "a.b.c", "*.b.z" ] should reduce to a shape of
+    // { "a": [ "b.c", "b.z" ], *: [ "b.z" ] }
+    // note: "b.z" is in both "a" and * arrays because "a" matches the wildcard.
+    // (* entry has wildcardFirstSym as key)
+    if (ns !== wildcardFirstSym && o[ns].length === 0) {
+      // first time ns's get all '*' redactions so far
+      o[ns].push(...(o[wildcardFirstSym] || []))
+    }
+
+    if (ns === wildcardFirstSym) {
+      // new * path gets added to all previously registered literal ns's.
+      Object.keys(o).forEach(function (k) {
+        if (o[k]) {
+          o[k].push(nextPath)
+        }
+      })
+    }
+
+    o[ns].push(nextPath)
+    return o
+  }, {})
+
+  // the redactor assigned to the format symbol key
+  // provides top level redaction for instances where
+  // an object is interpolated into the msg string
+  const result = {
+    [redactFmtSym]: fastRedact({ paths, censor, serialize, strict })
+  }
+
+  const topCensor = (...args) => {
+    return typeof censor === 'function' ? serialize(censor(...args)) : serialize(censor)
+  }
+
+  return [...Object.keys(shape), ...Object.getOwnPropertySymbols(shape)].reduce((o, k) => {
+    // top level key:
+    if (shape[k] === null) {
+      o[k] = (value) => topCensor(value, [k])
+    } else {
+      const wrappedCensor = typeof censor === 'function'
+        ? (value, path) => {
+            return censor(value, [k, ...path])
+          }
+        : censor
+      o[k] = fastRedact({
+        paths: shape[k],
+        censor: wrappedCensor,
+        serialize,
+        strict
+      })
+    }
+    return o
+  }, result)
+}
+
+function handle (opts) {
+  if (Array.isArray(opts)) {
+    opts = { paths: opts, censor: CENSOR }
+    validate(opts)
+    return opts
+  }
+  let { paths, censor = CENSOR, remove } = opts
+  if (Array.isArray(paths) === false) { throw Error('pino – redact must contain an array of strings') }
+  if (remove === true) censor = undefined
+  validate({ paths, censor })
+
+  return { paths, censor }
+}
+
+module.exports = redaction

node_modules/pino/lib/symbols.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const setLevelSym = Symbol('pino.setLevel')
+const getLevelSym = Symbol('pino.getLevel')
+const levelValSym = Symbol('pino.levelVal')
+const useLevelLabelsSym = Symbol('pino.useLevelLabels')
+const useOnlyCustomLevelsSym = Symbol('pino.useOnlyCustomLevels')
+const mixinSym = Symbol('pino.mixin')
+
+const lsCacheSym = Symbol('pino.lsCache')
+const chindingsSym = Symbol('pino.chindings')
+const parsedChindingsSym = Symbol('pino.parsedChindings')
+
+const asJsonSym = Symbol('pino.asJson')
+const writeSym = Symbol('pino.write')
+const redactFmtSym = Symbol('pino.redactFmt')
+
+const timeSym = Symbol('pino.time')
+const timeSliceIndexSym = Symbol('pino.timeSliceIndex')
+const streamSym = Symbol('pino.stream')
+const stringifySym = Symbol('pino.stringify')
+const stringifiersSym = Symbol('pino.stringifiers')
+const endSym = Symbol('pino.end')
+const formatOptsSym = Symbol('pino.formatOpts')
+const messageKeySym = Symbol('pino.messageKey')
+const nestedKeySym = Symbol('pino.nestedKey')
+const mixinMergeStrategySym = Symbol('pino.mixinMergeStrategy')
+
+const wildcardFirstSym = Symbol('pino.wildcardFirst')
+
+// public symbols, no need to use the same pino
+// version for these
+const serializersSym = Symbol.for('pino.serializers')
+const formattersSym = Symbol.for('pino.formatters')
+const hooksSym = Symbol.for('pino.hooks')
+const needsMetadataGsym = Symbol.for('pino.metadata')
+
+module.exports = {
+  setLevelSym,
+  getLevelSym,
+  levelValSym,
+  useLevelLabelsSym,
+  mixinSym,
+  lsCacheSym,
+  chindingsSym,
+  parsedChindingsSym,
+  asJsonSym,
+  writeSym,
+  serializersSym,
+  redactFmtSym,
+  timeSym,
+  timeSliceIndexSym,
+  streamSym,
+  stringifySym,
+  stringifiersSym,
+  endSym,
+  formatOptsSym,
+  messageKeySym,
+  nestedKeySym,
+  wildcardFirstSym,
+  needsMetadataGsym,
+  useOnlyCustomLevelsSym,
+  formattersSym,
+  hooksSym,
+  mixinMergeStrategySym
+}

node_modules/pino/lib/time.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const nullTime = () => ''
+
+const epochTime = () => `,"time":${Date.now()}`
+
+const unixTime = () => `,"time":${Math.round(Date.now() / 1000.0)}`
+
+const isoTime = () => `,"time":"${new Date(Date.now()).toISOString()}"` // using Date.now() for testability
+
+module.exports = { nullTime, epochTime, unixTime, isoTime }

node_modules/pino/lib/tools.js

@@ -0,0 +1,437 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const format = require('quick-format-unescaped')
+const { mapHttpRequest, mapHttpResponse } = require('pino-std-serializers')
+const SonicBoom = require('sonic-boom')
+const stringifySafe = require('fast-safe-stringify')
+const {
+  lsCacheSym,
+  chindingsSym,
+  parsedChindingsSym,
+  writeSym,
+  serializersSym,
+  formatOptsSym,
+  endSym,
+  stringifiersSym,
+  stringifySym,
+  wildcardFirstSym,
+  needsMetadataGsym,
+  redactFmtSym,
+  streamSym,
+  nestedKeySym,
+  formattersSym,
+  messageKeySym
+} = require('./symbols')
+
+function noop () {}
+
+function genLog (level, hook) {
+  if (!hook) return LOG
+
+  return function hookWrappedLog (...args) {
+    hook.call(this, args, LOG, level)
+  }
+
+  function LOG (o, ...n) {
+    if (typeof o === 'object') {
+      let msg = o
+      if (o !== null) {
+        if (o.method && o.headers && o.socket) {
+          o = mapHttpRequest(o)
+        } else if (typeof o.setHeader === 'function') {
+          o = mapHttpResponse(o)
+        }
+      }
+      if (this[nestedKeySym]) o = { [this[nestedKeySym]]: o }
+      let formatParams
+      if (msg === null && n.length === 0) {
+        formatParams = [null]
+      } else {
+        msg = n.shift()
+        formatParams = n
+      }
+      this[writeSym](o, format(msg, formatParams, this[formatOptsSym]), level)
+    } else {
+      this[writeSym](null, format(o, n, this[formatOptsSym]), level)
+    }
+  }
+}
+
+// magically escape strings for json
+// relying on their charCodeAt
+// everything below 32 needs JSON.stringify()
+// 34 and 92 happens all the time, so we
+// have a fast case for them
+function asString (str) {
+  let result = ''
+  let last = 0
+  let found = false
+  let point = 255
+  const l = str.length
+  if (l > 100) {
+    return JSON.stringify(str)
+  }
+  for (var i = 0; i < l && point >= 32; i++) {
+    point = str.charCodeAt(i)
+    if (point === 34 || point === 92) {
+      result += str.slice(last, i) + '\\'
+      last = i
+      found = true
+    }
+  }
+  if (!found) {
+    result = str
+  } else {
+    result += str.slice(last)
+  }
+  return point < 32 ? JSON.stringify(str) : '"' + result + '"'
+}
+
+function asJson (obj, msg, num, time) {
+  const stringify = this[stringifySym]
+  const stringifiers = this[stringifiersSym]
+  const end = this[endSym]
+  const chindings = this[chindingsSym]
+  const serializers = this[serializersSym]
+  const formatters = this[formattersSym]
+  const messageKey = this[messageKeySym]
+  let data = this[lsCacheSym][num] + time
+
+  // we need the child bindings added to the output first so instance logged
+  // objects can take precedence when JSON.parse-ing the resulting log line
+  data = data + chindings
+
+  let value
+  const notHasOwnProperty = obj.hasOwnProperty === undefined
+  if (formatters.log) {
+    obj = formatters.log(obj)
+  }
+  if (msg !== undefined) {
+    obj[messageKey] = msg
+  }
+  const wildcardStringifier = stringifiers[wildcardFirstSym]
+  for (const key in obj) {
+    value = obj[key]
+    if ((notHasOwnProperty || obj.hasOwnProperty(key)) && value !== undefined) {
+      value = serializers[key] ? serializers[key](value) : value
+
+      const stringifier = stringifiers[key] || wildcardStringifier
+
+      switch (typeof value) {
+        case 'undefined':
+        case 'function':
+          continue
+        case 'number':
+          /* eslint no-fallthrough: "off" */
+          if (Number.isFinite(value) === false) {
+            value = null
+          }
+        // this case explicitly falls through to the next one
+        case 'boolean':
+          if (stringifier) value = stringifier(value)
+          break
+        case 'string':
+          value = (stringifier || asString)(value)
+          break
+        default:
+          value = (stringifier || stringify)(value)
+      }
+      if (value === undefined) continue
+      data += ',"' + key + '":' + value
+    }
+  }
+
+  return data + end
+}
+
+function asChindings (instance, bindings) {
+  let value
+  let data = instance[chindingsSym]
+  const stringify = instance[stringifySym]
+  const stringifiers = instance[stringifiersSym]
+  const wildcardStringifier = stringifiers[wildcardFirstSym]
+  const serializers = instance[serializersSym]
+  const formatter = instance[formattersSym].bindings
+  bindings = formatter(bindings)
+
+  for (const key in bindings) {
+    value = bindings[key]
+    const valid = key !== 'level' &&
+      key !== 'serializers' &&
+      key !== 'formatters' &&
+      key !== 'customLevels' &&
+      bindings.hasOwnProperty(key) &&
+      value !== undefined
+    if (valid === true) {
+      value = serializers[key] ? serializers[key](value) : value
+      value = (stringifiers[key] || wildcardStringifier || stringify)(value)
+      if (value === undefined) continue
+      data += ',"' + key + '":' + value
+    }
+  }
+  return data
+}
+
+function getPrettyStream (opts, prettifier, dest, instance) {
+  if (prettifier && typeof prettifier === 'function') {
+    prettifier = prettifier.bind(instance)
+    return prettifierMetaWrapper(prettifier(opts), dest, opts)
+  }
+  try {
+    const prettyFactory = require('pino-pretty').prettyFactory || require('pino-pretty')
+    prettyFactory.asMetaWrapper = prettifierMetaWrapper
+    return prettifierMetaWrapper(prettyFactory(opts), dest, opts)
+  } catch (e) {
+    if (e.message.startsWith("Cannot find module 'pino-pretty'")) {
+      throw Error('Missing `pino-pretty` module: `pino-pretty` must be installed separately')
+    };
+    throw e
+  }
+}
+
+function prettifierMetaWrapper (pretty, dest, opts) {
+  opts = Object.assign({ suppressFlushSyncWarning: false }, opts)
+  let warned = false
+  return {
+    [needsMetadataGsym]: true,
+    lastLevel: 0,
+    lastMsg: null,
+    lastObj: null,
+    lastLogger: null,
+    flushSync () {
+      if (opts.suppressFlushSyncWarning || warned) {
+        return
+      }
+      warned = true
+      setMetadataProps(dest, this)
+      dest.write(pretty(Object.assign({
+        level: 40, // warn
+        msg: 'pino.final with prettyPrint does not support flushing',
+        time: Date.now()
+      }, this.chindings())))
+    },
+    chindings () {
+      const lastLogger = this.lastLogger
+      let chindings = null
+
+      // protection against flushSync being called before logging
+      // anything
+      if (!lastLogger) {
+        return null
+      }
+
+      if (lastLogger.hasOwnProperty(parsedChindingsSym)) {
+        chindings = lastLogger[parsedChindingsSym]
+      } else {
+        chindings = JSON.parse('{' + lastLogger[chindingsSym].substr(1) + '}')
+        lastLogger[parsedChindingsSym] = chindings
+      }
+
+      return chindings
+    },
+    write (chunk) {
+      const lastLogger = this.lastLogger
+      const chindings = this.chindings()
+
+      let time = this.lastTime
+
+      if (time.match(/^\d+/)) {
+        time = parseInt(time)
+      } else {
+        time = time.slice(1, -1)
+      }
+
+      const lastObj = this.lastObj
+      const lastMsg = this.lastMsg
+      const errorProps = null
+
+      const formatters = lastLogger[formattersSym]
+      const formattedObj = formatters.log ? formatters.log(lastObj) : lastObj
+
+      const messageKey = lastLogger[messageKeySym]
+      if (lastMsg && formattedObj && !formattedObj.hasOwnProperty(messageKey)) {
+        formattedObj[messageKey] = lastMsg
+      }
+
+      const obj = Object.assign({
+        level: this.lastLevel,
+        time
+      }, formattedObj, errorProps)
+
+      const serializers = lastLogger[serializersSym]
+      const keys = Object.keys(serializers)
+
+      for (var i = 0; i < keys.length; i++) {
+        const key = keys[i]
+        if (obj[key] !== undefined) {
+          obj[key] = serializers[key](obj[key])
+        }
+      }
+
+      for (const key in chindings) {
+        if (!obj.hasOwnProperty(key)) {
+          obj[key] = chindings[key]
+        }
+      }
+
+      const stringifiers = lastLogger[stringifiersSym]
+      const redact = stringifiers[redactFmtSym]
+
+      const formatted = pretty(typeof redact === 'function' ? redact(obj) : obj)
+      if (formatted === undefined) return
+
+      setMetadataProps(dest, this)
+      dest.write(formatted)
+    }
+  }
+}
+
+function hasBeenTampered (stream) {
+  return stream.write !== stream.constructor.prototype.write
+}
+
+function buildSafeSonicBoom (opts) {
+  const stream = new SonicBoom(opts)
+  stream.on('error', filterBrokenPipe)
+  return stream
+
+  function filterBrokenPipe (err) {
+    // TODO verify on Windows
+    if (err.code === 'EPIPE') {
+      // If we get EPIPE, we should stop logging here
+      // however we have no control to the consumer of
+      // SonicBoom, so we just overwrite the write method
+      stream.write = noop
+      stream.end = noop
+      stream.flushSync = noop
+      stream.destroy = noop
+      return
+    }
+    stream.removeListener('error', filterBrokenPipe)
+    stream.emit('error', err)
+  }
+}
+
+function createArgsNormalizer (defaultOptions) {
+  return function normalizeArgs (instance, opts = {}, stream) {
+    // support stream as a string
+    if (typeof opts === 'string') {
+      stream = buildSafeSonicBoom({ dest: opts, sync: true })
+      opts = {}
+    } else if (typeof stream === 'string') {
+      stream = buildSafeSonicBoom({ dest: stream, sync: true })
+    } else if (opts instanceof SonicBoom || opts.writable || opts._writableState) {
+      stream = opts
+      opts = null
+    }
+    opts = Object.assign({}, defaultOptions, opts)
+    if ('extreme' in opts) {
+      throw Error('The extreme option has been removed, use pino.destination({ sync: false }) instead')
+    }
+    if ('onTerminated' in opts) {
+      throw Error('The onTerminated option has been removed, use pino.final instead')
+    }
+    if ('changeLevelName' in opts) {
+      process.emitWarning(
+        'The changeLevelName option is deprecated and will be removed in v7. Use levelKey instead.',
+        { code: 'changeLevelName_deprecation' }
+      )
+      opts.levelKey = opts.changeLevelName
+      delete opts.changeLevelName
+    }
+    const { enabled, prettyPrint, prettifier, messageKey } = opts
+    if (enabled === false) opts.level = 'silent'
+    stream = stream || process.stdout
+    if (stream === process.stdout && stream.fd >= 0 && !hasBeenTampered(stream)) {
+      stream = buildSafeSonicBoom({ fd: stream.fd, sync: true })
+    }
+    if (prettyPrint) {
+      const prettyOpts = Object.assign({ messageKey }, prettyPrint)
+      stream = getPrettyStream(prettyOpts, prettifier, stream, instance)
+    }
+    return { opts, stream }
+  }
+}
+
+function final (logger, handler) {
+  if (typeof logger === 'undefined' || typeof logger.child !== 'function') {
+    throw Error('expected a pino logger instance')
+  }
+  const hasHandler = (typeof handler !== 'undefined')
+  if (hasHandler && typeof handler !== 'function') {
+    throw Error('if supplied, the handler parameter should be a function')
+  }
+  const stream = logger[streamSym]
+  if (typeof stream.flushSync !== 'function') {
+    throw Error('final requires a stream that has a flushSync method, such as pino.destination')
+  }
+
+  const finalLogger = new Proxy(logger, {
+    get: (logger, key) => {
+      if (key in logger.levels.values) {
+        return (...args) => {
+          logger[key](...args)
+          stream.flushSync()
+        }
+      }
+      return logger[key]
+    }
+  })
+
+  if (!hasHandler) {
+    return finalLogger
+  }
+
+  return (err = null, ...args) => {
+    try {
+      stream.flushSync()
+    } catch (e) {
+      // it's too late to wait for the stream to be ready
+      // because this is a final tick scenario.
+      // in practice there shouldn't be a situation where it isn't
+      // however, swallow the error just in case (and for easier testing)
+    }
+    return handler(err, finalLogger, ...args)
+  }
+}
+
+function stringify (obj) {
+  try {
+    return JSON.stringify(obj)
+  } catch (_) {
+    return stringifySafe(obj)
+  }
+}
+
+function buildFormatters (level, bindings, log) {
+  return {
+    level,
+    bindings,
+    log
+  }
+}
+
+function setMetadataProps (dest, that) {
+  if (dest[needsMetadataGsym] === true) {
+    dest.lastLevel = that.lastLevel
+    dest.lastMsg = that.lastMsg
+    dest.lastObj = that.lastObj
+    dest.lastTime = that.lastTime
+    dest.lastLogger = that.lastLogger
+  }
+}
+
+module.exports = {
+  noop,
+  buildSafeSonicBoom,
+  getPrettyStream,
+  asChindings,
+  asJson,
+  genLog,
+  createArgsNormalizer,
+  final,
+  stringify,
+  buildFormatters
+}

node_modules/pino/node_modules/pino-std-serializers/.editorconfig

@@ -0,0 +1,13 @@
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+
+# [*.md]
+# trim_trailing_whitespace = false

node_modules/pino/node_modules/pino-std-serializers/.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

node_modules/pino/node_modules/pino-std-serializers/.github/workflows/ci.yml

@@ -0,0 +1,35 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  build-lint-test:
+    runs-on: [ubuntu-latest]
+
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x, 14.x, 15.x]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup Node
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{matrix.node-version}}
+      - name: Install Dependencies
+        run: npm install
+        env:
+          NODE_ENV: development
+      - name: Lint-CI
+        run: npm run lint-ci
+      - name: Test-CI
+        run: npm run test-ci
+
+  automerge:
+    needs: build-lint-test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: fastify/github-action-merge-dependabot@v1
+        if: ${{ github.actor == 'dependabot[bot]' && github.event_name == 'pull_request' }}
+        with:
+          github-token: ${{secrets.github_token}}

node_modules/pino/node_modules/pino-std-serializers/LICENSE

@@ -0,0 +1,7 @@
+Copyright Mateo Collina, David Mark Clements, James Sumners
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/pino/node_modules/pino-std-serializers/Readme.md

@@ -0,0 +1,107 @@
+# pino-std-serializers  [![CI](https://github.com/pinojs/pino-std-serializers/workflows/CI/badge.svg)](https://github.com/pinojs/pino-std-serializers/actions?query=workflow%3ACI)
+
+This module provides a set of standard object serializers for the
+[Pino](https://getpino.io) logger.
+
+## Serializers
+
+### `exports.err(error)`
+Serializes an `Error` like object. Returns an object:
+
+```js
+{
+  type: 'string', // The name of the object's constructor.
+  message: 'string', // The supplied error message.
+  stack: 'string', // The stack when the error was generated.
+  raw: Error  // Non-enumerable, i.e. will not be in the output, original
+              // Error object. This is available for subsequent serializers
+              // to use.
+}
+```
+
+Any other extra properties, e.g. `statusCode`, that have been attached to the
+object will also be present on the serialized object.
+
+### `exports.mapHttpResponse(response)`
+Used internally by Pino for general response logging. Returns an object:
+
+```js
+{
+  res: {}
+}
+```
+
+Where `res` is the `response` as serialized by the standard response serializer.
+
+### `exports.mapHttpRequest(request)`
+Used internall by Pino for general request logging. Returns an object:
+
+```js
+{
+  req: {}
+}
+```
+
+Where `req` is the `request` as serialized by the standard request serializer.
+
+### `exports.req(request)`
+The default `request` serializer. Returns and object:
+
+```js
+{
+  id: 'string', // Defaults to `undefined`, unless there is an `id` property 
+                // already attached to the `request` object or to the `request.info`
+                // object. Attach a synchronous function
+                // to the `request.id` that returns an identifier to have
+                // the value filled.
+  method: 'string',
+  url: 'string', // the request pathname (as per req.url in core HTTP)
+  headers: Object, // a reference to the `headers` object from the request
+                   // (as per req.headers in core HTTP)
+  remoteAddress: 'string',
+  remotePort: Number,
+  raw: Object // Non-enumerable, i.e. will not be in the output, original
+              // request object. This is available for subsequent serializers
+              // to use. In cases where the `request` input already has 
+              // a `raw` property this will replace the original `request.raw`
+              // property
+}
+```
+
+### `exports.res(response)`
+The default `response` serializer. Returns an object:
+
+```js
+{
+  statusCode: Number,
+  headers: Object, // The headers to be sent in the response.
+  raw: Object // Non-enumerable, i.e. will not be in the output, original
+              // response object. This is available for subsequent serializers
+              // to use.
+}
+```
+
+### `exports.wrapErrorSerializer(customSerializer)`
+A utility method for wrapping the default error serializer. This allows
+custom serializers to work with the already serialized object.
+
+The `customSerializer` accepts one parameter — the newly serialized error
+object — and returns the new (or updated) error object.
+
+### `exports.wrapRequestSerializer(customSerializer)`
+A utility method for wrapping the default request serializer. This allows
+custom serializers to work with the already serialized object.
+
+The `customSerializer` accepts one parameter — the newly serialized request
+object — and returns the new (or updated) request object.
+
+### `exports.wrapResponseSerializer(customSerializer)`
+A utility method for wrapping the default response serializer. This allows
+custom serializers to work with the already serialized object.
+
+The `customSerializer` accepts one parameter — the newly serialized response
+object — and returns the new (or updated) response object.
+
+## License
+
+MIT License

node_modules/pino/node_modules/pino-std-serializers/index.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const errSerializer = require('./lib/err')
+const reqSerializers = require('./lib/req')
+const resSerializers = require('./lib/res')
+
+module.exports = {
+  err: errSerializer,
+  mapHttpRequest: reqSerializers.mapHttpRequest,
+  mapHttpResponse: resSerializers.mapHttpResponse,
+  req: reqSerializers.reqSerializer,
+  res: resSerializers.resSerializer,
+
+  wrapErrorSerializer: function wrapErrorSerializer (customSerializer) {
+    if (customSerializer === errSerializer) return customSerializer
+    return function wrapErrSerializer (err) {
+      return customSerializer(errSerializer(err))
+    }
+  },
+
+  wrapRequestSerializer: function wrapRequestSerializer (customSerializer) {
+    if (customSerializer === reqSerializers.reqSerializer) return customSerializer
+    return function wrappedReqSerializer (req) {
+      return customSerializer(reqSerializers.reqSerializer(req))
+    }
+  },
+
+  wrapResponseSerializer: function wrapResponseSerializer (customSerializer) {
+    if (customSerializer === resSerializers.resSerializer) return customSerializer
+    return function wrappedResSerializer (res) {
+      return customSerializer(resSerializers.resSerializer(res))
+    }
+  }
+}

node_modules/pino/node_modules/pino-std-serializers/lib/err.js

@@ -0,0 +1,68 @@
+'use strict'
+
+module.exports = errSerializer
+
+const { toString } = Object.prototype
+const seen = Symbol('circular-ref-tag')
+const rawSymbol = Symbol('pino-raw-err-ref')
+const pinoErrProto = Object.create({}, {
+  type: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
+  message: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
+  stack: {
+    enumerable: true,
+    writable: true,
+    value: undefined
+  },
+  raw: {
+    enumerable: false,
+    get: function () {
+      return this[rawSymbol]
+    },
+    set: function (val) {
+      this[rawSymbol] = val
+    }
+  }
+})
+Object.defineProperty(pinoErrProto, rawSymbol, {
+  writable: true,
+  value: {}
+})
+
+function errSerializer (err) {
+  if (!(err instanceof Error)) {
+    return err
+  }
+
+  err[seen] = undefined // tag to prevent re-looking at this
+  const _err = Object.create(pinoErrProto)
+  _err.type = toString.call(err.constructor) === '[object Function]'
+    ? err.constructor.name
+    : err.name
+  _err.message = err.message
+  _err.stack = err.stack
+  for (const key in err) {
+    if (_err[key] === undefined) {
+      const val = err[key]
+      if (val instanceof Error) {
+        /* eslint-disable no-prototype-builtins */
+        if (!val.hasOwnProperty(seen)) {
+          _err[key] = errSerializer(val)
+        }
+      } else {
+        _err[key] = val
+      }
+    }
+  }
+
+  delete err[seen] // clean up tag in case err is serialized again later
+  _err.raw = err
+  return _err
+}

node_modules/pino/node_modules/pino-std-serializers/lib/req.js

@@ -0,0 +1,92 @@
+'use strict'
+
+module.exports = {
+  mapHttpRequest,
+  reqSerializer
+}
+
+const rawSymbol = Symbol('pino-raw-req-ref')
+const pinoReqProto = Object.create({}, {
+  id: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  method: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  url: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  query: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  params: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  headers: {
+    enumerable: true,
+    writable: true,
+    value: {}
+  },
+  remoteAddress: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  remotePort: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  raw: {
+    enumerable: false,
+    get: function () {
+      return this[rawSymbol]
+    },
+    set: function (val) {
+      this[rawSymbol] = val
+    }
+  }
+})
+Object.defineProperty(pinoReqProto, rawSymbol, {
+  writable: true,
+  value: {}
+})
+
+function reqSerializer (req) {
+  // req.info is for hapi compat.
+  const connection = req.info || req.socket
+  const _req = Object.create(pinoReqProto)
+  _req.id = (typeof req.id === 'function' ? req.id() : (req.id || (req.info ? req.info.id : undefined)))
+  _req.method = req.method
+  // req.originalUrl is for expressjs compat.
+  if (req.originalUrl) {
+    _req.url = req.originalUrl
+    _req.query = req.query
+    _req.params = req.params
+  } else {
+    // req.url.path is  for hapi compat.
+    _req.url = req.path || (req.url ? (req.url.path || req.url) : undefined)
+  }
+  _req.headers = req.headers
+  _req.remoteAddress = connection && connection.remoteAddress
+  _req.remotePort = connection && connection.remotePort
+  // req.raw is  for hapi compat/equivalence
+  _req.raw = req.raw || req
+  return _req
+}
+
+function mapHttpRequest (req) {
+  return {
+    req: reqSerializer(req)
+  }
+}

node_modules/pino/node_modules/pino-std-serializers/lib/res.js

@@ -0,0 +1,47 @@
+'use strict'
+
+module.exports = {
+  mapHttpResponse,
+  resSerializer
+}
+
+const rawSymbol = Symbol('pino-raw-res-ref')
+const pinoResProto = Object.create({}, {
+  statusCode: {
+    enumerable: true,
+    writable: true,
+    value: 0
+  },
+  headers: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  raw: {
+    enumerable: false,
+    get: function () {
+      return this[rawSymbol]
+    },
+    set: function (val) {
+      this[rawSymbol] = val
+    }
+  }
+})
+Object.defineProperty(pinoResProto, rawSymbol, {
+  writable: true,
+  value: {}
+})
+
+function resSerializer (res) {
+  const _res = Object.create(pinoResProto)
+  _res.statusCode = res.statusCode
+  _res.headers = res.getHeaders ? res.getHeaders() : res._headers
+  _res.raw = res
+  return _res
+}
+
+function mapHttpResponse (res) {
+  return {
+    res: resSerializer(res)
+  }
+}

node_modules/pino/node_modules/pino-std-serializers/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "pino-std-serializers",
+  "version": "3.2.0",
+  "description": "A collection of standard object serializers for Pino",
+  "main": "index.js",
+  "scripts": {
+    "lint": "standard | snazzy",
+    "lint-ci": "standard",
+    "test": "tap --no-cov 'test/**/*.test.js'",
+    "test-ci": "tap --cov --coverage-report=text 'test/**/*.test.js'"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/pinojs/pino-std-serializers.git"
+  },
+  "keywords": [
+    "pino",
+    "logging"
+  ],
+  "author": "James Sumners <james.sumners@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pinojs/pino-std-serializers/issues"
+  },
+  "homepage": "https://github.com/pinojs/pino-std-serializers#readme",
+  "precommit": [
+    "lint",
+    "test"
+  ],
+  "devDependencies": {
+    "pre-commit": "^1.2.2",
+    "snazzy": "^9.0.0",
+    "standard": "^16.0.0",
+    "tap": "^14.0.0"
+  }
+}

node_modules/pino/node_modules/pino-std-serializers/test/err.test.js

@@ -0,0 +1,147 @@
+'use strict'
+
+const test = require('tap').test
+const serializer = require('../lib/err')
+const wrapErrorSerializer = require('../').wrapErrorSerializer
+
+test('serializes Error objects', function (t) {
+  t.plan(3)
+  const serialized = serializer(Error('foo'))
+  t.is(serialized.type, 'Error')
+  t.is(serialized.message, 'foo')
+  t.match(serialized.stack, /err\.test\.js:/)
+})
+
+test('serializes Error objects with extra properties', function (t) {
+  t.plan(5)
+  const err = Error('foo')
+  err.statusCode = 500
+  const serialized = serializer(err)
+  t.is(serialized.type, 'Error')
+  t.is(serialized.message, 'foo')
+  t.ok(serialized.statusCode)
+  t.is(serialized.statusCode, 500)
+  t.match(serialized.stack, /err\.test\.js:/)
+})
+
+test('serializes Error objects with subclass "type"', function (t) {
+  t.plan(1)
+  class MyError extends Error {}
+  const err = new MyError('foo')
+  const serialized = serializer(err)
+  t.is(serialized.type, 'MyError')
+})
+
+test('serializes nested errors', function (t) {
+  t.plan(7)
+  const err = Error('foo')
+  err.inner = Error('bar')
+  const serialized = serializer(err)
+  t.is(serialized.type, 'Error')
+  t.is(serialized.message, 'foo')
+  t.match(serialized.stack, /err\.test\.js:/)
+  t.is(serialized.inner.type, 'Error')
+  t.is(serialized.inner.message, 'bar')
+  t.match(serialized.inner.stack, /Error: bar/)
+  t.match(serialized.inner.stack, /err\.test\.js:/)
+})
+
+test('prevents infinite recursion', function (t) {
+  t.plan(4)
+  const err = Error('foo')
+  err.inner = err
+  const serialized = serializer(err)
+  t.is(serialized.type, 'Error')
+  t.is(serialized.message, 'foo')
+  t.match(serialized.stack, /err\.test\.js:/)
+  t.notOk(serialized.inner)
+})
+
+test('cleans up infinite recursion tracking', function (t) {
+  t.plan(8)
+  const err = Error('foo')
+  const bar = Error('bar')
+  err.inner = bar
+  bar.inner = err
+
+  serializer(err)
+  const serialized = serializer(err)
+
+  t.is(serialized.type, 'Error')
+  t.is(serialized.message, 'foo')
+  t.match(serialized.stack, /err\.test\.js:/)
+  t.ok(serialized.inner)
+  t.is(serialized.inner.type, 'Error')
+  t.is(serialized.inner.message, 'bar')
+  t.match(serialized.inner.stack, /Error: bar/)
+  t.notOk(serialized.inner.inner)
+})
+
+test('err.raw is available', function (t) {
+  t.plan(1)
+  const err = Error('foo')
+  const serialized = serializer(err)
+  t.equal(serialized.raw, err)
+})
+
+test('redefined err.constructor doesnt crash serializer', function (t) {
+  t.plan(10)
+
+  function check (a, name) {
+    t.is(a.type, name)
+    t.is(a.message, 'foo')
+  }
+
+  const err1 = TypeError('foo')
+  err1.constructor = '10'
+
+  const err2 = TypeError('foo')
+  err2.constructor = undefined
+
+  const err3 = Error('foo')
+  err3.constructor = null
+
+  const err4 = Error('foo')
+  err4.constructor = 10
+
+  class MyError extends Error {}
+  const err5 = new MyError('foo')
+  err5.constructor = undefined
+
+  check(serializer(err1), 'TypeError')
+  check(serializer(err2), 'TypeError')
+  check(serializer(err3), 'Error')
+  check(serializer(err4), 'Error')
+  // We do not expect 'MyError' because err5.constructor has been blown away.
+  // `err5.name` is 'Error' from the base class prototype.
+  check(serializer(err5), 'Error')
+})
+
+test('pass through anything that is not an Error', function (t) {
+  t.plan(3)
+
+  function check (a) {
+    t.is(serializer(a), a)
+  }
+
+  check('foo')
+  check({ hello: 'world' })
+  check([1, 2])
+})
+
+test('can wrap err serializers', function (t) {
+  t.plan(5)
+  const err = Error('foo')
+  err.foo = 'foo'
+  const serializer = wrapErrorSerializer(function (err) {
+    delete err.foo
+    err.bar = 'bar'
+    return err
+  })
+  const serialized = serializer(err)
+  t.is(serialized.type, 'Error')
+  t.is(serialized.message, 'foo')
+  t.match(serialized.stack, /err\.test\.js:/)
+  t.notOk(serialized.foo)
+  t.is(serialized.bar, 'bar')
+})

node_modules/pino/node_modules/pino-std-serializers/test/req.test.js

@@ -0,0 +1,394 @@
+'use strict'
+
+const http = require('http')
+const test = require('tap').test
+const serializers = require('../lib/req')
+const wrapRequestSerializer = require('../').wrapRequestSerializer
+
+test('maps request', function (t) {
+  t.plan(2)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    const serialized = serializers.mapHttpRequest(req)
+    t.ok(serialized.req)
+    t.ok(serialized.req.method)
+    t.end()
+    res.end()
+  }
+})
+
+test('does not return excessively long object', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    const serialized = serializers.reqSerializer(req)
+    t.is(Object.keys(serialized).length, 6)
+    res.end()
+  }
+})
+
+test('req.raw is available', function (t) {
+  t.plan(2)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.foo = 'foo'
+    const serialized = serializers.reqSerializer(req)
+    t.ok(serialized.raw)
+    t.is(serialized.raw.foo, 'foo')
+    res.end()
+  }
+})
+
+test('req.raw will be obtained in from input request raw property if input request raw property is truthy', function (t) {
+  t.plan(2)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.raw = { req: { foo: 'foo' }, res: {} }
+    const serialized = serializers.reqSerializer(req)
+    t.ok(serialized.raw)
+    t.is(serialized.raw.req.foo, 'foo')
+    res.end()
+  }
+})
+
+test('req.id defaults to undefined', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.id, undefined)
+    res.end()
+  }
+})
+
+test('req.id has a non-function value', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    const serialized = serializers.reqSerializer(req)
+    t.is(typeof serialized.id === 'function', false)
+    res.end()
+  }
+})
+
+test('req.id will be obtained from input request info.id when input request id does not exist', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.info = { id: 'test' }
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.id, 'test')
+    res.end()
+  }
+})
+
+test('req.id has a non-function value with custom id function', function (t) {
+  t.plan(2)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.id = function () { return 42 }
+    const serialized = serializers.reqSerializer(req)
+    t.is(typeof serialized.id === 'function', false)
+    t.is(serialized.id, 42)
+    res.end()
+  }
+})
+
+test('req.url will be obtained from input request req.path when input request url is an object', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.path = '/test'
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.url, '/test')
+    res.end()
+  }
+})
+
+test('req.url will be obtained from input request url.path when input request url is an object', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.url = { path: '/test' }
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.url, '/test')
+    res.end()
+  }
+})
+
+test('req.url will be obtained from input request url when input request url is not an object', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.url = '/test'
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.url, '/test')
+    res.end()
+  }
+})
+
+test('req.url will be empty when input request path and url are not defined', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.url, '/')
+    res.end()
+  }
+})
+
+test('req.url will be obtained from input request originalUrl when available', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.originalUrl = '/test'
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.url, '/test')
+    res.end()
+  }
+})
+
+test('can wrap request serializers', function (t) {
+  t.plan(3)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  const serailizer = wrapRequestSerializer(function (req) {
+    t.ok(req.method)
+    t.is(req.method, 'GET')
+    delete req.method
+    return req
+  })
+
+  function handler (req, res) {
+    const serialized = serailizer(req)
+    t.notOk(serialized.method)
+    res.end()
+  }
+})
+
+test('req.remoteAddress will be obtained from request socket.remoteAddress as fallback', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.socket = { remoteAddress: 'http://localhost' }
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.remoteAddress, 'http://localhost')
+    res.end()
+  }
+})
+
+test('req.remoteAddress will be obtained from request info.remoteAddress if available', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.info = { remoteAddress: 'http://localhost' }
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.remoteAddress, 'http://localhost')
+    res.end()
+  }
+})
+
+test('req.remotePort will be obtained from request socket.remotePort as fallback', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.socket = { remotePort: 3000 }
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.remotePort, 3000)
+    res.end()
+  }
+})
+
+test('req.remotePort will be obtained from request info.remotePort if available', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.info = { remotePort: 3000 }
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.remotePort, 3000)
+    res.end()
+  }
+})
+
+test('req.query is available', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.originalUrl = '/test'
+    req.query = '/foo?bar=foobar&bar=foo'
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.query, '/foo?bar=foobar&bar=foo')
+    res.end()
+  }
+})
+
+test('req.params is available', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.originalUrl = '/test'
+    req.params = '/foo/bar'
+    const serialized = serializers.reqSerializer(req)
+    t.is(serialized.params, '/foo/bar')
+    res.end()
+  }
+})

node_modules/pino/node_modules/pino-std-serializers/test/res.test.js

@@ -0,0 +1,91 @@
+'use strict'
+
+/* eslint-disable no-prototype-builtins */
+
+const http = require('http')
+const test = require('tap').test
+const serializers = require('../lib/res')
+const wrapResponseSerializer = require('../').wrapResponseSerializer
+
+test('res.raw is not enumerable', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    const serialized = serializers.resSerializer(res)
+    t.is(serialized.propertyIsEnumerable('raw'), false)
+    res.end()
+  }
+})
+
+test('res.raw is available', function (t) {
+  t.plan(2)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    res.statusCode = 200
+    const serialized = serializers.resSerializer(res)
+    t.ok(serialized.raw)
+    t.is(serialized.raw.statusCode, 200)
+    res.end()
+  }
+})
+
+test('can wrap response serializers', function (t) {
+  t.plan(3)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  const serializer = wrapResponseSerializer(function (res) {
+    t.ok(res.statusCode)
+    t.is(res.statusCode, 200)
+    delete res.statusCode
+    return res
+  })
+
+  function handler (req, res) {
+    res.statusCode = 200
+    const serialized = serializer(res)
+    t.notOk(serialized.statusCode)
+    res.end()
+  }
+})
+
+test('res.headers is serialized', function (t) {
+  t.plan(1)
+
+  const server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    res.setHeader('x-custom', 'y')
+    const serialized = serializers.resSerializer(res)
+    t.is(serialized.headers['x-custom'], 'y')
+    res.end()
+  }
+})

node_modules/pino/node_modules/sonic-boom/.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+- package-ecosystem: github-actions
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: daily
+  open-pull-requests-limit: 10

node_modules/pino/node_modules/sonic-boom/.github/workflows/nodejs.yml

@@ -0,0 +1,44 @@
+name: Node.js CI
+
+on: [ push, pull_request ]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        node-version: [10.x, 12.x, 13.x, 14.x, 15.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v2.1.5
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: node --version
+    - run: npm --version
+    - run: npm install --ignore-scripts
+    - run: npm test
+      env:
+        CI: true
+
+  test-legacy:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        node-version: [11.x, 13.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v2.1.5
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: node --version
+    - run: npm --version
+    - run: npm install --ignore-scripts
+    - run: npm run test-only
+      env:
+        CI: true

node_modules/pino/node_modules/sonic-boom/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npm test

node_modules/pino/node_modules/sonic-boom/.taprc

@@ -0,0 +1,5 @@
+flow: false
+ts: false
+jsx: false
+timeout: 120
+check-coverage: false

node_modules/pino/node_modules/sonic-boom/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Matteo Collina
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/pino/node_modules/sonic-boom/README.md

@@ -0,0 +1,101 @@
+# sonic-boom  ![Node.js CI](https://github.com/mcollina/sonic-boom/workflows/Node.js%20CI/badge.svg)
+
+Extremely fast utf8-only stream implementation to write to files and
+file descriptors.
+
+This implementation is partial, but support backpressure and `.pipe()` in is here.
+However, it is 2-3x faster than Node Core `fs.createWriteStream()`:
+
+```
+benchSonic*1000: 1916.904ms
+benchSonicSync*1000: 8605.265ms
+benchSonic4k*1000: 1965.231ms
+benchSonicSync4k*1000: 1588.224ms
+benchCore*1000: 5851.959ms
+benchConsole*1000: 7605.713ms
+```
+
+Note that sync mode without buffering is _slower_ than a Node Core WritableStream, however
+this mode matches the expected behavior of `console.log()`.
+
+Note that if this is used to log to a windows terminal (`cmd.exe` or
+powershell), it is needed to run `chcp 65001` in the terminal to
+correctly display utf-8 characters, see
+[chcp](https://ss64.com/nt/chcp.html) for more details.
+
+## Install
+
+```
+npm i sonic-boom
+```
+
+## Example
+
+```js
+'use strict'
+
+const SonicBoom = require('sonic-boom')
+const sonic = new SonicBoom({ fd: process.stdout.fd }) // or { dest: '/path/to/destination' }
+
+for (let i = 0; i < 10; i++) {
+  sonic.write('hello sonic\n')
+}
+```
+
+## API
+
+### SonicBoom(opts)
+
+Creates a new instance of SonicBoom.
+
+The options are:
+
+* `fd`: a file descriptor, something that is returned by `fs.open` or
+   `fs.openSync`.
+* `dest`: a string that is a path to a file to be written to (mode `'a'`).
+* `minLength`: the minimum lenght of the internal buffer that is
+  required to be full before flushing.
+* `sync`: perform writes synchronously (similar to `console.log`).
+
+For `sync:false`  a `SonicBoom` instance will emit the `'ready'` event when a file descriptor is available. 
+For `sync:true` this is not relevant because the `'ready'` event will be fired when the `SonicBoom` instance is created, before it can be subscribed to. 
+   
+
+### SonicBoom#write(string)
+
+Writes the string to the file.
+It will return false to signal the producer to slow down.
+
+### SonicBoom#flush()
+
+Writes the current buffer to the file if a write was not in progress.
+Do nothing if `minLength` is zero or if it is already writing.
+
+### SonicBoom#reopen([file])
+
+Reopen the file in place, useful for log rotation.
+
+Example:
+
+```js
+const stream = new SonicBoom('./my.log')
+process.on('SIGUSR2', function () {
+  stream.reopen()
+})
+```
+
+### SonicBoom#flushSync()
+
+Flushes the buffered data synchronously. This is a costly operation.
+
+### SonicBoom#end()
+
+Closes the stream, the data will be flushed down asynchronously
+
+### SonicBoom#destroy()
+
+Closes the stream immediately, the data is not flushed.
+
+## License
+
+MIT

node_modules/pino/node_modules/sonic-boom/bench.js

@@ -0,0 +1,67 @@
+'use strict'
+
+const bench = require('fastbench')
+const SonicBoom = require('./')
+const Console = require('console').Console
+const fs = require('fs')
+
+const core = fs.createWriteStream('/dev/null')
+const fd = fs.openSync('/dev/null', 'w')
+const sonic = new SonicBoom({ fd })
+const sonic4k = new SonicBoom({ fd, minLength: 4096 })
+const sonicSync = new SonicBoom({ fd, sync: true })
+const sonicSync4k = new SonicBoom({ fd, minLength: 4096, sync: true })
+const dummyConsole = new Console(fs.createWriteStream('/dev/null'))
+
+const MAX = 10000
+
+let str = ''
+
+for (let i = 0; i < 10; i++) {
+  str += 'hello'
+}
+
+setTimeout(doBench, 100)
+
+const run = bench([
+  function benchSonic (cb) {
+    sonic.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      sonic.write(str)
+    }
+  },
+  function benchSonicSync (cb) {
+    sonicSync.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      sonicSync.write(str)
+    }
+  },
+  function benchSonic4k (cb) {
+    sonic4k.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      sonic4k.write(str)
+    }
+  },
+  function benchSonicSync4k (cb) {
+    sonicSync4k.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      sonicSync4k.write(str)
+    }
+  },
+  function benchCore (cb) {
+    core.once('drain', cb)
+    for (let i = 0; i < MAX; i++) {
+      core.write(str)
+    }
+  },
+  function benchConsole (cb) {
+    for (let i = 0; i < MAX; i++) {
+      dummyConsole.log(str)
+    }
+    setImmediate(cb)
+  }
+], 1000)
+
+function doBench () {
+  run(run)
+}

node_modules/pino/node_modules/sonic-boom/check.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const SonicBoom = require('.')
+const sonic = new SonicBoom({ fd: process.stdout.fd })
+
+let count = 0
+function scheduleWrites () {
+  for (let i = 0; i < 1000; i++) {
+    sonic.write('hello sonic\n')
+    console.log('hello console')
+  }
+
+  if (++count < 10) {
+    setTimeout(scheduleWrites, 100)
+  }
+}
+
+scheduleWrites()

node_modules/pino/node_modules/sonic-boom/example.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const SonicBoom = require('.')
+const sonic = new SonicBoom({ fd: process.stdout.fd }) // or 'destination'
+
+for (let i = 0; i < 10; i++) {
+  sonic.write('hello sonic\n')
+}

node_modules/pino/node_modules/sonic-boom/fixtures/firehose.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const SonicBoom = require('..')
+
+const out = new SonicBoom({ fd: process.stdout.fd })
+const str = Buffer.alloc(1000).fill('a').toString()
+
+let i = 0
+
+function write () {
+  if (i++ === 10) {
+    return
+  }
+
+  if (out.write(str)) {
+    write()
+  } else {
+    out.once('drain', write)
+  }
+}
+
+write()

node_modules/pino/node_modules/sonic-boom/index.js

@@ -0,0 +1,380 @@
+'use strict'
+
+const fs = require('fs')
+const EventEmitter = require('events')
+const flatstr = require('flatstr')
+const inherits = require('util').inherits
+
+const BUSY_WRITE_TIMEOUT = 100
+
+const sleep = require('atomic-sleep')
+
+// 16 MB - magic number
+// This constant ensures that SonicBoom only needs
+// 32 MB of free memory to run. In case of having 1GB+
+// of data to write, this prevents an out of memory
+// condition.
+const MAX_WRITE = 16 * 1024 * 1024
+
+function openFile (file, sonic) {
+  sonic._opening = true
+  sonic._writing = true
+  sonic._asyncDrainScheduled = false
+
+  // NOTE: 'error' and 'ready' events emitted below only relevant when sonic.sync===false
+  // for sync mode, there is no way to add a listener that will receive these
+
+  function fileOpened (err, fd) {
+    if (err) {
+      sonic._reopening = false
+      sonic._writing = false
+      sonic._opening = false
+
+      if (sonic.sync) {
+        process.nextTick(() => {
+          if (sonic.listenerCount('error') > 0) {
+            sonic.emit('error', err)
+          }
+        })
+      } else {
+        sonic.emit('error', err)
+      }
+      return
+    }
+
+    sonic.fd = fd
+    sonic.file = file
+    sonic._reopening = false
+    sonic._opening = false
+    sonic._writing = false
+
+    if (sonic.sync) {
+      process.nextTick(() => sonic.emit('ready'))
+    } else {
+      sonic.emit('ready')
+    }
+
+    if (sonic._reopening) {
+      return
+    }
+
+    // start
+    const len = sonic._buf.length
+    if (len > 0 && len > sonic.minLength && !sonic.destroyed) {
+      actualWrite(sonic)
+    }
+  }
+
+  if (sonic.sync) {
+    try {
+      const fd = fs.openSync(file, 'a')
+      fileOpened(null, fd)
+    } catch (err) {
+      fileOpened(err)
+      throw err
+    }
+  } else {
+    fs.open(file, 'a', fileOpened)
+  }
+}
+
+function SonicBoom (opts) {
+  if (!(this instanceof SonicBoom)) {
+    return new SonicBoom(opts)
+  }
+
+  let { fd, dest, minLength, sync } = opts || {}
+
+  fd = fd || dest
+
+  this._buf = ''
+  this.fd = -1
+  this._writing = false
+  this._writingBuf = ''
+  this._ending = false
+  this._reopening = false
+  this._asyncDrainScheduled = false
+  this.file = null
+  this.destroyed = false
+  this.sync = sync || false
+
+  this.minLength = minLength || 0
+
+  if (typeof fd === 'number') {
+    this.fd = fd
+    process.nextTick(() => this.emit('ready'))
+  } else if (typeof fd === 'string') {
+    openFile(fd, this)
+  } else {
+    throw new Error('SonicBoom supports only file descriptors and files')
+  }
+
+  this.release = (err, n) => {
+    if (err) {
+      if (err.code === 'EAGAIN') {
+        if (this.sync) {
+          // This error code should not happen in sync mode, because it is
+          // not using the underlining operating system asynchronous functions.
+          // However it happens, and so we handle it.
+          // Ref: https://github.com/pinojs/pino/issues/783
+          try {
+            sleep(BUSY_WRITE_TIMEOUT)
+            this.release(undefined, 0)
+          } catch (err) {
+            this.release(err)
+          }
+        } else {
+          // Let's give the destination some time to process the chunk.
+          setTimeout(() => {
+            fs.write(this.fd, this._writingBuf, 'utf8', this.release)
+          }, BUSY_WRITE_TIMEOUT)
+        }
+      } else {
+        // The error maybe recoverable later, so just put data back to this._buf
+        this._buf = this._writingBuf + this._buf
+        this._writingBuf = ''
+        this._writing = false
+
+        this.emit('error', err)
+      }
+      return
+    }
+
+    if (this._writingBuf.length !== n) {
+      this._writingBuf = this._writingBuf.slice(n)
+      if (this.sync) {
+        try {
+          do {
+            n = fs.writeSync(this.fd, this._writingBuf, 'utf8')
+            this._writingBuf = this._writingBuf.slice(n)
+          } while (this._writingBuf.length !== 0)
+        } catch (err) {
+          this.release(err)
+          return
+        }
+      } else {
+        fs.write(this.fd, this._writingBuf, 'utf8', this.release)
+        return
+      }
+    }
+
+    this._writingBuf = ''
+
+    if (this.destroyed) {
+      return
+    }
+
+    const len = this._buf.length
+    if (this._reopening) {
+      this._writing = false
+      this._reopening = false
+      this.reopen()
+    } else if (len > 0 && len > this.minLength) {
+      actualWrite(this)
+    } else if (this._ending) {
+      if (len > 0) {
+        actualWrite(this)
+      } else {
+        this._writing = false
+        actualClose(this)
+      }
+    } else {
+      this._writing = false
+      if (this.sync) {
+        if (!this._asyncDrainScheduled) {
+          this._asyncDrainScheduled = true
+          process.nextTick(emitDrain, this)
+        }
+      } else {
+        this.emit('drain')
+      }
+    }
+  }
+
+  this.on('newListener', function (name) {
+    if (name === 'drain') {
+      this._asyncDrainScheduled = false
+    }
+  })
+}
+
+function emitDrain (sonic) {
+  const hasListeners = sonic.listenerCount('drain') > 0
+  if (!hasListeners) return
+  sonic._asyncDrainScheduled = false
+  sonic.emit('drain')
+}
+
+inherits(SonicBoom, EventEmitter)
+
+SonicBoom.prototype.write = function (data) {
+  if (this.destroyed) {
+    throw new Error('SonicBoom destroyed')
+  }
+
+  this._buf += data
+  const len = this._buf.length
+  if (!this._writing && len > this.minLength) {
+    actualWrite(this)
+  }
+  return len < 16384
+}
+
+SonicBoom.prototype.flush = function () {
+  if (this.destroyed) {
+    throw new Error('SonicBoom destroyed')
+  }
+
+  if (this._writing || this.minLength <= 0) {
+    return
+  }
+
+  actualWrite(this)
+}
+
+SonicBoom.prototype.reopen = function (file) {
+  if (this.destroyed) {
+    throw new Error('SonicBoom destroyed')
+  }
+
+  if (this._opening) {
+    this.once('ready', () => {
+      this.reopen(file)
+    })
+    return
+  }
+
+  if (this._ending) {
+    return
+  }
+
+  if (!this.file) {
+    throw new Error('Unable to reopen a file descriptor, you must pass a file to SonicBoom')
+  }
+
+  this._reopening = true
+
+  if (this._writing) {
+    return
+  }
+
+  const fd = this.fd
+  this.once('ready', () => {
+    if (fd !== this.fd) {
+      fs.close(fd, (err) => {
+        if (err) {
+          return this.emit('error', err)
+        }
+      })
+    }
+  })
+
+  openFile(file || this.file, this)
+}
+
+SonicBoom.prototype.end = function () {
+  if (this.destroyed) {
+    throw new Error('SonicBoom destroyed')
+  }
+
+  if (this._opening) {
+    this.once('ready', () => {
+      this.end()
+    })
+    return
+  }
+
+  if (this._ending) {
+    return
+  }
+
+  this._ending = true
+
+  if (!this._writing && this._buf.length > 0 && this.fd >= 0) {
+    actualWrite(this)
+    return
+  }
+
+  if (this._writing) {
+    return
+  }
+
+  actualClose(this)
+}
+
+SonicBoom.prototype.flushSync = function () {
+  if (this.destroyed) {
+    throw new Error('SonicBoom destroyed')
+  }
+
+  if (this.fd < 0) {
+    throw new Error('sonic boom is not ready yet')
+  }
+
+  while (this._buf.length > 0) {
+    try {
+      fs.writeSync(this.fd, this._buf, 'utf8')
+      this._buf = ''
+    } catch (err) {
+      if (err.code !== 'EAGAIN') {
+        throw err
+      }
+
+      sleep(BUSY_WRITE_TIMEOUT)
+    }
+  }
+}
+
+SonicBoom.prototype.destroy = function () {
+  if (this.destroyed) {
+    return
+  }
+  actualClose(this)
+}
+
+function actualWrite (sonic) {
+  sonic._writing = true
+  let buf = sonic._buf
+  const release = sonic.release
+  if (buf.length > MAX_WRITE) {
+    buf = buf.slice(0, MAX_WRITE)
+    sonic._buf = sonic._buf.slice(MAX_WRITE)
+  } else {
+    sonic._buf = ''
+  }
+  flatstr(buf)
+  sonic._writingBuf = buf
+  if (sonic.sync) {
+    try {
+      const written = fs.writeSync(sonic.fd, buf, 'utf8')
+      release(null, written)
+    } catch (err) {
+      release(err)
+    }
+  } else {
+    fs.write(sonic.fd, buf, 'utf8', release)
+  }
+}
+
+function actualClose (sonic) {
+  if (sonic.fd === -1) {
+    sonic.once('ready', actualClose.bind(null, sonic))
+    return
+  }
+  // TODO write a test to check if we are not leaking fds
+  fs.close(sonic.fd, (err) => {
+    if (err) {
+      sonic.emit('error', err)
+      return
+    }
+
+    if (sonic._ending && !sonic._writing) {
+      sonic.emit('finish')
+    }
+    sonic.emit('close')
+  })
+  sonic.destroyed = true
+  sonic._buf = ''
+}
+
+module.exports = SonicBoom

node_modules/pino/node_modules/sonic-boom/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "sonic-boom",
+  "version": "1.4.1",
+  "description": "Extremely fast utf8 only stream implementation",
+  "main": "index.js",
+  "scripts": {
+    "test-only": "tap test.js",
+    "test": "standard && tap test.js",
+    "prepare": "husky install"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mcollina/sonic-boom.git"
+  },
+  "keywords": [
+    "stream",
+    "fs",
+    "net",
+    "fd",
+    "file",
+    "descriptor",
+    "fast"
+  ],
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mcollina/sonic-boom/issues"
+  },
+  "homepage": "https://github.com/mcollina/sonic-boom#readme",
+  "devDependencies": {
+    "fastbench": "^1.0.1",
+    "husky": "^6.0.0",
+    "proxyquire": "^2.1.0",
+    "standard": "^16.0.3",
+    "tap": "^15.0.1"
+  },
+  "dependencies": {
+    "atomic-sleep": "^1.0.0",
+    "flatstr": "^1.0.12"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "npm test"
+    }
+  }
+}

node_modules/pino/node_modules/sonic-boom/test.js

@@ -0,0 +1,946 @@
+'use strict'
+
+const { test, teardown } = require('tap')
+const { join } = require('path')
+const { fork } = require('child_process')
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const proxyquire = require('proxyquire')
+const SonicBoom = require('.')
+
+const files = []
+let count = 0
+
+function file () {
+  const file = path.join(os.tmpdir(), `sonic-boom-${process.pid}-${process.hrtime().toString()}-${count++}`)
+  files.push(file)
+  return file
+}
+
+teardown(() => {
+  files.forEach((file) => {
+    try {
+      if (fs.existsSync(file)) {
+        fs.unlinkSync(file)
+      }
+    } catch (e) {
+      console.log(e)
+    }
+  })
+})
+
+test('sync false', (t) => {
+  buildTests(t.test, false)
+  t.end()
+})
+
+test('sync true', (t) => {
+  buildTests(t.test, true)
+  t.end()
+})
+
+function buildTests (test, sync) {
+  test('write things to a file descriptor', (t) => {
+    t.plan(6)
+
+    const dest = file()
+    const fd = fs.openSync(dest, 'w')
+    const stream = new SonicBoom({ fd, sync })
+
+    stream.on('ready', () => {
+      t.pass('ready emitted')
+    })
+
+    t.ok(stream.write('hello world\n'))
+    t.ok(stream.write('something else\n'))
+
+    stream.end()
+
+    stream.on('finish', () => {
+      fs.readFile(dest, 'utf8', (err, data) => {
+        t.error(err)
+        t.equal(data, 'hello world\nsomething else\n')
+      })
+    })
+    stream.on('close', () => {
+      t.pass('close emitted')
+    })
+  })
+
+  test('write things in a streaming fashion', (t) => {
+    t.plan(8)
+
+    const dest = file()
+    const fd = fs.openSync(dest, 'w')
+    const stream = new SonicBoom({ fd, sync })
+
+    stream.once('drain', () => {
+      fs.readFile(dest, 'utf8', (err, data) => {
+        t.error(err)
+        t.equal(data, 'hello world\n')
+        t.ok(stream.write('something else\n'))
+      })
+
+      stream.once('drain', () => {
+        fs.readFile(dest, 'utf8', (err, data) => {
+          t.error(err)
+          t.equal(data, 'hello world\nsomething else\n')
+          stream.end()
+        })
+      })
+    })
+
+    t.ok(stream.write('hello world\n'))
+
+    stream.on('finish', () => {
+      t.pass('finish emitted')
+    })
+    stream.on('close', () => {
+      t.pass('close emitted')
+    })
+  })
+
+  test('can be piped into', (t) => {
+    t.plan(4)
+
+    const dest = file()
+    const fd = fs.openSync(dest, 'w')
+    const stream = new SonicBoom({ fd, sync })
+    const source = fs.createReadStream(__filename)
+
+    source.pipe(stream)
+
+    stream.on('finish', () => {
+      fs.readFile(__filename, 'utf8', (err, expected) => {
+        t.error(err)
+        fs.readFile(dest, 'utf8', (err, data) => {
+          t.error(err)
+          t.equal(data, expected)
+        })
+      })
+    })
+    stream.on('close', () => {
+      t.pass('close emitted')
+    })
+  })
+
+  test('write things to a file', (t) => {
+    t.plan(6)
+
+    const dest = file()
+    const stream = new SonicBoom({ dest, sync })
+
+    stream.on('ready', () => {
+      t.pass('ready emitted')
+    })
+
+    t.ok(stream.write('hello world\n'))
+    t.ok(stream.write('something else\n'))
+
+    stream.end()
+
+    stream.on('finish', () => {
+      fs.readFile(dest, 'utf8', (err, data) => {
+        t.error(err)
+        t.equal(data, 'hello world\nsomething else\n')
+      })
+    })
+    stream.on('close', () => {
+      t.pass('close emitted')
+    })
+  })
+
+  test('flushSync', (t) => {
+    t.plan(4)
+
+    const dest = file()
+    const fd = fs.openSync(dest, 'w')
+    const stream = new SonicBoom({ fd, minLength: 4096, sync })
+
+    t.ok(stream.write('hello world\n'))
+    t.ok(stream.write('something else\n'))
+
+    stream.flushSync()
+
+    // let the file system settle down things
+    setImmediate(function () {
+      stream.end()
+      const data = fs.readFileSync(dest, 'utf8')
+      t.equal(data, 'hello world\nsomething else\n')
+
+      stream.on('close', () => {
+        t.pass('close emitted')
+      })
+    })
+  })
+
+  test('destroy', (t) => {
+    t.plan(5)
+
+    const dest = file()
+    const fd = fs.openSync(dest, 'w')
+    const stream = new SonicBoom({ fd, sync })
+
+    t.ok(stream.write('hello world\n'))
+    stream.destroy()
+    t.throws(() => { stream.write('hello world\n') })
+
+    fs.readFile(dest, 'utf8', function (err, data) {
+      t.error(err)
+      t.equal(data, 'hello world\n')
+    })
+
+    stream.on('finish', () => {
+      t.fail('finish emitted')
+    })
+
+    stream.on('close', () => {
+      t.pass('close emitted')
+    })
+  })
+
+  test('destroy while opening', (t) => {
+    t.plan(1)
+
+    const dest = file()
+    const stream = new SonicBoom({ dest })
+
+    stream.destroy()
+    stream.on('close', () => {
+      t.pass('close emitted')
+    })
+  })
+
+  test('minLength', (t) => {
+    t.plan(8)
+
+    const dest = file()
+    const stream = new SonicBoom({ dest, minLength: 4096, sync })
+
+    stream.on('ready', () => {
+      t.pass('ready emitted')
+    })
+
+    t.ok(stream.write('hello world\n'))
+    t.ok(stream.write('something else\n'))
+
+    const fail = t.fail
+    stream.on('drain', fail)
+
+    // bad use of timer
+    // TODO refactor
+    setTimeout(function () {
+      fs.readFile(dest, 'utf8', (err, data) => {
+        t.error(err)
+        t.equal(data, '')
+
+        stream.end()
+
+        stream.on('finish', () => {
+          fs.readFile(dest, 'utf8', (err, data) => {
+            t.error(err)
+            t.equal(data, 'hello world\nsomething else\n')
+          })
+        })
+      })
+    }, 100)
+
+    stream.on('close', () => {
+      t.pass('close emitted')
+    })
+  })
+
+  test('flush', (t) => {
+    t.plan(5)
+
+    const dest = file()
+    const fd = fs.openSync(dest, 'w')
+    const stream = new SonicBoom({ fd, minLength: 4096, sync })
+
+    stream.on('ready', () => {
+      t.pass('ready emitted')
+    })
+
+    t.ok(stream.write('hello world\n'))
+    t.ok(stream.write('something else\n'))
+
+    stream.flush()
+
+    stream.on('drain', () => {
+      fs.readFile(dest, 'utf8', (err, data) => {
+        t.error(err)
+        t.equal(data, 'hello world\nsomething else\n')
+        stream.end()
+      })
+    })
+  })
+
+  test('reopen', (t) => {
+    t.plan(9)
+
+    const dest = file()
+    const stream = new SonicBoom({ dest, sync })
+
+    t.ok(stream.write('hello world\n'))
+    t.ok(stream.write('something else\n'))
+
+    const after = dest + '-moved'
+
+    stream.once('drain', () => {
+      t.pass('drain emitted')
+
+      fs.renameSync(dest, after)
+      stream.reopen()
+
+      stream.once('ready', () => {
+        t.pass('ready emitted')
+        t.ok(stream.write('after reopen\n'))
+
+        stream.on('drain', () => {
+          fs.readFile(after, 'utf8', (err, data) => {
+            t.error(err)
+            t.equal(data, 'hello world\nsomething else\n')
+            fs.readFile(dest, 'utf8', (err, data) => {
+              t.error(err)
+              t.equal(data, 'after reopen\n')
+              stream.end()
+            })
+          })
+        })
+      })
+    })
+  })
+
+  test('reopen with buffer', (t) => {
+    t.plan(9)
+
+    const dest = file()
+    const stream = new SonicBoom({ dest, minLength: 4096, sync })
+
+    t.ok(stream.write('hello world\n'))
+    t.ok(stream.write('something else\n'))
+
+    const after = dest + '-moved'
+
+    stream.once('ready', () => {
+      t.pass('drain emitted')
+
+      stream.flush()
+      fs.renameSync(dest, after)
+      stream.reopen()
+
+      stream.once('ready', () => {
+        t.pass('ready emitted')
+        t.ok(stream.write('after reopen\n'))
+        stream.flush()
+
+        stream.on('drain', () => {
+          fs.readFile(after, 'utf8', (err, data) => {
+            t.error(err)
+            t.equal(data, 'hello world\nsomething else\n')
+            fs.readFile(dest, 'utf8', (err, data) => {
+              t.error(err)
+              t.equal(data, 'after reopen\n')
+              stream.end()
+            })
+          })
+        })
+      })
+    })
+  })
+
+  test('reopen if not open', (t) => {
+    t.plan(3)
+
+    const dest = file()
+    const stream = new SonicBoom({ dest, sync })
+
+    t.ok(stream.write('hello world\n'))
+    t.ok(stream.write('something else\n'))
+
+    stream.reopen()
+
+    stream.end()
+    stream.on('close', function () {
+      t.pass('ended')
+    })
+  })
+
+  test('end after reopen', (t) => {
+    t.plan(4)
+
+    const dest = file()
+    const stream = new SonicBoom({ dest, minLength: 4096, sync })
+
+    stream.once('ready', () => {
+      t.pass('ready emitted')
+      const after = dest + '-moved'
+      stream.reopen(after)
+      stream.write('after reopen\n')
+      stream.on('finish', () => {
+        t.pass('finish emitted')
+        fs.readFile(after, 'utf8', (err, data) => {
+          t.error(err)
+          t.equal(data, 'after reopen\n')
+        })
+      })
+      stream.end()
+    })
+  })
+
+  test('end after 2x reopen', (t) => {
+    t.plan(4)
+
+    const dest = file()
+    const stream = new SonicBoom({ dest, minLength: 4096, sync })
+
+    stream.once('ready', () => {
+      t.pass('ready emitted')
+      stream.reopen(dest + '-moved')
+      const after = dest + '-moved-moved'
+      stream.reopen(after)
+      stream.write('after reopen\n')
+      stream.on('finish', () => {
+        t.pass('finish emitted')
+        fs.readFile(after, 'utf8', (err, data) => {
+          t.error(err)
+          t.equal(data, 'after reopen\n')
+        })
+      })
+      stream.end()
+    })
+  })
+
+  test('end if not ready', (t) => {
+    t.plan(3)
+
+    const dest = file()
+    const stream = new SonicBoom({ dest, minLength: 4096, sync })
+    const after = dest + '-moved'
+    stream.reopen(after)
+    stream.write('after reopen\n')
+    stream.on('finish', () => {
+      t.pass('finish emitted')
+      fs.readFile(after, 'utf8', (err, data) => {
+        t.error(err)
+        t.equal(data, 'after reopen\n')
+      })
+    })
+    stream.end()
+  })
+
+  test('reopen with file', (t) => {
+    t.plan(9)
+
+    const dest = file()
+    const stream = new SonicBoom({ dest, minLength: 0, sync })
+
+    t.ok(stream.write('hello world\n'))
+    t.ok(stream.write('something else\n'))
+
+    const after = dest + '-new'
+
+    stream.once('drain', () => {
+      t.pass('drain emitted')
+
+      stream.reopen(after)
+
+      stream.once('ready', () => {
+        t.pass('ready emitted')
+        t.ok(stream.write('after reopen\n'))
+
+        stream.on('drain', () => {
+          fs.readFile(dest, 'utf8', (err, data) => {
+            t.error(err)
+            t.equal(data, 'hello world\nsomething else\n')
+            fs.readFile(after, 'utf8', (err, data) => {
+              t.error(err)
+              t.equal(data, 'after reopen\n')
+              stream.end()
+            })
+          })
+        })
+      })
+    })
+  })
+
+  test('chunk data accordingly', (t) => {
+    t.plan(2)
+
+    const child = fork(join(__dirname, 'fixtures', 'firehose.js'), { silent: true })
+    const str = Buffer.alloc(10000).fill('a').toString()
+
+    let data = ''
+
+    child.stdout.on('data', function (chunk) {
+      data += chunk.toString()
+    })
+
+    child.stdout.on('end', function () {
+      t.equal(data, str)
+    })
+
+    child.on('close', function (code) {
+      t.equal(code, 0)
+    })
+  })
+
+  test('write later on recoverable error', (t) => {
+    t.plan(8)
+
+    const fakeFs = Object.create(fs)
+    const SonicBoom = proxyquire('.', {
+      fs: fakeFs
+    })
+
+    const dest = file()
+    const fd = fs.openSync(dest, 'w')
+    const stream = new SonicBoom({ fd, minLength: 0, sync })
+
+    stream.on('ready', () => {
+      t.pass('ready emitted')
+    })
+    stream.on('error', () => {
+      t.pass('error emitted')
+    })
+
+    if (sync) {
+      fakeFs.writeSync = function (fd, buf, enc) {
+        t.pass('fake fs.writeSync called')
+        throw new Error('recoverable error')
+      }
+    } else {
+      fakeFs.write = function (fd, buf, enc, cb) {
+        t.pass('fake fs.write called')
+        setTimeout(() => cb(new Error('recoverable error')), 0)
+      }
+    }
+
+    t.ok(stream.write('hello world\n'))
+
+    setTimeout(() => {
+      if (sync) {
+        fakeFs.writeSync = fs.writeSync
+      } else {
+        fakeFs.write = fs.write
+      }
+
+      t.ok(stream.write('something else\n'))
+
+      stream.end()
+      stream.on('finish', () => {
+        fs.readFile(dest, 'utf8', (err, data) => {
+          t.error(err)
+          t.equal(data, 'hello world\nsomething else\n')
+        })
+      })
+      stream.on('close', () => {
+        t.pass('close emitted')
+      })
+    }, 0)
+  })
+
+  test('reopen throws an error', (t) => {
+    t.plan(sync ? 10 : 9)
+
+    const fakeFs = Object.create(fs)
+    const SonicBoom = proxyquire('.', {
+      fs: fakeFs
+    })
+
+    const dest = file()
+    const stream = new SonicBoom({ dest, sync })
+
+    t.ok(stream.write('hello world\n'))
+    t.ok(stream.write('something else\n'))
+
+    const after = dest + '-moved'
+
+    stream.on('error', () => {
+      t.pass('error emitted')
+    })
+
+    stream.once('drain', () => {
+      t.pass('drain emitted')
+
+      fs.renameSync(dest, after)
+      if (sync) {
+        fakeFs.openSync = function (file, flags) {
+          t.pass('fake fs.openSync called')
+          throw new Error('open error')
+        }
+      } else {
+        fakeFs.open = function (file, flags, cb) {
+          t.pass('fake fs.open called')
+          setTimeout(() => cb(new Error('open error')), 0)
+        }
+      }
+
+      if (sync) {
+        try {
+          stream.reopen()
+        } catch (err) {
+          t.pass('reopen throwed')
+        }
+      } else {
+        stream.reopen()
+      }
+
+      setTimeout(() => {
+        t.ok(stream.write('after reopen\n'))
+
+        stream.end()
+        stream.on('finish', () => {
+          fs.readFile(after, 'utf8', (err, data) => {
+            t.error(err)
+            t.equal(data, 'hello world\nsomething else\nafter reopen\n')
+          })
+        })
+        stream.on('close', () => {
+          t.pass('close emitted')
+        })
+      }, 0)
+    })
+  })
+}
+
+test('retry on EAGAIN', (t) => {
+  t.plan(7)
+
+  const fakeFs = Object.create(fs)
+  fakeFs.write = function (fd, buf, enc, cb) {
+    t.pass('fake fs.write called')
+    fakeFs.write = fs.write
+    const err = new Error('EAGAIN')
+    err.code = 'EAGAIN'
+    process.nextTick(cb, err)
+  }
+  const SonicBoom = proxyquire('.', {
+    fs: fakeFs
+  })
+
+  const dest = file()
+  const fd = fs.openSync(dest, 'w')
+  const stream = new SonicBoom({ fd, sync: false, minLength: 0 })
+
+  stream.on('ready', () => {
+    t.pass('ready emitted')
+  })
+
+  t.ok(stream.write('hello world\n'))
+  t.ok(stream.write('something else\n'))
+
+  stream.end()
+
+  stream.on('finish', () => {
+    fs.readFile(dest, 'utf8', (err, data) => {
+      t.error(err)
+      t.equal(data, 'hello world\nsomething else\n')
+    })
+  })
+  stream.on('close', () => {
+    t.pass('close emitted')
+  })
+})
+
+test('retry on EAGAIN (sync)', (t) => {
+  t.plan(7)
+
+  const fakeFs = Object.create(fs)
+  fakeFs.writeSync = function (fd, buf, enc, cb) {
+    t.pass('fake fs.writeSync called')
+    fakeFs.writeSync = fs.writeSync
+    const err = new Error('EAGAIN')
+    err.code = 'EAGAIN'
+    throw err
+  }
+  const SonicBoom = proxyquire('.', {
+    fs: fakeFs
+  })
+
+  const dest = file()
+  const fd = fs.openSync(dest, 'w')
+  const stream = new SonicBoom({ fd, minLength: 0, sync: true })
+
+  stream.on('ready', () => {
+    t.pass('ready emitted')
+  })
+
+  t.ok(stream.write('hello world\n'))
+  t.ok(stream.write('something else\n'))
+
+  stream.end()
+
+  stream.on('finish', () => {
+    fs.readFile(dest, 'utf8', (err, data) => {
+      t.error(err)
+      t.equal(data, 'hello world\nsomething else\n')
+    })
+  })
+  stream.on('close', () => {
+    t.pass('close emitted')
+  })
+})
+
+test('retry in flushSync on EAGAIN', (t) => {
+  t.plan(7)
+
+  const fakeFs = Object.create(fs)
+  const SonicBoom = proxyquire('.', {
+    fs: fakeFs
+  })
+
+  const dest = file()
+  const fd = fs.openSync(dest, 'w')
+  const stream = new SonicBoom({ fd, sync: false, minLength: 0 })
+
+  stream.on('ready', () => {
+    t.pass('ready emitted')
+  })
+
+  t.ok(stream.write('hello world\n'))
+
+  fakeFs.writeSync = function (fd, buf, enc) {
+    t.pass('fake fs.write called')
+    fakeFs.writeSync = fs.writeSync
+    const err = new Error('EAGAIN')
+    err.code = 'EAGAIN'
+    throw err
+  }
+
+  t.ok(stream.write('something else\n'))
+
+  stream.flushSync()
+  stream.end()
+
+  stream.on('finish', () => {
+    fs.readFile(dest, 'utf8', (err, data) => {
+      t.error(err)
+      t.equal(data, 'hello world\nsomething else\n')
+    })
+  })
+  stream.on('close', () => {
+    t.pass('close emitted')
+  })
+})
+
+test('write buffers that are not totally written', (t) => {
+  t.plan(9)
+
+  const fakeFs = Object.create(fs)
+  fakeFs.write = function (fd, buf, enc, cb) {
+    t.pass('fake fs.write called')
+    fakeFs.write = function (fd, buf, enc, cb) {
+      t.pass('calling real fs.write, ' + buf)
+      fs.write(fd, buf, enc, cb)
+    }
+    process.nextTick(cb, null, 0)
+  }
+  const SonicBoom = proxyquire('.', {
+    fs: fakeFs
+  })
+
+  const dest = file()
+  const fd = fs.openSync(dest, 'w')
+  const stream = new SonicBoom({ fd, minLength: 0, sync: false })
+
+  stream.on('ready', () => {
+    t.pass('ready emitted')
+  })
+
+  t.ok(stream.write('hello world\n'))
+  t.ok(stream.write('something else\n'))
+
+  stream.end()
+
+  stream.on('finish', () => {
+    fs.readFile(dest, 'utf8', (err, data) => {
+      t.error(err)
+      t.equal(data, 'hello world\nsomething else\n')
+    })
+  })
+  stream.on('close', () => {
+    t.pass('close emitted')
+  })
+})
+
+test('write buffers that are not totally written with sync mode', (t) => {
+  t.plan(9)
+
+  const fakeFs = Object.create(fs)
+  fakeFs.writeSync = function (fd, buf, enc) {
+    t.pass('fake fs.write called')
+    fakeFs.writeSync = (fd, buf, enc) => {
+      t.pass('calling real fs.writeSync, ' + buf)
+      return fs.writeSync(fd, buf, enc)
+    }
+    return 0
+  }
+  const SonicBoom = proxyquire('.', {
+    fs: fakeFs
+  })
+
+  const dest = file()
+  const fd = fs.openSync(dest, 'w')
+  const stream = new SonicBoom({ fd, minLength: 0, sync: true })
+
+  stream.on('ready', () => {
+    t.pass('ready emitted')
+  })
+
+  t.ok(stream.write('hello world\n'))
+  t.ok(stream.write('something else\n'))
+
+  stream.end()
+
+  stream.on('finish', () => {
+    fs.readFile(dest, 'utf8', (err, data) => {
+      t.error(err)
+      t.equal(data, 'hello world\nsomething else\n')
+    })
+  })
+  stream.on('close', () => {
+    t.pass('close emitted')
+  })
+})
+
+test('sync writing is fully sync', (t) => {
+  t.plan(6)
+
+  const fakeFs = Object.create(fs)
+  fakeFs.writeSync = function (fd, buf, enc, cb) {
+    t.pass('fake fs.write called')
+    return fs.writeSync(fd, buf, enc)
+  }
+  const SonicBoom = proxyquire('.', {
+    fs: fakeFs
+  })
+
+  const dest = file()
+  const fd = fs.openSync(dest, 'w')
+  const stream = new SonicBoom({ fd, minLength: 0, sync: true })
+  t.ok(stream.write('hello world\n'))
+  t.ok(stream.write('something else\n'))
+
+  // 'drain' will be only emitted once,
+  // the number of assertions at the top check this.
+  stream.on('drain', () => {
+    t.pass('drain emitted')
+  })
+
+  const data = fs.readFileSync(dest, 'utf8')
+  t.equal(data, 'hello world\nsomething else\n')
+})
+
+// These they will fail on Node 6, as we cannot allocate a string this
+// big. It's considered a won't fix on Node 6, as it's deprecated.
+if (process.versions.node.indexOf('6.') !== 0) {
+  test('write enormously large buffers async', (t) => {
+    t.plan(3)
+
+    const dest = file()
+    const fd = fs.openSync(dest, 'w')
+    const stream = new SonicBoom({ fd, minLength: 0, sync: false })
+
+    const buf = Buffer.alloc(1024).fill('x').toString() // 1 MB
+    let length = 0
+
+    for (let i = 0; i < 1024 * 512; i++) {
+      length += buf.length
+      stream.write(buf)
+    }
+
+    stream.end()
+
+    stream.on('finish', () => {
+      fs.stat(dest, (err, stat) => {
+        t.error(err)
+        t.equal(stat.size, length)
+      })
+    })
+    stream.on('close', () => {
+      t.pass('close emitted')
+    })
+  })
+
+  test('write enormously large buffers sync', (t) => {
+    t.plan(3)
+
+    const dest = file()
+    const fd = fs.openSync(dest, 'w')
+    const stream = new SonicBoom({ fd, minLength: 0, sync: true })
+
+    const buf = Buffer.alloc(1024).fill('x').toString() // 1 MB
+    let length = 0
+
+    for (let i = 0; i < 1024 * 512; i++) {
+      length += buf.length
+      stream.write(buf)
+    }
+
+    stream.end()
+
+    stream.on('finish', () => {
+      fs.stat(dest, (err, stat) => {
+        t.error(err)
+        t.equal(stat.size, length)
+      })
+    })
+    stream.on('close', () => {
+      t.pass('close emitted')
+    })
+  })
+}
+
+test('write enormously large buffers sync with utf8 multi-byte split', (t) => {
+  t.plan(4)
+
+  const dest = file()
+  const fd = fs.openSync(dest, 'w')
+  const stream = new SonicBoom({ fd, minLength: 0, sync: true })
+
+  let buf = Buffer.alloc((1024 * 16) - 2).fill('x') // 16MB - 3B
+  const length = buf.length + 4
+  buf = buf.toString() + '🌲' // 16 MB + 1B
+
+  stream.write(buf)
+
+  stream.end()
+
+  stream.on('finish', () => {
+    fs.stat(dest, (err, stat) => {
+      t.error(err)
+      t.equal(stat.size, length)
+      const char = Buffer.alloc(4)
+      const fd = fs.openSync(dest, 'r')
+      fs.readSync(fd, char, 0, 4, length - 4)
+      t.equal(char.toString(), '🌲')
+    })
+  })
+  stream.on('close', () => {
+    t.pass('close emitted')
+  })
+})
+
+// for context see this issue https://github.com/pinojs/pino/issues/871
+test('file specified by dest path available immediately when options.sync is true', (t) => {
+  t.plan(3)
+  const dest = file()
+  const stream = new SonicBoom({ dest, sync: true })
+  t.ok(stream.write('hello world\n'))
+  t.ok(stream.write('something else\n'))
+  stream.flushSync()
+  t.pass('file opened and written to without error')
+})
+
+test('sync error handling', (t) => {
+  t.plan(1)
+  try {
+    /* eslint no-new: off */
+    new SonicBoom({ dest: '/path/to/nowwhere', sync: true })
+    t.fail('must throw synchronously')
+  } catch (err) {
+    t.pass('an error happened')
+  }
+})

node_modules/pino/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "pino",
+  "version": "6.14.0",
+  "description": "super fast, all natural json logger",
+  "main": "pino.js",
+  "browser": "./browser.js",
+  "files": [
+    "pino.js",
+    "bin.js",
+    "browser.js",
+    "pretty.js",
+    "usage.txt",
+    "test",
+    "docs",
+    "example.js",
+    "lib"
+  ],
+  "scripts": {
+    "docs": "docsify serve",
+    "browser-test": "airtap --local 8080 test/browser*test.js",
+    "lint": "eslint .",
+    "test": "npm run lint && tap --100 test/*test.js test/*/*test.js",
+    "test-ci": "npm run lint && tap test/*test.js test/*/*test.js --coverage-report=lcovonly",
+    "cov-ui": "tap --coverage-report=html test/*test.js test/*/*test.js",
+    "bench": "node benchmarks/utils/runbench all",
+    "bench-basic": "node benchmarks/utils/runbench basic",
+    "bench-object": "node benchmarks/utils/runbench object",
+    "bench-deep-object": "node benchmarks/utils/runbench deep-object",
+    "bench-multi-arg": "node benchmarks/utils/runbench multi-arg",
+    "bench-longs-tring": "node benchmarks/utils/runbench long-string",
+    "bench-child": "node benchmarks/utils/runbench child",
+    "bench-child-child": "node benchmarks/utils/runbench child-child",
+    "bench-child-creation": "node benchmarks/utils/runbench child-creation",
+    "bench-formatters": "node benchmarks/utils/runbench formatters",
+    "update-bench-doc": "node benchmarks/utils/generate-benchmark-doc > docs/benchmarks.md"
+  },
+  "bin": {
+    "pino": "./bin.js"
+  },
+  "precommit": "test",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pinojs/pino.git"
+  },
+  "keywords": [
+    "fast",
+    "logger",
+    "stream",
+    "json"
+  ],
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "contributors": [
+    "David Mark Clements <huperekchuno@googlemail.com>",
+    "James Sumners <james.sumners@gmail.com>",
+    "Thomas Watson Steen <w@tson.dk> (https://twitter.com/wa7son)"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pinojs/pino/issues"
+  },
+  "homepage": "http://getpino.io",
+  "devDependencies": {
+    "airtap": "4.0.3",
+    "benchmark": "^2.1.4",
+    "bole": "^4.0.0",
+    "bunyan": "^1.8.14",
+    "docsify-cli": "^4.4.1",
+    "eslint": "^7.17.0",
+    "eslint-config-standard": "^16.0.2",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^5.1.0",
+    "execa": "^5.0.0",
+    "fastbench": "^1.0.1",
+    "flush-write-stream": "^2.0.0",
+    "import-fresh": "^3.2.1",
+    "log": "^6.0.0",
+    "loglevel": "^1.6.7",
+    "pino-pretty": "^5.0.0",
+    "pre-commit": "^1.2.2",
+    "proxyquire": "^2.1.3",
+    "pump": "^3.0.0",
+    "semver": "^7.0.0",
+    "split2": "^3.1.1",
+    "steed": "^1.1.3",
+    "strip-ansi": "^6.0.0",
+    "tap": "^15.0.1",
+    "tape": "^5.0.0",
+    "through2": "^4.0.0",
+    "winston": "^3.3.3"
+  },
+  "dependencies": {
+    "fast-redact": "^3.0.0",
+    "fast-safe-stringify": "^2.0.8",
+    "process-warning": "^1.0.0",
+    "flatstr": "^1.0.12",
+    "pino-std-serializers": "^3.1.0",
+    "quick-format-unescaped": "^4.0.3",
+    "sonic-boom": "^1.0.2"
+  }
+}

node_modules/pino/pino.js

@@ -0,0 +1,238 @@
+'use strict'
+/* eslint no-prototype-builtins: 0 */
+const os = require('os')
+const stdSerializers = require('pino-std-serializers')
+const redaction = require('./lib/redaction')
+const time = require('./lib/time')
+const proto = require('./lib/proto')
+const symbols = require('./lib/symbols')
+const { assertDefaultLevelFound, mappings, genLsCache } = require('./lib/levels')
+const {
+  createArgsNormalizer,
+  asChindings,
+  final,
+  stringify,
+  buildSafeSonicBoom,
+  buildFormatters,
+  noop
+} = require('./lib/tools')
+const { version } = require('./lib/meta')
+const { mixinMergeStrategySym } = require('./lib/symbols')
+const {
+  chindingsSym,
+  redactFmtSym,
+  serializersSym,
+  timeSym,
+  timeSliceIndexSym,
+  streamSym,
+  stringifySym,
+  stringifiersSym,
+  setLevelSym,
+  endSym,
+  formatOptsSym,
+  messageKeySym,
+  nestedKeySym,
+  mixinSym,
+  useOnlyCustomLevelsSym,
+  formattersSym,
+  hooksSym
+} = symbols
+const { epochTime, nullTime } = time
+const { pid } = process
+const hostname = os.hostname()
+const defaultErrorSerializer = stdSerializers.err
+const defaultOptions = {
+  level: 'info',
+  messageKey: 'msg',
+  nestedKey: null,
+  enabled: true,
+  prettyPrint: false,
+  base: { pid, hostname },
+  serializers: Object.assign(Object.create(null), {
+    err: defaultErrorSerializer
+  }),
+  formatters: Object.assign(Object.create(null), {
+    bindings (bindings) {
+      return bindings
+    },
+    level (label, number) {
+      return { level: number }
+    }
+  }),
+  hooks: {
+    logMethod: undefined
+  },
+  timestamp: epochTime,
+  name: undefined,
+  redact: null,
+  customLevels: null,
+  levelKey: undefined,
+  useOnlyCustomLevels: false
+}
+
+const normalize = createArgsNormalizer(defaultOptions)
+
+const serializers = Object.assign(Object.create(null), stdSerializers)
+
+function pino (...args) {
+  const instance = {}
+  const { opts, stream } = normalize(instance, ...args)
+  const {
+    redact,
+    crlf,
+    serializers,
+    timestamp,
+    messageKey,
+    nestedKey,
+    base,
+    name,
+    level,
+    customLevels,
+    useLevelLabels,
+    changeLevelName,
+    levelKey,
+    mixin,
+    mixinMergeStrategy,
+    useOnlyCustomLevels,
+    formatters,
+    hooks
+  } = opts
+
+  const allFormatters = buildFormatters(
+    formatters.level,
+    formatters.bindings,
+    formatters.log
+  )
+
+  if (useLevelLabels && !(changeLevelName || levelKey)) {
+    process.emitWarning('useLevelLabels is deprecated, use the formatters.level option instead', 'Warning', 'PINODEP001')
+    allFormatters.level = labelsFormatter
+  } else if ((changeLevelName || levelKey) && !useLevelLabels) {
+    process.emitWarning('changeLevelName and levelKey are deprecated, use the formatters.level option instead', 'Warning', 'PINODEP002')
+    allFormatters.level = levelNameFormatter(changeLevelName || levelKey)
+  } else if ((changeLevelName || levelKey) && useLevelLabels) {
+    process.emitWarning('useLevelLabels is deprecated, use the formatters.level option instead', 'Warning', 'PINODEP001')
+    process.emitWarning('changeLevelName and levelKey are deprecated, use the formatters.level option instead', 'Warning', 'PINODEP002')
+    allFormatters.level = levelNameLabelFormatter(changeLevelName || levelKey)
+  }
+
+  if (serializers[Symbol.for('pino.*')]) {
+    process.emitWarning('The pino.* serializer is deprecated, use the formatters.log options instead', 'Warning', 'PINODEP003')
+    allFormatters.log = serializers[Symbol.for('pino.*')]
+  }
+
+  if (!allFormatters.bindings) {
+    allFormatters.bindings = defaultOptions.formatters.bindings
+  }
+  if (!allFormatters.level) {
+    allFormatters.level = defaultOptions.formatters.level
+  }
+
+  const stringifiers = redact ? redaction(redact, stringify) : {}
+  const formatOpts = redact
+    ? { stringify: stringifiers[redactFmtSym] }
+    : { stringify }
+  const end = '}' + (crlf ? '\r\n' : '\n')
+  const coreChindings = asChindings.bind(null, {
+    [chindingsSym]: '',
+    [serializersSym]: serializers,
+    [stringifiersSym]: stringifiers,
+    [stringifySym]: stringify,
+    [formattersSym]: allFormatters
+  })
+
+  let chindings = ''
+  if (base !== null) {
+    if (name === undefined) {
+      chindings = coreChindings(base)
+    } else {
+      chindings = coreChindings(Object.assign({}, base, { name }))
+    }
+  }
+
+  const time = (timestamp instanceof Function)
+    ? timestamp
+    : (timestamp ? epochTime : nullTime)
+  const timeSliceIndex = time().indexOf(':') + 1
+
+  if (useOnlyCustomLevels && !customLevels) throw Error('customLevels is required if useOnlyCustomLevels is set true')
+  if (mixin && typeof mixin !== 'function') throw Error(`Unknown mixin type "${typeof mixin}" - expected "function"`)
+
+  assertDefaultLevelFound(level, customLevels, useOnlyCustomLevels)
+  const levels = mappings(customLevels, useOnlyCustomLevels)
+
+  Object.assign(instance, {
+    levels,
+    [useOnlyCustomLevelsSym]: useOnlyCustomLevels,
+    [streamSym]: stream,
+    [timeSym]: time,
+    [timeSliceIndexSym]: timeSliceIndex,
+    [stringifySym]: stringify,
+    [stringifiersSym]: stringifiers,
+    [endSym]: end,
+    [formatOptsSym]: formatOpts,
+    [messageKeySym]: messageKey,
+    [nestedKeySym]: nestedKey,
+    [serializersSym]: serializers,
+    [mixinSym]: mixin,
+    [mixinMergeStrategySym]: mixinMergeStrategy,
+    [chindingsSym]: chindings,
+    [formattersSym]: allFormatters,
+    [hooksSym]: hooks,
+    silent: noop
+  })
+
+  Object.setPrototypeOf(instance, proto())
+
+  genLsCache(instance)
+
+  instance[setLevelSym](level)
+
+  return instance
+}
+
+function labelsFormatter (label, number) {
+  return { level: label }
+}
+
+function levelNameFormatter (name) {
+  return function (label, number) {
+    return { [name]: number }
+  }
+}
+
+function levelNameLabelFormatter (name) {
+  return function (label, number) {
+    return { [name]: label }
+  }
+}
+
+module.exports = pino
+
+module.exports.extreme = (dest = process.stdout.fd) => {
+  process.emitWarning(
+    'The pino.extreme() option is deprecated and will be removed in v7. Use pino.destination({ sync: false }) instead.',
+    { code: 'extreme_deprecation' }
+  )
+  return buildSafeSonicBoom({ dest, minLength: 4096, sync: false })
+}
+
+module.exports.destination = (dest = process.stdout.fd) => {
+  if (typeof dest === 'object') {
+    dest.dest = dest.dest || process.stdout.fd
+    return buildSafeSonicBoom(dest)
+  } else {
+    return buildSafeSonicBoom({ dest, minLength: 0, sync: true })
+  }
+}
+
+module.exports.final = final
+module.exports.levels = mappings()
+module.exports.stdSerializers = serializers
+module.exports.stdTimeFunctions = Object.assign({}, time)
+module.exports.symbols = symbols
+module.exports.version = version
+
+// Enables default and name export with TypeScript and Babel
+module.exports.default = pino
+module.exports.pino = pino

node_modules/pino/test/basic.test.js

@@ -0,0 +1,667 @@
+'use strict'
+const os = require('os')
+const { join } = require('path')
+const { readFileSync } = require('fs')
+const { test } = require('tap')
+const { sink, check, once, watchFileCreated } = require('./helper')
+const pino = require('../')
+const { version } = require('../package.json')
+const { pid } = process
+const hostname = os.hostname()
+
+test('pino version is exposed on export', async ({ equal }) => {
+  equal(pino.version, version)
+})
+
+test('pino version is exposed on instance', async ({ equal }) => {
+  const instance = pino()
+  equal(instance.version, version)
+})
+
+test('child instance exposes pino version', async ({ equal }) => {
+  const child = pino().child({ foo: 'bar' })
+  equal(child.version, version)
+})
+
+test('bindings are exposed on every instance', async ({ same }) => {
+  const instance = pino()
+  same(instance.bindings(), {})
+})
+
+test('bindings contain the name and the child bindings', async ({ same }) => {
+  const instance = pino({ name: 'basicTest', level: 'info' }).child({ foo: 'bar' }).child({ a: 2 })
+  same(instance.bindings(), { name: 'basicTest', foo: 'bar', a: 2 })
+})
+
+test('set bindings on instance', async ({ same }) => {
+  const instance = pino({ name: 'basicTest', level: 'info' })
+  instance.setBindings({ foo: 'bar' })
+  same(instance.bindings(), { name: 'basicTest', foo: 'bar' })
+})
+
+test('newly set bindings overwrite old bindings', async ({ same }) => {
+  const instance = pino({ name: 'basicTest', level: 'info', base: { foo: 'bar' } })
+  instance.setBindings({ foo: 'baz' })
+  same(instance.bindings(), { name: 'basicTest', foo: 'baz' })
+})
+
+test('set bindings on child instance', async ({ same }) => {
+  const child = pino({ name: 'basicTest', level: 'info' }).child({})
+  child.setBindings({ foo: 'bar' })
+  same(child.bindings(), { name: 'basicTest', foo: 'bar' })
+})
+
+test('child should have bindings set by parent', async ({ same }) => {
+  const instance = pino({ name: 'basicTest', level: 'info' })
+  instance.setBindings({ foo: 'bar' })
+  const child = instance.child({})
+  same(child.bindings(), { name: 'basicTest', foo: 'bar' })
+})
+
+test('child should not share bindings of parent set after child creation', async ({ same }) => {
+  const instance = pino({ name: 'basicTest', level: 'info' })
+  const child = instance.child({})
+  instance.setBindings({ foo: 'bar' })
+  same(instance.bindings(), { name: 'basicTest', foo: 'bar' })
+  same(child.bindings(), { name: 'basicTest' })
+})
+
+function levelTest (name, level) {
+  test(`${name} logs as ${level}`, async ({ equal }) => {
+    const stream = sink()
+    const instance = pino(stream)
+    instance.level = name
+    instance[name]('hello world')
+    check(equal, await once(stream, 'data'), level, 'hello world')
+  })
+
+  test(`passing objects at level ${name}`, async ({ equal, same }) => {
+    const stream = sink()
+    const instance = pino(stream)
+    instance.level = name
+    const obj = { hello: 'world' }
+    instance[name](obj)
+
+    const result = await once(stream, 'data')
+    equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+    equal(result.pid, pid)
+    equal(result.hostname, hostname)
+    equal(result.level, level)
+    equal(result.hello, 'world')
+    same(Object.keys(obj), ['hello'])
+  })
+
+  test(`passing an object and a string at level ${name}`, async ({ equal, same }) => {
+    const stream = sink()
+    const instance = pino(stream)
+    instance.level = name
+    const obj = { hello: 'world' }
+    instance[name](obj, 'a string')
+    const result = await once(stream, 'data')
+    equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+    delete result.time
+    same(result, {
+      pid,
+      hostname,
+      level,
+      msg: 'a string',
+      hello: 'world'
+    })
+    same(Object.keys(obj), ['hello'])
+  })
+
+  test(`overriding object key by string at level ${name}`, async ({ equal, same }) => {
+    const stream = sink()
+    const instance = pino(stream)
+    instance.level = name
+    instance[name]({ hello: 'world', msg: 'object' }, 'string')
+    const result = await once(stream, 'data')
+    equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+    delete result.time
+    same(result, {
+      pid,
+      hostname,
+      level,
+      msg: 'string',
+      hello: 'world'
+    })
+  })
+
+  test(`formatting logs as ${name}`, async ({ equal }) => {
+    const stream = sink()
+    const instance = pino(stream)
+    instance.level = name
+    instance[name]('hello %d', 42)
+    const result = await once(stream, 'data')
+    check(equal, result, level, 'hello 42')
+  })
+
+  test(`formatting a symbol at level ${name}`, async ({ equal }) => {
+    const stream = sink()
+    const instance = pino(stream)
+    instance.level = name
+
+    const sym = Symbol('foo')
+    instance[name]('hello %s', sym)
+
+    const result = await once(stream, 'data')
+
+    check(equal, result, level, 'hello Symbol(foo)')
+  })
+
+  test(`passing error with a serializer at level ${name}`, async ({ equal, same }) => {
+    const stream = sink()
+    const err = new Error('myerror')
+    const instance = pino({
+      serializers: {
+        err: pino.stdSerializers.err
+      }
+    }, stream)
+    instance.level = name
+    instance[name]({ err })
+    const result = await once(stream, 'data')
+    equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+    delete result.time
+    same(result, {
+      pid,
+      hostname,
+      level,
+      err: {
+        type: 'Error',
+        message: err.message,
+        stack: err.stack
+      }
+    })
+  })
+
+  test(`child logger for level ${name}`, async ({ equal, same }) => {
+    const stream = sink()
+    const instance = pino(stream)
+    instance.level = name
+    const child = instance.child({ hello: 'world' })
+    child[name]('hello world')
+    const result = await once(stream, 'data')
+    equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+    delete result.time
+    same(result, {
+      pid,
+      hostname,
+      level,
+      msg: 'hello world',
+      hello: 'world'
+    })
+  })
+}
+
+levelTest('fatal', 60)
+levelTest('error', 50)
+levelTest('warn', 40)
+levelTest('info', 30)
+levelTest('debug', 20)
+levelTest('trace', 10)
+
+test('serializers can return undefined to strip field', async ({ equal }) => {
+  const stream = sink()
+  const instance = pino({
+    serializers: {
+      test () { return undefined }
+    }
+  }, stream)
+
+  instance.info({ test: 'sensitive info' })
+  const result = await once(stream, 'data')
+  equal('test' in result, false)
+})
+
+test('does not explode with a circular ref', async ({ doesNotThrow }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  const b = {}
+  const a = {
+    hello: b
+  }
+  b.a = a // circular ref
+  doesNotThrow(() => instance.info(a))
+})
+
+test('set the name', async ({ equal, same }) => {
+  const stream = sink()
+  const instance = pino({
+    name: 'hello'
+  }, stream)
+  instance.fatal('this is fatal')
+  const result = await once(stream, 'data')
+  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    name: 'hello',
+    msg: 'this is fatal'
+  })
+})
+
+test('set the messageKey', async ({ equal, same }) => {
+  const stream = sink()
+  const message = 'hello world'
+  const messageKey = 'fooMessage'
+  const instance = pino({
+    messageKey
+  }, stream)
+  instance.info(message)
+  const result = await once(stream, 'data')
+  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    fooMessage: message
+  })
+})
+
+test('set the nestedKey', async ({ equal, same }) => {
+  const stream = sink()
+  const object = { hello: 'world' }
+  const nestedKey = 'stuff'
+  const instance = pino({
+    nestedKey
+  }, stream)
+  instance.info(object)
+  const result = await once(stream, 'data')
+  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    stuff: object
+  })
+})
+
+test('set undefined properties', async ({ equal, same }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info({ hello: 'world', property: undefined })
+  const result = await once(stream, 'data')
+  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    hello: 'world'
+  })
+})
+
+test('prototype properties are not logged', async ({ equal }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info(Object.create({ hello: 'world' }))
+  const { hello } = await once(stream, 'data')
+  equal(hello, undefined)
+})
+
+test('set the base', async ({ equal, same }) => {
+  const stream = sink()
+  const instance = pino({
+    base: {
+      a: 'b'
+    }
+  }, stream)
+
+  instance.fatal('this is fatal')
+  const result = await once(stream, 'data')
+  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    a: 'b',
+    level: 60,
+    msg: 'this is fatal'
+  })
+})
+
+test('set the base to null', async ({ equal, same }) => {
+  const stream = sink()
+  const instance = pino({
+    base: null
+  }, stream)
+  instance.fatal('this is fatal')
+  const result = await once(stream, 'data')
+  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    level: 60,
+    msg: 'this is fatal'
+  })
+})
+
+test('set the base to null and use a formatter', async ({ equal, same }) => {
+  const stream = sink()
+  const instance = pino({
+    base: null,
+    formatters: {
+      log (input) {
+        return Object.assign({}, input, { additionalMessage: 'using pino' })
+      }
+    }
+  }, stream)
+  instance.fatal('this is fatal too')
+  const result = await once(stream, 'data')
+  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    level: 60,
+    msg: 'this is fatal too',
+    additionalMessage: 'using pino'
+  })
+})
+
+test('throw if creating child without bindings', async ({ equal, fail }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  try {
+    instance.child()
+    fail('it should throw')
+  } catch (err) {
+    equal(err.message, 'missing bindings for child Pino')
+  }
+})
+
+test('correctly escapes msg strings with stray double quote at end', async ({ same }) => {
+  const stream = sink()
+  const instance = pino({
+    name: 'hello'
+  }, stream)
+
+  instance.fatal('this contains "')
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    name: 'hello',
+    msg: 'this contains "'
+  })
+})
+
+test('correctly escape msg strings with unclosed double quote', async ({ same }) => {
+  const stream = sink()
+  const instance = pino({
+    name: 'hello'
+  }, stream)
+  instance.fatal('" this contains')
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    name: 'hello',
+    msg: '" this contains'
+  })
+})
+
+// https://github.com/pinojs/pino/issues/139
+test('object and format string', async ({ same }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info({}, 'foo %s', 'bar')
+
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'foo bar'
+  })
+})
+
+test('object and format string property', async ({ same }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info({ answer: 42 }, 'foo %s', 'bar')
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'foo bar',
+    answer: 42
+  })
+})
+
+test('correctly strip undefined when returned from toJSON', async ({ equal }) => {
+  const stream = sink()
+  const instance = pino({
+    test: 'this'
+  }, stream)
+  instance.fatal({ test: { toJSON () { return undefined } } })
+  const result = await once(stream, 'data')
+  equal('test' in result, false)
+})
+
+test('correctly supports stderr', async ({ same }) => {
+  // stderr inherits from Stream, rather than Writable
+  const dest = {
+    writable: true,
+    write (result) {
+      result = JSON.parse(result)
+      delete result.time
+      same(result, {
+        pid,
+        hostname,
+        level: 60,
+        msg: 'a message'
+      })
+    }
+  }
+  const instance = pino(dest)
+  instance.fatal('a message')
+})
+
+test('normalize number to string', async ({ same }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info(1)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: '1'
+  })
+})
+
+test('normalize number to string with an object', async ({ same }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info({ answer: 42 }, 1)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: '1',
+    answer: 42
+  })
+})
+
+test('handles objects with null prototype', async ({ same }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  const o = Object.create(null)
+  o.test = 'test'
+  instance.info(o)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    test: 'test'
+  })
+})
+
+test('pino.destination', async ({ same }) => {
+  const tmp = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const instance = pino(pino.destination(tmp))
+  instance.info('hello')
+  await watchFileCreated(tmp)
+  const result = JSON.parse(readFileSync(tmp).toString())
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+test('auto pino.destination with a string', async ({ same }) => {
+  const tmp = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const instance = pino(tmp)
+  instance.info('hello')
+  await watchFileCreated(tmp)
+  const result = JSON.parse(readFileSync(tmp).toString())
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+test('auto pino.destination with a string as second argument', async ({ same }) => {
+  const tmp = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const instance = pino(null, tmp)
+  instance.info('hello')
+  await watchFileCreated(tmp)
+  const result = JSON.parse(readFileSync(tmp).toString())
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})
+
+test('does not override opts with a string as second argument', async ({ same }) => {
+  const tmp = join(
+    os.tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const instance = pino({
+    timestamp: () => ',"time":"none"'
+  }, tmp)
+  instance.info('hello')
+  await watchFileCreated(tmp)
+  const result = JSON.parse(readFileSync(tmp).toString())
+  same(result, {
+    pid,
+    hostname,
+    level: 30,
+    time: 'none',
+    msg: 'hello'
+  })
+})
+
+// https://github.com/pinojs/pino/issues/222
+test('children with same names render in correct order', async ({ equal }) => {
+  const stream = sink()
+  const root = pino(stream)
+  root.child({ a: 1 }).child({ a: 2 }).info({ a: 3 })
+  const { a } = await once(stream, 'data')
+  equal(a, 3, 'last logged object takes precedence')
+})
+
+// https://github.com/pinojs/pino/pull/251 - use this.stringify
+test('use `fast-safe-stringify` to avoid circular dependencies', async ({ same }) => {
+  const stream = sink()
+  const root = pino(stream)
+  // circular depth
+  const obj = {}
+  obj.a = obj
+  root.info(obj)
+  const { a } = await once(stream, 'data')
+  same(a, { a: '[Circular]' })
+})
+
+test('fast-safe-stringify must be used when interpolating', async (t) => {
+  const stream = sink()
+  const instance = pino(stream)
+
+  const o = { a: { b: {} } }
+  o.a.b.c = o.a.b
+  instance.info('test %j', o)
+
+  const { msg } = await once(stream, 'data')
+  t.equal(msg, 'test {"a":{"b":{"c":"[Circular]"}}}')
+})
+
+test('throws when setting useOnlyCustomLevels without customLevels', async ({ throws }) => {
+  throws(() => {
+    pino({
+      useOnlyCustomLevels: true
+    })
+  }, 'customLevels is required if useOnlyCustomLevels is set true')
+})
+
+test('correctly log Infinity', async (t) => {
+  const stream = sink()
+  const instance = pino(stream)
+
+  const o = { num: Infinity }
+  instance.info(o)
+
+  const { num } = await once(stream, 'data')
+  t.equal(num, null)
+})
+
+test('correctly log -Infinity', async (t) => {
+  const stream = sink()
+  const instance = pino(stream)
+
+  const o = { num: -Infinity }
+  instance.info(o)
+
+  const { num } = await once(stream, 'data')
+  t.equal(num, null)
+})
+
+test('correctly log NaN', async (t) => {
+  const stream = sink()
+  const instance = pino(stream)
+
+  const o = { num: NaN }
+  instance.info(o)
+
+  const { num } = await once(stream, 'data')
+  t.equal(num, null)
+})
+
+test('offers a .default() method to please typescript', async ({ equal }) => {
+  equal(pino.default, pino)
+
+  const stream = sink()
+  const instance = pino.default(stream)
+  instance.info('hello world')
+  check(equal, await once(stream, 'data'), 30, 'hello world')
+})

node_modules/pino/test/broken-pipe.test.js

@@ -0,0 +1,42 @@
+'use strict'
+
+const t = require('tap')
+const { join } = require('path')
+const { fork } = require('child_process')
+const { once } = require('./helper')
+const pino = require('..')
+
+function test (file) {
+  file = join('fixtures', 'broken-pipe', file)
+  t.test(file, { parallel: true }, async ({ equal }) => {
+    const child = fork(join(__dirname, file), { silent: true })
+    child.stdout.destroy()
+
+    child.stderr.pipe(process.stdout)
+
+    const res = await once(child, 'close')
+    equal(res, 0) // process exits successfully
+  })
+}
+
+t.jobs = 42
+
+test('basic.js')
+test('destination.js')
+test('syncfalse.js')
+
+t.test('let error pass through', ({ equal, plan }) => {
+  plan(3)
+  const stream = pino.destination()
+
+  // side effect of the pino constructor is that it will set an
+  // event handler for error
+  pino(stream)
+
+  process.nextTick(() => stream.emit('error', new Error('kaboom')))
+  process.nextTick(() => stream.emit('error', new Error('kaboom')))
+
+  stream.on('error', (err) => {
+    equal(err.message, 'kaboom')
+  })
+})

node_modules/pino/test/browser-levels.test.js

@@ -0,0 +1,218 @@
+'use strict'
+const test = require('tape')
+const pino = require('../browser')
+
+test('set the level by string', ({ end, same, is }) => {
+  const expected = [
+    {
+      level: 50,
+      msg: 'this is an error'
+    },
+    {
+      level: 60,
+      msg: 'this is fatal'
+    }
+  ]
+  const instance = pino({
+    browser: {
+      write (actual) {
+        checkLogObjects(is, same, actual, expected.shift())
+      }
+    }
+  })
+
+  instance.level = 'error'
+  instance.info('hello world')
+  instance.error('this is an error')
+  instance.fatal('this is fatal')
+
+  end()
+})
+
+test('set the level by string. init with silent', ({ end, same, is }) => {
+  const expected = [
+    {
+      level: 50,
+      msg: 'this is an error'
+    },
+    {
+      level: 60,
+      msg: 'this is fatal'
+    }
+  ]
+  const instance = pino({
+    level: 'silent',
+    browser: {
+      write (actual) {
+        checkLogObjects(is, same, actual, expected.shift())
+      }
+    }
+  })
+
+  instance.level = 'error'
+  instance.info('hello world')
+  instance.error('this is an error')
+  instance.fatal('this is fatal')
+
+  end()
+})
+
+test('set the level by string. init with silent and transmit', ({ end, same, is }) => {
+  const expected = [
+    {
+      level: 50,
+      msg: 'this is an error'
+    },
+    {
+      level: 60,
+      msg: 'this is fatal'
+    }
+  ]
+  const instance = pino({
+    level: 'silent',
+    browser: {
+      write (actual) {
+        checkLogObjects(is, same, actual, expected.shift())
+      }
+    },
+    transmit: {
+      send () {}
+    }
+  })
+
+  instance.level = 'error'
+  instance.info('hello world')
+  instance.error('this is an error')
+  instance.fatal('this is fatal')
+
+  end()
+})
+
+test('set the level via constructor', ({ end, same, is }) => {
+  const expected = [
+    {
+      level: 50,
+      msg: 'this is an error'
+    },
+    {
+      level: 60,
+      msg: 'this is fatal'
+    }
+  ]
+  const instance = pino({
+    level: 'error',
+    browser: {
+      write (actual) {
+        checkLogObjects(is, same, actual, expected.shift())
+      }
+    }
+  })
+
+  instance.info('hello world')
+  instance.error('this is an error')
+  instance.fatal('this is fatal')
+
+  end()
+})
+
+test('the wrong level throws', ({ end, throws }) => {
+  const instance = pino()
+  throws(() => {
+    instance.level = 'kaboom'
+  })
+  end()
+})
+
+test('the wrong level by number throws', ({ end, throws }) => {
+  const instance = pino()
+  throws(() => {
+    instance.levelVal = 55
+  })
+  end()
+})
+
+test('exposes level string mappings', ({ end, is }) => {
+  is(pino.levels.values.error, 50)
+  end()
+})
+
+test('exposes level number mappings', ({ end, is }) => {
+  is(pino.levels.labels[50], 'error')
+  end()
+})
+
+test('returns level integer', ({ end, is }) => {
+  const instance = pino({ level: 'error' })
+  is(instance.levelVal, 50)
+  end()
+})
+
+test('silent level via constructor', ({ end, fail }) => {
+  const instance = pino({
+    level: 'silent',
+    browser: {
+      write () {
+        fail('no data should be logged')
+      }
+    }
+  })
+
+  Object.keys(pino.levels.values).forEach((level) => {
+    instance[level]('hello world')
+  })
+
+  end()
+})
+
+test('silent level by string', ({ end, fail }) => {
+  const instance = pino({
+    browser: {
+      write () {
+        fail('no data should be logged')
+      }
+    }
+  })
+
+  instance.level = 'silent'
+
+  Object.keys(pino.levels.values).forEach((level) => {
+    instance[level]('hello world')
+  })
+
+  end()
+})
+
+test('exposed levels', ({ end, same }) => {
+  same(Object.keys(pino.levels.values), [
+    'fatal',
+    'error',
+    'warn',
+    'info',
+    'debug',
+    'trace'
+  ])
+  end()
+})
+
+test('exposed labels', ({ end, same }) => {
+  same(Object.keys(pino.levels.labels), [
+    '10',
+    '20',
+    '30',
+    '40',
+    '50',
+    '60'
+  ])
+  end()
+})
+
+function checkLogObjects (is, same, actual, expected) {
+  is(actual.time <= Date.now(), true, 'time is greater than Date.now()')
+
+  const actualCopy = Object.assign({}, actual)
+  const expectedCopy = Object.assign({}, expected)
+  delete actualCopy.time
+  delete expectedCopy.time
+
+  same(actualCopy, expectedCopy)
+}

node_modules/pino/test/browser-serializers.test.js

@@ -0,0 +1,354 @@
+'use strict'
+// eslint-disable-next-line
+if (typeof $1 !== 'undefined') $1 = arguments.callee.caller.arguments[0]
+
+const test = require('tape')
+const fresh = require('import-fresh')
+const pino = require('../browser')
+
+const parentSerializers = {
+  test: () => 'parent'
+}
+
+const childSerializers = {
+  test: () => 'child'
+}
+
+test('serializers override values', ({ end, is }) => {
+  const parent = pino({
+    serializers: parentSerializers,
+    browser: {
+      serialize: true,
+      write (o) {
+        is(o.test, 'parent')
+        end()
+      }
+    }
+  })
+
+  parent.fatal({ test: 'test' })
+})
+
+test('without the serialize option, serializers do not override values', ({ end, is }) => {
+  const parent = pino({
+    serializers: parentSerializers,
+    browser: {
+      write (o) {
+        is(o.test, 'test')
+        end()
+      }
+    }
+  })
+
+  parent.fatal({ test: 'test' })
+})
+
+if (process.title !== 'browser') {
+  test('if serialize option is true, standard error serializer is auto enabled', ({ end, same }) => {
+    const err = Error('test')
+    err.code = 'test'
+    err.type = 'Error' // get that cov
+    const expect = pino.stdSerializers.err(err)
+
+    const consoleError = console.error
+    console.error = function (err) {
+      same(err, expect)
+    }
+
+    const logger = fresh('../browser')({
+      browser: { serialize: true }
+    })
+
+    console.error = consoleError
+
+    logger.fatal(err)
+    end()
+  })
+
+  test('if serialize option is array, standard error serializer is auto enabled', ({ end, same }) => {
+    const err = Error('test')
+    err.code = 'test'
+    const expect = pino.stdSerializers.err(err)
+
+    const consoleError = console.error
+    console.error = function (err) {
+      same(err, expect)
+    }
+
+    const logger = fresh('../browser', require)({
+      browser: { serialize: [] }
+    })
+
+    console.error = consoleError
+
+    logger.fatal(err)
+    end()
+  })
+
+  test('if serialize option is array containing !stdSerializers.err, standard error serializer is disabled', ({ end, is }) => {
+    const err = Error('test')
+    err.code = 'test'
+    const expect = err
+
+    const consoleError = console.error
+    console.error = function (err) {
+      is(err, expect)
+    }
+
+    const logger = fresh('../browser', require)({
+      browser: { serialize: ['!stdSerializers.err'] }
+    })
+
+    console.error = consoleError
+
+    logger.fatal(err)
+    end()
+  })
+
+  test('in browser, serializers apply to all objects', ({ end, is }) => {
+    const consoleError = console.error
+    console.error = function (test, test2, test3, test4, test5) {
+      is(test.key, 'serialized')
+      is(test2.key2, 'serialized2')
+      is(test5.key3, 'serialized3')
+    }
+
+    const logger = fresh('../browser', require)({
+      serializers: {
+        key: () => 'serialized',
+        key2: () => 'serialized2',
+        key3: () => 'serialized3'
+      },
+      browser: { serialize: true }
+    })
+
+    console.error = consoleError
+
+    logger.fatal({ key: 'test' }, { key2: 'test' }, 'str should skip', [{ foo: 'array should skip' }], { key3: 'test' })
+    end()
+  })
+
+  test('serialize can be an array of selected serializers', ({ end, is }) => {
+    const consoleError = console.error
+    console.error = function (test, test2, test3, test4, test5) {
+      is(test.key, 'test')
+      is(test2.key2, 'serialized2')
+      is(test5.key3, 'test')
+    }
+
+    const logger = fresh('../browser', require)({
+      serializers: {
+        key: () => 'serialized',
+        key2: () => 'serialized2',
+        key3: () => 'serialized3'
+      },
+      browser: { serialize: ['key2'] }
+    })
+
+    console.error = consoleError
+
+    logger.fatal({ key: 'test' }, { key2: 'test' }, 'str should skip', [{ foo: 'array should skip' }], { key3: 'test' })
+    end()
+  })
+
+  test('serialize filter applies to child loggers', ({ end, is }) => {
+    const consoleError = console.error
+    console.error = function (binding, test, test2, test3, test4, test5) {
+      is(test.key, 'test')
+      is(test2.key2, 'serialized2')
+      is(test5.key3, 'test')
+    }
+
+    const logger = fresh('../browser', require)({
+      browser: { serialize: ['key2'] }
+    })
+
+    console.error = consoleError
+
+    logger.child({
+      aBinding: 'test'
+    }, {
+      serializers: {
+        key: () => 'serialized',
+        key2: () => 'serialized2',
+        key3: () => 'serialized3'
+      }
+    }).fatal({ key: 'test' }, { key2: 'test' }, 'str should skip', [{ foo: 'array should skip' }], { key3: 'test' })
+    end()
+  })
+
+  test('serialize filter applies to child loggers through bindings', ({ end, is }) => {
+    const consoleError = console.error
+    console.error = function (binding, test, test2, test3, test4, test5) {
+      is(test.key, 'test')
+      is(test2.key2, 'serialized2')
+      is(test5.key3, 'test')
+    }
+
+    const logger = fresh('../browser', require)({
+      browser: { serialize: ['key2'] }
+    })
+
+    console.error = consoleError
+
+    logger.child({
+      aBinding: 'test',
+      serializers: {
+        key: () => 'serialized',
+        key2: () => 'serialized2',
+        key3: () => 'serialized3'
+      }
+    }).fatal({ key: 'test' }, { key2: 'test' }, 'str should skip', [{ foo: 'array should skip' }], { key3: 'test' })
+    end()
+  })
+
+  test('parent serializers apply to child bindings', ({ end, is }) => {
+    const consoleError = console.error
+    console.error = function (binding) {
+      is(binding.key, 'serialized')
+    }
+
+    const logger = fresh('../browser', require)({
+      serializers: {
+        key: () => 'serialized'
+      },
+      browser: { serialize: true }
+    })
+
+    console.error = consoleError
+
+    logger.child({ key: 'test' }).fatal({ test: 'test' })
+    end()
+  })
+
+  test('child serializers apply to child bindings', ({ end, is }) => {
+    const consoleError = console.error
+    console.error = function (binding) {
+      is(binding.key, 'serialized')
+    }
+
+    const logger = fresh('../browser', require)({
+      browser: { serialize: true }
+    })
+
+    console.error = consoleError
+
+    logger.child({
+      key: 'test'
+    }, {
+      serializers: {
+        key: () => 'serialized'
+      }
+    }).fatal({ test: 'test' })
+    end()
+  })
+}
+
+test('child does not overwrite parent serializers', ({ end, is }) => {
+  let c = 0
+  const parent = pino({
+    serializers: parentSerializers,
+    browser: {
+      serialize: true,
+      write (o) {
+        c++
+        if (c === 1) is(o.test, 'parent')
+        if (c === 2) {
+          is(o.test, 'child')
+          end()
+        }
+      }
+    }
+  })
+  const child = parent.child({}, { serializers: childSerializers })
+
+  parent.fatal({ test: 'test' })
+  child.fatal({ test: 'test' })
+})
+
+test('children inherit parent serializers', ({ end, is }) => {
+  const parent = pino({
+    serializers: parentSerializers,
+    browser: {
+      serialize: true,
+      write (o) {
+        is(o.test, 'parent')
+      }
+    }
+  })
+
+  const child = parent.child({ a: 'property' })
+  child.fatal({ test: 'test' })
+  end()
+})
+
+test('children serializers get called', ({ end, is }) => {
+  const parent = pino({
+    test: 'this',
+    browser: {
+      serialize: true,
+      write (o) {
+        is(o.test, 'child')
+      }
+    }
+  })
+
+  const child = parent.child({ a: 'property' }, { serializers: childSerializers })
+
+  child.fatal({ test: 'test' })
+  end()
+})
+
+test('children serializers get called when inherited from parent', ({ end, is }) => {
+  const parent = pino({
+    test: 'this',
+    serializers: parentSerializers,
+    browser: {
+      serialize: true,
+      write: (o) => {
+        is(o.test, 'pass')
+      }
+    }
+  })
+
+  const child = parent.child({}, { serializers: { test: () => 'pass' } })
+
+  child.fatal({ test: 'fail' })
+  end()
+})
+
+test('non overridden serializers are available in the children', ({ end, is }) => {
+  const pSerializers = {
+    onlyParent: () => 'parent',
+    shared: () => 'parent'
+  }
+
+  const cSerializers = {
+    shared: () => 'child',
+    onlyChild: () => 'child'
+  }
+
+  let c = 0
+
+  const parent = pino({
+    serializers: pSerializers,
+    browser: {
+      serialize: true,
+      write (o) {
+        c++
+        if (c === 1) is(o.shared, 'child')
+        if (c === 2) is(o.onlyParent, 'parent')
+        if (c === 3) is(o.onlyChild, 'child')
+        if (c === 4) is(o.onlyChild, 'test')
+      }
+    }
+  })
+
+  const child = parent.child({}, { serializers: cSerializers })
+
+  child.fatal({ shared: 'test' })
+  child.fatal({ onlyParent: 'test' })
+  child.fatal({ onlyChild: 'test' })
+  parent.fatal({ onlyChild: 'test' })
+  end()
+})

node_modules/pino/test/browser-timestamp.test.js

@@ -0,0 +1,88 @@
+'use strict'
+const test = require('tape')
+const pino = require('../browser')
+
+Date.now = () => 1599400603614
+
+test('null timestamp', ({ end, is }) => {
+  const instance = pino({
+    timestamp: pino.stdTimeFunctions.nullTime,
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.time, undefined)
+      }
+    }
+  })
+  instance.info('hello world')
+  end()
+})
+
+test('iso timestamp', ({ end, is }) => {
+  const instance = pino({
+    timestamp: pino.stdTimeFunctions.isoTime,
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.time, '2020-09-06T13:56:43.614Z')
+      }
+    }
+  })
+  instance.info('hello world')
+  end()
+})
+
+test('epoch timestamp', ({ end, is }) => {
+  const instance = pino({
+    timestamp: pino.stdTimeFunctions.epochTime,
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.time, 1599400603614)
+      }
+    }
+  })
+  instance.info('hello world')
+  end()
+})
+
+test('unix timestamp', ({ end, is }) => {
+  const instance = pino({
+    timestamp: pino.stdTimeFunctions.unixTime,
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.time, Math.round(1599400603614 / 1000.0))
+      }
+    }
+  })
+  instance.info('hello world')
+  end()
+})
+
+test('epoch timestamp by default', ({ end, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.time, 1599400603614)
+      }
+    }
+  })
+  instance.info('hello world')
+  end()
+})
+
+test('not print timestamp if the option is false', ({ end, is }) => {
+  const instance = pino({
+    timestamp: false,
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.time, undefined)
+      }
+    }
+  })
+  instance.info('hello world')
+  end()
+})

node_modules/pino/test/browser-transmit.test.js

@@ -0,0 +1,349 @@
+'use strict'
+const test = require('tape')
+const pino = require('../browser')
+
+function noop () {}
+
+test('throws if transmit object does not have send function', ({ end, throws }) => {
+  throws(() => {
+    pino({ browser: { transmit: {} } })
+  })
+
+  throws(() => {
+    pino({ browser: { transmit: { send: 'not a func' } } })
+  })
+
+  end()
+})
+
+test('calls send function after write', ({ end, is }) => {
+  let c = 0
+  const logger = pino({
+    browser: {
+      write: () => {
+        c++
+      },
+      transmit: {
+        send () { is(c, 1) }
+      }
+    }
+  })
+
+  logger.fatal({ test: 'test' })
+  end()
+})
+
+test('passes send function the logged level', ({ end, is }) => {
+  const logger = pino({
+    browser: {
+      write () {},
+      transmit: {
+        send (level) {
+          is(level, 'fatal')
+        }
+      }
+    }
+  })
+
+  logger.fatal({ test: 'test' })
+  end()
+})
+
+test('passes send function message strings in logEvent object when asObject is not set', ({ end, same, is }) => {
+  const logger = pino({
+    browser: {
+      write: noop,
+      transmit: {
+        send (level, { messages }) {
+          is(messages[0], 'test')
+          is(messages[1], 'another test')
+        }
+      }
+    }
+  })
+
+  logger.fatal('test', 'another test')
+
+  end()
+})
+
+test('passes send function message objects in logEvent object when asObject is not set', ({ end, same, is }) => {
+  const logger = pino({
+    browser: {
+      write: noop,
+      transmit: {
+        send (level, { messages }) {
+          same(messages[0], { test: 'test' })
+          is(messages[1], 'another test')
+        }
+      }
+    }
+  })
+
+  logger.fatal({ test: 'test' }, 'another test')
+
+  end()
+})
+
+test('passes send function message strings in logEvent object when asObject is set', ({ end, same, is }) => {
+  const logger = pino({
+    browser: {
+      asObject: true,
+      write: noop,
+      transmit: {
+        send (level, { messages }) {
+          is(messages[0], 'test')
+          is(messages[1], 'another test')
+        }
+      }
+    }
+  })
+
+  logger.fatal('test', 'another test')
+
+  end()
+})
+
+test('passes send function message objects in logEvent object when asObject is set', ({ end, same, is }) => {
+  const logger = pino({
+    browser: {
+      asObject: true,
+      write: noop,
+      transmit: {
+        send (level, { messages }) {
+          same(messages[0], { test: 'test' })
+          is(messages[1], 'another test')
+        }
+      }
+    }
+  })
+
+  logger.fatal({ test: 'test' }, 'another test')
+
+  end()
+})
+
+test('supplies a timestamp (ts) in logEvent object which is exactly the same as the `time` property in asObject mode', ({ end, is }) => {
+  let expected
+  const logger = pino({
+    browser: {
+      asObject: true, // implicit because `write`, but just to be explicit
+      write (o) {
+        expected = o.time
+      },
+      transmit: {
+        send (level, logEvent) {
+          is(logEvent.ts, expected)
+        }
+      }
+    }
+  })
+
+  logger.fatal('test')
+  end()
+})
+
+test('passes send function child bindings via logEvent object', ({ end, same, is }) => {
+  const logger = pino({
+    browser: {
+      write: noop,
+      transmit: {
+        send (level, logEvent) {
+          const messages = logEvent.messages
+          const bindings = logEvent.bindings
+          same(bindings[0], { first: 'binding' })
+          same(bindings[1], { second: 'binding2' })
+          same(messages[0], { test: 'test' })
+          is(messages[1], 'another test')
+        }
+      }
+    }
+  })
+
+  logger
+    .child({ first: 'binding' })
+    .child({ second: 'binding2' })
+    .fatal({ test: 'test' }, 'another test')
+  end()
+})
+
+test('passes send function level:{label, value} via logEvent object', ({ end, is }) => {
+  const logger = pino({
+    browser: {
+      write: noop,
+      transmit: {
+        send (level, logEvent) {
+          const label = logEvent.level.label
+          const value = logEvent.level.value
+
+          is(label, 'fatal')
+          is(value, 60)
+        }
+      }
+    }
+  })
+
+  logger.fatal({ test: 'test' }, 'another test')
+  end()
+})
+
+test('calls send function according to transmit.level', ({ end, is }) => {
+  let c = 0
+  const logger = pino({
+    browser: {
+      write: noop,
+      transmit: {
+        level: 'error',
+        send (level) {
+          c++
+          if (c === 1) is(level, 'error')
+          if (c === 2) is(level, 'fatal')
+        }
+      }
+    }
+  })
+  logger.warn('ignored')
+  logger.error('test')
+  logger.fatal('test')
+  end()
+})
+
+test('transmit.level defaults to logger level', ({ end, is }) => {
+  let c = 0
+  const logger = pino({
+    level: 'error',
+    browser: {
+      write: noop,
+      transmit: {
+        send (level) {
+          c++
+          if (c === 1) is(level, 'error')
+          if (c === 2) is(level, 'fatal')
+        }
+      }
+    }
+  })
+  logger.warn('ignored')
+  logger.error('test')
+  logger.fatal('test')
+  end()
+})
+
+test('transmit.level is effective even if lower than logger level', ({ end, is }) => {
+  let c = 0
+  const logger = pino({
+    level: 'error',
+    browser: {
+      write: noop,
+      transmit: {
+        level: 'info',
+        send (level) {
+          c++
+          if (c === 1) is(level, 'warn')
+          if (c === 2) is(level, 'error')
+          if (c === 3) is(level, 'fatal')
+        }
+      }
+    }
+  })
+  logger.warn('ignored')
+  logger.error('test')
+  logger.fatal('test')
+  end()
+})
+
+test('applies all serializers to messages and bindings (serialize:false - default)', ({ end, same, is }) => {
+  const logger = pino({
+    serializers: {
+      first: () => 'first',
+      second: () => 'second',
+      test: () => 'serialize it'
+    },
+    browser: {
+      write: noop,
+      transmit: {
+        send (level, logEvent) {
+          const messages = logEvent.messages
+          const bindings = logEvent.bindings
+          same(bindings[0], { first: 'first' })
+          same(bindings[1], { second: 'second' })
+          same(messages[0], { test: 'serialize it' })
+          is(messages[1].type, 'Error')
+        }
+      }
+    }
+  })
+
+  logger
+    .child({ first: 'binding' })
+    .child({ second: 'binding2' })
+    .fatal({ test: 'test' }, Error())
+  end()
+})
+
+test('applies all serializers to messages and bindings (serialize:true)', ({ end, same, is }) => {
+  const logger = pino({
+    serializers: {
+      first: () => 'first',
+      second: () => 'second',
+      test: () => 'serialize it'
+    },
+    browser: {
+      serialize: true,
+      write: noop,
+      transmit: {
+        send (level, logEvent) {
+          const messages = logEvent.messages
+          const bindings = logEvent.bindings
+          same(bindings[0], { first: 'first' })
+          same(bindings[1], { second: 'second' })
+          same(messages[0], { test: 'serialize it' })
+          is(messages[1].type, 'Error')
+        }
+      }
+    }
+  })
+
+  logger
+    .child({ first: 'binding' })
+    .child({ second: 'binding2' })
+    .fatal({ test: 'test' }, Error())
+  end()
+})
+
+test('extracts correct bindings and raw messages over multiple transmits', ({ end, same, is }) => {
+  let messages = null
+  let bindings = null
+
+  const logger = pino({
+    browser: {
+      write: noop,
+      transmit: {
+        send (level, logEvent) {
+          messages = logEvent.messages
+          bindings = logEvent.bindings
+        }
+      }
+    }
+  })
+
+  const child = logger.child({ child: true })
+  const grandchild = child.child({ grandchild: true })
+
+  logger.fatal({ test: 'parent:test1' })
+  logger.fatal({ test: 'parent:test2' })
+  same([], bindings)
+  same([{ test: 'parent:test2' }], messages)
+
+  child.fatal({ test: 'child:test1' })
+  child.fatal({ test: 'child:test2' })
+  same([{ child: true }], bindings)
+  same([{ test: 'child:test2' }], messages)
+
+  grandchild.fatal({ test: 'grandchild:test1' })
+  grandchild.fatal({ test: 'grandchild:test2' })
+  same([{ child: true }, { grandchild: true }], bindings)
+  same([{ test: 'grandchild:test2' }], messages)
+
+  end()
+})

node_modules/pino/test/browser.test.js

@@ -0,0 +1,547 @@
+'use strict'
+const test = require('tape')
+const fresh = require('import-fresh')
+const pinoStdSerializers = require('pino-std-serializers')
+const pino = require('../browser')
+
+levelTest('fatal')
+levelTest('error')
+levelTest('warn')
+levelTest('info')
+levelTest('debug')
+levelTest('trace')
+
+test('silent level', ({ end, fail, pass }) => {
+  const instance = pino({
+    level: 'silent',
+    browser: { write: fail }
+  })
+  instance.info('test')
+  const child = instance.child({ test: 'test' })
+  child.info('msg-test')
+  // use setTimeout because setImmediate isn't supported in most browsers
+  setTimeout(() => {
+    pass()
+    end()
+  }, 0)
+})
+
+test('enabled false', ({ end, fail, pass }) => {
+  const instance = pino({
+    enabled: false,
+    browser: { write: fail }
+  })
+  instance.info('test')
+  const child = instance.child({ test: 'test' })
+  child.info('msg-test')
+  // use setTimeout because setImmediate isn't supported in most browsers
+  setTimeout(() => {
+    pass()
+    end()
+  }, 0)
+})
+
+test('throw if creating child without bindings', ({ end, throws }) => {
+  const instance = pino()
+  throws(() => instance.child())
+  end()
+})
+
+test('stubs write, flush and ee methods on instance', ({ end, ok, is }) => {
+  const instance = pino()
+
+  ok(isFunc(instance.setMaxListeners))
+  ok(isFunc(instance.getMaxListeners))
+  ok(isFunc(instance.emit))
+  ok(isFunc(instance.addListener))
+  ok(isFunc(instance.on))
+  ok(isFunc(instance.prependListener))
+  ok(isFunc(instance.once))
+  ok(isFunc(instance.prependOnceListener))
+  ok(isFunc(instance.removeListener))
+  ok(isFunc(instance.removeAllListeners))
+  ok(isFunc(instance.listeners))
+  ok(isFunc(instance.listenerCount))
+  ok(isFunc(instance.eventNames))
+  ok(isFunc(instance.write))
+  ok(isFunc(instance.flush))
+
+  is(instance.on(), undefined)
+
+  end()
+})
+
+test('exposes levels object', ({ end, same }) => {
+  same(pino.levels, {
+    values: {
+      fatal: 60,
+      error: 50,
+      warn: 40,
+      info: 30,
+      debug: 20,
+      trace: 10
+    },
+    labels: {
+      10: 'trace',
+      20: 'debug',
+      30: 'info',
+      40: 'warn',
+      50: 'error',
+      60: 'fatal'
+    }
+  })
+
+  end()
+})
+
+test('exposes faux stdSerializers', ({ end, ok, same }) => {
+  ok(pino.stdSerializers)
+  // make sure faux stdSerializers match pino-std-serializers
+  for (const serializer in pinoStdSerializers) {
+    ok(pino.stdSerializers[serializer], `pino.stdSerializers.${serializer}`)
+  }
+  // confirm faux methods return empty objects
+  same(pino.stdSerializers.req(), {})
+  same(pino.stdSerializers.mapHttpRequest(), {})
+  same(pino.stdSerializers.mapHttpResponse(), {})
+  same(pino.stdSerializers.res(), {})
+  // confirm wrapping function is a passthrough
+  const noChange = { foo: 'bar', fuz: 42 }
+  same(pino.stdSerializers.wrapRequestSerializer(noChange), noChange)
+  same(pino.stdSerializers.wrapResponseSerializer(noChange), noChange)
+  end()
+})
+
+test('exposes err stdSerializer', ({ end, ok }) => {
+  ok(pino.stdSerializers.err)
+  ok(pino.stdSerializers.err(Error()))
+  end()
+})
+
+consoleMethodTest('error')
+consoleMethodTest('fatal', 'error')
+consoleMethodTest('warn')
+consoleMethodTest('info')
+consoleMethodTest('debug')
+consoleMethodTest('trace')
+absentConsoleMethodTest('error', 'log')
+absentConsoleMethodTest('warn', 'error')
+absentConsoleMethodTest('info', 'log')
+absentConsoleMethodTest('debug', 'log')
+absentConsoleMethodTest('trace', 'log')
+
+// do not run this with airtap
+if (process.title !== 'browser') {
+  test('in absence of console, log methods become noops', ({ end, ok }) => {
+    const console = global.console
+    delete global.console
+    const instance = fresh('../browser')()
+    global.console = console
+    ok(fnName(instance.log).match(/noop/))
+    ok(fnName(instance.fatal).match(/noop/))
+    ok(fnName(instance.error).match(/noop/))
+    ok(fnName(instance.warn).match(/noop/))
+    ok(fnName(instance.info).match(/noop/))
+    ok(fnName(instance.debug).match(/noop/))
+    ok(fnName(instance.trace).match(/noop/))
+    end()
+  })
+}
+
+test('opts.browser.asObject logs pino-like object to console', ({ end, ok, is }) => {
+  const info = console.info
+  console.info = function (o) {
+    is(o.level, 30)
+    is(o.msg, 'test')
+    ok(o.time)
+    console.info = info
+  }
+  const instance = require('../browser')({
+    browser: {
+      asObject: true
+    }
+  })
+
+  instance.info('test')
+  end()
+})
+
+test('opts.browser.write func log single string', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      write: function (o) {
+        is(o.level, 30)
+        is(o.msg, 'test')
+        ok(o.time)
+      }
+    }
+  })
+  instance.info('test')
+
+  end()
+})
+
+test('opts.browser.write func string joining', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      write: function (o) {
+        is(o.level, 30)
+        is(o.msg, 'test test2 test3')
+        ok(o.time)
+      }
+    }
+  })
+  instance.info('test %s %s', 'test2', 'test3')
+
+  end()
+})
+
+test('opts.browser.write func string joining when asObject is true', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.level, 30)
+        is(o.msg, 'test test2 test3')
+        ok(o.time)
+      }
+    }
+  })
+  instance.info('test %s %s', 'test2', 'test3')
+
+  end()
+})
+
+test('opts.browser.write func string joining when asObject is true', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.level, 30)
+        is(o.msg, 'test test2 test3')
+        ok(o.time)
+      }
+    }
+  })
+  instance.info('test %s %s', 'test2', 'test3')
+
+  end()
+})
+
+test('opts.browser.write func string object joining', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      write: function (o) {
+        is(o.level, 30)
+        is(o.msg, 'test {"test":"test2"} {"test":"test3"}')
+        ok(o.time)
+      }
+    }
+  })
+  instance.info('test %j %j', { test: 'test2' }, { test: 'test3' })
+
+  end()
+})
+
+test('opts.browser.write func string object joining when asObject is true', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      asObject: true,
+      write: function (o) {
+        is(o.level, 30)
+        is(o.msg, 'test {"test":"test2"} {"test":"test3"}')
+        ok(o.time)
+      }
+    }
+  })
+  instance.info('test %j %j', { test: 'test2' }, { test: 'test3' })
+
+  end()
+})
+
+test('opts.browser.write func string interpolation', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      write: function (o) {
+        is(o.level, 30)
+        is(o.msg, 'test2 test ({"test":"test3"})')
+        ok(o.time)
+      }
+    }
+  })
+  instance.info('%s test (%j)', 'test2', { test: 'test3' })
+
+  end()
+})
+
+test('opts.browser.write func number', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      write: function (o) {
+        is(o.level, 30)
+        is(o.msg, 1)
+        ok(o.time)
+      }
+    }
+  })
+  instance.info(1)
+
+  end()
+})
+
+test('opts.browser.write func log single object', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      write: function (o) {
+        is(o.level, 30)
+        is(o.test, 'test')
+        ok(o.time)
+      }
+    }
+  })
+  instance.info({ test: 'test' })
+
+  end()
+})
+
+test('opts.browser.write obj writes to methods corresponding to level', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      write: {
+        error: function (o) {
+          is(o.level, 50)
+          is(o.test, 'test')
+          ok(o.time)
+        }
+      }
+    }
+  })
+  instance.error({ test: 'test' })
+
+  end()
+})
+
+test('opts.browser.asObject/write supports child loggers', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      write (o) {
+        is(o.level, 30)
+        is(o.test, 'test')
+        is(o.msg, 'msg-test')
+        ok(o.time)
+      }
+    }
+  })
+  const child = instance.child({ test: 'test' })
+  child.info('msg-test')
+
+  end()
+})
+
+test('opts.browser.asObject/write supports child child loggers', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      write (o) {
+        is(o.level, 30)
+        is(o.test, 'test')
+        is(o.foo, 'bar')
+        is(o.msg, 'msg-test')
+        ok(o.time)
+      }
+    }
+  })
+  const child = instance.child({ test: 'test' }).child({ foo: 'bar' })
+  child.info('msg-test')
+
+  end()
+})
+
+test('opts.browser.asObject/write supports child child child loggers', ({ end, ok, is }) => {
+  const instance = pino({
+    browser: {
+      write (o) {
+        is(o.level, 30)
+        is(o.test, 'test')
+        is(o.foo, 'bar')
+        is(o.baz, 'bop')
+        is(o.msg, 'msg-test')
+        ok(o.time)
+      }
+    }
+  })
+  const child = instance.child({ test: 'test' }).child({ foo: 'bar' }).child({ baz: 'bop' })
+  child.info('msg-test')
+
+  end()
+})
+
+test('opts.browser.asObject defensively mitigates naughty numbers', ({ end, pass }) => {
+  const instance = pino({
+    browser: { asObject: true, write: () => {} }
+  })
+  const child = instance.child({ test: 'test' })
+  child._childLevel = -10
+  child.info('test')
+  pass() // if we reached here, there was no infinite loop, so, .. pass.
+
+  end()
+})
+
+test('opts.browser.write obj falls back to console where a method is not supplied', ({ end, ok, is }) => {
+  const info = console.info
+  console.info = (o) => {
+    is(o.level, 30)
+    is(o.msg, 'test')
+    ok(o.time)
+    console.info = info
+  }
+  const instance = require('../browser')({
+    browser: {
+      write: {
+        error (o) {
+          is(o.level, 50)
+          is(o.test, 'test')
+          ok(o.time)
+        }
+      }
+    }
+  })
+  instance.error({ test: 'test' })
+  instance.info('test')
+
+  end()
+})
+
+function levelTest (name) {
+  test(name + ' logs', ({ end, is }) => {
+    const msg = 'hello world'
+    sink(name, (args) => {
+      is(args[0], msg)
+      end()
+    })
+    pino({ level: name })[name](msg)
+  })
+
+  test('passing objects at level ' + name, ({ end, is }) => {
+    const msg = { hello: 'world' }
+    sink(name, (args) => {
+      is(args[0], msg)
+      end()
+    })
+    pino({ level: name })[name](msg)
+  })
+
+  test('passing an object and a string at level ' + name, ({ end, is }) => {
+    const a = { hello: 'world' }
+    const b = 'a string'
+    sink(name, (args) => {
+      is(args[0], a)
+      is(args[1], b)
+      end()
+    })
+    pino({ level: name })[name](a, b)
+  })
+
+  test('formatting logs as ' + name, ({ end, is }) => {
+    sink(name, (args) => {
+      is(args[0], 'hello %d')
+      is(args[1], 42)
+      end()
+    })
+    pino({ level: name })[name]('hello %d', 42)
+  })
+
+  test('passing error at level ' + name, ({ end, is }) => {
+    const err = new Error('myerror')
+    sink(name, (args) => {
+      is(args[0], err)
+      end()
+    })
+    pino({ level: name })[name](err)
+  })
+
+  test('passing error with a serializer at level ' + name, ({ end, is }) => {
+    // in browser - should have no effect (should not crash)
+    const err = new Error('myerror')
+    sink(name, (args) => {
+      is(args[0].err, err)
+      end()
+    })
+    const instance = pino({
+      level: name,
+      serializers: {
+        err: pino.stdSerializers.err
+      }
+    })
+    instance[name]({ err })
+  })
+
+  test('child logger for level ' + name, ({ end, is }) => {
+    const msg = 'hello world'
+    const parent = { hello: 'world' }
+    sink(name, (args) => {
+      is(args[0], parent)
+      is(args[1], msg)
+      end()
+    })
+    const instance = pino({ level: name })
+    const child = instance.child(parent)
+    child[name](msg)
+  })
+
+  test('child-child logger for level ' + name, ({ end, is }) => {
+    const msg = 'hello world'
+    const grandParent = { hello: 'world' }
+    const parent = { hello: 'you' }
+    sink(name, (args) => {
+      is(args[0], grandParent)
+      is(args[1], parent)
+      is(args[2], msg)
+      end()
+    })
+    const instance = pino({ level: name })
+    const child = instance.child(grandParent).child(parent)
+    child[name](msg)
+  })
+}
+
+function consoleMethodTest (level, method) {
+  if (!method) method = level
+  test('pino().' + level + ' uses console.' + method, ({ end, is }) => {
+    sink(method, (args) => {
+      is(args[0], 'test')
+      end()
+    })
+    const instance = require('../browser')({ level })
+    instance[level]('test')
+  })
+}
+
+function absentConsoleMethodTest (method, fallback) {
+  test('in absence of console.' + method + ', console.' + fallback + ' is used', ({ end, is }) => {
+    const fn = console[method]
+    console[method] = undefined
+    sink(fallback, function (args) {
+      is(args[0], 'test')
+      end()
+      console[method] = fn
+    })
+    const instance = require('../browser')({ level: method })
+    instance[method]('test')
+  })
+}
+
+function isFunc (fn) { return typeof fn === 'function' }
+function fnName (fn) {
+  const rx = /^\s*function\s*([^(]*)/i
+  const match = rx.exec(fn)
+  return match && match[1]
+}
+function sink (method, fn) {
+  if (method === 'fatal') method = 'error'
+  const orig = console[method]
+  console[method] = function () {
+    console[method] = orig
+    fn(Array.prototype.slice.call(arguments))
+  }
+}

node_modules/pino/test/complex-objects.test.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const { test } = require('tap')
+const { sink, once } = require('./helper')
+const { PassThrough } = require('stream')
+const pino = require('../')
+
+test('Proxy and stream objects', async ({ equal }) => {
+  const s = new PassThrough()
+  s.resume()
+  s.write('', () => {})
+  const obj = { s, p: new Proxy({}, { get () { throw new Error('kaboom') } }) }
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info({ obj })
+
+  const result = await once(stream, 'data')
+
+  equal(result.obj, '[unable to serialize, circular reference is too complex to analyze]')
+})
+
+test('Proxy and stream objects', async ({ equal }) => {
+  const s = new PassThrough()
+  s.resume()
+  s.write('', () => {})
+  const obj = { s, p: new Proxy({}, { get () { throw new Error('kaboom') } }) }
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info(obj)
+
+  const result = await once(stream, 'data')
+
+  equal(result.p, '[unable to serialize, circular reference is too complex to analyze]')
+})

node_modules/pino/test/crlf.test.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const { test } = require('tap')
+const writer = require('flush-write-stream')
+const pino = require('../')
+
+function capture () {
+  const ws = writer((chunk, enc, cb) => {
+    ws.data += chunk.toString()
+    cb()
+  })
+  ws.data = ''
+  return ws
+}
+
+test('pino uses LF by default', async ({ ok }) => {
+  const stream = capture()
+  const logger = pino(stream)
+  logger.info('foo')
+  logger.error('bar')
+  ok(/foo[^\r\n]+\n[^\r\n]+bar[^\r\n]+\n/.test(stream.data))
+})
+
+test('pino can log CRLF', async ({ ok }) => {
+  const stream = capture()
+  const logger = pino({
+    crlf: true
+  }, stream)
+  logger.info('foo')
+  logger.error('bar')
+  ok(/foo[^\n]+\r\n[^\n]+bar[^\n]+\r\n/.test(stream.data))
+})

node_modules/pino/test/custom-levels.test.js

@@ -0,0 +1,294 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const { test } = require('tap')
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+// Silence all warnings for this test
+process.removeAllListeners('warning')
+process.on('warning', () => {})
+
+test('adds additional levels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35,
+      bar: 45
+    }
+  }, stream)
+
+  logger.foo('test')
+  const { level } = await once(stream, 'data')
+  equal(level, 35)
+})
+
+test('custom levels does not override default levels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    }
+  }, stream)
+
+  logger.info('test')
+  const { level } = await once(stream, 'data')
+  equal(level, 30)
+})
+
+test('default levels can be redefined using custom levels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      info: 35,
+      debug: 45
+    },
+    useOnlyCustomLevels: true
+  }, stream)
+
+  equal(logger.hasOwnProperty('info'), true)
+
+  logger.info('test')
+  const { level } = await once(stream, 'data')
+  equal(level, 35)
+})
+
+test('custom levels overrides default level label if use useOnlyCustomLevels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    },
+    useOnlyCustomLevels: true,
+    level: 'foo'
+  }, stream)
+
+  equal(logger.hasOwnProperty('info'), false)
+})
+
+test('custom levels overrides default level value if use useOnlyCustomLevels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    },
+    useOnlyCustomLevels: true,
+    level: 35
+  }, stream)
+
+  equal(logger.hasOwnProperty('info'), false)
+})
+
+test('custom levels are inherited by children', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    }
+  }, stream)
+
+  logger.child({ childMsg: 'ok' }).foo('test')
+  const { msg, childMsg, level } = await once(stream, 'data')
+  equal(level, 35)
+  equal(childMsg, 'ok')
+  equal(msg, 'test')
+})
+
+test('custom levels can be specified on child bindings', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino(stream).child({
+    childMsg: 'ok'
+  }, {
+    customLevels: {
+      foo: 35
+    }
+  })
+
+  logger.foo('test')
+  const { msg, childMsg, level } = await once(stream, 'data')
+  equal(level, 35)
+  equal(childMsg, 'ok')
+  equal(msg, 'test')
+})
+
+test('customLevels property child bindings does not get logged', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino(stream).child({
+    childMsg: 'ok'
+  }, {
+    customLevels: {
+      foo: 35
+    }
+  })
+
+  logger.foo('test')
+  const { customLevels } = await once(stream, 'data')
+  equal(customLevels, undefined)
+})
+
+test('throws when specifying pre-existing parent labels via child bindings', async ({ throws }) => {
+  const stream = sink()
+  throws(() => pino({
+    customLevels: {
+      foo: 35
+    }
+  }, stream).child({}, {
+    customLevels: {
+      foo: 45
+    }
+  }), 'levels cannot be overridden')
+})
+
+test('throws when specifying pre-existing parent values via child bindings', async ({ throws }) => {
+  const stream = sink()
+  throws(() => pino({
+    customLevels: {
+      foo: 35
+    }
+  }, stream).child({}, {
+    customLevels: {
+      bar: 35
+    }
+  }), 'pre-existing level values cannot be used for new levels')
+})
+
+test('throws when specifying core values via child bindings', async ({ throws }) => {
+  const stream = sink()
+  throws(() => pino(stream).child({}, {
+    customLevels: {
+      foo: 30
+    }
+  }), 'pre-existing level values cannot be used for new levels')
+})
+
+test('throws when useOnlyCustomLevels is set true without customLevels', async ({ throws }) => {
+  const stream = sink()
+  throws(() => pino({
+    useOnlyCustomLevels: true
+  }, stream), 'customLevels is required if useOnlyCustomLevels is set true')
+})
+
+test('custom level on one instance does not affect other instances', async ({ equal }) => {
+  pino({
+    customLevels: {
+      foo: 37
+    }
+  })
+  equal(typeof pino().foo, 'undefined')
+})
+
+test('setting level below or at custom level will successfully log', async ({ equal }) => {
+  const stream = sink()
+  const instance = pino({ customLevels: { foo: 35 } }, stream)
+  instance.level = 'foo'
+  instance.info('nope')
+  instance.foo('bar')
+  const { msg } = await once(stream, 'data')
+  equal(msg, 'bar')
+})
+
+test('custom level below level threshold will not log', async ({ equal }) => {
+  const stream = sink()
+  const instance = pino({ customLevels: { foo: 15 } }, stream)
+  instance.level = 'info'
+  instance.info('bar')
+  instance.foo('nope')
+  const { msg } = await once(stream, 'data')
+  equal(msg, 'bar')
+})
+
+test('does not share custom level state across siblings', async ({ doesNotThrow }) => {
+  const stream = sink()
+  const logger = pino(stream)
+  logger.child({}, {
+    customLevels: { foo: 35 }
+  })
+  doesNotThrow(() => {
+    logger.child({}, {
+      customLevels: { foo: 35 }
+    })
+  })
+})
+
+test('custom level does not affect the levels serializer', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      foo: 35,
+      bar: 45
+    },
+    formatters: {
+      level (label, number) {
+        return { priority: number }
+      }
+    }
+  }, stream)
+
+  logger.foo('test')
+  const { priority } = await once(stream, 'data')
+  equal(priority, 35)
+})
+
+test('When useOnlyCustomLevels is set to true, the level formatter should only get custom levels', async ({ equal }) => {
+  const stream = sink()
+  const logger = pino({
+    customLevels: {
+      answer: 42
+    },
+    useOnlyCustomLevels: true,
+    level: 42,
+    formatters: {
+      level (label, number) {
+        equal(label, 'answer')
+        equal(number, 42)
+        return { level: number }
+      }
+    }
+  }, stream)
+
+  logger.answer('test')
+  const { level } = await once(stream, 'data')
+  equal(level, 42)
+})
+
+test('custom levels accessible in prettifier function', async ({ plan, same }) => {
+  plan(1)
+  const logger = pino({
+    prettyPrint: true,
+    prettifier: function prettifierFactory () {
+      const instance = this
+      return function () {
+        same(instance.levels, {
+          labels: {
+            10: 'trace',
+            20: 'debug',
+            30: 'info',
+            35: 'foo',
+            40: 'warn',
+            45: 'bar',
+            50: 'error',
+            60: 'fatal'
+          },
+          values: {
+            trace: 10,
+            debug: 20,
+            info: 30,
+            warn: 40,
+            error: 50,
+            fatal: 60,
+            foo: 35,
+            bar: 45
+          }
+        })
+      }
+    },
+    customLevels: {
+      foo: 35,
+      bar: 45
+    },
+    changeLevelName: 'priority'
+  })
+
+  logger.foo('test')
+})

node_modules/pino/test/deprecations.test.js

@@ -0,0 +1,242 @@
+'use strict'
+/* eslint no-prototype-builtins: 0 */
+
+const { hostname } = require('os')
+const { test } = require('tap')
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+process.removeAllListeners('warning')
+
+test('useLevelLabels', async ({ match, equal }) => {
+  process.on('warning', onWarning)
+  function onWarning (warn) {
+    equal(warn.code, 'PINODEP001')
+  }
+
+  const stream = sink()
+  const logger = pino({
+    useLevelLabels: true
+  }, stream)
+
+  const o = once(stream, 'data')
+  logger.info('hello world')
+  match(await o, { level: 'info' })
+  process.removeListener('warning', onWarning)
+})
+
+test('changeLevelName', async ({ match, equal }) => {
+  process.on('warning', onWarning)
+  function onWarning (warn) {
+    equal(warn.code, 'PINODEP002')
+  }
+
+  const stream = sink()
+  const logger = pino({
+    changeLevelName: 'priority'
+  }, stream)
+
+  const o = once(stream, 'data')
+  logger.info('hello world')
+  match(await o, { priority: 30 })
+  process.removeListener('warning', onWarning)
+})
+
+test('levelKey', async ({ match, equal }) => {
+  process.on('warning', onWarning)
+  function onWarning (warn) {
+    equal(warn.code, 'PINODEP002')
+  }
+
+  const stream = sink()
+  const logger = pino({
+    levelKey: 'priority'
+  }, stream)
+
+  const o = once(stream, 'data')
+  logger.info('hello world')
+  match(await o, { priority: 30 })
+  process.removeListener('warning', onWarning)
+})
+
+test('useLevelLabels and changeLevelName', async ({ match, equal }) => {
+  let count = 0
+  process.on('warning', onWarning)
+  function onWarning (warn) {
+    equal(warn.code, count === 0 ? 'PINODEP001' : 'PINODEP002')
+    count += 1
+  }
+
+  const stream = sink()
+  const logger = pino({
+    changeLevelName: 'priority',
+    useLevelLabels: true
+  }, stream)
+
+  const o = once(stream, 'data')
+  logger.info('hello world')
+  match(await o, { priority: 'info' })
+  process.removeListener('warning', onWarning)
+})
+
+test('pino.* serializer', async ({ match, equal, pass }) => {
+  process.on('warning', onWarning)
+  function onWarning (warn) {
+    equal(warn.code, 'PINODEP003')
+  }
+
+  const stream = sink()
+  const logger = pino({
+    serializers: {
+      [Symbol.for('pino.*')] (log) {
+        pass('called')
+        return log
+      }
+    }
+  }, stream)
+
+  const o = once(stream, 'data')
+  logger.info('hello world')
+  match(await o, { level: 30 })
+  process.removeListener('warning', onWarning)
+})
+
+test('child(bindings.serializers)', async ({ match, equal, pass }) => {
+  process.on('warning', onWarning)
+  function onWarning (warn) {
+    equal(warn.code, 'PINODEP004')
+  }
+
+  const stream = sink()
+  const parent = pino({ serializers: { test: () => 'parent' } }, stream)
+  const child = parent.child({
+    serializers: {
+      test () {
+        pass('called')
+        return 'child'
+      }
+    }
+  })
+
+  const o = once(stream, 'data')
+  child.fatal({ test: 'test' })
+  match(await o, { test: 'child' })
+  process.removeListener('warning', onWarning)
+})
+
+test('child(bindings.formatters)', async ({ match, equal, pass }) => {
+  process.on('warning', onWarning)
+  function onWarning (warn) {
+    equal(warn.code, 'PINODEP005')
+  }
+
+  const stream = sink()
+  const logger = pino({
+    formatters: {
+      level (label, number) {
+        return {
+          log: {
+            level: label
+          }
+        }
+      },
+      bindings (bindings) {
+        return {
+          process: {
+            pid: bindings.pid
+          },
+          host: {
+            name: bindings.hostname
+          }
+        }
+      },
+      log (obj) {
+        return { hello: 'world', ...obj }
+      }
+    }
+  }, stream)
+
+  const child = logger.child({
+    foo: 'bar',
+    nested: { object: true },
+    formatters: {
+      bindings (bindings) {
+        pass('called')
+        return { ...bindings, faz: 'baz' }
+      }
+    }
+  })
+
+  const o = once(stream, 'data')
+  child.info('hello world')
+  match(await o, {
+    log: {
+      level: 'info'
+    },
+    process: {
+      pid: process.pid
+    },
+    host: {
+      name: hostname()
+    },
+    hello: 'world',
+    foo: 'bar',
+    nested: { object: true },
+    faz: 'baz'
+  })
+  process.removeListener('warning', onWarning)
+})
+
+test('child(bindings.customLevels)', async ({ match, equal, pass }) => {
+  process.on('warning', onWarning)
+  function onWarning (warn) {
+    equal(warn.code, 'PINODEP006')
+  }
+
+  const stream = sink()
+  const logger = pino(stream).child({
+    childMsg: 'ok',
+    customLevels: {
+      foo: 35
+    }
+  }, {
+    formatters: {
+      level (label, number) {
+        if (label === 'foo' && number === 35) {
+          pass('using customLevels')
+        }
+        return { level: number }
+      }
+    }
+  })
+
+  const o = once(stream, 'data')
+  logger.foo('test')
+  match(await o, {
+    level: 35,
+    childMsg: 'ok',
+    msg: 'test'
+  })
+  process.removeListener('warning', onWarning)
+})
+
+test('child(bindings.level)', async ({ equal, pass }) => {
+  process.on('warning', onWarning)
+  function onWarning (warn) {
+    equal(warn.code, 'PINODEP007')
+  }
+
+  const stream = sink()
+  const logger = pino({
+    level: 'info'
+  }, stream).child({
+    level: 'trace'
+  })
+
+  const o = once(stream, 'data')
+  logger.info('test')
+  if (await o === null) {
+    pass('child can overrid parent level')
+  }
+  process.removeListener('warning', onWarning)
+})

node_modules/pino/test/error.test.js

@@ -0,0 +1,173 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const os = require('os')
+const { test } = require('tap')
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+const { pid } = process
+const hostname = os.hostname()
+const level = 50
+const name = 'error'
+
+test('err is serialized with additional properties set on the Error object', async ({ ok, same }) => {
+  const stream = sink()
+  const err = Object.assign(new Error('myerror'), { foo: 'bar' })
+  const instance = pino(stream)
+  instance.level = name
+  instance[name](err)
+  const result = await once(stream, 'data')
+  ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level,
+    type: 'Error',
+    msg: err.message,
+    stack: err.stack,
+    foo: err.foo
+  })
+})
+
+test('type should be retained, even if type is a property', async ({ ok, same }) => {
+  const stream = sink()
+  const err = Object.assign(new Error('myerror'), { type: 'bar' })
+  const instance = pino(stream)
+  instance.level = name
+  instance[name](err)
+  const result = await once(stream, 'data')
+  ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level,
+    type: 'bar',
+    msg: err.message,
+    stack: err.stack
+  })
+})
+
+test('type, message and stack should be first level properties', async ({ ok, same }) => {
+  const stream = sink()
+  const err = Object.assign(new Error('foo'), { foo: 'bar' })
+  const instance = pino(stream)
+  instance.level = name
+  instance[name](err)
+
+  const result = await once(stream, 'data')
+  ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level,
+    type: 'Error',
+    msg: err.message,
+    stack: err.stack,
+    foo: err.foo
+  })
+})
+
+test('err serializer', async ({ ok, same }) => {
+  const stream = sink()
+  const err = Object.assign(new Error('myerror'), { foo: 'bar' })
+  const instance = pino({
+    serializers: {
+      err: pino.stdSerializers.err
+    }
+  }, stream)
+
+  instance.level = name
+  instance[name]({ err })
+  const result = await once(stream, 'data')
+  ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level,
+    err: {
+      type: 'Error',
+      message: err.message,
+      stack: err.stack,
+      foo: err.foo
+    }
+  })
+})
+
+test('an error with statusCode property is not confused for a http response', async ({ ok, same }) => {
+  const stream = sink()
+  const err = Object.assign(new Error('StatusCodeErr'), { statusCode: 500 })
+  const instance = pino(stream)
+
+  instance.level = name
+  instance[name](err)
+  const result = await once(stream, 'data')
+
+  ok(new Date(result.time) <= new Date(), 'time is greater than Date.now()')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level,
+    type: 'Error',
+    msg: err.message,
+    stack: err.stack,
+    statusCode: err.statusCode
+  })
+})
+
+test('stack is omitted if it is not set on err', t => {
+  t.plan(2)
+  const err = new Error('myerror')
+  delete err.stack
+  const instance = pino(sink(function (chunk, enc, cb) {
+    t.ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    t.equal(chunk.hasOwnProperty('stack'), false)
+    cb()
+  }))
+
+  instance.level = name
+  instance[name](err)
+})
+
+test('stack is rendered as any other property if it\'s not a string', t => {
+  t.plan(3)
+  const err = new Error('myerror')
+  err.stack = null
+  const instance = pino(sink(function (chunk, enc, cb) {
+    t.ok(new Date(chunk.time) <= new Date(), 'time is greater than Date.now()')
+    delete chunk.time
+    t.equal(chunk.hasOwnProperty('stack'), true)
+    t.equal(chunk.stack, null)
+    cb()
+  }))
+
+  instance.level = name
+  instance[name](err)
+})
+
+test('correctly ignores toString on errors', async ({ same }) => {
+  const err = new Error('myerror')
+  err.toString = () => undefined
+  const stream = sink()
+  const instance = pino({
+    test: 'this'
+  }, stream)
+  instance.fatal(err)
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    type: 'Error',
+    msg: err.message,
+    stack: err.stack
+  })
+})

node_modules/pino/test/escaping.test.js

@@ -0,0 +1,91 @@
+'use strict'
+
+const os = require('os')
+const { test } = require('tap')
+const { sink, once } = require('./helper')
+const pino = require('../')
+
+const { pid } = process
+const hostname = os.hostname()
+
+function testEscape (ch, key) {
+  test('correctly escape ' + ch, async ({ same }) => {
+    const stream = sink()
+    const instance = pino({
+      name: 'hello'
+    }, stream)
+    instance.fatal('this contains ' + key)
+    const result = await once(stream, 'data')
+    delete result.time
+    same(result, {
+      pid,
+      hostname,
+      level: 60,
+      name: 'hello',
+      msg: 'this contains ' + key
+    })
+  })
+}
+
+testEscape('\\n', '\n')
+testEscape('\\/', '/')
+testEscape('\\\\', '\\')
+testEscape('\\r', '\r')
+testEscape('\\t', '\t')
+testEscape('\\b', '\b')
+
+const toEscape = [
+  '\u0000', // NUL  Null character
+  '\u0001', // SOH  Start of Heading
+  '\u0002', // STX  Start of Text
+  '\u0003', // ETX  End-of-text character
+  '\u0004', // EOT  End-of-transmission character
+  '\u0005', // ENQ  Enquiry character
+  '\u0006', // ACK  Acknowledge character
+  '\u0007', // BEL  Bell character
+  '\u0008', // BS   Backspace
+  '\u0009', // HT   Horizontal tab
+  '\u000A', // LF   Line feed
+  '\u000B', // VT   Vertical tab
+  '\u000C', // FF   Form feed
+  '\u000D', // CR   Carriage return
+  '\u000E', // SO   Shift Out
+  '\u000F', // SI   Shift In
+  '\u0010', // DLE  Data Link Escape
+  '\u0011', // DC1  Device Control 1
+  '\u0012', // DC2  Device Control 2
+  '\u0013', // DC3  Device Control 3
+  '\u0014', // DC4  Device Control 4
+  '\u0015', // NAK  Negative-acknowledge character
+  '\u0016', // SYN  Synchronous Idle
+  '\u0017', // ETB  End of Transmission Block
+  '\u0018', // CAN  Cancel character
+  '\u0019', // EM   End of Medium
+  '\u001A', // SUB  Substitute character
+  '\u001B', // ESC  Escape character
+  '\u001C', // FS   File Separator
+  '\u001D', // GS   Group Separator
+  '\u001E', // RS   Record Separator
+  '\u001F' // US   Unit Separator
+]
+
+toEscape.forEach((key) => {
+  testEscape(JSON.stringify(key), key)
+})
+
+test('correctly escape `hello \\u001F world \\n \\u0022`', async ({ same }) => {
+  const stream = sink()
+  const instance = pino({
+    name: 'hello'
+  }, stream)
+  instance.fatal('hello \u001F world \n \u0022')
+  const result = await once(stream, 'data')
+  delete result.time
+  same(result, {
+    pid,
+    hostname,
+    level: 60,
+    name: 'hello',
+    msg: 'hello \u001F world \n \u0022'
+  })
+})

node_modules/pino/test/esm/esm.mjs

@@ -0,0 +1,12 @@
+import t from 'tap'
+import pino from '../../pino.js'
+import helper from '../helper.js'
+
+const { sink, check, once } = helper
+
+t.test('esm support', async ({ equal }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info('hello world')
+  check(equal, await once(stream, 'data'), 30, 'hello world')
+})

node_modules/pino/test/esm/index.test.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const t = require('tap')
+const semver = require('semver')
+
+if (!semver.satisfies(process.versions.node, '^13.3.0 || ^12.10.0 || >= 14.0.0')) {
+  t.skip('Skip esm because not supported by Node')
+} else {
+  // Node v8 throw a `SyntaxError: Unexpected token import`
+  // even if this branch is never touch in the code,
+  // by using `eval` we can avoid this issue.
+  // eslint-disable-next-line
+  new Function('module', 'return import(module)')('./esm.mjs').catch((err) => {
+    process.nextTick(() => {
+      throw err
+    })
+  })
+}
+
+if (!semver.satisfies(process.versions.node, '>= 14.13.0 || ^12.20.0')) {
+  t.skip('Skip named exports because not supported by Node')
+} else {
+  // Node v8 throw a `SyntaxError: Unexpected token import`
+  // even if this branch is never touch in the code,
+  // by using `eval` we can avoid this issue.
+  // eslint-disable-next-line
+  new Function('module', 'return import(module)')('./named-exports.mjs').catch((err) => {
+    process.nextTick(() => {
+      throw err
+    })
+  })
+}

node_modules/pino/test/esm/named-exports.mjs

@@ -0,0 +1,31 @@
+import { tmpdir, hostname } from 'os'
+import t from 'tap'
+import { sink, check, once, watchFileCreated } from '../helper.js'
+import { pino, destination } from '../../pino.js'
+import { join } from 'path'
+import { readFileSync } from 'fs'
+
+t.test('named exports support', async ({ equal }) => {
+  const stream = sink()
+  const instance = pino(stream)
+  instance.info('hello world')
+  check(equal, await once(stream, 'data'), 30, 'hello world')
+})
+
+t.test('destination', async ({ same }) => {
+  const tmp = join(
+    tmpdir(),
+    '_' + Math.random().toString(36).substr(2, 9)
+  )
+  const instance = pino(destination(tmp))
+  instance.info('hello')
+  await watchFileCreated(tmp)
+  const result = JSON.parse(readFileSync(tmp).toString())
+  delete result.time
+  same(result, {
+    pid: process.pid,
+    hostname,
+    level: 30,
+    msg: 'hello'
+  })
+})

node_modules/pino/test/exit.test.js

@@ -0,0 +1,68 @@
+'use strict'
+
+const { test } = require('tap')
+const { join } = require('path')
+const execa = require('execa')
+const writer = require('flush-write-stream')
+const { once } = require('./helper')
+
+// https://github.com/pinojs/pino/issues/542
+test('pino.destination log everything when calling process.exit(0)', async ({ not }) => {
+  let actual = ''
+  const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'destination-exit.js')])
+
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+
+  await once(child, 'close')
+
+  not(actual.match(/hello/), null)
+  not(actual.match(/world/), null)
+})
+
+test('pino with no args log everything when calling process.exit(0)', async ({ not }) => {
+  let actual = ''
+  const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'default-exit.js')])
+
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+
+  await once(child, 'close')
+
+  not(actual.match(/hello/), null)
+  not(actual.match(/world/), null)
+})
+
+test('sync false does not log everything when calling process.exit(0)', async ({ equal }) => {
+  let actual = ''
+  const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'syncfalse-exit.js')])
+
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+
+  await once(child, 'close')
+
+  equal(actual.match(/hello/), null)
+  equal(actual.match(/world/), null)
+})
+
+test('sync false logs everything when calling flushSync', async ({ not }) => {
+  let actual = ''
+  const child = execa(process.argv[0], [join(__dirname, 'fixtures', 'syncfalse-flush-exit.js')])
+
+  child.stdout.pipe(writer((s, enc, cb) => {
+    actual += s
+    cb()
+  }))
+
+  await once(child, 'close')
+
+  not(actual.match(/hello/), null)
+  not(actual.match(/world/), null)
+})

node_modules/pino/test/final.test.js

@@ -0,0 +1,182 @@
+'use strict'
+const pino = require('..')
+const fs = require('fs')
+const { test } = require('tap')
+const { sleep, getPathToNull } = require('./helper')
+
+test('replaces onTerminated option', async ({ throws }) => {
+  throws(() => {
+    pino({
+      onTerminated: () => {}
+    })
+  }, Error('The onTerminated option has been removed, use pino.final instead'))
+})
+
+test('throws if not supplied a logger instance', async ({ throws }) => {
+  throws(() => {
+    pino.final()
+  }, Error('expected a pino logger instance'))
+})
+
+test('throws if the supplied handler is not a function', async ({ throws }) => {
+  throws(() => {
+    pino.final(pino(), 'dummy')
+  }, Error('if supplied, the handler parameter should be a function'))
+})
+
+test('throws if not supplied logger with pino.destination instance with sync false', async ({ throws, doesNotThrow }) => {
+  throws(() => {
+    pino.final(pino(fs.createWriteStream(getPathToNull())), () => {})
+  }, Error('final requires a stream that has a flushSync method, such as pino.destination'))
+
+  doesNotThrow(() => {
+    pino.final(pino(pino.destination({ sync: false })), () => {})
+  })
+
+  doesNotThrow(() => {
+    pino.final(pino(pino.destination({ sync: false })), () => {})
+  })
+})
+
+test('returns an exit listener function', async ({ equal }) => {
+  equal(typeof pino.final(pino(pino.destination({ sync: false })), () => {}), 'function')
+})
+
+test('listener function immediately sync flushes when fired (sync false)', async ({ pass, fail }) => {
+  const dest = pino.destination({ dest: getPathToNull(), sync: false })
+  let passed = false
+  dest.flushSync = () => {
+    passed = true
+    pass('flushSync called')
+  }
+  pino.final(pino(dest), () => {})()
+  await sleep(10)
+  if (passed === false) fail('flushSync not called')
+})
+
+test('listener function immediately sync flushes when fired (sync true)', async ({ pass, fail }) => {
+  const dest = pino.destination({ dest: getPathToNull(), sync: true })
+  let passed = false
+  dest.flushSync = () => {
+    passed = true
+    pass('flushSync called')
+  }
+  pino.final(pino(dest), () => {})()
+  await sleep(10)
+  if (passed === false) fail('flushSync not called')
+})
+
+test('swallows the non-ready error', async ({ doesNotThrow }) => {
+  const dest = pino.destination({ dest: getPathToNull(), sync: false })
+  doesNotThrow(() => {
+    pino.final(pino(dest), () => {})()
+  })
+})
+
+test('listener function triggers handler function parameter', async ({ pass, fail }) => {
+  const dest = pino.destination({ dest: getPathToNull(), sync: false })
+  let passed = false
+  pino.final(pino(dest), () => {
+    passed = true
+    pass('handler function triggered')
+  })()
+  await sleep(10)
+  if (passed === false) fail('handler function not triggered')
+})
+
+test('passes any error to the handler', async ({ equal }) => {
+  const dest = pino.destination({ dest: getPathToNull(), sync: false })
+  pino.final(pino(dest), (err) => {
+    equal(err.message, 'test')
+  })(Error('test'))
+})
+
+test('passes a specialized final logger instance', async ({ equal, not, error }) => {
+  const dest = pino.destination({ dest: getPathToNull(), sync: false })
+  const logger = pino(dest)
+  pino.final(logger, (err, finalLogger) => {
+    error(err)
+    equal(typeof finalLogger.trace, 'function')
+    equal(typeof finalLogger.debug, 'function')
+    equal(typeof finalLogger.info, 'function')
+    equal(typeof finalLogger.warn, 'function')
+    equal(typeof finalLogger.error, 'function')
+    equal(typeof finalLogger.fatal, 'function')
+
+    not(finalLogger.trace, logger.trace)
+    not(finalLogger.debug, logger.debug)
+    not(finalLogger.info, logger.info)
+    not(finalLogger.warn, logger.warn)
+    not(finalLogger.error, logger.error)
+    not(finalLogger.fatal, logger.fatal)
+
+    equal(finalLogger.child, logger.child)
+    equal(finalLogger.levels, logger.levels)
+  })()
+})
+
+test('returns a specialized final logger instance if no handler is passed', async ({ equal, not }) => {
+  const dest = pino.destination({ dest: getPathToNull(), sync: false })
+  const logger = pino(dest)
+  const finalLogger = pino.final(logger)
+  equal(typeof finalLogger.trace, 'function')
+  equal(typeof finalLogger.debug, 'function')
+  equal(typeof finalLogger.info, 'function')
+  equal(typeof finalLogger.warn, 'function')
+  equal(typeof finalLogger.error, 'function')
+  equal(typeof finalLogger.fatal, 'function')
+
+  not(finalLogger.trace, logger.trace)
+  not(finalLogger.debug, logger.debug)
+  not(finalLogger.info, logger.info)
+  not(finalLogger.warn, logger.warn)
+  not(finalLogger.error, logger.error)
+  not(finalLogger.fatal, logger.fatal)
+
+  equal(finalLogger.child, logger.child)
+  equal(finalLogger.levels, logger.levels)
+})
+
+test('final logger instances synchronously flush after a log method call', async ({ pass, fail, error }) => {
+  const dest = pino.destination({ dest: getPathToNull(), sync: false })
+  const logger = pino(dest)
+  let passed = false
+  let count = 0
+  dest.flushSync = () => {
+    count++
+    if (count === 2) {
+      passed = true
+      pass('flushSync called')
+    }
+  }
+  pino.final(logger, (err, finalLogger) => {
+    error(err)
+    finalLogger.info('hello')
+  })()
+  await sleep(10)
+  if (passed === false) fail('flushSync not called')
+})
+
+test('also instruments custom log methods', async ({ pass, fail, error }) => {
+  const dest = pino.destination({ dest: getPathToNull(), sync: false })
+  const logger = pino({
+    customLevels: {
+      foo: 35
+    }
+  }, dest)
+  let passed = false
+  let count = 0
+  dest.flushSync = () => {
+    count++
+    if (count === 2) {
+      passed = true
+      pass('flushSync called')
+    }
+  }
+  pino.final(logger, (err, finalLogger) => {
+    error(err)
+    finalLogger.foo('hello')
+  })()
+  await sleep(10)
+  if (passed === false) fail('flushSync not called')
+})

node_modules/pino/test/fixtures/broken-pipe/basic.js

@@ -0,0 +1,9 @@
+'use strict'
+
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+
+const pino = require('../../..')()
+
+pino.info('hello world')

node_modules/pino/test/fixtures/broken-pipe/destination.js

@@ -0,0 +1,10 @@
+'use strict'
+
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+
+const pino = require('../../..')
+const logger = pino(pino.destination())
+
+logger.info('hello world')

node_modules/pino/test/fixtures/broken-pipe/syncfalse.js

@@ -0,0 +1,12 @@
+'use strict'
+
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+
+const pino = require('../../..')
+const logger = pino(pino.destination({ sync: false }))
+
+for (var i = 0; i < 1000; i++) {
+  logger.info('hello world')
+}

node_modules/pino/test/fixtures/default-exit.js

@@ -0,0 +1,8 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../'))
+const logger = pino()
+logger.info('hello')
+logger.info('world')
+process.exit(0)

node_modules/pino/test/fixtures/destination-exit.js

@@ -0,0 +1,8 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../'))
+const logger = pino({}, pino.destination(1))
+logger.info('hello')
+logger.info('world')
+process.exit(0)

node_modules/pino/test/fixtures/pretty/basic.js

@@ -0,0 +1,6 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({ prettyPrint: true })
+log.info('h')

node_modules/pino/test/fixtures/pretty/child-with-serializer.js

@@ -0,0 +1,17 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({
+  prettyPrint: true,
+  serializers: {
+    a (num) {
+      return num * 2
+    }
+  }
+})
+log.info({ a: 1 }, 'h')
+const child = log.child({ a: 8 })
+child.info('h2')
+child.child({ b: 2 }).info('h3')
+child.info({ a: 21 }, 'h4')

node_modules/pino/test/fixtures/pretty/child-with-updated-chindings.js

@@ -0,0 +1,8 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({ prettyPrint: true }).child({ foo: 123 })
+log.info('before')
+log.setBindings({ foo: 456, bar: 789 })
+log.info('after')

node_modules/pino/test/fixtures/pretty/child.js

@@ -0,0 +1,8 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({ prettyPrint: true }).child({ a: 1 })
+log.info('h')
+log.child({ b: 2 }).info('h3')
+setTimeout(() => log.info('h2'), 200)

node_modules/pino/test/fixtures/pretty/custom-time-label.js

@@ -0,0 +1,9 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({
+  timestamp: () => ',"custom-time-label":"test"',
+  prettyPrint: true
+})
+log.info('h')

node_modules/pino/test/fixtures/pretty/custom-time.js

@@ -0,0 +1,9 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({
+  timestamp: () => ',"time":"test"',
+  prettyPrint: true
+})
+log.info('h')

node_modules/pino/test/fixtures/pretty/dateformat.js

@@ -0,0 +1,10 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({
+  prettyPrint: {
+    translateTime: true
+  }
+})
+log.info('h')

node_modules/pino/test/fixtures/pretty/error-props.js

@@ -0,0 +1,9 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({
+  prettyPrint: { errorProps: 'code,errno' }
+})
+const err = Object.assign(new Error('kaboom'), { code: 'ENOENT', errno: 1 })
+log.error(err)

node_modules/pino/test/fixtures/pretty/error.js

@@ -0,0 +1,7 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({ prettyPrint: true })
+log.error(new Error('kaboom'))
+log.error(new Error('kaboom'), 'with a message')

node_modules/pino/test/fixtures/pretty/final-no-log-before.js

@@ -0,0 +1,8 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({ prettyPrint: true })
+process.once('beforeExit', pino.final(log, (_, logger) => {
+  logger.info('beforeExit')
+}))

node_modules/pino/test/fixtures/pretty/final-return.js

@@ -0,0 +1,7 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({ prettyPrint: true })
+log.info('h')
+pino.final(log).info('after')

node_modules/pino/test/fixtures/pretty/final.js

@@ -0,0 +1,9 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({ prettyPrint: true })
+log.info('h')
+process.once('beforeExit', pino.final(log, (_, logger) => {
+  logger.info('beforeExit')
+}))

node_modules/pino/test/fixtures/pretty/formatters.js

@@ -0,0 +1,13 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({
+  prettyPrint: true,
+  formatters: {
+    log (obj) {
+      return { foo: 'formatted_' + obj.foo }
+    }
+  }
+})
+log.info({ foo: 'bar' }, 'h')

node_modules/pino/test/fixtures/pretty/level-first.js

@@ -0,0 +1,6 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({ prettyPrint: { levelFirst: true } })
+log.info('h')

node_modules/pino/test/fixtures/pretty/no-time.js

@@ -0,0 +1,9 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({
+  timestamp: false,
+  prettyPrint: true
+})
+log.info('h')

node_modules/pino/test/fixtures/pretty/obj-msg-prop.js

@@ -0,0 +1,6 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({ prettyPrint: true })
+log.info({ msg: 'hello' })

node_modules/pino/test/fixtures/pretty/pretty-factory.js

@@ -0,0 +1,6 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({ prettyPrint: { levelFirst: true }, prettifier: require('pino-pretty') })
+log.info('h')

node_modules/pino/test/fixtures/pretty/redact.js

@@ -0,0 +1,9 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({
+  prettyPrint: true,
+  redact: ['foo.an']
+})
+log.info({ foo: { an: 'object' } }, 'h')

node_modules/pino/test/fixtures/pretty/serializers.js

@@ -0,0 +1,17 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({
+  prettyPrint: true,
+  serializers: {
+    foo (obj) {
+      if (obj.an !== 'object') {
+        throw new Error('kaboom')
+      }
+
+      return 'bar'
+    }
+  }
+})
+log.info({ foo: { an: 'object' } }, 'h')

node_modules/pino/test/fixtures/pretty/skipped-output.js

@@ -0,0 +1,13 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({
+  prettyPrint: true,
+  prettifier: function () {
+    return function () {
+      return undefined
+    }
+  }
+})
+log.info('h')

node_modules/pino/test/fixtures/pretty/suppress-flush-sync-warning.js

@@ -0,0 +1,7 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../../'))
+const log = pino({ prettyPrint: { suppressFlushSyncWarning: true } })
+log.info('h')
+log.fatal('h1')

node_modules/pino/test/fixtures/stdout-hack-protection.js

@@ -0,0 +1,11 @@
+global.process = { __proto__: process, pid: 123456 }
+
+const write = process.stdout.write.bind(process.stdout)
+process.stdout.write = function (chunk) {
+  write('hack ' + chunk)
+}
+
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('../../'))()
+pino.info('me')

node_modules/pino/test/fixtures/syncfalse-child.js

@@ -0,0 +1,6 @@
+global.process = { __proto__: process, pid: 123456 }
+Date.now = function () { return 1459875739796 }
+require('os').hostname = function () { return 'abcdefghijklmnopqr' }
+const pino = require(require.resolve('./../../'))
+const asyncLogger = pino(pino.destination({ sync: false })).child({ hello: 'world' })
+pino.final(asyncLogger, (_, logger) => logger.info('h'))()