Middleware error handling inconsistencies

[MorganGellert]

Hi. I was writing an ASGI middleware and noticed some odd error handling behavior if an exception is raised in the receive callback.

With no other middleware lower on the stack (later in the list of middleware), HTTPExceptions are handled as expected and land on exception handlers as expected. (In code below set trigger to ExceptionTrigger.HTTP_EXCEPTION or ExceptionTrigger.HTTP_EXCEPTION_ALT.)

However if the middleware lower on the stack calls request.body() it will raise the HTTPException in the callback and it will not be caught by the exception handler stack resulting in a 500 response from the server. (In code below set trigger to ExceptionTrigger.UNCAUGHT.)

Strangest of all, if there is a BaseHTTPMiddleware lower on the stack that does not call request.body() then the ExceptionGroup is not parsed apart properly but an ExceptionGroup can be caught by the exception handler stack. (In code below set trigger to ExceptionTrigger.EXCEPTION_GROUP.)

I tried to do a thorough search of the Discussions for middleware exception issues and didn't find these exact problems. This broke my brain for a while so let me know if I can answer any questions!

(Using python 3.13.0 and starlette 0.48.0.)

Thanks so much!

from exceptiongroup import ExceptionGroup
from enum import Enum

from starlette.applications import Starlette
from starlette.exceptions import HTTPException
from starlette.middleware import Middleware
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.responses import PlainTextResponse
from starlette.routing import Route
from starlette.testclient import TestClient

class ExceptionTrigger(Enum):
    EXCEPTION_GROUP = 1
    HTTP_EXCEPTION = 2
    HTTP_EXCEPTION_ALT = 3
    UNCAUGHT = 4

trigger = ExceptionTrigger.UNCAUGHT

async def test_route(request):
    # Calling request.body raises a caught Exception
    # Exception handler gets an HTTPException if there is no BaseHTTPMiddleware
    # higher on the middleware stack
    # Otherwise it gets an ExceptionGroup
    print("in test route")
    body = await request.body()
    return PlainTextResponse("Hello world")

routes = [
    Route("/", endpoint=test_route, methods=["POST"])
]

class TestASGIMiddleware():
    def __init__(self, app):
        self.app = app

    async def __call__(self, scope, receive, send):

        async def receive_override():
            message = await receive()

            raise HTTPException(410, "Something bad happened")
            return message

        try:

            await self.app(scope, receive_override, send)
        except Exception as e:
            print(f"An error has occurred: {e}")
            raise

class TestRequestBodyMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        try:

            # Call reqeust.body here to raise an uncaught
            # exception
            body = await request.body()

            response = await call_next(request)
            return response
        except Exception as e:
            print(type(e))
            print(e)
            raise

class TestPassthroughMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        response = await call_next(request)
        return response

middleware = []

# Putting the request body middleware call earlier on the
# middleware stack results in a handled 410 instead of uncaught if it
# is lower on the stack
if trigger == ExceptionTrigger.HTTP_EXCEPTION_ALT:
    middleware.append(Middleware(TestRequestBodyMiddleware))

middleware.append(Middleware(TestASGIMiddleware))

# Calling request.body from middleware later on the stack raises an uncaught exception
if trigger == ExceptionTrigger.UNCAUGHT:
    middleware.append(Middleware(TestRequestBodyMiddleware))

# Adding a passthrough middleware later on the stack raises an ExceptionGroup
elif trigger == ExceptionTrigger.EXCEPTION_GROUP:
    middleware.append(Middleware(TestPassthroughMiddleware))


def exception_handler_410(request, exc):
    print("410 exception handler")
    return PlainTextResponse("410 response handler response")

def exception_handler_exception_group(request, exc):
    print("exception group exception handler")
    return PlainTextResponse("exception group response handler response")

exception_handlers = {
    410: exception_handler_410,
    ExceptionGroup: exception_handler_exception_group
}

app = Starlette(
    debug=True,
    routes=routes,
    middleware=middleware,
    exception_handlers=exception_handlers
)

if __name__ == "__main__":
    try:
        client = TestClient(app)
        response = client.post('/', data="{}")

        print("Got response:")
        print(response.status_code)
        print(response.content)

    except Exception as e:
        print("MAIN ERROR HANDLING")
        print(type(e))
        print(e)