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

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

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

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

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').

Practice

1. What is the main purpose of a request timing middleware in FastAPI?

easy

A. To convert JSON data to Python objects

B. To handle user authentication automatically

C. To serve static files faster

D. To measure how long each HTTP request takes to process

Solution

1. Step 1: Understand middleware role

   Middleware runs code before and after each request to add extra features.

2. Step 2: Identify timing middleware purpose

   Request timing middleware specifically measures the time taken to process requests.

3. Final Answer:

   To measure how long each HTTP request takes to process -> Option D

4. Quick Check:

   Request timing = measure duration [OK]

Hint: Middleware timing measures request duration [OK]

Common Mistakes:

• Confusing timing middleware with authentication
• Thinking it serves static files
• Assuming it parses JSON data

2. Which of the following is the correct way to define a request timing middleware in FastAPI?

easy

A. @app.middleware('websocket')\nasync def timing_middleware(request, call_next):\n pass

B. @app.route('/middleware')\ndef timing_middleware(request):\n start = time.time()\n return 'Done'

C. @app.middleware('http')\nasync def timing_middleware(request, call_next):\n start = time.time()\n response = await call_next(request)\n duration = time.time() - start\n response.headers['X-Process-Time'] = str(duration)\n return response

D. def timing_middleware(request):\n start = time.time()\n return 'Middleware running'

Solution

1. Step 1: Check middleware decorator and signature

   FastAPI HTTP middleware uses @app.middleware('http') and async def with (request, call_next).

2. Step 2: Verify timing logic and response modification

   It records start time, awaits call_next(request), calculates duration, adds header, and returns response.

3. Final Answer:

   Correct async HTTP middleware with timing and header addition -> Option C

4. Quick Check:

   @app.middleware('http') + call_next + timing [OK]

Hint: Use @app.middleware('http') with async and call_next [OK]

Common Mistakes:

• Using @app.route instead of @app.middleware
• Missing async or call_next parameter
• Using websocket middleware for HTTP requests

3. Given this middleware code snippet, what will be added to the response headers after a request is processed?

import time
from fastapi import FastAPI
app = FastAPI()

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

medium

A. A header named 'Content-Length' with the size of the response

B. A header named 'X-Process-Time' with the request processing duration in seconds

C. A header named 'X-Request-ID' with a unique request identifier

D. No headers are added by this middleware

Solution

1. Step 1: Analyze header addition in middleware

   The code adds 'X-Process-Time' header with the calculated process_time value.

2. Step 2: Confirm header content meaning

   This header holds the duration in seconds the request took to process.

3. Final Answer:

   A header named 'X-Process-Time' with the request processing duration in seconds -> Option B

4. Quick Check:

   Header 'X-Process-Time' = duration seconds [OK]

Hint: Look for response.headers assignment for header name [OK]

Common Mistakes:

• Confusing header names added by middleware
• Assuming no headers are added
• Thinking it adds request ID or content length

4. Identify the error in this FastAPI request timing middleware code:

import time
from fastapi import FastAPI
app = FastAPI()

@app.middleware('http')
def timing_middleware(request, call_next):
    start = time.time()
    response = call_next(request)
    duration = time.time() - start
    response.headers['X-Time'] = str(duration)
    return response

medium

A. Missing async keyword and missing await before call_next(request)

B. Using time.time() instead of datetime.now()

C. Response headers cannot be modified in middleware

D. Middleware should be defined with @app.route decorator

Solution

1. Step 1: Check function signature and async usage

   Middleware must be async and await call_next(request) because call_next is async.

2. Step 2: Identify missing await and async

   Code lacks async def and await, causing runtime errors.

3. Final Answer:

   Missing async keyword and missing await before call_next(request) -> Option A

4. Quick Check:

   Async + await call_next required [OK]

Hint: Middleware must be async and await call_next(request) [OK]

Common Mistakes:

• Forgetting async keyword on middleware function
• Not awaiting call_next(request)
• Using wrong decorator like @app.route

5. You want to create a request timing middleware that logs the duration only if it exceeds 0.5 seconds. Which code snippet correctly implements this behavior?

hard

A. @app.middleware('http')\nasync def timing_middleware(request, call_next):\n start = time.time()\n response = await call_next(request)\n duration = time.time() - start\n if duration > 0.5:\n print(f'Request took {duration:.3f} seconds')\n return response

B. @app.middleware('http')\ndef timing_middleware(request, call_next):\n start = time.time()\n response = call_next(request)\n duration = time.time() - start\n if duration > 0.5:\n print('Slow request')\n return response

C. @app.middleware('http')\nasync def timing_middleware(request, call_next):\n response = await call_next(request)\n duration = time.time()\n if duration > 0.5:\n print('Request slow')\n return response

D. @app.middleware('http')\nasync def timing_middleware(request, call_next):\n start = time.time()\n response = await call_next(request)\n duration = start - time.time()\n if duration > 0.5:\n print('Request slow')\n return response

Solution

1. Step 1: Confirm async middleware and await call_next

   Middleware must be async and await call_next(request) to work properly.

2. Step 2: Check timing calculation and conditional logging

   Duration is end time minus start time; log only if duration > 0.5 seconds.

3. Step 3: Verify correct duration calculation and print statement

   Code with start = time.time(), await call_next, duration = time.time() - start, if duration > 0.5: print(f'Request took {duration:.3f} seconds') correctly calculates duration and prints formatted message conditionally.

4. Final Answer:

   Async middleware with correct timing and conditional logging if duration > 0.5s -> Option A

5. Quick Check:

   Async + await + correct timing + conditional print [OK]

Hint: Use async, await, and check duration > 0.5 before logging [OK]

Common Mistakes:

• Missing async or await in middleware
• Calculating duration incorrectly (start - end)
• Logging unconditionally or not at all