""" 匹配监控系统模块 监控匹配过程和性能 """ import time from typing import Dict, Any, List, Optional from collections import deque class MatchMonitor: """ 匹配监控器 监控匹配过程和性能 """ def __init__(self, plugin): """ 初始化匹配监控器 Args: plugin: 匹配系统插件实例 """ self.plugin = plugin self.enabled = False self.initialized = False # 监控配置 self.monitor_config = { "enable_monitoring": True, "monitoring_interval": 5.0, "log_level": "INFO", "enable_performance_monitoring": True, "enable_alerts": True, "alert_thresholds": { "match_queue_time": 60.0, "match_failure_rate": 10.0, "system_latency": 100.0 }, "enable_metrics_collection": True, "metrics_retention_period": 3600 # 1小时 } # 性能指标存储 self.performance_metrics = { "match_queue_times": deque(maxlen=1000), "match_success_rates": deque(maxlen=1000), "system_latencies": deque(maxlen=1000), "player_wait_times": deque(maxlen=1000), "algorithm_performance": deque(maxlen=1000) } # 监控状态 self.monitor_state = { "last_monitoring_update": 0.0, "last_performance_check": 0.0, "total_monitored_matches": 0, "active_alerts": 0 } # 警报系统 self.active_alerts = {} self.alert_history = deque(maxlen=1000) # 监控统计 self.monitor_stats = { "metrics_collected": 0, "alerts_generated": 0, "alerts_resolved": 0, "performance_checks": 0, "monitor_errors": 0 } # 回调函数 self.monitor_callbacks = { "metric_collected": [], "alert_triggered": [], "alert_resolved": [], "performance_degraded": [] } # 时间戳记录 self.last_metric_collection = 0.0 self.last_alert_check = 0.0 print("✓ 匹配监控器已创建") def initialize(self) -> bool: """ 初始化匹配监控器 Returns: 是否初始化成功 """ try: print("正在初始化匹配监控器...") self.initialized = True print("✓ 匹配监控器初始化完成") return True except Exception as e: print(f"✗ 匹配监控器初始化失败: {e}") self.monitor_stats["monitor_errors"] += 1 import traceback traceback.print_exc() return False def enable(self) -> bool: """ 启用匹配监控器 Returns: 是否启用成功 """ try: if not self.initialized: print("✗ 匹配监控器未初始化") return False self.enabled = True print("✓ 匹配监控器已启用") return True except Exception as e: print(f"✗ 匹配监控器启用失败: {e}") self.monitor_stats["monitor_errors"] += 1 import traceback traceback.print_exc() return False def disable(self): """禁用匹配监控器""" try: self.enabled = False print("✓ 匹配监控器已禁用") except Exception as e: print(f"✗ 匹配监控器禁用失败: {e}") self.monitor_stats["monitor_errors"] += 1 import traceback traceback.print_exc() def finalize(self): """清理匹配监控器资源""" try: # 禁用匹配监控器 if self.enabled: self.disable() # 清理回调 self.monitor_callbacks.clear() self.initialized = False print("✓ 匹配监控器资源已清理") except Exception as e: print(f"✗ 匹配监控器资源清理失败: {e}") import traceback traceback.print_exc() def update(self, dt: float): """ 更新匹配监控器状态 Args: dt: 时间增量（秒） """ try: if not self.enabled: return current_time = time.time() self.monitor_state["last_monitoring_update"] = current_time # 定期收集性能指标 if current_time - self.last_metric_collection >= self.monitor_config["monitoring_interval"]: self._collect_performance_metrics() self.last_metric_collection = current_time # 定期检查警报 if current_time - self.last_alert_check >= self.monitor_config["monitoring_interval"]: self._check_alerts() self.last_alert_check = current_time except Exception as e: print(f"✗ 匹配监控器更新失败: {e}") self.monitor_stats["monitor_errors"] += 1 import traceback traceback.print_exc() def _collect_performance_metrics(self): """收集性能指标""" try: current_time = time.time() metrics = {} # 收集匹配管理器指标 if self.plugin.match_manager: match_stats = self.plugin.match_manager.get_match_stats() match_state = match_stats.get("state", {}) metrics["active_matches"] = match_state.get("active_matches", 0) metrics["successful_matches"] = match_state.get("successful_matches", 0) metrics["failed_matches"] = match_state.get("failed_matches", 0) # 计算成功率 total_matches = metrics["successful_matches"] + metrics["failed_matches"] if total_matches > 0: success_rate = (metrics["successful_matches"] / total_matches) * 100 metrics["match_success_rate"] = success_rate self.performance_metrics["match_success_rates"].append((current_time, success_rate)) # 收集队列管理器指标 if self.plugin.queue_manager: queue_stats = self.plugin.queue_manager.get_queue_stats() queue_state = queue_stats.get("state", {}) metrics["total_players"] = queue_state.get("total_players", 0) metrics["players_matched"] = queue_state.get("players_matched", 0) metrics["players_timed_out"] = queue_state.get("players_timed_out", 0) # 计算超时率 total_players = metrics["players_matched"] + metrics["players_timed_out"] if total_players > 0: timeout_rate = (metrics["players_timed_out"] / total_players) * 100 metrics["queue_timeout_rate"] = timeout_rate # 收集算法管理器指标 if self.plugin.algorithm_manager: algorithm_stats = self.plugin.algorithm_manager.get_algorithm_stats() algorithm_state = algorithm_stats.get("state", {}) metrics["total_algorithms"] = algorithm_state.get("total_matches", 0) metrics["successful_algorithms"] = algorithm_state.get("successful_matches", 0) metrics["average_match_quality"] = algorithm_state.get("average_match_quality", 0) self.performance_metrics["algorithm_performance"].append( (current_time, metrics["average_match_quality"]) ) # 收集房间分配器指标 if self.plugin.room_allocator: room_stats = self.plugin.room_allocator.get_room_stats() room_state = room_stats.get("state", {}) metrics["active_rooms"] = room_state.get("active_rooms", 0) metrics["total_rooms"] = room_state.get("total_rooms", 0) # 更新统计 self.monitor_stats["metrics_collected"] += 1 self.monitor_state["total_monitored_matches"] += 1 # 触发指标收集回调 self._trigger_monitor_callback("metric_collected", { "metrics": metrics, "timestamp": current_time }) except Exception as e: print(f"✗ 性能指标收集失败: {e}") self.monitor_stats["monitor_errors"] += 1 def _check_alerts(self): """检查警报条件""" try: if not self.monitor_config["enable_alerts"]: return current_time = time.time() thresholds = self.monitor_config["alert_thresholds"] # 检查匹配队列时间 if self.performance_metrics["match_queue_times"]: latest_queue_time = self.performance_metrics["match_queue_times"][-1][1] if latest_queue_time > thresholds["match_queue_time"]: self._trigger_alert("high_queue_time", f"匹配队列时间过长: {latest_queue_time:.2f}秒", current_time) # 检查匹配失败率 if self.performance_metrics["match_success_rates"]: latest_success_rate = self.performance_metrics["match_success_rates"][-1][1] failure_rate = 100 - latest_success_rate if failure_rate > thresholds["match_failure_rate"]: self._trigger_alert("high_failure_rate", f"匹配失败率过高: {failure_rate:.2f}%", current_time) # 检查系统延迟 if self.performance_metrics["system_latencies"]: latest_latency = self.performance_metrics["system_latencies"][-1][1] if latest_latency > thresholds["system_latency"]: self._trigger_alert("high_latency", f"系统延迟过高: {latest_latency:.2f}ms", current_time) except Exception as e: print(f"✗ 警报检查失败: {e}") self.monitor_stats["monitor_errors"] += 1 def _trigger_alert(self, alert_type: str, message: str, timestamp: float = None): """ 触发警报 Args: alert_type: 警报类型 message: 警报消息 timestamp: 时间戳 """ try: if timestamp is None: timestamp = time.time() alert_id = f"{alert_type}_{int(timestamp)}" # 检查是否已存在相同类型的活动警报 if alert_type in self.active_alerts: # 更新现有警报 self.active_alerts[alert_type]["count"] += 1 self.active_alerts[alert_type]["last_triggered"] = timestamp else: # 创建新警报 self.active_alerts[alert_type] = { "id": alert_id, "type": alert_type, "message": message, "first_triggered": timestamp, "last_triggered": timestamp, "count": 1, "resolved": False } self.monitor_state["active_alerts"] += 1 self.monitor_stats["alerts_generated"] += 1 # 添加到警报历史 self.alert_history.append({ "id": alert_id, "type": alert_type, "message": message, "timestamp": timestamp, "resolved": False }) # 触发警报回调 self._trigger_monitor_callback("alert_triggered", { "alert_id": alert_id, "alert_type": alert_type, "message": message, "timestamp": timestamp }) print(f"⚠️ 警报触发 [{alert_type}]: {message}") except Exception as e: print(f"✗ 警报触发失败: {e}") self.monitor_stats["monitor_errors"] += 1 def resolve_alert(self, alert_type: str): """ 解决警报 Args: alert_type: 警报类型 """ try: if alert_type in self.active_alerts: alert_data = self.active_alerts[alert_type] alert_data["resolved"] = True alert_data["resolved_time"] = time.time() self.monitor_state["active_alerts"] -= 1 self.monitor_stats["alerts_resolved"] += 1 # 触发警报解决回调 self._trigger_monitor_callback("alert_resolved", { "alert_type": alert_type, "alert_data": alert_data }) # 从活动警报中移除 del self.active_alerts[alert_type] print(f"✅ 警报已解决: {alert_type}") except Exception as e: print(f"✗ 警报解决失败: {e}") self.monitor_stats["monitor_errors"] += 1 def record_match_queue_time(self, queue_time: float): """ 记录匹配队列时间 Args: queue_time: 队列时间（秒） """ try: current_time = time.time() self.performance_metrics["match_queue_times"].append((current_time, queue_time)) except Exception as e: print(f"✗ 匹配队列时间记录失败: {e}") self.monitor_stats["monitor_errors"] += 1 def record_player_wait_time(self, wait_time: float): """ 记录玩家等待时间 Args: wait_time: 等待时间（秒） """ try: current_time = time.time() self.performance_metrics["player_wait_times"].append((current_time, wait_time)) except Exception as e: print(f"✗ 玩家等待时间记录失败: {e}") self.monitor_stats["monitor_errors"] += 1 def record_system_latency(self, latency: float): """ 记录系统延迟 Args: latency: 延迟（毫秒） """ try: current_time = time.time() self.performance_metrics["system_latencies"].append((current_time, latency)) except Exception as e: print(f"✗ 系统延迟记录失败: {e}") self.monitor_stats["monitor_errors"] += 1 def get_performance_metrics(self, metric_name: str = None, limit: int = 100) -> Any: """ 获取性能指标 Args: metric_name: 指标名称（可选） limit: 限制返回的数量 Returns: 性能指标数据 """ try: if metric_name: if metric_name in self.performance_metrics: metrics = list(self.performance_metrics[metric_name]) return metrics[-limit:] if len(metrics) > limit else metrics else: return [] else: # 返回所有指标 result = {} for name, metrics in self.performance_metrics.items(): metric_list = list(metrics) result[name] = metric_list[-limit:] if len(metric_list) > limit else metric_list return result except Exception as e: print(f"✗ 获取性能指标失败: {e}") self.monitor_stats["monitor_errors"] += 1 return {} def get_active_alerts(self) -> Dict[str, Any]: """ 获取活动警报 Returns: 活动警报字典 """ try: return self.active_alerts.copy() except Exception as e: print(f"✗ 获取活动警报失败: {e}") self.monitor_stats["monitor_errors"] += 1 return {} def get_alert_history(self, limit: int = 100) -> List[Dict[str, Any]]: """ 获取警报历史 Args: limit: 限制返回的数量 Returns: 警报历史列表 """ try: history = list(self.alert_history) return history[-limit:] if len(history) > limit else history except Exception as e: print(f"✗ 获取警报历史失败: {e}") self.monitor_stats["monitor_errors"] += 1 return [] def get_monitor_stats(self) -> Dict[str, Any]: """ 获取监控统计信息 Returns: 监控统计字典 """ return { "state": self.monitor_state.copy(), "stats": self.monitor_stats.copy(), "config": self.monitor_config.copy(), "active_alerts_count": len(self.active_alerts), "alert_history_count": len(self.alert_history) } def reset_stats(self): """重置监控统计信息""" try: self.monitor_stats = { "metrics_collected": 0, "alerts_generated": 0, "alerts_resolved": 0, "performance_checks": 0, "monitor_errors": 0 } self.monitor_state["total_monitored_matches"] = 0 self.monitor_state["active_alerts"] = 0 print("✓ 监控统计信息已重置") except Exception as e: print(f"✗ 监控统计信息重置失败: {e}") def set_monitor_config(self, config: Dict[str, Any]) -> bool: """ 设置监控配置 Args: config: 监控配置字典 Returns: 是否设置成功 """ try: self.monitor_config.update(config) print(f"✓ 监控配置已更新: {self.monitor_config}") return True except Exception as e: print(f"✗ 监控配置设置失败: {e}") return False def get_monitor_config(self) -> Dict[str, Any]: """ 获取监控配置 Returns: 监控配置字典 """ return self.monitor_config.copy() def _trigger_monitor_callback(self, callback_type: str, data: Dict[str, Any]): """ 触发监控回调 Args: callback_type: 回调类型 data: 回调数据 """ try: if callback_type in self.monitor_callbacks: for callback in self.monitor_callbacks[callback_type]: try: callback(data) except Exception as e: print(f"✗ 监控回调执行失败: {callback_type} - {e}") except Exception as e: print(f"✗ 监控回调触发失败: {e}") def register_monitor_callback(self, callback_type: str, callback: callable): """ 注册监控回调 Args: callback_type: 回调类型 callback: 回调函数 """ try: if callback_type in self.monitor_callbacks: self.monitor_callbacks[callback_type].append(callback) print(f"✓ 监控回调已注册: {callback_type}") else: print(f"✗ 无效的回调类型: {callback_type}") except Exception as e: print(f"✗ 监控回调注册失败: {e}") def unregister_monitor_callback(self, callback_type: str, callback: callable): """ 注销监控回调 Args: callback_type: 回调类型 callback: 回调函数 """ try: if callback_type in self.monitor_callbacks: if callback in self.monitor_callbacks[callback_type]: self.monitor_callbacks[callback_type].remove(callback) print(f"✓ 监控回调已注销: {callback_type}") else: print(f"✗ 无效的回调类型: {callback_type}") except Exception as e: print(f"✗ 监控回调注销失败: {e}")