update

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-std-serializers/.travis.yml

@@ -0,0 +1,22 @@
+language: node_js
+
+node_js:
+  - "12"
+  - "10"
+  - "9"
+  - "8"
+  - "6"
+
+# before_install:
+#   - curl -L https://unpkg.com/@pnpm/self-installer | node
+# install:
+#   - pnpm install
+
+script:
+  - npm run lint-ci
+  - npm run test-ci
+
+notifications:
+  email:
+    on_success: never
+    on_failure: always

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-std-serializers/Readme.md

@@ -0,0 +1,107 @@
+# pino-std-serializers  [![Build Status](https://travis-ci.org/pinojs/pino-std-serializers.svg)](https://travis-ci.org/pinojs/pino-std-serializers)
+
+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-std-serializers/index.js

@@ -0,0 +1,34 @@
+'use strict'
+
+var errSerializer = require('./lib/err')
+var reqSerializers = require('./lib/req')
+var 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-std-serializers/lib/err.js

@@ -0,0 +1,64 @@
+'use strict'
+
+module.exports = errSerializer
+
+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 = err.constructor.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) {
+        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-std-serializers/lib/req.js

@@ -0,0 +1,80 @@
+'use strict'
+
+module.exports = {
+  mapHttpRequest,
+  reqSerializer
+}
+
+var rawSymbol = Symbol('pino-raw-req-ref')
+var pinoReqProto = Object.create({}, {
+  id: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  method: {
+    enumerable: true,
+    writable: true,
+    value: ''
+  },
+  url: {
+    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.
+  var connection = req.info || req.connection
+  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
+  } else {
+    // req.url.path is  for hapi compat.
+    _req.url = 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-std-serializers/lib/res.js

@@ -0,0 +1,47 @@
+'use strict'
+
+module.exports = {
+  mapHttpResponse,
+  resSerializer
+}
+
+var rawSymbol = Symbol('pino-raw-res-ref')
+var 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-std-serializers/package.json

@@ -0,0 +1,64 @@
+{
+  "_from": "pino-std-serializers@^2.4.2",
+  "_id": "pino-std-serializers@2.4.2",
+  "_inBundle": false,
+  "_integrity": "sha512-WaL504dO8eGs+vrK+j4BuQQq6GLKeCCcHaMB2ItygzVURcL1CycwNEUHTD/lHFHs/NL5qAz2UKrjYWXKSf4aMQ==",
+  "_location": "/pino-std-serializers",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "pino-std-serializers@^2.4.2",
+    "name": "pino-std-serializers",
+    "escapedName": "pino-std-serializers",
+    "rawSpec": "^2.4.2",
+    "saveSpec": null,
+    "fetchSpec": "^2.4.2"
+  },
+  "_requiredBy": [
+    "/pino"
+  ],
+  "_resolved": "https://registry.npmjs.org/pino-std-serializers/-/pino-std-serializers-2.4.2.tgz",
+  "_shasum": "cb5e3e58c358b26f88969d7e619ae54bdfcc1ae1",
+  "_spec": "pino-std-serializers@^2.4.2",
+  "_where": "/home/dawidd6/github/dawidd6/action-debian-package/node_modules/pino",
+  "author": {
+    "name": "James Sumners",
+    "email": "james.sumners@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/pinojs/pino-std-serializers/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "A collection of standard object serializers for Pino",
+  "devDependencies": {
+    "pre-commit": "^1.2.2",
+    "snazzy": "^7.0.0",
+    "standard": "^11.0.0",
+    "tap": "^12.0.0"
+  },
+  "homepage": "https://github.com/pinojs/pino-std-serializers#readme",
+  "keywords": [
+    "pino",
+    "logging"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "pino-std-serializers",
+  "precommit": [
+    "lint",
+    "test"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/pinojs/pino-std-serializers.git"
+  },
+  "scripts": {
+    "lint": "standard | snazzy",
+    "lint-ci": "standard",
+    "test": "tap --no-cov 'test/**/*.test.js'",
+    "test-ci": "tap --cov --coverage-report=text 'test/**/*.test.js'"
+  },
+  "version": "2.4.2"
+}

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

@@ -0,0 +1,106 @@
+'use strict'
+
+var test = require('tap').test
+const serializer = require('../lib/err')
+var wrapErrorSerializer = require('../').wrapErrorSerializer
+
+test('serializes Error objects', function (t) {
+  t.plan(3)
+  var 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)
+  var err = Error('foo')
+  err.statusCode = 500
+  var 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 nested errors', function (t) {
+  t.plan(7)
+  var err = Error('foo')
+  err.inner = Error('bar')
+  var 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)
+  var err = Error('foo')
+  err.inner = err
+  var 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)
+  var err = Error('foo')
+  var bar = Error('bar')
+  err.inner = bar
+  bar.inner = err
+
+  serializer(err)
+  var 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('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)
+  var err = Error('foo')
+  err.foo = 'foo'
+  var serializer = wrapErrorSerializer(function (err) {
+    delete err.foo
+    err.bar = 'bar'
+    return err
+  })
+  var 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-std-serializers/test/req.test.js

@@ -0,0 +1,298 @@
+'use strict'
+
+var http = require('http')
+var test = require('tap').test
+var serializers = require('../lib/req')
+var wrapRequestSerializer = require('../').wrapRequestSerializer
+
+test('maps request', function (t) {
+  t.plan(2)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    var 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)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    var serialized = serializers.reqSerializer(req)
+    t.is(Object.keys(serialized).length, 6)
+    res.end()
+  }
+})
+
+test('req.raw is available', function (t) {
+  t.plan(2)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.foo = 'foo'
+    var 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)
+
+  var 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: {} }
+    var 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)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    var serialized = serializers.reqSerializer(req)
+    t.is(serialized.id, undefined)
+    res.end()
+  }
+})
+
+test('req.id has a non-function value', function (t) {
+  t.plan(1)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    var 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)
+
+  var 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'}
+    var 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)
+
+  var 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 }
+    var 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 url.path when input request url is an object', function (t) {
+  t.plan(1)
+
+  var 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'}
+    var serialized = serializers.reqSerializer(req)
+    t.is(serialized.url, '/test')
+    res.end()
+  }
+})
+
+test('req.url will be obtained from input request originalUrl when available', function (t) {
+  t.plan(1)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.originalUrl = '/test'
+    var serialized = serializers.reqSerializer(req)
+    t.is(serialized.url, '/test')
+    res.end()
+  }
+})
+
+test('can wrap request serializers', function (t) {
+  t.plan(3)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  var serailizer = wrapRequestSerializer(function (req) {
+    t.ok(req.method)
+    t.is(req.method, 'GET')
+    delete req.method
+    return req
+  })
+
+  function handler (req, res) {
+    var serialized = serailizer(req)
+    t.notOk(serialized.method)
+    res.end()
+  }
+})
+
+test('req.remoteAddress will be obtained from request connect.remoteAddress as fallback', function (t) {
+  t.plan(1)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.connection = {remoteAddress: 'http://localhost'}
+    var 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)
+
+  var 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'}
+    var serialized = serializers.reqSerializer(req)
+    t.is(serialized.remoteAddress, 'http://localhost')
+    res.end()
+  }
+})
+
+test('req.remotePort will be obtained from request connect.remotePort as fallback', function (t) {
+  t.plan(1)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    req.connection = {remotePort: 3000}
+    var 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)
+
+  var 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}
+    var serialized = serializers.reqSerializer(req)
+    t.is(serialized.remotePort, 3000)
+    res.end()
+  }
+})

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

@@ -0,0 +1,89 @@
+'use strict'
+
+var http = require('http')
+var test = require('tap').test
+var serializers = require('../lib/res')
+var wrapResponseSerializer = require('../').wrapResponseSerializer
+
+test('res.raw is not enumerable', function (t) {
+  t.plan(1)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    var serialized = serializers.resSerializer(res)
+    t.is(serialized.propertyIsEnumerable('raw'), false)
+    res.end()
+  }
+})
+
+test('res.raw is available', function (t) {
+  t.plan(2)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  function handler (req, res) {
+    res.statusCode = 200
+    var 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)
+
+  var server = http.createServer(handler)
+  server.unref()
+  server.listen(0, () => {
+    http.get(server.address(), () => {})
+  })
+
+  t.tearDown(() => server.close())
+
+  var 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
+    var serialized = serializer(res)
+    t.notOk(serialized.statusCode)
+    res.end()
+  }
+})
+
+test('res.headers is serialized', function (t) {
+  t.plan(1)
+
+  var 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')
+    var serialized = serializers.resSerializer(res)
+    t.is(serialized.headers['x-custom'], 'y')
+    res.end()
+  }
+})