Why Request timing middleware in FastAPI? - Purpose & Use Cases

The Big Idea

Discover how one simple middleware can reveal hidden delays slowing down your app!

The Scenario

Imagine you want to know how long each web request takes in your FastAPI app, so you can find slow parts and improve them.

You try adding timers inside every route handler manually.

The Problem

Manually adding timers everywhere is tiring and easy to forget.

You might miss some routes or add inconsistent timing code.

This makes your code messy and hard to maintain.

The Solution

Request timing middleware automatically measures how long every request takes, no matter which route it hits.

You add it once, and it works everywhere consistently.

Before vs After

✗ Before

start = time.time()
response = await some_route_handler()
elapsed = time.time() - start
print(f"Request took {elapsed}s")

✓ After

app.add_middleware(RequestTimingMiddleware)
# Middleware logs time for all requests automatically

What It Enables

You can easily monitor and improve your app's speed without cluttering your route code.

Real Life Example

A developer adds request timing middleware to spot slow API calls and optimize database queries, improving user experience.

Key Takeaways

Manual timing is repetitive and error-prone.

Middleware centralizes timing logic for all requests.

This helps keep code clean and performance visible.

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