Implementing custom middleware in FastAPI is like giving your API superpowers. Imagine being able to sneak in a little bit of magic before and after each request—it’s kind of like a behind-the-scenes superpower that can handle a bunch of important tasks, like logging, monitoring, and even performance profiling.

The Lowdown on FastAPI Middleware

So, FastAPI middleware is this cool thing that steps in every time a request hits your API. It gets in there, grabs the incoming requests before they hit the specific operation, and also snags the outgoing responses before they bounce back to the client. This detour allows you to throw in some generic operations, like logging all the details of a request or checking how much time it takes to handle one.

To whip up a middleware, you use something called the @app.middleware("http") decorator above a function. This function will grab the request object and a call_next function, which you need to forward the request to the desired operation and fetch the response back.

Making Logging Simple

Logging stuff is one of the most common uses for middleware. Think about it—you can log every little detail about each request and response, like the URL, method, headers, and status code. Here’s a snippet on how you might set it up:

import logging
from fastapi import FastAPI, Request
import time

app = FastAPI()

logging.basicConfig(filename='requests.log', level=logging.INFO)

@app.middleware("http")
async def log_requests(request: Request, call_next):
    start_time = time.perf_counter()
    response = await call_next(request)
    process_time = time.perf_counter() - start_time
    logging.info(f"Request: {request.method} {request.url} - Status: {response.status_code} - Process Time: {process_time:.2f} seconds")
    return response

With this, each request’s method, URL, status code, and processing time get logged. Handy, right?

Tacking on Custom Headers

Sometimes you need a little extra flair, like adding custom headers to responses. Let’s say you want a header showing how long each request took to process. Easy-peasy:

import time
from fastapi import FastAPI, Request

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.perf_counter()
    response = await call_next(request)
    process_time = time.perf_counter() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

Now, your responses boast a custom X-Process-Time header that tells you just how long everything took. Neat, huh?

Profiling Performance

To keep your API speedy and efficient, profiling its performance is a must. Middleware comes in handy for this too—it can log the time taken for each request, letting you spot performance bottlenecks. Check out this advanced way using a custom middleware class:

import time
from fastapi import FastAPI

class TimingMiddleware:
    def __init__(self, app):
        self.app = app

    async def __call__(self, scope, receive, send):
        start_time = time.time()
        await self.app(scope, receive, send)
        duration = time.time() - start_time
        print(f"Request duration: {duration:.2f} seconds")

app = FastAPI()
app.add_middleware(TimingMiddleware)

This middleware class will time each request and let you know how long it took, which is super useful for keeping things running smoothly.

Logging Raw HTTP Requests and Responses

Sometimes, you need to go hardcore and log the raw HTTP requests and responses. This is a bit tricky because you need to handle the request and response bodies without messing them up before they get processed. Here’s an example for this:

import logging
from fastapi import FastAPI, Request, Response
from starlette.background import BackgroundTask
from starlette.responses import StreamingResponse

app = FastAPI()
logging.basicConfig(filename='requests.log', level=logging.INFO)

def log_info(req_body, res_body):
    logging.info(f"Request Body: {req_body}")
    logging.info(f"Response Body: {res_body}")

@app.middleware("http")
async def log_raw_requests(request: Request, call_next):
    req_body = await request.body()
    response = await call_next(request)
    if isinstance(response, StreamingResponse):
        res_body = b''
        async for item in response.body_iterator:
            res_body += item
        task = BackgroundTask(log_info, req_body, res_body)
    else:
        task = BackgroundTask(log_info, req_body, response.body)
    response.background = task
    return response

This will log the raw request and response bodies while making sure it doesn’t slow down the response time.

Logging User Info

Whenever you need to log user information, like who made the request, you need to make sure the user is authenticated first. Middleware can help with authentication and then log the user details:

from fastapi import FastAPI, Request, Response
import logging

app = FastAPI()

@app.middleware("http")
async def log_user_info(request: Request, call_next):
    response = await call_next(request)
    if hasattr(request, 'user'):
        logging.info(f"User: {request.user} - Request: {request.method} {request.url} - Status: {response.status_code}")
    return response

Just remember, accessing request.user needs an authentication middleware in place, or you’ll hit errors.

Nailing It with Best Practices

There are a few pointers to keep in mind when cooking up middleware:

• Keep it light: Since middleware runs on every request, make sure it’s super lightweight to keep performance snappy.
• Background tasks are your friend: For things like logging, use background tasks to avoid delaying the response.
• Simple is better: Avoid tossing in complex logic within middleware. Keep it straightforward and focused.
• Test, test, test: Thorough testing is crucial to dodge any unexpected hiccups.

By following these tips and using the handy examples above, you can effectively implement custom middleware in FastAPI to handle logging and monitoring, boosting the reliability and performance of your API.

Wrapping Up

Custom middleware in FastAPI is like the unseen wizard behind the curtain, meticulously managing every request and response. Whether it’s logging details, adding headers, or profiling performance, middleware lets you sprinkle a little bit of magic to make sure your API runs smoothly and efficiently.

So, go ahead and experiment with these middleware examples. Tweak them to fit your needs, and watch as your FastAPI project transforms into a well-oiled machine. Keep it simple, keep it light, and most importantly, have fun coding!