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

mdbq/__version__.py

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

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 天
+        这个方法应该在单独的进程中循环调用
         
-    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.12.dist-info → mdbq-4.2.14.dist-info}/METADATA

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

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

@@ -1,5 +1,5 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
-mdbq/__version__.py,sha256=dDSxXk_6SqNGdPyHVpg1_A9XcQnsjS0F-BHHn27DAr4,18
+mdbq/__version__.py,sha256=cr0O8LE2OkusCNWIOsW9RXnz5146D47fEK2fLTbqnUU,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
@@ -30,12 +30,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=gJX3qC6PE5obkIH4KbZxfZJ8UBxjyyfMrwHB77F4pgQ,34153
+mdbq/route/monitor.py,sha256=mY55Y2m0c_1fmC2A6GNWvkSbW3OsXPs3jOI-9HHTYMw,40738
 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.12.dist-info/METADATA,sha256=rp5NjFgwzyRcuWcmGqCKjeeg60uvteXEeQCXpuah7F4,364
-mdbq-4.2.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mdbq-4.2.12.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-4.2.12.dist-info/RECORD,,
+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,,