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

qena_shared_lib/logstash/_tcp_sender.py

@@ -0,0 +1,84 @@
+from asyncio import open_connection
+
+from pydantic_core import to_json
+
+from ..logging import LoggerProvider
+from ._base import BaseLogstashSender, LogstashLogRecord, SenderResponse
+
+__all__ = ["TCPSender"]
+
+
+class TCPSender(BaseLogstashSender):
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        service_name: str,
+        max_log_retry: int = 5,
+        log_queue_size: int = 100,
+        failed_log_queue_size: int = 500,
+    ):
+        super().__init__(
+            service_name=service_name,
+            max_log_retry=max_log_retry,
+            log_queue_size=log_queue_size,
+            failed_log_queue_size=failed_log_queue_size,
+        )
+
+        self._client = AsyncTcpClient(host=host, port=port)
+        self._logger = LoggerProvider.default().get_logger("logstash.tcpsender")
+
+    async def _send(self, log: LogstashLogRecord) -> SenderResponse:
+        await self._client.write(log.to_dict())
+
+        return SenderResponse(sent=True)
+
+    async def _hook_on_start_async(self):
+        await self._client.open()
+
+    async def _hook_on_stop_async(self):
+        await self._client.close()
+
+
+class AsyncTcpClient:
+    def __init__(self, host: str, port: int):
+        self._host = host
+        self._port = port
+        self._writer = None
+        self._client_closed = False
+
+    async def write(self, json: dict):
+        if self._client_closed:
+            raise RuntimeError("async tcp client already closed")
+
+        if self._writer_closed():
+            await self._connect()
+
+        assert self._writer is not None
+
+        self._writer.write(to_json(json))
+        self._writer.write(b"\n")
+
+        try:
+            await self._writer.drain()
+        except ConnectionResetError:
+            await self._connect()
+
+    async def open(self):
+        await self._connect()
+
+    async def close(self):
+        if not self._writer_closed() and self._writer is not None:
+            self._writer.write_eof()
+            await self._writer.drain()
+            self._writer.close()
+
+            self._client_closed = True
+
+    def _writer_closed(self) -> bool:
+        return self._writer is None or self._writer.is_closing()
+
+    async def _connect(self):
+        _, self._writer = await open_connection(
+            host=self._host, port=self._port
+        )

qena_shared_lib/rabbitmq/__init__.py

@@ -0,0 +1,52 @@
+from ._base import AbstractRabbitMQService, RabbitMqManager
+from ._channel import BaseChannel
+from ._exception_handlers import (
+    handle_general_mq_exception,
+    handle_microservice_exception,
+    handle_rabbitmq_exception,
+    handle_validation_error,
+)
+from ._exceptions import RabbitMQException
+from ._listener import (
+    CONSUMER_ATTRIBUTE,
+    LISTENER_ATTRIBUTE,
+    RPC_WORKER_ATTRIBUTE,
+    BackoffRetryDelay,
+    Consumer,
+    FixedRetryDelay,
+    ListenerBase,
+    ListenerContext,
+    RetryDelayJitter,
+    RetryPolicy,
+    RpcWorker,
+    consume,
+    execute,
+)
+from ._publisher import Publisher
+from ._rpc_client import RpcClient
+
+__all__ = [
+    "AbstractRabbitMQService",
+    "BackoffRetryDelay",
+    "BaseChannel",
+    "consume",
+    "CONSUMER_ATTRIBUTE",
+    "Consumer",
+    "execute",
+    "FixedRetryDelay",
+    "handle_general_mq_exception",
+    "handle_microservice_exception",
+    "handle_rabbitmq_exception",
+    "handle_validation_error",
+    "LISTENER_ATTRIBUTE",
+    "ListenerBase",
+    "ListenerContext",
+    "Publisher",
+    "RabbitMQException",
+    "RabbitMqManager",
+    "RetryDelayJitter",
+    "RetryPolicy",
+    "RPC_WORKER_ATTRIBUTE",
+    "RpcClient",
+    "RpcWorker",
+]