Request timing middleware in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this FastAPI middleware output?

Consider this FastAPI middleware that measures request processing time and adds it to the response headers. What will be the value of the header 'X-Process-Time' in the response?

FastAPI

from fastapi import FastAPI, Request
import time

app = FastAPI()

@app.middleware('http')
async def add_process_time_header(request: 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

A A string representing the time in seconds it took to process the request, e.g., '0.0023'

B The current timestamp in seconds since epoch as a string

C The total number of requests processed so far as an integer string

D The HTTP status code of the response as a string

💡 Hint

Think about what time.time() measures and how the difference is used.

The middleware records the time before and after processing the request. The difference is the processing time in seconds, which is added as a string to the 'X-Process-Time' header.

📝 Syntax

intermediate

Identify the syntax error in this FastAPI middleware

Which option contains a syntax error that will prevent this FastAPI middleware from running?

FastAPI

from fastapi import FastAPI, Request
import time

app = FastAPI()

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

A Change 'response.headers['X-Duration'] = str(duration)' to 'response.headers.X-Duration = duration' (invalid attribute assignment)

B Remove 'async' keyword from the function definition (will cause error because 'await' is used)

C Replace 'await call_next(request)' with 'call_next(request)' (missing await causes error)

D Change @app.middleware('http') to @app.middleware('http') with parentheses as shown (correct syntax)

💡 Hint

Remember that 'await' can only be used inside async functions.

Removing 'async' causes a syntax error because 'await' is used inside the function. The function must be async to use await.

🔧 Debug

advanced

Why does this middleware not add the timing header?

This middleware is intended to add a header 'X-Time' with the request duration, but the header is missing in responses. What is the cause?

FastAPI

from fastapi import FastAPI, Request
import time

app = FastAPI()

@app.middleware('http')
async def timing(request: Request, call_next):
    start = time.time()
    response = call_next(request)  # Missing await
    duration = time.time() - start
    response.headers['X-Time'] = str(duration)
    return response

A The middleware must be synchronous, not async, to modify headers

B The time.time() function is called before the request processing, so duration is always zero

C The header name 'X-Time' is invalid and ignored by FastAPI

D The call_next function is not awaited, so response is a coroutine, not a response object

💡 Hint

Check how async functions and await work with call_next.

call_next returns a coroutine that must be awaited to get the response object. Without await, response is not a response object, so headers cannot be set.

❓ state_output

advanced

What is the output of this middleware with nested calls?

Given this middleware that adds timing and a route that calls another route internally, what will be the value of 'X-Process-Time' in the final response?

FastAPI

from fastapi import FastAPI, Request
import time

app = FastAPI()

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

@app.get('/inner')
async def inner():
    time.sleep(0.1)
    return {'message': 'inner'}

@app.get('/outer')
async def outer():
    from fastapi.testclient import TestClient
    client = TestClient(app)
    res = client.get('/inner')
    return {'inner_response': res.json()}

A The 'X-Process-Time' header shows the combined time of '/outer' and '/inner' requests

B The 'X-Process-Time' header is missing because TestClient blocks header propagation

C The 'X-Process-Time' header shows the time taken to process the '/outer' request only, excluding '/inner' internal call

D The middleware raises an error because time.sleep is blocking in async code

💡 Hint

Think about how TestClient calls are separate HTTP requests.

The middleware measures time per HTTP request. The internal TestClient call to '/inner' is a separate request, so the timing header on '/outer' only measures its own processing time.

🧠 Conceptual

expert

What is the best way to ensure accurate request timing in FastAPI middleware?

Which approach ensures the most accurate measurement of request processing time in FastAPI middleware?

A Record start time before calling call_next, await call_next, then record end time immediately after to calculate duration

B Record start time inside the route handler and pass it to middleware via request state

C Use time.sleep to simulate processing delay and measure time after sleep

D Add a background task to measure time asynchronously after response is sent

💡 Hint

Middleware wraps the entire request processing.

Measuring time before and after awaiting call_next captures the full request processing time including route handler and other middleware.

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