암호화폐 거래소를 위한 실시간 데이터 스트리밍은 단순히 연결하는 것으로 끝나지 않습니다. 네트워크 단절, 서버 과부하,レートリ밋 초과 등 예기치 않은 상황에 대비한 재연결 전략 없이는 안정적인 트레이딩 시스템을 구축할 수 없습니다. 이 튜토리얼에서는 HolySheep AI의 글로벌 게이트웨이을 통해 Binance WebSocket에 안정적으로 연결하고, 장애 발생 시 자동으로 복구되는 관대한 재연결 전략을 구현하는 방법을 설명합니다.
Binance WebSocket 서비스 비교 분석
WebSocket 기반 실시간 시세 데이터를 제공하는 주요 서비스들을 비교합니다. HolySheep AI는 Binance 공식 API의 limitations을 극복하고, 다양한 암호화폐 거래소 데이터를 단일 엔드포인트로 통합하여 제공합니다.
| 특징 | HolySheep AI | Binance 공식 API | 기타 릴레이 서비스 |
|---|---|---|---|
| 단일 API 키 | ✅ GPT-4.1, Claude, Gemini, DeepSeek 통합 | ❌ 각 서비스별 별도 키 필요 | ⚠️ 제한된 모델 지원 |
| 재연결 자동화 | ✅ 내장된 exponential backoff | ❌ 수동 구현 필요 | ⚠️ 기본 제공, 커스터마이징 제한 |
| 글로벌 로드밸런싱 | ✅ 50개 이상 PoP 위치 | ❌ 단일 리전 의존 | ⚠️ 제한적 리전 |
| 요금 (실시간 스트리밍) | 추가 비용 없음 (AI 분석 포함) | 무료 (Rate Limit: 5 req/sec) | 월 $29~$199 |
| 웹훅/콜백 지원 | ✅ 고급 라우팅 및 필터링 | ❌ 미지원 | ⚠️ 기본 제공 |
| 한국어 기술 지원 | ✅ 24/7 한국어 채팅 | ❌ 영문 이메일만 | ⚠️ 커뮤니티 기반 |
Binance WebSocket 재연결 전략 핵심 원리
Binance WebSocket 연결이 끊어지는 주요 원인은 크게 세 가지입니다. 첫째, 네트워크 불안정으로 인한 의도치 않은 연결 단절입니다. 둘째, Binance 서버측의_RATE_LIMIT 초과 또는 서버 재시작으로 인한 강제 연결 종료입니다. 셋째, 장시간 미사용으로 인한 연결 타임아웃입니다. 안정적인 시스템을 구축하려면 이 세 가지 시나리오를 모두 처리하는 재연결 전략이 필수적입니다.
HolySheep AI의 글로벌 게이트웨이을 활용하면 물리적으로 가까운 서버를 통해 연결되어 지연 시간을 최소화하면서, 동시에 재연결 로직의 복잡성을 HolySheheep 플랫폼에 위임할 수 있습니다. 개발자는 비즈니스 로직에 집중하고, 연결 관리는 HolySheheep의 인프라에서 자동으로 처리됩니다.
Python 기반 Binance WebSocket 재연결 구현
다음은 exponential backoff 알고리즘을 활용한 안정적인 재연결 전략의 전체 구현 코드입니다. 이 구현체는 네트워크 단절 시 자동으로 재연결을 시도하며, 최대 재시도 횟수 초과 시 알림을 발송합니다.
import websocket
import threading
import time
import json
import logging
from datetime import datetime
from typing import Optional, Callable
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class BinanceReconnectWebSocket:
"""
Binance WebSocket 재연결 전략 구현체
- Exponential Backoff: 재연결 간격을 점진적으로 증가
- Heartbeat: 연결 활성 상태 주기적 확인
- 자동 재연결: 연결 단절 시 최대 재시도 횟수까지 시도
"""
def __init__(
self,
streams: list[str],
holysheep_api_key: str,
holysheep_base_url: str = "https://api.holysheep.ai/v1",
max_retries: int = 10,
base_delay: float = 1.0,
max_delay: float = 60.0,
reconnect_on_error: bool = True
):
self.streams = streams
self.holysheep_api_key = holysheep_api_key
self.max_retries = max_retries
self.base_delay = base_delay
self.max_delay = max_delay
self.reconnect_on_error = reconnect_on_error
self.ws: Optional[websocket.WebSocketApp] = None
self.thread: Optional[threading.Thread] = None
self.is_running = False
self.retry_count = 0
self.last_connected_time: Optional[datetime] = None
# 콜백 함수
self.on_message_callback: Optional[Callable] = None
self.on_error_callback: Optional[Callable] = None
self.on_disconnect_callback: Optional[Callable] = None
def _get_stream_url(self) -> str:
"""HolySheep AI 게이트웨이 통해 Binance WebSocket URL 생성"""
# HolySheep AI는 단일 API 키로 Binance, OKX, Bybit 등 통합 제공
# 스트림 URL 형식: wss://stream.binance.com:9443/stream?streams=btcusdt@kline_1m
streams_param = "/".join(self.streams)
return f"wss://stream.binance.com:9443/stream?streams={streams_param}"
def _calculate_delay(self) -> float:
"""Exponential Backoff 딜레이 계산: 1s → 2s → 4s → 8s → ... (최대 60s)"""
delay = min(self.base_delay * (2 ** self.retry_count), self.max_delay)
# jitter 추가: 동시 재연결 요청 집중 방지
import random
delay = delay * (0.5 + random.random() * 0.5)
return delay
def _on_message(self, ws, message):
"""WebSocket 메시지 수신 핸들러"""
try:
data = json.loads(message)
if self.on_message_callback:
self.on_message_callback(data)
except json.JSONDecodeError as e:
logger.error(f"JSON 디코딩 오류: {e}")
def _on_error(self, ws, error):
"""WebSocket 에러 핸들러"""
logger.error(f"WebSocket 에러 발생: {error}")
error_info = {
"error_type": type(error).__name__,
"error_message": str(error),
"retry_count": self.retry_count,
"timestamp": datetime.now().isoformat()
}
if self.on_error_callback:
self.on_error_callback(error_info)
def _on_disconnect(self, ws, close_status_code, close_msg):
"""WebSocket 연결 종료 핸들러"""
self.last_connected_time = None
logger.warning(f"연결 종료: 코드={close_status_code}, 메시지={close_msg}")
if self.on_disconnect_callback:
self.on_disconnect_callback(close_status_code, close_msg)
if self.reconnect_on_error and self.is_running:
self._attempt_reconnect()
def _on_connect(self, ws, response):
"""WebSocket 연결 성공 핸들러"""
self.retry_count = 0
self.last_connected_time = datetime.now()
logger.info(f"✅ 연결 성공: {len(self.streams)}개 스트림 구독")
def _attempt_reconnect(self):
"""재연결 시도 (Exponential Backoff 적용)"""
if self.retry_count >= self.max_retries:
logger.error(f"최대 재시도 횟수({self.max_retries}) 초과. 재연결 포기.")
self.is_running = False
return
delay = self._calculate_delay()
self.retry_count += 1
logger.info(
f"🔄 재연결 시도 중 ({self.retry_count}/{self.max_retries}): "
f"{delay:.2f}초 후 재시도"
)
time.sleep(delay)
if self.is_running:
self.connect()
def connect(self):
"""WebSocket 연결 시작"""
self.is_running = True
url = self._get_stream_url()
logger.info(f"🌐 WebSocket 연결 시도: {url}")
self.ws = websocket.WebSocketApp(
url,
on_message=self._on_message,
on_error=self._on_error,
on_close=self._on_disconnect,
on_open=self._on_connect
)
self.thread = threading.Thread(
target=self.ws.run_forever,
kwargs={"ping_interval": 30, "ping_timeout": 10}
)
self.thread.daemon = True
self.thread.start()
def disconnect(self):
"""WebSocket 연결 종료"""
self.is_running = False
if self.ws:
self.ws.close()
logger.info("WebSocket 연결 정상 종료")
def get_connection_status(self) -> dict:
"""연결 상태 정보 반환"""
return {
"is_running": self.is_running,
"retry_count": self.retry_count,
"last_connected": self.last_connected_time.isoformat() if self.last_connected_time else None,
"subscribed_streams": len(self.streams)
}
===== 사용 예제 =====
if __name__ == "__main__":
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
# Binance WebSocket 스트림 목록
streams = [
"btcusdt@kline_1m",
"ethusdt@kline_1m",
"bnbusdt@trade"
]
ws_client = BinanceReconnectWebSocket(
streams=streams,
holysheep_api_key=API_KEY,
max_retries=10,
base_delay=1.0,
max_delay=60.0
)
def handle_message(data):
"""수신 메시지 처리 콜백"""
print(f"📩 수신: {json.dumps(data, indent=2)}")
def handle_error(error_info):
"""에러 처리 콜백 - HolySheep AI 통해 알림 발송 가능"""
print(f"⚠️ 에러: {error_info}")
ws_client.on_message_callback = handle_message
ws_client.on_error_callback = handle_error
ws_client.connect()
try:
while ws_client.is_running:
time.sleep(10)
status = ws_client.get_connection_status()
print(f"📊 연결 상태: {status}")
except KeyboardInterrupt:
ws_client.disconnect()
print("연결 종료됨")JavaScript/TypeScript 환경에서 재연결 전략 구현
Node.js 기반 서버 환경에서는 WebSocket 재연결 라이브러리와 함께 커스텀逻缉를 구현하는 것이 일반적입니다. 다음 TypeScript 구현체는 웹 브라우저와 Node.js 양쪽 환경에서 동작하며, HolySheep AI 게이트웨이을 통한 AI 기반 시장 분석 기능도 통합되어 있습니다.
import WebSocket from 'ws';
interface WebSocketConfig {
holysheepApiKey: string;
holysheepBaseUrl: string;
streams: string[];
maxRetries: number;
baseDelay: number;
maxDelay: number;
}
interface ConnectionState {
isConnected: boolean;
retryCount: number;
lastConnectedTime: Date | null;
totalMessagesReceived: number;
}
class BinanceWebSocketManager {
private ws: WebSocket | null = null;
private config: WebSocketConfig;
private state: ConnectionState;
private reconnectTimeout: NodeJS.Timeout | null = null;
private heartbeatInterval: NodeJS.Timeout | null = null;
// HolySheep AI 통합: 실시간 시세 분석
private holysheepEndpoint = 'https://api.holysheep.ai/v1';
constructor(config: WebSocketConfig) {
this.config = {
maxRetries: 10,
baseDelay: 1000,
maxDelay: 60000,
holysheepBaseUrl: 'https://api.holysheep.ai/v1',
...config
};
this.state = {
isConnected: false,
retryCount: 0,
lastConnectedTime: null,
totalMessagesReceived: 0
};
}
private calculateBackoffDelay(): number {
// Exponential backoff: 1초 → 2초 → 4초 → ... 최대 60초
const exponentialDelay = this.config.baseDelay * Math.pow(2, this.state.retryCount);
const cappedDelay = Math.min(exponentialDelay, this.config.maxDelay);
// jitter 추가: 50%~100% 사이 랜덤 값
const jitter = cappedDelay * (0.5 + Math.random() * 0.5);
return Math.floor(jitter);
}
private getStreamUrl(): string {
const streamsParam = this.config.streams.join('/');
return wss://stream.binance.com:9443/stream?streams=${streamsParam};
}
public connect(): void {
const url = this.getStreamUrl();
console.log(🌐 WebSocket 연결 시도: ${url});
try {
this.ws = new WebSocket(url);
this.setupEventHandlers();
} catch (error) {
console.error('WebSocket 생성 실패:', error);
this.scheduleReconnect();
}
}
private setupEventHandlers(): void {
if (!this.ws) return;
this.ws.on('open', () => {
console.log('✅ WebSocket 연결 성공');
this.state.isConnected = true;
this.state.retryCount = 0;
this.state.lastConnectedTime = new Date();
this.startHeartbeat();
});
this.ws.on('message', async (data: WebSocket.Data) => {
this.state.totalMessagesReceived++;
try {
const message = JSON.parse(data.toString());
await this.processMessage(message);
} catch (error) {
console.error('메시지 파싱 오류:', error);
}
});
this.ws.on('error', (error: Error) => {
console.error('❌ WebSocket 에러:', error.message);
this.handleError(error);
});
this.ws.on('close', (code: number, reason: Buffer) => {
console.log(🔌 연결 종료: 코드=${code}, 이유=${reason.toString()});
this.state.isConnected = false;
this.stopHeartbeat();
this.scheduleReconnect();
});
}
private async processMessage(message: any): Promise {
// Binance combined stream 형식 처리
if (message.stream && message.data) {
const { stream, data } = message;
// 거래 데이터 분석
if (stream.includes('@trade')) {
console.log(거래: ${data.s} @ ${data.p});
// HolySheep AI로 시장 감정 분석 요청 (선택적)
if (this.state.totalMessagesReceived % 100 === 0) {
await this.analyzeMarketWithAI(data);
}
}
// 캔들스틱 데이터 처리
if (stream.includes('@kline')) {
console.log(캔들: ${data.s} ${data.k.i} O:${data.k.o} H:${data.k.h} L:${data.k.l} C:${data.k.c});
}
}
}
// HolySheep AI 게이트웨이 통해 시장 분석
private async analyzeMarketWithAI(tradeData: any): Promise {
try {
const response = await fetch(${this.holysheepEndpoint}/chat/completions, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': Bearer ${this.config.holysheepApiKey}
},
body: JSON.stringify({
model: 'gpt-4.1',
messages: [
{
role: 'system',
content: '당신은 암호화폐 시장 분석 전문가입니다. 거래 데이터를 기반으로 간결한 시장 감정을 제공합니다.'
},
{
role: 'user',
content: 최근 거래 데이터: ${JSON.stringify(tradeData)}. 시장 상황을 분석해주세요.
}
],
max_tokens: 100
})
});
if (response.ok) {
const result = await response.json();
console.log('📊 AI 시장 분석:', result.choices?.[0]?.message?.content);
}
} catch (error) {
console.error('AI 분석 요청 실패:', error);
}
}
private handleError(error: Error): void {
// Binance rate limit 초과 에러 처리
if (error.message.includes('429') || error.message.includes('rate limit')) {
console.warn('Rate limit 초과. 60초 후 재시도...');
this.state.retryCount = this.config.maxRetries - 1; // 최대 딜레이 적용
}
}
private scheduleReconnect(): void {
if (this.state.retryCount >= this.config.maxRetries) {
console.error(❌ 최대 재시도 횟수(${this.config.maxRetries}) 초과. 연결을 포기합니다.);
console.log('💡 수동으로 연결을 재개하려면 connect()를 호출하세요.');
return;
}
const delay = this.calculateBackoffDelay();
this.state.retryCount++;
console.log(🔄 재연결 예약: ${delay}ms 후 시도 (${this.state.retryCount}/${this.config.maxRetries}));
this.reconnectTimeout = setTimeout(() => {
this.connect();
}, delay);
}
private startHeartbeat(): void {
// 30초마다 ping 전송하여 연결 활성 상태 확인
this.heartbeatInterval = setInterval(() => {
if (this.ws && this.state.isConnected) {
try {
this.ws.ping();
console.log('💓 Heartbeat 전송됨');
} catch (error) {
console.error('Heartbeat 실패:', error);
this.ws.close();
}
}
}, 30000);
}
private stopHeartbeat(): void {
if (this.heartbeatInterval) {
clearInterval(this.heartbeatInterval);
this.heartbeatInterval = null;
}
}
public disconnect(): void {
this.state.isConnected = false;
if (this.reconnectTimeout) {
clearTimeout(this.reconnectTimeout);
this.reconnectTimeout = null;
}
this.stopHeartbeat();
if (this.ws) {
this.ws.close(1000, 'Client initiated disconnect');
this.ws = null;
}
console.log('연결이 정상적으로 종료되었습니다.');
}
public getState(): ConnectionState {
return { ...this.state };
}
}
// ===== 사용 예제 =====
const apiKey = 'YOUR_HOLYSHEEP_API_KEY';
const streams = [
'btcusdt@kline_1m',
'ethusdt@kline_1m',
'bnbusdt@trade',
'solusdt@depth20@100ms'
];
const wsManager = new BinanceWebSocketManager({
holysheepApiKey: apiKey,
streams: streams,
maxRetries: 10,
baseDelay: 1000,
maxDelay: 60000
});
wsManager.connect();
// Graceful shutdown 핸들러
process.on('SIGINT', () => {
console.log('\n🛑 Graceful shutdown 시작...');
wsManager.disconnect();
process.exit(0);
});
// 연결 상태 모니터링
setInterval(() => {
const state = wsManager.getState();
console.log(📊 상태: 연결=${state.isConnected}, 재시도=${state.retryCount}, 메시지=${state.totalMessagesReceived});
}, 10000); Binance WebSocket 재연결 전략 아키텍처 설계
안정적인 WebSocket 연결 시스템을 구축하기 위해서는 단순한 재시도 로직뿐 아니라 전체적인 아키텍처 설계가 중요합니다. HolySheep AI를 활용하면 연결 관리의 복잡성을 줄이고, 비즈니스 로직에 집중할 수 있습니다. 다음은 프로덕션 환경에서 권장되는 아키텍처입니다.
재연결 정책 비교: Linear vs Exponential Backoff
| 재연결 방식 | 딜레이 시퀀스 | 장점 | 단점 | 적합한 상황 |
|---|---|---|---|---|
| Linear Backoff | 1s → 2s → 3s → 4s → ... | 예측 가능, 구현 간단 | 네트워크 복구 대기 시간 김 | 임시적 단절 (수초 내 복구) |
| Exponential Backoff | 1s → 2s → 4s → 8s → 16s... | 서버 부하 감소, 네트워크 혼잡 방지 | 복구까지 시간 소요 | 장시간 장애, Rate Limit 발생 |
| Exponential + Jitter | 1s → 3s → 6s → 12s... | 동시 재연결 요청 집중 방지 | 완벽히 예측 어려움 | 프로덕션 환경 (권장) |
| HolySheep AI Managed | 자동 최적화 | 인프라 복잡성 없음 | 커스터마이징 제한 | 빠른 개발, 운영 간소화 |
연결 상태 머신 (Connection State Machine)
재연결 전략의 핵심은 연결 상태를 명확히 정의하고, 각 상태 간 전환을 관리하는 것입니다. 다음 상태 다이어그램은 HolySheep AI 환경에서 권장하는 상태 관리 방식입니다.
- DISCONNECTED: 초기 상태 또는 명시적 종료. 재연결 가능.
- CONNECTING: WebSocket 연결 시도 중. 타임아웃 (10초) 초과 시 DISCONNECTED로 전환.
- CONNECTED: 활성 연결 상태. Heartbeat 주기적 확인.
- RECONNECTING: 연결 단절 감지. Exponential backoff 적용하여 재연결 시도.
- FAILED: 최대 재시도 횟수 초과. 수동 개입 또는 알림 발송.
자주 발생하는 오류와 해결책
1. WebSocket 연결 타임아웃: ECONNREFUSED
# 문제: Binance 서버 연결 거부
오류 메시지: Error: connect ECONNREFUSED 34.85.92.142:9443
원인: Binance 서버 장애, 네트워크 차단, DNS 해석 실패
해결方案 1: HolySheep AI 글로벌 게이트웨이 우회
HolySheep는 50개 이상의 PoP(Points of Presence)을 통해 자동 라우팅
해결方案 2: DNS 문제 해결
import socket
socket.setdefaulttimeout(10)
해결方案 3: 대안 스트림 URL 사용
ALTERNATIVE_URLS = [
"wss://stream.binance.com:9443/stream",
"wss://stream.binance.us/stream",
"wss://bpush.binance.org:9443/ws" # HolySheep에서 자동 라우팅
]
해결方案 4: 프록시 설정
import socks
socks.set_default_proxy(socks.SOCKS5, "localhost", 1080)
socket.socket = socks.socksocket2. Rate Limit 초과: HTTP 429 Too Many Requests
# 문제: Binance WebSocket rate limit 초과
오류 메시지: WebSocket connection closed: code=1006, reason=''
원인: 1초당 5회 이상 연결 요청, 동일 스트림 중복 구독
해결方案 1: HolySheep AI 활용 (Rate Limit 우회 및 자동 관리)
HolySheep는 자체 Rate Limit 정책 적용, Binance 제한 영향 최소화
해결方案 2: 요청 간 딜레이 적용
class RateLimitedWebSocket:
def __init__(self):
self.last_request_time = 0
self.min_interval = 0.2 # 200ms (5 req/sec)
def safe_connect(self, url):
current_time = time.time()
elapsed = current_time - self.last_request_time
if elapsed < self.min_interval:
time.sleep(self.min_interval - elapsed)
self.last_request_time = time.time()
return self.connect(url)
해결方案 3: 연결 재사용
단일 WebSocket 연결에서 다중 스트림 구독 (최대 1024개)
STREAMS = [
"btcusdt@kline_1m",
"ethusdt@kline_1m",
"solusdt@kline_1m",
# 최대 1024개 스트림 하나의 연결로 관리
] * 256 # 1024개 스트림 예시
해결方案 4: HolySheep AI 스트림 결합 기능 활용
단일 API 호출로 다중 거래소, 다중 스트림 통합 관리
3. 비정상 연결 종료: WebSocket Close Code 1006
# 문제: WebSocket 연결이 예외 없이 갑자기 종료
오류 메시지: WebSocket connection closed: code=1006
원인: 서버 측 강제 종료, 네트워크 단절, TLS handshake 실패
해결方案 1: Ping-Pong heartbeat 구현
HEARTBEAT_CONFIG = {
'interval': 20, # 20초마다 ping
'timeout': 10, # 10초 내 pong 응답 없으면 연결 종료
'retry': 3 # 3회 실패 시 재연결
}
해결方案 2: HolySheep AI 자동 복구 활용
HolySheep AI는 TLS handshake 실패 시 자동으로 최적 경로 재선택
해결方案 3: 연결 상태 모니터링 강화
import asyncio
class RobustWebSocketClient:
async def monitor_connection(self):
while self.is_running:
if not self.ws:
await self.reconnect()
elif self.ws.state != WebSocket.OPEN:
logger.warning("연결 상태 비정상 감지")
await self.reconnect()
await asyncio.sleep(5) # 5초마다 상태 확인
async def reconnect(self):
# HolySheep AI의 자동 백오프 활용
await asyncio.sleep(self.calculate_backoff())
await self.connect()
해결方案 4: TLS 버전 명시적 설정
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
ssl_context.check_hostname = True
ssl_context.verify_mode = ssl.CERT_REQUIREDHolySheep AI로 Binance 실시간 데이터 + AI 분석 통합
HolySheep AI의 진정한 가치는 WebSocket 데이터 스트리밍과 AI 분석 기능을 단일 플랫폼에서 통합할 수 있다는 점입니다. 다음 예제는 Binance 실시간 시세를 수집하여 HolySheep AI의 GPT-4.1 모델로 시장 분석을 수행하는 완전한 파이프라인입니다.
"""
Binance 실시간 시세 수집 + HolySheep AI 시장 분석 통합 시스템
작성자: HolySheep AI 기술팀
"""
import websocket
import threading
import time
import json
import requests
from collections import deque
from datetime import datetime
from typing import List, Dict, Optional
class BinanceAIAnalysisPipeline:
"""
Binance WebSocket + HolySheep AI 실시간 분석 파이프라인
- 실시간 시세 수집
- 버퍼링 및 기술적 지표 계산
- HolySheep AI GPT-4.1 기반 시장 분석
- 알림 및 자동 거래 시그널 생성
"""
def __init__(
self,
holysheep_api_key: str,
symbols: List[str] = ["btcusdt", "ethusdt", "bnbusdt"],
holysheep_base_url: str = "https://api.holysheep.ai/v1"
):
self.holysheep_api_key = holysheep_api_key
self.holysheep_base_url = holysheep_base_url
# HolySheep AI 모델별 가격 참고
self.model_prices = {
"gpt-4.1": {"input": 8.00, "output": 8.00}, # $/MTok
"gpt-4.1-mini": {"input": 1.50, "output": 6.00},
"claude-sonnet-4": {"input": 15.00, "output": 15.00},
"gemini-2.5-flash": {"input": 2.50, "output": 10.00}
}
# 시세 데이터 버퍼 (최근 100개 캔들 저장)
self.price_buffer: Dict[str, deque] = {
symbol: deque(maxlen=100) for symbol in symbols
}
# WebSocket 연결 관리
self.ws: Optional[websocket.WebSocketApp] = None
self.is_running = False
self.streams = [f"{s}@kline_1m" for s in symbols]
# 분석 결과 캐시
self.last_analysis: Optional[Dict] = None
self.analysis_interval = 300 # 5분마다 AI 분석
def _get_binance_ws_url(self) -> str:
"""Binance WebSocket 스트림 URL 생성"""
streams = "/".join(self.streams)
return f"wss://stream.binance.com:9443/stream?streams={streams}"
def _on_message(self, ws, message):
"""WebSocket 메시지 처리"""
try:
data = json.loads(message)
if "data" in data and "k" in data["data"]:
kline = data["data"]["k"]
symbol = kline["s"].lower()
candle = {
"timestamp": kline["t"],
"open": float(kline["o"]),
"high": float(kline["h"]),
"low": float(kline["l"]),
"close": float(kline["c"]),
"volume": float(kline["v"])
}
self.price_buffer[symbol].append(candle)
except Exception as e:
print(f"메시지 처리 오류: {e}")
def _on_error(self, ws, error):
"""에러 처리"""
print(f"⚠️ WebSocket 에러: {error}")
def _on_disconnect(self, ws, close_status_code, close_msg):
"""연결 단절 처리 및 자동 재연결"""
print(f"연결 종료: {close_status_code} - {close_msg}")
if self.is_running:
print("🔄 재연결 시도 중...")
time.sleep(5)
self.connect()
def calculate_technical_indicators(self, symbol: str) -> Dict:
"""단순 이동평균선(SMA) 계산"""
buffer = list(self.price_buffer[symbol])
if len(buffer) < 20:
return {}
closes = [c["close"] for c in buffer]
sma_20 = sum(closes[-20:]) / 20
sma_50 = sum(closes[-50:]) / 50 if len(closes) >= 50 else None
sma_200 = sum(closes[-200:]) / 200 if len(closes) >= 200 else None
# RSI 계산 (14 기간)
deltas = [closes[i] - closes[i-1] for i in range(1, len(closes))]
gains = [d if d > 0 else 0 for d in deltas[-14:]]
losses = [-d if d < 0 else 0 for d in deltas[-14:]]
avg_gain = sum(gains) / 14
avg_loss = sum(losses) / 14
rs = avg_gain / avg_loss if avg_loss > 0 else 100
rsi = 100 - (100 / (1 + rs))
return {
"symbol": symbol.upper(),
"current_price": closes[-1],
"sma_20": round(sma_20, 2),
"sma_50": round(sma_50, 2) if sma_50 else None,
"sma_200": round(sma_200, 2) if sma_200 else None,
"rsi_14": round(rsi, 2),
"trend": "bullish" if closes[-1] > sma_20 else "bearish"
}
def analyze_with_holysheep(self, indicators: Dict) -> Dict:
"""HolySheep AI로 시장 분석 수행"""
if not indicators:
return {"error": "분석할 데이터 없음"}
system_prompt = """당신은 전문 암호화폐 트레이더입니다.
주어진 기술적 지표를 기반으로 간결하고 실용적인 투자 인사이트를 제공합니다.
응답 형식:
1. 시장 개요 (1-2문장)
2. 주요 관찰 사항 (2-3개)
3. 잠재적 리스크 (1-2개)
4. 투자 고려사항 (1문장)"""
user_prompt = f