qena-shared-lib 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

qena_shared_lib/rabbitmq/_listener.py

@@ -30,8 +30,9 @@ from pydantic import ValidationError
 from pydantic_core import from_json, to_json
 
 from ..dependencies.miscellaneous import validate_annotation
-from ..exceptions import RabbitMQServiceException
-from ..logging import LoggerProvider
+from ..exception_handling import ServiceContext
+from ..exceptions import RabbitMQBlockedError, RabbitMQServiceException
+from ..logging import LoggerFactory
 from ..remotelogging import BaseRemoteLogSender
 from ..utils import AsyncEventLoopMixin, TypeAdapterCache
 from ._channel import BaseChannel
@@ -97,21 +98,29 @@ class RpcReply:
         self,
         channel_pool: ChannelPool,
         reply_to: str,
+        blocked_connection_check_callback: Callable[[], bool],
         correlation_id: str | None = None,
     ) -> None:
         self._channel_pool = channel_pool
         self._reply_to = reply_to
+        self._blocked_connection_check_callback = (
+            blocked_connection_check_callback
+        )
         self._correlation_id = correlation_id
         self._replied = False
 
     async def reply(self, message: Any) -> None:
         base_channel = await self._channel_pool.get()
-
         reply_properties = BasicProperties(content_type="application/json")
 
         if self._correlation_id is not None:
             reply_properties.correlation_id = self._correlation_id
 
+        if self._blocked_connection_check_callback():
+            raise RabbitMQBlockedError(
+                "rabbitmq broker is not able to accept message right now for manual reply"
+            )
+
         try:
             with base_channel as channel:
                 channel.basic_publish(
@@ -131,7 +140,7 @@ class RpcReply:
 
 
 @dataclass
-class ListenerContext:
+class ListenerContext(ServiceContext):
     queue: str
     listener_name: str
     body: bytes
@@ -218,6 +227,13 @@ class ListenerMethodContainer:
     dependencies: dict[str, type]
     retry_policy: RetryPolicy | None = None
 
+    def __post_init__(self) -> None:
+        self._is_async_listener = iscoroutinefunction(self.listener_method)
+
+    @property
+    def is_async_listener(self) -> bool:
+        return self._is_async_listener
+
 
 class ListenerChannelAdapter(BaseChannel):
     def __init__(
@@ -242,7 +258,7 @@ class ListenerChannelAdapter(BaseChannel):
 
 
 @dataclass
-class ListenerMessageMeta:
+class ListenerMessageMetadata:
     body: bytes
     method: Basic.Deliver
     properties: BasicProperties
@@ -252,17 +268,17 @@ class ListenerMessageMeta:
 
 
 class Listener(AsyncEventLoopMixin):
-    LISTENER_SUCCEEDED_COMSUMPTION = Counter(
+    _LISTENER_SUCCEEDED_COMSUMPTION = Counter(
         name="listener_succeeded_comsumption",
         documentation="Listener succeeded comsumption",
         labelnames=["queue", "listener_name"],
     )
-    LISTENER_FAILED_COMSUMPTION = Counter(
+    _LISTENER_FAILED_COMSUMPTION = Counter(
         name="listener_failed_comsumption",
         documentation="Listener failed comsumption",
         labelnames=["queue", "listener_name", "exception"],
     )
-    LISTENER_PROCESSING_LATENCY = Summary(
+    _LISTENER_PROCESSING_LATENCY = Summary(
         name="listener_processing_latency",
         documentation="Listener processing latency",
         labelnames=["queue", "listener_name"],
@@ -287,7 +303,7 @@ class Listener(AsyncEventLoopMixin):
         self._listeners_tasks_and_futures: list[Task[Any] | Future[Any]] = []
         self._consumer_tag: str | None = None
         self._cancelled = False
-        self._logger = LoggerProvider.default().get_logger("rabbitmq.listener")
+        self._logger = LoggerFactory.get_logger("rabbitmq.listener")
 
     @property
     def queue(self) -> str:
@@ -356,6 +372,7 @@ class Listener(AsyncEventLoopMixin):
         connection: AsyncioConnection,
         channel_pool: ChannelPool,
         on_exception_callback: Callable[[ListenerContext, BaseException], bool],
+        blocked_connection_check_callback: Callable[[], bool],
         container: Container,
         remote_logger: BaseRemoteLogSender,
         global_retry_policy: RetryPolicy | None = None,
@@ -364,6 +381,9 @@ class Listener(AsyncEventLoopMixin):
         self._channel_pool = channel_pool
         self._listener_future = self.loop.create_future()
         self._on_exception_callback = on_exception_callback
+        self._blocked_connection_check_callback = (
+            blocked_connection_check_callback
+        )
         self._container = container
         self._remote_logger = remote_logger
         self._global_retry_policy = global_retry_policy
@@ -485,12 +505,13 @@ class Listener(AsyncEventLoopMixin):
             self._remote_logger.error(
                 message=f"no listener registered with the name `{listener_name}` on queue `{self._queue}`",
                 tags=[
-                    "RabbitMQ",
+                    "rabbitmq",
+                    "listener_doesnt_exist",
                     self._queue,
                     listener_name,
                 ],
                 extra={
-                    "serviceType": "RabbitMQ",
+                    "serviceType": "rabbitmq",
                     "queue": self._queue,
                     "listenerName": listener_name,
                 },
@@ -498,60 +519,38 @@ class Listener(AsyncEventLoopMixin):
 
             return
 
-        listener_message_meta = ListenerMessageMeta(
-            body=body,
-            method=method,
-            properties=properties,
-            listener_name=listener_name,
-            listener_method_container=listener_method_container,
-            listener_start_time=time(),
-        )
-
-        self.loop.run_in_executor(
-            executor=None,
-            func=partial(self._parse_and_execute, listener_message_meta),
-        ).add_done_callback(
-            partial(self._on_submitted_listener_error, listener_message_meta)
-        )
-
-    def _on_submitted_listener_error(
-        self, listener_message_meta: ListenerMessageMeta, future: Future[None]
-    ) -> None:
-        if future.cancelled():
-            return
-
-        exception = future.exception()
-
-        if exception is not None:
-            self._call_exception_callback(
-                exception=exception,
-                listener_message_meta=listener_message_meta,
-                message=f"error occured while submitting listener callback on listener `{listener_message_meta.listener_name}` and queue `{self._queue}`",
+        self._parse_and_execute(
+            ListenerMessageMetadata(
+                body=body,
+                method=method,
+                properties=properties,
+                listener_name=listener_name,
+                listener_method_container=listener_method_container,
+                listener_start_time=time(),
             )
+        )
 
     def _parse_and_execute(
-        self, listener_message_meta: ListenerMessageMeta
+        self, listener_message_metadata: ListenerMessageMetadata
     ) -> None:
         try:
             listener_method_args, listener_method_kwargs = self._parse_args(
-                listener_message_meta
+                listener_message_metadata
             )
         except Exception as e:
             self._call_exception_callback(
                 exception=e,
-                listener_message_meta=listener_message_meta,
-                message=f"arguments for listener `{listener_message_meta.listener_name}` in queue `{self._queue}` are not valid",
+                listener_message_metadata=listener_message_metadata,
+                message=f"arguments for listener `{listener_message_metadata.listener_name}` in queue `{self._queue}` are not valid",
             )
 
             return
 
         listener_task_or_future: Task[Any] | Future[Any] | None = None
 
-        if iscoroutinefunction(
-            listener_message_meta.listener_method_container.listener_method
-        ):
+        if listener_message_metadata.listener_method_container.is_async_listener:
             listener_task_or_future = self.loop.create_task(
-                listener_message_meta.listener_method_container.listener_method(
+                listener_message_metadata.listener_method_container.listener_method(
                     *listener_method_args, **listener_method_kwargs
                 )
             )
@@ -559,7 +558,7 @@ class Listener(AsyncEventLoopMixin):
             listener_task_or_future = self.loop.run_in_executor(
                 executor=None,
                 func=partial(
-                    listener_message_meta.listener_method_container.listener_method,
+                    listener_message_metadata.listener_method_container.listener_method,
                     *listener_method_args,
                     **listener_method_kwargs,
                 ),
@@ -569,16 +568,16 @@ class Listener(AsyncEventLoopMixin):
 
         self._listeners_tasks_and_futures.append(listener_task_or_future)
         listener_task_or_future.add_done_callback(
-            partial(self._on_listener_done_executing, listener_message_meta)
+            partial(self._on_listener_done_executing, listener_message_metadata)
         )
 
     def _parse_args(
-        self, listener_message_meta: ListenerMessageMeta
+        self, listener_message_metadata: ListenerMessageMetadata
     ) -> tuple[list[Any], dict[str, Any]]:
         try:
-            message = from_json(listener_message_meta.body)
+            message = from_json(listener_message_metadata.body)
         except:
-            message = listener_message_meta.body.decode()
+            message = listener_message_metadata.body.decode()
 
         assigned_args: list[Any] = []
         listener_method_args = []
@@ -593,8 +592,8 @@ class Listener(AsyncEventLoopMixin):
                 for (
                     parameter_name,
                     parameter,
-                ) in listener_message_meta.listener_method_container.parameters.items():
-                    dependency_key = listener_message_meta.listener_method_container.dependencies.get(
+                ) in listener_message_metadata.listener_method_container.parameters.items():
+                    dependency_key = listener_message_metadata.listener_method_container.dependencies.get(
                         parameter_name
                     )
                     dependency = None
@@ -609,8 +608,8 @@ class Listener(AsyncEventLoopMixin):
                     ):
                         listener_context = ListenerContext(
                             queue=self._queue,
-                            listener_name=listener_message_meta.listener_name,
-                            body=listener_message_meta.body,
+                            listener_name=listener_message_metadata.listener_name,
+                            body=listener_message_metadata.body,
                             flow_control=self._flow_control,
                         )
 
@@ -709,8 +708,8 @@ class Listener(AsyncEventLoopMixin):
         for (
             parameter_name,
             parameter,
-        ) in listener_message_meta.listener_method_container.parameters.items():
-            dependency = listener_message_meta.listener_method_container.dependencies.get(
+        ) in listener_message_metadata.listener_method_container.parameters.items():
+            dependency = listener_message_metadata.listener_method_container.dependencies.get(
                 parameter_name
             )
 
@@ -721,8 +720,8 @@ class Listener(AsyncEventLoopMixin):
                 listener_method_args.append(
                     ListenerContext(
                         queue=self._queue,
-                        listener_name=listener_message_meta.listener_name,
-                        body=listener_message_meta.body,
+                        listener_name=listener_message_metadata.listener_name,
+                        body=listener_message_metadata.body,
                         flow_control=self._flow_control,
                     )
                 )
@@ -773,7 +772,7 @@ class Listener(AsyncEventLoopMixin):
 
     def _on_listener_done_executing(
         self,
-        listener_message_meta: ListenerMessageMeta,
+        listener_message_metadata: ListenerMessageMetadata,
         task_or_future: Task[Any] | Future[Any],
     ) -> None:
         if (
@@ -785,14 +784,14 @@ class Listener(AsyncEventLoopMixin):
         if task_or_future.cancelled():
             return
 
-        self._observe_listener_time(listener_message_meta)
+        self._observe_listener_time(listener_message_metadata)
 
         exception = task_or_future.exception()
 
         if exception is not None:
-            if listener_message_meta.properties.reply_to is None:
+            if listener_message_metadata.properties.reply_to is None:
                 retry_policy = (
-                    listener_message_meta.listener_method_container.retry_policy
+                    listener_message_metadata.listener_method_container.retry_policy
                     or self._retry_policy
                     or self._global_retry_policy
                 )
@@ -812,12 +811,10 @@ class Listener(AsyncEventLoopMixin):
                 ):
                     times_rejected = None
 
-                    if listener_message_meta.properties.headers is not None:
+                    if listener_message_metadata.properties.headers is not None:
                         try:
-                            _times_rejected = (
-                                listener_message_meta.properties.headers.get(
-                                    "times_rejected"
-                                )
+                            _times_rejected = listener_message_metadata.properties.headers.get(
+                                "times_rejected"
                             )
 
                             if isinstance(_times_rejected, int):
@@ -835,7 +832,7 @@ class Listener(AsyncEventLoopMixin):
 
                     if retry_policy.can_retry(times_rejected):
                         self._reject_message(
-                            listener_message_meta=listener_message_meta,
+                            listener_message_metadata=listener_message_metadata,
                             retry_policy=retry_policy,
                             times_rejected=times_rejected,
                         )
@@ -844,43 +841,44 @@ class Listener(AsyncEventLoopMixin):
 
             self._call_exception_callback(
                 exception=exception,
-                listener_message_meta=listener_message_meta,
-                message=f"error occured while executing listener `{listener_message_meta.listener_name}` in queue `{self._queue}`",
+                listener_message_metadata=listener_message_metadata,
+                message=f"error occured while executing listener `{listener_message_metadata.listener_name}` in queue `{self._queue}`",
             )
 
         if (
-            listener_message_meta.properties.reply_to is not None
+            listener_message_metadata.properties.reply_to is not None
             and exception is None
         ):
             self._reply_response(
-                listener_message_meta=listener_message_meta,
+                listener_message_metadata=listener_message_metadata,
                 response=task_or_future.result(),
             )
 
         self._logger.debug(
             "message from queue `%s` consumed by listener `%s`",
             self.queue,
-            listener_message_meta.listener_name,
+            listener_message_metadata.listener_name,
         )
 
         if exception is not None:
-            self.LISTENER_FAILED_COMSUMPTION.labels(
+            self._LISTENER_FAILED_COMSUMPTION.labels(
                 queue=self._queue,
-                listener_name=listener_message_meta.listener_name,
+                listener_name=listener_message_metadata.listener_name,
                 exception=exception.__class__.__name__,
             ).inc()
         else:
-            self.LISTENER_SUCCEEDED_COMSUMPTION.labels(
+            self._LISTENER_SUCCEEDED_COMSUMPTION.labels(
                 queue=self._queue,
-                listener_name=listener_message_meta.listener_name,
+                listener_name=listener_message_metadata.listener_name,
             ).inc()
 
     def _observe_listener_time(
-        self, listener_message_meta: ListenerMessageMeta
+        self, listener_message_metadata: ListenerMessageMetadata
     ) -> None:
-        self.LISTENER_PROCESSING_LATENCY.labels(
-            queue=self._queue, listener_name=listener_message_meta.listener_name
-        ).observe(listener_message_meta.listener_start_time - time())
+        self._LISTENER_PROCESSING_LATENCY.labels(
+            queue=self._queue,
+            listener_name=listener_message_metadata.listener_name,
+        ).observe(listener_message_metadata.listener_start_time - time())
 
     def _is_recoverable_exception(
         self,
@@ -905,7 +903,7 @@ class Listener(AsyncEventLoopMixin):
             ):
                 return True
 
-            cause = cause.__cause__ or exception.__context__
+            cause = cause.__cause__ or cause.__context__
 
         return False
 
@@ -922,84 +920,86 @@ class Listener(AsyncEventLoopMixin):
     def _call_exception_callback(
         self,
         exception: BaseException,
-        listener_message_meta: ListenerMessageMeta,
+        listener_message_metadata: ListenerMessageMetadata,
         message: str | None = None,
     ) -> None:
         context_dispose_callback = None
         rpc_reply = None
+        tags = [
+            "rabbitmq",
+            self._queue,
+            listener_message_metadata.listener_name,
+        ]
+        extra = {
+            "serviceType": "rabbitmq",
+            "queue": self._queue,
+            "listenerName": listener_message_metadata.listener_name,
+            "section": "exceptionHandlerCallback",
+            "raisedException": exception.__class__.__name__,
+        }
 
-        if listener_message_meta.properties.reply_to is not None:
+        if listener_message_metadata.properties.reply_to is not None:
 
             def on_context_disposed(context: ListenerContext) -> None:
-                assert listener_message_meta.properties.reply_to is not None
+                assert listener_message_metadata.properties.reply_to is not None
                 assert context.rpc_reply is not None
 
                 if not context.rpc_reply.replied:
                     self._reply_response(
-                        listener_message_meta=listener_message_meta,
+                        listener_message_metadata=listener_message_metadata,
                         response=self._reponse_from_exception(exception),
                     )
 
             context_dispose_callback = on_context_disposed
             rpc_reply = RpcReply(
                 channel_pool=self._channel_pool,
-                reply_to=listener_message_meta.properties.reply_to,
-                correlation_id=listener_message_meta.properties.correlation_id,
+                reply_to=listener_message_metadata.properties.reply_to,
+                blocked_connection_check_callback=self._blocked_connection_check_callback,
+                correlation_id=listener_message_metadata.properties.correlation_id,
             )
 
         try:
             exception_callback_succeeded = self._on_exception_callback(
                 ListenerContext(
                     queue=self._queue,
-                    listener_name=listener_message_meta.listener_name,
-                    body=listener_message_meta.body,
+                    listener_name=listener_message_metadata.listener_name,
+                    body=listener_message_metadata.body,
                     flow_control=self._flow_control,
                     rpc_reply=rpc_reply,
                     context_dispose_callback=context_dispose_callback,
+                ).set_labels(
+                    {
+                        "queue": self._queue,
+                        "listener_name": listener_message_metadata.listener_name,
+                        "exception": exception.__class__.__name__,
+                    }
                 ),
                 exception,
             )
         except:
+            tags.append("exception_callback_error")
             self._remote_logger.exception(
-                message=f"error occured while invoking rabbitmq exception handler callback in listener `{listener_message_meta.listener_name}` and queue `{self._queue}`",
-                tags=[
-                    "RabbitMQ",
-                    self._queue,
-                    listener_message_meta.listener_name,
-                ],
-                extra={
-                    "serviceType": "RabbitMQ",
-                    "queue": self._queue,
-                    "listenerName": listener_message_meta.listener_name,
-                    "section": "exceptionHandlerCallback",
-                    "raisedException": exception.__class__.__name__,
-                },
+                message=f"error occured while invoking rabbitmq exception handler callback in listener `{listener_message_metadata.listener_name}` and queue `{self._queue}`",
+                tags=tags,
+                extra=extra,
             )
 
             return
 
         if not exception_callback_succeeded:
+            tags.append("exception_callback_unsuccessful")
             self._remote_logger.exception(
                 message=(
                     message
-                    or f"error occured while handling event in listener `{listener_message_meta.listener_name}` and queue `{self._queue}`"
+                    or f"error occured while handling event in listener `{listener_message_metadata.listener_name}` and queue `{self._queue}`"
                 ),
-                tags=[
-                    "RabbitMQ",
-                    self._queue,
-                    listener_message_meta.listener_name,
-                ],
-                extra={
-                    "serviceType": "RabbitMQ",
-                    "queue": self._queue,
-                    "listenerName": listener_message_meta.listener_name,
-                    "raisedException": exception.__class__.__name__,
-                },
+                tags=tags,
+                extra=extra,
             )
 
     def _reject_message(
         self,
-        listener_message_meta: ListenerMessageMeta,
+        listener_message_metadata: ListenerMessageMetadata,
         retry_policy: RetryPolicy,
         times_rejected: int,
     ) -> None:
@@ -1007,7 +1007,7 @@ class Listener(AsyncEventLoopMixin):
 
         self._logger.debug(
             "message will be redelivered to listenr `%s` on queue `%s` after `%f` seconds, times redelivered `%d`",
-            listener_message_meta.listener_name,
+            listener_message_metadata.listener_name,
             self._queue,
             message_redelivery_delay,
             times_rejected,
@@ -1016,27 +1016,27 @@ class Listener(AsyncEventLoopMixin):
             delay=message_redelivery_delay,
             callback=partial(
                 self._on_time_to_redeliver_message,
-                listener_message_meta,
+                listener_message_metadata,
                 times_rejected,
             ),
         )
 
     def _on_time_to_redeliver_message(
         self,
-        listener_message_meta: ListenerMessageMeta,
+        listener_message_metadata: ListenerMessageMetadata,
         times_rejected: int,
     ) -> None:
         self.loop.create_task(self._channel_pool.get()).add_done_callback(
             partial(
                 self._on_redelivery_channel_found,
-                listener_message_meta,
+                listener_message_metadata,
                 times_rejected,
             )
         )
 
     def _on_redelivery_channel_found(
         self,
-        listener_message_meta: ListenerMessageMeta,
+        listener_message_metadata: ListenerMessageMetadata,
         times_rejected: int,
         task: Task[BaseChannel],
     ) -> None:
@@ -1048,66 +1048,84 @@ class Listener(AsyncEventLoopMixin):
         if exception is not None:
             self._call_exception_callback(
                 exception=exception,
-                listener_message_meta=listener_message_meta,
-                message=f"error occured while getting channel from pool in listener `{listener_message_meta.listener_name}` and queue `{self._queue}` after rejecteed {times_rejected} times",
+                listener_message_metadata=listener_message_metadata,
+                message=f"error occured while getting channel from pool in listener `{listener_message_metadata.listener_name}` and queue `{self._queue}` after rejecteed {times_rejected} times",
             )
 
             return
 
         headers = {
-            self._listener_name_header_key: listener_message_meta.listener_name,
+            self._listener_name_header_key: listener_message_metadata.listener_name,
             "times_rejected": times_rejected + 1,
         }
 
-        if listener_message_meta.properties.headers is None:
-            listener_message_meta.properties.headers = headers
+        if listener_message_metadata.properties.headers is None:
+            listener_message_metadata.properties.headers = headers
         else:
             cast(
-                dict[str, Any], listener_message_meta.properties.headers
+                dict[str, Any], listener_message_metadata.properties.headers
             ).update(headers)
 
+        if self._blocked_connection_check_callback():
+            self._remote_logger.error(
+                message=f"couldn't redeliver message to queue `{self._queue}` and listener `{listener_message_metadata.listener_name}` due to blocked connection",
+                tags=[
+                    "rabbitmq",
+                    "redelivery_connection_blocked",
+                    self._queue,
+                    listener_message_metadata.listener_name,
+                ],
+                extra={
+                    "serviceType": "rabbitmq",
+                    "queue": self._queue,
+                    "listenerName": listener_message_metadata.listener_name,
+                },
+            )
+
+            return
+
         try:
             with task.result() as channel:
                 channel.basic_publish(
                     exchange=DEFAULT_EXCHANGE,
                     routing_key=self._queue,
-                    body=listener_message_meta.body,
-                    properties=listener_message_meta.properties,
+                    body=listener_message_metadata.body,
+                    properties=listener_message_metadata.properties,
                 )
         except Exception as e:
             self._call_exception_callback(
                 exception=e,
-                listener_message_meta=listener_message_meta,
-                message=f"error occured while sending event for redelivery in listener `{listener_message_meta.listener_name}` and queue `{self._queue}` after rejecteed {times_rejected} times",
+                listener_message_metadata=listener_message_metadata,
+                message=f"error occured while sending event for redelivery in listener `{listener_message_metadata.listener_name}` and queue `{self._queue}` after rejecteed {times_rejected} times",
             )
 
             return
 
         self._logger.debug(
             "message queued for redelivery to `%s` on queue `%s`, times redelivered `%d`",
-            listener_message_meta.listener_name,
+            listener_message_metadata.listener_name,
             self._queue,
             times_rejected + 1,
         )
 
     def _reply_response(
         self,
-        listener_message_meta: ListenerMessageMeta,
+        listener_message_metadata: ListenerMessageMetadata,
         response: Any,
     ) -> None:
-        assert listener_message_meta.properties.reply_to is not None
+        assert listener_message_metadata.properties.reply_to is not None
 
         reponse_properties = BasicProperties(content_type="application/json")
 
-        if listener_message_meta.properties.correlation_id is None:
+        if listener_message_metadata.properties.correlation_id is None:
             self._logger.warning(
                 "`correlation_id` property not supplied for listener `%s` and queue `%s`",
-                listener_message_meta.listener_name,
+                listener_message_metadata.listener_name,
                 self._queue,
             )
         else:
             reponse_properties.correlation_id = (
-                listener_message_meta.properties.correlation_id
+                listener_message_metadata.properties.correlation_id
             )
 
         try:
@@ -1115,8 +1133,8 @@ class Listener(AsyncEventLoopMixin):
         except Exception as e:
             self._call_exception_callback(
                 exception=e,
-                listener_message_meta=listener_message_meta,
-                message=f"listener response is not json serializable in listener `{listener_message_meta.listener_name}` and queue `{self._queue}`",
+                listener_message_metadata=listener_message_metadata,
+                message=f"listener response is not json serializable in listener `{listener_message_metadata.listener_name}` and queue `{self._queue}`",
             )
 
             return
@@ -1124,7 +1142,7 @@ class Listener(AsyncEventLoopMixin):
         self.loop.create_task(self._channel_pool.get()).add_done_callback(
             partial(
                 self._on_reply_channel_found,
-                listener_message_meta,
+                listener_message_metadata,
                 response_body,
                 reponse_properties,
             )
@@ -1156,7 +1174,7 @@ class Listener(AsyncEventLoopMixin):
 
     def _on_reply_channel_found(
         self,
-        listener_message_meta: ListenerMessageMeta,
+        listener_message_metadata: ListenerMessageMetadata,
         response_body: bytes,
         response_properties: BasicProperties,
         task: Task[BaseChannel],
@@ -1169,36 +1187,54 @@ class Listener(AsyncEventLoopMixin):
         if exception is not None:
             self._call_exception_callback(
                 exception=exception,
-                listener_message_meta=listener_message_meta,
-                message=f"error occured while getting channel for publishing response in listener `{listener_message_meta.listener_name}` and queue `{self._queue}`",
+                listener_message_metadata=listener_message_metadata,
+                message=f"error occured while getting channel for publishing response in listener `{listener_message_metadata.listener_name}` and queue `{self._queue}`",
             )
 
             return
 
-        try:
-            assert listener_message_meta.properties.reply_to is not None
+        if self._blocked_connection_check_callback():
+            self._remote_logger.error(
+                message=f"couldn't repond to rpc call on queue `{self._queue}` and listener `{listener_message_metadata.listener_name}` due to blocked connection",
+                tags=[
+                    "rabbitmq",
+                    "reply_connection_blocked",
+                    self._queue,
+                    listener_message_metadata.listener_name,
+                ],
+                extra={
+                    "serviceType": "rabbitmq",
+                    "queue": self._queue,
+                    "listenerName": listener_message_metadata.listener_name,
+                },
+            )
+
+            return
 
+        assert listener_message_metadata.properties.reply_to is not None
+
+        try:
             with task.result() as channel:
                 channel.basic_publish(
                     exchange=DEFAULT_EXCHANGE,
-                    routing_key=listener_message_meta.properties.reply_to,
+                    routing_key=listener_message_metadata.properties.reply_to,
                     properties=response_properties,
                     body=response_body,
                 )
         except Exception as e:
             self._call_exception_callback(
                 exception=e,
-                listener_message_meta=listener_message_meta,
-                message=f"error occured while publishing response to rpc call in listener `{listener_message_meta.listener_name}` and queue `{self._queue}`",
+                listener_message_metadata=listener_message_metadata,
+                message=f"error occured while publishing response to rpc call in listener `{listener_message_metadata.listener_name}` and queue `{self._queue}`",
             )
 
             return
 
         self._logger.debug(
             "sent a reply to `%s` for request from queue `%s` and listener `%s`",
-            listener_message_meta.properties.reply_to,
+            listener_message_metadata.properties.reply_to,
             self._queue,
-            listener_message_meta.listener_name,
+            listener_message_metadata.listener_name,
         )
 
     def __call__(self, listener: type[L]) -> type[L]:
@@ -1207,6 +1243,13 @@ class Listener(AsyncEventLoopMixin):
         return listener
 
 
+@dataclass
+class ListenerMethodMetadata:
+    listener_type: type[Listener]
+    listener_name: str | None = None
+    retry_policy: RetryPolicy | None = None
+
+
 class Consumer(Listener):
     def __init__(
         self,
@@ -1266,7 +1309,11 @@ def consume(
         setattr(
             consumer_method,
             CONSUMER_ATTRIBUTE,
-            ListenerMethodMeta(listener_name=target, retry_policy=retry_policy),
+            ListenerMethodMetadata(
+                listener_type=Consumer,
+                listener_name=target,
+                retry_policy=retry_policy,
+            ),
         )
 
         return consumer_method
@@ -1317,7 +1364,11 @@ def execute(
             )
 
         setattr(
-            worker_method, RPC_WORKER_ATTRIBUTE, ListenerMethodMeta(procedure)
+            worker_method,
+            RPC_WORKER_ATTRIBUTE,
+            ListenerMethodMetadata(
+                listener_type=RpcWorker, listener_name=procedure
+            ),
         )
 
         return worker_method
@@ -1325,13 +1376,9 @@ def execute(
     return wrapper
 
 
-@dataclass
-class ListenerMethodMeta:
-    listener_name: str | None = None
-    retry_policy: RetryPolicy | None = None
-
-
 class ListenerBase:
+    _LISTENER_ATTRIBUTES = {CONSUMER_ATTRIBUTE, RPC_WORKER_ATTRIBUTE}
+
     def get_inner_listener(self) -> Listener:
         listener = getattr(self, LISTENER_ATTRIBUTE, None)
 
@@ -1352,32 +1399,35 @@ class ListenerBase:
             if attribute is None:
                 continue
 
-            listener_method_attribute, listener_method, listener_method_meta = (
-                self._validate_listener_method_attribute(
-                    attribute=attribute,
-                    listener_method_attribute=CONSUMER_ATTRIBUTE,
-                    previous_listener_method_attribute=listener_method_attribute,
-                )
-            )
+            listener_method_attribute = None
+            listener_method = None
+            listener_method_metadata = None
+
+            for listener_attribute in self._LISTENER_ATTRIBUTES:
+                if (
+                    listener_method is not None
+                    and listener_method_metadata is not None
+                ):
+                    break
 
-            if listener_method is None or listener_method_meta is None:
                 (
                     listener_method_attribute,
                     listener_method,
-                    listener_method_meta,
+                    listener_method_metadata,
                 ) = self._validate_listener_method_attribute(
                     attribute=attribute,
-                    listener_method_attribute=RPC_WORKER_ATTRIBUTE,
+                    listener_method_attribute=listener_attribute,
                     previous_listener_method_attribute=listener_method_attribute,
+                    listener=listener,
                 )
 
-            if listener_method is None or listener_method_meta is None:
+            if listener_method is None or listener_method_metadata is None:
                 continue
 
             listener.add_listener_method(
-                listener_name=listener_method_meta.listener_name,
+                listener_name=listener_method_metadata.listener_name,
                 listener_method=listener_method,
-                retry_policy=listener_method_meta.retry_policy,
+                retry_policy=listener_method_metadata.retry_policy,
             )
 
         return listener
@@ -1387,19 +1437,21 @@ class ListenerBase:
         attribute: Any,
         listener_method_attribute: str,
         previous_listener_method_attribute: str | None,
+        listener: Listener,
     ) -> tuple[
-        str | None, Callable[..., Any] | None, ListenerMethodMeta | None
+        str | None, Callable[..., Any] | None, ListenerMethodMetadata | None
     ]:
-        listener_method_meta = getattr(
+        listener_method_metadata = getattr(
             attribute, listener_method_attribute, None
         )
 
-        if listener_method_meta is None:
+        if listener_method_metadata is None:
             return previous_listener_method_attribute or None, None, None
 
-        if not isinstance(listener_method_meta, ListenerMethodMeta):
+        if not isinstance(listener_method_metadata, ListenerMethodMetadata):
             raise TypeError(
-                f"expected `{listener_method_attribute}` to by of type `ListenerMethodMeta`, got {type(listener_method_meta)}"
+                f"expected `{listener_method_attribute}` to by of type `ListenerMethodMetadata`, "
+                f"got {type(listener_method_metadata)}"
             )
 
         if (
@@ -1413,4 +1465,17 @@ class ListenerBase:
                 f"object annotated with `{listener_method_attribute}` is not callable"
             )
 
-        return listener_method_attribute, attribute, listener_method_meta
+        if (
+            listener_method_metadata.listener_type
+            not in listener.__class__.mro()
+        ):
+            listener_mro = ", ".join(
+                map(lambda c: c.__name__, listener.__class__.mro())
+            )
+
+            raise TypeError(
+                f"listener method is not correct member of `{listener_method_metadata.listener_type.__name__}`, "
+                f"got `[{listener_mro}]` super classes"
+            )
+
+        return listener_method_attribute, attribute, listener_method_metadata