aury-boot 0.0.39__py3-none-any.whl → 0.0.41__py3-none-any.whl

aury/boot/infrastructure/clients/redis/manager.py

@@ -1,16 +1,25 @@
 """Redis 客户端管理器 - 命名多实例模式。
 
 提供统一的 Redis 连接管理，支持多实例。
+支持普通 Redis 和 Redis Cluster：
+- redis://... - 普通 Redis
+- redis-cluster://... - Redis Cluster
 """
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING, Any
+from urllib.parse import urlparse
+
 from redis.asyncio import ConnectionPool, Redis
 
 from aury.boot.common.logging import logger
 
 from .config import RedisConfig
 
+if TYPE_CHECKING:
+    from redis.asyncio.cluster import RedisCluster
+
 
 class RedisClient:
     """Redis 客户端管理器（命名多实例）。
@@ -50,8 +59,9 @@ class RedisClient:
         self.name = name
         self._config: RedisConfig | None = None
         self._pool: ConnectionPool | None = None
-        self._redis: Redis | None = None
+        self._redis: Redis | RedisCluster | None = None
         self._initialized: bool = False
+        self._is_cluster: bool = False
     
     @classmethod
     def get_instance(cls, name: str = "default") -> RedisClient:
@@ -135,6 +145,10 @@ class RedisClient:
     async def initialize(self) -> RedisClient:
         """初始化 Redis 连接。
         
+        自动检测 URL scheme：
+        - redis://... -> 普通 Redis
+        - redis-cluster://... -> Redis Cluster
+        
         Returns:
             self: 支持链式调用
             
@@ -152,33 +166,81 @@ class RedisClient:
             )
         
         try:
-            # 创建连接池
-            self._pool = ConnectionPool.from_url(
-                self._config.url,
-                max_connections=self._config.max_connections,
-                socket_timeout=self._config.socket_timeout,
-                socket_connect_timeout=self._config.socket_connect_timeout,
-                retry_on_timeout=self._config.retry_on_timeout,
-                health_check_interval=self._config.health_check_interval,
-                decode_responses=self._config.decode_responses,
-            )
+            url = self._config.url
             
-            # 创建 Redis 客户端
-            self._redis = Redis(connection_pool=self._pool)
+            # 自动检测是否为集群模式
+            if url.startswith("redis-cluster://"):
+                await self._initialize_cluster(url)
+            else:
+                await self._initialize_standalone(url)
             
             # 验证连接
             await self._redis.ping()
             
             self._initialized = True
-            # 脱敏日志
-            masked_url = self._mask_url(self._config.url)
-            logger.info(f"Redis 客户端 [{self.name}] 初始化完成: {masked_url}")
+            masked_url = self._mask_url(url)
+            mode = "Cluster" if self._is_cluster else "Standalone"
+            logger.info(f"Redis 客户端 [{self.name}] 初始化完成 ({mode}): {masked_url}")
             
             return self
         except Exception as e:
             logger.error(f"Redis 客户端 [{self.name}] 初始化失败: {e}")
             raise
     
+    async def _initialize_standalone(self, url: str) -> None:
+        """初始化普通 Redis 连接。"""
+        self._pool = ConnectionPool.from_url(
+            url,
+            max_connections=self._config.max_connections,
+            socket_timeout=self._config.socket_timeout,
+            socket_connect_timeout=self._config.socket_connect_timeout,
+            retry_on_timeout=self._config.retry_on_timeout,
+            health_check_interval=self._config.health_check_interval,
+            decode_responses=self._config.decode_responses,
+        )
+        self._redis = Redis(connection_pool=self._pool)
+        self._is_cluster = False
+    
+    async def _initialize_cluster(self, url: str) -> None:
+        """初始化 Redis Cluster 连接。
+        
+        支持 URL 格式:
+        - redis-cluster://password@host:port （密码在用户名位置）
+        - redis-cluster://:password@host:port （标准格式）
+        - redis-cluster://username:password@host:port （ACL 模式）
+        """
+        from redis.asyncio.cluster import RedisCluster
+        
+        parsed_url = url.replace("redis-cluster://", "redis://")
+        parsed = urlparse(parsed_url)
+        
+        # 提取认证信息
+        username = parsed.username
+        password = parsed.password
+        
+        # 处理 password@host 格式（密码在用户名位置）
+        if username and not password:
+            password = username
+            username = None
+        
+        # 构建连接参数
+        cluster_kwargs: dict = {
+            "host": parsed.hostname or "localhost",
+            "port": parsed.port or 6379,
+            "decode_responses": self._config.decode_responses,
+            "socket_timeout": self._config.socket_timeout,
+            "socket_connect_timeout": self._config.socket_connect_timeout,
+            "retry_on_timeout": self._config.retry_on_timeout,
+        }
+        
+        if username:
+            cluster_kwargs["username"] = username
+        if password:
+            cluster_kwargs["password"] = password
+        
+        self._redis = RedisCluster(**cluster_kwargs)
+        self._is_cluster = True
+    
     def _mask_url(self, url: str) -> str:
         """URL 脱敏（隐藏密码）。"""
         if "@" in url:
@@ -198,11 +260,16 @@ class RedisClient:
         return self._initialized
     
     @property
-    def connection(self) -> Redis:
+    def is_cluster(self) -> bool:
+        """检查是否为集群模式。"""
+        return self._is_cluster
+    
+    @property
+    def connection(self) -> Redis | RedisCluster:
         """获取 Redis 连接。
         
         Returns:
-            Redis: Redis 客户端实例
+            Redis 或 RedisCluster 客户端实例
             
         Raises:
             RuntimeError: 未初始化时调用
@@ -245,7 +312,10 @@ class RedisClient:
     async def cleanup(self) -> None:
         """清理资源，关闭连接。"""
         if self._redis:
-            await self._redis.close()
+            if self._is_cluster:
+                await self._redis.aclose()
+            else:
+                await self._redis.close()
             logger.info(f"Redis 客户端 [{self.name}] 已关闭")
         
         if self._pool:
@@ -254,6 +324,7 @@ class RedisClient:
         self._redis = None
         self._pool = None
         self._initialized = False
+        self._is_cluster = False
     
     def __repr__(self) -> str:
         """字符串表示。"""

aury/boot/infrastructure/database/manager.py

@@ -226,6 +226,9 @@ class DatabaseManager:
     async def session(self) -> AsyncGenerator[AsyncSession]:
         """获取数据库会话（上下文管理器）。
         
+        连接校验由 pool_pre_ping=True 在引擎层自动处理，
+        无需手动检查。
+        
         Yields:
             AsyncSession: 数据库会话
             
@@ -235,7 +238,6 @@ class DatabaseManager:
         """
         session = self.session_factory()
         try:
-            await self._check_session_connection(session)
             yield session
         except SQLAlchemyError as exc:
             # 只捕获数据库相关异常
@@ -253,15 +255,15 @@ class DatabaseManager:
     async def create_session(self) -> AsyncSession:
         """创建新的数据库会话（需要手动关闭）。
         
+        连接校验由 pool_pre_ping=True 在引擎层自动处理。
+        
         Returns:
             AsyncSession: 数据库会话
             
         注意：使用后需要手动调用 await session.close()
         建议使用 session() 上下文管理器代替此方法。
         """
-        session = self.session_factory()
-        await self._check_session_connection(session)
-        return session
+        return self.session_factory()
     
     async def get_session(self) -> AsyncGenerator[AsyncSession]:
         """FastAPI 依赖注入专用的会话获取器。

aury/boot/infrastructure/monitoring/__init__.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import traceback
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from functools import wraps
@@ -13,6 +14,11 @@ import time
 from aury.boot.common.logging import logger
 
 
+def _format_exception_stacktrace(exc: Exception) -> str:
+    """格式化异常堆栈为字符串。"""
+    return "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+
+
 class MonitorContext:
     """监控上下文。
     
@@ -262,6 +268,7 @@ async def _emit_http_exception_alert(
             method=method,
             error_type=type(exception).__name__,
             error_message=str(exception),
+            stacktrace=_format_exception_stacktrace(exception),
         )
     except ImportError:
         pass
@@ -369,8 +376,9 @@ class ErrorReporterComponent(MonitorComponent):
                 source="service",
                 duration=context.duration,
                 service=context.service_name,
-                exception_type=type(context.exception).__name__,
-                exception_message=str(context.exception),
+                error_type=type(context.exception).__name__,
+                error_message=str(context.exception),
+                stacktrace=_format_exception_stacktrace(context.exception),
             )
         except ImportError:
             pass  # alerting 模块未加载

aury/boot/infrastructure/monitoring/alerting/notifiers/feishu.py

@@ -11,7 +11,7 @@ import hmac
 import time
 from typing import TYPE_CHECKING, Any
 
-import httpx
+import aiohttp
 
 from aury.boot.common.logging import logger
 
@@ -118,6 +118,25 @@ class FeishuNotifier(AlertNotifier):
                 details.append(f"**错误信息**: {notification.metadata['error_message']}")
             if "task_name" in notification.metadata:
                 details.append(f"**任务**: {notification.metadata['task_name']}")
+            
+            # 事件循环阻塞检测专用字段
+            if "blocked_ms" in notification.metadata:
+                details.append(f"**阻塞时间**: {notification.metadata['blocked_ms']:.0f}ms")
+            if "threshold_ms" in notification.metadata:
+                details.append(f"**阈值**: {notification.metadata['threshold_ms']:.0f}ms")
+            if "total_blocks" in notification.metadata:
+                window_minutes = notification.metadata.get("window_minutes", 5)
+                details.append(f"**近{window_minutes}分钟**: {notification.metadata['total_blocks']} 次")
+            if "block_rate" in notification.metadata:
+                details.append(f"**阻塞率**: {notification.metadata['block_rate']}")
+            if "process_stats" in notification.metadata:
+                stats = notification.metadata["process_stats"]
+                if stats:
+                    stats_str = f"CPU {stats.get('cpu_percent', 'N/A')}%, "
+                    stats_str += f"RSS {stats.get('memory_rss_mb', 'N/A')}MB, "
+                    stats_str += f"线程 {stats.get('num_threads', 'N/A')}"
+                    details.append(f"**进程状态**: {stats_str}")
+            
             # SQL 和堆栈单独处理
             if "sql" in notification.metadata:
                 sql_content = notification.metadata["sql"]
@@ -155,11 +174,10 @@ class FeishuNotifier(AlertNotifier):
                 "content": f"**堆栈**:\n```python\n{stacktrace_content}\n```",
             })
         
-        # 构建 JSON 2.0 卡片消息
+        # 构建卡片消息（飞书自定义机器人格式）
         card = {
             "msg_type": "interactive",
             "card": {
-                "schema": "2.0",
                 "config": {
                     "wide_screen_mode": True,
                 },
@@ -170,9 +188,7 @@ class FeishuNotifier(AlertNotifier):
                         "content": notification.title,
                     },
                 },
-                "body": {
-                    "elements": elements,
-                },
+                "elements": elements,
             },
         }
         
@@ -191,16 +207,17 @@ class FeishuNotifier(AlertNotifier):
                 message["sign"] = self._generate_sign(timestamp)
             
             # 发送请求
-            async with httpx.AsyncClient(timeout=10) as client:
-                response = await client.post(self.webhook, json=message)
-                result = response.json()
-                
-                if result.get("code") == 0 or result.get("StatusCode") == 0:
-                    logger.debug(f"飞书通知发送成功: {notification.title}")
-                    return True
-                else:
-                    logger.error(f"飞书通知发送失败: {result}")
-                    return False
+            timeout = aiohttp.ClientTimeout(total=10)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.post(self.webhook, json=message) as response:
+                    result = await response.json()
+                    
+                    if result.get("code") == 0 or result.get("StatusCode") == 0:
+                        logger.debug(f"飞书通知发送成功: {notification.title}")
+                        return True
+                    else:
+                        logger.error(f"飞书通知发送失败: {result}")
+                        return False
         except Exception as e:
             logger.error(f"飞书通知发送异常: {e}")
             return False

aury/boot/infrastructure/monitoring/alerting/notifiers/webhook.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-import httpx
+import aiohttp
 
 from aury.boot.common.logging import logger
 
@@ -87,21 +87,22 @@ class WebhookNotifier(AlertNotifier):
         try:
             payload = self._build_payload(notification)
             
-            async with httpx.AsyncClient(timeout=self.timeout) as client:
-                response = await client.post(
+            timeout = aiohttp.ClientTimeout(total=self.timeout)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.post(
                     self.url,
                     json=payload,
                     headers=self.headers,
-                )
-                
-                if response.is_success:
-                    logger.debug(f"Webhook 通知发送成功: {notification.title}")
-                    return True
-                else:
-                    logger.error(
-                        f"Webhook 通知发送失败: {response.status_code} - {response.text}"
-                    )
-                    return False
+                ) as response:
+                    if response.status < 400:
+                        logger.debug(f"Webhook 通知发送成功: {notification.title}")
+                        return True
+                    else:
+                        text = await response.text()
+                        logger.error(
+                            f"Webhook 通知发送失败: {response.status} - {text}"
+                        )
+                        return False
         except Exception as e:
             logger.error(f"Webhook 通知发送异常: {e}")
             return False