xmi-logger 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

xmi_logger/xmi_logger.py

@@ -10,13 +10,18 @@ import os
 import sys
 import inspect
 import requests
+import asyncio
+import aiohttp
 
-from typing import Optional
+from typing import Optional, Dict, Any, Union, List, Tuple
 
-from functools import wraps
+from functools import wraps, lru_cache
 from time import perf_counter
 from contextvars import ContextVar
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from collections import defaultdict
+from datetime import datetime, timedelta
+import threading
 
 from loguru import logger
 
@@ -55,8 +60,8 @@ class XmiLogger:
             'END_ASYNC_FUNCTION_CALL': "结束异步函数调用",
             'CALLING_FUNCTION': "调用函数: {func}，参数: {args}，关键字参数: {kwargs}",
             'CALLING_ASYNC_FUNCTION': "调用异步函数: {func}，参数: {args}，关键字参数: {kwargs}",
-            'FUNCTION_RETURNED': "函数 {func} 返回结果: {result}，耗时: {duration:.6f}秒",
-            'ASYNC_FUNCTION_RETURNED': "异步函数 {func} 返回结果: {result}，耗时: {duration:.6f}秒",
+            'FUNCTION_RETURNED': "函数 {func} 返回结果: {result}，耗时: {duration}秒",
+            'ASYNC_FUNCTION_RETURNED': "异步函数 {func} 返回结果: {result}，耗时: {duration}秒",
         },
         'en': {
             'LOG_STATS': "Log statistics: Total {total}, Errors {error}, Warnings {warning}, Info {info}",
@@ -70,12 +75,15 @@ class XmiLogger:
             'END_ASYNC_FUNCTION_CALL': "Ending async function call",
             'CALLING_FUNCTION': "Calling function: {func}, args: {args}, kwargs: {kwargs}",
             'CALLING_ASYNC_FUNCTION': "Calling async function: {func}, args: {args}, kwargs: {kwargs}",
-            'FUNCTION_RETURNED': "Function {func} returned: {result}, duration: {duration:.6f}s",
-            'ASYNC_FUNCTION_RETURNED': "Async function {func} returned: {result}, duration: {duration:.6f}s",
+            'FUNCTION_RETURNED': "Function {func} returned: {result}, duration: {duration}s",
+            'ASYNC_FUNCTION_RETURNED': "Async function {func} returned: {result}, duration: {duration}s",
         }
     }
 
-    # 在 __init__ 方法中添加新的参数
+    # 添加类级别的缓存
+    _format_cache: Dict[str, str] = {}
+    _message_cache: Dict[str, str] = {}
+
     def __init__(
         self,
         file_name: str,
@@ -90,9 +98,9 @@ class XmiLogger:
         custom_format: Optional[str] = None,  # 新增：自定义日志格式
         filter_level: str = "DEBUG",  # 新增：日志过滤级别
         compression: str = "zip",   # 新增：压缩格式，支持 zip, gz, tar
-        file_pattern: str = "{time:YYYY-MM-DD}",  # 新增：文件命名模式
         enable_stats: bool = False,  # 新增：是否启用日志统计
         categories: Optional[list] = None,  # 新增：日志分类列表
+        cache_size: int = 128,  # 新增：缓存大小配置
     ) -> None:
         """
         初始化日志记录器。
@@ -118,9 +126,13 @@ class XmiLogger:
         self.custom_format = custom_format
         self.filter_level = filter_level
         self.compression = compression
-        self.file_pattern = file_pattern
         self.enable_stats = enable_stats
         self.categories = categories or []
+        self._cache_size = cache_size
+        self._async_queue = asyncio.Queue() if remote_log_url else None
+        self._remote_task = None
+        if self._async_queue:
+            self._start_remote_worker()
 
         # 语言选项
         self.language = language if language in ('zh', 'en') else 'zh'
@@ -149,115 +161,172 @@ class XmiLogger:
         # 初始化 Logger 配置
         self.configure_logger()
 
+        self._stats_lock = threading.Lock()
+        self._stats = {
+            'total': 0,
+            'error': 0,
+            'warning': 0,
+            'info': 0,
+            'debug': 0,
+            'by_category': defaultdict(int),
+            'by_hour': defaultdict(int),
+            'errors': [],
+            'last_error_time': None,
+            'error_rate': 0.0
+        }
+        self._stats_start_time = datetime.now()
+
     def _msg(self, key: str, **kwargs) -> str:
-        """
-        根据当前语言，从 _LANG_MAP 中获取对应文本。
-        可使用 kwargs 替换字符串中的占位符。
-        
-        Args:
-            key: Message key from _LANG_MAP
-            **kwargs: Format arguments for the message
-            
-        Returns:
-            Formatted message string
-        """
-        # 安全获取文本，如果键不存在则返回键名
-        text = self._LANG_MAP.get(self.language, {}).get(key, key)
+        """消息格式化处理"""
         try:
-            return text.format(**kwargs)
+            # 获取消息模板
+            text = self._LANG_MAP.get(self.language, {}).get(key, key)
+            
+            # 将所有参数转换为字符串
+            str_kwargs = {}
+            for k, v in kwargs.items():
+                try:
+                    if isinstance(v, (list, tuple)):
+                        str_kwargs[k] = [str(item) for item in v]
+                    elif isinstance(v, dict):
+                        str_kwargs[k] = {str(kk): str(vv) for kk, vv in v.items()}
+                    else:
+                        str_kwargs[k] = str(v)
+                except Exception:
+                    str_kwargs[k] = f"<{type(v).__name__}>"
+            
+            # 格式化消息
+            return text.format(**str_kwargs)
+            
         except KeyError as e:
-            # 如果格式化失败，返回原始文本并记录警告
             return f"{text} (格式化错误: 缺少参数 {e})"
+        except Exception as e:
+            return f"{text} (格式化错误: {str(e)})"
 
     def configure_logger(self) -> None:
-        """Configure logger with console, file and remote handlers.
+        """配置日志记录器，添加错误处理和安全性检查"""
+        try:
+            # 移除所有现有的处理器
+            self.logger.remove()
+            
+            # 验证配置参数
+            self._validate_config()
+            
+            # 确保日志目录存在且可写
+            self._ensure_log_directory()
+            
+            # 配置日志格式
+            log_format = self._get_log_format()
+            
+            # 添加控制台处理器
+            self._add_console_handler(log_format)
+            
+            # 添加文件处理器
+            self._add_file_handlers(log_format)
+            
+            # 配置远程日志（如果启用）
+            if self.remote_log_url:
+                self._configure_remote_logging()
+            
+            # 设置异常处理器
+            self.setup_exception_handler()
+            
+        except Exception as e:
+            # 如果配置失败，使用基本配置
+            self._fallback_configuration()
+            raise RuntimeError(f"日志配置失败: {str(e)}")
+    
+    def _validate_config(self) -> None:
+        """验证配置参数"""
+        if not isinstance(self.max_size, int) or self.max_size <= 0:
+            raise ValueError("max_size 必须是正整数")
         
-        Raises:
-            OSError: If log directory cannot be created
-            ValueError: If invalid configuration values are provided
-        """
-        """
-        配置 Loguru 日志记录器：控制台输出、文件输出、远程日志收集、自定义日志级别。
-        """
-        # 移除所有现有的处理器，重新添加
-        self.logger.remove()
-
-        # 定义日志格式：可根据需要自由增减字段
-        # 包含时间、进程 ID、线程 ID、日志级别、request_id、调用位置等
-        # 目前去除进程 ID、线程 ID
-        """
-        custom_format = (
-            "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
-            "<cyan>PID:{process}</cyan>/<cyan>TID:{thread}</cyan> | "
-            "<level>{level: <8}</level> | "
-            "ReqID:{extra[request_id]} | "
-            "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - "
-            "<level>{message}</level>"
-        )
-        """
-        custom_format = (
+        if not isinstance(self.retention, str):
+            raise ValueError("retention 必须是字符串")
+        
+        if self.remote_log_url and not self.remote_log_url.startswith(('http://', 'https://')):
+            raise ValueError("remote_log_url 必须是有效的 HTTP(S) URL")
+        
+        if self.language not in ('zh', 'en'):
+            raise ValueError("language 必须是 'zh' 或 'en'")
+        
+        if self.compression not in ('zip', 'gz', 'tar'):
+            raise ValueError("compression 必须是 'zip', 'gz' 或 'tar'")
+    
+    def _ensure_log_directory(self) -> None:
+        """确保日志目录存在且可写"""
+        try:
+            os.makedirs(self.log_dir, exist_ok=True)
+            # 测试目录是否可写
+            test_file = os.path.join(self.log_dir, '.write_test')
+            with open(test_file, 'w') as f:
+                f.write('test')
+            os.remove(test_file)
+        except (OSError, IOError) as e:
+            raise RuntimeError(f"无法创建或写入日志目录: {str(e)}")
+    
+    def _get_log_format(self) -> str:
+        """获取日志格式"""
+        if self.custom_format:
+            return self.custom_format
+        
+        return (
             "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
             "<level>{level: <8}</level> | "
             "ReqID:{extra[request_id]} | "
             "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - "
             "<level>{message}</level>"
         )
-
-        # 使用自定义格式或默认格式
-        log_format = self.custom_format or custom_format
-
-        # 添加控制台处理器
+    
+    def _add_console_handler(self, log_format: str) -> None:
+        """添加控制台处理器"""
         self.logger.add(
             sys.stdout,
             format=log_format,
             level=self.filter_level,
-            enqueue=True,
+            enqueue=self.enqueue,
+            diagnose=self.diagnose,
+            backtrace=self.backtrace,
         )
-
-        # 确保日志目录存在
-        try:
-            os.makedirs(self.log_dir, exist_ok=True)
-        except OSError as e:
-            self.logger.error(f"Failed to create log directory: {e}")
-            raise
-
-        # 设置日志轮转策略
-        rotation = self.rotation_time or f"{self.max_size} MB"
-
-        # 添加主日志文件
+    
+    def _add_file_handlers(self, log_format: str) -> None:
+        """添加文件处理器"""
+        # 主日志文件
         self.logger.add(
-            os.path.join(self.log_dir, f"{self.file_name}_{self.file_pattern}.log"),
+            os.path.join(self.log_dir, f"{self.file_name}.log"),
             format=log_format,
             level=self.filter_level,
-            rotation=rotation,
+            rotation=self.rotation_time or f"{self.max_size} MB",
             retention=self.retention,
             compression=self.compression,
             encoding='utf-8',
-            enqueue=True,
-            diagnose=True,
-            backtrace=True,
+            enqueue=self.enqueue,
+            diagnose=self.diagnose,
+            backtrace=self.backtrace,
         )
-
-        # 仅示例演示：为 ERROR 级别单独输出到文件
+        
+        # 错误日志文件
         self.logger.add(
             self._get_level_log_path("error"),
-            format=custom_format,
+            format=log_format,
             level="ERROR",
             rotation=f"{self.max_size} MB",
             retention=self.retention,
-            compression="zip",
+            compression=self.compression,
             encoding='utf-8',
             enqueue=self.enqueue,
             diagnose=self.diagnose,
             backtrace=self.backtrace,
         )
-
-        # 远程日志收集
-        if self.remote_log_url:
-            self._configure_remote_logging()
-
-        # 设置统一异常处理
-        self.setup_exception_handler()
+    
+    def _fallback_configuration(self) -> None:
+        """配置失败时的后备方案"""
+        self.logger.remove()
+        self.logger.add(
+            sys.stderr,
+            format="<red>{time:YYYY-MM-DD HH:mm:ss}</red> | <level>{level: <8}</level> | <level>{message}</level>",
+            level="ERROR"
+        )
 
     def _configure_remote_logging(self):
         """
@@ -305,12 +374,22 @@ class XmiLogger:
                 # 允许程序被 Ctrl+C 中断
                 sys.__excepthook__(exc_type, exc_value, exc_traceback)
                 return
+            
+            try:
+                # 安全地格式化异常信息
+                error_msg = self._msg('UNHANDLED_EXCEPTION') if 'UNHANDLED_EXCEPTION' in self._LANG_MAP[self.language] else "未处理的异常"
                 
-            # 修复：不直接传递 traceback 对象，而是将异常信息格式化为字符串
-            error_msg = self._msg('UNHANDLED_EXCEPTION') if 'UNHANDLED_EXCEPTION' in self._LANG_MAP[self.language] else "未处理的异常"
-            self.logger.opt(exception=True).error(
-                f"{error_msg}: {exc_type.__name__}: {exc_value}"
-            )
+                # 安全地格式化异常值
+                exc_value_str = str(exc_value) if exc_value is not None else "None"
+                
+                # 组合错误消息
+                full_error_msg = f"{error_msg}: {exc_type.__name__}: {exc_value_str}"
+                
+                # 记录错误
+                self.logger.opt(exception=True).error(full_error_msg)
+            except Exception as e:
+                # 如果格式化失败，使用最基本的错误记录
+                self.logger.opt(exception=True).error(f"未处理的异常: {exc_type.__name__}")
 
         sys.excepthook = exception_handler
 
@@ -328,11 +407,56 @@ class XmiLogger:
         log_file = f"{log_level}.log"
         return os.path.join(self.log_dir, log_file)
 
+    def _start_remote_worker(self):
+        """启动异步远程日志工作器"""
+        async def remote_worker():
+            while True:
+                try:
+                    message = await self._async_queue.get()
+                    await self._send_to_remote_async(message)
+                    self._async_queue.task_done()
+                except Exception as e:
+                    self.logger.error(f"远程日志工作器错误: {e}")
+                await asyncio.sleep(0.1)
+        
+        self._remote_task = asyncio.create_task(remote_worker())
+    
+    async def _send_to_remote_async(self, message: Any) -> None:
+        """异步发送日志到远程服务器"""
+        log_entry = message.record
+        payload = {
+            "time": log_entry["time"].strftime("%Y-%m-%d %H:%M:%S"),
+            "level": log_entry["level"].name,
+            "message": log_entry["message"],
+            "file": os.path.basename(log_entry["file"].path) if log_entry["file"] else "",
+            "line": log_entry["line"],
+            "function": log_entry["function"],
+            "request_id": log_entry["extra"].get("request_id", "no-request-id")
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            for attempt in range(3):
+                try:
+                    async with session.post(
+                        self.remote_log_url,
+                        json=payload,
+                        timeout=5
+                    ) as response:
+                        response.raise_for_status()
+                        return
+                except Exception as e:
+                    if attempt == 2:
+                        self.logger.warning(
+                            self._msg('FAILED_REMOTE', error=f"最终尝试失败: {e}")
+                        )
+                    await asyncio.sleep(1 * (attempt + 1))
+    
     def remote_sink(self, message):
-        """
-        自定义的远程日志处理器，将日志发送到远程服务器（使用线程池防止阻塞）。
-        """
-        self._executor.submit(self._send_to_remote, message)
+        """优化的远程日志处理器"""
+        if self._async_queue:
+            asyncio.create_task(self._async_queue.put(message))
+        else:
+            self._executor.submit(self._send_to_remote, message)
 
     def _send_to_remote(self, message) -> None:
         """Send log message to remote server with retry logic.
@@ -455,84 +579,198 @@ class XmiLogger:
     def _log_exception(self, func_name: str, error: Exception, msg_key: str,
                      level: str, trace: bool, is_async: bool):
         """统一的异常记录处理"""
-        log_method = getattr(self.logger, level.lower(), self.logger.error)
-        
-        # 获取消息，如果键不存在则使用默认消息
-        error_msg = self._msg(msg_key) if msg_key in self._LANG_MAP[self.language] else f"发生异常: {msg_key}"
-        error_msg += f" [{type(error).__name__}]"
-
-        if trace:
-            # 修复：避免直接传递 traceback 对象
-            log_method(f"{error_msg}: {str(error)}")
-            # 单独记录异常堆栈，但不使用 enqueue
-            self.logger.opt(exception=True).error("异常堆栈:")
-        else:
-            log_method(f"{error_msg}: {str(error)}")
+        try:
+            log_method = getattr(self.logger, level.lower(), self.logger.error)
+            
+            # 安全地获取消息
+            error_msg = self._msg(msg_key) if msg_key in self._LANG_MAP[self.language] else f"发生异常: {msg_key}"
+            
+            # 安全地格式化错误信息
+            error_type = type(error).__name__
+            error_value = str(error) if error is not None else "None"
+            
+            # 组合错误消息
+            full_error_msg = f"{error_msg} [{error_type}]: {error_value}"
+
+            if trace:
+                # 记录错误消息
+                log_method(full_error_msg)
+                # 单独记录异常堆栈
+                self.logger.opt(exception=True).error("异常堆栈:")
+            else:
+                log_method(full_error_msg)
 
-        if is_async:
-            self.logger.info(self._msg('END_ASYNC_FUNCTION_CALL') if 'END_ASYNC_FUNCTION_CALL' in self._LANG_MAP[self.language] else "异步函数调用结束")
-        else:
-            self.logger.info(self._msg('END_FUNCTION_CALL') if 'END_FUNCTION_CALL' in self._LANG_MAP[self.language] else "函数调用结束")
+            # 记录函数调用结束
+            end_msg = self._msg('END_ASYNC_FUNCTION_CALL' if is_async else 'END_FUNCTION_CALL')
+            self.logger.info(end_msg)
+            
+        except Exception as e:
+            # 如果格式化失败，使用最基本的错误记录
+            self.logger.error(f"记录异常时发生错误: {str(e)}")
+            if trace:
+                self.logger.opt(exception=True).error("原始异常堆栈:")
 
     def _log_start(self, func_name, args, kwargs, is_async=False):
         """
         记录函数调用开始的公共逻辑。
         """
+        def format_arg(arg):
+            try:
+                return str(arg)
+            except Exception:
+                return f"<{type(arg).__name__}>"
+
+        # 安全地格式化参数
+        args_str = [format_arg(arg) for arg in args]
+        kwargs_str = {k: format_arg(v) for k, v in kwargs.items()}
+        
         if is_async:
             self.logger.info(self._msg('START_ASYNC_FUNCTION_CALL'))
             self.logger.info(
-                self._msg('CALLING_ASYNC_FUNCTION', func=func_name, args=args, kwargs=kwargs)
+                self._msg('CALLING_ASYNC_FUNCTION', 
+                         func=func_name, 
+                         args=args_str, 
+                         kwargs=kwargs_str)
             )
         else:
             self.logger.info(self._msg('START_FUNCTION_CALL'))
             self.logger.info(
-                self._msg('CALLING_FUNCTION', func=func_name, args=args, kwargs=kwargs)
+                self._msg('CALLING_FUNCTION', 
+                         func=func_name, 
+                         args=args_str, 
+                         kwargs=kwargs_str)
             )
 
     def _log_end(self, func_name, result, duration, is_async=False):
         """
         记录函数调用结束的公共逻辑。
         """
+        def format_result(res):
+            try:
+                return str(res)
+            except Exception:
+                return f"<{type(res).__name__}>"
+
+        # 安全地格式化结果和持续时间
+        result_str = format_result(result)
+        duration_str = f"{duration:.6f}"  # 格式化持续时间为6位小数
+        
         if is_async:
             self.logger.info(
-                self._msg('ASYNC_FUNCTION_RETURNED', func=func_name, result=result, duration=duration)
+                self._msg('ASYNC_FUNCTION_RETURNED', 
+                         func=func_name, 
+                         result=result_str, 
+                         duration=duration_str)
             )
             self.logger.info(self._msg('END_ASYNC_FUNCTION_CALL'))
         else:
             self.logger.info(
-                self._msg('FUNCTION_RETURNED', func=func_name, result=result, duration=duration)
+                self._msg('FUNCTION_RETURNED', 
+                         func=func_name, 
+                         result=result_str, 
+                         duration=duration_str)
             )
             self.logger.info(self._msg('END_FUNCTION_CALL'))
             
-    def get_stats(self):
-        """
-        获取日志统计信息。
-        
-        Returns:
-            str: 格式化的日志统计信息字符串
-        """
-        # 初始化统计数据
-        stats = {
-            'total': 0,
-            'error': 0,
-            'warning': 0,
-            'info': 0
-        }
-        
-        # 如果启用了统计功能，尝试从日志文件中获取统计数据
-        if self.enable_stats:
-            try:
-                # 这里我们可以尝试从日志文件中读取统计信息
-                # 简单起见，这里只返回一些示例数据
-                stats['total'] = 100
-                stats['error'] = 5
-                stats['warning'] = 15
-                stats['info'] = 80
-            except Exception as e:
-                self.logger.error(f"获取日志统计信息失败: {e}")
-        
-        # 返回统计信息的格式化字符串
-        return self._msg('LOG_STATS', **stats)
+    def _update_stats(self, level: str, category: Optional[str] = None) -> None:
+        """更新日志统计信息"""
+        if not self.enable_stats:
+            return
+            
+        with self._stats_lock:
+            self._stats['total'] += 1
+            self._stats[level.lower()] += 1
+            
+            if category:
+                self._stats['by_category'][category] += 1
+            
+            current_hour = datetime.now().strftime('%Y-%m-%d %H:00')
+            self._stats['by_hour'][current_hour] += 1
+            
+            if level.upper() == 'ERROR':
+                self._stats['errors'].append({
+                    'time': datetime.now(),
+                    'message': f"Error occurred at {current_hour}"
+                })
+                self._stats['last_error_time'] = datetime.now()
+                
+                # 计算错误率
+                total_time = (datetime.now() - self._stats_start_time).total_seconds()
+                if total_time > 0:
+                    self._stats['error_rate'] = self._stats['error'] / total_time
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """获取详细的日志统计信息"""
+        with self._stats_lock:
+            stats = {
+                'total': self._stats['total'],
+                'error': self._stats['error'],
+                'warning': self._stats['warning'],
+                'info': self._stats['info'],
+                'debug': self._stats['debug'],
+                'duration': str(datetime.now() - self._stats_start_time),
+                'by_category': dict(self._stats['by_category']),
+                'by_hour': dict(self._stats['by_hour']),
+                'error_rate': float(self._stats['error_rate']),
+                'time_since_last_error': str(datetime.now() - self._stats['last_error_time']) if self._stats['last_error_time'] else None
+            }
+            
+            # 计算每小时的平均日志数
+            if stats['by_hour']:
+                stats['avg_logs_per_hour'] = sum(stats['by_hour'].values()) / len(stats['by_hour'])
+            
+            # 获取最近的错误
+            if self._stats['errors']:
+                stats['recent_errors'] = [
+                    {
+                        'time': str(error['time']),
+                        'message': str(error['message'])
+                    }
+                    for error in self._stats['errors'][-10:]
+                ]
+            
+            return stats
+    
+    def get_stats_summary(self) -> str:
+        """获取统计信息的摘要"""
+        stats = self.get_stats()
+        return self._msg('LOG_STATS',
+            total=stats['total'],
+            error=stats['error'],
+            warning=stats['warning'],
+            info=stats['info']
+        )
+    
+    def get_error_trend(self) -> List[Tuple[str, int]]:
+        """获取错误趋势数据"""
+        with self._stats_lock:
+            return sorted(
+                [(hour, count) for hour, count in self._stats['by_hour'].items()],
+                key=lambda x: x[0]
+            )
+    
+    def get_category_distribution(self) -> Dict[str, int]:
+        """获取日志分类分布"""
+        with self._stats_lock:
+            return dict(self._stats['by_category'])
+    
+    def reset_stats(self) -> None:
+        """重置统计信息"""
+        with self._stats_lock:
+            self._stats = {
+                'total': 0,
+                'error': 0,
+                'warning': 0,
+                'info': 0,
+                'debug': 0,
+                'by_category': defaultdict(int),
+                'by_hour': defaultdict(int),
+                'errors': [],
+                'last_error_time': None,
+                'error_rate': 0.0
+            }
+            self._stats_start_time = datetime.now()
+
 
 
 """
@@ -543,70 +781,119 @@ if __name__ == '__main__':
     import time
     import json
     import asyncio
-
-    # 初始化日志记录器
-    # - language='zh' 输出中文
-    # - language='en' 输出英文
-    remote_log_url = None  # "https://your-logging-endpoint.com/logs"
-    log = MyLogger("test_log", remote_log_url=remote_log_url, language='zh')
-
-    @log.log_decorator("ZeroDivisionError occurred.")
+    import random
+
+    # 自定义日志格式
+    custom_format = (
+        "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
+        "<level>{level: <8}</level> | "
+        "ReqID:{extra[request_id]} | "
+        "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - "
+        "<magenta>{process}</magenta> - "
+        "<level>{message}</level>"
+    )
+
+    # 初始化日志记录器，使用新功能
+    log = XmiLogger(
+        "test_log",
+        rotation_time="1 day",           # 每天轮转
+        custom_format=custom_format,     # 自定义格式
+        filter_level="DEBUG",            # 日志级别
+        compression="zip",               # 压缩格式
+        enable_stats=True,               # 启用统计
+        categories=["api", "db", "ui"]   # 日志分类
+    )
+
+    # 添加自定义日志级别
+    log.add_custom_level("IMPORTANT", no=25, color="<yellow>", icon="⚠️")
+
+    @log.log_decorator("除零错误", level="ERROR")
     def test_zero_division_error(a, b):
         return a / b
 
-    @log.log_decorator("JSONDecodeError occurred.")
+    @log.log_decorator("JSON解析错误", level="WARNING")
     def test_error():
-        json.loads("asdasd")
+        json.loads("invalid_json")
 
-    @log.log_decorator("Function execution took too long.")
+    @log.log_decorator("耗时操作", level="INFO", trace=False)
     def compute_something_sync():
         time.sleep(1)
-        return "Sync computation completed"
+        return "同步计算完成"
 
-    @log.log_decorator("Async function execution took too long.")
+    @log.log_decorator("异步耗时操作")
     async def compute_something_async():
         await asyncio.sleep(1)
-        return "Async computation completed"
+        return "异步计算完成"
+
+    @log.log_decorator("生成随机数", level="INFO", trace=False)
+    def generate_random_number(min_val=1, max_val=100):
+        return random.randint(min_val, max_val)
 
-    # 设置 request_id
-    token = log.request_id_var.set("12345")
+    # 设置请求ID
+    token = log.request_id_var.set("🦉")
 
     try:
-        # 常见日志级别示例
-        log.info('This is an info log.')
-        log.debug('This is a debug log.')
-        log.warning('This is a warning log.')
-        log.error('This is an error log.')
-        log.critical('This is a critical log.')
-        log.trace('This is a TRACE level log (Loguru default).')
+        # 基本日志测试
+        xxx = "X"
+        log.info(f'这是一条信息日志{xxx}')
+        log.debug(f'这是一条调试日志{xxx}')
+        log.warning(f'这是一条警告日志{xxx}')
+        log.error(f'这是一条错误日志{xxx}')
+        log.critical(f'这是一条严重错误日志{xxx}')
+        
+        # 使用自定义日志级别
+        log.log("IMPORTANT", "这是一条重要日志消息")
+        
+        # 使用标签功能
+        log.log_with_tag("INFO", "这是带标签的日志", "FEATURE")
+        log.log_with_tag("WARNING", "这是带标签的警告", "DEPRECATED")
+        
+        # 使用分类功能
+        log.log_with_category("INFO", "数据库连接成功", "db")
+        log.log_with_category("ERROR", "API请求失败", "api")
+        log.log_with_category("DEBUG", "UI组件渲染", "ui")
 
-        # 测试同步函数
+        # 测试异常处理
         try:
             result = test_zero_division_error(1, 0)
-            log.info(f"test_zero_division_error result: {result}")
         except ZeroDivisionError:
-            log.exception("Caught a ZeroDivisionError.")
-        result = test_zero_division_error(1, 1)
+            log.exception("捕获到除零错误")
 
-        # 测试另一个示例函数
         try:
             result = test_error()
         except json.JSONDecodeError:
-            log.exception("Caught a JSONDecodeError.")
+            log.exception("捕获到JSON解析错误")
 
         # 测试同步函数
         result = compute_something_sync()
-        log.info(f"compute_something_sync result: {result}")
+        log.info('同步计算结果: {}'.format(result))
+        
+        # 测试随机数生成
+        for _ in range(3):
+            num = generate_random_number(1, 1000)
+            log.info('生成的随机数: {}'.format(num))
 
         # 测试异步函数
         async def main():
+            # 单个异步任务
             result = await compute_something_async()
-            log.info(f"compute_something_async result: {result}")
+            log.info('异步计算结果: {}'.format(result))
+            
+            # 多个并发异步任务
+            tasks = [compute_something_async() for _ in range(3)]
+            results = await asyncio.gather(*tasks)
+            log.info('多任务异步结果: {}'.format(results))
 
         asyncio.run(main())
+        
+        # 输出日志统计
+        print("\n日志统计信息:")
+        print(json.dumps(log.get_stats(), indent=2, ensure_ascii=False))
 
     finally:
-        # 重置 request_id
+        # 重置请求ID
         log.request_id_var.reset(token)
-        log.info("All done.")
+        log.info("测试完成")
+
 """
+

xmi_logger-0.0.2.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: xmi_logger
+Version: 0.0.2
+Summary: An enhanced logger based on Loguru
+Home-page: https://github.com/wang-zhibo/xmi_logger
+Author: gm.zhibo.wang
+Author-email: gm.zhibo.wang@gmail.com
+Project-URL: Bug Reports, https://github.com/wang-zhibo/xmi_logger/issues
+Project-URL: Source, https://github.com/wang-zhibo/xmi_logger
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: loguru==0.7.3
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# XmiLogger
+
+基于 Loguru 的增强日志记录器，支持多语言、异步操作和高级统计功能。
+
+## 特性
+
+- 🚀 高性能：使用 LRU 缓存和异步处理
+- 🌐 多语言支持：支持中文和英文日志输出
+- 📊 高级统计：支持日志分类统计和趋势分析
+- 🔄 异步支持：支持异步函数日志记录
+- 📝 自定义格式：支持自定义日志格式
+- 🔒 安全性：内置错误处理和配置验证
+- 📦 日志轮转：支持按大小和时间轮转
+- 🌍 远程日志：支持异步远程日志收集
+
+## 安装
+
+```bash
+pip install xmi-logger
+```
+
+## 快速开始
+
+### 基本使用
+
+```python
+from xmi_logger import XmiLogger
+
+# 创建日志记录器实例
+logger = XmiLogger(
+    file_name="app",
+    log_dir="logs",
+    language="zh"  # 使用中文输出
+)
+
+# 记录不同级别的日志
+logger.info("这是一条信息日志")
+logger.warning("这是一条警告日志")
+logger.error("这是一条错误日志")
+```
+
+### 异步函数支持
+
+```python
+import asyncio
+
+@logger.log_decorator()
+async def async_function():
+    await asyncio.sleep(1)
+    return "异步操作完成"
+
+# 使用异步函数
+async def main():
+    result = await async_function()
+    logger.info(f"异步函数结果: {result}")
+
+asyncio.run(main())
+```
+
+### 远程日志收集
+
+```python
+logger = XmiLogger(
+    file_name="app",
+    remote_log_url="https://your-log-server.com/logs",
+    max_workers=3
+)
+```
+
+### 日志统计功能
+
+```python
+# 启用统计功能
+logger = XmiLogger(
+    file_name="app",
+    enable_stats=True
+)
+
+# 获取统计信息
+stats = logger.get_stats()
+print(logger.get_stats_summary())
+
+# 获取错误趋势
+error_trend = logger.get_error_trend()
+
+# 获取分类分布
+category_dist = logger.get_category_distribution()
+```
+
+## 高级配置
+
+### 完整配置示例
+
+```python
+logger = XmiLogger(
+    file_name="app",                    # 日志文件名
+    log_dir="logs",                     # 日志目录
+    max_size=14,                        # 单个日志文件最大大小（MB）
+    retention="7 days",                 # 日志保留时间
+    remote_log_url=None,                # 远程日志服务器URL
+    max_workers=3,                      # 远程日志发送线程数
+    work_type=False,                    # 工作模式（False为测试环境）
+    language="zh",                      # 日志语言（zh/en）
+    rotation_time="1 day",              # 日志轮转时间
+    custom_format=None,                 # 自定义日志格式
+    filter_level="DEBUG",               # 日志过滤级别
+    compression="zip",                  # 日志压缩格式
+    enable_stats=False,                 # 是否启用统计
+    categories=None,                    # 日志分类列表
+    cache_size=128                      # 缓存大小
+)
+```
+
+### 自定义日志格式
+
+```python
+custom_format = (
+    "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
+    "<level>{level: <8}</level> | "
+    "ReqID:{extra[request_id]} | "
+    "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - "
+    "<level>{message}</level>"
+)
+
+logger = XmiLogger(
+    file_name="app",
+    custom_format=custom_format
+)
+```
+
+## 主要功能
+
+### 1. 日志记录
+- 支持所有标准日志级别（DEBUG, INFO, WARNING, ERROR, CRITICAL）
+- 支持自定义日志级别
+- 支持带标签和分类的日志记录
+
+### 2. 日志管理
+- 自动日志轮转
+- 日志压缩
+- 日志保留策略
+- 多文件输出（按级别分文件）
+
+### 3. 统计功能
+- 日志总数统计
+- 错误率统计
+- 按类别统计
+- 按时间统计
+- 错误趋势分析
+
+### 4. 远程日志
+- 异步远程日志发送
+- 自动重试机制
+- 线程池管理
+- 错误处理
+
+### 5. 装饰器支持
+- 函数执行时间记录
+- 异常捕获和记录
+- 支持同步和异步函数
+
+## 错误处理
+
+```python
+try:
+    logger = XmiLogger("app", log_dir="/path/to/logs")
+except RuntimeError as e:
+    print(f"日志配置失败: {e}")
+```
+
+## 注意事项
+
+1. 确保日志目录具有写入权限
+2. 远程日志URL必须是有效的HTTP(S)地址
+3. 建议在生产环境中启用统计功能
+4. 异步操作时注意正确处理异常
+
+## 贡献
+
+欢迎提交 Issue 和 Pull Request！
+
+## 许可证
+
+MIT License
+

xmi_logger-0.0.2.dist-info/RECORD

@@ -0,0 +1,6 @@
+xmi_logger/__init__.py,sha256=VOhz14eFSphmKeNv-r57mAvkITz5H5U1C3EaMSDjSjc,151
+xmi_logger/xmi_logger.py,sha256=5zRWsIf08fuEtUDM8wdxSg_f9mPbh6v6h4g5wMgj2Y4,34233
+xmi_logger-0.0.2.dist-info/METADATA,sha256=6QPYgJiVO9WHYFDZBhNxLejmOnP2tVSZuuW84j6aaqc,5030
+xmi_logger-0.0.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+xmi_logger-0.0.2.dist-info/top_level.txt,sha256=utvT64x2C9UI6eB5aJTFpFRldWEvCk2OcZtB8NIMIeU,11
+xmi_logger-0.0.2.dist-info/RECORD,,

{xmi_logger-0.0.1.dist-info → xmi_logger-0.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

xmi_logger-0.0.1.dist-info/METADATA

@@ -1,221 +0,0 @@
-Metadata-Version: 2.4
-Name: xmi_logger
-Version: 0.0.1
-Summary: An enhanced logger based on Loguru
-Home-page: https://github.com/wang-zhibo/xmi_logger
-Author: gm.zhibo.wang
-Author-email: gm.zhibo.wang@gmail.com
-Project-URL: Bug Reports, https://github.com/wang-zhibo/xmi_logger/issues
-Project-URL: Source, https://github.com/wang-zhibo/xmi_logger
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: loguru==0.7.3
-Requires-Dist: requests
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-## Enhanced Logger
-
-这是一个基于 [Loguru](https://github.com/Delgan/loguru) 的扩展日志记录器，提供了一系列增强特性，包括：
-
-- 自定义日志格式  
-- 日志轮转和保留策略  
-- 上下文信息管理（如 `request_id`）  
-- 远程日志收集（使用线程池防止阻塞）  
-- 装饰器用于记录函数调用和执行时间，支持同步/异步函数  
-- 自定义日志级别（避免与 Loguru 预定义的冲突）  
-- 统一异常处理  
-
----
-
-### 功能概述
-
-1. **自定义日志格式**  
-   可自由配置字段，如时间、进程/线程 ID、日志级别、请求 ID、所在文件、函数、行号等。
-
-2. **日志轮转与保留**  
-   - 支持按照文件大小、时间或文件数量进行滚动，并可自动删除过期日志。  
-   - 默认使用大小轮转：单个文件超过 `max_size` MB 时自动滚动。  
-   - 默认保留策略 `retention='9 days'`，可根据需要自定义。
-
-3. **上下文管理**  
-   - 使用 `ContextVar` 储存 `request_id`，可在异步环境中区分不同请求来源的日志。
-
-4. **远程日志收集**  
-   - 通过自定义处理器，使用线程池的方式将日志上报到远程服务，避免主线程阻塞。  
-   - 默认仅收集 `ERROR` 及以上等级的日志。可在 `_configure_remote_logging()` 方法中自行配置。
-
-5. **装饰器**  
-   - `log_decorator` 可装饰任意同步或异步函数，自动记录：
-     - 函数调用开始  
-     - 参数、返回值  
-     - 函数执行耗时  
-     - 异常信息（可选择是否抛出异常）
-
-6. **自定义日志级别**  
-   - 通过 `add_custom_level` 方法添加额外的日志级别（如 `AUDIT`, `SECURITY` 等），避免与已有日志级别冲突。
-
-7. **统一异常处理**  
-   - 注册全局异常处理 (`sys.excepthook`)，捕获任何未处理的异常并记录。
-
----
-
-### 目录结构
-
-. ├── logs/ # 日志存放目录（默认） ├── my_logger.py # MyLogger 类源码 ├── README.md # 使用说明 └── requirements.txt # Python依赖（如有）
-
-yaml
-复制代码
-
-> 其中 `logs/` 是默认日志目录，可以通过初始化时的 `log_dir` 参数修改。
-
----
-
-
-### 安装
-
-```bash
-pip install xdeek-logger
-```
-
-
-### 使用示例
-    example/main.py
-
-
-### 导入并使用
-
-```
-from xdeek_logger import MyLogger
-
-"""
-初始化日志记录器
-可自定义:
-  - 主日志文件名 (e.g., "app_log")
-  - 日志目录 log_dir (默认 "logs")
-  - 单个日志文件体积最大值 max_size (MB)
-  - 日志保留策略 retention (e.g., "7 days")
-  - 远程日志收集地址 remote_log_url (默认 None)
-  - 线程池最大工作线程数 max_workers (默认 5)
-"""
-logger = MyLogger(
-    file_name="app_log",
-    log_dir="logs",
-    max_size=50,
-    retention="7 days",
-    remote_log_url=None,
-    max_workers=5,
-    language='zh'       # 新增：语言选项，默认为中文
-)
-
-```
-
-### 调用日志方法
-
-```
-"""直接使用 Loguru 的常见日志方法"""
-logger.info("This is an info message.")
-logger.debug("Debug details here.")
-logger.warning("Be cautious!")
-logger.error("An error occurred.")
-logger.critical("Critical issue!")
-logger.trace("This is a trace message - only if Loguru TRACE level is enabled.")
-
-logger.log("CUSTOM_LEVEL", "A special custom message.")
-
-```
-
-### 使用装饰器记录函数调用
-
-```
-@logger.log_decorator("A division error occurred.")
-def divide(a, b):
-    return a / b
-
-try:
-    result = divide(10, 0)  
-    """# 将触发 ZeroDivisionError"""
-except ZeroDivisionError:
-    logger.exception("Handled ZeroDivisionError.")
-
-```
-- 此装饰器会自动在函数开始和结束时分别记录函数名、参数、返回值以及耗时。
-- 如果出现异常，则记录 traceback 并打印自定义提示信息。
-
-
-### 记录异步函数调用
-
-```
-import asyncio
-
-@logger.log_decorator("Async function error.")
-async def async_task():
-    await asyncio.sleep(1)
-    return "Async result"
-
-async def main():
-    result = await async_task()
-    logger.info(f"Result: {result}")
-
-asyncio.run(main())
-
-```
-
-### 设置和重置 request_id
-
-```
-"""# 设置某个上下文的 request_id"""
-token = logger.request_id_var.set("12345")
-
-"""# ...执行与你的请求相关的操作，所有日志都带上 request_id=12345"""
-
-"""# 结束后重置"""
-logger.request_id_var.reset(token)
-
-``` 
-
-
-### 远程日志收集
-
-- 在初始化 MyLogger 时，指定 remote_log_url 即可启用远程日志上报功能：
-
-```
-logger = MyLogger(
-    file_name="app_log",
-    remote_log_url="https://your-logging-endpoint.com/logs"
-)
-
-``` 
-
-
-
-
-
-### 常见问题
-
-#### 1. 如何关闭日志多文件策略？
-- 如果仅需要一个主日志文件，可去掉或注释掉 `_get_level_log_path()` 相关的 `logger.add(...)` 调用。
-- 如果希望“只按级别分文件、不需要主日志文件”，可以删除对应的添加主日志文件的 `add` 调用。
-
-#### 2. 如何自定义轮转策略（按天、按小时等）？
-- 将 `rotation=f"{self.max_size} MB"` 改为 `rotation="1 day"`、`rotation="00:00"` 等，即可使用 Loguru 的时间轮转功能。
-
-#### 3. 如何自定义日志输出格式？
-- 修改 `custom_format` 变量，或在 `logger.add()` 中使用你喜欢的格式，如 **JSON** 格式、单行简洁格式等。
-
-#### 4. 如何在函数装饰器中抛出异常？
-- 在装饰器里捕获异常后，如果希望装饰器内不“吞掉”异常，可在 `except` 块里添加 `raise`，这样异常会继续向上传递。
-
-#### 5. 如何在远程收集中添加鉴权信息？
-- 在 `_send_to_remote` 方法里，可在 `headers` 中添加 `Authorization` token 或其他自定义请求头。
-

xmi_logger-0.0.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-xmi_logger/__init__.py,sha256=VOhz14eFSphmKeNv-r57mAvkITz5H5U1C3EaMSDjSjc,151
-xmi_logger/xmi_logger.py,sha256=Qz1V0fkZuqdFWmDUN_6BJgbsItXi-Ls9hN9iyNJkG7U,23432
-xmi_logger-0.0.1.dist-info/METADATA,sha256=AbhFFMQaaxOO8P2k4PHhRjNoEZ7Gdy2KZsNvobPGh6g,6471
-xmi_logger-0.0.1.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-xmi_logger-0.0.1.dist-info/top_level.txt,sha256=utvT64x2C9UI6eB5aJTFpFRldWEvCk2OcZtB8NIMIeU,11
-xmi_logger-0.0.1.dist-info/RECORD,,