Request timing middleware in FastAPI - Mini Project: Build & Apply

Request timing middleware

📖 Scenario: You are building a web API using FastAPI. You want to measure how long each request takes to process. This helps you understand the speed of your API and find slow parts.

🎯 Goal: Create a middleware in FastAPI that records the time before and after handling a request. Then add a custom header X-Process-Time to the response showing the time taken in seconds.

📋 What You'll Learn

Create a FastAPI app instance called app

Create a middleware function called request_timing_middleware

Use time.perf_counter() to measure start and end times

Add a header X-Process-Time with the elapsed time to the response

Register the middleware with the FastAPI app using app.middleware('http')

💡 Why This Matters

🌍 Real World

Measuring request processing time helps developers monitor API performance and detect slow endpoints in real time.

💼 Career

Middleware skills are essential for backend developers working with FastAPI or similar frameworks to add cross-cutting features like logging, timing, and authentication.

1

Create the FastAPI app instance

Create a FastAPI app instance called app by importing FastAPI and calling FastAPI().

FastAPI

# Create a FastAPI app instance called app
# Your code here

Need a hint?

Import FastAPI from fastapi and create app = FastAPI().

2

Import time and define middleware function

Import the time module. Define a middleware function called request_timing_middleware that takes request and call_next as parameters.

FastAPI

from fastapi import FastAPI

app = FastAPI()

# Import time module
# Define middleware function request_timing_middleware(request, call_next)
# Your code here

Need a hint?

Use import time and define the function header def request_timing_middleware(request, call_next):.

3

Measure request time and get response

Inside request_timing_middleware, use time.perf_counter() to record the start time in a variable called start_time. Then call call_next(request) and save the result in a variable called response. After that, record the end time in a variable called end_time using time.perf_counter() again.

FastAPI

from fastapi import FastAPI
import time

app = FastAPI()

def request_timing_middleware(request, call_next):
    # Record start time
    # Call next middleware or endpoint
    # Record end time
    # Your code here

Need a hint?

Use start_time = time.perf_counter(), then response = call_next(request), then end_time = time.perf_counter().

4

Add header and register middleware

Calculate the elapsed time as end_time - start_time and convert it to a string. Add this as a header X-Process-Time to the response.headers. Return the response. Finally, register the middleware function with the FastAPI app using the decorator @app.middleware('http') above the middleware function definition.

FastAPI

from fastapi import FastAPI
import time

app = FastAPI()

@app.middleware('http')
def request_timing_middleware(request, call_next):
    start_time = time.perf_counter()
    response = call_next(request)
    end_time = time.perf_counter()
    # Calculate elapsed time
    # Add X-Process-Time header to response
    # Return response
    # Your code here

Need a hint?

Calculate process_time = str(end_time - start_time), add header with response.headers['X-Process-Time'] = process_time, return response, and decorate with @app.middleware('http').