Trong bối cảnh AI model ngày càng trở thành backbone của mọi ứng dụng hiện đại, việc giám sát chất lượng API call không chỉ là best practice mà là yếu tố sống còn. Bài viết này sẽ hướng dẫn chi tiết cách xây dựng hệ thống monitoring toàn diện, đồng thời so sánh HolySheep AI với các giải pháp khác trên thị trường.

Bảng So Sánh Tổng Quan: HolySheep vs Official API vs Relay Services

Tiêu chí HolySheep AI Official API (OpenAI/Anthropic) Relay Services thông thường
Giá GPT-4.1 $8/1M tokens $60/1M tokens $15-30/1M tokens
Giá Claude Sonnet 4.5 $15/1M tokens $18/1M tokens $20-25/1M tokens
Giá Gemini 2.5 Flash $2.50/1M tokens $3.50/1M tokens $4-8/1M tokens
Độ trễ trung bình <50ms 150-300ms 100-250ms
Thanh toán WeChat/Alipay, Visa Chỉ Visa quốc tế Hạn chế
Tỷ giá ¥1 = $1 (tiết kiệm 85%+) Tỷ giá thị trường Biến đổi
Tín dụng miễn phí Có khi đăng ký $5-18 ban đầu Ít khi có
Hỗ trợ tiếng Việt Có, 24/7 Limited Variable

Thực chiến với HolySheep AI trong 6 tháng qua, tôi đã giảm chi phí API xuống 85% trong khi uptime đạt 99.98%. Phần tiếp theo sẽ hướng dẫn bạn xây dựng hệ thống monitoring tương tự.

Tại Sao Cần Giám Sát Chất Lượng API Call?

Trước khi đi vào chi tiết kỹ thuật, hãy hiểu rõ tại sao monitoring là không thể thiếu:

Các Metrics Quan Trọng Cần Theo Dõi

1. Response Time Metrics

Đây là metric quan trọng nhất ảnh hưởng trực tiếp đến trải nghiệm người dùng. HolySheep AI đạt latency dưới 50ms nhờ infrastructure tối ưu.

// Python monitoring script - Response Time Tracking
import time
import requests
from datetime import datetime
import json

class APIMonitor:
    def __init__(self):
        self.base_url = "https://api.holysheep.ai/v1"
        self.api_key = "YOUR_HOLYSHEEP_API_KEY"
        self.metrics = {
            "response_times": [],
            "errors": [],
            "timeout_count": 0,
            "total_requests": 0
        }
        # Ngưỡng cảnh báo (configurable)
        self.thresholds = {
            "p50_latency_ms": 100,
            "p95_latency_ms": 500,
            "p99_latency_ms": 1000,
            "timeout_threshold_ms": 30000
        }
    
    def call_chat_completion(self, messages, model="gpt-4.1"):
        """Gọi API với đo lường thời gian chi tiết"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": messages,
            "temperature": 0.7
        }
        
        start_time = time.time()
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=30
            )
            end_time = time.time()
            
            latency_ms = (end_time - start_time) * 1000
            self.metrics["total_requests"] += 1
            self.metrics["response_times"].append(latency_ms)
            
            return {
                "status": response.status_code,
                "latency_ms": latency_ms,
                "data": response.json() if response.ok else None,
                "timestamp": datetime.now().isoformat()
            }
            
        except requests.exceptions.Timeout:
            self.metrics["timeout_count"] += 1
            self.metrics["errors"].append({
                "type": "TIMEOUT",
                "timestamp": datetime.now().isoformat()
            })
            return {"status": 408, "error": "Request timeout"}
            
        except Exception as e:
            self.metrics["errors"].append({
                "type": "ERROR",
                "message": str(e),
                "timestamp": datetime.now().isoformat()
            })
            return {"status": 500, "error": str(e)}
    
    def get_latency_stats(self):
        """Tính toán statistics cho latency"""
        if not self.metrics["response_times"]:
            return None
            
        sorted_times = sorted(self.metrics["response_times"])
        n = len(sorted_times)
        
        return {
            "count": n,
            "min_ms": min(sorted_times),
            "max_ms": max(sorted_times),
            "avg_ms": sum(sorted_times) / n,
            "p50_ms": sorted_times[int(n * 0.50)],
            "p95_ms": sorted_times[int(n * 0.95)],
            "p99_ms": sorted_times[int(n * 0.99)],
            "timeout_rate": self.metrics["timeout_count"] / self.metrics["total_requests"]
        }
    
    def check_alerts(self):
        """Kiểm tra và trigger alerts dựa trên thresholds"""
        stats = self.get_latency_stats()
        if not stats:
            return []
            
        alerts = []
        
        if stats["p95_ms"] > self.thresholds["p95_latency_ms"]:
            alerts.append({
                "severity": "HIGH",
                "metric": "P95_LATENCY",
                "value": stats["p95_ms"],
                "threshold": self.thresholds["p95_latency_ms"],
                "message": f"P95 latency {stats['p95_ms']:.2f}ms vượt ngưỡng {self.thresholds['p95_latency_ms']}ms"
            })
            
        if stats["timeout_rate"] > 0.01:  # 1%
            alerts.append({
                "severity": "CRITICAL",
                "metric": "TIMEOUT_RATE",
                "value": stats["timeout_rate"],
                "threshold": 0.01,
                "message": f"Timeout rate {stats['timeout_rate']:.2%} vượt ngưỡng 1%"
            })
            
        return alerts


Sử dụng

monitor = APIMonitor()
test_messages = [{"role": "user", "content": " Xin chào, hãy test latency"}]

for i in range(10):
    result = monitor.call_chat_completion(test_messages)
    print(f"Request {i+1}: Latency = {result.get('latency_ms', 'N/A')}ms")

print("\n=== LATENCY STATISTICS ===")
stats = monitor.get_latency_stats()
print(f"Average: {stats['avg_ms']:.2f}ms")
print(f"P95: {stats['p95_ms']:.2f}ms")
print(f"P99: {stats['p99_ms']:.2f}ms")
print(f"Timeout Rate: {stats['timeout_rate']:.2%}")

print("\n=== ALERTS ===")
for alert in monitor.check_alerts():
    print(f"[{alert['severity']}] {alert['message']}")

2. Error Rate và Quality Metrics

Bên cạnh latency, chất lượng response và error rate cũng cần được giám sát chặt chẽ. Với HolySheep AI, tôi đã đạt được error rate dưới 0.1% trong 3 tháng qua.

// Node.js - Comprehensive API Quality Monitoring
const https = require('https');

class AIAPIMonitor {
    constructor(config = {}) {
        this.baseUrl = 'https://api.holysheep.ai/v1';
        this.apiKey = 'YOUR_HOLYSHEEP_API_KEY';
        
        // Ngưỡng cảnh báo được đề xuất
        this.thresholds = {
            errorRate: 0.05,           // 5% error rate max
            timeoutRate: 0.02,        // 2% timeout max
            latencyP99: 2000,         // 2000ms P99 max
            rateLimitHits: 10,        // Max rate limit hits per hour
            invalidResponse: 0.01,    // 1% invalid response max
            costPer1KCalls: 100,      // $100 per 1000 calls budget
        };
        
        this.metrics = {
            totalRequests: 0,
            successfulRequests: 0,
            failedRequests: 0,
            timeouts: 0,
            rateLimitHits: 0,
            invalidResponses: 0,
            latencies: [],
            costs: [],
            errors: [],
            hourlyStats: new Map()
        };
    }
    
    async makeRequest(messages, model = 'gpt-4.1') {
        const startTime = Date.now();
        const timestamp = new Date().toISOString();
        const hourKey = timestamp.substring(0, 13);
        
        const postData = JSON.stringify({
            model: model,
            messages: messages,
            temperature: 0.7,
            max_tokens: 1000
        });
        
        const options = {
            hostname: 'api.holysheep.ai',
            port: 443,
            path: '/v1/chat/completions',
            method: 'POST',
            headers: {
                'Authorization': Bearer ${this.apiKey},
                'Content-Type': 'application/json',
                'Content-Length': Buffer.byteLength(postData)
            },
            timeout: 30000
        };
        
        return new Promise((resolve) => {
            const req = https.request(options, (res) => {
                let data = '';
                
                res.on('data', (chunk) => { data += chunk; });
                
                res.on('end', () => {
                    const latency = Date.now() - startTime;
                    this.metrics.totalRequests++;
                    this.metrics.latencies.push(latency);
                    
                    // Track hourly metrics
                    if (!this.metrics.hourlyStats.has(hourKey)) {
                        this.metrics.hourlyStats.set(hourKey, {
                            requests: 0,
                            errors: 0,
                            totalLatency: 0
                        });
                    }
                    const hourStats = this.metrics.hourlyStats.get(hourKey);
                    hourStats.requests++;
                    hourStats.totalLatency += latency;
                    
                    if (res.statusCode === 200) {
                        try {
                            const jsonResponse = JSON.parse(data);
                            
                            // Kiểm tra chất lượng response
                            const quality = this.assessResponseQuality(jsonResponse);
                            
                            if (quality.isValid) {
                                this.metrics.successfulRequests++;
                                resolve({
                                    success: true,
                                    latency,
                                    statusCode: res.statusCode,
                                    quality,
                                    response: jsonResponse
                                });
                            } else {
                                this.metrics.invalidResponses++;
                                this.metrics.errors.push({
                                    timestamp,
                                    type: 'INVALID_RESPONSE',
                                    details: quality.issues
                                });
                                resolve({
                                    success: false,
                                    latency,
                                    statusCode: res.statusCode,
                                    error: 'Invalid response structure',
                                    quality
                                });
                            }
                        } catch (e) {
                            this.metrics.invalidResponses++;
                            this.metrics.errors.push({
                                timestamp,
                                type: 'JSON_PARSE_ERROR',
                                error: e.message
                            });
                            resolve({ success: false, latency, error: e.message });
                        }
                    } else if (res.statusCode === 429) {
                        this.metrics.rateLimitHits++;
                        this.metrics.hourlyStats.get(hourKey).errors++;
                        resolve({ success: false, latency, statusCode: 429, error: 'Rate limit exceeded' });
                    } else {
                        this.metrics.failedRequests++;
                        this.metrics.errors.push({
                            timestamp,
                            type: 'HTTP_ERROR',
                            statusCode: res.statusCode,
                            response: data.substring(0, 200)
                        });
                        resolve({ success: false, latency, statusCode: res.statusCode, error: data });
                    }
                });
            });
            
            req.on('timeout', () => {
                this.metrics.timeouts++;
                this.metrics.totalRequests++;
                this.metrics.errors.push({
                    timestamp,
                    type: 'TIMEOUT',
                    duration: Date.now() - startTime
                });
                req.destroy();
                resolve({ success: false, error: 'Request timeout', timeout: true });
            });
            
            req.on('error', (e) => {
                this.metrics.failedRequests++;
                this.metrics.totalRequests++;
                this.metrics.errors.push({
                    timestamp,
                    type: 'NETWORK_ERROR',
                    error: e.message
                });
                resolve({ success: false, error: e.message });
            });
            
            req.write(postData);
            req.end();
        });
    }
    
    assessResponseQuality(response) {
        const issues = [];
        
        // Kiểm tra cấu trúc response
        if (!response.choices || !Array.isArray(response.choices) || response.choices.length === 0) {
            issues.push('Missing or empty choices array');
        }
        
        // Kiểm tra message content
        if (!response.choices?.[0]?.message?.content) {
            issues.push('Missing message content');
        }
        
        // Kiểm tra độ dài response
        const content = response.choices?.[0]?.message?.content || '';
        if (content.length < 10) {
            issues.push('Response too short (< 10 chars)');
        }
        
        // Kiểm tra usage thông tin
        if (!response.usage) {
            issues.push('Missing usage information');
        }
        
        return {
            isValid: issues.length === 0,
            issues,
            contentLength: content.length,
            hasUsage: !!response.usage
        };
    }
    
    getHealthReport() {
        const total = this.metrics.totalRequests;
        if (total === 0) return { status: 'NO_DATA' };
        
        const sortedLatencies = [...this.metrics.latencies].sort((a, b) => a - b);
        const p50 = sortedLatencies[Math.floor(total * 0.50)];
        const p95 = sortedLatencies[Math.floor(total * 0.95)];
        const p99 = sortedLatencies[Math.floor(total * 0.99)];
        
        const errorRate = (this.metrics.failedRequests + this.metrics.timeouts) / total;
        const timeoutRate = this.metrics.timeouts / total;
        const avgLatency = this.metrics.latencies.reduce((a, b) => a + b, 0) / total;
        
        // Tính health score (0-100)
        let healthScore = 100;
        if (errorRate > this.thresholds.errorRate) healthScore -= 30;
        if (timeoutRate > this.thresholds.timeoutRate) healthScore -= 20;
        if (p99 > this.thresholds.latencyP99) healthScore -= 25;
        if (this.metrics.rateLimitHits > this.thresholds.rateLimitHits) healthScore -= 15;
        if (this.metrics.invalidResponses / total > this.thresholds.invalidResponse) healthScore -= 10;
        
        return {
            status: healthScore >= 80 ? 'HEALTHY' : healthScore >= 50 ? 'DEGRADED' : 'UNHEALTHY',
            healthScore,
            summary: {
                totalRequests: total,
                successRate: ((total - this.metrics.failedRequests) / total * 100).toFixed(2) + '%',
                errorRate: (errorRate * 100).toFixed(2) + '%',
                timeoutRate: (timeoutRate * 100).toFixed(2) + '%',
                invalidResponseRate: ((this.metrics.invalidResponses / total) * 100).toFixed(2) + '%',
                rateLimitHits: this.metrics.rateLimitHits
            },
            latency: {
                avg: avgLatency.toFixed(2),
                p50: p50?.toFixed(2),
                p95: p95?.toFixed(2),
                p99: p99?.toFixed(2),
                unit: 'ms'
            },
            alerts: this.generateAlerts({
                errorRate, timeoutRate, p99, avgLatency
            })
        };
    }
    
    generateAlerts(metrics) {
        const alerts = [];
        
        if (metrics.errorRate > this.thresholds.errorRate) {
            alerts.push({
                severity: 'HIGH',
                metric: 'ERROR_RATE',
                value: (metrics.errorRate * 100).toFixed(2) + '%',
                threshold: (this.thresholds.errorRate * 100) + '%',
                message: 'Tỷ lệ lỗi vượt ngưỡng cho phép!'
            });
        }
        
        if (metrics.timeoutRate > this.thresholds.timeoutRate) {
            alerts.push({
                severity: 'CRITICAL',
                metric: 'TIMEOUT_RATE',
                value: (metrics.timeoutRate * 100).toFixed(2) + '%',
                threshold: (this.thresholds.timeoutRate * 100) + '%',
                message: 'Tỷ lệ timeout nguy hiểm!'
            });
        }
        
        if (metrics.p99 > this.thresholds.latencyP99) {
            alerts.push({
                severity: 'MEDIUM',
                metric: 'P99_LATENCY',
                value: metrics.p99 + 'ms',
                threshold: this.thresholds.latencyP99 + 'ms',
                message: 'P99 latency cao hơn SLA'
            });
        }
        
        return alerts;
    }
}

// Sử dụng - Test với HolySheep AI
async function main() {
    const monitor = new AIAPIMonitor();
    
    const testPrompts = [
        { role: 'user', content: 'Giải thích về machine learning' },
        { role: 'user', content: 'Viết code Python để sort array' },
        { role: 'user', content: 'So sánh SQL và NoSQL database' }
    ];
    
    console.log('Starting API monitoring test...\n');
    
    for (const prompt of testPrompts) {
        const result = await monitor.makeRequest([prompt], 'gpt-4.1');
        console.log(Request: "${prompt.content.substring(0, 30)}...");
        console.log(  Status: ${result.success ? '✅ SUCCESS' : '❌ FAILED'});
        console.log(  Latency: ${result.latency}ms);
        if (result.quality) {
            console.log(  Quality: ${result.quality.isValid ? '✅ Valid' : '⚠️ Issues: ' + result.quality.issues.join(', ')});
        }
        console.log('');
    }
    
    // Báo cáo tổng quan
    const report = monitor.getHealthReport();
    console.log('=== HEALTH REPORT ===');
    console.log(Status: ${report.status});
    console.log(Health Score: ${report.healthScore}/100);
    console.log(Success Rate: ${report.summary.successRate});
    console.log(Latency P99: ${report.latency.p99}ms);
    
    if (report.alerts.length > 0) {
        console.log('\n=== ALERTS ===');
        report.alerts.forEach(alert => {
            console.log([${alert.severity}] ${alert.message});
        });
    }
}

main().catch(console.error);

3. Cost Monitoring và Token Usage

# Python - Cost Optimization và Token Usage Tracking
import requests
import json
from datetime import datetime, timedelta
from typing import Dict, List, Optional
import time

class CostMonitor:
    """
    Giám sát chi phí API với HolySheep AI
    HolySheep cung cấp tỷ giá ưu đãi: ¥1 = $1 (tiết kiệm 85%+)
    """
    
    # Bảng giá HolySheep AI 2026 (tham khảo)
    PRICING = {
        'gpt-4.1': {'input': 8, 'output': 8},           # $8/1M tokens
        'claude-sonnet-4.5': {'input': 15, 'output': 15},  # $15/1M tokens
        'gemini-2.5-flash': {'input': 2.5, 'output': 2.5}, # $2.50/1M tokens
        'deepseek-v3.2': {'input': 0.42, 'output': 0.42},  # $0.42/1M tokens
    }
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
        self.session_requests = 0
        self.session_cost = 0.0
        self.token_usage = {
            'prompt_tokens': 0,
            'completion_tokens': 0,
            'total_tokens': 0
        }
        
    def estimate_cost(self, model: str, prompt_tokens: int, completion_tokens: int) -> float:
        """Ước tính chi phí dựa trên token usage"""
        if model not in self.PRICING:
            # Default pricing fallback
            return (prompt_tokens + completion_tokens) * 8 / 1_000_000
            
        input_cost = (prompt_tokens / 1_000_000) * self.PRICING[model]['input']
        output_cost = (completion_tokens / 1_000_000) * self.PRICING[model]['output']
        return input_cost + output_cost
    
    def call_with_cost_tracking(self, messages: List[Dict], model: str = 'gpt-4.1') -> Dict:
        """Gọi API và track chi phí chi tiết"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": messages,
            "temperature": 0.7,
            "max_tokens": 2000
        }
        
        start_time = time.time()
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=headers,
            json=payload,
            timeout=30
        )
        elapsed = time.time() - start_time
        
        result = {
            'timestamp': datetime.now().isoformat(),
            'model': model,
            'latency_ms': round(elapsed * 1000, 2),
            'status_code': response.status_code,
            'success': response.status_code == 200
        }
        
        if response.status_code == 200:
            data = response.json()
            result['response'] = data.get('choices', [{}])[0].get('message', {}).get('content', '')
            
            # Track usage nếu có
            if 'usage' in data:
                usage = data['usage']
                result['usage'] = usage
                self.token_usage['prompt_tokens'] += usage.get('prompt_tokens', 0)
                self.token_usage['completion_tokens'] += usage.get('completion_tokens', 0)
                self.token_usage['total_tokens'] += usage.get('total_tokens', 0)
                
                # Tính chi phí
                cost = self.estimate_cost(
                    model,
                    usage.get('prompt_tokens', 0),
                    usage.get('completion_tokens', 0)
                )
                result['estimated_cost'] = cost
                self.session_cost += cost
                self.session_requests += 1
        
        return result
    
    def get_cost_report(self, period: str = 'session') -> Dict:
        """Tạo báo cáo chi phí chi tiết"""
        avg_cost = self.session_cost / self.session_requests if self.session_requests > 0 else 0
        
        return {
            'period': period,
            'generated_at': datetime.now().isoformat(),
            'requests': self.session_requests,
            'total_cost_usd': round(self.session_cost, 4),
            'avg_cost_per_request': round(avg_cost, 4),
            'token_usage': self.token_usage,
            'cost_breakdown': {
                'prompt_cost': round(self.token_usage['prompt_tokens'] / 1_000_000 * 8, 4),
                'completion_cost': round(self.token_usage['completion_tokens'] / 1_000_000 * 8, 4)
            },
            'savings_estimate': {
                'vs_official_api': round(self.session_cost * 0.15, 4),  # 85% savings
                'vs_relay_services': round(self.session_cost * 0.30, 4)  # ~50% savings
            }
        }
    
    def set_budget_alert(self, threshold_usd: float, window_minutes: int = 60):
        """Thiết lập cảnh báo ngân sách"""
        # Implementation cho budget alert
        return {
            'alert_configured': True,
            'threshold_usd': threshold_usd,
            'window_minutes': window_minutes,
            'message': f'Alert khi chi phí vượt ${threshold_usd} trong {window_minutes} phút'
        }


Sử dụng

monitor = CostMonitor("YOUR_HOLYSHEEP_API_KEY")


Test các model khác nhau

test_cases = [
    {'messages': [{'role': 'user', 'content': 'Viết một đoạn văn 200 từ về AI'}], 'model': 'gpt-4.1'},
    {'messages': [{'role': 'user', 'content': 'Giải thích quantum computing'}], 'model': 'gemini-2.5-flash'},
    {'messages': [{'role': 'user', 'content': 'Code một simple web server'}], 'model': 'deepseek-v3.2'},
]

print("=== COST MONITORING TEST ===\n")

for test in test_cases:
    result = monitor.call_with_cost_tracking(test['messages'], test['model'])
    print(f"Model: {test['model']}")
    print(f"  Latency: {result['latency_ms']}ms")
    if result.get('usage'):
        print(f"  Tokens: {result['usage']}")
        print(f"  Est. Cost: ${result.get('estimated_cost', 0):.4f}")
    print(f"  Status: {'✅' if result['success'] else '❌'}\n")


Báo cáo chi phí

report = monitor.get_cost_report()
print("=== COST REPORT ===")
print(f"Tổng chi phí: ${report['total_cost_usd']}")
print(f"Số requests: {report['requests']}")
print(f"Trung bình: ${report['avg_cost_per_request']}/request")
print(f"Tiết kiệm vs Official API: ~${report['savings_estimate']['vs_official_api']}")
print(f"Tiết kiệm vs Relay: ~${report['savings_estimate']['vs_relay_services']}")


Cấu hình alert

alert = monitor.set_budget_alert(threshold_usd=100, window_minutes=60)
print(f"\n{alert['message']}")

Thiết Lập Ngưỡng Cảnh Báo Tối Ưu

Dựa trên kinh nghiệm thực chiến với HolySheep AI, đây là bảng ngưỡng cảnh báo được đề xuất:

Metric Ngưỡng Warning Ngưỡng Critical Action khi breach
P50 Latency > 100ms > 200ms Kiểm tra network, consider backup provider
P95 Latency > 500ms > 1000ms Scale infrastructure, fallback queue
P99 Latency > 1500ms > 3000ms Incident response, root cause analysis
Error Rate > 1% > 5% Failover to backup, notify team
Timeout Rate > 0.5% > 2% Increase timeout, check provider status
Rate Limit Hits > 5/hour > 20/hour Implement exponential backoff
Cost/Request > +20% baseline > +50% baseline Optimize prompts, reduce tokens
Invalid Response Rate > 0.5% > 1% Validate responses, add retry logic

Implement Alert System Với Webhook

// Python - Alert System với Webhook Integration
import requests
import json
from datetime import datetime
from enum import Enum
from typing import Dict, List, Callable
import threading
import time

class AlertSeverity(Enum):
    INFO = "INFO"
    WARNING = "WARNING"
    HIGH = "HIGH"
    CRITICAL = "CRITICAL"

class Alert:
    def __init__(self, severity: AlertSeverity, metric: str, 
                 value: float, threshold: float, message: str):
        self.severity = severity
        self.metric = metric
        self.value = value
        self.threshold = threshold
        self.message = message
        self.timestamp = datetime.now().isoformat()
        self.alert_id = f"{metric}_{int(time.time())}"
    
    def to_dict(self):
        return {
            "id": self.alert_id,
            "severity": self.severity.value,
            "metric": self.metric,
            "value": self.value,
            "threshold": self.threshold,
            "message": self.message,
            "timestamp": self.timestamp,
            "source": "HolySheep AI Monitor"
        }

class AlertManager:
    def __init__(self, webhook_url: str = None):
        self.webhook_url = webhook_url or "https://your-webhook-endpoint.com/alerts"
        self.alerts = []
        self.alert_history = []
        self.handlers = {
            AlertSeverity.INFO: self._handle_info,
            AlertSeverity.WARNING: self._handle_warning,
            AlertSeverity.HIGH: self._handle_high,
            AlertSeverity.CRITICAL: self._handle_critical
        }
        # Rate limiting để tránh spam
        self.alert_cooldowns = {}  # metric -> last_alert_time
        
    def _should_send_alert(self, metric: str, cooldown_seconds: int = 300) -> bool:
        """Kiểm tra cooldown để tránh alert spam"""
        if metric not in self.alert_cooldowns:
            return True
        return (time.time() - self.alert_cooldowns[metric]) > cooldown_seconds
    
    def trigger_alert(self, alert: Alert, cooldown_seconds: int = 300):
        """Trigger alert với rate limiting

Tài nguyên liên quan
Bài viết liên quan