qena-shared-lib 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

qena_shared_lib/rabbitmq/_base.py

@@ -27,17 +27,18 @@ from punq import Container, Scope
 from pydantic import ValidationError
 
 from ..dependencies.miscellaneous import validate_annotation
-from ..exceptions import ServiceException
+from ..exceptions import (
+    RabbitMQConnectionUnhealthyError,
+    ServiceException,
+)
 from ..logging import LoggerProvider
 from ..logstash import BaseLogstashSender
 from ..utils import AsyncEventLoopMixin
 from ._exception_handlers import (
     handle_general_mq_exception,
-    handle_microservice_exception,
-    handle_rabbitmq_exception,
+    handle_rabbit_mq_service_exception,
     handle_validation_error,
 )
-from ._exceptions import RabbitMQException
 from ._listener import (
     LISTENER_ATTRIBUTE,
     Listener,
@@ -121,9 +122,10 @@ class RabbitMqManager(AsyncEventLoopMixin):
             type[Exception], ExceptionHandlerContainer
         ] = {}
 
-        self.exception_handler(RabbitMQException)(handle_rabbitmq_exception)
+        self.exception_handler(ServiceException)(
+            handle_rabbit_mq_service_exception
+        )
         self.exception_handler(ValidationError)(handle_validation_error)
-        self.exception_handler(ServiceException)(handle_microservice_exception)
         self.exception_handler(Exception)(handle_general_mq_exception)
 
         self._channel_pool = ChannelPool()
@@ -288,7 +290,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
     @property
     def connection(self) -> AsyncioConnection:
         if not self._is_connection_healthy():
-            raise RuntimeError("connection not ready yet")
+            raise RabbitMQConnectionUnhealthyError("connection not ready yet")
 
         assert self._connection is not None
 
@@ -302,7 +304,9 @@ class RabbitMqManager(AsyncEventLoopMixin):
         headers: dict[str, str] | None = None,
     ) -> Publisher:
         if not self._is_connection_healthy():
-            raise RuntimeError("rabbitmq connection is not healthy")
+            raise RabbitMQConnectionUnhealthyError(
+                "rabbitmq connection is not healthy"
+            )
 
         return Publisher(
             routing_key=routing_key,
@@ -322,16 +326,15 @@ class RabbitMqManager(AsyncEventLoopMixin):
         return_type: type | None = None,
         timeout: float = 0,
     ) -> RpcClient:
-        if timeout < 0:
-            raise ValueError(f"timeout cannot below 0, got {timeout} seconds")
-
         if timeout == 0:
             self._logger.warning(
                 "rpc call with 0 seconds timeout may never return back"
             )
 
         if not self._is_connection_healthy():
-            raise RuntimeError("rabbitmq connection is not healthy")
+            raise RabbitMQConnectionUnhealthyError(
+                "rabbitmq connection is not healthy"
+            )
 
         return RpcClient(
             routing_key=routing_key,
@@ -341,7 +344,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             procedure=procedure,
             headers=headers,
             return_type=return_type,
-            timeout=timeout,
+            timeout=abs(timeout),
         )
 
     def _is_connection_healthy(self) -> bool:
@@ -359,7 +362,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
         self._disconnected = True
 
         if self._connection is None:
-            raise RuntimeError("connection not ready yet")
+            raise RabbitMQConnectionUnhealthyError("connection not ready yet")
 
         if self._connection.is_closing or self._connection.is_closed:
             self._logger.info("already disconnected from rabbitmq")
@@ -411,7 +414,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             return
 
         if self._connection is None:
-            raise RuntimeError("connection not ready yet")
+            raise RabbitMQConnectionUnhealthyError("connection not ready yet")
 
         self.loop.create_task(
             self._channel_pool.fill(self._connection)
@@ -464,7 +467,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             return
 
         if self._connection is None:
-            raise RuntimeError("connection not ready yet")
+            raise RabbitMQConnectionUnhealthyError("connection not ready yet")
 
         channel_count = len(self._channel_pool)
 
@@ -537,7 +540,7 @@ class RabbitMqManager(AsyncEventLoopMixin):
             self._connected = True
 
         if self._connection is None:
-            raise RuntimeError("connection not ready yet")
+            raise RabbitMQConnectionUnhealthyError("connection not ready yet")
 
         params = self._connection.params
         listener_count = len(self._listeners)

qena_shared_lib/rabbitmq/_exception_handlers.py

@@ -3,80 +3,26 @@ from typing import Annotated
 from pydantic import ValidationError
 
 from ..dependencies.miscellaneous import DependsOn
-from ..exceptions import ServiceException, Severity
+from ..exceptions import (
+    HTTPServiceError,
+    RabbitMQServiceException,
+    ServiceException,
+    Severity,
+)
 from ..logging import LoggerProvider
 from ..logstash._base import BaseLogstashSender
-from ._exceptions import RabbitMQException
 from ._listener import ListenerContext
 
 __all__ = [
     "handle_general_mq_exception",
-    "handle_microservice_exception",
-    "handle_rabbitmq_exception",
+    "handle_rabbit_mq_service_exception",
     "handle_validation_error",
 ]
 
 RABBITMQ_EXCEPTION_HANDLER_LOGGER_NAME = "rabbitmq.exception_handler"
 
 
-def handle_rabbitmq_exception(
-    context: ListenerContext,
-    exception: RabbitMQException,
-    logstash: Annotated[BaseLogstashSender, DependsOn(BaseLogstashSender)],
-    logger_provider: Annotated[LoggerProvider, DependsOn(LoggerProvider)],
-):
-    logger = logger_provider.get_logger(RABBITMQ_EXCEPTION_HANDLER_LOGGER_NAME)
-
-    if not exception.logstash_logging:
-        logger.warning("%r", exception)
-
-        return
-
-    logstash.warning(
-        message=exception.message,
-        tags=exception.tags
-        or [
-            "RabbitMQ",
-            "RabbitMQException",
-            str(exception.code),
-            context.queue,
-            context.listener_name or "__default__",
-        ],
-        extra=exception.extra
-        or {
-            "serviceType": "RabbitMQ",
-            "queue": context.queue,
-            "listenerName": context.listener_name,
-            "exception": "RabbitMQException",
-        },
-        exception=exception,
-    )
-
-
-def handle_validation_error(
-    context: ListenerContext,
-    exception: ValidationError,
-    logstash: Annotated[BaseLogstashSender, DependsOn(BaseLogstashSender)],
-):
-    logstash.error(
-        message=f"invalid rabbitmq request data at queue `{context.queue}` and listener `{context.listener_name}`",
-        tags=[
-            "RabbitMQ",
-            "ValidationError",
-            context.queue,
-            context.listener_name or "__default__",
-        ],
-        extra={
-            "serviceType": "RabbitMQ",
-            "queue": context.queue,
-            "listenerName": context.listener_name,
-            "exception": "ValidationError",
-        },
-        exception=exception,
-    )
-
-
-def handle_microservice_exception(
+def handle_rabbit_mq_service_exception(
     context: ListenerContext,
     exception: ServiceException,
     logstash: Annotated[BaseLogstashSender, DependsOn(BaseLogstashSender)],
@@ -85,14 +31,10 @@ def handle_microservice_exception(
     logger = logger_provider.get_logger(RABBITMQ_EXCEPTION_HANDLER_LOGGER_NAME)
     tags = [
         "RabbitMQ",
-        type(exception).__name__,
         context.queue,
         context.listener_name or "__default__",
+        exception.__class__.__name__,
     ]
-
-    if exception.tags:
-        exception.tags.extend(tags)
-
     extra = {
         "serviceType": "RabbitMQ",
         "queue": context.queue,
@@ -100,8 +42,30 @@ def handle_microservice_exception(
         "exception": exception.__class__.__name__,
     }
 
+    match exception:
+        case HTTPServiceError() as http_service_error:
+            if http_service_error.status_code is not None:
+                str_status_code = str(http_service_error.status_code)
+                extra["statusCode"] = str_status_code
+
+                tags.append(str_status_code)
+
+            if http_service_error.response_code is not None:
+                str_response_code = str(http_service_error.response_code)
+                extra["responseCode"] = str_response_code
+
+                tags.append(str_response_code)
+        case RabbitMQServiceException() as rabbitmq_service_exception:
+            str_error_code = str(rabbitmq_service_exception.code)
+            extra["code"] = str_error_code
+
+            tags.append(str_error_code)
+
+    if exception.tags:
+        tags.extend(exception.tags)
+
     if exception.extra:
-        exception.extra.update(extra)
+        extra.update(exception.extra)
 
     exc_info = (
         (type(exception), exception, exception.__traceback__)
@@ -123,8 +87,8 @@ def handle_microservice_exception(
     if exception.logstash_logging:
         logstash_logger_method(
             message=exception.message,
-            tags=exception.tags or tags,
-            extra=exception.extra or extra,
+            tags=tags,
+            extra=extra,
             exception=exception if exception.extract_exc_info else None,
         )
     else:
@@ -137,6 +101,29 @@ def handle_microservice_exception(
         )
 
 
+def handle_validation_error(
+    context: ListenerContext,
+    exception: ValidationError,
+    logstash: Annotated[BaseLogstashSender, DependsOn(BaseLogstashSender)],
+):
+    logstash.error(
+        message=f"invalid rabbitmq request data at queue `{context.queue}` and listener `{context.listener_name}`",
+        tags=[
+            "RabbitMQ",
+            context.queue,
+            context.listener_name or "__default__",
+            "ValidationError",
+        ],
+        extra={
+            "serviceType": "RabbitMQ",
+            "queue": context.queue,
+            "listenerName": context.listener_name,
+            "exception": "ValidationError",
+        },
+        exception=exception,
+    )
+
+
 def handle_general_mq_exception(
     context: ListenerContext,
     exception: Exception,
@@ -146,9 +133,9 @@ def handle_general_mq_exception(
         message=f"something went wrong while consuming message on queue `{context.queue}` and listener `{context.listener_name}`",
         tags=[
             "RabbitMQ",
-            exception.__class__.__name__,
             context.queue,
             context.listener_name or "__default__",
+            exception.__class__.__name__,
         ],
         extra={
             "serviceType": "RabbitMQ",

qena_shared_lib/rabbitmq/_listener.py

@@ -19,11 +19,11 @@ 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 ..logstash import BaseLogstashSender
 from ..utils import AsyncEventLoopMixin, TypeAdapterCache
 from ._channel import BaseChannel
-from ._exceptions import RabbitMQException
 from ._pool import ChannelPool
 
 __all__ = [
@@ -184,6 +184,7 @@ class RetryPolicy:
     max_retry: int
     retry_delay_strategy: RetryDelayStrategy
     retry_delay_jitter: RetryDelayJitter | None = None
+    match_by_cause: bool = False
 
     def can_retry(self, times_rejected: int) -> bool:
         return times_rejected < self.max_retry
@@ -756,9 +757,18 @@ class Listener(AsyncEventLoopMixin):
                     or self._global_retry_policy
                 )
 
-                if retry_policy is not None and any(
-                    exception_type in retry_policy.exceptions
-                    for exception_type in type(exception).mro()
+                if retry_policy is not None and (
+                    self._is_recoverable_exception(
+                        exception=exception,
+                        retry_policy_exceptions=retry_policy.exceptions,
+                    )
+                    or (
+                        retry_policy.match_by_cause
+                        and self._has_recoverable_cause(
+                            exception=exception,
+                            retry_policy_exceptions=retry_policy.exceptions,
+                        )
+                    )
                 ):
                     times_rejected = None
 
@@ -824,6 +834,43 @@ class Listener(AsyncEventLoopMixin):
             queue=self._queue, listener_name=listener_message_meta.listener_name
         ).observe(listener_message_meta.listener_start_time - time())
 
+    def _is_recoverable_exception(
+        self,
+        exception: BaseException,
+        retry_policy_exceptions: Collection[type[Exception]],
+    ) -> bool:
+        return self._in_retry_policy_exceptions(
+            exception=exception, retry_policy_exceptions=retry_policy_exceptions
+        )
+
+    def _has_recoverable_cause(
+        self,
+        exception: BaseException,
+        retry_policy_exceptions: Collection[type[Exception]],
+    ) -> bool:
+        cause = exception.__cause__ or exception.__context__
+
+        while cause is not None:
+            if self._in_retry_policy_exceptions(
+                exception=cause,
+                retry_policy_exceptions=retry_policy_exceptions,
+            ):
+                return True
+
+            cause = cause.__cause__ or exception.__context__
+
+        return False
+
+    def _in_retry_policy_exceptions(
+        self,
+        exception: BaseException,
+        retry_policy_exceptions: Collection[type[Exception]],
+    ) -> bool:
+        return any(
+            exception_type in retry_policy_exceptions
+            for exception_type in type(exception).mro()
+        )
+
     def _call_exception_callback(
         self,
         exception: BaseException,
@@ -1035,20 +1082,24 @@ class Listener(AsyncEventLoopMixin):
 
     def _reponse_from_exception(self, exception: BaseException) -> dict:
         match exception:
-            case RabbitMQException() as rabbitmq_exception:
+            case RabbitMQServiceException() as rabbitmq_exception:
                 code = rabbitmq_exception.code
                 message = rabbitmq_exception.message
+                data = rabbitmq_exception.data
             case ValidationError() as validation_error:
                 code = 0
-                message = validation_error.json()
+                message = validation_error.title
+                data = validation_error.json()
             case unknown_execption:
                 code = 0
                 message = str(unknown_execption)
+                data = None
 
         return {
             "exception": True,
             "code": code,
             "message": message,
+            "data": data,
         }
 
     def _on_reply_channel_found(
@@ -1137,6 +1188,38 @@ class Consumer(Listener):
         return wrapper
 
 
+def consumer(
+    queue: str,
+    prefetch_count: int = 250,
+    retry_policy: RetryPolicy | None = None,
+) -> Consumer:
+    return Consumer(
+        queue=queue,
+        prefetch_count=prefetch_count,
+        retry_policy=retry_policy,
+    )
+
+
+def consume(
+    target: str | None = None, retry_policy: RetryPolicy | None = None
+) -> Callable[[Callable], Callable]:
+    def wrapper(consumer_method: Callable) -> Callable:
+        if not callable(consumer_method):
+            raise TypeError(
+                f"consumer method argument not a callable, got {type(consumer_method)}"
+            )
+
+        setattr(
+            consumer_method,
+            CONSUMER_ATTRIBUTE,
+            ListenerMethodMeta(listener_name=target, retry_policy=retry_policy),
+        )
+
+        return consumer_method
+
+    return wrapper
+
+
 class RpcWorker(Listener):
     def __init__(self, queue: str, prefetch_count: int = 250):
         super().__init__(
@@ -1166,6 +1249,26 @@ class RpcWorker(Listener):
         return wrapper
 
 
+def rpc_worker(queue: str, prefetch_count: int = 250) -> RpcWorker:
+    return RpcWorker(queue=queue, prefetch_count=prefetch_count)
+
+
+def execute(procedure: str | None = None) -> Callable[[Callable], Callable]:
+    def wrapper(worker_method: Callable) -> Callable:
+        if not callable(worker_method):
+            raise TypeError(
+                f"worker method argument not a callable, got {type(worker_method)}"
+            )
+
+        setattr(
+            worker_method, RPC_WORKER_ATTRIBUTE, ListenerMethodMeta(procedure)
+        )
+
+        return worker_method
+
+    return wrapper
+
+
 @dataclass
 class ListenerMethodMeta:
     listener_name: str | None = None
@@ -1253,39 +1356,3 @@ class ListenerBase:
             )
 
         return listener_method_attribute, attribute, listener_method_meta
-
-
-def consume(
-    target: str | None = None, retry_policy: RetryPolicy | None = None
-) -> Callable[[Callable], Callable]:
-    def wrapper(consumer_method: Callable) -> Callable:
-        if not callable(consumer_method):
-            raise TypeError(
-                f"consumer method argument not a callable, got {type(consumer_method)}"
-            )
-
-        setattr(
-            consumer_method,
-            CONSUMER_ATTRIBUTE,
-            ListenerMethodMeta(listener_name=target, retry_policy=retry_policy),
-        )
-
-        return consumer_method
-
-    return wrapper
-
-
-def execute(procedure: str | None = None) -> Callable[[Callable], Callable]:
-    def wrapper(worker_method: Callable) -> Callable:
-        if not callable(worker_method):
-            raise TypeError(
-                f"worker method argument not a callable, got {type(worker_method)}"
-            )
-
-        setattr(
-            worker_method, RPC_WORKER_ATTRIBUTE, ListenerMethodMeta(procedure)
-        )
-
-        return worker_method
-
-    return wrapper

qena_shared_lib/rabbitmq/_publisher.py

@@ -4,6 +4,7 @@ from pika import BasicProperties
 from prometheus_client import Counter
 from pydantic_core import to_json
 
+from ..exceptions import RabbitMQBlockedError
 from ..logging import LoggerProvider
 from ._pool import ChannelPool
 
@@ -47,7 +48,7 @@ class Publisher:
 
     async def _get_channel_and_publish(self, message: Any):
         if self._blocked_connection_check_callback():
-            raise RuntimeError(
+            raise RabbitMQBlockedError(
                 "rabbitmq broker is not able to accept message right now"
             )
 

qena_shared_lib/rabbitmq/_rpc_client.py

@@ -12,9 +12,14 @@ from pika.spec import Basic
 from prometheus_client import Counter, Summary
 from pydantic_core import from_json, to_json
 
+from ..exceptions import (
+    RabbitMQBlockedError,
+    RabbitMQRpcRequestPendingError,
+    RabbitMQRpcRequestTimeoutError,
+    RabbitMQServiceException,
+)
 from ..logging import LoggerProvider
 from ..utils import AsyncEventLoopMixin, TypeAdapterCache
-from ._exceptions import RabbitMQException
 from ._pool import ChannelPool
 
 __all__ = ["RpcClient"]
@@ -97,7 +102,7 @@ class RpcClient(AsyncEventLoopMixin):
         procedure: str | None = None,
         headers: dict[str, str] | None = None,
         return_type: type | None = None,
-        timeout: float = 0,
+        timeout: float = 15,
     ):
         self._routing_key = routing_key
         self._exchange = exchange or ""
@@ -130,13 +135,15 @@ class RpcClient(AsyncEventLoopMixin):
 
     async def _get_channel_and_call(self, message: Any) -> Any:
         if self._blocked_connection_check_callback():
-            raise RuntimeError(
+            raise RabbitMQBlockedError(
                 "rabbitmq broker is not able to accept message right now"
             )
 
         async with self._rpc_call_lock:
             if self._rpc_call_pending:
-                raise RuntimeError("previous rpc request not done yet")
+                raise RabbitMQRpcRequestPendingError(
+                    "previous rpc request not done yet"
+                )
 
             self._rpc_call_pending = True
 
@@ -200,7 +207,7 @@ class RpcClient(AsyncEventLoopMixin):
 
     def _on_timeout(self):
         self._finalize_call(
-            exception=TimeoutError(
+            exception=RabbitMQRpcRequestTimeoutError(
                 f"rpc worker didn't responed in a timely manner within `{self._timeout}` seconds"
             )
         )
@@ -232,7 +239,7 @@ class RpcClient(AsyncEventLoopMixin):
 
         if isinstance(response, dict) and "exception" in response:
             self._finalize_call(
-                exception=RabbitMQException(
+                exception=RabbitMQServiceException(
                     code=response.get("code") or 0,
                     message=response.get("message")
                     or "unknown error occured from the rpc worker side",

qena_shared_lib/scheduler.py

@@ -20,6 +20,7 @@ from .utils import AsyncEventLoopMixin
 __all__ = [
     "schedule",
     "ScheduleManager",
+    "scheduler",
     "Scheduler",
     "SchedulerBase",
 ]
@@ -108,6 +109,10 @@ class Scheduler:
         return self._scheduled_tasks
 
 
+def scheduler() -> Scheduler:
+    return Scheduler()
+
+
 @dataclass
 class ScheduledTaskMeta:
     cron_expression: str

qena_shared_lib/security.py

@@ -15,7 +15,7 @@ from .exceptions import Unauthorized
 from .utils import AsyncEventLoopMixin
 
 __all__ = [
-    "EndpointACL",
+    "Authorization",
     "get_int_from_datetime",
     "get_time_from_int",
     "jwk_from_dict",
@@ -137,7 +137,7 @@ class PermissionMatch(Enum):
     ALL = 1
 
 
-def EndpointACL(
+def Authorization(
     user_type: str | None = None,
     permissions: list[str] | None = None,
     permission_match_strategy: PermissionMatch | None = None,
@@ -186,7 +186,7 @@ class EndpointAclValidator:
                 tags=[user_info.user_id],
                 extra={
                     "userId": user_info.user_id,
-                    "userYype": user_info.user_type,
+                    "userType": user_info.user_type,
                     "userPermissions": str(user_info.user_permissions or []),
                     "requiredUserType": self._user_type or "None",
                     "requiredPermissions": str(self._permissions or []),