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

algo_backend/metrics/collector/system_metrics.py

@@ -0,0 +1,169 @@
+import asyncio
+import logging
+import os
+import threading
+from abc import ABC
+from typing import List, Type
+
+import psutil
+from prometheus_client import Gauge
+
+from .common import AbstractMetricCollector
+
+logger = logging.getLogger(__name__)
+
+
+class AbstractSystemMetricCollector(AbstractMetricCollector, ABC):
+    """系统指标收集器抽象基类"""
+
+    def __init__(self, process: psutil.Process, pid: int, **kwargs):
+        super().__init__()
+        self.process = process
+        self.pid = pid
+
+
+class CPUMetricCollector(AbstractSystemMetricCollector):
+    """CPU使用率指标收集器"""
+
+    def __init__(self, process: psutil.Process, pid: int):
+        super().__init__(process, pid)
+        self.gauge = Gauge(
+            "cpu_usage_percent",
+            "CPU usage in percent",
+            ["pid"],
+            multiprocess_mode="all",
+        )
+
+    async def collect(self):
+        cpu_usage = self.process.cpu_percent()
+        self.gauge.labels(pid=self.pid).set(cpu_usage)
+
+
+class MemoryMetricCollector(AbstractSystemMetricCollector):
+    """内存使用量指标收集器"""
+
+    def __init__(self, process: psutil.Process, pid: int):
+        super().__init__(process, pid)
+        self.gauge_rss = Gauge(
+            "resident_memory_usage_mb",
+            "Resident Memory usage in MB",
+            ["pid"],
+            multiprocess_mode="all",
+        )
+        self.gauge_vms = Gauge(
+            "virtual_memory_usage_mb",
+            "Virtual Memory usage in MB",
+            ["pid"],
+            multiprocess_mode="all",
+        )
+
+    async def collect(self):
+        memory_info = self.process.memory_info()
+        rss = memory_info.rss / (1024 * 1024)  # resident set size resident set size
+        vms = memory_info.vms / (1024 * 1024)  # virtual memory size
+        self.gauge_rss.labels(pid=self.pid).set(rss)
+        self.gauge_vms.labels(pid=self.pid).set(vms)
+
+
+class ThreadCountMetricCollector(AbstractSystemMetricCollector):
+    """线程数指标收集器"""
+
+    def __init__(self, process: psutil.Process, pid: int):
+        super().__init__(process, pid)
+        self.gauge_active_thread_count = Gauge(
+            "active_thread_count",
+            "Number of active threads",
+            ["pid"],
+            multiprocess_mode="all",
+        )
+        self.gauge_pid_thread_count = Gauge(
+            "thread_count", "Number of Pid threads", ["pid"], multiprocess_mode="all"
+        )
+
+    async def collect(self):
+        pid_thread_count = self.process.num_threads()
+        self.gauge_pid_thread_count.labels(pid=self.pid).set(pid_thread_count)
+        self.gauge_active_thread_count.labels(pid=self.pid).set(
+            threading.active_count()
+        )
+
+
+class FileMetricCollector(AbstractSystemMetricCollector):
+    """文件描述符数指标收集器"""
+
+    def __init__(self, process: psutil.Process, pid: int):
+        super().__init__(process, pid)
+        self.gauge = Gauge(
+            "open_fds",
+            "Number of open files",
+            ["pid"],
+            multiprocess_mode="all",
+        )
+
+    async def collect(self):
+        file_descriptor_count = len(self.process.open_files())
+        self.gauge.labels(pid=self.pid).set(file_descriptor_count)
+
+
+class SystemMetricsMonitor(AbstractMetricCollector):
+    """系统指标监控器 - 采用组装模式"""
+
+    def __init__(self, interval_sec: int = 30):
+        super().__init__(interval_sec=interval_sec)
+        self.pid = os.getpid()
+        self.process = psutil.Process(self.pid)
+        self.collectors: List[AbstractSystemMetricCollector] = []
+
+    def add(
+        self, collector_classes: Type[AbstractSystemMetricCollector], **kwargs
+    ) -> "SystemMetricsMonitor":
+        self.collectors.append(collector_classes(self.process, self.pid, **kwargs))
+        return self
+
+    def cpu(self):
+        return self.add(CPUMetricCollector)
+
+    def memory(self):
+        return self.add(MemoryMetricCollector)
+
+    def thread(self):
+        return self.add(ThreadCountMetricCollector)
+
+    def file(self):
+        return self.add(FileMetricCollector)
+
+    def register_default_collectors(self) -> "SystemMetricsMonitor":
+        """
+        组装默认指标收集器
+        """
+        self.add(CPUMetricCollector)
+        self.add(MemoryMetricCollector)
+        self.add(ThreadCountMetricCollector)
+        self.add(FileMetricCollector)
+        return self
+
+    async def collect(self):
+        for collector in self.collectors:
+            await collector.collect()
+
+    async def run_monitor(self, interval_sec: int = 10):
+        """运行监控任务"""
+
+        self.set_interval(interval_sec)
+
+        async def work():
+            while True:
+                # 执行所有收集器的收集任务
+                for collector in self.collectors:
+                    await collector.collect()
+
+                await asyncio.sleep(interval_sec)
+
+        if len(self.collectors) == 0:
+            self.register_default_collectors()
+
+        logger.info(
+            f"Start system metrics monitor, interval: {interval_sec}s, collector num = {len(self.collectors)}"
+        )
+
+        asyncio.create_task(work())

algo_backend/metrics/http_metrics.py

@@ -0,0 +1,56 @@
+import os
+from typing import List, Optional
+
+from prometheus_client import Counter, Histogram
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+
+
+class RequestTimeCostMiddleware(BaseHTTPMiddleware):
+    def __init__(
+        self,
+        app,
+        buckets: Optional[List[float]] = None,
+        ignore_paths: Optional[List[str]] = None,
+    ):
+        """
+        :param buckets: 默认[0.1, 0.5, 1, 3, 5]
+        :param ignore_paths: 默认不屏蔽，但是建议用户屏蔽/metrics
+        """
+        super().__init__(app)
+
+        default_buckets = [0.1, 0.5, 1, 3, 5]
+        self.buckets = buckets if buckets is not None else default_buckets
+        self.ignore_paths = ignore_paths if ignore_paths is not None else []
+
+        self.request_duration = Histogram(
+            "http_request_duration_seconds",
+            "Request duration in seconds",
+            ["uri", "pid"],
+            buckets=self.buckets,
+        )
+
+        self.error_requests = Counter(
+            "http_error_requests", "error HTTP requests", ["uri", "status"]
+        )
+
+    async def dispatch(self, request: Request, call_next):
+        # 规范化路径：去掉末尾的斜杠（根路径除外）
+        path = request.url.path
+        normalized_path = path.rstrip("/") if path != "/" else path
+
+        if normalized_path in self.ignore_paths:
+            return await call_next(request)
+        else:
+            with self.request_duration.labels(
+                uri=normalized_path, pid=os.getpid()
+            ).time():
+                response = await call_next(request)
+
+                # 记录错误请求
+                if response.status_code >= 400:
+                    self.error_requests.labels(
+                        uri=normalized_path, status=response.status_code
+                    ).inc()
+
+                return response

algo_backend/metrics/prometheus_context.py

@@ -0,0 +1,55 @@
+import logging
+import os
+import shutil
+
+from fastapi import FastAPI
+
+logger = logging.getLogger(__name__)
+
+
+class PrometheusContext:
+    PROM_MULTI_PROC_OS_VAR = "PROMETHEUS_MULTIPROC_DIR"  #
+    DEFAULT_PROMETHEUS_MULTIPROC_DIR = "/temp/prometheus_multiproc_dir"
+
+    @classmethod
+    def get_prometheus_multiproc_dir(cls):
+        return os.environ.get(
+            cls.PROM_MULTI_PROC_OS_VAR, cls.DEFAULT_PROMETHEUS_MULTIPROC_DIR
+        )
+
+    @classmethod
+    def init(cls):
+        """
+        Initialize the Prometheus multiprocessing directory.
+        """
+        prom_dir = os.environ.get(cls.PROM_MULTI_PROC_OS_VAR, None)
+        if not prom_dir:
+            logger.warning(
+                f"Prometheus multiprocessing directory is not set. Using default directory {cls.DEFAULT_PROMETHEUS_MULTIPROC_DIR}."
+            )
+            prom_dir = cls.DEFAULT_PROMETHEUS_MULTIPROC_DIR
+            os.environ["prometheus_multiproc_dir"] = prom_dir
+        else:
+            logger.info(
+                f"Using Prometheus multiprocessing directory from environment variable: {prom_dir}"
+            )
+
+        if os.path.exists(prom_dir):
+            shutil.rmtree(prom_dir)
+            logger.info(
+                f"Removed existing Prometheus multiprocessing directory: {prom_dir}"
+            )
+
+        os.makedirs(prom_dir, exist_ok=True)
+        logger.info(f"Created new Prometheus multiprocessing directory: {prom_dir}")
+
+    @classmethod
+    def mount_prometheus_endpoint(cls, app: FastAPI):
+        """
+        Mount the Prometheus metrics endpoint on the given application.
+        """
+        from prometheus_client import CollectorRegistry, make_asgi_app, multiprocess
+
+        registry = CollectorRegistry()
+        multiprocess.MultiProcessCollector(registry=registry)
+        app.mount("/metrics", make_asgi_app(registry=registry))

algo_backend/metrics/time_cost_metrics.py

@@ -0,0 +1,146 @@
+import logging
+import os
+import time
+from functools import wraps
+from typing import Awaitable, Callable, List, Optional
+
+from prometheus_client import Counter, Histogram
+
+logger = logging.getLogger(__name__)
+
+
+class BasicTimeCostMetrics:
+    """
+    如果启动prometheus则使用此类
+    """
+
+    def __init__(self, buckets: Optional[List[float]] = None):
+        default_buckets = [2, 5, 10, 30, 60, 120, 180, 240, 300]
+        self.buckets = buckets if buckets is not None else default_buckets
+        self.pid = os.getpid()
+
+    def add(self, key, cost): ...
+
+    def add_error(self, key): ...
+
+
+class ApiTimeCostMetrics(BasicTimeCostMetrics):
+    """
+    接口操作的耗时统计
+    指标名如下：
+    operation_duration_seconds_count
+    operation_duration_seconds_bucket
+    operation_errors_total
+    """
+
+    def __init__(self, buckets: Optional[List[float]] = None):
+        super().__init__(buckets=buckets)
+
+        self.ops_duration = Histogram(
+            "operation_duration_seconds",
+            "Api operation duration in seconds",
+            ["operation", "pid"],
+            buckets=self.buckets,
+        )
+        self.ops_error_cnt = Counter(
+            "operation_errors_total",
+            "The total number of errors in operations.",
+            ["operation", "pid"],
+        )
+
+    def add(self, key, cost):
+        self.ops_duration.labels(operation=key, pid=self.pid).observe(cost)
+
+    def add_error(self, key):
+        self.ops_error_cnt.labels(operation=key, pid=self.pid).inc(1)
+
+
+class ClientTimeCostMetrics(BasicTimeCostMetrics):
+    """
+    统计client请求的耗时
+    """
+
+    def __init__(self, buckets: Optional[List[float]] = None):
+        super().__init__(buckets=buckets)
+
+        self.duration = Histogram(
+            "client_duration_seconds",
+            "Client response duration in seconds",
+            ["client", "pid"],
+            buckets=self.buckets,
+        )
+        self.error_cnt = Counter(
+            "client_errors_total",
+            "The total number of errors in client response.",
+            ["client", "pid"],
+        )
+
+    def add(self, key, cost):
+        self.duration.labels(client=key, pid=self.pid).observe(cost)
+
+    def add_error(self, key):
+        self.error_cnt.labels(client=key, pid=self.pid).inc(1)
+
+
+class PrometheusTimeCostMetricSetting:
+    __default_metrics = BasicTimeCostMetrics()
+    __api_metrics = None
+    __client_metrics = None
+
+    @classmethod
+    def initialize(
+        cls,
+        *,
+        api_metrics_buckets: Optional[List[int]] = None,
+        client_metrics_buckets: Optional[List[int]] = None,
+    ):
+        if api_metrics_buckets is None:
+            cls.__api_metrics = ApiTimeCostMetrics()
+        elif len(api_metrics_buckets) == 0:
+            cls.__api_metrics = BasicTimeCostMetrics()
+        else:
+            cls.__api_metrics = ApiTimeCostMetrics(buckets=list(api_metrics_buckets))
+
+        if client_metrics_buckets is None:
+            cls.__client_metrics = ClientTimeCostMetrics()
+        elif len(client_metrics_buckets) == 0:
+            cls.__client_metrics = BasicTimeCostMetrics()
+        else:
+            cls.__client_metrics = ClientTimeCostMetrics(
+                buckets=list(client_metrics_buckets)
+            )
+
+    @classmethod
+    def api_metrics_instance(cls) -> BasicTimeCostMetrics:
+        return cls.__api_metrics or cls.__default_metrics
+
+    @classmethod
+    def client_metrics_instance(cls) -> BasicTimeCostMetrics:
+        return cls.__client_metrics or cls.__default_metrics
+
+    @classmethod
+    def metrics_handler(cls, key: str, metrics: BasicTimeCostMetrics):
+        def decorator(func: Callable[..., Awaitable]) -> Callable[..., Awaitable]:
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                try:
+                    start = time.perf_counter()
+                    result = await func(*args, **kwargs)
+                    cost = time.perf_counter() - start
+                    metrics.add(key, cost)
+                    return result
+                except Exception as e:
+                    metrics.add_error(key)
+                    raise e
+
+            return wrapper
+
+        return decorator
+
+    @classmethod
+    def client_metrics_handler(cls, client_name: str):
+        return cls.metrics_handler(client_name, cls.client_metrics_instance())
+
+    @classmethod
+    def api_metrics_handler(cls, api_name: str):
+        return cls.metrics_handler(api_name, cls.api_metrics_instance())

algo_backend/middleware/__init__.py

@@ -0,0 +1,4 @@
+from .cors import default_cors_middleware
+from .metrics import http_request_time_cost_middleware
+
+__all__ = ["default_cors_middleware", "http_request_time_cost_middleware"]

algo_backend/middleware/cors.py

@@ -0,0 +1,10 @@
+from starlette.middleware import Middleware
+from starlette.middleware.cors import CORSMiddleware
+
+default_cors_middleware = Middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)

algo_backend/middleware/metrics.py

@@ -0,0 +1,12 @@
+from typing import Optional, List
+
+from algo_backend.metrics import RequestTimeCostMiddleware
+from starlette.middleware import Middleware
+
+
+def http_request_time_cost_middleware(
+    buckets: Optional[List[float]] = None, ignore_paths: Optional[List[str]] = None
+):
+    return Middleware(
+        RequestTimeCostMiddleware, buckets=buckets, ignore_paths=ignore_paths
+    )

algo_backend/schema/__init__.py

@@ -0,0 +1,3 @@
+from .vo import AbstractRespVo, BaseRespVo
+
+__all__ = ["BaseRespVo", "AbstractRespVo"]

algo_backend/schema/vo.py

@@ -0,0 +1,83 @@
+from abc import ABC, abstractmethod
+from typing import Generic, Optional, TypeVar
+
+from pydantic import BaseModel, Field
+
+from algo_backend.exception import BasicException, BasicStatusCode, CommonStatusCode
+
+T = TypeVar("T")
+
+
+class AbstractRespVo(BaseModel, ABC):
+    @classmethod
+    @abstractmethod
+    def success(cls, result: Optional[T]) -> "AbstractRespVo": ...
+
+    @classmethod
+    @abstractmethod
+    def from_exception(
+        cls,
+        e: BasicException,
+        *,
+        api_name: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> "AbstractRespVo":
+        """
+        将异常转换为vo
+        """
+        ...
+
+    @abstractmethod
+    def set_request_id(self, request_id: Optional[str]) -> "AbstractRespVo":
+        """
+        增加requestId，以帮助追踪问题
+        """
+        ...
+
+
+class BaseRespVo(AbstractRespVo, Generic[T]):
+    """
+    默认vo实现
+    """
+
+    code: int
+    message: str
+    result: Optional[T] = Field(None, description="结果")
+    requestId: Optional[str] = None
+
+    @classmethod
+    def success(cls, result: Optional[T]) -> "BaseRespVo":
+        return BaseRespVo(
+            code=CommonStatusCode.SUCCESS.code,
+            result=result,
+            message=CommonStatusCode.SUCCESS.msg,
+        )
+
+    @classmethod
+    def from_status_code(cls, status_code: BasicStatusCode, **kwargs) -> "BaseRespVo":
+        return BaseRespVo(
+            code=status_code.code,
+            message=status_code.msg.format(**kwargs),
+            result=None,
+        )
+
+    @classmethod
+    def from_exception(
+        cls,
+        e: BasicException,
+        *,
+        api_name: Optional[str] = None,
+        request_id: Optional[str] = None,
+    ) -> "BaseRespVo":
+        vo = BaseRespVo(
+            code=e.code,
+            message=e.msg,
+            result=None,
+        )
+        vo.set_request_id(request_id)
+        vo.message = f"接口{api_name}报错:{vo.message}" if api_name else vo.message
+        return vo
+
+    def set_request_id(self, request_id: Optional[str]) -> "BaseRespVo":
+        self.requestId = request_id
+        return self

algo_backend/starter/__init__.py

@@ -0,0 +1,4 @@
+from .default_app_generator import DefaultAlgoAppGenerator
+from .default_service_starter import DefaultAlgoServiceStarter
+
+__all__ = ["DefaultAlgoAppGenerator", "DefaultAlgoServiceStarter"]