mdbq 4.2.12__tar.gz → 4.2.13__tar.gz

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

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

mdbq-4.2.13/mdbq/__version__.py

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

{mdbq-4.2.12 → mdbq-4.2.13}/mdbq/route/monitor.py

@@ -15,21 +15,21 @@ import os
 import json
 import time
 import uuid
+import threading
 import pymysql
 import functools
+import hashlib
 from datetime import datetime, timedelta
 from typing import Dict, Any, Optional
 from dbutils.pooled_db import PooledDB # type: ignore
 from flask import request, g
 
 
-
 class RouteMonitor:
     """
     路由监控核心类
     
     负责 API 请求的监控、日志记录和统计分析。
-    采用精简设计，专注于核心监控指标，最大程度降低对业务性能的影响。
     
     Attributes:
         database (str): 监控数据库名称，默认为 'api监控系统'
@@ -41,19 +41,50 @@ class RouteMonitor:
         - cleanup_old_data: 清理历史数据
     """
     
-    def __init__(self, database: str = 'api监控系统', pool = None):
+    def __init__(self, database: str = 'api监控系统', pool = None, redis_client = None, enable_async: bool = True):
         """
         初始化监控系统
         
         Args:
             database: 数据库名称，默认为 'api监控系统'
             pool: 数据库连接池对象，如果不传则使用默认配置创建
+            redis_client: Redis 客户端，用于异步队列（可选，如果不传则同步写入）
+            enable_async: 是否启用异步模式（需要 redis_client），默认 True
         """
         self.database = database
         self.pool = pool
         if self.pool is None:
             self.init_database_pool()
         self.init_database_tables()
+        
+        # Redis 异步队列配置
+        self.redis_client = redis_client
+        self.enable_async = enable_async and self.redis_client is not None
+        # 队列名ASCII化，避免中文带来的跨系统兼容问题
+        try:
+            db_hash = hashlib.md5(self.database.encode('utf-8')).hexdigest()[:8]
+            self.queue_name = f"api_monitor:{db_hash}:tasks"
+        except Exception:
+            self.queue_name = "api_monitor:tasks"
+        
+        # 线程锁（用于保护统计数据）
+        import threading
+        self._stats_lock = threading.Lock()
+        
+        # 统计信息
+        self._stats = {
+            'total_requests': 0,
+            'queued_tasks': 0,
+            'sync_writes': 0,
+            'queue_failures': 0,
+        }
+        
+        if self.enable_async:
+            # 使用 Redis 队列模式（适合 uwsgi 多进程）
+            pass  # 队列消费者需要单独进程运行
+        else:
+            # 降级为同步模式
+            pass
 
     def init_database_pool(self):
         """
@@ -100,6 +131,7 @@ class RouteMonitor:
                 connection.close()
                 
         except Exception as e:
+            # 保持原有行为：抛出异常由上层处理
             raise
     
     def ensure_database_context(self, cursor):
@@ -178,7 +210,7 @@ class RouteMonitor:
                             `失败次数` INT UNSIGNED DEFAULT 0 COMMENT '失败响应次数（状态码 >= 400）',
                             `平均耗时` DECIMAL(10,3) DEFAULT 0 COMMENT '平均响应耗时（毫秒）',
                             `最大耗时` DECIMAL(10,3) DEFAULT 0 COMMENT '最大响应耗时（毫秒）',
-                            `最小耗时` DECIMAL(10,3) DEFAULT 0 COMMENT '最小响应耗时（毫秒）',
+                            `最小耗时` DECIMAL(10,3) DEFAULT NULL COMMENT '最小响应耗时（毫秒）',
                             `独立ip数` INT UNSIGNED DEFAULT 0 COMMENT '访问的独立 ip 数量',
                             `创建时间` TIMESTAMP DEFAULT CURRENT_TIMESTAMP COMMENT '记录创建时间',
                             `更新时间` TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '记录更新时间',
@@ -223,9 +255,88 @@ class RouteMonitor:
                 connection.close()
                 
         except Exception as e:
-            # 静默处理初始化错误，避免影响主应用启动
+            # 保持静默降级行为，不影响主应用启动
             pass
     
+    # ==================== Redis 队列方法 ====================
+    
+    @staticmethod
+    def _datetime_converter(obj):
+        """
+        JSON 序列化时的 datetime 转换器
+        
+        将 datetime 对象转换为特殊格式的字典，便于反序列化时还原
+        """
+        if isinstance(obj, datetime):
+            return {'__datetime__': True, 'value': obj.isoformat()}
+        return str(obj)
+    
+    @staticmethod
+    def _datetime_decoder(dct):
+        """
+        JSON 反序列化时的 datetime 解码器
+        
+        将特殊格式的字典还原为 datetime 对象
+        """
+        if isinstance(dct, dict) and '__datetime__' in dct:
+            return datetime.fromisoformat(dct['value'])
+        return dct
+    
+    def _push_to_queue(self, task_data: Dict[str, Any]) -> bool:
+        """
+        将监控任务推入 Redis 队列（非阻塞，极快）
+        
+        Args:
+            task_data: 任务数据字典
+            
+        Returns:
+            bool: 是否成功推入队列
+        """
+        if not self.enable_async:
+            return False
+        
+        try:
+            # 将任务数据序列化为 JSON（使用 datetime 转换器）
+            task_json = json.dumps(task_data, default=self._datetime_converter, ensure_ascii=False)
+            
+            # 推入 Redis 列表（LPUSH，从左侧推入）
+            self.redis_client.lpush(self.queue_name, task_json)
+            
+            with self._stats_lock:
+                self._stats['queued_tasks'] += 1
+            return True
+            
+        except Exception as e:
+            # 静默处理错误
+            with self._stats_lock:
+                self._stats['queue_failures'] += 1
+            return False
+    
+    def get_monitor_stats(self) -> Dict[str, Any]:
+        """
+        获取监控系统统计信息
+        
+        Returns:
+            dict: 统计信息字典
+        """
+        with self._stats_lock:
+            stats = self._stats.copy()
+        
+        # 添加队列信息
+        if self.enable_async:
+            try:
+                queue_length = self.redis_client.llen(self.queue_name)
+                stats['queue_length'] = queue_length
+                stats['mode'] = 'async_redis'
+            except:
+                stats['queue_length'] = -1
+                stats['mode'] = 'async_redis_error'
+        else:
+            stats['queue_length'] = 0
+            stats['mode'] = 'sync'
+        
+        return stats
+    
     # ==================== 辅助方法 ====================
     
     def generate_request_id(self) -> str:
@@ -345,10 +456,31 @@ class RouteMonitor:
         elif hasattr(g, 'user_id'):
             user_id = str(g.user_id)
         
-        # 收集请求参数（可选，仅在需要时记录）
+        # 收集请求参数（GET 参数 + POST 数据）
         request_params = None
+        params_dict = {}
+        
+        # 1. 收集 URL 参数（GET）
         if request.args:
-            request_params = self.sanitize_params(dict(request.args))
+            params_dict.update(dict(request.args))
+        
+        # 2. 收集 POST/PUT/PATCH 请求体数据
+        if request.method in ['POST', 'PUT', 'PATCH']:
+            try:
+                if request.is_json:
+                    # JSON 数据
+                    json_data = request.get_json(silent=True)
+                    if json_data:
+                        params_dict.update(json_data)
+                elif request.form:
+                    # 表单数据
+                    params_dict.update(dict(request.form))
+            except Exception:
+                pass
+        
+        # 3. 脱敏处理
+        if params_dict:
+            request_params = self.sanitize_params(params_dict)
         
         # 构建请求数据字典
         request_data = {
@@ -436,9 +568,11 @@ class RouteMonitor:
                 with connection.cursor() as cursor:
                     self.ensure_database_context(cursor)
                     
-                    now = datetime.now()
-                    date = now.date()
-                    hour = now.hour
+                    # 使用请求时间而不是当前时间，避免统计时间不一致
+                    request_time = request_data.get('请求时间', datetime.now())
+                    date = request_time.date()
+                    hour = request_time.hour
+                    now = datetime.now()  # 用于IP统计的最后访问时间
                     
                     # 判断是否成功（状态码 < 400）
                     status_code = request_data.get('响应状态码', 500)
@@ -455,14 +589,19 @@ class RouteMonitor:
                         ) VALUES (
                             %s, %s, %s, %s, 1, %s, %s, %s, %s, %s
                         ) ON DUPLICATE KEY UPDATE
-                            `请求总数` = `请求总数` + 1,
-                            `成功次数` = `成功次数` + %s,
-                            `失败次数` = `失败次数` + %s,
-                            `平均耗时` = (
-                                (`平均耗时` * (`请求总数` - 1) + %s) / `请求总数`
-                            ),
-                            `最大耗时` = GREATEST(`最大耗时`, %s),
-                            `最小耗时` = LEAST(`最小耗时`, %s)
+                        `请求总数` = `请求总数` + 1,
+                        `成功次数` = `成功次数` + %s,
+                        `失败次数` = `失败次数` + %s,
+                        `平均耗时` = (
+                            (`平均耗时` * `请求总数` + %s) / (`请求总数` + 1)
+                        ),
+                        `最大耗时` = GREATEST(`最大耗时`, %s),
+                        `最小耗时` = (
+                            CASE 
+                                WHEN `最小耗时` IS NULL OR `最小耗时` = 0 THEN %s 
+                                ELSE LEAST(`最小耗时`, %s) 
+                            END
+                        )
                     """, (
                         date, hour, 
                         request_data.get('接口路径', ''),
@@ -470,9 +609,10 @@ class RouteMonitor:
                         is_success, is_error,
                         response_time, response_time, response_time,
                         is_success, is_error,
-                        response_time,
-                        response_time,
-                        response_time
+                    response_time,
+                    response_time,
+                    response_time,
+                    response_time
                     ))
                     
                     # 2. 更新 IP 统计表
@@ -486,9 +626,9 @@ class RouteMonitor:
                             `请求总数` = `请求总数` + 1,
                             `成功次数` = `成功次数` + %s,
                             `失败次数` = `失败次数` + %s,
-                            `平均耗时` = (
-                                (`平均耗时` * (`请求总数` - 1) + %s) / `请求总数`
-                            ),
+                        `平均耗时` = (
+                            (`平均耗时` * `请求总数` + %s) / (`请求总数` + 1)
+                        ),
                             `最后访问` = %s
                     """, (
                         date,
@@ -547,6 +687,10 @@ class RouteMonitor:
             request_data = self.collect_request_data(request)
             request_id = request_data.get('请求id', 'unknown')
             
+            # 统计总请求数（线程安全）
+            with self._stats_lock:
+                self._stats['total_requests'] += 1
+            
             try:
                 # 执行原函数
                 response = func(*args, **kwargs)
@@ -562,6 +706,12 @@ class RouteMonitor:
                 elif isinstance(response, tuple) and len(response) > 1:
                     # 处理 (data, status_code) 格式的返回
                     response_status = response[1]
+                # 健壮化：支持 '200 OK' 等字符串状态
+                if isinstance(response_status, str):
+                    try:
+                        response_status = int(str(response_status).split()[0])
+                    except Exception:
+                        response_status = 200
                 
                 # 更新响应数据
                 response_data = {
@@ -569,12 +719,22 @@ class RouteMonitor:
                     '响应耗时': process_time,
                 }
                 
-                # 保存日志
-                self.save_request_log(request_data, response_data)
-                
-                # 更新统计
+                # 合并数据
                 request_data.update(response_data)
-                self.update_statistics(request_data)
+                
+                # 【改进】优先使用 Redis 队列（非阻塞）
+                queued = self._push_to_queue({
+                    'type': 'request_log',
+                    'data': request_data,
+                    'timestamp': time.time()
+                })
+                
+                # 如果队列失败，降级为同步写入
+                if not queued:
+                    with self._stats_lock:
+                        self._stats['sync_writes'] += 1
+                    self.save_request_log(request_data, None)
+                    self.update_statistics(request_data)
                 
                 return response
                 
@@ -590,12 +750,22 @@ class RouteMonitor:
                     '错误信息': f"{type(e).__name__}: {str(e)}"
                 }
                 
-                # 保存错误日志
-                self.save_request_log(request_data, error_data)
-                
-                # 更新统计
+                # 合并数据
                 request_data.update(error_data)
-                self.update_statistics(request_data)
+                
+                # 【改进】优先使用 Redis 队列（非阻塞）
+                queued = self._push_to_queue({
+                    'type': 'request_log',
+                    'data': request_data,
+                    'timestamp': time.time()
+                })
+                
+                # 如果队列失败，降级为同步写入
+                if not queued:
+                    with self._stats_lock:
+                        self._stats['sync_writes'] += 1
+                    self.save_request_log(request_data, None)
+                    self.update_statistics(request_data)
                 
                 # 重新抛出异常，不影响原有错误处理逻辑
                 raise
@@ -754,84 +924,69 @@ class RouteMonitor:
                 
         except Exception as e:
             return {'错误': str(e)}
-
-
-# ==================== 全局实例与导出 ====================
-
-# 创建全局监控实例
-route_monitor = RouteMonitor()
-
-# 导出核心装饰器（推荐使用此方式）
-api_monitor = route_monitor.api_monitor
-
-
-# ==================== 便捷工具函数 ====================
-
-def get_request_id() -> Optional[str]:
-    """
-    获取当前请求的唯一 ID
-    
-    可在被 @api_monitor 装饰的函数内调用，用于日志关联和问题追踪。
     
-    Returns:
-        str: 请求 ID，如果不在请求上下文中则返回 None
+    def consume_queue_tasks(self, batch_size: int = 100, timeout: float = 1.0):
+        """
+        从 Redis 队列中消费任务并写入数据库（用于单独的消费者进程）
         
-    示例：
-        ```python
-        @api_monitor
-        def my_api():
-            req_id = get_request_id()
-            logger.info(f"处理请求: {req_id}")
-            return {'status': 'ok'}
-        ```
-    """
-    return getattr(g, 'request_id', None)
-
-
-def get_statistics_summary(days: int = 7) -> Dict[str, Any]:
-    """
-    获取统计摘要数据
-    
-    Args:
-        days: 统计天数，默认 7 天
+        这个方法应该在单独的进程中循环调用，不要在 uwsgi worker 中调用！
         
-    Returns:
-        dict: 统计摘要数据
+        Args:
+            batch_size: 每次处理的最大任务数
+            timeout: 从队列获取任务的超时时间（秒）
+            
+        Returns:
+            int: 处理的任务数量
+        """
+        if not self.enable_async:
+            return 0
         
-    示例：
-        ```python
-        # 获取最近 7 天的统计
-        stats = get_statistics_summary(7)
-        print(stats['总体统计'])
+        processed = 0
         
-        # 获取最近 30 天的统计
-        stats = get_statistics_summary(30)
-        ```
-    """
-    return route_monitor.get_statistics_summary(days)
+        try:
+            # 批量从队列中取出任务（BRPOP，从右侧阻塞弹出）
+            for _ in range(batch_size):
+                result = self.redis_client.brpop(self.queue_name, timeout=timeout)
+                if not result:
+                    break  # 队列为空
+                
+                _, task_json = result
+                
+                try:
+                    # （Redis 可能返回 bytes）
+                    if isinstance(task_json, bytes):
+                        task_json = task_json.decode('utf-8')
+                    
+                    # 解析任务数据，还原 datetime 对象（使用 datetime 解码器）
+                    task = json.loads(task_json, object_hook=self._datetime_decoder)
+                    task_type = task.get('type')
+                    task_data = task.get('data', {})
+                    
+                    # 处理不同类型的任务
+                    if task_type == 'request_log':
+                        # 写入日志和统计
+                        self.save_request_log(task_data, None)
+                        self.update_statistics(task_data)
+                        processed += 1
+                    
+                except Exception as e:
+                    # 单个任务失败不影响其他任务
+                    pass
+            
+            return processed
+            
+        except Exception as e:
+            # 静默处理错误
+            return processed
 
 
-def cleanup_old_data(days_to_keep: int = 30) -> Dict[str, int]:
-    """
-    清理历史数据
-    
-    删除指定天数之前的详细日志，保留统计数据。
-    建议通过定时任务定期执行。
-    
-    Args:
-        days_to_keep: 保留最近多少天的数据，默认 30 天
-        
-    Returns:
-        dict: 清理结果统计
-        
-    示例：
-        ```python
-        # 保留最近 30 天的数据，删除更早的
-        result = cleanup_old_data(30)
-        print(f"清理完成: {result}")
-        ```
-    """
-    return route_monitor.cleanup_old_data(days_to_keep)
+# # ==================== 全局实例与导出 ====================
+
+# # 创建全局监控实例
+# route_monitor = RouteMonitor()
+
+# # 导出核心装饰器（推荐使用此方式）
+# api_monitor = route_monitor.api_monitor
 
 
 # ==================== 模块导出列表 ====================
@@ -841,4 +996,5 @@ __all__ = [
     'get_request_id',
     'get_statistics_summary',
     'cleanup_old_data',
+    'get_async_stats',
 ]

mdbq-4.2.13/mdbq/route/monitor_worker.py

@@ -0,0 +1,152 @@
+#!/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()
+

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

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

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

@@ -37,6 +37,7 @@ 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.12/mdbq/__version__.py

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