Global exception middleware in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the correct FastAPI class.

FastAPI

from fastapi import [1]
app = FastAPI()

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

ADepends

BRequest

CResponse

DFastAPI

Attempts:

3 left

💡 Hint

Common Mistakes

Importing Request or Response instead of FastAPI.

Using lowercase fastapi instead of FastAPI.

The FastAPI class is imported from fastapi to create the app instance.

2fill in blank

medium

Complete the code to import the ExceptionMiddleware from Starlette.

FastAPI

from starlette.middleware.errors import [1]

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

AExceptionMiddleware

BBaseHTTPMiddleware

CMiddleware

DErrorMiddleware

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing ExceptionMiddleware with BaseHTTPMiddleware.

Using Middleware or ErrorMiddleware which do not exist in this context.

ExceptionMiddleware is the middleware class used to catch global exceptions.

3fill in blank

hard

Fix the error in the middleware setup by completing the missing argument.

FastAPI

app.add_middleware(ExceptionMiddleware, app=[1], debug=False)

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

Arequest

Bself

Capp

Dmiddleware

Attempts:

3 left

💡 Hint

Common Mistakes

Passing 'request' or 'self' which are not the app instance.

Omitting the app argument entirely.

The ExceptionMiddleware requires the app instance passed as the 'app' argument.

4fill in blank

hard

Fill both blanks to define a global exception handler function that returns JSON response.

FastAPI

from fastapi.responses import JSONResponse

@app.exception_handler([1])
async def global_exception_handler(request, exc):
    return JSONResponse(status_code=500, content={"detail": [2])

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

AException

B"An error occurred"

Cexc.detail

D"Internal Server Error"

Attempts:

3 left

💡 Hint

Common Mistakes

Using a specific exception class instead of Exception.

Returning exc.detail which may not exist.

The handler catches all Exceptions and returns a JSON with a simple error message.

5fill in blank

hard

Fill all three blanks to create a middleware that logs exceptions and re-raises them.

FastAPI

from starlette.middleware.base import BaseHTTPMiddleware

class LoggingExceptionMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        try:
            response = await call_next(request)
            return response
        except [1] as exc:
            print(f"Error: [2]")
            raise [3]

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

AException

Bexc

DRuntimeError

Attempts:

3 left

💡 Hint

Common Mistakes

Catching RuntimeError instead of all Exceptions.

Printing wrong variable or re-raising a different exception.

The middleware catches all exceptions, logs the exception object, and re-raises it.

Practice

1. What is the main purpose of global exception middleware in a FastAPI application?

easy

A. To automatically generate API documentation

B. To speed up the API response time by caching results

C. To manage database connections efficiently

D. To catch and handle errors for the entire application in one place

Solution

1. Step 1: Understand middleware role

   Middleware runs for every request and can intercept errors globally.

2. Step 2: Identify purpose of global exception middleware

   It catches errors from any part of the app and handles them centrally.

3. Final Answer:

   To catch and handle errors for the entire application in one place -> Option D

4. Quick Check:

   Global error handling = catch all errors [OK]

Hint: Global middleware handles all errors in one place [OK]

Common Mistakes:

• Confusing middleware with caching or documentation
• Thinking it manages database connections
• Assuming it only handles specific routes

2. Which of the following is the correct way to add a global exception middleware in FastAPI?

easy

A. app.use_middleware(ExceptionMiddleware, handler=custom_handler)

B. app.add_middleware(ExceptionMiddleware, handler=custom_handler)

C. app.middleware(ExceptionMiddleware, handler=custom_handler)

D. app.register_middleware(ExceptionMiddleware, handler=custom_handler)

Solution

1. Step 1: Recall FastAPI middleware syntax

   FastAPI uses add_middleware method to add middleware.

2. Step 2: Match correct method name

   Only add_middleware is valid; others are incorrect method names.

3. Final Answer:

   app.add_middleware(ExceptionMiddleware, handler=custom_handler) -> Option B

4. Quick Check:

   Use add_middleware() to add middleware [OK]

Hint: Use add_middleware() method to add middleware [OK]

Common Mistakes:

• Using incorrect method names like use_middleware or register_middleware
• Confusing middleware with route decorators
• Missing required parameters in add_middleware

3. Given this FastAPI middleware code snippet, what will be the response if a ValueError is raised inside a route?

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.middleware("http")
async def catch_exceptions_middleware(request: Request, call_next):
    try:
        response = await call_next(request)
        return response
    except ValueError as e:
        return JSONResponse(status_code=400, content={"error": str(e)})

@app.get("/test")
async def test_route():
    raise ValueError("Invalid input")

medium

A. {"detail": "ValueError"} with status 422

B. 500 Internal Server Error with default HTML page

C. {"error": "Invalid input"} with status 400

D. Empty response with status 200

Solution

1. Step 1: Analyze middleware error handling

   The middleware catches ValueError and returns JSONResponse with status 400 and error message.

2. Step 2: Check route behavior

   The route raises ValueError("Invalid input"), triggering the middleware's except block.

3. Final Answer:

   {"error": "Invalid input"} with status 400 -> Option C

4. Quick Check:

   Middleware catches ValueError and returns JSON error [OK]

Hint: Middleware catches ValueError and returns JSON with status 400 [OK]

Common Mistakes:

• Assuming default 500 error instead of custom JSON response
• Confusing status codes 422 and 400
• Ignoring middleware and expecting normal route error

4. Identify the error in this FastAPI global exception middleware code:

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse

app = FastAPI()

@app.middleware("http")
async def exception_middleware(request: Request, call_next):
    try:
        response = call_next(request)
        return response
    except Exception as e:
        return JSONResponse(status_code=500, content={"error": "Server error"})

medium

A. Missing await before call_next(request)

B. Incorrect exception type used

C. JSONResponse should not be returned in middleware

D. Middleware should not catch exceptions

Solution

1. Step 1: Check async call to call_next

   call_next is an async function and must be awaited.

2. Step 2: Identify missing await

   Code calls call_next(request) without await, causing a coroutine object to be returned instead of response.

3. Final Answer:

   Missing await before call_next(request) -> Option A

4. Quick Check:

   Always await async call_next() in middleware [OK]

Hint: Always await call_next(request) in async middleware [OK]

Common Mistakes:

• Forgetting to await async call_next
• Thinking JSONResponse can't be returned in middleware
• Believing middleware shouldn't catch exceptions

5. You want to create a global exception middleware in FastAPI that logs all exceptions and returns a JSON error with status 500. Which code snippet correctly implements this behavior?

hard

A. @app.middleware('http')
async def global_exception(request, call_next):
try:
return await call_next(request)
except Exception as e:
print(f"Error: {e}")
return JSONResponse(status_code=500, content={"error": "Internal server error"})

B. app.add_middleware(ExceptionMiddleware, handler=lambda req, exc: JSONResponse({"error": str(exc)}, status_code=500))

C. @app.exception_handler(Exception)
async def global_exception_handler(request, exc):
return JSONResponse(status_code=500, content={"error": str(exc)})

D. app.add_exception_handler(Exception, lambda request, exc: JSONResponse({"error": "Error occurred"}, status_code=500))

Solution

1. Step 1: Understand middleware vs exception handler

   Middleware wraps all requests and can catch exceptions globally; exception handlers are per-exception but not middleware.

2. Step 2: Check for logging and JSON response in middleware

   @app.middleware('http') async def global_exception(request, call_next): try: return await call_next(request) except Exception as e: print(f"Error: {e}") return JSONResponse(status_code=500, content={"error": "Internal server error"}) uses @app.middleware('http') with try-except, logs error with print, and returns JSONResponse with status 500.

3. Step 3: Verify other options

   app.add_middleware(ExceptionMiddleware, handler=lambda req, exc: JSONResponse({"error": str(exc)}, status_code=500)) uses add_middleware incorrectly; C and D are exception handlers, not middleware.

4. Final Answer:

   @app.middleware('http') async def global_exception(request, call_next): try: return await call_next(request) except Exception as e: print(f"Error: {e}") return JSONResponse(status_code=500, content={"error": "Internal server error"}) -> Option A

5. Quick Check:

   Middleware with try-except and logging = @app.middleware('http') async def global_exception(request, call_next): try: return await call_next(request) except Exception as e: print(f"Error: {e}") return JSONResponse(status_code=500, content={"error": "Internal server error"}) [OK]

Hint: Use @app.middleware('http') with try-except and logging [OK]

Common Mistakes:

• Confusing middleware with exception handlers
• Using add_middleware incorrectly for exceptions
• Not logging exceptions inside middleware