Initial public release

hydra/resilience/circuit_breaker.py

@@ -0,0 +1,6 @@
+from pybreaker import CircuitBreaker
+
+
+def create_breaker(name: str, fail_max: int = 5, reset_timeout: int = 30) -> CircuitBreaker:
+    """거래소/API별 독립 서킷 브레이커 생성."""
+    return CircuitBreaker(fail_max=fail_max, reset_timeout=reset_timeout, name=name)

hydra/resilience/graceful.py

@@ -0,0 +1,35 @@
+import asyncio
+import signal
+
+from hydra.logging.setup import get_logger
+
+logger = get_logger(__name__)
+_SHUTDOWN_TIMEOUT = 30
+
+
+class GracefulManager:
+    def __init__(self, order_queue, position_tracker, redis_client):
+        self._order_queue = order_queue
+        self._positions = position_tracker
+        self._redis = redis_client
+        self._shutting_down = False
+
+    def register_signals(self) -> None:
+        """메인 이벤트 루프에서 호출. SIGTERM/SIGINT 핸들러 등록."""
+        loop = asyncio.get_event_loop()
+        for sig in (signal.SIGTERM, signal.SIGINT):
+            loop.add_signal_handler(sig, lambda s=sig: asyncio.create_task(self.shutdown(s.name)))
+
+    async def shutdown(self, reason: str = "unknown") -> None:
+        if self._shutting_down:
+            return
+        self._shutting_down = True
+        logger.info("graceful_shutdown_start", reason=reason)
+        try:
+            async with asyncio.timeout(_SHUTDOWN_TIMEOUT):
+                self._order_queue.block_new_orders()
+                snapshot = await self._positions.snapshot()
+                self._redis.set("hydra:last_snapshot", str(snapshot))
+                logger.info("graceful_shutdown_complete")
+        except TimeoutError:
+            logger.error("graceful_shutdown_timeout", seconds=_SHUTDOWN_TIMEOUT)

hydra/resilience/rate_limiter.py

@@ -0,0 +1,28 @@
+import asyncio
+import time
+
+
+class TokenBucketRateLimiter:
+    """거래소별 API 호출 제한. 우선순위: 0=주문, 1=시세, 2=조회."""
+
+    def __init__(self, rate: float, capacity: int):
+        self.rate = rate          # tokens/second
+        self.capacity = capacity
+        self._tokens = float(capacity)
+        self._last_refill = time.monotonic()
+        self._lock = asyncio.Lock()
+
+    async def acquire(self, priority: int = 2, tokens: int = 1) -> None:
+        async with self._lock:
+            self._refill()
+            while self._tokens < tokens:
+                wait = (tokens - self._tokens) / self.rate
+                await asyncio.sleep(wait)
+                self._refill()
+            self._tokens -= tokens
+
+    def _refill(self) -> None:
+        now = time.monotonic()
+        elapsed = now - self._last_refill
+        self._tokens = min(self.capacity, self._tokens + elapsed * self.rate)
+        self._last_refill = now

hydra/resilience/retry.py

@@ -0,0 +1,11 @@
+from functools import wraps
+from tenacity import retry, stop_after_attempt, wait_exponential_jitter
+
+
+def with_retry(func):
+    """지수 백오프 + 지터 재시도 데코레이터 (최대 3회)."""
+    return retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential_jitter(initial=1, max=10, jitter=2),
+        reraise=True,
+    )(func)