Raise exception from background task on BaseHTTPMiddleware introduced a bug?

[ramannanda9]

Looking at this commit, it pushed the logic out to the end, but if there is an error raised and handled, it will reraise it again

Steps to reproduce.

   @app.get("/error")
    async def foo():
        exc = Exception("foobar")
        exc.status_code = 501
        raise exc

Middleware handler.

@app.middleware("http")
    async def http_middleware(request: Request, call_next):
          try:
                response = await call_next(request)
          except Exception as exc:
                logger.exception("Failure in user code!")
                # stuff in between
                response = JSONResponse(
                {"error": str(exc), "stacktrace": traceback.format_exc()},
                status_code=status_code,
            )
          return response      

trace

During handling of the above exception, another exception occurred:

request = <starlette.middleware.base._CachedRequest object at 0x13a837040>

    async def call_next(request: Request) -> Response:
        async def receive_or_disconnect() -> Message:
            if response_sent.is_set():
                return {"type": "http.disconnect"}
    
            async with anyio.create_task_group() as task_group:
    
                async def wrap(func: typing.Callable[[], typing.Awaitable[T]]) -> T:
                    result = await func()
                    task_group.cancel_scope.cancel()
                    return result
    
                task_group.start_soon(wrap, response_sent.wait)
                message = await wrap(wrapped_receive)
    
            if response_sent.is_set():
                return {"type": "http.disconnect"}
    
            return message
    
        async def send_no_error(message: Message) -> None:
            try:
                await send_stream.send(message)
            except anyio.BrokenResourceError:
                # recv_stream has been closed, i.e. response_sent has been set.
                return
    
        async def coro() -> None:
            nonlocal app_exc
    
            with send_stream:
                try:
                    await self.app(scope, receive_or_disconnect, send_no_error)
                except Exception as exc:
                    app_exc = exc
    
        task_group.start_soon(coro)
    
        try:
>           message = await recv_stream.receive()


_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = MemoryObjectReceiveStream(_state=MemoryObjectStreamState(max_buffer_size=0, buffer=deque([]), open_send_channels=0, open_receive_channels=0, waiting_receivers=OrderedDict(), waiting_senders=OrderedDict()), _closed=True)

    async def receive(self) -> T_co:
        await checkpoint()
        try:
            return self.receive_nowait()
        except WouldBlock:
            # Add ourselves in the queue
            receive_event = Event()
            receiver = MemoryObjectItemReceiver[T_co]()
            self._state.waiting_receivers[receive_event] = receiver
    
            try:
                await receive_event.wait()
            finally:
                self._state.waiting_receivers.pop(receive_event, None)
    
            try:
                return receiver.item
            except AttributeError:
>               raise EndOfStream
E               anyio.EndOfStream

[febus982]

I was literally debugging the same!

[sfriedowitz]

Yep same issue, I've been debugging this same thing. My LoggingMiddleware that try/catches exceptions from call_next was no longer working as expected, and turns out it stems from this.

Will have to pin to a previous version of starlette until this is resolved.

[mrfroggg]

Same kind of issue with 0.46.0 on my end. I have a Timeout Middleware setup in my FastAPI app when I raise an asyncio..exceptions.IncompleteReadError to timeout the client with a HTTP 408. Now The code can't catch the exception anymore.
Fixing starlette to 0.45.3 fixes the issue for now

[Sanchoyzer]

Same problem with raising exception

main.py

from starlette.applications import Starlette
from starlette.middleware import Middleware
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.responses import JSONResponse
from starlette.routing import Route


class NotFoundError(Exception):
    pass


async def handle_error(request):
    raise NotFoundError()


class HandleValueErrorMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        try:
            response = await call_next(request)
        except NotFoundError:
            return JSONResponse({"detail": "Not Found"}, status_code=404)
        return response


app = Starlette(
    middleware=[Middleware(HandleValueErrorMiddleware)],
    routes=[Route("/error", handle_error)],
)

test_1.py

from starlette.testclient import TestClient

from main import app


async def test_404():
    result = TestClient(app=app).get("/error")
    assert result.status_code == 404

This test works on 0.45.3, but fails on 0.46.0

[andri1gryniv]

Same issue on my end, temporary fix with pinning to 0.45.3 helped

[aurelwildfellner]

One issue which is introduced by applying collapse_excgroups is that the Exceptions then self-reference via Exception.__context__. exception_a.__context__ -> ExceptionGroup -> exception_a to be precise. If logging frameworks walk this, they end up in an infinite loop.

[condar-mpb]

Adding another voice to the chorus, we've had to pin to starlette==0.45.3 because it has broken our general purpose exception handler middleware - it'd be good to get a fix so we can get back onto the most up to date version.