FastAPI Middleware: Enhanced Logging Guide

Oct 23, 2025 by Jhon Lennon 43 views

Hey guys! Let's dive into how we can supercharge our FastAPI applications with some seriously useful middleware for logging. Trust me, good logging is the unsung hero of debugging and monitoring, so let's get it right!

Why Use Middleware for Logging in FastAPI?

Why should you even bother with middleware for logging in FastAPI? Great question! Think of middleware as that trusty gatekeeper in your application. It sits between the client's request and your application's endpoint, giving you a chance to intercept and modify the request or response. When it comes to logging, this is pure gold.

Here's the deal:

Centralized Logging: Middleware gives you a single place to log all incoming requests and outgoing responses. No more scattered logging statements throughout your codebase.
Request Context: You can easily capture crucial request information like headers, IP addresses, and the request body itself. This context is invaluable when you're trying to trace issues.
Response Monitoring: Similarly, you can log response status codes, response times, and even response bodies to keep an eye on your application's performance and identify bottlenecks.
Error Tracking: Middleware can catch exceptions and log them with all the relevant request context, making debugging a breeze.
Customization: You have complete control over what you log and how you log it. Tailor your logging to your specific application's needs.

Essentially, middleware-based logging provides a comprehensive and consistent way to monitor your FastAPI application, making it more robust and easier to maintain. Without middleware, you'd likely end up with ad-hoc logging scattered throughout your code, making it harder to manage and less effective. Embrace the power of middleware, and your future self will thank you!

Setting Up Basic Logging

Before we jump into middleware, let's make sure we have a basic logging setup in place. Python's logging module is your friend here. We'll configure it to output logs to the console and/or a file.

First, import the logging module:

import logging

Next, configure the logger. Here's an example that logs to both the console and a file:

import logging
import sys

# Get the root logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

# Create handlers
console_handler = logging.StreamHandler(sys.stdout)
file_handler = logging.FileHandler('app.log')

# Create formatters and add them to handlers
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

# Add handlers to the logger
logger.addHandler(console_handler)
logger.addHandler(file_handler)

# Example log message
logger.info('Application started')

Let's break down what's happening here:

logging.getLogger(__name__): This creates a logger instance. Using __name__ is a good practice because it names the logger after the module it's in.
logger.setLevel(logging.DEBUG): This sets the logging level to DEBUG. This means that all log messages with a level of DEBUG or higher (e.g., INFO, WARNING, ERROR, CRITICAL) will be logged.
logging.StreamHandler(sys.stdout): This creates a handler that outputs log messages to the console (standard output).
logging.FileHandler('app.log'): This creates a handler that writes log messages to a file named app.log.
logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'): This creates a formatter that defines the structure of the log messages. You can customize this to include different information.
console_handler.setFormatter(formatter) and file_handler.setFormatter(formatter): These set the formatter for each handler.
logger.addHandler(console_handler) and logger.addHandler(file_handler): These add the handlers to the logger.
logger.info('Application started'): This is an example of how to log a message.

With this setup, you'll have a basic logging system that outputs messages to both the console and a file. Now, let's move on to creating middleware to enhance this logging.

Creating a Logging Middleware

Alright, let's get our hands dirty and create some middleware! We'll build a simple middleware that logs the incoming request's method, path, and processing time. This will give you a solid foundation to build upon.

Here's the code:

import time
from fastapi import FastAPI, Request
from starlette.middleware.base import BaseHTTPMiddleware
import logging

logger = logging.getLogger(__name__)

class LoggingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        start_time = time.time()
        
        response = await call_next(request)
        
        process_time = time.time() - start_time
        formatted_process_time = '{0:.4f}'.format(process_time)
        logger.info(f"Request: {request.method} {request.url.path} - Process time: {formatted_process_time}s")
        
        return response


app = FastAPI()

app.add_middleware(LoggingMiddleware)


@app.get("/")
async def read_root():
    return {"Hello": "World"}

Let's break down the code:

from starlette.middleware.base import BaseHTTPMiddleware: We import BaseHTTPMiddleware from Starlette, which is the foundation for creating middleware in FastAPI.
class LoggingMiddleware(BaseHTTPMiddleware): We define a class LoggingMiddleware that inherits from BaseHTTPMiddleware.
async def dispatch(self, request: Request, call_next): This is the core of the middleware. The dispatch method is called for each request. It takes the request and a call_next function as arguments. call_next is an awaitable that will execute the next middleware in the chain or the actual endpoint if this is the last middleware.
start_time = time.time(): We record the start time of the request.
response = await call_next(request): We call the next middleware or the endpoint and get the response.
process_time = time.time() - start_time: We calculate the processing time.
`logger.info(f