Fix MiddlewareNotUsed: ImproperlyConfigured: MIDDLEWARE contains 'myapp.middleware.RequestLogMiddleware' which does not define a __call__ method. in Django

This error means your custom middleware class is missing the required __call__ method or was written for the old-style MIDDLEWARE_CLASSES format. Fix it by ensuring your middleware accepts get_response in __init__ and implements __call__ to process the request, following Django's new-style middleware pattern.

Reading the Stack Trace

Here's what each line means:

• File "/venv/lib/python3.11/site-packages/django/core/handlers/base.py", line 57, in load_middleware: Django loads all middleware classes at startup and validates they follow the new-style middleware protocol.
• mw_instance = middleware(handler): Django passes the next handler to the middleware constructor, expecting the middleware to store it and call it in __call__.
• raise ImproperlyConfigured(: The middleware class does not implement the required __call__ method, so Django cannot use it in the middleware chain.

Common Causes

# myapp/middleware.py
class RequestLogMiddleware:
    def process_request(self, request):
        import logging
        logging.info(f'Request: {request.path}')

    def process_response(self, request, response):
        return response

class RequestLogMiddleware:
    def __init__(self):
        pass  # Missing get_response parameter

    def __call__(self, request):
        return self.get_response(request)  # AttributeError

# settings.py
MIDDLEWARE = [
    'myapp.middlware.RequestLogMiddleware',  # Typo: 'middlware'
]

The Fix

Convert the middleware to Django's new-style format: accept get_response in __init__, implement __call__ to handle the request/response cycle. The process_request and process_response hooks are replaced by code before and after calling self.get_response(request).

# myapp/middleware.py
class RequestLogMiddleware:
    def process_request(self, request):
        import logging
        logging.info(f'Request: {request.path}')

    def process_response(self, request, response):
        return response

# myapp/middleware.py
import logging

logger = logging.getLogger(__name__)


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

    def __call__(self, request):
        logger.info(f'Request: {request.method} {request.path}')
        response = self.get_response(request)
        logger.info(f'Response: {response.status_code}')
        return response

Testing the Fix

import pytest
from django.test import TestCase, Client, RequestFactory
from myapp.middleware import RequestLogMiddleware


class TestRequestLogMiddleware(TestCase):
    def setUp(self):
        self.factory = RequestFactory()

    def test_middleware_passes_request_through(self):
        def fake_get_response(request):
            from django.http import HttpResponse
            return HttpResponse('OK')

        middleware = RequestLogMiddleware(fake_get_response)
        request = self.factory.get('/test/')
        response = middleware(request)
        assert response.status_code == 200

    def test_middleware_logs_request(self, caplog):
        def fake_get_response(request):
            from django.http import HttpResponse
            return HttpResponse('OK')

        middleware = RequestLogMiddleware(fake_get_response)
        request = self.factory.get('/test/')
        with self.assertLogs('myapp.middleware', level='INFO') as cm:
            middleware(request)
        assert any('/test/' in msg for msg in cm.output)

    def test_middleware_integration(self):
        client = Client()
        response = client.get('/')
        assert response.status_code in (200, 302, 404)

Run your tests:

pytest

Pushing Through CI/CD

git checkout -b fix/middleware-new-style,git add myapp/middleware.py,git commit -m "fix: convert middleware to new-style with __init__ and __call__",git push origin fix/middleware-new-style

Your CI config should look something like this:

name: CI
on:
  pull_request:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.11'
          cache: 'pip'
      - run: pip install -r requirements.txt
      - run: python manage.py check
      - run: pytest --tb=short -q

The Full Manual Process: 18 Steps

Here's every step you just went through to fix this one bug:

1. Notice the error alert or see it in your monitoring tool
2. Open the error dashboard and read the stack trace
3. Identify the file and line number from the stack trace
4. Open your IDE and navigate to the file
5. Read the surrounding code to understand context
6. Reproduce the error locally
7. Identify the root cause
8. Write the fix
9. Run the test suite locally
10. Fix any failing tests
11. Write new tests covering the edge case
12. Run the full test suite again
13. Create a new git branch
14. Commit and push your changes
15. Open a pull request
16. Wait for code review
17. Merge and deploy to production
18. Monitor production to confirm the error is resolved

Total time: 30-60 minutes. For one bug.

pip install bugstack

import bugstack

bugstack.init(api_key=os.environ["BUGSTACK_API_KEY"])

Deploying the Fix (Manual Path)

1. Run the full test suite locally to confirm the middleware loads correctly.
2. Open a pull request with the middleware refactor.
3. Wait for CI checks including Django's system check to pass.
4. Have a teammate review and approve the PR.
5. Merge to main and verify the middleware works correctly in staging.

Frequently Asked Questions