mdbq 4.1.1__py3-none-any.whl → 4.1.3__py3-none-any.whl

mdbq/redis/redis_cache.py

@@ -26,21 +26,21 @@ from typing import Optional, Dict, Any, List, Callable
 from threading import Event
 from collections import defaultdict, deque
 import redis
-from mdbq.log import mylogger
+# from mdbq.log import mylogger
 
 
-# 全局日志器
-logger = mylogger.MyLogger(
-    logging_mode='file',
-    log_level='info',
-    log_format='json',
-    max_log_size=50,
-    backup_count=5,
-    enable_async=False,
-    sample_rate=1,
-    sensitive_fields=[],
-    enable_metrics=False,
-)
+# # 全局日志器
+# logger = mylogger.MyLogger(
+#     logging_mode='file',
+#     log_level='info',
+#     log_format='json',
+#     max_log_size=50,
+#     backup_count=5,
+#     enable_async=False,
+#     sample_rate=1,
+#     sensitive_fields=[],
+#     enable_metrics=False,
+# )
 
 
 class CacheStatsCollector:
@@ -105,31 +105,28 @@ class CacheStatsCollector:
                     self._check_and_submit()
                 except Exception as submit_error:
                     # 统计提交失败不应影响统计记录
-                    logger.error("统计数据提交检查失败，但统计记录继续", {
-                        'instance_name': self.instance_name,
-                        'process_id': self.process_id,
-                        'operation': operation,
-                        'submit_error': str(submit_error)
-                    })
+                    # logger.error("统计数据提交检查失败，但统计记录继续", {
+                    #     'instance_name': self.instance_name,
+                    #     'process_id': self.process_id,
+                    #     'operation': operation,
+                    #     'submit_error': str(submit_error)
+                    # })
+                    pass
         except Exception as e:
             # 统计记录失败不应影响缓存操作
-            logger.error("统计记录失败，但缓存操作继续", {
-                'instance_name': self.instance_name,
-                'process_id': self.process_id,
-                'operation': operation,
-                'error': str(e)
-            })
+            # logger.error("统计记录失败，但缓存操作继续", {
+            #     'instance_name': self.instance_name,
+            #     'process_id': self.process_id,
+            #     'operation': operation,
+            #     'error': str(e)
+            # })
+            pass
     
     def _start_background_timer(self):
         """启动后台定时提交线程"""
         if self._timer is not None:
             return  # 已经启动
         
-        logger.debug("启动后台定时提交", {
-            'instance_name': self.instance_name,
-            'submit_interval': self.submit_interval
-        })
-        
         self._timer = threading.Timer(self.submit_interval, self._background_submit)
         self._timer.daemon = True  # 设置为守护线程
         self._timer.start()
@@ -147,22 +144,22 @@ class CacheStatsCollector:
             
         except Exception as e:
             self._error_count += 1
-            logger.error("后台定时提交失败", {
-                'instance_name': self.instance_name,
-                'process_id': self.process_id,
-                'error': str(e),
-                'error_type': type(e).__name__,
-                'error_count': self._error_count,
-                'max_errors': self._max_errors
-            })
+            # logger.error("后台定时提交失败", {
+            #     'instance_name': self.instance_name,
+            #     'process_id': self.process_id,
+            #     'error': str(e),
+            #     'error_type': type(e).__name__,
+            #     'error_count': self._error_count,
+            #     'max_errors': self._max_errors
+            # })
             
             # 如果连续错误次数过多，停止定时器
             if self._error_count >= self._max_errors:
-                logger.error("后台定时器连续错误过多，停止定时提交", {
-                    'instance_name': self.instance_name,
-                    'process_id': self.process_id,
-                    'error_count': self._error_count
-                })
+                # logger.error("后台定时器连续错误过多，停止定时提交", {
+                #     'instance_name': self.instance_name,
+                #     'process_id': self.process_id,
+                #     'error_count': self._error_count
+                # })
                 return  # 不再安排下一次定时器
                 
         finally:
@@ -198,27 +195,22 @@ class CacheStatsCollector:
                     self.last_submit_time = current_time
                     self.last_operation_count = self.stats['total_operations']
                     
-                    logger.info("统计数据提交成功", {
-                        'instance_name': self.instance_name,
-                        'total_operations': self.stats['total_operations'],
-                        'new_operations': new_operations,
-                        'trigger_type': 'background_timer' if force_check else 'operation_triggered'
-                    })
+                    # logger.info("统计数据提交成功", {
+                    #     'instance_name': self.instance_name,
+                    #     'total_operations': self.stats['total_operations'],
+                    #     'new_operations': new_operations,
+                    #     'trigger_type': 'background_timer' if force_check else 'operation_triggered'
+                    # })
                 except Exception as e:
-                    logger.error("统计数据提交失败", {
-                        'instance_name': self.instance_name,
-                        'error': str(e),
-                        'trigger_type': 'background_timer' if force_check else 'operation_triggered'
-                    })
+                    # logger.error("统计数据提交失败", {
+                    #     'instance_name': self.instance_name,
+                    #     'error': str(e),
+                    #     'trigger_type': 'background_timer' if force_check else 'operation_triggered'
+                    # })
+                    pass
             else:
                 # 无新操作，跳过提交但更新时间
                 self.last_submit_time = current_time
-                if force_check:  # 仅在后台定时器触发时记录
-                    logger.debug("后台检查：无新操作，跳过提交", {
-                        'instance_name': self.instance_name,
-                        'total_operations': self.stats['total_operations']
-                    })
-    
     def _submit_to_mysql(self):
         """同步提交统计数据到MySQL"""
         if not self.mysql_pool:
@@ -270,12 +262,12 @@ class CacheStatsCollector:
             connection.close()
             
         except Exception as e:
-            logger.error("MySQL提交失败", {
-                'instance_name': self.instance_name,
-                'database': db_name,
-                'table': table_name,
-                'error': str(e)
-            })
+            # logger.error("MySQL提交失败", {
+            #     'instance_name': self.instance_name,
+            #     'database': db_name,
+            #     'table': table_name,
+            #     'error': str(e)
+            # })
             raise
     
     def get_stats(self) -> Dict[str, Any]:
@@ -307,9 +299,9 @@ class CacheStatsCollector:
     
     def shutdown(self):
         """关闭统计收集器，停止后台定时器"""
-        logger.info("关闭统计收集器", {
-            'instance_name': self.instance_name
-        })
+        # logger.info("关闭统计收集器", {
+        #     'instance_name': self.instance_name
+        # })
         
         # 设置关闭标志
         self._shutdown_event.set()
@@ -417,18 +409,19 @@ class SmartCacheSystem:
                 try:
                     self._create_simple_stats_table()
                     self._state = CacheSystemState.MYSQL_READY
-                    logger.info("统计功能已启用", {
-                        'instance_name': self.instance_name,
-                        'process_id': os.getpid()
-                    })
+                    # logger.info("统计功能已启用", {
+                    #     'instance_name': self.instance_name,
+                    #     'process_id': os.getpid()
+                    # })
                 except Exception as e:
-                    logger.error("统计表创建失败", {
-                        'instance_name': self.instance_name,
-                        'error': str(e)
-                    })
+                    # logger.error("统计表创建失败", {
+                    #     'instance_name': self.instance_name,
+                    #     'error': str(e)
+                    # })
+                    pass
         else:
             self._state = CacheSystemState.ERROR
-            logger.error("Redis连接失败", {'instance_name': self.instance_name})
+            # logger.error("Redis连接失败", {'instance_name': self.instance_name})
     
     def _test_redis_connection(self) -> bool:
         """测试Redis连接"""
@@ -436,7 +429,7 @@ class SmartCacheSystem:
             self.redis_client.ping()
             return True
         except Exception as e:
-            logger.error("Redis连接测试失败", {'error': str(e)})
+            # logger.error("Redis连接测试失败", {'error': str(e)})
             return False
     
     def _create_simple_stats_table(self):
@@ -493,7 +486,7 @@ class SmartCacheSystem:
             connection.close()
             
         except Exception as e:
-            logger.error("统计表初始化失败", {'error': str(e)})
+            # logger.error("统计表初始化失败", {'error': str(e)})
             raise
     
     @property
@@ -539,11 +532,11 @@ class SmartCacheSystem:
             response_time = (time.time() - start_time) * 1000
             if self.stats_collector:
                 self.stats_collector.record_operation('errors', response_time, namespace)
-            logger.error("缓存获取失败", {
-                'key': key,
-                'namespace': namespace,
-                'error': str(e)
-            })
+            # logger.error("缓存获取失败", {
+            #     'key': key,
+            #     'namespace': namespace,
+            #     'error': str(e)
+            # })
             return default
     
     def set(self, key: str, value: Any, ttl: Optional[int] = None, namespace: str = "") -> bool:
@@ -574,11 +567,11 @@ class SmartCacheSystem:
             if value_size > self.config.max_value_size:
                 if self.stats_collector:
                     self.stats_collector.record_operation('errors', 0, namespace)
-                logger.warning("缓存值过大，跳过设置", {
-                    'key': key,
-                    'size': len(serialized_value),
-                    'max_size': self.config.max_value_size
-                })
+                # logger.warning("缓存值过大，跳过设置", {
+                #     'key': key,
+                #     'size': len(serialized_value),
+                #     'max_size': self.config.max_value_size
+                # })
                 return False
             
             result = self.redis_client.setex(cache_key, ttl, serialized_value)
@@ -592,11 +585,11 @@ class SmartCacheSystem:
             response_time = (time.time() - start_time) * 1000
             if self.stats_collector:
                 self.stats_collector.record_operation('errors', response_time, namespace)
-            logger.error("缓存设置失败", {
-                'key': key,
-                'namespace': namespace,
-                'error': str(e)
-            })
+            # logger.error("缓存设置失败", {
+            #     'key': key,
+            #     'namespace': namespace,
+            #     'error': str(e)
+            # })
             return False
     
     def delete(self, key: str, namespace: str = "") -> bool:
@@ -621,11 +614,11 @@ class SmartCacheSystem:
             response_time = (time.time() - start_time) * 1000
             if self.stats_collector:
                 self.stats_collector.record_operation('errors', response_time, namespace)
-            logger.error("缓存删除失败", {
-                'key': key,
-                'namespace': namespace,
-                'error': str(e)
-            })
+            # logger.error("缓存删除失败", {
+            #     'key': key,
+            #     'namespace': namespace,
+            #     'error': str(e)
+            # })
             return False
     
     def clear_namespace(self, namespace: str) -> int:
@@ -643,10 +636,10 @@ class SmartCacheSystem:
             return 0
             
         except Exception as e:
-            logger.error("清除命名空间失败", {
-                'namespace': namespace,
-                'error': str(e)
-            })
+            # logger.error("清除命名空间失败", {
+            #     'namespace': namespace,
+            #     'error': str(e)
+            # })
             return 0
     
     def _generate_cache_key(self, key: str, namespace: str = "") -> str:
@@ -760,18 +753,6 @@ class SmartCacheSystem:
         # 7. TTL边界限制（使用配置值）
         final_ttl = max(self.config.ttl_min, min(self.config.ttl_max, final_ttl))
         
-        # 8. 记录智能TTL决策（使用配置开关）
-        if self.config.debug_ttl:
-            logger.debug("智能TTL计算", {
-                'namespace': namespace,
-                'key': key[:50] + "..." if len(key) > 50 else key,
-                'data_size': data_size,
-                'base_ttl': base_ttl,
-                'key_factor': key_factor,
-                'size_factor': size_factor,
-                'final_ttl': final_ttl
-            })
-        
         return final_ttl
     
     def get_stats(self) -> Dict[str, Any]:
@@ -779,11 +760,7 @@ class SmartCacheSystem:
         # 确保统计系统已初始化
         if self.stats_collector:
             return self.stats_collector.get_stats()
-        
-        logger.debug("统计系统未初始化，返回空统计信息", {
-            'instance_name': self.instance_name,
-            'process_id': os.getpid()
-        })
+
         return {
             'enabled': False,
             'message': '统计系统未初始化',
@@ -828,14 +805,6 @@ class SmartCacheSystem:
         if not self.config.enable_stats:
             return
             
-        logger.debug("调用操作记录", {
-            'operation': operation,
-            'response_time_ms': round(response_time, 2),
-            'namespace': namespace,
-            'key': key[:50] + "..." if len(key) > 50 else key,
-            'instance_name': self.instance_name
-        })
-        
     def shutdown(self):
         """关闭缓存系统"""
         self._state = CacheSystemState.SHUTDOWN
@@ -844,7 +813,7 @@ class SmartCacheSystem:
             # 关闭统计收集器（包括后台定时器）
             self.stats_collector.shutdown()
         
-        logger.info("缓存系统已关闭", {'instance_name': self.instance_name})
+        # logger.info("缓存系统已关闭", {'instance_name': self.instance_name})
 
 
 class CacheManager:
@@ -868,10 +837,10 @@ class CacheManager:
     def initialize(self, redis_client: redis.Redis, mysql_pool=None, instance_name: str = "default", **config):
         """初始化缓存系统"""
         if self.cache_instance is not None:
-            logger.warning("缓存系统已初始化，跳过重复初始化", {
-                'existing_instance': self.cache_instance.instance_name,
-                'new_instance': instance_name
-            })
+            # logger.warning("缓存系统已初始化，跳过重复初始化", {
+            #     'existing_instance': self.cache_instance.instance_name,
+            #     'new_instance': instance_name
+            # })
             return
         
         self.cache_instance = SmartCacheSystem(