fastify 5.8.5 → 5.10.0

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
   */
@@ -364,6 +371,12 @@ const codes = {
     400,
     URIError
   ),
+  FST_ERR_MAX_PARAM_LENGTH: createError(
+    'FST_ERR_MAX_PARAM_LENGTH',
+    "'%s' is exceeding the max param length",
+    414,
+    URIError
+  ),
   FST_ERR_ASYNC_CONSTRAINT: createError(
     'FST_ERR_ASYNC_CONSTRAINT',
     'Unexpected error from async constraint',
@@ -408,6 +421,12 @@ const codes = {
     '%s method is not supported.',
     500
   ),
+  FST_ERR_ROUTE_LOG_LEVEL_INVALID: createError(
+    'FST_ERR_ROUTE_LOG_LEVEL_INVALID',
+    "Log level for '%s:%s' route must be a valid logger level. Received: '%s'",
+    500,
+    TypeError
+  ),
   FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED: createError(
     'FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED',
     'Body validation schema for %s:%s route is not supported!',
@@ -470,7 +489,10 @@ const codes = {
     500,
     TypeError
   ),
-
+  FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED: createError(
+    'FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED',
+    "The dependency '%s' of plugin '%s' is not registered"
+  ),
   /**
    *  Avvio Errors
    */

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,11 +30,15 @@ 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({ onBadUrl: createOnBadUrl(), defaultRoute: fourOhFourFallBack })
-  let _onBadUrlHandler = null
+  const router = FindMyWay({
+    onBadUrl: createRouteEventHandler(),
+    onMaxParamLength: createRouteEventHandler(),
+    defaultRoute: fourOhFourFallBack
+  })
+  let _routeEventHandler = null
 
   return { router, setNotFoundHandler, setContext, arrange404 }
 
@@ -43,32 +48,29 @@ function fourOhFour (options) {
     instance[kCanSetNotFoundHandler] = true
     // we need to bind instance for the context
     router.onBadUrl = router.onBadUrl.bind(instance)
+    router.onMaxParamLength = router.onMaxParamLength.bind(instance)
     router.defaultRoute = router.defaultRoute.bind(instance)
   }
 
   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
     })
   }
 
-  function createOnBadUrl () {
-    return function onBadUrl (path, req, res) {
+  function createRouteEventHandler () {
+    return function onRouteEvent (path, req, res) {
       const fourOhFourContext = this[kFourOhFourLevelInstance][kFourOhFourContext]
       const id = getGenReqId(fourOhFourContext.server, req)
       const childLogger = createChildLogger(fourOhFourContext, logger, req, id)
       const request = new Request(id, null, req, null, childLogger, fourOhFourContext)
       const reply = new Reply(res, request, childLogger)
 
-      _onBadUrlHandler(request, reply)
+      _routeEventHandler(request, reply)
     }
   }
 
@@ -121,12 +123,12 @@ function fourOhFour (options) {
     if (handler) {
       this[kFourOhFourLevelInstance][kCanSetNotFoundHandler] = false
       handler = handler.bind(this)
-      // update onBadUrl handler
-      _onBadUrlHandler = handler
+      // update route event handler
+      _routeEventHandler = handler
     } else {
       handler = basic404
-      // update onBadUrl handler
-      _onBadUrlHandler = basic404
+      // update route event handler
+      _routeEventHandler = basic404
     }
 
     this.after((notHandledErr, done) => {
@@ -176,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

@@ -1,7 +1,6 @@
 'use strict'
 
 const diagnostics = require('node:diagnostics_channel')
-const ContentType = require('./content-type')
 const wrapThenable = require('./wrap-thenable')
 const { validate: validateSchema } = require('./validation')
 const { preValidationHookRunner, preHandlerHookRunner } = require('./hooks')
@@ -11,8 +10,11 @@ const {
   kReplyIsError,
   kRouteContext,
   kFourOhFourContext,
-  kSupportedHTTPMethods
+  kSupportedHTTPMethods,
+  kRequestContentType,
+  kDiagnosticsStore
 } = require('./symbols')
+const ContentType = require('./content-type')
 
 const channels = diagnostics.tracingChannel('fastify.request.handler')
 
@@ -51,13 +53,17 @@ function handleRequest (err, request, reply) {
       return
     }
 
-    const contentType = new ContentType(ctHeader)
-    if (contentType.isValid === false) {
+    // Conditional assignment to avoid creating a new ContentType instance
+    // It can be assigned when accessing the .mediaType in hooks
+    if (!request[kRequestContentType]) {
+      request[kRequestContentType] = ContentType.from(ctHeader)
+    }
+    if (request[kRequestContentType].isValid === false) {
       reply[kReplyIsError] = true
       reply.status(415).send(new FST_ERR_CTP_INVALID_MEDIA_TYPE())
       return
     }
-    request[kRouteContext].contentTypeParser.run(contentType.toString(), handler, request, reply)
+    request[kRouteContext].contentTypeParser.run(request[kRequestContentType].toString(), handler, request, reply)
     return
   }
 
@@ -142,6 +148,7 @@ function preHandlerCallback (err, request, reply) {
         method: context.config.method
       }
     }
+    reply[kDiagnosticsStore] = store
     channels.start.runStores(store, preHandlerCallbackInner, undefined, err, request, reply, store)
   }
 }

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
 }

package/lib/plugin-override.js

@@ -82,7 +82,8 @@ function buildRoutePrefix (instancePrefix, pluginPrefix) {
   if (instancePrefix.endsWith('/') && pluginPrefix[0] === '/') {
     // Remove the extra '/' to avoid: '/first//second'
     pluginPrefix = pluginPrefix.slice(1)
-  } else if (pluginPrefix[0] !== '/') {
+  } else if (pluginPrefix[0] !== '/' && !instancePrefix.endsWith('/')) {
+    // Add the missing '/' to avoid: '/firstsecond'
     pluginPrefix = '/' + pluginPrefix
   }
 

package/lib/plugin-utils.js

@@ -10,7 +10,8 @@ const { exist, existReply, existRequest } = require('./decorate.js')
 const {
   FST_ERR_PLUGIN_VERSION_MISMATCH,
   FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE,
-  FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER
+  FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER,
+  FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED
 } = require('./errors.js')
 
 const rcRegex = /-(?:rc|pre|alpha).+$/u
@@ -70,10 +71,9 @@ function checkDependencies (fn) {
   assert(Array.isArray(dependencies), 'The dependencies should be an array of strings')
 
   dependencies.forEach(dependency => {
-    assert(
-      this[kRegisteredPlugins].indexOf(dependency) > -1,
-      `The dependency '${dependency}' of plugin '${meta.name}' is not registered`
-    )
+    if (!this[kRegisteredPlugins].includes(dependency)) {
+      throw new FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED(dependency, meta.name)
+    }
   })
 }