mlog-util 0.1.6__tar.gz → 0.1.7__tar.gz

{mlog_util-0.1.6 → mlog_util-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlog-util
-Version: 0.1.6
+Version: 0.1.7
 Summary: Add your description here
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{mlog_util-0.1.6 → mlog_util-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mlog-util"
-version = "0.1.6"
+version = "0.1.7"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"

{mlog_util-0.1.6 → mlog_util-0.1.7}/src/mlog_util/__init__.py

@@ -1,3 +1,5 @@
 from .log_manager import LogManager, get_logger
 from .handlers import MultiProcessSafeSizeRotatingHandler, MultiProcessSafeTimeRotatingHandler
 
+__version__ = "0.1.7"
+

{mlog_util-0.1.6 → mlog_util-0.1.7}/src/mlog_util/handlers.py

@@ -5,6 +5,8 @@ import glob
 import errno
 import logging
 import portalocker
+from pathlib import Path
+import re
 from abc import ABC, abstractmethod
 
 
@@ -234,20 +236,34 @@ class MultiProcessSafeSizeRotatingHandler(MultiProcessSafeRotatingHandlerBase):
 
     def _do_rollover_impl(self):
         # 轮转备份文件
+        log_path = Path(self.filename)
+
+        # 1. 轮转已存在的备份文件 (例如 .3 -> .4, .2 -> .3, .1 -> .2)
+        # 倒序处理，避免覆盖
         for i in range(self.backupCount - 1, 0, -1):
-            sfn = f"{self.filename}.{i}"
-            dfn = f"{self.filename}.{i+1}"
-            if os.path.exists(sfn):
-                if os.path.exists(dfn):
-                    os.remove(dfn)
-                os.rename(sfn, dfn)
-        if os.path.exists(self.filename):
-            dfn = f"{self.filename}.1"
-            if os.path.exists(dfn):
-                os.remove(dfn)
-            os.rename(self.filename, dfn)
-
-        # 重新创建空的日志文件
+            sfn = log_path.with_suffix(f'.log.{i}')
+            dfn = log_path.with_suffix(f'.log.{i+1}')
+
+            if sfn.exists():
+                try:
+                    # 直接尝试重命名，如果目标文件已存在会失败
+                    os.rename(sfn, dfn)
+                except FileExistsError:
+                    # 如果失败，说明目标文件已存在，先删除再重命名
+                    # 这比 "先检查再操作" 更能避免竞态条件
+                    dfn.unlink()  # pathlib 的删除方法
+                    os.rename(sfn, dfn)
+
+        # 2. 将当前日志文件重命名为第一个备份 .1
+        if log_path.exists():
+            dfn = log_path.with_suffix('.log.1')
+            try:
+                os.rename(log_path, dfn)
+            except FileExistsError:
+                dfn.unlink()
+                os.rename(log_path, dfn)
+
+        # 重新创建空的日志文件 占位
         try:
             with open(self.filename, 'w', encoding='utf-8') as f:
                 pass
@@ -268,7 +284,6 @@ class MultiProcessSafeTimeRotatingHandler(MultiProcessSafeRotatingHandlerBase):
         super().__init__(filename, backupCount)
         self.when = when.upper()
         self.interval = max(1, int(interval))  # 至少为 1
-        self.last_rollover = int(time.time())
 
         # 支持的单位映射
         self.when_to_seconds = {
@@ -278,29 +293,90 @@ class MultiProcessSafeTimeRotatingHandler(MultiProcessSafeRotatingHandlerBase):
             'D': 86400,   # 天
         }
 
-    def _should_rollover(self, record) -> bool:
-        now = int(time.time())
-
         if self.when not in self.when_to_seconds:
-            return False
+            raise ValueError(f"Invalid rollover interval specified: {self.when}")
+        
+        # 在初始化时就计算好下一个轮转时间点
+        self.rolloverAt = self._compute_next_rollover_time(int(time.time()))
 
-        seconds_per_unit = self.when_to_seconds[self.when]
-        total_interval_seconds = seconds_per_unit * self.interval
+    def _compute_next_rollover_time(self, current_time):
+        """
+        计算下一个轮转的时间点（时间戳）。
+        这个方法的核心是使用本地时间来计算，确保轮转发生在正确的本地时间。
+        """
+        t = time.localtime(current_time)
+        
+        # 根据轮转单位，找到当前周期的起始时间点
+        if self.when == 'S':
+            current_period_start = time.mktime((t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, t.tm_wday, t.tm_yday, t.tm_isdst))
+        elif self.when == 'M':
+            current_period_start = time.mktime((t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, 0, t.tm_wday, t.tm_yday, t.tm_isdst))
+        elif self.when == 'H':
+            current_period_start = time.mktime((t.tm_year, t.tm_mon, t.tm_mday, t.tm_hour, 0, 0, t.tm_wday, t.tm_yday, t.tm_isdst))
+        else:  # 'D' or any other
+            current_period_start = time.mktime((t.tm_year, t.tm_mon, t.tm_mday, 0, 0, 0, t.tm_wday, t.tm_yday, t.tm_isdst))
 
-        # 计算当前属于第几个周期（从 0 开始）
-        current_cycle = now // total_interval_seconds
-        last_cycle = self.last_rollover // total_interval_seconds
+        # 下一个轮转时间点 = 当前周期起始 + N个周期
+        next_rollover_time = current_period_start + (self.interval * self.when_to_seconds[self.when])
 
-        return current_cycle > last_cycle
+        # 如果计算出的时间点已经过了（例如，程序刚好在边界点启动），则再推后一个周期
+        if next_rollover_time <= current_time:
+            next_rollover_time += self.interval * self.when_to_seconds[self.when]
+            
+        return next_rollover_time
+
+    def _should_rollover(self, record) -> bool:
+        """
+        修正3: 判断逻辑改为与下一个轮转时间点比较
+        """
+        # 获取日志记录产生的时间戳
+        record_time = int(record.created)
+        
+        # 如果记录的时间已经超过了我们预定的下一个轮转时间点，则触发轮转
+        return record_time >= self.rolloverAt
 
     def _do_rollover_impl(self):
-        # 按日期重命名，如 log.txt -> log.txt.2025-09-16
+        # 1. 执行轮转：将当前日志文件重命名为带时间戳的文件
         date_str = time.strftime(self._get_rollover_format())
-        dfn = f"{self.filename}.{date_str}"
-        if os.path.exists(self.filename):
-            os.rename(self.filename, dfn)
-        with open(self.filename, 'w'): pass
-        self.last_rollover = int(time.time())
+        log_path = Path(self.filename)
+        dfn = log_path.with_name(f"{log_path.name}.{date_str}")
+
+        if log_path.exists():
+            try:
+                log_path.rename(dfn)
+            except FileExistsError:
+                dfn.unlink()
+                log_path.rename(dfn)
+
+        # 2. 重新创建空的日志文件（使用你指定的方式）
+        try:
+            with open(self.filename, 'w', encoding='utf-8') as f:
+                pass
+        except Exception as e:
+            print(f"Failed to recreate log file {self.filename}: {e}")
+
+        # 3. 更新下一个轮转的时间点（核心逻辑）
+        current_time = int(time.time())
+        self.rolloverAt = self._compute_next_rollover_time(current_time)
+
+        # --- 清理旧备份的逻辑 ---
+        
+        # 4. 查找所有匹配的备份文件
+        backup_pattern = log_path.with_name(f"{log_path.name}.*")
+        backup_files = glob.glob(str(backup_pattern))
+
+        # 5. 如果备份文件数量超过限制，则进行清理
+        if len(backup_files) > self.backupCount:
+            # 6. 按文件名（即时间戳）排序，找出最旧的文件
+            backup_files.sort()
+            
+            # 7. 计算需要删除的文件数量并删除
+            files_to_delete = backup_files[:-self.backupCount]
+            for file_to_delete in files_to_delete:
+                try:
+                    Path(file_to_delete).unlink()
+                except OSError as e:
+                    print(f"Error deleting old log file {file_to_delete}: {e}")
 
     def _get_rollover_format(self):
         """

{mlog_util-0.1.6 → mlog_util-0.1.7}/src/mlog_util/log_manager.py

@@ -19,7 +19,7 @@ class LogManager:
         log_file: Optional[str] = None,
         add_console: bool = True,
         level: int = logging.INFO,
-        custom_handlers: Optional[List[logging.Handler]] = None,
+        custom_handlers: Optional[logging.Handler] = None,
     ) -> logging.Logger:
         """
         获取或创建一个配置好的 logger。
@@ -69,10 +69,9 @@ class LogManager:
                     "%(asctime)s | %(name)s | %(levelname)-8s | %(message)s",
                     datefmt="%Y-%m-%d %H:%M:%S"
                 )
-                for handler in custom_handlers:
-                    if handler not in logger.handlers:
-                        handler.setFormatter(custom_formatter)
-                        logger.addHandler(handler)
+                if custom_handlers not in logger.handlers:
+                    custom_handlers.setFormatter(custom_formatter)
+                    logger.addHandler(custom_handlers)
 
             return logger
 

{mlog_util-0.1.6 → mlog_util-0.1.7}/src/mlog_util.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlog-util
-Version: 0.1.6
+Version: 0.1.7
 Summary: Add your description here
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{mlog_util-0.1.6 → mlog_util-0.1.7}/src/mlog_util.egg-info/SOURCES.txt

@@ -7,4 +7,5 @@ src/mlog_util.egg-info/SOURCES.txt
 src/mlog_util.egg-info/dependency_links.txt
 src/mlog_util.egg-info/requires.txt
 src/mlog_util.egg-info/top_level.txt
-tests/test_mlog.py
+tests/test_size.py
+tests/test_time.py

mlog_util-0.1.7/tests/test_size.py

@@ -0,0 +1,175 @@
+import os
+import time
+import glob
+import shutil
+import multiprocessing
+from src.mlog_util import MultiProcessSafeSizeRotatingHandler, get_logger
+
+# --- 修复：将工作函数定义为顶级函数 ---
+
+def write_logs_worker(process_id, num_messages=1000):
+    """在指定进程中写入日志（用于测试1）"""
+    handler = MultiProcessSafeSizeRotatingHandler(
+        filename="logs/size.log",
+        maxBytes=1 * 1024 * 1024,  # 1MB
+        backupCount=5
+    )
+    logger = get_logger(f"test_process_{process_id}", custom_handlers=handler, add_console=False)
+    
+    for i in range(num_messages):
+        logger.info(f"Process {process_id} - Message {i}: " + "x" * 100)  # 每条消息约100字节
+
+def concurrent_rotation_worker(worker_id):
+    """并发轮转测试的工作进程（用于测试3）"""
+    handler = MultiProcessSafeSizeRotatingHandler(
+        filename="logs/size.log",
+        maxBytes=500 * 1024,  # 500KB
+        backupCount=3
+    )
+    logger = get_logger(f"worker_{worker_id}", custom_handlers=handler, add_console=False)
+    
+    for i in range(200):
+        logger.info(f"Worker {worker_id} - Log {i}: " + "z" * 150)
+        time.sleep(0.01)  # 模拟实际工作负载
+
+# --- 测试函数 ---
+
+def setup_test_environment():
+    """设置测试环境，清理旧的日志文件"""
+    if os.path.exists("logs"):
+        shutil.rmtree("logs")
+    os.makedirs("logs", exist_ok=True)
+
+def test_large_backup_count():
+    """测试1: 大backupCount，验证轮转是否生效，日志是否丢失"""
+    print("\n=== 测试1: 大backupCount测试 ===")
+    setup_test_environment()
+    
+    # 启动多个进程写入日志
+    processes = []
+    for i in range(3):
+        # 使用顶级函数
+        p = multiprocessing.Process(target=write_logs_worker, args=(i, 500))
+        processes.append(p)
+        p.start()
+    
+    for p in processes:
+        p.join()
+    
+    # 检查日志文件
+    log_files = sorted(glob.glob("logs/size.log*"))
+    print(f"生成的日志文件: {log_files}")
+    
+    # 验证文件数量不超过backupCount+1
+    assert len(log_files) <= 6, f"日志文件数量 {len(log_files)} 超过预期 6"
+    
+    # 验证所有文件内容完整性
+    total_messages = 0
+    for log_file in log_files:
+        with open(log_file, 'r') as f:
+            lines = f.readlines()
+            total_messages += len(lines)
+    
+    print(f"总日志条数: {total_messages} (预期: 1500)")
+    assert total_messages == 1500, f"日志条数 {total_messages} 不等于预期 1500"
+    print("✓ 测试1通过: 大backupCount测试成功")
+
+def test_medium_backup_count():
+    """测试2: 中等backupCount，触发删除机制"""
+    print("\n=== 测试2: 中等backupCount测试 ===")
+    setup_test_environment()
+    
+    # 使用较小的backupCount
+    handler = MultiProcessSafeSizeRotatingHandler(
+        filename="logs/size.log",
+        maxBytes=1 * 1024 * 1024,  # 1MB
+        backupCount=2
+    )
+    logger = get_logger("test_medium", custom_handlers=handler, add_console=False)
+    
+    # 写入足够多的日志以触发多次轮转
+    for i in range(3000):
+        logger.info(f"Message {i}: " + "y" * 200)  # 每条消息约200字节
+    
+    # 检查日志文件
+    log_files = sorted(glob.glob("logs/size.log*"))
+    print(f"生成的日志文件: {log_files}")
+    
+    # 验证文件数量不超过backupCount+1
+    assert len(log_files) <= 3, f"日志文件数量 {len(log_files)} 超过预期 3"
+    
+    # 验证最新的日志文件存在
+    assert os.path.exists("logs/size.log"), "主日志文件不存在"
+    
+    # 验证备份文件编号正确
+    if len(log_files) > 1:
+        assert "size.log.1" in log_files[-1], "备份文件编号不正确"
+    
+    print("✓ 测试2通过: 中等backupCount测试成功")
+
+def test_concurrent_rotation():
+    """测试3: 并发轮转测试"""
+    print("\n=== 测试3: 并发轮转测试 ===")
+    setup_test_environment()
+    
+    # 启动多个工作进程
+    processes = []
+    for i in range(5):
+        # 使用顶级函数
+        p = multiprocessing.Process(target=concurrent_rotation_worker, args=(i,))
+        processes.append(p)
+        p.start()
+    
+    for p in processes:
+        p.join()
+    
+    # 检查日志文件
+    log_files = sorted(glob.glob("logs/size.log*"))
+    print(f"并发测试生成的日志文件: {log_files}")
+    
+    # 验证文件数量
+    assert len(log_files) <= 4, f"并发测试日志文件数量 {len(log_files)} 超过预期 4"
+    
+    # 验证日志完整性
+    total_lines = 0
+    for log_file in log_files:
+        with open(log_file, 'r') as f:
+            total_lines += len(f.readlines())
+    
+    print(f"并发测试总日志条数: {total_lines} (预期: 1000)")
+    assert total_lines == 1000, f"并发测试日志条数 {total_lines} 不等于预期 1000"
+    print("✓ 测试3通过: 并发轮转测试成功")
+
+def run_all_tests():
+    """运行所有测试"""
+    print("开始运行 MultiProcessSafeSizeRotatingHandler 自动化测试...")
+    print(f"当前时间: {time.strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    try:
+        test_large_backup_count()
+        test_medium_backup_count()
+        test_concurrent_rotation()
+        
+        print("\n🎉 所有测试通过!")
+    except AssertionError as e:
+        print(f"\n❌ 测试失败: {e}")
+    except Exception as e:
+        print(f"\n💥 测试出错: {e}")
+        import traceback
+        traceback.print_exc() # 打印详细的错误堆栈
+    finally:
+        # 清理测试环境
+        if os.path.exists("logs"):
+            shutil.rmtree("logs")
+
+if __name__ == "__main__":
+    # 为了安全地在多进程环境中运行，设置启动方法
+    # 'spawn' 是跨平台最安全的方法，但启动开销较大
+    # 'fork' (仅在Unix上可用) 启动快，但可能有一些副作用
+    try:
+        multiprocessing.set_start_method('spawn', force=True)
+    except RuntimeError:
+        # 在某些环境（如Jupyter Notebook）中，可能已经设置了启动方法
+        pass
+    
+    run_all_tests()

mlog_util-0.1.7/tests/test_time.py

@@ -0,0 +1,108 @@
+import os
+import time
+import glob
+import shutil
+import multiprocessing
+from pathlib import Path
+from src.mlog_util import MultiProcessSafeTimeRotatingHandler, get_logger
+
+def setup_test_environment():
+    """设置测试环境，清理旧的日志文件"""
+    if os.path.exists("logs"):
+        shutil.rmtree("logs")
+    os.makedirs("logs", exist_ok=True)
+
+def test_large_backup_count():
+    """测试1: 大backupCount，验证轮转是否生效，日志是否丢失"""
+    print("\n=== 测试1: 大backupCount测试 ===")
+    setup_test_environment()
+
+    handler = MultiProcessSafeTimeRotatingHandler(
+        filename="logs/time.log",
+        when="S",
+        backupCount=5 # 5 * 10 = 50s
+    )
+    logger = get_logger(f"test_time", custom_handlers=handler, add_console=False)
+
+    add_nums = 0
+    for i in range(22):
+        logger.info(f"{i=}")
+        add_nums += 1
+        time.sleep(1)
+    
+    # 检查文件数量
+    files_list = list(Path("logs").glob("time.log*"))
+    files_num = len(files_list)
+    assert files_num == 3, f"日志条数 {files_num} 不等于预期 3"
+    print(f"日志数量 = {files_num}, 符合日志要求")
+    
+    # 验证所有文件内容完整性
+    total_messages = 0
+    for log_file in files_list:
+        with open(log_file, 'r') as f:
+            lines = f.readlines()
+            total_messages += len(lines)
+
+    assert total_messages == 22, f"日志条数 {total_messages} 不等于预期 22"
+    print(f"当前日志一共 {total_messages} 条")
+
+def test_medium_backup_count():
+    """
+    检测轮询的文件数量是否达到预期
+    """
+    print("\n=== 测试1: backupCount数量测试 ===")
+    setup_test_environment()
+
+    handler = MultiProcessSafeTimeRotatingHandler(
+        filename="logs/time.log",
+        when="S", 
+        backupCount=3 # 2 * 10 = 20s
+    )
+    logger = get_logger(f"test_time", custom_handlers=handler, add_console=False)
+    for i in range(32):
+        logger.info(f"{i=}")
+        time.sleep(1)
+
+    # 检查文件数量
+    files_list = list(Path("logs").glob("time.log*"))
+    files_num = len(files_list)
+    assert files_num == 3, f"日志条数 {files_num} 不等于预期 3"
+    print(f"日志数量 = {files_num}, 符合日志要求")
+
+    """
+    TODO: 不知道顺序应该怎么写测试
+    """
+
+def run_all_tests():
+    """运行所有测试"""
+    print("开始运行 MultiProcessSafeTimeRotatingHandler 自动化测试...")
+    try:
+        test_large_backup_count()
+        test_medium_backup_count()
+        # test_concurrent_rotation()
+        
+        print("\n🎉 所有测试通过!")
+    except AssertionError as e:
+        print(f"\n❌ 测试失败: {e}")
+    except Exception as e:
+        print(f"\n💥 测试出错: {e}")
+        import traceback
+        traceback.print_exc() # 打印详细的错误堆栈
+    finally:
+        # 清理测试环境
+        if os.path.exists("logs"):
+            shutil.rmtree("logs")
+        pass
+
+
+if __name__ == "__main__":
+    # 为了安全地在多进程环境中运行，设置启动方法
+    # 'spawn' 是跨平台最安全的方法，但启动开销较大
+    # 'fork' (仅在Unix上可用) 启动快，但可能有一些副作用
+    try:
+        multiprocessing.set_start_method('spawn', force=True)
+    except RuntimeError:
+        # 在某些环境（如Jupyter Notebook）中，可能已经设置了启动方法
+        pass
+    
+    run_all_tests()

mlog_util-0.1.6/tests/test_mlog.py

@@ -1,37 +0,0 @@
-import time
-import os
-import mlog
-from mlog import LogManager
-from multiprocessing import Pool
-
-log_file = "logs/a1.log"
-
-log_manager = LogManager()
-logger_a1 = log_manager.get_logger("a1", log_file=log_file, add_console=False)
-# logger_a2 = log_manager.get_logger("a2", log_file=log_file, add_console=False)
-# logger_a3 = log_manager.get_logger("a3", log_file=log_file, add_console=False)
-
-
-# 测试 num 个 日志耗时
-def test_speed_time(num = 500):
-    import time
-    _st = time.time()
-    for i in range(num):
-        logger_a1.info(i)
-    logger_a1.info(f"{num} --- {time.time() - _st}")
-
-# 测试多进程
-# 1000 个日志有没有
-def test_logger(x):
-    _pid = os.getpid()
-    logger_a1.info(f"{_pid} -- {x}")
-
-
-if __name__ == "__main__":
-    with open(log_file, "w") as f:
-        pass
-    with Pool(2) as pool:
-        pool.map(test_logger, range(0, 5000))
-
-
-