Request timing middleware in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the correct module for timing.

FastAPI

from fastapi import FastAPI
import [1]

app = FastAPI()

Drag options to blanks, or click blank then click option'

Atime

Bdatetime

Cos

Dsys

Attempts:

3 left

💡 Hint

Common Mistakes

Importing datetime instead of time

Using os or sys which are unrelated to timing

The time module provides functions to measure time intervals, which is needed for timing requests.

2fill in blank

medium

Complete the code to define a middleware function that records the start time.

FastAPI

@app.middleware("http")
async def add_process_time_header(request, call_next):
    start_time = [1]()
    response = await call_next(request)
    return response

Drag options to blanks, or click blank then click option'

Atime.sleep

Btime.time

Cdatetime.now

Dtime.clock

Attempts:

3 left

💡 Hint

Common Mistakes

Using datetime.now which returns a datetime object

Using time.sleep which pauses execution

Using deprecated time.clock

time.time() returns the current time in seconds since the epoch, useful for measuring elapsed time.

3fill in blank

hard

Fix the error in calculating the process time by completing the blank.

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() [1] start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

Drag options to blanks, or click blank then click option'

A/

B+

C-

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Adding times instead of subtracting

Multiplying or dividing times which is incorrect

To find the elapsed time, subtract the start time from the current time.

4fill in blank

hard

Fill both blanks to convert the process time to milliseconds and add it to the response headers.

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) [1] 1000
    response.headers["X-Process-Time-ms"] = str(round(process_time, [2]))
    return response

Drag options to blanks, or click blank then click option'

A*

B//

C4

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using integer division instead of multiplication

Using addition instead of multiplication

Using wrong number of decimals like 5 or 3

Multiply seconds by 1000 to get milliseconds. Then round to 4 decimal places using round(process_time, 4).

5fill in blank

hard

Fill all three blanks to create a complete middleware that measures request time and adds it as a header rounded to 3 decimals.

FastAPI

from fastapi import FastAPI
import time

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request, call_next):
    start = [1]()
    response = await call_next(request)
    duration = [3]() - start
    response.headers["X-Process-Time"] = str(round(duration, [2]))
    return response

@app.get("/")
async def root():
    return {"message": "Hello World"}

Drag options to blanks, or click blank then click option'

Atime.time

Btime.sleep

C3

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using sleep instead of time for start

Not rounding or rounding to wrong decimal places

Use time.time() to get the start time, and round the duration to 3 decimals for readability.

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