fastify 5.9.0 → 5.10.0

package/test/internals/logger.test.js

@@ -3,6 +3,7 @@
 const { test } = require('node:test')
 const Fastify = require('../..')
 const loggerUtils = require('../../lib/logger-factory')
+const { createLogController, LogController } = require('../../lib/logger-factory')
 const { serializers } = require('../../lib/logger-pino')
 
 test('time resolution', t => {
@@ -142,6 +143,327 @@ test('The logger should error if both stream and file destination are given', t
   }
 })
 
+test('LogController defaults', t => {
+  t.plan(3)
+  const dispatcher = new LogController()
+  t.assert.strictEqual(dispatcher.disableRequestLogging, false)
+  t.assert.strictEqual(dispatcher.requestIdLogLabel, 'reqId')
+  t.assert.strictEqual(dispatcher.isLogDisabled({}), false)
+})
+
+test('LogController with custom options', t => {
+  t.plan(2)
+  const dispatcher = new LogController({
+    disableRequestLogging: true,
+    requestIdLogLabel: 'traceId'
+  })
+  t.assert.strictEqual(dispatcher.disableRequestLogging, true)
+  t.assert.strictEqual(dispatcher.requestIdLogLabel, 'traceId')
+})
+
+test('LogController with function disableRequestLogging', t => {
+  t.plan(2)
+  const dispatcher = new LogController({
+    disableRequestLogging: (req) => req.skip === true
+  })
+  t.assert.strictEqual(dispatcher.isLogDisabled({ skip: true }), true)
+  t.assert.strictEqual(dispatcher.isLogDisabled({ skip: false }), false)
+})
+
+test('requestCompleted should not log when logging is disabled (boolean)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: true })
+  const log = {
+    error: () => { t.assert.fail('error should not be called') },
+    info: () => { t.assert.fail('info should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.requestCompleted(new Error('test'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('requestCompleted should not log when logging is disabled (function)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: () => true })
+  const log = {
+    error: () => { t.assert.fail('error should not be called') },
+    info: () => { t.assert.fail('info should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.requestCompleted(new Error('test'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('requestCompleted should log error when err is present', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: false })
+  const err = new Error('test')
+  const log = {
+    error: (data, msg) => {
+      t.assert.strictEqual(msg, 'request errored')
+    }
+  }
+  const request = {}
+  const reply = { request, log, elapsedTime: 42 }
+  logController.requestCompleted(err, request, reply)
+})
+
+test('requestCompleted should log info when no error', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: false })
+  const log = {
+    info: (data, msg) => {
+      t.assert.strictEqual(msg, 'request completed')
+    }
+  }
+  const request = {}
+  const reply = { request, log, elapsedTime: 42 }
+  logController.requestCompleted(null, request, reply)
+})
+
+test('defaultErrorLog should not log when logging is disabled (boolean)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: true })
+  const log = {
+    info: () => { t.assert.fail('info should not be called') },
+    error: () => { t.assert.fail('error should not be called') }
+  }
+  const request = {}
+  const reply = { request, log, statusCode: 404 }
+  logController.defaultErrorLog(new Error('not found'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('defaultErrorLog should not log when logging is disabled (function)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: () => true })
+  const log = {
+    info: () => { t.assert.fail('info should not be called') },
+    error: () => { t.assert.fail('error should not be called') }
+  }
+  const request = {}
+  const reply = { request, log, statusCode: 404 }
+  logController.defaultErrorLog(new Error('not found'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('defaultErrorLog should log info for 4xx errors', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: false })
+  const err = new Error('not found')
+  const log = {
+    info: (data, msg) => {
+      t.assert.strictEqual(msg, 'not found')
+    }
+  }
+  const request = {}
+  const reply = { request, log, statusCode: 404 }
+  logController.defaultErrorLog(err, request, reply)
+})
+
+test('defaultErrorLog should log error for 5xx errors', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: false })
+  const err = new Error('internal error')
+  const log = {
+    error: (data, msg) => {
+      t.assert.strictEqual(msg, 'internal error')
+    }
+  }
+  const request = {}
+  const reply = { request, log, statusCode: 500 }
+  logController.defaultErrorLog(err, request, reply)
+})
+
+test('writeHeadError should not log when logging is disabled (boolean)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: true })
+  const log = {
+    warn: () => { t.assert.fail('warn should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.writeHeadError(new Error('write head failed'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('writeHeadError should not log when logging is disabled (function)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: () => true })
+  const log = {
+    warn: () => { t.assert.fail('warn should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.writeHeadError(new Error('write head failed'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('writeHeadError should log warn with error message', t => {
+  t.plan(2)
+  const logController = new LogController({ disableRequestLogging: false })
+  const error = new Error('write head failed')
+  const request = {}
+  const reply = {
+    request,
+    log: {
+      warn: (data, msg) => {
+        t.assert.strictEqual(msg, 'write head failed')
+        t.assert.strictEqual(data.err, error)
+      }
+    }
+  }
+  logController.writeHeadError(error, request, reply)
+})
+
+test('serializerError should not log when logging is disabled (boolean)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: true })
+  const log = {
+    error: () => { t.assert.fail('error should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.serializerError(new Error('serializer failed'), request, reply, { statusCode: 500 })
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('serializerError should not log when logging is disabled (function)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: () => true })
+  const log = {
+    error: () => { t.assert.fail('error should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.serializerError(new Error('serializer failed'), request, reply, { statusCode: 500 })
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('serializerError should log error with status code', t => {
+  t.plan(2)
+  const logController = new LogController({ disableRequestLogging: false })
+  const err = new Error('serializer failed')
+  const request = {}
+  const reply = {
+    request,
+    log: {
+      error: (data, msg) => {
+        t.assert.strictEqual(msg, 'The serializer for the given status code failed')
+        t.assert.strictEqual(data.statusCode, 500)
+      }
+    }
+  }
+  logController.serializerError(err, request, reply, { statusCode: 500 })
+})
+
+test('createLogController should use LogController instance directly', t => {
+  t.plan(2)
+  const custom = new LogController({ disableRequestLogging: true, requestIdLogLabel: 'traceId' })
+  const dispatcher = createLogController({ logController: custom })
+  t.assert.strictEqual(dispatcher, custom)
+  t.assert.strictEqual(dispatcher.requestIdLogLabel, 'traceId')
+})
+
+test('createLogController should create default when no instance provided', t => {
+  t.plan(2)
+  const dispatcher = createLogController({ disableRequestLogging: false, requestIdLogLabel: 'reqId' })
+  t.assert.ok(dispatcher instanceof LogController)
+  t.assert.strictEqual(dispatcher.requestIdLogLabel, 'reqId')
+})
+
+test('createLogController should throw on invalid type', t => {
+  t.plan(1)
+  t.assert.throws(() => {
+    createLogController({ disableRequestLogging: false, logController: 'bad' })
+  }, { code: 'FST_ERR_LOG_INVALID_LOG_CONTROLLER' })
+})
+
+test('createLogController should throw when plain object is provided', t => {
+  t.plan(1)
+  t.assert.throws(() => {
+    createLogController({ disableRequestLogging: false, logController: { incomingRequest: () => { } } })
+  }, { code: 'FST_ERR_LOG_INVALID_LOG_CONTROLLER' })
+})
+
+test('createLogController should accept null', t => {
+  t.plan(1)
+  const logController = createLogController({ disableRequestLogging: false, logController: null })
+  t.assert.ok(logController)
+})
+
+test('LogController subclass should work', t => {
+  t.plan(2)
+
+  class MyDispatcher extends LogController {
+    constructor () {
+      super({ requestIdLogLabel: 'traceId' })
+    }
+
+    incomingRequest (request, reply, metadata) {
+      t.assert.ok(true, 'custom incomingRequest called')
+    }
+  }
+
+  const dispatcher = new MyDispatcher()
+  t.assert.strictEqual(dispatcher.requestIdLogLabel, 'traceId')
+  dispatcher.incomingRequest({})
+})
+
+test('LogController subclass keeps defaults for non-overridden methods', t => {
+  t.plan(1)
+
+  class MyDispatcher extends LogController {
+    incomingRequest () { }
+  }
+
+  const dispatcher = new MyDispatcher()
+  const log = {
+    info: (data, msg) => {
+      t.assert.strictEqual(msg, 'request completed')
+    }
+  }
+  const request = {}
+  const reply = { request, log, elapsedTime: 42 }
+  dispatcher.requestCompleted(null, request, reply)
+})
+
+test('serviceUnavailable should log with logger and receive server', t => {
+  t.plan(2)
+  const dispatcher = new LogController()
+  const fakeLogger = {
+    info: (data, msg) => {
+      t.assert.deepStrictEqual(data, { res: { statusCode: 503 } })
+      t.assert.strictEqual(msg, 'request aborted - refusing to accept new requests as server is closing')
+    }
+  }
+  const fakeServer = { name: 'test-server' }
+  dispatcher.serviceUnavailable(fakeLogger, fakeServer)
+})
+
+test('serviceUnavailable subclass can use server', t => {
+  t.plan(1)
+
+  const fakeServer = { name: 'test-server' }
+
+  class MyDispatcher extends LogController {
+    serviceUnavailable (logger, server) {
+      t.assert.strictEqual(server, fakeServer)
+    }
+  }
+
+  const dispatcher = new MyDispatcher()
+  dispatcher.serviceUnavailable({}, fakeServer)
+})
+
+test('LogController is exported from fastify', t => {
+  t.plan(2)
+  t.assert.ok(Fastify.LogController)
+  t.assert.strictEqual(Fastify.LogController, LogController)
+})
+
 test('The serializer prevent fails if the request socket is undefined', t => {
   t.plan(1)
 

package/test/internals/reply.test.js

@@ -5,6 +5,7 @@ const http = require('node:http')
 const NotFound = require('http-errors').NotFound
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
+const { LogController } = require('../../lib/log-controller')
 const Fastify = require('../..')
 const { Readable, Writable } = require('node:stream')
 const {
@@ -13,7 +14,8 @@ const {
   kReplySerializer,
   kReplyIsError,
   kReplySerializerDefault,
-  kRouteContext
+  kRouteContext,
+  kLogController
 } = require('../../lib/symbols')
 const fs = require('node:fs')
 const path = require('node:path')
@@ -85,7 +87,14 @@ test('reply.send will logStream error and destroy the stream', t => {
     warn: () => { }
   }
 
-  const reply = new Reply(response, { [kRouteContext]: { onSend: null } }, log)
+  const fakeRequest = {
+    [kRouteContext]: {
+      onSend: null,
+      server: { [kLogController]: new LogController() }
+    }
+  }
+
+  const reply = new Reply(response, fakeRequest, log)
   reply.send(payload)
   payload.destroy(new Error('stream error'))
 
@@ -764,7 +773,7 @@ test('non-string with custom json\'s content-type SHOULD be serialized as json',
 
   const result = await fetch(fastifyServer)
   t.assert.ok(result.ok)
-  t.assert.strictEqual(result.headers.get('content-type'), 'application/json; version=2; charset=utf-8')
+  t.assert.strictEqual(result.headers.get('content-type'), 'application/json; version="2"; charset=utf-8')
   t.assert.deepStrictEqual(await result.text(), JSON.stringify({ key: 'hello world!' }))
 })
 
@@ -1149,7 +1158,7 @@ test('reply.hasHeader computes raw and fastify headers', async t => {
 })
 
 test('Reply should handle JSON content type with a charset', async t => {
-  t.plan(8)
+  t.plan(10)
 
   const fastify = require('../../')()
 
@@ -1199,6 +1208,18 @@ test('Reply should handle JSON content type with a charset', async t => {
       .send({ hello: 'world' })
   })
 
+  fastify.get('/upper-charset', function (req, reply) {
+    reply
+      .header('content-type', 'application/json; CHARSET=utf-8')
+      .send({ hello: 'world' })
+  })
+
+  fastify.get('/random-case', function (req, reply) {
+    reply
+      .header('content-type', 'ApPlIcAtIoN/JsOn; ChArSeT=utf-8')
+      .send({ hello: 'world' })
+  })
+
   {
     const res = await fastify.inject('/default')
     t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
@@ -1233,6 +1254,16 @@ test('Reply should handle JSON content type with a charset', async t => {
     t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-32')
   }
 
+  {
+    const res = await fastify.inject('/upper-charset')
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; CHARSET=utf-8')
+  }
+
+  {
+    const res = await fastify.inject('/random-case')
+    t.assert.strictEqual(res.headers['content-type'], 'ApPlIcAtIoN/JsOn; ChArSeT=utf-8')
+  }
+
   {
     const res = await fastify.inject('/no-space-type-utf32')
     t.assert.strictEqual(res.headers['content-type'], 'application/json;charset=utf-32')

package/test/internals/request.test.js

@@ -331,10 +331,10 @@ test('Request with trust proxy - no x-forwarded-host header', t => {
 })
 
 test('Request with trust proxy - no x-forwarded-host header and fallback to authority', t => {
-  t.plan(2)
+  t.plan(3)
   const headers = {
     'x-forwarded-for': '2.2.2.2, 1.1.1.1',
-    ':authority': 'authority'
+    ':authority': 'authority:4321'
   }
   const req = {
     method: 'GET',
@@ -370,15 +370,16 @@ test('Request with trust proxy - no x-forwarded-host header and fallback to auth
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log', context)
   t.assert.ok(request instanceof TpRequest)
-  t.assert.strictEqual(request.host, 'authority')
+  t.assert.strictEqual(request.host, 'authority:4321')
+  t.assert.strictEqual(request.port, 4321)
 })
 
 test('Request with trust proxy - x-forwarded-host header has precedence over host', t => {
-  t.plan(2)
+  t.plan(4)
   const headers = {
     'x-forwarded-for': ' 2.2.2.2, 1.1.1.1',
-    'x-forwarded-host': 'fastify.test',
-    host: 'hostname'
+    'x-forwarded-host': 'fastify.test:1234',
+    host: 'hostname:5678'
   }
   const req = {
     method: 'GET',
@@ -390,7 +391,9 @@ test('Request with trust proxy - x-forwarded-host header has precedence over hos
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
   t.assert.ok(request instanceof TpRequest)
-  t.assert.strictEqual(request.host, 'fastify.test')
+  t.assert.strictEqual(request.host, 'fastify.test:1234')
+  t.assert.strictEqual(request.hostname, 'fastify.test')
+  t.assert.strictEqual(request.port, 1234)
 })
 
 test('Request with trust proxy - handles multiple entries in x-forwarded-host/proto', t => {

package/test/logger/logging.test.js

@@ -7,6 +7,7 @@ const split = require('split2')
 const pino = require('pino')
 
 const Fastify = require('../../fastify')
+const { LogController } = require('../../lib/log-controller')
 const helper = require('../helper')
 const { once, on } = stream
 const { request } = require('./logger-test-utils')
@@ -16,7 +17,7 @@ t.test('logging', { timeout: 60000 }, async (t) => {
   let localhost
   let localhostForURL
 
-  t.plan(15)
+  t.plan(16)
 
   t.before(async function () {
     [localhost, localhostForURL] = await helper.getLoopbackHost()
@@ -80,6 +81,44 @@ t.test('logging', { timeout: 60000 }, async (t) => {
     }
   })
 
+  await t.test('should not log if logController option disables logging', async (t) => {
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: {
+        stream,
+        level: 'info'
+      },
+      logController: new class extends LogController {
+        isLogDisabled () {
+          t.assert.ok(true, 'isLogDisabled should be called')
+          return true // disable logging to test that incomingRequest is not called
+        }
+      }()
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/info', function (req, reply) {
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.ready()
+    const server = await fastify.listen({ port: 0, host: localhost })
+    const lines = [
+      { msg: `Server listening at ${server}` }
+    ]
+    // 2:
+    // - incoming request
+    // - request completed
+    t.plan(lines.length + 2)
+
+    await request(`http://${localhostForURL}:` + fastify.server.address().port + '/info')
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
+      if (lines.length === 0) break
+    }
+  })
+
   await t.test('should log the error if no error handler is defined', async (t) => {
     const stream = split(JSON.parse)
     const fastify = Fastify({

package/test/stream.4.test.js

@@ -6,7 +6,7 @@ const JSONStream = require('JSONStream')
 const Readable = require('node:stream').Readable
 const split = require('split2')
 const Fastify = require('..')
-const { kDisableRequestLogging } = require('../lib/symbols.js')
+const { kLogController } = require('../lib/symbols.js')
 
 test('Destroying streams prematurely should call abort method', (t, testDone) => {
   t.plan(7)
@@ -87,7 +87,7 @@ test('Destroying streams prematurely, log is disabled', (t, testDone) => {
   const http = require('node:http')
 
   fastify.get('/', function (request, reply) {
-    reply.log[kDisableRequestLogging] = true
+    reply.server[kLogController].disableRequestLogging = true
 
     let sent = false
     const reallyLongStream = new stream.Readable({