qena-shared-lib 0.1.0__py3-none-any.whl

qena_shared_lib/rabbitmq/_channel.py

@@ -0,0 +1,196 @@
+from asyncio import Future
+from random import uniform
+from uuid import UUID, uuid4
+
+from pika.adapters.asyncio_connection import AsyncioConnection
+from pika.channel import Channel
+from pika.exceptions import ChannelClosedByClient
+from pika.spec import Basic
+
+from ..logging import LoggerProvider
+from ..utils import AsyncEventLoopMixin
+
+__all__ = ["BaseChannel"]
+
+
+class BaseChannel(AsyncEventLoopMixin):
+    def __init__(
+        self,
+        connection: AsyncioConnection,
+        reopen_delay: int = 1,
+        reopen_delay_jitter: tuple[float, float] = (0.0, 2.0),
+        failed_reopen_threshold: int | None = 5,
+    ):
+        self._connection = connection
+        self._reopen_delay = reopen_delay
+        self._reopen_delay_jitter = reopen_delay_jitter
+        self._failed_reopen_threshold = failed_reopen_threshold
+        self._completion_future = self.loop.create_future()
+        self._channel = None
+        self._channel_id = uuid4()
+        self._reopen_failures = 0
+        self._reserved = False
+        self._can_be_disposed = False
+        self._logger = LoggerProvider.default().get_logger(
+            "rabbitmq.base_channel"
+        )
+
+    def open(self) -> Future[UUID]:
+        if self._channel is not None:
+            raise RuntimeError("channel already opened")
+
+        try:
+            _ = self._connection.channel(
+                channel_number=None, on_open_callback=self._on_channel_opened
+            )
+        except Exception as e:
+            self._can_be_disposed = True
+
+            if not self._completion_future.done():
+                self._completion_future.set_exception(e)
+
+        return self._completion_future
+
+    def reserve(self):
+        self._reserved = True
+
+    def release(self):
+        self._reserved = False
+
+    def _on_channel_opened(self, channel: Channel):
+        self._channel = channel
+
+        try:
+            self._hook_on_channel_opened()
+        except Exception as e:
+            if not self._completion_future.done():
+                self._completion_future.set_exception(e)
+            else:
+                if not self.channel_closed():
+                    self._channel.close()
+
+                self._reopen()
+
+            return
+
+        self._channel.add_on_cancel_callback(self._on_cancelled)
+        self._channel.add_on_close_callback(self._on_channel_closed)
+
+        self._completion_future.set_result(self._channel_id)
+
+    def _hook_on_channel_opened(self):
+        pass
+
+    def channel_closed(self) -> bool:
+        if self._channel is None:
+            raise RuntimeError("underlying channel not set")
+
+        return self._channel.is_closing or self._channel.is_closed
+
+    def _on_cancelled(self, method: Basic.Cancel):
+        del method
+
+        if not self._completion_future.done():
+            self._completion_future.set_exception(
+                RuntimeError("cancellation recieved from rabbitmq server")
+            )
+
+            return
+
+        try:
+            self._hook_on_cancelled()
+        except:
+            self._logger.exception("error occured on invoking cancel hook")
+
+    def _hook_on_cancelled(self):
+        pass
+
+    def _on_channel_closed(self, channel: Channel, error: BaseException):
+        del channel
+
+        try:
+            self._hook_on_channel_closed(error)
+        except:
+            self._reopen_failures += 1
+
+            return
+
+        if not isinstance(error, ChannelClosedByClient):
+            self._reopen()
+
+    def _hook_on_channel_closed(self, error: BaseException):
+        del error
+
+    def _reopen(self):
+        if (
+            self._failed_reopen_threshold is not None
+            and self._reopen_failures >= self._failed_reopen_threshold
+        ):
+            self._can_be_disposed = True
+
+            return
+
+        self.loop.call_later(
+            delay=self._reopen_delay + uniform(*self._reopen_delay_jitter),
+            callback=self._on_time_to_reopen,
+        )
+
+    def _on_time_to_reopen(self):
+        if self._connection.is_closing or self._connection.is_closed:
+            self._can_be_disposed = True
+
+            return
+
+        try:
+            _ = self._connection.channel(
+                channel_number=None, on_open_callback=self._on_channel_opened
+            )
+        except:
+            self._logger.exception(
+                "coudn't reopen channel %s", self._channel_id
+            )
+            self._reopen()
+
+    def __enter__(self):
+        if not self._reserved:
+            self.reserve()
+
+        if self._channel is None:
+            raise RuntimeError("underlying channel not opened yet")
+
+        return self._channel
+
+    def __exit__(self, *_):
+        self.release()
+
+    @property
+    def channel_id(self) -> UUID:
+        return self._channel_id
+
+    @property
+    def healthy(self) -> bool:
+        return (
+            not self._can_be_disposed
+            and self._channel is not None
+            and not self._channel.is_closing
+            and not self._channel.is_closed
+        )
+
+    @property
+    def reserved(self) -> bool:
+        return self._reserved
+
+    @property
+    def can_be_disposed(self) -> bool:
+        return self._can_be_disposed
+
+    @property
+    def connection(self) -> AsyncioConnection:
+        return self._connection
+
+    @property
+    def channel(self) -> Channel:
+        if self._channel is None:
+            raise RuntimeError("underlying channel not opened yet")
+
+        return self._channel

qena_shared_lib/rabbitmq/_exception_handlers.py

@@ -0,0 +1,159 @@
+from typing import Annotated
+
+from pydantic import ValidationError
+
+from ..dependencies.miscellaneous import DependsOn
+from ..exceptions import 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_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",
+        },
+    )
+
+
+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(
+    context: ListenerContext,
+    exception: ServiceException,
+    logstash: Annotated[BaseLogstashSender, DependsOn(BaseLogstashSender)],
+    logger_provider: Annotated[LoggerProvider, DependsOn(LoggerProvider)],
+):
+    logger = logger_provider.get_logger(RABBITMQ_EXCEPTION_HANDLER_LOGGER_NAME)
+    tags = [
+        "RabbitMQ",
+        type(exception).__name__,
+        context.queue,
+        context.listener_name or "__default__",
+    ]
+
+    if exception.tags:
+        exception.tags.extend(tags)
+
+    extra = {
+        "serviceType": "RabbitMQ",
+        "queue": context.queue,
+        "listenerName": context.listener_name,
+        "exception": exception.__class__.__name__,
+    }
+
+    if exception.extra:
+        exception.extra.update(extra)
+
+    exc_info = (
+        (type(exception), exception, exception.__traceback__)
+        if exception.extract_exc_info
+        else None
+    )
+
+    match exception.severity:
+        case Severity.HIGH:
+            logstash_logger_method = logstash.error
+            logger_method = logger.error
+        case Severity.MEDIUM:
+            logstash_logger_method = logstash.warning
+            logger_method = logger.warning
+        case _:
+            logstash_logger_method = logstash.info
+            logger_method = logger.info
+
+    if exception.logstash_logging:
+        logstash_logger_method(
+            message=exception.message,
+            tags=exception.tags or tags,
+            extra=exception.extra or extra,
+            exception=exception if exception.extract_exc_info else None,
+        )
+    else:
+        logger_method(
+            "\nRabbitMQ `%s` -> `%s`\n%s",
+            context.queue,
+            context.listener_name,
+            exception.message,
+            exc_info=exc_info,
+        )
+
+
+def handle_general_mq_exception(
+    context: ListenerContext,
+    exception: Exception,
+    logstash: Annotated[BaseLogstashSender, DependsOn(BaseLogstashSender)],
+):
+    logstash.error(
+        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__",
+        ],
+        extra={
+            "serviceType": "RabbitMQ",
+            "queue": context.queue,
+            "listenerName": context.listener_name,
+            "exception": exception.__class__.__name__,
+        },
+        exception=exception,
+    )

qena_shared_lib/rabbitmq/_exceptions.py

@@ -0,0 +1,46 @@
+class RabbitMQException(Exception):
+    def __init__(
+        self,
+        code: int,
+        message: str,
+        tags: list[str] | None = None,
+        extra: dict[str, str] | None = None,
+        logstash_logging: bool = True,
+        extract_exc_info: bool = True,
+    ):
+        self._code = code
+        self._message = message
+        self._tags = tags
+        self._extra = extra
+        self._logstash_logging = logstash_logging
+        self._extract_exc_info = extract_exc_info
+
+    @property
+    def code(self) -> int:
+        return self._code
+
+    @property
+    def message(self) -> str:
+        return self._message
+
+    @property
+    def tags(self) -> list[str] | None:
+        return self._tags
+
+    @property
+    def extra(self) -> dict[str, str] | None:
+        return self._extra
+
+    @property
+    def logstash_logging(self) -> bool:
+        return self._logstash_logging
+
+    @property
+    def extract_exc_info(self) -> bool:
+        return self._extract_exc_info
+
+    def __str__(self) -> str:
+        return f"message `{self.message}`, code `{self.code}`"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__} ( message: `{self._message}`, code: {self._code} )"