mdbq 4.2.17__tar.gz → 4.2.19__tar.gz

{mdbq-4.2.17 → mdbq-4.2.19}/PKG-INFO

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

mdbq-4.2.19/mdbq/__version__.py

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

{mdbq-4.2.17 → mdbq-4.2.19}/mdbq/redis/redis_cache.py

@@ -914,16 +914,23 @@ def flask_redis_cache(cache_key_func=None, ttl=1200, namespace="default",
         def wrapper(*args, **kwargs):
             # 导入Flask相关模块（延迟导入避免依赖问题）
             try:
-                from flask import request, jsonify
+                from flask import request, jsonify, g
             except ImportError:
                 # 如果没有Flask环境，直接执行原函数
                 return func(*args, **kwargs)
             
+            # 初始化数据源标记（默认为 none）
+            g.data_source = 'none'
+            g.cache_hit = False
+            
             # 获取缓存系统
             cache_system = cache_manager.get_cache()
             
             # 如果缓存系统不可用，直接执行原函数
             if not cache_system:
+                # 标记为直接查询数据库（无缓存系统）
+                g.data_source = 'mysql'
+                g.cache_hit = False
                 return func(*args, **kwargs)
             
             try:
@@ -952,12 +959,18 @@ def flask_redis_cache(cache_key_func=None, ttl=1200, namespace="default",
                 try:
                     cached_result = cache_system.get(cache_key, namespace)
                     if cached_result is not None:
+                        # 缓存命中：标记为 redis
+                        g.data_source = 'redis'
+                        g.cache_hit = True
                         return jsonify(cached_result)
                 except Exception as e:
                     if not skip_cache_on_error:
                         raise
                 
-                # 缓存未命中，执行原函数
+                # 缓存未命中，执行原函数（会查询数据库）
+                # 标记为 mysql 查询
+                g.data_source = 'mysql'
+                g.cache_hit = False
                 result = func(*args, **kwargs)
                 
                 # 如果结果是Flask Response对象，提取JSON数据进行缓存

{mdbq-4.2.17 → mdbq-4.2.19}/mdbq/route/monitor.py

@@ -176,6 +176,8 @@ class RouteMonitor:
                             `客户端ip` VARCHAR(45) NOT NULL COMMENT '客户端 ip 地址（支持 IPv6）',
                             `状态码` SMALLINT COMMENT 'HTTP 状态码',
                             `响应耗时` DECIMAL(10,3) COMMENT '请求处理耗时（毫秒）',
+                            `数据源` VARCHAR(20) COMMENT '数据源类型：redis/mysql/hybrid/none',
+                            `缓存命中` TINYINT(1) DEFAULT 0 COMMENT '是否命中缓存：1-命中，0-未命中',
                             `用户标识` VARCHAR(64) COMMENT '用户id或标识（如有）',
                             `用户代理` VARCHAR(500) COMMENT '浏览器 User-Agent（精简版）',
                             `请求参数` TEXT COMMENT '请求参数（JSON格式，可选记录）',
@@ -188,8 +190,11 @@ class RouteMonitor:
                             INDEX `idx_路由地址` (`路由地址`(191)),
                             INDEX `idx_客户端ip` (`客户端ip`),
                             INDEX `idx_状态码` (`状态码`),
+                            INDEX `idx_数据源` (`数据源`),
+                            INDEX `idx_缓存命中` (`缓存命中`),
                             INDEX `idx_用户标识` (`用户标识`),
-                            INDEX `idx_时间_接口` (`请求时间`, `路由地址`(191))
+                            INDEX `idx_时间_接口` (`请求时间`, `路由地址`(191)),
+                            INDEX `idx_时间_数据源` (`请求时间`, `数据源`)
                         ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci 
                         COMMENT='API 访问日志表 - 记录每次请求的核心信息'
                         ROW_FORMAT=COMPRESSED;
@@ -207,6 +212,8 @@ class RouteMonitor:
                             `请求总数` INT UNSIGNED DEFAULT 0 COMMENT '总请求次数',
                             `成功次数` INT UNSIGNED DEFAULT 0 COMMENT '成功响应次数（状态码 < 400）',
                             `失败次数` INT UNSIGNED DEFAULT 0 COMMENT '失败响应次数（状态码 >= 400）',
+                            `缓存命中次数` INT UNSIGNED DEFAULT 0 COMMENT '缓存命中次数',
+                            `数据库查询次数` INT UNSIGNED DEFAULT 0 COMMENT '没有命中缓存，直接查询数据库的次数',
                             `平均耗时` DECIMAL(10,3) DEFAULT 0 COMMENT '平均响应耗时（毫秒）',
                             `最大耗时` DECIMAL(10,3) DEFAULT 0 COMMENT '最大响应耗时（毫秒）',
                             `最小耗时` DECIMAL(10,3) DEFAULT NULL COMMENT '最小响应耗时（毫秒）',
@@ -451,11 +458,27 @@ class RouteMonitor:
             user_agent = user_agent[:500]
         
         # 获取用户标识（如果有）
+        # 安全获取 user_id，允许为空时使用默认值
         user_id = None
         if hasattr(g, 'current_user_id'):
-            user_id = str(g.current_user_id)
+            user_id = str(g.current_user_id) if g.current_user_id else None
         elif hasattr(g, 'user_id'):
-            user_id = str(g.user_id)
+            user_id = str(g.user_id) if g.user_id else None
+        
+        # 如果还是获取不到，尝试从 request.current_user 获取
+        if not user_id and hasattr(request, 'current_user'):
+            try:
+                current_user = request.current_user
+                if isinstance(current_user, dict):
+                    user_id = current_user.get('user_id') or current_user.get('id')
+                    if user_id:
+                        user_id = str(user_id)
+            except Exception:
+                pass
+        
+        # 兜底：使用默认值，避免 None
+        if not user_id:
+            user_id = 'anonymous'
         
         # 收集请求参数（GET 参数 + POST 数据）
         request_params = None
@@ -483,6 +506,10 @@ class RouteMonitor:
         if params_dict:
             request_params = self.sanitize_params(params_dict)
         
+        # 获取数据源信息（从 g 对象中读取，由缓存装饰器设置）
+        data_source = getattr(g, 'data_source', 'none')
+        cache_hit = getattr(g, 'cache_hit', False)
+        
         # 构建请求数据字典
         request_data = {
             '请求id': request_id,
@@ -490,6 +517,8 @@ class RouteMonitor:
             '请求方法': request.method,
             '路由地址': request.endpoint or request.path,
             '客户端ip': client_ip,
+            '数据源': data_source,
+            '缓存命中': 1 if cache_hit else 0,
             '用户标识': user_id,
             '用户代理': user_agent,
             '请求参数': request_params,
@@ -523,9 +552,10 @@ class RouteMonitor:
                     sql = """
                         INSERT INTO `api_访问日志` (
                             `请求id`, `请求时间`, `请求方法`, `路由地址`, `客户端ip`,
-                            `状态码`, `响应耗时`, `用户标识`, `用户代理`, `请求参数`, `错误信息`
+                            `状态码`, `响应耗时`, `数据源`, `缓存命中`,
+                            `用户标识`, `用户代理`, `请求参数`, `错误信息`
                         ) VALUES (
-                            %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
+                            %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s
                         )
                     """
                     
@@ -537,6 +567,8 @@ class RouteMonitor:
                         request_data.get('客户端ip'),
                         request_data.get('状态码'),
                         request_data.get('响应耗时'),
+                        request_data.get('数据源', 'none'),
+                        request_data.get('缓存命中', 0),
                         request_data.get('用户标识'),
                         request_data.get('用户代理'),
                         request_data.get('请求参数'),
@@ -581,18 +613,27 @@ class RouteMonitor:
                     is_error = 1 if status_code >= 400 else 0
                     response_time = request_data.get('响应耗时', 0)
                     
+                    # 获取数据源信息
+                    cache_hit = request_data.get('缓存命中', 0)
+                    data_source = request_data.get('数据源', 'none')
+                    is_cache_hit = 1 if cache_hit else 0
+                    is_db_query = 1 if data_source in ['mysql', 'hybrid'] else 0
+                    
                     # 1. 更新接口统计表
                     cursor.execute("""
                         INSERT INTO `api_接口统计` (
                             `统计日期`, `统计小时`, `路由地址`, `请求方法`,
                             `请求总数`, `成功次数`, `失败次数`,
+                            `缓存命中次数`, `数据库查询次数`,
                             `平均耗时`, `最大耗时`, `最小耗时`
                         ) VALUES (
-                            %s, %s, %s, %s, 1, %s, %s, %s, %s, %s
+                            %s, %s, %s, %s, 1, %s, %s, %s, %s, %s, %s, %s
                         ) ON DUPLICATE KEY UPDATE
                         `请求总数` = `请求总数` + 1,
                         `成功次数` = `成功次数` + %s,
                         `失败次数` = `失败次数` + %s,
+                        `缓存命中次数` = `缓存命中次数` + %s,
+                        `数据库查询次数` = `数据库查询次数` + %s,
                         `平均耗时` = (
                             (`平均耗时` * `请求总数` + %s) / (`请求总数` + 1)
                         ),
@@ -607,13 +648,13 @@ class RouteMonitor:
                         date, hour, 
                         request_data.get('路由地址', ''),
                         request_data.get('请求方法', ''),
-                        is_success, is_error,
+                        is_success, is_error, is_cache_hit, is_db_query,
                         response_time, response_time, response_time,
-                        is_success, is_error,
-                    response_time,
-                    response_time,
-                    response_time,
-                    response_time
+                        is_success, is_error, is_cache_hit, is_db_query,
+                        response_time,
+                        response_time,
+                        response_time,
+                        response_time
                     ))
                     
                     # 2. 更新 IP 统计表
@@ -686,7 +727,7 @@ class RouteMonitor:
             
             # 收集请求数据
             request_data = self.collect_request_data(request)
-            request_id = request_data.get('请求id', 'unknown')
+            # request_id = request_data.get('请求id', 'unknown')
             
             # 统计总请求数（线程安全）
             with self._stats_lock:
@@ -723,7 +764,7 @@ class RouteMonitor:
                 # 合并数据
                 request_data.update(response_data)
                 
-                # 【改进】优先使用 Redis 队列（非阻塞）
+                # 优先使用 Redis 队列（非阻塞）
                 queued = self._push_to_queue({
                     'type': 'request_log',
                     'data': request_data,
@@ -754,7 +795,7 @@ class RouteMonitor:
                 # 合并数据
                 request_data.update(error_data)
                 
-                # 【改进】优先使用 Redis 队列（非阻塞）
+                # 优先使用 Redis 队列（非阻塞）
                 queued = self._push_to_queue({
                     'type': 'request_log',
                     'data': request_data,

{mdbq-4.2.17 → mdbq-4.2.19}/mdbq.egg-info/PKG-INFO

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

mdbq-4.2.17/mdbq/__version__.py

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