mdbq 4.0.81__tar.gz → 4.0.83__tar.gz

{mdbq-4.0.81 → mdbq-4.0.83}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdbq
-Version: 4.0.81
+Version: 4.0.83
 Home-page: https://pypi.org/project/mdbq
 Author: xigua, 
 Author-email: 2587125111@qq.com

mdbq-4.0.83/mdbq/__version__.py

@@ -0,0 +1 @@
+VERSION = '4.0.83'

{mdbq-4.0.81 → mdbq-4.0.83}/mdbq/route/monitor.py

@@ -22,6 +22,7 @@ from typing import Dict, Any, Optional, List
 from urllib.parse import urlparse, parse_qs
 from dbutils.pooled_db import PooledDB
 from mdbq.myconf import myconf
+from mdbq.log import mylogger
 from flask import request, g
 import re
 import ipaddress
@@ -33,41 +34,89 @@ host, port, username, password = parser.get_section_values(
     keys=['host', 'port', 'username', 'password'],
 )
 
+logger = mylogger.MyLogger(
+    logging_mode='file',
+    log_level='debug',
+    log_format='json',
+    max_log_size=50,
+    backup_count=5,
+    enable_async=False,  # 是否启用异步日志
+    sample_rate=1,  # 采样DEBUG/INFO日志
+    sensitive_fields=[],  #  敏感字段过滤
+    enable_metrics=False,  # 是否启用性能指标
+)
+
 
 class RouteMonitor:
     """路由监控核心类"""
     
-    def __init__(self, pool=None):
+    def __init__(self, database='api_monitor_logs'):
         """初始化监控系统"""
-        if pool is not None:
-            self.pool = pool
-        else:
-            self.init_database_pool()
+        self.database = database
+        self.init_database_pool()
         self.init_database_tables()
-        
+
     def init_database_pool(self):
         """初始化数据库连接池"""
-        self.pool = PooledDB(
-            creator=pymysql,
-            maxconnections=3,  # 最大连接数
-            mincached=1,  # 初始化空闲连接数
-            maxcached=3,  # 空闲连接最大缓存数
-            blocking=True,
-            host=host,
-            port=int(port),
-            user=username,
-            password=password,
-            ping=1,
-            charset='utf8mb4',
-            cursorclass=pymysql.cursors.DictCursor
-        )
+        try:
+            self.pool = PooledDB(
+                creator=pymysql,
+                maxconnections=2,  # 监控系统连接数较小
+                mincached=1,
+                maxcached=2,
+                blocking=True,
+                host=host,
+                port=int(port),
+                user=username,
+                password=password,
+                ping=1,
+                charset='utf8mb4',
+                cursorclass=pymysql.cursors.DictCursor
+            )
+
+            # 创建数据库并切换
+            connection = self.pool.connection()
+            try:
+                with connection.cursor() as cursor:
+                    cursor.execute(f"CREATE DATABASE IF NOT EXISTS `{self.database}` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci")
+                    cursor.execute(f"USE `{self.database}`")
+            finally:
+                connection.close()
+                
+        except Exception as e:
+            logger.error("❌ 数据库连接池初始化失败", {
+                "错误信息": str(e),
+                "数据库": self.database
+            })
+            raise
+    
+    def ensure_database_context(self, cursor):
+        """确保当前游标处于正确的数据库上下文中"""
+        try:
+            cursor.execute(f"USE `{self.database}`")
+        except Exception as e:
+            logger.warning("切换数据库上下文失败，尝试重新创建", {
+                "数据库": self.database,
+                "错误": str(e)
+            })
+            cursor.execute(f"CREATE DATABASE IF NOT EXISTS `{self.database}` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci")
+            cursor.execute(f"USE `{self.database}`")
         
     def init_database_tables(self):
         """初始化数据库表结构"""
         try:
+            logger.debug("🗄️ 开始创建/验证数据库表结构", {
+                "操作": "表结构初始化",
+                "预期表数": 4,
+                "数据库": self.database
+            })
+            
             connection = self.pool.connection()
             try:
                 with connection.cursor() as cursor:
+                    # 确保使用正确的数据库上下文
+                    self.ensure_database_context(cursor)
+                    
                     # 创建详细请求记录表 - 修复MySQL 8.4+兼容性
                     cursor.execute("""
                         CREATE TABLE IF NOT EXISTS `api_request_logs` (
@@ -120,7 +169,6 @@ class RouteMonitor:
                         ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci 
                         COMMENT='API请求详细日志表';
                     """)
-                    
                     # 创建访问统计汇总表
                     cursor.execute("""
                         CREATE TABLE IF NOT EXISTS `api_access_statistics` (
@@ -178,7 +226,6 @@ class RouteMonitor:
                         ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci 
                         COMMENT='IP访问统计表';
                     """)
-                    
                     # 创建系统性能统计表
                     cursor.execute("""
                         CREATE TABLE IF NOT EXISTS `system_performance_stats` (
@@ -197,11 +244,24 @@ class RouteMonitor:
                         ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci 
                         COMMENT='系统性能统计表';
                     """)
-                    
                 connection.commit()
+                logger.debug("🎯 所有数据库表结构初始化完成", {
+                    "创建表数": 4,
+                    "操作状态": "成功",
+                    "数据库": self.database,
+                    "数据库引擎": "InnoDB"
+                })
+                
             finally:
                 connection.close()
+                
         except Exception as e:
+            logger.error("❌ 数据库表结构初始化失败", {
+                "错误信息": str(e),
+                "错误类型": type(e).__name__,
+                "数据库": self.database,
+                "影响": "监控系统可能无法正常工作"
+            })
             # 静默处理初始化错误，避免影响主应用
             pass
     
@@ -376,9 +436,24 @@ class RouteMonitor:
         # 设置请求ID到全局变量中，供后续使用
         g.request_id = request_id
         
+        logger.debug("📋 开始收集请求数据", {
+            "请求ID": request_id,
+            "请求方法": request.method,
+            "端点": request.endpoint or request.path,
+            "客户端IP": request.remote_addr
+        })
+        
         # 获取真实IP
         real_ip, forwarded_ips = self.get_real_ip(request)
         
+        if real_ip != request.remote_addr:
+            logger.debug("🔍 检测到IP转发", {
+                "请求ID": request_id,
+                "原始IP": request.remote_addr,
+                "真实IP": real_ip,
+                "转发链长度": len(forwarded_ips) if forwarded_ips else 0
+            })
+        
         # 获取请求头信息
         headers = dict(request.headers)
         sanitized_headers = self.sanitize_data(headers)
@@ -405,11 +480,25 @@ class RouteMonitor:
                             request_body = body_data.decode('utf-8')
                         except UnicodeDecodeError:
                             request_body = f"[BINARY_DATA:{len(body_data)}_bytes]"
+                            logger.debug("📁 检测到二进制数据", {
+                                "请求ID": request_id,
+                                "数据大小": len(body_data),
+                                "处理方式": "标记为二进制"
+                            })
                 
                 if request_body:
                     request_size = len(str(request_body).encode('utf-8'))
-        except Exception:
+                    logger.debug("📊 请求体信息", {
+                        "请求ID": request_id,
+                        "数据类型": "JSON" if request.is_json else "表单" if request.form else "文本",
+                        "大小": f"{request_size} bytes"
+                    })
+        except Exception as e:
             request_body = "[ERROR_READING_BODY]"
+            logger.warning("⚠️ 读取请求体失败", {
+                "请求ID": request_id,
+                "错误": str(e)
+            })
         
         # 清理敏感数据
         sanitized_body = self.sanitize_data(request_body)
@@ -419,6 +508,20 @@ class RouteMonitor:
         user_agent = request.headers.get('User-Agent', '')
         device_info = self.extract_device_info(user_agent)
         
+        if device_info['is_bot']:
+            logger.debug("🤖 检测到机器人请求", {
+                "请求ID": request_id,
+                "用户代理": user_agent[:100] + "..." if len(user_agent) > 100 else user_agent,
+                "IP": real_ip
+            })
+        
+        if device_info['is_mobile']:
+            logger.debug("📱 检测到移动设备请求", {
+                "请求ID": request_id,
+                "操作系统": device_info['os_name'],
+                "浏览器": device_info['browser_name']
+            })
+        
         # URL解析
         parsed_url = urlparse(request.url)
         
@@ -457,6 +560,14 @@ class RouteMonitor:
             'os_version': device_info['os_version'],
         }
         
+        logger.debug("✅ 请求数据收集完成", {
+            "请求ID": request_id,
+            "数据字段数": len(request_data),
+            "请求大小": f"{request_size} bytes",
+            "设备类型": "移动" if device_info['is_mobile'] else "桌面",
+            "是否机器人": device_info['is_bot']
+        })
+        
         return request_data
     
     def mask_token(self, token: str) -> str:
@@ -471,14 +582,26 @@ class RouteMonitor:
     
     def save_request_log(self, request_data: Dict[str, Any], response_data: Dict[str, Any] = None):
         """保存请求日志到数据库"""
+        request_id = request_data.get('request_id', 'unknown')
+        
         try:
             # 合并响应数据
             if response_data:
                 request_data.update(response_data)
             
+            logger.debug("💾 保存请求日志到数据库", {
+                "请求ID": request_id,
+                "端点": request_data.get('endpoint', ''),
+                "状态码": request_data.get('response_status', '未知'),
+                "处理时间": f"{request_data.get('process_time', 0)}ms"
+            })
+            
             connection = self.pool.connection()
             try:
                 with connection.cursor() as cursor:
+                    # 确保使用正确的数据库上下文
+                    self.ensure_database_context(cursor)
+                    
                     # 插入请求日志
                     columns = ', '.join([f"`{key}`" for key in request_data.keys()])
                     placeholders = ', '.join(['%s'] * len(request_data))
@@ -490,19 +613,46 @@ class RouteMonitor:
                     
                     cursor.execute(sql, list(request_data.values()))
                 connection.commit()
+                
+                logger.debug("✅ 请求日志保存成功", {
+                    "请求ID": request_id,
+                    "写入状态": "成功",
+                    "数据库表": "api_request_logs"
+                })
+                
             finally:
                 connection.close()
                 
         except Exception as e:
+            logger.error("❌ 保存请求日志失败", {
+                "请求ID": request_id,
+                "错误信息": str(e),
+                "错误类型": type(e).__name__,
+                "影响": "日志丢失，但不影响主业务"
+            })
             # 静默处理错误，不影响主业务
             pass
     
     def update_statistics(self, request_data: Dict[str, Any]):
         """更新统计数据"""
+        request_id = request_data.get('request_id', 'unknown')
+        endpoint = request_data.get('endpoint', '')
+        status_code = request_data.get('response_status', 500)
+        
         try:
+            logger.debug("📈 更新统计数据", {
+                "请求ID": request_id,
+                "端点": endpoint,
+                "状态码": status_code,
+                "统计类型": "API访问统计和IP统计"
+            })
+            
             connection = self.pool.connection()
             try:
                 with connection.cursor() as cursor:
+                    # 确保使用正确的数据库上下文
+                    self.ensure_database_context(cursor)
+                    
                     now = datetime.now()
                     date = now.date()
                     hour = now.hour
@@ -552,10 +702,24 @@ class RouteMonitor:
                     ))
                     
                 connection.commit()
+                
+                logger.debug("✅ 统计数据更新成功", {
+                    "请求ID": request_id,
+                    "更新表": "api_access_statistics, ip_access_statistics",
+                    "日期": str(date),
+                    "小时": hour
+                })
+                
             finally:
                 connection.close()
                 
         except Exception as e:
+            logger.error("❌ 更新统计数据失败", {
+                "请求ID": request_id,
+                "错误信息": str(e),
+                "错误类型": type(e).__name__,
+                "影响": "统计数据缺失，但不影响主业务"
+            })
             # 静默处理错误
             pass
 
@@ -569,6 +733,15 @@ class RouteMonitor:
             
             # 收集请求数据
             request_data = self.collect_request_data(request)
+            request_id = request_data.get('request_id', 'unknown')
+            
+            logger.debug("🎯 开始监控请求", {
+                "请求ID": request_id,
+                "函数名": func.__name__,
+                "端点": request_data.get('endpoint', ''),
+                "方法": request_data.get('method', ''),
+                "来源IP": request_data.get('real_ip', request_data.get('client_ip'))
+            })
             
             try:
                 # 执行原函数
@@ -578,12 +751,24 @@ class RouteMonitor:
                 end_time = time.time()
                 process_time = round((end_time - start_time) * 1000, 3)
                 
+                response_status = getattr(response, 'status_code', 200) if hasattr(response, 'status_code') else 200
+                response_size = len(str(response.get_data() if hasattr(response, 'get_data') else ''))
+                
                 response_data = {
-                    'response_status': getattr(response, 'status_code', 200) if hasattr(response, 'status_code') else 200,
+                    'response_status': response_status,
                     'process_time': process_time,
-                    'response_size': len(str(response.get_data() if hasattr(response, 'get_data') else ''))
+                    'response_size': response_size
                 }
                 
+                logger.debug("✅ 请求处理完成", {
+                    "请求ID": request_id,
+                    "函数名": func.__name__,
+                    "状态码": response_status,
+                    "处理时间": f"{process_time}ms",
+                    "响应大小": f"{response_size} bytes",
+                    "结果": "成功"
+                })
+                
                 # 保存日志
                 self.save_request_log(request_data, response_data)
                 
@@ -605,6 +790,15 @@ class RouteMonitor:
                     'response_size': 0
                 }
                 
+                logger.error("❌ 请求处理异常", {
+                    "请求ID": request_id,
+                    "函数名": func.__name__,
+                    "错误信息": str(e),
+                    "错误类型": type(e).__name__,
+                    "处理时间": f"{process_time}ms",
+                    "结果": "异常"
+                })
+                
                 # 保存错误日志
                 self.save_request_log(request_data, error_data)
                 
@@ -620,12 +814,26 @@ class RouteMonitor:
     def get_statistics_summary(self, days: int = 7) -> Dict[str, Any]:
         """获取统计摘要"""
         try:
+            logger.debug("📊 开始获取统计摘要", {
+                "查询天数": days,
+                "操作": "统计数据查询"
+            })
+            
             connection = self.pool.connection()
             try:
                 with connection.cursor() as cursor:
+                    # 确保使用正确的数据库上下文
+                    self.ensure_database_context(cursor)
+                    
                     end_date = datetime.now().date()
                     start_date = end_date - timedelta(days=days)
                     
+                    logger.debug("📅 统计查询时间范围", {
+                        "开始日期": str(start_date),
+                        "结束日期": str(end_date),
+                        "查询天数": days
+                    })
+                    
                     # 总体统计
                     cursor.execute("""
                         SELECT 
@@ -640,6 +848,14 @@ class RouteMonitor:
                     
                     summary = cursor.fetchone() or {}
                     
+                    logger.debug("📈 总体统计查询完成", {
+                        "总请求数": summary.get('total_requests', 0) or 0,
+                        "成功请求数": summary.get('success_requests', 0) or 0,
+                        "错误请求数": summary.get('error_requests', 0) or 0,
+                        "平均响应时间": f"{(summary.get('avg_response_time', 0) or 0):.2f}ms",
+                        "唯一端点数": summary.get('unique_endpoints', 0) or 0
+                    })
+                    
                     # 热门端点
                     cursor.execute("""
                         SELECT endpoint, SUM(total_requests) as requests
@@ -652,6 +868,12 @@ class RouteMonitor:
                     
                     top_endpoints = cursor.fetchall()
                     
+                    logger.debug("🔥 热门端点查询完成", {
+                        "查询结果数": len(top_endpoints),
+                        "最热门端点": top_endpoints[0]['endpoint'] if top_endpoints else "无数据",
+                        "最高请求数": top_endpoints[0]['requests'] if top_endpoints else 0
+                    })
+                    
                     # 活跃IP统计
                     cursor.execute("""
                         SELECT COUNT(DISTINCT ip_address) as unique_ips,
@@ -662,16 +884,36 @@ class RouteMonitor:
                     
                     ip_stats = cursor.fetchone() or {}
                     
-                    return {
+                    logger.debug("🌐 IP统计查询完成", {
+                        "唯一IP数": ip_stats.get('unique_ips', 0),
+                        "IP总请求数": ip_stats.get('total_ip_requests', 0)
+                    })
+                    
+                    result = {
                         'period': f'{start_date} to {end_date}',
                         'summary': summary,
                         'top_endpoints': top_endpoints,
                         'ip_statistics': ip_stats
                     }
+                    
+                    logger.debug("✅ 统计摘要获取成功", {
+                        "查询天数": days,
+                        "数据完整性": "完整",
+                        "结果状态": "成功"
+                    })
+                    
+                    return result
+                    
             finally:
                 connection.close()
                     
         except Exception as e:
+            logger.error("❌ 获取统计摘要失败", {
+                "查询天数": days,
+                "错误信息": str(e),
+                "错误类型": type(e).__name__,
+                "影响": "统计摘要不可用"
+            })
             return {'error': str(e)}
 
 

{mdbq-4.0.81 → mdbq-4.0.83}/mdbq.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdbq
-Version: 4.0.81
+Version: 4.0.83
 Home-page: https://pypi.org/project/mdbq
 Author: xigua, 
 Author-email: 2587125111@qq.com

{mdbq-4.0.81 → mdbq-4.0.83}/mdbq.egg-info/SOURCES.txt

@@ -29,7 +29,6 @@ mdbq/redis/__init__.py
 mdbq/redis/getredis.py
 mdbq/route/__init__.py
 mdbq/route/analytics.py
-mdbq/route/example.py
 mdbq/route/monitor.py
 mdbq/route/routes.py
 mdbq/selenium/__init__.py

mdbq-4.0.81/mdbq/__version__.py

@@ -1 +0,0 @@
-VERSION = '4.0.81'

mdbq-4.0.81/mdbq/route/example.py

@@ -1,378 +0,0 @@
-"""
-路由监控系统集成示例
-展示如何在现有的Flask应用中集成路由监控功能
-
-重点：批量装饰器应用 - 无需手动为每个函数添加装饰器！
-
-使用方法：
-1. 导入监控模块
-2. 定义需要监控的路由列表
-3. 批量应用装饰器
-4. 可选择性地添加全局监控
-
-"""
-
-# ========================================
-# 方法1：批量装饰器应用（强烈推荐） 
-# ========================================
-
-from monitor import monitor_request, get_request_id, get_statistics_summary
-from routes import register_routes
-
-# 在 dpflask.py 文件末尾添加以下代码：
-
-# 第一步：定义需要监控的路由函数名列表
-MONITORED_ROUTES = [
-    # DeepSeek相关接口
-    'deepseek_request',              # 主要接口
-    'deepseek_public_key',           # 获取公钥接口
-    'deepseek_update',               # 更新日志接口
-    'deepseek_feedback',             # 客户端反馈接口
-    'deepseek_chat_history',         # 加载历史记录接口
-    'deepseek_client_id_save_user_info',     # 存储client id
-    'deepseek_client_id_auth_user_info',     # 校检client id
-    
-    # 生意参谋相关接口
-    'sycm_access_control_info',      # 访问控制信息
-    'sycm_load_userinfo',            # 用户信息加载
-    'sycm_list_database',            # 数据库列表
-    'sycm_list_tables',              # 数据表列表
-    'sycm_view_table',               # 查看表数据
-]
-
-# 第二步：批量应用监控装饰器的函数
-def apply_monitor_to_routes(app_globals, route_names):
-    """
-    为指定的路由函数批量添加监控装饰器
-    
-    优势：
-    - 无需手动修改每个函数
-    - 统一管理监控配置
-    - 避免遗漏或重复
-    - 便于维护
-    """
-    applied_count = 0
-    skipped_count = 0
-    
-    print("🚀 开始批量应用监控装饰器...")
-    
-    for route_name in route_names:
-        if route_name in app_globals and callable(app_globals[route_name]):
-            # 检查是否已经添加过监控装饰器
-            if not hasattr(app_globals[route_name], '_is_monitored'):
-                # 应用监控装饰器
-                app_globals[route_name] = monitor_request(app_globals[route_name])
-                app_globals[route_name]._is_monitored = True
-                applied_count += 1
-                print(f"  ✅ 已为 {route_name} 添加监控")
-            else:
-                skipped_count += 1
-                print(f"  ⚠️  {route_name} 已经有监控装饰器，跳过")
-        else:
-            print(f"  ❌ 未找到函数: {route_name}")
-    
-    print(f"📊 批量装饰器应用完成：")
-    print(f"  - 成功添加: {applied_count} 个")
-    print(f"  - 已存在跳过: {skipped_count} 个")
-    print(f"  - 总计处理: {len(route_names)} 个")
-
-# 第三步：执行批量应用（在 dpflask.py 文件最后添加）
-"""
-# 批量应用监控装饰器
-apply_monitor_to_routes(globals(), MONITORED_ROUTES)
-
-# 注册管理界面路由
-register_routes(app)
-
-print("🎯 路由监控系统初始化完成！")
-"""
-
-# ========================================
-# 方法2：按模式自动应用（更智能）
-# ========================================
-
-def auto_apply_monitor_by_pattern(app_globals, pattern_prefixes=None, exclude_patterns=None):
-    """
-    根据函数名模式自动添加监控装饰器
-    
-    Args:
-        pattern_prefixes: 匹配的函数名前缀，如 ['deepseek_', 'sycm_']
-        exclude_patterns: 排除的模式，如 ['_test', '_internal']
-    """
-    if pattern_prefixes is None:
-        pattern_prefixes = ['deepseek_', 'sycm_', 'api_']
-    
-    if exclude_patterns is None:
-        exclude_patterns = ['_test', '_internal', '_helper', '_debug']
-    
-    applied_count = 0
-    
-    print("🔍 开始自动扫描并应用监控装饰器...")
-    
-    for name, obj in app_globals.items():
-        # 检查是否为函数且符合命名模式
-        if callable(obj) and any(name.startswith(prefix) for prefix in pattern_prefixes):
-            # 检查是否需要排除
-            if any(exclude in name for exclude in exclude_patterns):
-                print(f"  🚫 跳过排除的函数: {name}")
-                continue
-                
-            # 检查是否已经有监控装饰器
-            if not hasattr(obj, '_is_monitored'):
-                app_globals[name] = monitor_request(obj)
-                app_globals[name]._is_monitored = True
-                applied_count += 1
-                print(f"  ✅ 自动为 {name} 添加监控")
-    
-    print(f"🎯 自动扫描完成，为 {applied_count} 个路由添加了监控")
-
-# 使用自动模式的示例：
-"""
-# 自动为所有以 deepseek_ 和 sycm_ 开头的函数添加监控
-auto_apply_monitor_by_pattern(globals(), 
-    pattern_prefixes=['deepseek_', 'sycm_'],
-    exclude_patterns=['_test', '_internal', '_debug']
-)
-"""
-
-# ========================================
-# 方法3：环境感知的监控配置（生产级）
-# ========================================
-
-import os
-
-class MonitorConfig:
-    """监控配置管理类 - 根据环境应用不同的监控策略"""
-    
-    # 核心业务接口（所有环境都监控）
-    CRITICAL_ROUTES = [
-        'deepseek_request',
-        'sycm_list_database',
-        'sycm_view_table',
-    ]
-    
-    # 重要接口（生产和测试环境监控）
-    IMPORTANT_ROUTES = [
-        'deepseek_public_key',
-        'deepseek_chat_history',
-        'sycm_load_userinfo',
-        'sycm_list_tables',
-    ]
-    
-    # 辅助接口（仅生产环境监控）
-    AUXILIARY_ROUTES = [
-        'deepseek_update',
-        'deepseek_feedback',
-        'sycm_access_control_info',
-        'deepseek_client_id_save_user_info',
-        'deepseek_client_id_auth_user_info',
-    ]
-    
-    @classmethod
-    def apply_monitoring(cls, app_globals, environment=None):
-        """
-        根据环境应用相应的监控策略
-        
-        Args:
-            environment: 'production', 'staging', 'development' 或 None（自动检测）
-        """
-        if environment is None:
-            environment = os.getenv('FLASK_ENV', 'development')
-        
-        routes_to_monitor = []
-        
-        # 根据环境确定监控范围
-        if environment == 'production':
-            routes_to_monitor.extend(cls.CRITICAL_ROUTES)
-            routes_to_monitor.extend(cls.IMPORTANT_ROUTES)
-            routes_to_monitor.extend(cls.AUXILIARY_ROUTES)
-            print("🔥 生产环境：启用完整监控")
-            
-        elif environment == 'staging':
-            routes_to_monitor.extend(cls.CRITICAL_ROUTES)
-            routes_to_monitor.extend(cls.IMPORTANT_ROUTES)
-            print("🧪 测试环境：启用重要接口监控")
-            
-        else:  # development
-            routes_to_monitor.extend(cls.CRITICAL_ROUTES)
-            print("🔧 开发环境：仅监控核心接口")
-        
-        # 应用监控
-        apply_monitor_to_routes(app_globals, routes_to_monitor)
-        print(f"📊 {environment} 环境监控配置已应用")
-
-# 环境感知监控的使用示例：
-"""
-# 在 dpflask.py 文件末尾添加：
-
-# 根据环境自动应用监控配置
-MonitorConfig.apply_monitoring(globals())
-
-# 手动指定环境
-# MonitorConfig.apply_monitoring(globals(), 'production')
-
-# 注册管理界面
-register_routes(app)
-"""
-
-# ========================================
-# 方法4：带条件的智能监控（高级用法）
-# ========================================
-
-def conditional_monitor_routes(app_globals, route_conditions):
-    """
-    根据条件应用监控装饰器
-    
-    Args:
-        route_conditions: 字典，格式为 {函数名: 条件函数}
-    """
-    applied_count = 0
-    
-    for route_name, condition_func in route_conditions.items():
-        if route_name in app_globals and callable(app_globals[route_name]):
-            if condition_func():
-                if not hasattr(app_globals[route_name], '_is_monitored'):
-                    app_globals[route_name] = monitor_request(app_globals[route_name])
-                    app_globals[route_name]._is_monitored = True
-                    applied_count += 1
-                    print(f"  ✅ 条件满足，为 {route_name} 添加监控")
-                else:
-                    print(f"  ⚠️  {route_name} 已有监控装饰器")
-            else:
-                print(f"  🚫 条件不满足，跳过 {route_name}")
-    
-    print(f"🎯 条件监控应用完成，处理了 {applied_count} 个路由")
-
-# 条件监控示例：
-"""
-# 定义条件函数
-def is_production():
-    return os.getenv('FLASK_ENV') == 'production'
-
-def is_debug_enabled():
-    return os.getenv('DEBUG', '').lower() == 'true'
-
-# 定义条件监控规则
-CONDITIONAL_ROUTES = {
-    'deepseek_request': lambda: True,  # 总是监控
-    'deepseek_update': is_production,  # 仅生产环境监控
-    'sycm_view_table': is_production,  # 仅生产环境监控
-    'debug_endpoint': is_debug_enabled,  # 仅调试模式监控
-}
-
-# 应用条件监控
-conditional_monitor_routes(globals(), CONDITIONAL_ROUTES)
-"""
-
-# ========================================
-# 完整的集成示例代码
-# ========================================
-
-COMPLETE_INTEGRATION_EXAMPLE = '''
-# ================================================
-# 在 dpflask.py 文件末尾添加以下完整代码
-# ================================================
-
-# 1. 导入监控模块
-from route.monitor import monitor_request, get_request_id, get_statistics_summary
-from route.routes import register_routes
-import os
-
-# 2. 批量装饰器应用函数
-def apply_monitor_to_routes(app_globals, route_names):
-    """批量为路由函数添加监控装饰器"""
-    applied_count = 0
-    for route_name in route_names:
-        if route_name in app_globals and callable(app_globals[route_name]):
-            if not hasattr(app_globals[route_name], '_is_monitored'):
-                app_globals[route_name] = monitor_request(app_globals[route_name])
-                app_globals[route_name]._is_monitored = True
-                applied_count += 1
-                print(f"✅ 已为 {route_name} 添加监控")
-    print(f"🎯 总计为 {applied_count} 个路由添加了监控")
-
-# 3. 定义需要监控的路由列表
-MONITORED_ROUTES = [
-    'deepseek_request',
-    'deepseek_public_key', 
-    'deepseek_chat_history',
-    'sycm_list_database',
-    'sycm_view_table',
-    # 根据需要添加更多路由
-]
-
-# 4. 应用监控
-print("🚀 正在初始化路由监控系统...")
-apply_monitor_to_routes(globals(), MONITORED_ROUTES)
-
-# 5. 注册管理界面
-register_routes(app)
-
-# 6. 完成提示
-current_env = os.getenv('FLASK_ENV', 'development')
-print(f"✨ 路由监控系统初始化完成！")
-print(f"🔧 当前环境: {current_env}")
-print(f"📊 管理界面: http://localhost:5000/admin/monitor/dashboard")
-
-# 可选：添加一些简单的管理接口
-@app.route('/admin/monitor/stats', methods=['GET'])
-def get_monitor_stats():
-    """获取监控统计信息"""
-    try:
-        days = request.args.get('days', 7, type=int)
-        stats = get_statistics_summary(days)
-        return jsonify({
-            'code': 0,
-            'status': 'success',
-            'data': stats
-        })
-    except Exception as e:
-        return jsonify({
-            'code': 500,
-            'status': 'error',
-            'message': str(e)
-        }), 500
-'''
-
-# ========================================
-# 总结说明
-# ========================================
-
-print("""
-🎯 批量装饰器的核心优势：
-
-1. ✅ 无需手动修改每个函数定义
-   - 原始函数保持不变
-   - 所有装饰器在一个地方统一管理
-
-2. ✅ 灵活的监控策略
-   - 可以根据环境启用不同的监控范围
-   - 支持条件性监控
-   - 便于测试和调试
-
-3. ✅ 维护性强
-   - 新增监控只需在列表中添加函数名
-   - 移除监控只需从列表中删除
-   - 避免在代码中到处添加装饰器
-
-4. ✅ 性能优化
-   - 避免重复装饰
-   - 自动检测已有装饰器
-   - 支持条件性启用
-
-📋 推荐使用方式：
-- 开发阶段：使用方法1（明确的函数名列表）
-- 生产环境：使用方法3（环境感知配置）
-- 大型项目：结合多种方法，分模块管理
-
-🔧 集成步骤：
-1. 复制 COMPLETE_INTEGRATION_EXAMPLE 中的代码
-2. 添加到 dpflask.py 文件末尾
-3. 根据需要调整 MONITORED_ROUTES 列表
-4. 重启应用即可生效
-
-这样就实现了批量添加监控装饰器，无需手动修改每个函数！
-""")
-
-if __name__ == "__main__":
-    print(COMPLETE_INTEGRATION_EXAMPLE)