qena-shared-lib 0.1.18__py3-none-any.whl → 0.1.20__py3-none-any.whl

qena_shared_lib/redis.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+from inspect import isawaitable
+
+from redis.asyncio import ConnectionPool, Redis
+
+from .logging import LoggerFactory
+
+__all__ = [
+    "RedisDependent",
+    "RedisManager",
+]
+
+
+class RedisDependent(ABC):
+    @abstractmethod
+    def attach(self, redis_client: Redis) -> None:
+        pass
+
+
+class RedisManager:
+    def __init__(self, url: str):
+        self._logger = LoggerFactory.get_logger("redis")
+        self._redis_dependents: set[RedisDependent] = set()
+        self._url = url
+
+    async def connect(self) -> None:
+        self._redis_connection_pool = ConnectionPool.from_url(self._url)
+        self._redis_client = Redis.from_pool(self._redis_connection_pool)
+
+        response = self._redis_client.ping()
+
+        if isawaitable(response):
+            await response
+
+        for redis_dependent in self._redis_dependents:
+            redis_dependent.attach(self._redis_client)
+
+        self._logger.info("connected to redis")
+
+    async def disconnect(self) -> None:
+        await self._redis_connection_pool.aclose()
+        self._logger.info("disconnected from redis")
+
+    def add(self, redis_dependent: RedisDependent) -> "RedisManager":
+        self._redis_dependents.add(redis_dependent)
+
+        return self

qena_shared_lib/remotelogging/_base.py

@@ -6,6 +6,7 @@ from asyncio import (
     gather,
 )
 from dataclasses import dataclass
+from datetime import datetime
 from enum import Enum
 from sys import exc_info
 from traceback import format_exception
@@ -47,6 +48,7 @@ class RemoteLogRecord:
         self._error_type: str | None = None
         self._error_message: str | None = None
         self._error_stack_trace: str | None = None
+        self._created_time = datetime.now()
         self._log_retries = 0
 
     @property
@@ -85,6 +87,18 @@ class RemoteLogRecord:
     def error(self) -> tuple[str | None, str | None, str | None]:
         return self._error_type, self._error_message, self._error_stack_trace
 
+    @property
+    def log_retries(self) -> int:
+        return self._log_retries
+
+    @log_retries.setter
+    def log_retries(self, log_retries: int) -> None:
+        self._log_retries = log_retries
+
+    @property
+    def created_time(self) -> datetime:
+        return self._created_time
+
     def error_from_exception(self, exception: BaseException) -> None:
         self._error_type = type(exception).__name__
         self._error_message = str(exception)
@@ -154,14 +168,6 @@ class RemoteLogRecord:
             )
         )
 
-    @property
-    def log_retries(self) -> int:
-        return self._log_retries
-
-    @log_retries.setter
-    def log_retries(self, log_retries: int) -> None:
-        self._log_retries = log_retries
-
 
 @dataclass
 class SenderResponse:

qena_shared_lib/remotelogging/logstash/_base.py

@@ -6,6 +6,7 @@ from .._base import BaseRemoteLogSender, RemoteLogRecord
 class BaseLogstashSender(BaseRemoteLogSender):
     def remote_log_record_to_ecs(self, log: RemoteLogRecord) -> dict[str, Any]:
         log_dict: dict[str, Any] = {
+            "@timestamp": log.created_time.isoformat(),
             "message": log.message,
             "service.name": log.service_name,
             "log.level": log.log_level.name.lower(),

qena_shared_lib/sync.py

@@ -0,0 +1,91 @@
+from inspect import Traceback
+from typing import cast
+
+from redis.asyncio import Redis
+from redis.asyncio.lock import Lock
+from typing_extensions import Self
+
+from .redis import RedisDependent
+
+__all__ = [
+    "DistributedLockGuard",
+    "DistributedLockManager",
+]
+
+
+class DistributedLockGuard:
+    def __init__(
+        self,
+        distributed_lock_manager: "DistributedLockManager",
+        key: str,
+        blocking: bool = True,
+    ):
+        self._distributed_lock_manager = distributed_lock_manager
+        self._key = key
+        self._blocking = blocking
+        self._is_acquired = False
+
+    @property
+    def is_aquired(self) -> bool:
+        return self._is_acquired
+
+    async def __aenter__(self) -> Self:
+        if self._blocking:
+            await self._distributed_lock_manager.acquire(self._key)
+        else:
+            self._is_acquired = (
+                await self._distributed_lock_manager.try_acquire(self._key)
+            )
+
+        return self
+
+    async def __aexit__(
+        self,
+        exception_type: type[Exception],
+        exception: Exception,
+        traceback: Traceback,
+    ) -> None:
+        del exception_type, exception, traceback
+
+        await self._distributed_lock_manager.release(self._key)
+
+        self._is_acquired = False
+
+
+class DistributedLockManager(RedisDependent):
+    def __init__(self, lock_timeout: int = 30):
+        self._lock_timeout = lock_timeout
+        self._lockes: dict[str, Lock] = {}
+
+    def attach(self, redis_client: Redis) -> None:
+        self._redis_client = redis_client
+
+    async def acquire(self, key: str) -> None:
+        lock = self._register_lock(key)
+
+        await lock.acquire()
+
+    async def try_acquire(self, key: str) -> bool:
+        lock = self._register_lock(key=key, blocking=False)
+        is_acquired = await lock.acquire()
+
+        return cast(bool, is_acquired)
+
+    def _register_lock(self, key: str, blocking: bool = True) -> Lock:
+        if key not in self._lockes:
+            self._lockes[key] = self._redis_client.lock(
+                name=key, blocking=blocking, timeout=self._lock_timeout
+            )
+
+        return self._lockes[key]
+
+    async def release(self, key: str) -> None:
+        if key not in self._lockes or not await self._lockes[key].owned():
+            return
+
+        await self._lockes[key].release()
+
+    def __call__(self, key: str, blocking: bool = True) -> DistributedLockGuard:
+        return DistributedLockGuard(
+            distributed_lock_manager=self, key=key, blocking=blocking
+        )