mdbq 4.2.13__tar.gz → 4.2.15__tar.gz

{mdbq-4.2.13 → mdbq-4.2.15}/PKG-INFO

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

mdbq-4.2.15/mdbq/__version__.py

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

{mdbq-4.2.13 → mdbq-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))
@@ -929,7 +928,7 @@ class RouteMonitor:
         """
         从 Redis 队列中消费任务并写入数据库（用于单独的消费者进程）
         
-        这个方法应该在单独的进程中循环调用，不要在 uwsgi worker 中调用！
+        这个方法应该在单独的进程中循环调用
         
         Args:
             batch_size: 每次处理的最大任务数

{mdbq-4.2.13 → mdbq-4.2.15}/mdbq.egg-info/PKG-INFO

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

{mdbq-4.2.13 → mdbq-4.2.15}/mdbq.egg-info/SOURCES.txt

@@ -35,9 +35,7 @@ mdbq/redis/__init__.py
 mdbq/redis/getredis.py
 mdbq/redis/redis_cache.py
 mdbq/route/__init__.py
-mdbq/route/analytics.py
 mdbq/route/monitor.py
-mdbq/route/monitor_worker.py
 mdbq/route/routes.py
 mdbq/selenium/__init__.py
 mdbq/selenium/get_driver.py

mdbq-4.2.13/mdbq/__version__.py

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

mdbq-4.2.13/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) 

mdbq-4.2.13/mdbq/route/monitor_worker.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-API 监控系统 - 队列消费者进程
-
-这是一个单独运行的守护进程，从 Redis 队列中消费监控任务并写入数据库。
-在 uwsgi 多进程环境下，只需运行一个或多个此进程即可处理所有 worker 的监控数据。
-
-使用方法：
-    python -m mdbq.route.monitor_worker
-    
-或通过 systemd/supervisor 管理：
-    supervisorctl start api_monitor_worker
-"""
-
-import os
-import sys
-import time
-import signal
-from typing import Optional
-
-
-class MonitorWorker:
-    """监控任务队列消费者"""
-    
-    def __init__(self, redis_client, database: str = 'api监控系统', pool=None):
-        """
-        初始化消费者
-        
-        Args:
-            redis_client: Redis 客户端实例
-            database: 监控数据库名称
-            pool: 数据库连接池（可选）
-        """
-        from mdbq.route.monitor import RouteMonitor
-        
-        self.monitor = RouteMonitor(
-            database=database,
-            pool=pool,
-            redis_client=redis_client,
-            enable_async=True
-        )
-        self.running = True
-        self.processed_total = 0
-        
-        # 注册信号处理
-        signal.signal(signal.SIGINT, self._handle_signal)
-        signal.signal(signal.SIGTERM, self._handle_signal)
-    
-    def _handle_signal(self, signum, frame):
-        """处理关闭信号"""
-        self.running = False
-    
-    def run(self, batch_size: int = 100, sleep_interval: float = 0.1):
-        """
-        运行消费者主循环
-        
-        Args:
-            batch_size: 每次处理的最大任务数
-            sleep_interval: 队列为空时的休眠间隔（秒）
-        """
-        last_log_time = time.time()
-        log_interval = 60  # 每60秒输出一次统计
-        
-        try:
-            while self.running:
-                # 消费一批任务
-                processed = self.monitor.consume_queue_tasks(
-                    batch_size=batch_size,
-                    timeout=1.0
-                )
-                
-                self.processed_total += processed
-                
-                # 定期输出统计信息
-                current_time = time.time()
-                if current_time - last_log_time >= log_interval:
-                    last_log_time = current_time
-                
-                # 如果队列为空，短暂休眠
-                if processed == 0:
-                    time.sleep(sleep_interval)
-        
-        except Exception as e:
-            pass
-
-
-def create_worker_from_config(config_file: Optional[str] = None):
-    """
-    从配置文件创建消费者实例
-    
-    Args:
-        config_file: 配置文件路径（可选，默认 ~/spd.txt）
-    
-    Returns:
-        MonitorWorker: 消费者实例
-    """
-    try:
-        import redis
-        from mdbq.myconf import myconf
-        
-        # 读取配置
-        if config_file is None:
-            config_file = os.path.join(os.path.expanduser("~"), 'spd.txt')
-        
-        parser = myconf.ConfigParser()
-        redis_password = parser.get_value(
-            file_path=config_file,
-            section='redis',
-            key='password',
-            value_type=str
-        )
-        
-        # 创建 Redis 客户端
-        redis_client = redis.Redis(
-            host='127.0.0.1',
-            port=6379,
-            db=0,
-            password=redis_password,
-            decode_responses=False,
-            socket_timeout=5,
-            socket_connect_timeout=3
-        )
-        
-        # 创建消费者
-        worker = MonitorWorker(
-            redis_client=redis_client,
-            database='api监控系统'
-        )
-        
-        return worker
-        
-    except Exception as e:
-        sys.exit(1)
-
-
-def main():
-    """主函数"""
-    
-    # 创建消费者
-    worker = create_worker_from_config()
-    
-    # 运行消费者
-    worker.run(
-        batch_size=100,      # 每次处理100个任务
-        sleep_interval=0.5   # 队列空时休眠0.5秒
-    )
-
-
-if __name__ == '__main__':
-    main()
-