DNS 순간 장애가 WebSocket을 종일 죽인 이유: 자동 복구 경로가 없었다

{
  "tradable": false,
  "tradable_reason": "kis_ws_disabled",
  "kis_ws_disabled_reason": "reconnect_failed",
  "kis_ws_reconnect_failures": 5
}

# KISExecutionWebSocketClient._run_loop (수정 전)
async def _run_loop(self) -> None:
    while self._running:
        try:
            await self._connect_and_receive()
        except Exception as exc:
            self._reconnect_failures += 1
            if self._reconnect_failures >= self._max_reconnect_failures:
                self._running = False                              # 루프 종료
                self._disabled_reason = "reconnect_failed"        # 영구 차단 플래그
                logger.error("kis_exec_ws_disabled", ...)
                return                                            # 태스크 종료
            await asyncio.sleep(self._backoff_seconds())

# system.py
kis_ws_disabled = (status["kis_ws_disabled_reason"] is not None)
# disabled_reason이 None이 아닌 한 tradable=false

# KISExecutionWebSocketClient._run_loop (수정 후)
async def _run_loop(self) -> None:
    fast_failures = 0
    slow_retries = 0

    while True:  # 루프를 외부에서 종료하지 않는 한 계속
        try:
            await self._connect_and_receive()
            # 성공 시 카운터 리셋
            fast_failures = 0
            slow_retries = 0
            self._reconnect_failures = 0
            self._disabled_reason = None  # 게이팅 해제
        except Exception as exc:
            fast_failures += 1
            self._reconnect_failures += 1

            if fast_failures < self._max_fast_failures:
                # 빠른 backoff 구간
                delay = self._fast_backoff_seconds(fast_failures)
                self._disabled_reason = "reconnect_retrying"
            else:
                # 느린 backoff 구간 (무한)
                slow_retries += 1
                delay = self._slow_backoff_seconds(slow_retries)
                self._disabled_reason = "reconnect_retrying"

                if slow_retries > 3:
                    logger.critical("kis_exec_ws_retry_critical",
                                    slow_retries=slow_retries)

            logger.warning("kis_exec_ws_reconnecting",
                           failures=self._reconnect_failures,
                           delay=delay)
            await asyncio.sleep(delay)

# tests/test_kis_websocket_lifecycle.py

@pytest.mark.asyncio
async def test_repeated_reconnect_failure_enters_slow_retry():
    """max_fast_failures 소진 후 느린 재시도로 전환되고 disabled가 되지 않는지 검증."""
    client = KISExecutionWebSocketClient(max_fast_failures=5)
    
    fail_count = 0
    async def always_fail():
        nonlocal fail_count
        fail_count += 1
        raise ConnectionError("DNS failure")
    
    client._connect_and_receive = always_fail
    task = asyncio.create_task(client._run_loop())
    
    # 5회 실패 후에도 태스크가 살아 있어야 한다
    await asyncio.sleep(0.5)
    assert not task.done(), "5회 실패 후 태스크가 종료되었다 — 영구 차단 버그"
    assert client._disabled_reason == "reconnect_retrying"  # 차단이 아닌 재시도 중
    task.cancel()


@pytest.mark.asyncio
async def test_reconnect_success_after_slow_retry_recovers_tradable_gate():
    """느린 재시도 성공 시 disabled_reason이 None이 되는지(게이팅 해제) 검증."""
    client = KISExecutionWebSocketClient(max_fast_failures=2)
    
    call_count = 0
    async def fail_then_succeed():
        nonlocal call_count
        call_count += 1
        if call_count <= 3:
            raise ConnectionError("DNS failure")
        # 4번째 호출부터 성공 (무한 루프 방지: 즉시 리턴)
        return
    
    client._connect_and_receive = fail_then_succeed
    await asyncio.wait_for(client._run_loop(), timeout=5)
    
    assert client._disabled_reason is None, "재연결 성공 후 disabled_reason이 남아 있다"
    assert client._reconnect_failures == 0

# 매매 가능 여부 확인
curl -H "Authorization: Bearer $TOKEN" \
  https://your-service/api/v1/system/status | jq '.tradable, .tradable_reason'

# WebSocket 상태 확인
curl ... | jq '.kis_ws_disabled_reason, .kis_ws_reconnect_failures'