fix(events): ensure callable metadata is replicated

litestar/events/listener.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import logging
+from functools import update_wrapper
 from typing import TYPE_CHECKING, Any
 
 from litestar.exceptions import ImproperlyConfiguredException
 from litestar.utils import ensure_async_callable
+from litestar.utils.predicates import is_async_callable
 
 if TYPE_CHECKING:
     from litestar.types import AnyCallable, AsyncAnyCallable
@@ -42,7 +44,12 @@ def __call__(self, fn: AnyCallable) -> EventListener:
         if not callable(fn):
             raise ImproperlyConfiguredException("EventListener instance should be called as a decorator on a callable")
 
-        self.fn = self.wrap_in_error_handler(ensure_async_callable(fn))
+        _fn = ensure_async_callable(fn)
+
+        if not is_async_callable(fn):
+            update_wrapper(_fn, fn)
+
+        self.fn = self.wrap_in_error_handler(_fn)
 
         return self
 

tests/unit/test_events.py

@@ -111,34 +111,49 @@ async def test_raises_when_not_listener_are_registered_for_an_event_id(async_lis
             client.app.emit("x")
 
 
-async def test_event_listener_raises_exception(async_listener: EventListener, mock: MagicMock) -> None:
+async def test_event_listener_raises_exception(
+    async_listener: EventListener, sync_listener: EventListener, mock: MagicMock
+) -> None:
     """Test that an event listener that raises an exception does not prevent other listeners from being called.
 
     https://github.com/litestar-org/litestar/issues/2809
+    https://github.com/litestar-org/litestar/issues/4044
     """
 
     error_mock = MagicMock()
 
-    @listener("error_event")
-    async def raising_listener(*args: Any, **kwargs: Any) -> None:
+    @listener("async_error_event")
+    async def async_raising_listener(*args: Any, **kwargs: Any) -> None:
+        error_mock()
+        raise ValueError("test")
+
+    @listener("sync_error_event")
+    def sync_raising_listener(*args: Any, **kwargs: Any) -> None:
         error_mock()
         raise ValueError("test")
 
-    @get("/error")
+    @get("/async-error")
     def route_handler_1(request: Request[Any, Any, Any]) -> None:
-        request.app.emit("error_event")
+        request.app.emit("async_error_event")
 
-    @get("/no-error")
+    @get("/sync-error")
     def route_handler_2(request: Request[Any, Any, Any]) -> None:
+        request.app.emit("sync_error_event")
+
+    @get("/no-error")
+    def route_handler_3(request: Request[Any, Any, Any]) -> None:
         request.app.emit("test_event")
 
     with create_test_client(
-        route_handlers=[route_handler_1, route_handler_2], listeners=[async_listener, raising_listener]
+        route_handlers=[route_handler_1, route_handler_2, route_handler_3],
+        listeners=[async_listener, sync_listener, async_raising_listener, sync_raising_listener],
     ) as client:
-        first_response = client.get("/error")
-        second_response = client.get("/no-error")
+        first_response = client.get("/async-error")
+        second_response = client.get("/sync-error")
+        third_response = client.get("/no-error")
         assert first_response.status_code == HTTP_200_OK
         assert second_response.status_code == HTTP_200_OK
+        assert third_response.status_code == HTTP_200_OK
 
     error_mock.assert_called()
     mock.assert_called()