Hệ Thống Giám Sát và Báo Cáo cho Bot Giao Dịch

Trong bài viết này, chúng ta sẽ tìm hiểu cách xây dựng hệ thống giám sát và báo cáo hiệu quả cho bot giao dịch tự động.

Thu thập dữ liệu

1. Metrics cơ bản

class MetricsCollector:
    def __init__(self):
        self.metrics = {
            'trading': {},
            'system': {},
            'performance': {}
        }
    
    def collect_trading_metrics(self):
        # Thu thập metrics giao dịch
        self.metrics['trading'].update({
            'open_positions': self.get_open_positions(),
            'daily_pnl': self.calculate_daily_pnl(),
            'win_rate': self.calculate_win_rate()
        })
    
    def collect_system_metrics(self):
        # Thu thập metrics hệ thống
        self.metrics['system'].update({
            'cpu_usage': psutil.cpu_percent(),
            'memory_usage': psutil.virtual_memory().percent,
            'disk_usage': psutil.disk_usage('/').percent
        })

2. Logging

import logging
from logging.handlers import RotatingFileHandler

class LogManager:
    def __init__(self, log_file='trading_bot.log'):
        self.logger = logging.getLogger('TradingBot')
        self.logger.setLevel(logging.INFO)
        
        # File handler
        file_handler = RotatingFileHandler(
            log_file,
            maxBytes=10*1024*1024,  # 10MB
            backupCount=5
        )
        
        # Format
        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
        file_handler.setFormatter(formatter)
        
        self.logger.addHandler(file_handler)

Giám sát thời gian thực

1. Dashboard

import dash
from dash import dcc, html
import plotly.graph_objs as go

class TradingDashboard:
    def __init__(self):
        self.app = dash.Dash(__name__)
        
        self.app.layout = html.Div([
            html.H1('Trading Bot Dashboard'),
            
            # PnL Chart
            dcc.Graph(id='pnl-chart'),
            
            # System Metrics
            dcc.Graph(id='system-metrics'),
            
            # Trading Metrics
            dcc.Graph(id='trading-metrics'),
            
            # Auto-refresh
            dcc.Interval(
                id='interval-component',
                interval=60*1000,  # 60 seconds
                n_intervals=0
            )
        ])
    
    def update_charts(self):
        # Cập nhật biểu đồ
        self.app.callback(
            [Output('pnl-chart', 'figure'),
             Output('system-metrics', 'figure'),
             Output('trading-metrics', 'figure')],
            [Input('interval-component', 'n_intervals')]
        )(self._update_charts)

2. Alerting

class AlertSystem:
    def __init__(self):
        self.alert_levels = {
            'info': 0,
            'warning': 1,
            'error': 2,
            'critical': 3
        }
        self.alert_channels = {
            'email': self.send_email_alert,
            'telegram': self.send_telegram_alert,
            'slack': self.send_slack_alert
        }
    
    def check_alerts(self, metrics):
        # Kiểm tra các ngưỡng
        for metric, value in metrics.items():
            if self.is_threshold_breached(metric, value):
                self.trigger_alert(metric, value)
    
    def trigger_alert(self, metric, value):
        # Gửi cảnh báo qua các kênh
        alert_message = self.format_alert_message(metric, value)
        for channel, send_func in self.alert_channels.items():
            send_func(alert_message)

Báo cáo

1. Báo cáo định kỳ

class ReportGenerator:
    def __init__(self):
        self.template = self.load_template()
    
    def generate_daily_report(self):
        # Thu thập dữ liệu
        trading_data = self.collect_trading_data()
        performance_data = self.collect_performance_data()
        
        # Tạo báo cáo
        report = {
            'date': datetime.now().strftime('%Y-%m-%d'),
            'trading_summary': self.summarize_trading(trading_data),
            'performance_metrics': self.calculate_metrics(performance_data),
            'charts': self.generate_charts(trading_data)
        }
        
        return report

2. Phân tích hiệu suất

class PerformanceAnalyzer:
    def analyze_performance(self, data):
        # Tính toán các chỉ số
        metrics = {
            'total_return': self.calculate_total_return(data),
            'sharpe_ratio': self.calculate_sharpe_ratio(data),
            'max_drawdown': self.calculate_max_drawdown(data),
            'win_rate': self.calculate_win_rate(data)
        }
        
        # Phân tích rủi ro
        risk_metrics = {
            'var': self.calculate_var(data),
            'expected_shortfall': self.calculate_expected_shortfall(data),
            'beta': self.calculate_beta(data)
        }
        
        return {**metrics, **risk_metrics}

Lưu trữ dữ liệu

1. Database

class DatabaseManager:
    def __init__(self, db_url):
        self.engine = create_engine(db_url)
        self.Session = sessionmaker(bind=self.engine)
    
    def store_metrics(self, metrics):
        session = self.Session()
        try:
            metric_record = MetricsRecord(
                timestamp=datetime.now(),
                metrics=metrics
            )
            session.add(metric_record)
            session.commit()
        finally:
            session.close()
    
    def query_metrics(self, start_date, end_date):
        session = self.Session()
        try:
            return session.query(MetricsRecord)\
                .filter(MetricsRecord.timestamp.between(start_date, end_date))\
                .all()
        finally:
            session.close()

Best Practices

1. Thu thập đầy đủ metrics cần thiết
2. Thiết lập ngưỡng cảnh báo phù hợp
3. Tự động hóa quá trình báo cáo
4. Lưu trữ dữ liệu có cấu trúc
5. Bảo mật thông tin nhạy cảm

Kết luận

Hệ thống giám sát và báo cáo là thành phần quan trọng trong việc vận hành bot giao dịch. Trong bài viết tiếp theo, chúng ta sẽ tìm hiểu về cách xây dựng hệ thống quản lý rủi ro cho bot giao dịch.