mdbq 4.2.14__py3-none-any.whl → 4.2.15__py3-none-any.whl

mdbq/__version__.py

@@ -1 +1 @@
-VERSION = '4.2.14'
+VERSION = '4.2.15'

mdbq/route/monitor.py

@@ -68,7 +68,6 @@ class RouteMonitor:
             self.queue_name = "api_monitor:tasks"
         
         # 线程锁（用于保护统计数据）
-        import threading
         self._stats_lock = threading.Lock()
         
         # 统计信息
@@ -173,9 +172,9 @@ class RouteMonitor:
                             `请求id` VARCHAR(64) NOT NULL COMMENT '请求唯一标识（用于追踪）',
                             `请求时间` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) COMMENT '请求时间，精确到毫秒',
                             `请求方法` VARCHAR(10) NOT NULL COMMENT 'HTTP 方法（GET/POST/PUT/DELETE等）',
-                            `接口路径` VARCHAR(500) NOT NULL COMMENT 'API 接口路径',
+                            `路由地址` VARCHAR(500) NOT NULL COMMENT 'API 路由地址',
                             `客户端ip` VARCHAR(45) NOT NULL COMMENT '客户端 ip 地址（支持 IPv6）',
-                            `响应状态码` SMALLINT COMMENT 'HTTP 响应状态码',
+                            `状态码` SMALLINT COMMENT 'HTTP 状态码',
                             `响应耗时` DECIMAL(10,3) COMMENT '请求处理耗时（毫秒）',
                             `用户标识` VARCHAR(64) COMMENT '用户id或标识（如有）',
                             `用户代理` VARCHAR(500) COMMENT '浏览器 User-Agent（精简版）',
@@ -186,11 +185,11 @@ class RouteMonitor:
                             
                             UNIQUE KEY `uk_请求id` (`请求id`),
                             INDEX `idx_请求时间` (`请求时间`),
-                            INDEX `idx_接口路径` (`接口路径`(191)),
+                            INDEX `idx_路由地址` (`路由地址`(191)),
                             INDEX `idx_客户端ip` (`客户端ip`),
-                            INDEX `idx_响应状态码` (`响应状态码`),
+                            INDEX `idx_状态码` (`状态码`),
                             INDEX `idx_用户标识` (`用户标识`),
-                            INDEX `idx_时间_接口` (`请求时间`, `接口路径`(191))
+                            INDEX `idx_时间_接口` (`请求时间`, `路由地址`(191))
                         ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci 
                         COMMENT='API 访问日志表 - 记录每次请求的核心信息'
                         ROW_FORMAT=COMPRESSED;
@@ -203,7 +202,7 @@ class RouteMonitor:
                             `id` BIGINT AUTO_INCREMENT PRIMARY KEY COMMENT '主键，自增id',
                             `统计日期` DATE NOT NULL COMMENT '统计日期',
                             `统计小时` TINYINT NOT NULL COMMENT '统计小时（0-23）',
-                            `接口路径` VARCHAR(500) NOT NULL COMMENT 'API 接口路径',
+                            `路由地址` VARCHAR(500) NOT NULL COMMENT 'API 路由地址',
                             `请求方法` VARCHAR(10) NOT NULL COMMENT 'HTTP 请求方法',
                             `请求总数` INT UNSIGNED DEFAULT 0 COMMENT '总请求次数',
                             `成功次数` INT UNSIGNED DEFAULT 0 COMMENT '成功响应次数（状态码 < 400）',
@@ -215,10 +214,10 @@ class RouteMonitor:
                             `创建时间` TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '记录创建时间',
                             `更新时间` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '记录更新时间',
                             
-                            UNIQUE KEY `uk_日期_小时_接口_方法` (`统计日期`, `统计小时`, `接口路径`(191), `请求方法`),
+                            UNIQUE KEY `uk_日期_小时_接口_方法` (`统计日期`, `统计小时`, `路由地址`(191), `请求方法`),
                             INDEX `idx_统计日期` (`统计日期`),
-                            INDEX `idx_接口路径` (`接口路径`(191)),
-                            INDEX `idx_日期_接口` (`统计日期`, `接口路径`(191))
+                            INDEX `idx_路由地址` (`路由地址`(191)),
+                            INDEX `idx_日期_接口` (`统计日期`, `路由地址`(191))
                         ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci 
                         COMMENT='API 接口统计表 - 按小时汇总的接口性能数据';
                     """)
@@ -487,7 +486,7 @@ class RouteMonitor:
             '请求id': request_id,
             '请求时间': datetime.now(),
             '请求方法': request.method,
-            '接口路径': request.endpoint or request.path,
+            '路由地址': request.endpoint or request.path,
             '客户端ip': client_ip,
             '用户标识': user_id,
             '用户代理': user_agent,
@@ -521,8 +520,8 @@ class RouteMonitor:
                     # 插入请求日志
                     sql = """
                         INSERT INTO `api_访问日志` (
-                            `请求id`, `请求时间`, `请求方法`, `接口路径`, `客户端ip`,
-                            `响应状态码`, `响应耗时`, `用户标识`, `用户代理`, `请求参数`, `错误信息`
+                            `请求id`, `请求时间`, `请求方法`, `路由地址`, `客户端ip`,
+                            `状态码`, `响应耗时`, `用户标识`, `用户代理`, `请求参数`, `错误信息`
                         ) VALUES (
                             %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
                         )
@@ -532,9 +531,9 @@ class RouteMonitor:
                         request_data.get('请求id'),
                         request_data.get('请求时间'),
                         request_data.get('请求方法'),
-                        request_data.get('接口路径'),
+                        request_data.get('路由地址'),
                         request_data.get('客户端ip'),
-                        request_data.get('响应状态码'),
+                        request_data.get('状态码'),
                         request_data.get('响应耗时'),
                         request_data.get('用户标识'),
                         request_data.get('用户代理'),
@@ -575,7 +574,7 @@ class RouteMonitor:
                     now = datetime.now()  # 用于IP统计的最后访问时间
                     
                     # 判断是否成功（状态码 < 400）
-                    status_code = request_data.get('响应状态码', 500)
+                    status_code = request_data.get('状态码', 500)
                     is_success = 1 if status_code < 400 else 0
                     is_error = 1 if status_code >= 400 else 0
                     response_time = request_data.get('响应耗时', 0)
@@ -583,7 +582,7 @@ class RouteMonitor:
                     # 1. 更新接口统计表
                     cursor.execute("""
                         INSERT INTO `api_接口统计` (
-                            `统计日期`, `统计小时`, `接口路径`, `请求方法`,
+                            `统计日期`, `统计小时`, `路由地址`, `请求方法`,
                             `请求总数`, `成功次数`, `失败次数`,
                             `平均耗时`, `最大耗时`, `最小耗时`
                         ) VALUES (
@@ -604,7 +603,7 @@ class RouteMonitor:
                         )
                     """, (
                         date, hour, 
-                        request_data.get('接口路径', ''),
+                        request_data.get('路由地址', ''),
                         request_data.get('请求方法', ''),
                         is_success, is_error,
                         response_time, response_time, response_time,
@@ -699,7 +698,7 @@ class RouteMonitor:
                 end_time = time.time()
                 process_time = round((end_time - start_time) * 1000, 3)  # 毫秒
                 
-                # 获取响应状态码
+                # 获取状态码
                 response_status = 200
                 if hasattr(response, 'status_code'):
                     response_status = response.status_code
@@ -715,7 +714,7 @@ class RouteMonitor:
                 
                 # 更新响应数据
                 response_data = {
-                    '响应状态码': response_status,
+                    '状态码': response_status,
                     '响应耗时': process_time,
                 }
                 
@@ -745,7 +744,7 @@ class RouteMonitor:
                 
                 # 构建错误数据
                 error_data = {
-                    '响应状态码': 500,
+                    '状态码': 500,
                     '响应耗时': process_time,
                     '错误信息': f"{type(e).__name__}: {str(e)}"
                 }
@@ -807,7 +806,7 @@ class RouteMonitor:
                             SUM(成功次数) as 成功次数,
                             SUM(失败次数) as 失败次数,
                             ROUND(AVG(平均耗时), 2) as 平均耗时,
-                            COUNT(DISTINCT 接口路径) as 接口数量
+                            COUNT(DISTINCT 路由地址) as 接口数量
                         FROM api_接口统计
                         WHERE 统计日期 BETWEEN %s AND %s
                     """, (start_date, end_date))
@@ -817,12 +816,12 @@ class RouteMonitor:
                     # 2. 热门接口 TOP 10
                     cursor.execute("""
                         SELECT 
-                            接口路径,
+                            路由地址,
                             SUM(请求总数) as 请求次数,
                             ROUND(AVG(平均耗时), 2) as 平均耗时
                         FROM api_接口统计
                         WHERE 统计日期 BETWEEN %s AND %s
-                        GROUP BY 接口路径
+                        GROUP BY 路由地址
                         ORDER BY 请求次数 DESC
                         LIMIT 10
                     """, (start_date, end_date))
@@ -843,12 +842,12 @@ class RouteMonitor:
                     # 4. 性能最慢的接口 TOP 5
                     cursor.execute("""
                         SELECT 
-                            接口路径,
+                            路由地址,
                             ROUND(MAX(最大耗时), 2) as 最大耗时,
                             ROUND(AVG(平均耗时), 2) as 平均耗时
                         FROM api_接口统计
                         WHERE 统计日期 BETWEEN %s AND %s
-                        GROUP BY 接口路径
+                        GROUP BY 路由地址
                         ORDER BY 最大耗时 DESC
                         LIMIT 5
                     """, (start_date, end_date))

{mdbq-4.2.14.dist-info → mdbq-4.2.15.dist-info}/METADATA

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

{mdbq-4.2.14.dist-info → mdbq-4.2.15.dist-info}/RECORD

@@ -1,5 +1,5 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
-mdbq/__version__.py,sha256=cr0O8LE2OkusCNWIOsW9RXnz5146D47fEK2fLTbqnUU,18
+mdbq/__version__.py,sha256=JI02MOsH9qq5B-OU52C1oxtIpP6VHv0R96xLUqhnZoQ,18
 mdbq/auth/__init__.py,sha256=pnPMAt63sh1B6kEvmutUuro46zVf2v2YDAG7q-jV_To,24
 mdbq/auth/auth_backend.py,sha256=iLN7AqiSq7fQgFtNtge_TIlVOR1hrCSZXH6oId6uGX4,116924
 mdbq/auth/crypto.py,sha256=M0i4dRljJuE30WH_13ythA2QGKPXZm6TgpnYp6aHOzw,17431
@@ -29,13 +29,12 @@ mdbq/redis/__init__.py,sha256=YtgBlVSMDphtpwYX248wGge1x-Ex_mMufz4-8W0XRmA,12
 mdbq/redis/getredis.py,sha256=vdg7YQEjhoMp5QzxygNGx5DQKRnePrcwPYgUrDypA6g,23672
 mdbq/redis/redis_cache.py,sha256=JWarX_l7LvdKyxtUNPANAqd-y20Jg5uqmllCbT-fyv8,45752
 mdbq/route/__init__.py,sha256=BT_dAY7V-U2o72bevq1B9Mq9QA7GodwtkxyLNdGaoE8,22
-mdbq/route/analytics.py,sha256=dngj5hVwKddEUy59nSYbOoJ9C7OVrtCmCkvW6Uj9RYM,28097
-mdbq/route/monitor.py,sha256=mY55Y2m0c_1fmC2A6GNWvkSbW3OsXPs3jOI-9HHTYMw,40738
+mdbq/route/monitor.py,sha256=qMgIMD1knYQWOoAG0VgbPRE8Gcd673JnvMZkSsZlDGk,40653
 mdbq/route/routes.py,sha256=QVGfTvDgu0CpcKCvk1ra74H8uojgqTLUav1fnVAqLEA,29433
 mdbq/selenium/__init__.py,sha256=AKzeEceqZyvqn2dEDoJSzDQnbuENkJSHAlbHAD0u0ZI,10
 mdbq/selenium/get_driver.py,sha256=1NTlVUE6QsyjTrVVVqTO2LOnYf578ccFWlWnvIXGtic,20903
 mdbq/spider/__init__.py,sha256=RBMFXGy_jd1HXZhngB2T2XTvJqki8P_Fr-pBcwijnew,18
-mdbq-4.2.14.dist-info/METADATA,sha256=aNX05FUtA3v3lVAh0N2n7q8Wp-usLo5yXiL4H5qN9Lc,364
-mdbq-4.2.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mdbq-4.2.14.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-4.2.14.dist-info/RECORD,,
+mdbq-4.2.15.dist-info/METADATA,sha256=gbbF14QD1DHVWxAdk4DK2ljrzRkhUZwZRqB8HGs1do0,364
+mdbq-4.2.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mdbq-4.2.15.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-4.2.15.dist-info/RECORD,,

mdbq/route/analytics.py

@@ -1,619 +0,0 @@
-"""
-数据分析工具
-
-主要功能：
-1. 实时监控数据查询
-2. 访问趋势分析
-3. 性能分析报告
-4. 异常检测和告警
-5. 用户行为分析
-
-"""
-
-import os
-import json
-import pymysql
-from datetime import datetime, timedelta
-from typing import Dict, Any, List, Optional
-from dbutils.pooled_db import PooledDB
-from mdbq.myconf import myconf
-
-
-class MonitorAnalytics:
-    """监控数据分析类"""
-    
-    def __init__(self, database='api_monitor_logs'):
-        """初始化分析工具"""
-        self.database = database
-        self.init_database_pool()
-    
-    def init_database_pool(self):
-        """初始化数据库连接池"""
-        dir_path = os.path.expanduser("~")
-        config_file = os.path.join(dir_path, 'spd.txt')
-        parser = myconf.ConfigParser()
-        
-        host, port, username, password = parser.get_section_values(
-            file_path=config_file,
-            section='mysql',
-            keys=['host', 'port', 'username', 'password'],
-        )
-        
-        self.pool = PooledDB(
-            creator=pymysql,
-            maxconnections=5,  # 增加连接数避免冲突
-            mincached=2,  # 增加最小缓存连接数
-            maxcached=5,  # 增加最大缓存连接数
-            blocking=True,
-            host=host,
-            port=int(port),
-            user=username,
-            password=password,
-            database=self.database,
-            ping=1,
-            charset='utf8mb4',
-            cursorclass=pymysql.cursors.DictCursor,
-            # 添加连接超时设置
-            connect_timeout=10,
-            read_timeout=30,
-            write_timeout=30
-        )
-    
-    def get_realtime_metrics(self) -> Dict[str, Any]:
-        """获取实时监控指标"""
-        try:
-            connection = self.pool.connection()
-            try:
-                with connection.cursor() as cursor:
-                    now = datetime.now()
-                    last_hour = now - timedelta(hours=1)
-                    last_day = now - timedelta(days=1)
-                    
-                    # 最近1小时的请求统计
-                    cursor.execute("""
-                        SELECT 
-                            COUNT(*) as requests_last_hour,
-                            COUNT(DISTINCT client_ip) as unique_ips_last_hour,
-                            AVG(process_time) as avg_response_time,
-                            MAX(process_time) as max_response_time,
-                            SUM(CASE WHEN response_status >= 400 THEN 1 ELSE 0 END) as error_count,
-                            SUM(CASE WHEN response_status >= 400 THEN 1 ELSE 0 END) / COUNT(*) * 100 as error_rate,
-                            SUM(CASE WHEN is_bot = 1 THEN 1 ELSE 0 END) as bot_requests,
-                            SUM(CASE WHEN is_mobile = 1 THEN 1 ELSE 0 END) as mobile_requests
-                        FROM api_request_logs 
-                        WHERE timestamp >= %s
-                    """, (last_hour,))
-                    
-                    hourly_stats = cursor.fetchone() or {}
-                    
-                    # 最近24小时趋势对比
-                    cursor.execute("""
-                        SELECT 
-                            COUNT(*) as requests_last_day,
-                            COUNT(DISTINCT client_ip) as unique_ips_last_day,
-                            AVG(process_time) as avg_response_time_day
-                        FROM api_request_logs 
-                        WHERE timestamp >= %s
-                    """, (last_day,))
-                    
-                    daily_stats = cursor.fetchone() or {}
-                    
-                    # 热门端点（最近1小时）
-                    cursor.execute("""
-                        SELECT endpoint, COUNT(*) as request_count,
-                               AVG(process_time) as avg_time
-                        FROM api_request_logs 
-                        WHERE timestamp >= %s AND endpoint IS NOT NULL
-                        GROUP BY endpoint
-                        ORDER BY request_count DESC
-                        LIMIT 5
-                    """, (last_hour,))
-                    
-                    top_endpoints = cursor.fetchall()
-                    
-                    # 慢查询（最近1小时）
-                    cursor.execute("""
-                        SELECT endpoint, process_time, client_ip, timestamp
-                        FROM api_request_logs 
-                        WHERE timestamp >= %s AND process_time > 5000
-                        ORDER BY process_time DESC
-                        LIMIT 10
-                    """, (last_hour,))
-                    
-                    slow_requests = cursor.fetchall()
-                    
-                    # 错误请求（最近1小时）
-                    cursor.execute("""
-                        SELECT endpoint, response_status, COUNT(*) as error_count
-                        FROM api_request_logs 
-                        WHERE timestamp >= %s AND response_status >= 400
-                        GROUP BY endpoint, response_status
-                        ORDER BY error_count DESC
-                        LIMIT 10
-                    """, (last_hour,))
-                    
-                    error_requests = cursor.fetchall()
-                    
-                    return {
-                        'realtime_metrics': {
-                            'requests_per_hour': hourly_stats.get('requests_last_hour', 0),
-                            'requests_per_day': daily_stats.get('requests_last_day', 0),
-                            'unique_ips_hour': hourly_stats.get('unique_ips_last_hour', 0),
-                            'unique_ips_day': daily_stats.get('unique_ips_last_day', 0),
-                            'avg_response_time': round(hourly_stats.get('avg_response_time', 0) or 0, 2),
-                            'max_response_time': round(hourly_stats.get('max_response_time', 0) or 0, 2),
-                            'error_rate': round(hourly_stats.get('error_rate', 0) or 0, 2),
-                            'error_count': hourly_stats.get('error_count', 0),
-                            'bot_requests': hourly_stats.get('bot_requests', 0),
-                            'mobile_requests': hourly_stats.get('mobile_requests', 0)
-                        },
-                        'top_endpoints': top_endpoints,
-                        'slow_requests': slow_requests,
-                        'error_requests': error_requests,
-                        'timestamp': now.isoformat()
-                    }
-            finally:
-                connection.close()
-                    
-        except Exception as e:
-            return {'error': str(e)}
-    
-    def get_traffic_trend(self, days: int = 7) -> Dict[str, Any]:
-        """获取流量趋势分析"""
-        try:
-            connection = self.pool.connection()
-            try:
-                with connection.cursor() as cursor:
-                    end_date = datetime.now().date()
-                    start_date = end_date - timedelta(days=days)
-                    
-                    # 按小时统计（最近7天）
-                    cursor.execute("""
-                        SELECT 
-                            DATE(timestamp) as date,
-                            HOUR(timestamp) as hour,
-                            COUNT(*) as requests,
-                            COUNT(DISTINCT client_ip) as unique_ips,
-                            AVG(process_time) as avg_response_time,
-                            SUM(CASE WHEN response_status >= 400 THEN 1 ELSE 0 END) as errors
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) BETWEEN %s AND %s
-                        GROUP BY DATE(timestamp), HOUR(timestamp)
-                        ORDER BY date, hour
-                    """, (start_date, end_date))
-                    
-                    hourly_data = cursor.fetchall()
-                    
-                    # 按天统计
-                    cursor.execute("""
-                        SELECT 
-                            DATE(timestamp) as date,
-                            COUNT(*) as requests,
-                            COUNT(DISTINCT client_ip) as unique_ips,
-                            AVG(process_time) as avg_response_time,
-                            SUM(CASE WHEN response_status >= 400 THEN 1 ELSE 0 END) as errors,
-                            SUM(CASE WHEN is_bot = 1 THEN 1 ELSE 0 END) as bot_requests,
-                            SUM(CASE WHEN is_mobile = 1 THEN 1 ELSE 0 END) as mobile_requests
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) BETWEEN %s AND %s
-                        GROUP BY DATE(timestamp)
-                        ORDER BY date
-                    """, (start_date, end_date))
-                    
-                    daily_data = cursor.fetchall()
-                    
-                    # 周中模式分析
-                    cursor.execute("""
-                        SELECT 
-                            DAYOFWEEK(timestamp) as day_of_week,
-                            DAYNAME(timestamp) as day_name,
-                            COUNT(*) as total_requests,
-                            AVG(process_time) as avg_response_time
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) BETWEEN %s AND %s
-                        GROUP BY DAYOFWEEK(timestamp), DAYNAME(timestamp)
-                        ORDER BY day_of_week
-                    """, (start_date, end_date))
-                    
-                    weekly_pattern = cursor.fetchall()
-                    
-                    # 小时模式分析
-                    cursor.execute("""
-                        SELECT 
-                            HOUR(timestamp) as hour,
-                            COUNT(*) as total_requests,
-                            AVG(process_time) as avg_response_time
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) BETWEEN %s AND %s
-                        GROUP BY HOUR(timestamp)
-                        ORDER BY hour
-                    """, (start_date, end_date))
-                    
-                    hourly_pattern = cursor.fetchall()
-                    
-                    return {
-                        'period': f'{start_date} to {end_date}',
-                        'hourly_data': hourly_data,
-                        'daily_data': daily_data,
-                        'weekly_pattern': weekly_pattern,
-                        'hourly_pattern': hourly_pattern
-                    }
-            finally:
-                connection.close()
-                    
-        except Exception as e:
-            return {'error': str(e)}
-    
-    def get_endpoint_analysis(self, days: int = 7) -> Dict[str, Any]:
-        """获取端点性能分析"""
-        try:
-            connection = self.pool.connection()
-            try:
-                with connection.cursor() as cursor:
-                    end_date = datetime.now().date()
-                    start_date = end_date - timedelta(days=days)
-                    
-                    # 端点性能统计
-                    cursor.execute("""
-                        SELECT 
-                            endpoint,
-                            COUNT(*) as total_requests,
-                            AVG(process_time) as avg_response_time,
-                            MIN(process_time) as min_response_time,
-                            MAX(process_time) as max_response_time,
-                            STDDEV(process_time) as response_time_stddev,
-                            COUNT(DISTINCT client_ip) as unique_users,
-                            SUM(CASE WHEN response_status >= 400 THEN 1 ELSE 0 END) as error_count,
-                            SUM(CASE WHEN response_status >= 400 THEN 1 ELSE 0 END) / COUNT(*) * 100 as error_rate,
-                            SUM(request_size) as total_request_size,
-                            SUM(response_size) as total_response_size
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) BETWEEN %s AND %s
-                        AND endpoint IS NOT NULL
-                        GROUP BY endpoint
-                        ORDER BY total_requests DESC
-                    """, (start_date, end_date))
-                    
-                    endpoint_stats = cursor.fetchall()
-                    
-                    # 最慢的端点
-                    slowest_endpoints = sorted(
-                        [ep for ep in endpoint_stats if ep['avg_response_time']],
-                        key=lambda x: x['avg_response_time'] or 0,
-                        reverse=True
-                    )[:10]
-                    
-                    # 错误率最高的端点
-                    error_prone_endpoints = sorted(
-                        [ep for ep in endpoint_stats if (ep['error_rate'] or 0) > 0],
-                        key=lambda x: x['error_rate'] or 0,
-                        reverse=True
-                    )[:10]
-                    
-                    # 最热门的端点
-                    popular_endpoints = endpoint_stats[:10]
-                    
-                    return {
-                        'period': f'{start_date} to {end_date}',
-                        'all_endpoints': endpoint_stats,
-                        'slowest_endpoints': slowest_endpoints,
-                        'error_prone_endpoints': error_prone_endpoints,
-                        'popular_endpoints': popular_endpoints
-                    }
-            finally:
-                connection.close()
-                    
-        except Exception as e:
-            return {'error': str(e)}
-    
-    def get_user_behavior_analysis(self, days: int = 7) -> Dict[str, Any]:
-        """获取用户行为分析"""
-        try:
-            connection = self.pool.connection()
-            try:
-                with connection.cursor() as cursor:
-                    end_date = datetime.now().date()
-                    start_date = end_date - timedelta(days=days)
-                    
-                    # IP访问模式分析
-                    cursor.execute("""
-                        SELECT 
-                            client_ip,
-                            COUNT(*) as total_requests,
-                            COUNT(DISTINCT endpoint) as unique_endpoints,
-                            COUNT(DISTINCT DATE(timestamp)) as active_days,
-                            MIN(timestamp) as first_access,
-                            MAX(timestamp) as last_access,
-                            AVG(process_time) as avg_response_time,
-                            SUM(CASE WHEN response_status >= 400 THEN 1 ELSE 0 END) as errors,
-                            SUM(CASE WHEN is_bot = 1 THEN 1 ELSE 0 END) as bot_requests,
-                            user_agent
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) BETWEEN %s AND %s
-                        GROUP BY client_ip, user_agent
-                        HAVING total_requests >= 10
-                        ORDER BY total_requests DESC
-                        LIMIT 50
-                    """, (start_date, end_date))
-                    
-                    ip_analysis = cursor.fetchall()
-                    
-                    # 设备类型统计
-                    cursor.execute("""
-                        SELECT 
-                            browser_name,
-                            os_name,
-                            COUNT(*) as request_count,
-                            COUNT(DISTINCT client_ip) as unique_users
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) BETWEEN %s AND %s
-                        AND browser_name != 'Unknown'
-                        GROUP BY browser_name, os_name
-                        ORDER BY request_count DESC
-                    """, (start_date, end_date))
-                    
-                    device_stats = cursor.fetchall()
-                    
-                    # 可疑活动检测
-                    cursor.execute("""
-                        SELECT 
-                            client_ip,
-                            COUNT(*) as requests_per_hour,
-                            COUNT(DISTINCT endpoint) as endpoints_accessed,
-                            SUM(CASE WHEN response_status = 404 THEN 1 ELSE 0 END) as not_found_errors,
-                            SUM(CASE WHEN response_status = 403 THEN 1 ELSE 0 END) as forbidden_errors,
-                            MAX(is_bot) as is_bot
-                        FROM api_request_logs 
-                        WHERE timestamp >= %s
-                        GROUP BY client_ip
-                        HAVING requests_per_hour > 100 
-                        OR not_found_errors > 10 
-                        OR forbidden_errors > 5
-                        ORDER BY requests_per_hour DESC
-                    """, (datetime.now() - timedelta(hours=1),))
-                    
-                    suspicious_activity = cursor.fetchall()
-                    
-                    # 用户会话分析
-                    cursor.execute("""
-                        SELECT 
-                            session_id,
-                            COUNT(*) as session_requests,
-                            COUNT(DISTINCT endpoint) as endpoints_in_session,
-                            TIMESTAMPDIFF(MINUTE, MIN(timestamp), MAX(timestamp)) as session_duration,
-                            MIN(timestamp) as session_start,
-                            MAX(timestamp) as session_end
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) BETWEEN %s AND %s
-                        AND session_id IS NOT NULL
-                        GROUP BY session_id
-                        HAVING session_requests >= 5
-                        ORDER BY session_duration DESC
-                        LIMIT 20
-                    """, (start_date, end_date))
-                    
-                    session_analysis = cursor.fetchall()
-                    
-                    return {
-                        'period': f'{start_date} to {end_date}',
-                        'ip_analysis': ip_analysis,
-                        'device_statistics': device_stats,
-                        'suspicious_activity': suspicious_activity,
-                        'session_analysis': session_analysis
-                    }
-            finally:
-                connection.close()
-                    
-        except Exception as e:
-            return {'error': str(e)}
-    
-    def get_performance_alerts(self) -> Dict[str, Any]:
-        """获取性能告警信息"""
-        try:
-            connection = self.pool.connection()
-            try:
-                with connection.cursor() as cursor:
-                    now = datetime.now()
-                    last_hour = now - timedelta(hours=1)
-                    
-                    alerts = []
-                    
-                    # 检查响应时间异常
-                    cursor.execute("""
-                        SELECT endpoint, AVG(process_time) as avg_time
-                        FROM api_request_logs 
-                        WHERE timestamp >= %s AND process_time IS NOT NULL
-                        GROUP BY endpoint
-                        HAVING avg_time > 3000
-                        ORDER BY avg_time DESC
-                    """, (last_hour,))
-                    
-                    slow_endpoints = cursor.fetchall()
-                    for endpoint in slow_endpoints:
-                        alerts.append({
-                            'type': 'SLOW_RESPONSE',
-                            'severity': 'HIGH' if (endpoint['avg_time'] or 0) > 5000 else 'MEDIUM',
-                            'message': f"端点 {endpoint['endpoint']} 平均响应时间 {endpoint['avg_time']:.0f}ms",
-                            'timestamp': now.isoformat()
-                        })
-                    
-                    # 检查错误率异常
-                    cursor.execute("""
-                        SELECT 
-                            endpoint,
-                            COUNT(*) as total,
-                            SUM(CASE WHEN response_status >= 400 THEN 1 ELSE 0 END) as errors,
-                            SUM(CASE WHEN response_status >= 400 THEN 1 ELSE 0 END) / COUNT(*) * 100 as error_rate
-                        FROM api_request_logs 
-                        WHERE timestamp >= %s
-                        GROUP BY endpoint
-                        HAVING total >= 10 AND error_rate > 10
-                        ORDER BY error_rate DESC
-                    """, (last_hour,))
-                    
-                    error_endpoints = cursor.fetchall()
-                    for endpoint in error_endpoints:
-                        alerts.append({
-                            'type': 'HIGH_ERROR_RATE',
-                            'severity': 'HIGH' if (endpoint['error_rate'] or 0) > 20 else 'MEDIUM',
-                            'message': f"端点 {endpoint['endpoint']} 错误率 {endpoint['error_rate']:.1f}%",
-                            'timestamp': now.isoformat()
-                        })
-                    
-                    # 检查异常流量
-                    cursor.execute("""
-                        SELECT 
-                            client_ip,
-                            COUNT(*) as request_count
-                        FROM api_request_logs 
-                        WHERE timestamp >= %s
-                        GROUP BY client_ip
-                        HAVING request_count > 500
-                        ORDER BY request_count DESC
-                    """, (last_hour,))
-                    
-                    high_traffic_ips = cursor.fetchall()
-                    for ip_data in high_traffic_ips:
-                        alerts.append({
-                            'type': 'HIGH_TRAFFIC',
-                            'severity': 'MEDIUM',
-                            'message': f"IP {ip_data['client_ip']} 请求量异常: {ip_data['request_count']} 次/小时",
-                            'timestamp': now.isoformat()
-                        })
-                    
-                    # 检查系统整体负载
-                    cursor.execute("""
-                        SELECT COUNT(*) as total_requests
-                        FROM api_request_logs 
-                        WHERE timestamp >= %s
-                    """, (last_hour,))
-                    
-                    total_requests = cursor.fetchone()['total_requests']
-                    if total_requests > 10000:  # 每小时超过1万请求
-                        alerts.append({
-                            'type': 'HIGH_SYSTEM_LOAD',
-                            'severity': 'HIGH',
-                            'message': f"系统负载异常: {total_requests} 请求/小时",
-                            'timestamp': now.isoformat()
-                        })
-                    
-                    return {
-                        'alerts': alerts,
-                        'alert_count': len(alerts),
-                        'high_severity_count': len([a for a in alerts if a['severity'] == 'HIGH']),
-                        'timestamp': now.isoformat()
-                    }
-            finally:
-                connection.close()
-                    
-        except Exception as e:
-            return {'error': str(e)}
-    
-    def generate_daily_report(self, target_date: datetime = None) -> Dict[str, Any]:
-        """生成日报告"""
-        if target_date is None:
-            target_date = datetime.now().date() - timedelta(days=1)
-        
-        try:
-            connection = self.pool.connection()
-            try:
-                with connection.cursor() as cursor:
-                    # 整体统计
-                    cursor.execute("""
-                        SELECT 
-                            COUNT(*) as total_requests,
-                            COUNT(DISTINCT client_ip) as unique_ips,
-                            COUNT(DISTINCT endpoint) as unique_endpoints,
-                            AVG(process_time) as avg_response_time,
-                            MAX(process_time) as max_response_time,
-                            SUM(CASE WHEN response_status >= 400 THEN 1 ELSE 0 END) as total_errors,
-                            SUM(CASE WHEN response_status >= 400 THEN 1 ELSE 0 END) / COUNT(*) * 100 as error_rate,
-                            SUM(CASE WHEN is_bot = 1 THEN 1 ELSE 0 END) as bot_requests,
-                            SUM(CASE WHEN is_mobile = 1 THEN 1 ELSE 0 END) as mobile_requests,
-                            SUM(request_size) as total_request_size,
-                            SUM(response_size) as total_response_size
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) = %s
-                    """, (target_date,))
-                    
-                    daily_summary = cursor.fetchone()
-                    
-                    # 热门端点
-                    cursor.execute("""
-                        SELECT endpoint, COUNT(*) as requests, AVG(process_time) as avg_time
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) = %s
-                        GROUP BY endpoint
-                        ORDER BY requests DESC
-                        LIMIT 10
-                    """, (target_date,))
-                    
-                    top_endpoints = cursor.fetchall()
-                    
-                    # 错误统计
-                    cursor.execute("""
-                        SELECT response_status, COUNT(*) as count
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) = %s AND response_status >= 400
-                        GROUP BY response_status
-                        ORDER BY count DESC
-                    """, (target_date,))
-                    
-                    error_breakdown = cursor.fetchall()
-                    
-                    # 流量分布（按小时）
-                    cursor.execute("""
-                        SELECT 
-                            HOUR(timestamp) as hour,
-                            COUNT(*) as requests,
-                            AVG(process_time) as avg_time
-                        FROM api_request_logs 
-                        WHERE DATE(timestamp) = %s
-                        GROUP BY HOUR(timestamp)
-                        ORDER BY hour
-                    """, (target_date,))
-                    
-                    hourly_distribution = cursor.fetchall()
-                    
-                    return {
-                        'date': target_date.isoformat(),
-                        'summary': daily_summary,
-                        'top_endpoints': top_endpoints,
-                        'error_breakdown': error_breakdown,
-                        'hourly_distribution': hourly_distribution,
-                        'generated_at': datetime.now().isoformat()
-                    }
-            finally:
-                connection.close()
-                    
-        except Exception as e:
-            return {'error': str(e)}
-
-
-# 全局分析实例
-analytics = MonitorAnalytics()
-
-# 导出分析函数
-def get_realtime_metrics():
-    """获取实时监控指标"""
-    return analytics.get_realtime_metrics()
-
-def get_traffic_trend(days: int = 7):
-    """获取流量趋势"""
-    return analytics.get_traffic_trend(days)
-
-def get_endpoint_analysis(days: int = 7):
-    """获取端点分析"""
-    return analytics.get_endpoint_analysis(days)
-
-def get_user_behavior_analysis(days: int = 7):
-    """获取用户行为分析"""
-    return analytics.get_user_behavior_analysis(days)
-
-def get_performance_alerts():
-    """获取性能告警"""
-    return analytics.get_performance_alerts()
-
-def generate_daily_report(target_date: datetime = None):
-    """生成日报告"""
-    return analytics.generate_daily_report(target_date)