Exception middleware in Django - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a middleware class that catches exceptions.

Django

class ExceptionMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        try:
            response = self.get_response(request)
        except [1] as e:
            response = self.handle_exception(e)
        return response

    def handle_exception(self, exception):
        # Handle exception here
        pass

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

AError

Brequest

Cresponse

DException

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'Error' which is not a base exception class in Python.

Catching 'request' or 'response' which are not exception types.

The middleware should catch the base Exception class to handle all exceptions.

2fill in blank

medium

Complete the code to import the middleware in Django settings.

Django

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'myapp.middleware.[1]',
    'django.middleware.common.CommonMiddleware',
]

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

ASecurityMiddleware

BExceptionMiddleware

CCommonMiddleware

DSessionMiddleware

Attempts:

3 left

💡 Hint

Common Mistakes

Using built-in middleware names instead of the custom one.

Misspelling the middleware class name.

You need to add your custom ExceptionMiddleware to the MIDDLEWARE list by its full path.

3fill in blank

hard

Fix the error in the middleware method to correctly return an HTTP response on exception.

Django

from django.http import HttpResponse

class ExceptionMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        try:
            response = self.get_response(request)
        except Exception as e:
            response = [1]('An error occurred', status=500)
        return response

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

AHttpResponse

BHttpRequest

CHttp404

DHttpError

Attempts:

3 left

💡 Hint

Common Mistakes

Using HttpRequest which is for requests, not responses.

Using Http404 which raises an exception, not returns a response.

HttpResponse is used to create an HTTP response with a status code.

4fill in blank

hard

Fill both blanks to log the exception message and return a simple error response.

Django

import logging
from django.http import HttpResponse

logger = logging.getLogger(__name__)

class ExceptionMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        try:
            response = self.get_response(request)
        except Exception as e:
            logger.[1](str(e))
            response = HttpResponse('Error occurred', status=[2])
        return response

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

Aerror

Bwarning

C404

D500

Attempts:

3 left

💡 Hint

Common Mistakes

Using logger.warning which is less severe than error.

Returning status 404 which means not found, not server error.

Use logger.error to log errors and return HTTP status 500 for server errors.

5fill in blank

hard

Fill all three blanks to create a middleware that logs exceptions, returns JSON error response, and sets content type.

Django

import logging
import json
from django.http import HttpResponse

logger = logging.getLogger(__name__)

class ExceptionMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        try:
            response = self.get_response(request)
        except Exception as e:
            logger.[1](str(e))
            error_content = json.dumps({'error': 'Server error'})
            response = HttpResponse(error_content, status=[2])
            response['Content-Type'] = [3]
        return response

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

Aerror

B500

C'application/json'

Dwarning

Attempts:

3 left

💡 Hint

Common Mistakes

Using logger.warning instead of error.

Setting wrong content type like 'text/html'.

Using status 404 instead of 500.

Log the error with logger.error, return status 500, and set content type to 'application/json'.

Practice

1. What is the main purpose of exception middleware in Django?

easy

A. To catch errors during request processing and handle them gracefully

B. To speed up database queries

C. To serve static files like images and CSS

D. To manage user authentication sessions

Solution

1. Step 1: Understand middleware role

   Middleware processes requests and responses in Django, and exception middleware specifically handles errors.

2. Step 2: Identify exception middleware purpose

   Its job is to catch exceptions during request handling and provide friendly error messages or logging.

3. Final Answer:

   To catch errors during request processing and handle them gracefully -> Option A

4. Quick Check:

   Exception middleware = catch errors [OK]

Hint: Exception middleware catches errors in requests [OK]

Common Mistakes:

• Confusing middleware with static file serving
• Thinking it manages database queries
• Assuming it handles user sessions

2. Which method must be implemented in a Django exception middleware class to process requests?

easy

A. __init__

B. __call__

C. process_exception

D. handle_request

Solution

1. Step 1: Recall middleware structure

   Django middleware classes require an __init__ and a __call__ method to be callable.

2. Step 2: Identify request processing method

   The __call__ method is called for each request and is where exception handling happens.

3. Final Answer:

   __call__ -> Option B

4. Quick Check:

   Request processing method = __call__ [OK]

Hint: Middleware uses __call__ to handle requests [OK]

Common Mistakes:

• Choosing process_exception which is for old-style middleware
• Confusing __init__ as request handler
• Inventing non-existent handle_request method

3. Given this middleware snippet, what will be the output if a ZeroDivisionError occurs during request processing?

class ExceptionMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        try:
            response = self.get_response(request)
        except ZeroDivisionError:
            return HttpResponse('Division error caught')
        return response

medium

A. The original response from get_response

B. A server error 500 page

C. No response, request hangs

D. HttpResponse with text 'Division error caught'

Solution

1. Step 1: Analyze try-except block

   The middleware calls get_response inside try; if ZeroDivisionError occurs, it returns a custom HttpResponse.

2. Step 2: Determine output on error

   When ZeroDivisionError happens, the except block returns HttpResponse('Division error caught').

3. Final Answer:

   HttpResponse with text 'Division error caught' -> Option D

4. Quick Check:

   Error caught returns custom response [OK]

Hint: Exception triggers except block response [OK]

Common Mistakes:

• Assuming original response is returned despite error
• Expecting default 500 error page
• Thinking request will hang without response

4. Identify the error in this exception middleware code:

class ExceptionMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        try:
            response = self.get_response(request)
        except Exception as e:
            print('Error:', e)
        return response

medium

A. No __init__ method defined

B. Incorrect method name __call__

C. Missing return statement inside except block

D. Using print instead of logging

Solution

1. Step 1: Check exception handling flow

   If an exception occurs, except block prints error but does not return a response.

2. Step 2: Understand middleware response requirement

   Middleware must always return a response; missing return in except causes NameError or no response.

3. Final Answer:

   Missing return statement inside except block -> Option C

4. Quick Check:

   Exception block must return response [OK]

Hint: Always return response in except block [OK]

Common Mistakes:

• Ignoring missing return causes runtime error
• Thinking print is enough for error handling
• Confusing method names or missing __init__

5. You want to create exception middleware that logs errors and returns a JSON error response with status 500. Which code snippet correctly implements this behavior?

import json
from django.http import HttpResponse

class ExceptionMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        try:
            response = self.get_response(request)
        except Exception as e:
            # Log the error
            print(f'Error: {e}')
            # Return JSON error response
            error_content = json.dumps({'error': 'Server error'})
            return HttpResponse(error_content, content_type='application/json', status=500)
        return response

hard

A. Correctly logs error and returns JSON response with status 500

B. Does not log error, only returns JSON response

C. Returns HTML response instead of JSON

D. Raises exception instead of handling it

Solution

1. Step 1: Check error logging

   The except block prints the error, which acts as logging here.

2. Step 2: Verify JSON response and status

   It returns HttpResponse with JSON content, correct content_type, and status 500.

3. Final Answer:

   Correctly logs error and returns JSON response with status 500 -> Option A

4. Quick Check:

   Logs error + JSON 500 response [OK]

Hint: Print error then return JSON with status 500 [OK]

Common Mistakes:

• Forgetting to set content_type to application/json
• Not returning response in except block
• Raising exception instead of handling