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.