fastify 5.9.0 → 5.10.0

package/docs/Reference/Warnings.md

@@ -10,6 +10,8 @@
     - [FSTWRN004](#FSTWRN004)
   - [Fastify Deprecation Codes](#fastify-deprecation-codes)
     - [FSTDEP022](#FSTDEP022)
+    - [FSTDEP023](#FSTDEP023)
+    - [FSTDEP024](#FSTDEP024)
 
 ## Warnings
 
@@ -57,3 +59,5 @@ Deprecation codes are supported by the Node.js CLI options:
 | Code | Description | How to solve | Discussion |
 | ---- | ----------- | ------------ | ---------- |
 | <a id="FSTDEP022">FSTDEP022</a> | You are trying to access the deprecated router options on top option properties. | Use `options.routerOptions`. | [#5985](https://github.com/fastify/fastify/pull/5985)
+| <a id="FSTDEP023">FSTDEP023</a> | `disableRequestLogging` top-level option is deprecated. | Pass a `LogController` instance via the `logController` option with `disableRequestLogging` in its constructor instead. |
+| <a id="FSTDEP024">FSTDEP024</a> | `requestIdLogLabel` top-level option is deprecated. | Pass a `LogController` instance via the `logController` option with `requestIdLogLabel` in its constructor instead. |

package/fastify.d.ts

@@ -17,6 +17,7 @@ import { FastifyInstance, FastifyListenOptions, PrintRoutesOptions } from './typ
 import {
   FastifyBaseLogger,
   FastifyChildLoggerFactory,
+  LogController as LogControllerClass,
   FastifyLogFn,
   FastifyLoggerInstance,
   FastifyLoggerOptions,
@@ -44,6 +45,7 @@ type Fastify = typeof fastify
 
 declare namespace fastify {
   export const errorCodes: FastifyErrorCodes
+  export { LogControllerClass as LogController }
 
   export type FastifyHttp2SecureOptions<
     Server extends http2.Http2SecureServer,
@@ -126,7 +128,9 @@ declare namespace fastify {
     bodyLimit?: number,
     handlerTimeout?: number,
     maxParamLength?: number,
+    /** @deprecated Use the `logController` option with `disableRequestLogging` or `isLogDisabled` override instead. Will be removed in `fastify@6`. */
     disableRequestLogging?: boolean | ((req: FastifyRequest) => boolean),
+    logController?: LogControllerClass,
     exposeHeadRoutes?: boolean,
     onProtoPoisoning?: ProtoAction,
     onConstructorPoisoning?: ConstructorAction,
@@ -137,6 +141,7 @@ declare namespace fastify {
     caseSensitive?: boolean,
     allowUnsafeRegex?: boolean,
     requestIdHeader?: string | false,
+    /** @deprecated Use the `logController` option with `requestIdLogLabel` instead. Will be removed in `fastify@6`. */
     requestIdLogLabel?: string;
     useSemicolonDelimiter?: boolean,
     genReqId?: (req: RawRequestDefaultExpression<RawServer>) => string,

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '5.9.0'
+const VERSION = '5.10.0'
 
 const Avvio = require('avvio')
 const http = require('node:http')
@@ -33,7 +33,8 @@ const {
   kChildLoggerFactory,
   kGenReqId,
   kErrorHandlerAlreadySet,
-  kHandlerTimeout
+  kHandlerTimeout,
+  kLogController
 } = require('./lib/symbols.js')
 
 const { createServer } = require('./lib/server')
@@ -44,7 +45,7 @@ const decorator = require('./lib/decorate')
 const ContentTypeParser = require('./lib/content-type-parser.js')
 const SchemaController = require('./lib/schema-controller')
 const { Hooks, hookRunnerApplication, supportedHooks } = require('./lib/hooks')
-const { createChildLogger, defaultChildLoggerFactory, createLogger } = require('./lib/logger-factory')
+const { createChildLogger, defaultChildLoggerFactory, createLogger, createLogController, LogController } = require('./lib/logger-factory')
 const pluginUtils = require('./lib/plugin-utils.js')
 const { getGenReqId, reqIdGenFactory } = require('./lib/req-id-gen-factory.js')
 const { buildRouting, validateBodyLimitOption, buildRouterOptions } = require('./lib/route')
@@ -79,7 +80,7 @@ const {
 } = errorCodes
 
 const { buildErrorHandler } = require('./lib/error-handler.js')
-const { FSTWRN004 } = require('./lib/warnings.js')
+const { FSTWRN004, FSTDEP023, FSTDEP024 } = require('./lib/warnings.js')
 
 const initChannel = diagnostics.channel('fastify.initialization')
 
@@ -90,7 +91,7 @@ function fastify (serverOptions) {
   const {
     options,
     genReqId,
-    disableRequestLogging,
+    logController,
     hasLogger,
     initialConfig
   } = processOptions(serverOptions, defaultRoute, onBadUrl, onMaxParamLength)
@@ -216,6 +217,7 @@ function fastify (serverOptions) {
     },
     // expose logger instance
     log: options.logger,
+    [kLogController]: logController,
     // type provider
     withTypeProvider,
     // hooks
@@ -643,10 +645,7 @@ function fastify (serverOptions) {
       const request = new Request(id, null, req, null, childLogger, routeEventContext)
       const reply = new Reply(res, request, childLogger)
 
-      const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(req) : disableRequestLogging
-      if (resolvedDisableRequestLogging === false) {
-        childLogger.info({ req: request }, 'incoming request')
-      }
+      routeEventContext.server[kLogController].incomingRequest(request, reply)
 
       return options.frameworkErrors(new FST_ERR_BAD_URL(path), request, reply)
     }
@@ -671,10 +670,7 @@ function fastify (serverOptions) {
       const request = new Request(id, null, req, null, childLogger, routeEventContext)
       const reply = new Reply(res, request, childLogger)
 
-      const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(req) : disableRequestLogging
-      if (resolvedDisableRequestLogging === false) {
-        childLogger.info({ req: request }, 'incoming request')
-      }
+      routeEventContext.server[kLogController].incomingRequest(request, reply)
 
       return options.frameworkErrors(new FST_ERR_MAX_PARAM_LENGTH(path), request, reply)
     }
@@ -702,10 +698,7 @@ function fastify (serverOptions) {
           const request = new Request(id, null, req, null, childLogger, routeEventContext)
           const reply = new Reply(res, request, childLogger)
 
-          const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(req) : disableRequestLogging
-          if (resolvedDisableRequestLogging === false) {
-            childLogger.info({ req: request }, 'incoming request')
-          }
+          routeEventContext.server[kLogController].incomingRequest(request, reply)
 
           return options.frameworkErrors(new FST_ERR_ASYNC_CONSTRAINT(), request, reply)
         }
@@ -876,9 +869,13 @@ function processOptions (options, defaultRoute, onBadUrl, onMaxParamLength) {
 
   const requestIdHeader = typeof options.requestIdHeader === 'string' && options.requestIdHeader.length !== 0 ? options.requestIdHeader.toLowerCase() : (options.requestIdHeader === true && 'request-id')
   const genReqId = reqIdGenFactory(requestIdHeader, options.genReqId)
-  const requestIdLogLabel = options.requestIdLogLabel || 'reqId'
+  if (options.requestIdLogLabel !== undefined) {
+    FSTDEP024()
+  }
   options.bodyLimit = options.bodyLimit || defaultInitOptions.bodyLimit
-  const disableRequestLogging = options.disableRequestLogging || false
+  if (options.disableRequestLogging !== undefined) {
+    FSTDEP023()
+  }
 
   const ajvOptions = Object.assign({
     customOptions: {},
@@ -894,6 +891,10 @@ function processOptions (options, defaultRoute, onBadUrl, onMaxParamLength) {
 
   const { logger, hasLogger } = createLogger(options)
 
+  // the internal logger uses the input logger to execute the logging. This allows the user
+  // to customize every internal log line
+  const logController = createLogController(options)
+
   // Update the options with the fixed values
   options.connectionTimeout = options.connectionTimeout || defaultInitOptions.connectionTimeout
   options.keepAliveTimeout = options.keepAliveTimeout || defaultInitOptions.keepAliveTimeout
@@ -901,8 +902,6 @@ function processOptions (options, defaultRoute, onBadUrl, onMaxParamLength) {
   options.requestTimeout = options.requestTimeout || defaultInitOptions.requestTimeout
   options.logger = logger
   options.requestIdHeader = requestIdHeader
-  options.requestIdLogLabel = requestIdLogLabel
-  options.disableRequestLogging = disableRequestLogging
   options.ajv = ajvOptions
   options.clientErrorHandler = options.clientErrorHandler || defaultClientErrorHandler
   options.allowErrorHandlerOverride = options.allowErrorHandlerOverride ?? defaultInitOptions.allowErrorHandlerOverride
@@ -930,7 +929,7 @@ function processOptions (options, defaultRoute, onBadUrl, onMaxParamLength) {
   return {
     options,
     genReqId,
-    disableRequestLogging,
+    logController,
     hasLogger,
     initialConfig
   }
@@ -1010,5 +1009,6 @@ function validateSchemaErrorFormatter (schemaErrorFormatter) {
  */
 module.exports = fastify
 module.exports.errorCodes = errorCodes
+module.exports.LogController = LogController
 module.exports.fastify = fastify
 module.exports.default = fastify

package/lib/content-type-parser.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { AsyncResource } = require('node:async_hooks')
-const { FifoMap: Fifo, LruMap: Lru } = require('toad-cache')
+const { FifoMap: Fifo } = require('toad-cache')
 const { parse: secureJsonParse } = require('secure-json-parse')
 const ContentType = require('./content-type')
 const {
@@ -39,15 +39,6 @@ function ContentTypeParser (bodyLimit, onProtoPoisoning, onConstructorPoisoning)
   this.parserList = ['application/json', 'text/plain']
   this.parserRegExpList = []
   this.cache = new Fifo(100)
-  this.ctCache = new Lru(100)
-}
-
-ContentTypeParser.prototype.getContentType = function (raw) {
-  let ct = this.ctCache.get(raw)
-  if (ct !== undefined) return ct
-  ct = new ContentType(raw)
-  this.ctCache.set(raw, ct)
-  return ct
 }
 
 ContentTypeParser.prototype.add = function (contentType, opts, parserFn) {
@@ -169,7 +160,6 @@ ContentTypeParser.prototype.removeAll = function () {
   this.parserRegExpList = []
   this.parserList = []
   this.cache = new Fifo(100)
-  this.ctCache = new Lru(100)
 }
 
 ContentTypeParser.prototype.remove = function (contentType) {

package/lib/content-type.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { LruMap: Lru } = require('toad-cache')
+
 /**
  * keyValuePairsReg is used to split the parameters list into associated
  * key value pairings. The leading `(?:^|;)\s*` anchor ensures the regex
@@ -35,6 +37,12 @@ const typeNameReg = /^[\w!#$%&'*+.^`|~-]+$/
  */
 const subtypeNameReg = /^[\w!#$%&'*+.^`|~-]+\s*$/
 
+/**
+ * Content-Type internal shared cache
+ * @type {Lru<ContentType>}
+ */
+const cache = new Lru(100)
+
 /**
  * ContentType parses and represents the value of the content-type header.
  *
@@ -49,6 +57,27 @@ class ContentType {
   #parameters = new Map()
   #string
 
+  /**
+   * The shared cache of ContentType instances. The cache is used to avoid
+   * creating multiple instances of ContentType for the same header value.
+   * @type {Lru<ContentType>}
+   */
+  static get cache () { return cache }
+
+  /**
+   * Create a ContentType instance from a header value. If the value has been
+   * previously parsed, the cached instance will be returned.
+   * @param {string} headerValue
+   * @returns {ContentType | undefined}
+   */
+  static from (headerValue) {
+    let contentType = cache.get(headerValue)
+    if (contentType !== undefined) return contentType
+    contentType = new ContentType(headerValue)
+    cache.set(headerValue, contentType)
+    return contentType
+  }
+
   constructor (headerValue) {
     if (headerValue == null || headerValue === '' || headerValue === 'undefined') {
       return
@@ -106,7 +135,11 @@ class ContentType {
 
     let matches = keyValuePairsReg.exec(paramsList)
     while (matches) {
-      const key = matches[1]
+      // https://httpwg.org/specs/rfc9110.html#parameter
+      // Parameter names are case-insensitive.
+      const key = matches[1].toLowerCase()
+      // Parameter values might or might not be case-sensitive,
+      // depending on the semantics of the parameter name.
       const value = matches[2]
       if (value[0] === '"') {
         if (value.at(-1) !== '"') {

package/lib/context.js

@@ -6,7 +6,6 @@ const {
   kSchemaErrorFormatter,
   kErrorHandler,
   kChildLoggerFactory,
-  kOptions,
   kReply,
   kRequest,
   kBodyLimit,
@@ -24,7 +23,6 @@ function Context ({
   schema,
   handler,
   config,
-  requestIdLogLabel,
   childLoggerFactory,
   errorHandler,
   bodyLimit,
@@ -56,7 +54,6 @@ function Context ({
   this.onRequestAbort = null
   this.config = config
   this.errorHandler = errorHandler || server[kErrorHandler]
-  this.requestIdLogLabel = requestIdLogLabel || server[kOptions].requestIdLogLabel
   this.childLoggerFactory = childLoggerFactory || server[kChildLoggerFactory]
   this._middie = null
   this._parserOptions = {

package/lib/error-handler.js

@@ -8,7 +8,7 @@ const {
   kReplyNextErrorHandler,
   kReplyIsRunningOnErrorHook,
   kRouteContext,
-  kDisableRequestLogging,
+  kLogController,
   kDiagnosticsStore
 } = require('./symbols.js')
 
@@ -36,12 +36,7 @@ function handleError (reply, error, cb) {
       try {
         reply.raw.writeHead(reply.raw.statusCode, reply[kReplyHeaders])
       } catch (error) {
-        if (!reply.log[kDisableRequestLogging]) {
-          reply.log.warn(
-            { req: reply.request, res: reply, err: error },
-            error?.message
-          )
-        }
+        reply.server[kLogController].writeHeadError(error, reply.request, reply)
         reply.raw.writeHead(reply.raw.statusCode)
       }
       reply.raw.end(payload)
@@ -83,21 +78,7 @@ function handleError (reply, error, cb) {
 function defaultErrorHandler (error, request, reply) {
   setErrorHeaders(error, reply)
   setErrorStatusCode(reply, error)
-  if (reply.statusCode < 500) {
-    if (!reply.log[kDisableRequestLogging]) {
-      reply.log.info(
-        { res: reply, err: error },
-        error?.message
-      )
-    }
-  } else {
-    if (!reply.log[kDisableRequestLogging]) {
-      reply.log.error(
-        { req: request, res: reply, err: error },
-        error?.message
-      )
-    }
-  }
+  request.server[kLogController].defaultErrorLog(error, request, reply)
   reply.send(error)
 }
 
@@ -123,10 +104,10 @@ function fallbackErrorHandler (error, reply, cb) {
       }))
     }
   } catch (err) {
-    if (!reply.log[kDisableRequestLogging]) {
-      // error is always FST_ERR_SCH_SERIALIZATION_BUILD because this is called from route/compileSchemasForSerialization
-      reply.log.error({ err, statusCode: res.statusCode }, 'The serializer for the given status code failed')
-    }
+    // error is always FST_ERR_SCH_SERIALIZATION_BUILD
+    // because this is called from route/compileSchemasForSerialization
+    reply.server[kLogController].serializerError(err, reply.request, reply, { statusCode: res.statusCode })
+
     reply.code(500)
     payload = serializeError(new FST_ERR_FAILED_ERROR_SERIALIZATION(err.message, error.message))
   }

package/lib/errors.js

@@ -243,6 +243,13 @@ const codes = {
     TypeError
   ),
 
+  FST_ERR_LOG_INVALID_LOG_CONTROLLER: createError(
+    'FST_ERR_LOG_INVALID_LOG_CONTROLLER',
+    "logController option must be an instance of LogController, got '%s'.",
+    500,
+    TypeError
+  ),
+
   /**
    * reply
   */

package/lib/four-oh-four.js

@@ -11,7 +11,8 @@ const {
   kFourOhFourLevelInstance,
   kFourOhFourContext,
   kHooks,
-  kErrorHandler
+  kErrorHandler,
+  kLogController
 } = require('./symbols.js')
 const { lifecycleHooks } = require('./hooks')
 const { buildErrorHandler } = require('./error-handler.js')
@@ -29,7 +30,7 @@ const { getGenReqId } = require('./req-id-gen-factory.js')
  * kFourOhFourContext: the context in the reply object where the handler will be executed
  */
 function fourOhFour (options) {
-  const { logger, disableRequestLogging } = options
+  const { logger } = options
 
   // 404 router, used for handling encapsulated 404 handlers
   const router = FindMyWay({
@@ -52,14 +53,10 @@ function fourOhFour (options) {
   }
 
   function basic404 (request, reply) {
+    request.server[kLogController].routeNotFound(request, reply)
     const { url, method } = request.raw
-    const message = `Route ${method}:${url} not found`
-    const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(request.raw) : disableRequestLogging
-    if (!resolvedDisableRequestLogging) {
-      request.log.info(message)
-    }
     reply.code(404).send({
-      message,
+      message: `Route ${method}:${url} not found`,
       error: 'Not Found',
       statusCode: 404
     })
@@ -181,11 +178,12 @@ function fourOhFour (options) {
     const id = getGenReqId(fourOhFourContext.server, req)
     const childLogger = createChildLogger(fourOhFourContext, logger, req, id)
 
-    childLogger.info({ req }, 'incoming request')
-
     const request = new Request(id, null, req, null, childLogger, fourOhFourContext)
     const reply = new Reply(res, request, childLogger)
 
+    fourOhFourContext.server[kLogController].incomingRequest(request, reply)
+
+    // Since this could be a bug, we log it without checking if the logging is disabled
     request.log.warn('the default handler for 404 did not catch this, this is likely a fastify bug, please report it')
     request.log.warn(router.prettyPrint())
     reply.code(404).send(new FST_ERR_NOT_FOUND())

package/lib/handle-request.js

@@ -14,6 +14,7 @@ const {
   kRequestContentType,
   kDiagnosticsStore
 } = require('./symbols')
+const ContentType = require('./content-type')
 
 const channels = diagnostics.tracingChannel('fastify.request.handler')
 
@@ -55,7 +56,7 @@ function handleRequest (err, request, reply) {
     // Conditional assignment to avoid creating a new ContentType instance
     // It can be assigned when accessing the .mediaType in hooks
     if (!request[kRequestContentType]) {
-      request[kRequestContentType] = request[kRouteContext].contentTypeParser.getContentType(ctHeader)
+      request[kRequestContentType] = ContentType.from(ctHeader)
     }
     if (request[kRequestContentType].isValid === false) {
       reply[kReplyIsError] = true

package/lib/log-controller.js

@@ -0,0 +1,169 @@
+'use strict'
+
+const { defaultInitOptions } = require('./initial-config-validation')
+
+/**
+ * Internal logger layer that wraps Fastify's log calls with
+ * request-lifecycle awareness (disable-check, level selection).
+ * Keeps the surface intentionally small so hot paths stay fast.
+ *
+ * Users can extend this class to customize internal log lines.
+ */
+class LogController {
+  /**
+   * @param {object} [options]
+   * @param {boolean | ((req: object) => boolean)} [options.disableRequestLogging=false]
+   *   When `true` (or a function returning `true`), per-request log lines
+   *   (incoming, completed, errors) are suppressed.
+   * @param {string} [options.requestIdLogLabel='reqId']
+   *   The label used for the request identifier when logging the request.
+   */
+  constructor (options) {
+    const opts = options || {}
+    this.disableRequestLogging = opts.disableRequestLogging || defaultInitOptions.disableRequestLogging
+    this.isDisableRequestLoggingFunction = typeof this.disableRequestLogging === 'function'
+    this.requestIdLogLabel = opts.requestIdLogLabel || defaultInitOptions.requestIdLogLabel
+  }
+
+  /**
+   * Checks whether request logging is disabled for the given request.
+   *
+   * @param {object} req  Raw or Fastify request object.
+   * @returns {boolean}   `true` when logging should be skipped.
+   */
+  isLogDisabled (req) {
+    return this.isDisableRequestLoggingFunction
+      ? this.disableRequestLogging(req)
+      : this.disableRequestLogging
+  }
+
+  /**
+   * Logs an incoming request at `info` level.
+   *
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  incomingRequest (request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    request.log.info({ req: request }, 'incoming request')
+  }
+
+  /**
+   * Logs the outcome of a completed request.
+   * Uses `error` level when an error is present, `info` otherwise.
+   *
+   * @param {Error | null} error  Error that occurred during the response, if any.
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  requestCompleted (error, request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    if (error) {
+      reply.log.error({ res: reply, err: error, responseTime: reply.elapsedTime }, 'request errored')
+    } else {
+      reply.log.info({ res: reply, responseTime: reply.elapsedTime }, 'request completed')
+    }
+  }
+
+  /**
+   * Logs an error handled by the default error handler.
+   * Uses `error` for 5xx status codes, `info` for 4xx.
+   *
+   * @param {Error} error         The error being handled.
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object (must have `statusCode`).
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  defaultErrorLog (error, request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    if (reply.statusCode >= 500) {
+      reply.log.error({ req: request, res: reply, err: error }, error?.message)
+    } else {
+      reply.log.info({ res: reply, err: error }, error?.message)
+    }
+  }
+
+  /**
+   * Logs stream-level errors that occur after headers have been sent.
+   * Premature closes are logged at `info`; other errors at `warn`.
+   *
+   * @param {Error} error         The stream error.
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  streamError (error, request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    if (error.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+      reply.log.info({ res: reply }, 'stream closed prematurely')
+    } else {
+      reply.log.warn({ err: error }, 'response terminated with an error with headers already sent')
+    }
+  }
+
+  /**
+   * Logs a "route not found" message at `info` level.
+   * Used by the default 404 handler.
+   *
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  routeNotFound (request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    const { url, method } = request.raw
+    request.log.info(`Route ${method}:${url} not found`)
+  }
+
+  /**
+   * Logs a warning when writeHead fails during error handling.
+   *
+   * @param {Error} error         The error thrown by writeHead.
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  writeHeadError (error, request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    reply.log.warn(
+      { req: request, res: reply, err: error },
+      error?.message
+    )
+  }
+
+  /**
+   * Logs an error when the serializer for a given status code fails.
+   *
+   * @param {Error} error         The serialization error.
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} metadata     Extra contextual data.
+   * @param {number} metadata.statusCode The status code that triggered the serializer.
+   */
+  serializerError (error, request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    reply.log.error({ err: error, statusCode: metadata.statusCode }, 'The serializer for the given status code failed')
+  }
+
+  /**
+   * Logs a 503 Service Unavailable when the server is closing.
+   * Always emitted (not gated by `disableRequestLogging`).
+   *
+   * @param {import('../fastify').FastifyBaseLogger} logger
+   * @param {import('../fastify').FastifyInstance} server
+   */
+  serviceUnavailable (logger, server) {
+    logger.info({ res: { statusCode: 503 } }, 'request aborted - refusing to accept new requests as server is closing')
+  }
+}
+
+module.exports = { LogController }

package/lib/logger-factory.js

@@ -1,11 +1,18 @@
 'use strict'
 
+const { performance } = require('node:perf_hooks')
+
 const {
   FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED,
   FST_ERR_LOG_INVALID_LOGGER_CONFIG,
   FST_ERR_LOG_INVALID_LOGGER_INSTANCE,
-  FST_ERR_LOG_INVALID_LOGGER
+  FST_ERR_LOG_INVALID_LOGGER,
+  FST_ERR_LOG_INVALID_LOG_CONTROLLER
 } = require('./errors')
+const {
+  kLogController
+} = require('./symbols.js')
+const { LogController } = require('./log-controller.js')
 
 /**
  * Utility for creating a child logger with the appropriate bindings, logger factory
@@ -21,7 +28,7 @@ const {
  */
 function createChildLogger (context, logger, req, reqId, loggerOpts) {
   const loggerBindings = {
-    [context.requestIdLogLabel]: reqId
+    [context.server[kLogController].requestIdLogLabel]: reqId
   }
   const child = context.childLoggerFactory.call(context.server, logger, loggerBindings, loggerOpts || {}, req)
 
@@ -122,15 +129,29 @@ function createLogger (options) {
   return { logger, hasLogger: true }
 }
 
+function createLogController (options) {
+  const userController = options.logController
+  if (!userController) {
+    return new LogController(options)
+  }
+
+  if (userController instanceof LogController) {
+    return userController
+  }
+
+  throw new FST_ERR_LOG_INVALID_LOG_CONTROLLER(typeof userController)
+}
+
 function now () {
-  const ts = process.hrtime()
-  return (ts[0] * 1e3) + (ts[1] / 1e6)
+  return performance.now()
 }
 
 module.exports = {
   createChildLogger,
   defaultChildLoggerFactory,
+  createLogController,
   createLogger,
+  LogController,
   validateLogger,
   now
 }