simplified this version of the exception handling

Author: pcrespov

services/web/server/src/simcore_service_webserver/exceptions_handlers.py

@@ -1,8 +1,6 @@
 import functools
 import logging
-from collections.abc import Callable
-from contextlib import contextmanager
-from typing import NamedTuple, Protocol, TypeAlias
+from typing import NamedTuple, TypeAlias
 
 from aiohttp import web
 from servicelib.aiohttp.typing_extension import Handler
@@ -13,74 +11,6 @@
 _logger = logging.getLogger(__name__)
 
 
-class WebApiExceptionHandler(Protocol):
-    def __call__(
-        self, exception: BaseException, request: web.Request
-    ) -> web.HTTPError | BaseException | None:
-        """
-        Callback to process an exception raised during a web request, allowing custom handling.
-
-        This function can be implemented to  suppress, reraise, or transform the exception
-        into an `web.HTTPError` (i.e.the errors specified in the web-api)
-
-        Arguments:
-            exception -- exception raised in web handler during this request
-            request -- current request
-
-        Returns:
-            - None: to suppress `exception`
-            - `exception`: to reraise it
-            - an instance of `web.HTTPError` to transform to HTTP Api exceptions
-        """
-
-
-@contextmanager
-def _handled_exception_context(
-    exception_catch: type[BaseException] | tuple[type[BaseException], ...],
-    exception_handler: Callable,
-    **forward_ctx,
-):
-    try:
-        yield
-    except exception_catch as e:
-        if exc := exception_handler(e, **forward_ctx):
-            assert isinstance(exc, BaseException)
-            raise exc from e
-
-        _logger.debug(
-            "%s suppressed %s: %s", exception_handler.__name__, type(e).__name__, f"{e}"
-        )
-
-
-def create_exception_handlers_decorator(
-    exception_handler: WebApiExceptionHandler,
-    exception_types: type[BaseException] | tuple[type[BaseException], ...] = Exception,
-):
-    """
-    Creates a function to decorate routes handlers functions
-    that can catch and handle exceptions raised in the decorated functions
-    """
-
-    def _decorator(handler: Handler):
-        @functools.wraps(handler)
-        async def _wrapper(request: web.Request) -> web.StreamResponse:
-            with _handled_exception_context(
-                exception_types,
-                exception_handler,
-                request=request,
-            ):
-                return await handler(request)
-
-        return _wrapper
-
-    return _decorator
-
-
-#
-# Http Error Map Handler Customization
-#
-
-
 class HttpErrorInfo(NamedTuple):
     status_code: int
     msg_template: str
@@ -104,57 +34,51 @@ def _sort_exceptions_by_specificity(
     )
 
 
-def create__http_error_map_handler(
-    to_http_error_map: ExceptionToHttpErrorMap,
-) -> WebApiExceptionHandler:
-    """
-    Creates a custom `WebApiExceptionHandler` that maps specific exceptions to HTTP errors.
-
-    Given an `ExceptionToHttpErrorMap`, this function returns a handler that checks if an exception
-    matches one in the map, returning an HTTP error with the mapped status code and message.
-    Server errors (5xx) include additional logging with request context. Unmapped exceptions are
-    returned as-is for re-raising.
-
-    Arguments:
-        to_http_error_map -- Maps exceptions to HTTP status codes and messages.
+def create_exception_handlers_decorator(
+    exception_catch: type[BaseException] | tuple[type[BaseException], ...],
+    exc_to_status_map: ExceptionToHttpErrorMap,
+):
 
-    Returns:
-        A web api exception handler
-    """
     included: list[type[BaseException]] = _sort_exceptions_by_specificity(
-        list(to_http_error_map.keys())
+        list(exc_to_status_map.keys())
     )
 
-    def _handler(
-        exception: BaseException,
-        request: web.Request,
-    ) -> web.HTTPError | BaseException | None:
-        if exc_cls := next((_ for _ in included if isinstance(exception, _)), None):
-            http_error_info = to_http_error_map[exc_cls]
-
-            # safe formatting, i.e. does not raise
-            user_msg = http_error_info.msg_template.format_map(
-                _DefaultDict(getattr(exception, "__dict__", {}))
-            )
-
-            http_error_cls = get_http_error_class_or_none(http_error_info.status_code)
-            assert http_error_cls  # nosec
-
-            if is_5xx_server_error(http_error_info.status_code):
-                _logger.exception(
-                    **create_troubleshotting_log_kwargs(
-                        user_msg,
-                        error=exception,
-                        error_context={
-                            "request": request,
-                            "request.remote": f"{request.remote}",
-                            "request.method": f"{request.method}",
-                            "request.path": f"{request.path}",
-                        },
+    def _decorator(handler: Handler):
+        @functools.wraps(handler)
+        async def _wrapper(request: web.Request) -> web.StreamResponse:
+            try:
+                return await handler(request)
+
+            except exception_catch as exc:
+                if exc_cls := next((_ for _ in included if isinstance(exc, _)), None):
+                    http_error_info = exc_to_status_map[exc_cls]
+
+                    # safe formatting, i.e. does not raise
+                    user_msg = http_error_info.msg_template.format_map(
+                        _DefaultDict(getattr(exc, "__dict__", {}))
                     )
-                )
-            return http_error_cls(reason=user_msg)
-        # NOTE: not in my list, return so it gets reraised
-        return exception
 
-    return _handler
+                    http_error_cls = get_http_error_class_or_none(
+                        http_error_info.status_code
+                    )
+                    assert http_error_cls  # nosec
+
+                    if is_5xx_server_error(http_error_info.status_code):
+                        _logger.exception(
+                            **create_troubleshotting_log_kwargs(
+                                user_msg,
+                                error=exc,
+                                error_context={
+                                    "request": request,
+                                    "request.remote": f"{request.remote}",
+                                    "request.method": f"{request.method}",
+                                    "request.path": f"{request.path}",
+                                },
+                            )
+                        )
+                    raise http_error_cls(reason=user_msg) from exc
+                raise
+
+        return _wrapper
+
+    return _decorator

…ebserver/folders/_exceptions_handling.py …ebserver/folders/_exceptions_handlers.pyservices/web/server/src/simcore_service_webserver/folders/_exceptions_handling.py renamed to services/web/server/src/simcore_service_webserver/folders/_exceptions_handlers.py services/web/server/src/simcore_service_webserver/folders/_exceptions_handling.py renamed to services/web/server/src/simcore_service_webserver/folders/_exceptions_handlers.py

@@ -5,7 +5,6 @@
 from ..exceptions_handlers import (
     ExceptionToHttpErrorMap,
     HttpErrorInfo,
-    create__http_error_map_handler,
     create_exception_handlers_decorator,
 )
 from ..projects.exceptions import (
@@ -69,6 +68,6 @@
 
 
 handle_plugin_requests_exceptions = create_exception_handlers_decorator(
-    create__http_error_map_handler(_TO_HTTP_ERROR_MAP),
-    (ProjectTrashError, FoldersValueError),
+    exception_catch=(ProjectTrashError, FoldersValueError),
+    exc_to_status_map=_TO_HTTP_ERROR_MAP,
 )

services/web/server/src/simcore_service_webserver/folders/_folders_handlers.py

@@ -25,7 +25,7 @@
 from ..security.decorators import permission_required
 from ..utils_aiohttp import envelope_json_response
 from . import _folders_api
-from ._exceptions_handling import handle_plugin_requests_exceptions
+from ._exceptions_handlers import handle_plugin_requests_exceptions
 from ._models import (
     FolderFilters,
     FolderListWithJsonStrQueryParams,

services/web/server/src/simcore_service_webserver/folders/_trash_handlers.py

@@ -13,7 +13,7 @@
 from ..products.api import get_product_name
 from ..security.decorators import permission_required
 from . import _trash_api
-from ._exceptions_handling import handle_plugin_requests_exceptions
+from ._exceptions_handlers import handle_plugin_requests_exceptions
 from ._models import FoldersPathParams, RemoveQueryParams
 
 _logger = logging.getLogger(__name__)

services/web/server/src/simcore_service_webserver/projects/_trash_handlers.py

@@ -12,7 +12,6 @@
 from ..exceptions_handlers import (
     ExceptionToHttpErrorMap,
     HttpErrorInfo,
-    create__http_error_map_handler,
     create_exception_handlers_decorator,
 )
 from ..login.decorators import get_user_id, login_required
@@ -47,7 +46,7 @@
 
 
 _handle_exceptions = create_exception_handlers_decorator(
-    create__http_error_map_handler(_TO_HTTP_ERROR_MAP), ProjectTrashError
+    exception_catch=ProjectTrashError, exc_to_status_map=_TO_HTTP_ERROR_MAP
 )
 
 #

services/web/server/tests/unit/isolated/test_exceptions_handlers.py

@@ -6,16 +6,16 @@
 # pylint: disable=unused-variable
 
 
+import logging
+
 import pytest
 from aiohttp import web
 from aiohttp.test_utils import make_mocked_request
 from servicelib.aiohttp import status
 from simcore_service_webserver.errors import WebServerBaseError
 from simcore_service_webserver.exceptions_handlers import (
     HttpErrorInfo,
-    _handled_exception_context,
     _sort_exceptions_by_specificity,
-    create__http_error_map_handler,
     create_exception_handlers_decorator,
 )
 
@@ -65,84 +65,53 @@ def test_sort_exceptions_by_specificity():
             assert not issubclass(exc_after, exc), f"{got_exceptions_cls=}"
 
 
-@pytest.fixture
-def fake_request() -> web.Request:
-    return make_mocked_request("GET", "/foo")
-
-
-def test_http_error_map_handler_factory(fake_request: web.Request):
+async def test_exception_handlers_decorator(
+    caplog: pytest.LogCaptureFixture,
+):
 
-    exc_handler = create__http_error_map_handler(
-        {
+    _handle_exceptions = create_exception_handlers_decorator(
+        exception_catch=BasePluginError,
+        exc_to_status_map={
             OneError: HttpErrorInfo(
-                status.HTTP_400_BAD_REQUEST, "Error One mapped to 400"
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                msg_template="This is one error for front-end",
             )
-        }
+        },
     )
 
-    # Converts exception in map
-    got_exc = exc_handler(OneError(), fake_request)
-
-    assert isinstance(got_exc, web.HTTPBadRequest)
-    assert got_exc.reason == "Error One mapped to 400"
-
-    # By-passes exceptions not listed
-    err = RuntimeError()
-    assert exc_handler(err, fake_request) is err
-
-
-def test_handled_exception_context(fake_request: web.Request):
-    def _suppress_handler(exception, request):
-        assert request == fake_request
-        assert isinstance(
-            exception, BasePluginError
-        ), "only BasePluginError exceptions should call this handler"
-        return None  # noqa: RET501, PLR1711
-
-    def _fun(raises):
-        with _handled_exception_context(
-            BasePluginError, _suppress_handler, request=fake_request
-        ):
-            raise raises
-
-    # checks
-    _fun(raises=OneError)
-    _fun(raises=OtherError)
+    @_handle_exceptions
+    async def _rest_handler(request: web.Request) -> web.Response:
+        if request.query.get("raise") == "OneError":
+            raise OneError
+        if request.query.get("raise") == "ArithmeticError":
+            raise ArithmeticError
 
-    with pytest.raises(ArithmeticError):
-        _fun(raises=ArithmeticError)
+        return web.Response(reason="all good")
 
+    with caplog.at_level(logging.ERROR):
 
-async def test_exception_handlers_decorator():
-    def _suppress_handler(exception, request):
-        assert isinstance(
-            exception, BasePluginError
-        ), "only BasePluginError exceptions should call this handler"
-        return None  # noqa: RET501, PLR1711
+        # emulates successful call
+        resp = await _rest_handler(make_mocked_request("GET", "/foo"))
+        assert resp.status == status.HTTP_200_OK
+        assert resp.reason == "all good"
 
-    _handle_exceptons = create_exception_handlers_decorator(
-        _suppress_handler, BasePluginError
-    )
+        assert not caplog.records
 
-    @_handle_exceptons
-    async def _rest_handler(request: web.Request):
-        if request.query.get("raise") == "OneError":
-            raise OneError
-        if request.query.get("raise") == "ArithmeticError":
-            raise ArithmeticError
+        # this will be passed and catched by the outermost error middleware
+        with pytest.raises(ArithmeticError):
+            await _rest_handler(
+                make_mocked_request("GET", "/foo?raise=ArithmeticError")
+            )
 
-        return web.Response(text="all good")
+        assert not caplog.records
 
-    # emulates call
-    resp = await _rest_handler(make_mocked_request("GET", "/foo"))
-    assert resp.status == status.HTTP_200_OK
+        # this is a 5XX will be converted to response but is logged as error as well
+        with pytest.raises(web.HTTPException) as exc_info:
+            await _rest_handler(make_mocked_request("GET", "/foo?raise=OneError"))
 
-    # OMG! not good!?
-    resp = await _rest_handler(make_mocked_request("GET", "/foo?raise=OneError"))
-    assert resp is None
+        resp = exc_info.value
+        assert resp.status == status.HTTP_503_SERVICE_UNAVAILABLE
+        assert "front-end" in resp.reason
 
-    # typically capture by last
-    with pytest.raises(ArithmeticError):
-        resp = await _rest_handler(
-            make_mocked_request("GET", "/foo?raise=ArithmeticError")
-        )
+        assert caplog.records
+        assert caplog.records[0].levelno == logging.ERROR