algo-backend-framework 0.0.1__py3-none-any.whl

algo_backend/log/loguru/log_clean.py

@@ -0,0 +1,140 @@
+import os
+import threading
+import time
+from datetime import datetime, timedelta
+from typing import List, Optional
+
+from loguru import logger
+from pydantic import BaseModel, Field
+
+
+class LogInfo(BaseModel):
+    """
+    日志信息
+    """
+
+    file_path: str = Field(..., description="日志文件路径")
+    file_size: Optional[int] = None  # 日志文件大小
+    create_time: Optional[datetime] = None  # 日志文件创建时间
+    modify_time: Optional[datetime] = None  # 日志文件修改时间
+    access_time: Optional[datetime] = None  # 日志文件访问时间
+
+    @classmethod
+    def gen(cls, file_path: str):
+        if not os.path.exists(file_path):
+            return cls(file_path=file_path)
+        return cls(
+            file_path=file_path,
+            file_size=os.path.getsize(file_path),
+            create_time=datetime.fromtimestamp(os.path.getctime(file_path)),
+            modify_time=datetime.fromtimestamp(os.path.getmtime(file_path)),
+            access_time=datetime.fromtimestamp(os.path.getatime(file_path)),
+        )
+
+
+class LoguruCleaner:
+    """
+    清理时间较长的日志，默认保留60天的日志
+    """
+
+    def __init__(self, log_dir: str, retention_day: int = 60):
+        """
+        :param log_dir: 日志目录
+        :param retention_day: 保留天数
+        """
+        self.retention_day = retention_day
+        self.log_dir = log_dir
+        self.current_time: datetime = datetime.now()
+        self.threshold_time: datetime = self.current_time - timedelta(
+            days=self.retention_day
+        )
+
+    def scan_log(self) -> List[LogInfo]:
+        """
+        扫描日志目录，返回所有日志文件
+        """
+        log_files = []
+        if os.path.exists(self.log_dir):
+            log_files = [
+                LogInfo.gen(os.path.join(self.log_dir, file))
+                for file in os.listdir(self.log_dir)
+                if file.endswith(".log")
+            ]
+        return log_files
+
+    def judge_is_old_log(self, log_file: LogInfo) -> bool:
+        """
+        判断日志文件是否过期
+        过期标准:
+        """
+        if log_file.modify_time and log_file.modify_time < self.threshold_time:
+            return True
+        return False
+
+    def extract_old_log(self) -> List[LogInfo]:
+        """
+        提取过期的日志文件
+        """
+        log_files = self.scan_log()
+
+        if not log_files:
+            logger.debug("No log files found")
+            return []
+
+        logger.debug(
+            f"[ExtractOldLogFiles]: scan [{len(log_files)}] logs from [{self.log_dir}]"
+        )
+
+        old_log_files = [o for o in log_files if self.judge_is_old_log(o)]
+
+        logger.debug(
+            f"[ExtractOldLogFiles]: extract [{len(old_log_files)}] old logs, threshold day [{self.threshold_time}]"
+        )
+
+        return old_log_files
+
+    def delete_log(self, log_file: List[LogInfo]):
+        """
+        删除日志文件
+        """
+        if log_file:
+            logger.debug(f"[DeleteLogFiles]: Start to delete [{len(log_file)}] logs")
+            cnt = 0
+            for log in log_file:
+                try:
+                    os.remove(log.file_path)
+                    logger.debug(f"[DeleteLogFiles]: Delete log [{log.file_path}]")
+                    cnt += 1
+                except FileNotFoundError as e:
+                    logger.warning(
+                        f"[DeleteLogFiles]: Failed to delete log [{log.file_path}], error [{e}]"
+                    )
+
+            logger.debug(f"[DeleteLogFiles]: Delete [{cnt}]/[{len(log_file)}] logs")
+
+    def delete_lod_log(self):
+        """
+        删除过时的日志文件
+        """
+        old_logs = self.extract_old_log()
+        self.delete_log(old_logs)
+
+    @classmethod
+    def schedule_run(cls, log_dir: str, retention_day: int = 60):
+        """
+        启动线程，定时清理日志
+        """
+        # 创建线程
+        interval = 60 * 60 * 24
+
+        def worker():
+            while True:
+                log_cleaner = LoguruCleaner(log_dir, retention_day)
+                logger.debug(
+                    f"pid={os.getpid()} | [ScheduleRun]: Start to run log cleaner, log dir [{log_dir}], retention day [{retention_day}]"
+                )
+                log_cleaner.delete_lod_log()
+                time.sleep(interval)  # 暂停一天
+
+        thread = threading.Thread(target=worker, daemon=True)
+        thread.start()

algo_backend/log/loguru/log_setup.py

@@ -0,0 +1,89 @@
+import os
+import sys
+from typing import Optional
+
+from loguru import logger
+
+from .patch_logging import patch_logging_to_loguru
+
+
+class LoguruSetup:
+    FORMAT = (
+        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
+        "<level>{level: <8}</level> | "
+        "<cyan>p-{process}</cyan> | "
+        "<cyan>t-{thread}</cyan> | "
+        "<cyan>{thread.name}</cyan> | "
+        "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - "
+        "<level>{message}</level>"
+    )
+
+    __IS_SET_ROTATE = False
+
+    @classmethod
+    def rotate_daily(
+        cls,
+        *,
+        log_dir: str,
+        service_name: str,
+        add_pid_suffix: bool = True,
+        save_info: bool = True,
+        save_debug: bool = True,
+        stderr_colorize: bool = True,
+        run_id_suffix: Optional[str] = None,
+    ):
+        """
+        日志输出终端和落盘
+        : params: log_dir: 日志目录
+        : params: service_name: 服务名
+        : params: add_pid_suffix: 是否添加进程ID后缀
+        : params: save_info: 是否保存INFO级别日志
+        : params: save_debug: 是否保存DEBUG级别日志
+        : params: stderr_colorize: 是否启用终端颜色显示
+        : params: run_id_suffix: 运行ID后缀，用于避免多副本时的冲突
+        """
+        if cls.__IS_SET_ROTATE:
+            return
+
+        logger.remove()  # 清空设置，防止重复
+
+        os.makedirs(log_dir, exist_ok=True)
+        pid_suffix = f"_{os.getpid()}" if add_pid_suffix else ""
+        run_id_suffix = f"_r{run_id_suffix}" if run_id_suffix else ""
+
+        # 添加终端处理器（控制台输出）
+        logger.add(
+            sink=sys.stderr,  # 输出到标准错误流
+            level="DEBUG",  # 终端显示更详细的DEBUG日志
+            format=cls.FORMAT,
+            colorize=stderr_colorize,  # 启用颜色显示
+            backtrace=True,  # 堆栈信息显示在终端
+        )
+
+        if save_info:
+            # 配置 INFO 及以上级别日志
+            logger.add(
+                os.path.join(
+                    log_dir, f"{service_name}_info{pid_suffix}{run_id_suffix}.log"
+                ),
+                rotation="1 day",  # 每日滚动
+                filter=lambda record: record["level"].no >= 20,
+                format=cls.FORMAT,
+                enqueue=True,
+            )
+
+        if save_debug:
+            # 配置 DEBUG 级别日志
+            logger.add(
+                os.path.join(
+                    log_dir, f"{service_name}_debug{pid_suffix}{run_id_suffix}.log"
+                ),
+                rotation="1 day",  # 每日滚动
+                level="DEBUG",
+                filter=lambda record: record["level"].no >= 10,
+                format=cls.FORMAT,
+                enqueue=True,
+            )
+        patch_logging_to_loguru()
+        logger.info("日志设置完成")
+        cls.__IS_SET_ROTATE = True

algo_backend/log/loguru/log_starter.py

@@ -0,0 +1,65 @@
+import os
+import socket
+
+from loguru import logger
+
+from algo_backend.config import LoguruConfig as LogConfig
+
+from ..common import BasicLogStarter
+from .log_clean import LoguruCleaner
+from .log_setup import LoguruSetup
+
+
+class LoguruStarter(BasicLogStarter):
+    """
+    容器内日志目录默认是：/logger/服务名
+    """
+
+    def __init__(self, service_name: str):
+        super().__init__(service_name)
+
+    @property
+    def service_log_dir(self):
+        return os.path.join(LogConfig.LOGGER_PATH, self.service_name)
+
+    def setup_log(self):
+        """
+        日志设置
+        """
+
+        LoguruSetup.rotate_daily(
+            log_dir=self.service_log_dir,
+            service_name=self.add_container_id(service_name=self.service_name),
+            add_pid_suffix=True,
+            save_info=LogConfig.SAVE_INFO_LEVEL,
+            save_debug=LogConfig.SAVE_DEBUG_LOG,
+        )
+
+        for pkg in LogConfig.get_disable_log_pkg():
+            # 忽略一些包的日志
+            logger.debug(f"ignore log: {pkg}")
+            logger.disable(pkg)
+
+    def run_log_cleaner(self):
+        """
+        启动定时任务清理日志
+        """
+        LoguruCleaner.schedule_run(
+            log_dir=self.service_log_dir,
+            retention_day=LogConfig.LOG_RETENTION_DAY,
+        )
+
+    @classmethod
+    def add_container_id(cls, service_name: str):
+        if not LogConfig.LOG_ADD_CONTAINED_ID:
+            logger.info("日志名不增加containerId")
+            return service_name
+
+        try:
+            socket_hostname = f"-{socket.gethostname()}"
+        except:
+            socket_hostname = ""
+        if service_name in socket_hostname:
+            return service_name
+        else:
+            return f"{service_name}{socket_hostname}"

algo_backend/log/loguru/patch_logging.py

@@ -0,0 +1,83 @@
+import logging
+
+from loguru import logger
+
+from algo_backend.config import LoguruConfig
+
+disable_log_pkg = LoguruConfig.get_disable_log_pkg()
+
+
+def patch_logging_to_loguru():
+    """
+    将 Python 原生 logging 系统的所有日志重定向到 loguru
+    """
+
+    class LoguruHandler(logging.Handler):
+        def emit(self, record):
+            # 过滤特定模块的日志
+            if any(excluded in record.name for excluded in disable_log_pkg):
+                return
+
+            try:
+                level = logger.level(record.levelname).name
+            except ValueError:
+                level = record.levelno
+
+            # 从当前帧开始，找到真正调用 logging 的位置
+            frame = logging.currentframe()
+            depth = 0  # 从0开始计算，动态确定深度
+
+            # 遍历调用栈，跳过所有 logging 模块的内部调用
+            while frame:
+                filename = frame.f_code.co_filename
+                func_name = frame.f_code.co_name
+
+                # 检查是否为 logging 模块的内部调用
+                is_logging_internal = (
+                    # 标准库 logging 模块路径
+                    "logging" in filename
+                    and (
+                        filename.endswith("logging/__init__.py")
+                        or "/logging/" in filename
+                        or "\\logging\\" in filename
+                    )
+                ) or (
+                    # logging 内部函数名
+                    func_name
+                    in (
+                        "callHandlers",
+                        "handle",
+                        "emit",
+                        "handleError",
+                        "_log",
+                        "makeRecord",
+                        "getLogger",
+                        "debug",
+                        "info",
+                        "warning",
+                        "error",
+                        "exception",
+                        "critical",
+                    )
+                )
+
+                if is_logging_internal:
+                    frame = frame.f_back
+                    depth += 1
+                else:
+                    # 找到真实的调用者，跳出循环
+                    break
+
+            # 如果找不到合适的帧，回退到默认行为
+            if not frame:
+                depth = 2
+
+            logger.opt(depth=depth, exception=record.exc_info).log(
+                level, record.getMessage()
+            )
+
+    # 设置根记录器级别为最低级别，确保所有日志都被处理
+    logging.root.setLevel(logging.DEBUG)
+
+    logging.root.handlers = []
+    logging.root.addHandler(LoguruHandler())

algo_backend/metrics/__init__.py

@@ -0,0 +1,22 @@
+from .collector import AbstractMetricCollector, SystemMetricsMonitor
+from .http_metrics import RequestTimeCostMiddleware
+from .prometheus_context import PrometheusContext
+from .time_cost_metrics import (
+    BasicTimeCostMetrics,
+    ApiTimeCostMetrics,
+    ClientTimeCostMetrics,
+    PrometheusTimeCostMetricSetting,
+)
+
+__all__ = [
+    "SystemMetricsMonitor",
+    "RequestTimeCostMiddleware",
+    "PrometheusContext",
+    # 定时收集指标
+    "AbstractMetricCollector",
+    # 耗时指标
+    "PrometheusTimeCostMetricSetting",
+    "BasicTimeCostMetrics",
+    "ApiTimeCostMetrics",
+    "ClientTimeCostMetrics",
+]

algo_backend/metrics/collector/__init__.py

@@ -0,0 +1,12 @@
+from .common import AbstractMetricCollector
+from .gc_metrics import PythonGcMetricsCollector, PythonGcObjectMetricsCollector
+from .schedule_monitor import MetricsScheduleMonitor
+from .system_metrics import SystemMetricsMonitor
+
+__all__ = [
+    "PythonGcMetricsCollector",
+    "PythonGcObjectMetricsCollector",
+    "AbstractMetricCollector",
+    "MetricsScheduleMonitor",
+    "SystemMetricsMonitor",
+]

algo_backend/metrics/collector/common.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+
+class AbstractMetricCollector(ABC):
+    """指标收集器抽象基类"""
+
+    def __init__(self, interval_sec: int = None):
+        self.collect_interval = interval_sec or 30  # 收集间隔，秒
+
+    @abstractmethod
+    async def collect(self):
+        """收集指标数据"""
+        pass
+
+    def set_interval(self, interval_sec: int):
+        """设置收集间隔"""
+        self.collect_interval = interval_sec

algo_backend/metrics/collector/gc_metrics.py

@@ -0,0 +1,74 @@
+import gc
+import logging
+import os
+
+from prometheus_client import Gauge
+
+from .common import AbstractMetricCollector
+
+logger = logging.getLogger(__name__)
+
+
+class PythonGcMetricsCollector(AbstractMetricCollector):
+    def __init__(self, interval_sec: int = 30):
+        super().__init__(interval_sec=interval_sec)
+        self.pid = os.getpid()
+        # GC 总次数
+        self.gc_collections_total = Gauge(
+            "app_python_gc_collections_total",
+            "Total number of GC collections",
+            ["generation", "pid"],
+        )
+        # 累计回收的对象总数
+        self.gc_collected_total = Gauge(
+            "app_python_gc_collected_total",
+            "Total objects collected",
+            ["generation", "pid"],
+        )
+        # 累计无法回收的对象总数
+        self.gc_uncollectable_total = Gauge(
+            "app_python_gc_uncollectable_total",
+            "Total uncollectable objects",
+            ["generation", "pid"],
+        )
+
+    async def collect(self):
+        try:
+            # 获取当前统计信息
+            stats = gc.get_stats()
+
+            # 更新指标
+            for gen, stat in enumerate(stats):
+                self.gc_collections_total.labels(generation=gen, pid=self.pid).set(
+                    stat.get("collections", 0)
+                )
+                self.gc_collected_total.labels(generation=gen, pid=self.pid).set(
+                    stat.get("collected", 0)
+                )
+                self.gc_uncollectable_total.labels(generation=gen, pid=self.pid).set(
+                    stat.get("uncollectable", 0)
+                )
+
+        except Exception as e:
+            logger.error(f"Error collecting GC metrics: {e}")
+
+
+class PythonGcObjectMetricsCollector(AbstractMetricCollector):
+    def __init__(self, interval_sec: int = 30):
+        super().__init__(interval_sec=interval_sec)
+        self.pid = os.getpid()
+        # 当前时刻回收的对象数
+        self.gc_objects_count = Gauge(
+            "app_python_gc_objects_count",
+            "Current number of objects",
+            ["generation", "pid"],
+        )
+
+    async def collect(self):
+        try:
+            counts = gc.get_count()
+            for gen, count in enumerate(counts):
+                self.gc_objects_count.labels(generation=gen, pid=self.pid).set(count)
+
+        except Exception as e:
+            logger.error(f"Error collecting GC Object metrics: {e}")

algo_backend/metrics/collector/schedule_monitor.py

@@ -0,0 +1,50 @@
+import asyncio
+import logging
+from typing import List
+
+from .common import AbstractMetricCollector
+from .gc_metrics import PythonGcMetricsCollector, PythonGcObjectMetricsCollector
+from .system_metrics import SystemMetricsMonitor
+
+logger = logging.getLogger(__name__)
+
+
+class MetricsScheduleMonitor:
+    """
+    定时收集指标
+    """
+
+    def __init__(self):
+        self.collectors: List[AbstractMetricCollector] = []
+
+    def add(self, collector: AbstractMetricCollector) -> "MetricsScheduleMonitor":
+        self.collectors.append(collector)
+        return self
+
+    def register_default_collectors(self) -> "MetricsScheduleMonitor":
+        """
+        注册默认指标收集器
+        """
+        self.add(SystemMetricsMonitor(interval_sec=30).register_default_collectors())
+        self.add(PythonGcMetricsCollector(interval_sec=30))
+        self.add(PythonGcObjectMetricsCollector(interval_sec=5))
+        return self
+
+    async def run_monitor(self):
+        """运行监控任务"""
+
+        if len(self.collectors) == 0:
+            self.register_default_collectors()
+
+        logger.info(
+            f"Start system metrics monitor, collector num = {len(self.collectors)}"
+        )
+
+        async def schedule_collect(collector: AbstractMetricCollector):
+            """定时收集指标数据"""
+            while True:
+                await collector.collect()
+                await asyncio.sleep(collector.collect_interval)
+
+        for c in self.collectors:
+            asyncio.create_task(schedule_collect(c))