aury-boot 0.0.30__py3-none-any.whl → 0.0.32__py3-none-any.whl

aury/boot/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.30'
-__version_tuple__ = version_tuple = (0, 0, 30)
+__version__ = version = '0.0.32'
+__version_tuple__ = version_tuple = (0, 0, 32)
 
 __commit_id__ = commit_id = None

aury/boot/application/__init__.py

@@ -24,6 +24,7 @@ from aury.boot.domain.transaction import (
 # 依赖注入容器（从 infrastructure 导入）
 from aury.boot.infrastructure.di import Container, Lifetime, Scope, ServiceDescriptor
 from aury.boot.infrastructure.events import (
+    BroadcasterEventBus,
     Event,
     EventBackend,
     EventBusManager,
@@ -31,9 +32,7 @@ from aury.boot.infrastructure.events import (
     EventType,
     IEventBus,
     # 后端实现
-    MemoryEventBus,
     RabbitMQEventBus,
-    RedisEventBus,
 )
 
 from . import interfaces, rpc
@@ -108,14 +107,13 @@ __all__ = [
     "IEventBus",
     "Lifetime",
     "LogSettings",
-    "MemoryEventBus",
+    "BroadcasterEventBus",
     "Middleware",
     "MiddlewareName",
     "MigrationComponent",
     # 迁移
     "MigrationManager",
     "RabbitMQEventBus",
-    "RedisEventBus",
     "RequestLoggingMiddleware",
     "SchedulerComponent",
     "SchedulerMode",

aury/boot/application/app/components.py

@@ -628,6 +628,7 @@ class TelemetryPlugin(Plugin):
                 alert_on_slow_sql=config.alert.alert_on_slow_sql,
                 alert_on_error=config.alert.alert_on_error,
                 alert_callback=alert_callback,
+                slow_request_exclude_paths=config.alert.slow_request_exclude_paths,
                 traces_endpoint=config.telemetry.traces_endpoint,
                 traces_headers=config.telemetry.traces_headers,
                 logs_endpoint=config.telemetry.logs_endpoint,
@@ -753,6 +754,7 @@ class AlertComponent(Component):
                         "slow_sql_aggregate": config.alert.slow_sql_aggregate,
                         "exception_aggregate": config.alert.exception_aggregate,
                         "suppress_seconds": config.alert.suppress_seconds,
+                        "slow_request_exclude_paths": config.alert.slow_request_exclude_paths,
                     },
                     notifiers=config.alert.get_notifiers(),
                 )

aury/boot/application/config/settings.py

@@ -696,6 +696,12 @@ class AlertSettings(BaseModel):
         description="是否对异常发送告警（默认只对 5xx 告警，4xx 业务异常不告警）"
     )
     
+    # 慢请求路径排除配置
+    slow_request_exclude_paths: list[str] = Field(
+        default_factory=list,
+        description="排除慢请求告警的路径列表（支持 * 通配符），如 SSE/WebSocket 长连接接口"
+    )
+    
     # 默认累计触发配置
     aggregate_window: int = Field(
         default=10,

aury/boot/commands/templates/project/AGENTS.md.tpl

@@ -127,6 +127,60 @@ mypy {package_name}/
 - **[aury_docs/99-cli.md](./aury_docs/99-cli.md)** - CLI 命令参考
 - **[.env.example](./.env.example)** - 所有可用环境变量
 
+## 配置结构
+
+框架使用 `BaseConfig` 统一管理配置，环境变量通过 `__` 分隔符映射到嵌套配置：
+
+```python
+# 配置结构（BaseConfig）
+class BaseConfig(BaseSettings):
+    # 基础服务
+    server: ServerSettings      # SERVER__*
+    cors: CORSSettings          # CORS__*
+    log: LogSettings            # LOG__*
+    health_check: HealthCheckSettings  # HEALTH_CHECK__*
+    admin: AdminConsoleSettings # ADMIN__*
+    
+    # 数据与缓存
+    database: DatabaseSettings  # DATABASE__*
+    cache: CacheSettings        # CACHE__*
+    channel: ChannelSettings    # CHANNEL__*
+    storage: StorageSettings    # STORAGE__*
+    migration: MigrationSettings  # MIGRATION__*
+    
+    # 服务编排
+    service: ServiceSettings    # SERVICE__*
+    scheduler: SchedulerSettings  # SCHEDULER__*
+    
+    # 异步与事件
+    task: TaskSettings          # TASK__*
+    event: EventSettings        # EVENT__*
+    
+    # 微服务通信
+    rpc_client: RPCClientSettings   # RPC_CLIENT__*
+    rpc_service: RPCServiceSettings # RPC_SERVICE__*
+    
+    # 监控告警
+    telemetry: TelemetrySettings  # TELEMETRY__*
+    alert: AlertSettings        # ALERT__*
+    
+    model_config = SettingsConfigDict(
+        env_nested_delimiter="__",  # 环境变量分隔符
+    )
+```
+
+**环境变量命名规则**：`{SECTION}__{FIELD}`
+
+```bash
+# 示例
+DATABASE__URL=postgresql://...
+DATABASE__POOL_SIZE=10
+CACHE__CACHE_TYPE=redis
+CACHE__URL=redis://localhost:6379
+ALERT__ENABLED=true
+ALERT__SLOW_REQUEST_THRESHOLD=1.0
+```
+
 ## 代码规范
 
 > 项目所有业务配置请通过应用 `settings`/配置对象获取，**不要**直接使用 `os.environ` 在业务代码中读环境变量。

aury/boot/commands/templates/project/env_templates/messaging.tpl

@@ -2,14 +2,18 @@
 # =============================================================================
 # 流式通道配置 (CHANNEL__) - SSE/实时通信
 # =============================================================================
+# 基于 Broadcaster 库，通过 URL scheme 切换后端
+# 支持: memory:// | redis://host:port/db | kafka://host:port | postgres://...
+#
 # 单实例配置:
-# CHANNEL__BACKEND=memory
-# CHANNEL__BACKEND=redis
-# CHANNEL__URL=redis://localhost:6379/3
+# CHANNEL__BACKEND=broadcaster
+# CHANNEL__URL=memory://
+# 分布式: CHANNEL__URL=redis://localhost:6379/3
 #
 # 多实例配置 (格式: CHANNEL__{{INSTANCE}}__{{FIELD}}):
-# CHANNEL__SSE__BACKEND=memory
-# CHANNEL__NOTIFICATION__BACKEND=redis
+# CHANNEL__SSE__BACKEND=broadcaster
+# CHANNEL__SSE__URL=memory://
+# CHANNEL__NOTIFICATION__BACKEND=broadcaster
 # CHANNEL__NOTIFICATION__URL=redis://localhost:6379/3
 
 # =============================================================================
@@ -32,18 +36,22 @@
 # =============================================================================
 # 事件总线配置 (EVENT__)
 # =============================================================================
+# 基于 Broadcaster 库，通过 URL scheme 切换后端
+# 支持: memory:// | redis://host:port/db | kafka://host:port | postgres://...
+# RabbitMQ 需使用 backend=rabbitmq
+#
 # 单实例配置:
-# EVENT__BROKER_URL=
-# EVENT__EXCHANGE_NAME=aury.events
-
+# EVENT__BACKEND=broadcaster
+# EVENT__URL=memory://
+# 分布式: EVENT__URL=redis://localhost:6379/5
+#
 # 多实例配置 (格式: EVENT__{{INSTANCE}}__{{FIELD}}):
-# EVENT__DEFAULT__BACKEND=memory
-# EVENT__DISTRIBUTED__BACKEND=redis
+# EVENT__DEFAULT__BACKEND=broadcaster
+# EVENT__DEFAULT__URL=memory://
+# EVENT__DISTRIBUTED__BACKEND=broadcaster
 # EVENT__DISTRIBUTED__URL=redis://localhost:6379/5
-# EVENT__DISTRIBUTED__KEY_PREFIX=events:
 #
-# RabbitMQ 后端:
+# RabbitMQ 后端 (复杂消息场景):
 # EVENT__DOMAIN__BACKEND=rabbitmq
 # EVENT__DOMAIN__URL=amqp://guest:guest@localhost:5672/
 # EVENT__DOMAIN__EXCHANGE_NAME=domain.events
-# EVENT__DOMAIN__EXCHANGE_TYPE=topic

aury/boot/commands/templates/project/env_templates/monitoring.tpl

@@ -21,6 +21,8 @@ ALERT__SLOW_SQL_THRESHOLD=0.5
 ALERT__ALERT_ON_SLOW_REQUEST=true
 ALERT__ALERT_ON_SLOW_SQL=true
 ALERT__ALERT_ON_ERROR=true
+# 慢请求排除路径（SSE/WebSocket 等长连接接口，支持 * 通配符）
+# ALERT__SLOW_REQUEST_EXCLUDE_PATHS=["*/subscribe", "*/ws", "*/stream"]
 # 聚合与抑制
 ALERT__AGGREGATE_WINDOW=10
 ALERT__SLOW_REQUEST_AGGREGATE=5

aury/boot/infrastructure/__init__.py

@@ -27,12 +27,11 @@ from .cache import (
 
 # 通道 (SSE/PubSub)
 from .channel import (
+    BroadcasterChannel,
     ChannelBackend,
     ChannelManager,
     ChannelMessage,
     IChannel,
-    MemoryChannel,
-    RedisChannel,
 )
 
 # RabbitMQ 客户端
@@ -47,15 +46,14 @@ from .di import Container, Lifetime, Scope, ServiceDescriptor
 
 # 事件总线
 from .events import (
+    BroadcasterEventBus,
     Event,
     EventBackend,
     EventBusManager,
     EventHandler,
     EventType,
     IEventBus,
-    MemoryEventBus,
     RabbitMQEventBus,
-    RedisEventBus,
 )
 
 # 消息队列
@@ -103,6 +101,7 @@ __all__ = [
     "CacheFactory",
     "CacheManager",
     # 通道
+    "BroadcasterChannel",
     "ChannelBackend",
     "ChannelManager",
     "ChannelMessage",
@@ -128,19 +127,16 @@ __all__ = [
     "MQMessage",
     "MemcachedCache",
     "MemoryCache",
-    "MemoryChannel",
-    "MemoryEventBus",
     "RabbitMQ",
     # RabbitMQ 客户端
     "RabbitMQClient",
     "RabbitMQConfig",
     "RabbitMQEventBus",
+    "BroadcasterEventBus",
     "RedisCache",
-    "RedisChannel",
     # Redis 客户端
     "RedisClient",
     "RedisConfig",
-    "RedisEventBus",
     "RedisMQ",
     "S3Storage",
     # 调度器

aury/boot/infrastructure/channel/__init__.py

@@ -2,23 +2,24 @@
 
 提供发布/订阅模式的通道功能，用于 SSE、WebSocket 等实时通信场景。
 
-支持的后端:
-- memory: 内存通道（单进程）
-- redis: Redis Pub/Sub（多进程/多实例）
+支持的后端（通过 Broadcaster 库）:
+- memory:// - 内存通道（单进程，开发/测试用）
+- redis:// - Redis Pub/Sub（多进程/分布式）
+- kafka:// - Apache Kafka
+- postgres:// - PostgreSQL LISTEN/NOTIFY
 """
 
-from .backends import MemoryChannel, RedisChannel
+from .backends import BroadcasterChannel
 from .base import ChannelBackend, ChannelMessage, IChannel
 from .manager import ChannelManager
 
 __all__ = [
     # 接口和类型
     "ChannelBackend",
-    # 管理器
-    "ChannelManager",
     "ChannelMessage",
     "IChannel",
+    # 管理器
+    "ChannelManager",
     # 后端实现
-    "MemoryChannel",
-    "RedisChannel",
+    "BroadcasterChannel",
 ]

aury/boot/infrastructure/channel/backends/__init__.py

@@ -1,9 +1,5 @@
 """通道后端实现。"""
 
-from .memory import MemoryChannel
-from .redis import RedisChannel
+from .broadcaster import BroadcasterChannel
 
-__all__ = [
-    "MemoryChannel",
-    "RedisChannel",
-]
+__all__ = ["BroadcasterChannel"]

aury/boot/infrastructure/channel/backends/broadcaster.py

@@ -0,0 +1,141 @@
+"""Broadcaster 通道后端。
+
+基于 Broadcaster 库实现，支持多种后端：
+- memory:// - 内存（单进程，开发/测试用）
+- redis:// - Redis Pub/Sub（多进程/分布式）
+- kafka:// - Apache Kafka
+- postgres:// - PostgreSQL LISTEN/NOTIFY
+
+优势：
+- 共享连接池，支持成千上万并发订阅
+- 自动重连机制
+- 统一 API，通过 URL scheme 切换后端
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator
+from datetime import datetime
+
+from broadcaster import Broadcast
+
+from aury.boot.common.logging import logger
+
+from ..base import ChannelMessage, IChannel
+
+
+class BroadcasterChannel(IChannel):
+    """Broadcaster 通道实现。
+
+    使用 Broadcaster 库统一处理多种后端，解决原生实现的连接池问题：
+    - 共享单个连接处理所有订阅
+    - 内部通过 asyncio.Queue 分发消息
+    - 支持成千上万并发订阅者
+    """
+
+    def __init__(self, url: str) -> None:
+        """初始化 Broadcaster 通道。
+
+        Args:
+            url: 连接 URL，支持的 scheme：
+                - memory:// - 内存后端
+                - redis://host:port/db - Redis Pub/Sub
+                - kafka://host:port - Apache Kafka
+                - postgres://user:pass@host:port/db - PostgreSQL
+        """
+        self._url = url
+        self._broadcast = Broadcast(url)
+        self._connected = False
+
+    async def _ensure_connected(self) -> None:
+        """确保已连接。"""
+        if not self._connected:
+            await self._broadcast.connect()
+            self._connected = True
+            logger.debug(f"Broadcaster 通道已连接: {self._mask_url(self._url)}")
+
+    def _mask_url(self, url: str) -> str:
+        """URL 脱敏（隐藏密码）。"""
+        if "@" in url:
+            parts = url.split("@")
+            prefix = parts[0]
+            suffix = parts[1]
+            if ":" in prefix:
+                scheme_and_user = prefix.rsplit(":", 1)[0]
+                return f"{scheme_and_user}:***@{suffix}"
+        return url
+
+    async def publish(self, channel: str, message: ChannelMessage) -> None:
+        """发布消息到通道。"""
+        await self._ensure_connected()
+
+        message.channel = channel
+        # 序列化消息
+        data = {
+            "data": message.data,
+            "event": message.event,
+            "id": message.id,
+            "channel": message.channel,
+            "timestamp": message.timestamp.isoformat(),
+        }
+        await self._broadcast.publish(channel=channel, message=json.dumps(data))
+
+    async def subscribe(self, channel: str) -> AsyncIterator[ChannelMessage]:
+        """订阅通道。
+
+        Broadcaster 内部共享连接，每个订阅者不会创建新的连接。
+        """
+        await self._ensure_connected()
+
+        async with self._broadcast.subscribe(channel=channel) as subscriber:
+            async for event in subscriber:
+                try:
+                    data = json.loads(event.message)
+                    message = ChannelMessage(
+                        data=data.get("data"),
+                        event=data.get("event"),
+                        id=data.get("id"),
+                        channel=data.get("channel") or channel,
+                        timestamp=datetime.fromisoformat(data["timestamp"])
+                        if data.get("timestamp")
+                        else datetime.now(),
+                    )
+                    yield message
+                except (json.JSONDecodeError, KeyError, TypeError) as e:
+                    logger.warning(f"解析通道消息失败: {e}")
+
+    async def psubscribe(self, pattern: str) -> AsyncIterator[ChannelMessage]:
+        """模式订阅（通配符）。
+
+        注意：Broadcaster 目前不支持模式订阅，此方法会抛出 NotImplementedError。
+        如需模式订阅，请使用具体的 channel 名称。
+
+        Args:
+            pattern: 通道模式
+
+        Raises:
+            NotImplementedError: Broadcaster 不支持模式订阅
+        """
+        raise NotImplementedError(
+            "Broadcaster 后端不支持模式订阅 (psubscribe)。"
+            "请使用具体的 channel 名称。"
+        )
+
+    async def unsubscribe(self, channel: str) -> None:
+        """取消订阅通道。
+
+        注意：Broadcaster 的订阅通过上下文管理器自动处理，
+        退出 subscribe() 的 async for 循环即可取消订阅。
+        """
+        pass
+
+    async def close(self) -> None:
+        """关闭通道。"""
+        if self._connected:
+            await self._broadcast.disconnect()
+            self._connected = False
+            logger.debug("Broadcaster 通道已关闭")
+
+
+__all__ = ["BroadcasterChannel"]

aury/boot/infrastructure/channel/base.py

@@ -16,8 +16,11 @@ from typing import Any
 class ChannelBackend(Enum):
     """通道后端类型。"""
 
-    MEMORY = "memory"
-    REDIS = "redis"
+    # Broadcaster 统一后端（支持 memory/redis/kafka/postgres，通过 URL scheme 区分）
+    BROADCASTER = "broadcaster"
+    # 未来扩展
+    RABBITMQ = "rabbitmq"
+    ROCKETMQ = "rocketmq"
 
 
 @dataclass

aury/boot/infrastructure/channel/manager.py

@@ -9,8 +9,7 @@ from collections.abc import AsyncIterator
 
 from aury.boot.common.logging import logger
 
-from .backends.memory import MemoryChannel
-from .backends.redis import RedisChannel
+from .backends.broadcaster import BroadcasterChannel
 from .base import ChannelBackend, ChannelMessage, IChannel
 
 
@@ -51,7 +50,6 @@ class ChannelManager:
         self._backend: IChannel | None = None
         self._backend_type: ChannelBackend | None = None
         self._initialized: bool = False
-        self._redis_client = None
         self._url: str | None = None
 
     @classmethod
@@ -84,17 +82,19 @@ class ChannelManager:
 
     async def initialize(
         self,
-        backend: ChannelBackend | str = ChannelBackend.MEMORY,
+        backend: ChannelBackend | str = ChannelBackend.BROADCASTER,
         *,
-        url: str | None = None,
-        max_subscribers: int = 1000,
+        url: str = "memory://",
     ) -> ChannelManager:
         """初始化通道（链式调用）。
 
         Args:
-            backend: 后端类型
-            url: Redis 连接 URL（当 backend=redis 时需要）
-            max_subscribers: 内存后端的最大订阅者数量
+            backend: 后端类型，默认 broadcaster
+            url: 连接 URL，支持：
+                - memory:// - 内存后端（单进程，默认）
+                - redis://host:port/db - Redis Pub/Sub
+                - kafka://host:port - Apache Kafka
+                - postgres://user:pass@host/db - PostgreSQL
 
         Returns:
             self: 支持链式调用
@@ -110,24 +110,28 @@ class ChannelManager:
         self._backend_type = backend
         self._url = url
 
-        if backend == ChannelBackend.MEMORY:
-            self._backend = MemoryChannel(max_subscribers=max_subscribers)
-        elif backend == ChannelBackend.REDIS:
-            if url is None:
-                raise ValueError("Redis 通道需要提供 url 参数")
-            # 内部创建 RedisClient
-            from aury.boot.infrastructure.clients.redis import RedisClient
-
-            self._redis_client = RedisClient()
-            await self._redis_client.configure(url=url).initialize()
-            self._backend = RedisChannel(self._redis_client)
+        if backend == ChannelBackend.BROADCASTER:
+            self._backend = BroadcasterChannel(url)
+        elif backend in (ChannelBackend.RABBITMQ, ChannelBackend.ROCKETMQ):
+            raise NotImplementedError(f"{backend.value} 后端暂未实现")
         else:
             raise ValueError(f"不支持的通道后端: {backend}")
 
         self._initialized = True
-        logger.info(f"通道管理器 [{self.name}] 初始化完成: {backend.value}")
+        logger.info(f"通道管理器 [{self.name}] 初始化完成: {backend.value}, url={self._mask_url(url)}")
         return self
 
+    def _mask_url(self, url: str) -> str:
+        """URL 脱敏（隐藏密码）。"""
+        if "@" in url:
+            parts = url.split("@")
+            prefix = parts[0]
+            suffix = parts[1]
+            if ":" in prefix:
+                scheme_and_user = prefix.rsplit(":", 1)[0]
+                return f"{scheme_and_user}:***@{suffix}"
+        return url
+
     @property
     def backend(self) -> IChannel:
         """获取通道后端。"""
@@ -218,9 +222,6 @@ class ChannelManager:
         if self._backend:
             await self._backend.close()
             self._backend = None
-        if self._redis_client:
-            await self._redis_client.cleanup()
-            self._redis_client = None
         self._initialized = False
         logger.info(f"通道管理器 [{self.name}] 已关闭")
 

aury/boot/infrastructure/events/__init__.py

@@ -3,12 +3,11 @@
 提供发布/订阅模式的事件总线功能，用于模块间解耦通信。
 
 支持的后端:
-- memory: 内存事件总线（单进程）
-- redis: Redis Pub/Sub（多进程/多实例）
-- rabbitmq: RabbitMQ Exchange（分布式）
+- broadcaster: 基于 broadcaster 库（推荐，支持 memory/redis/kafka/postgres）
+- rabbitmq: RabbitMQ Exchange（复杂消息场景）
 """
 
-from .backends import MemoryEventBus, RabbitMQEventBus, RedisEventBus
+from .backends import BroadcasterEventBus, RabbitMQEventBus
 from .base import Event, EventBackend, EventHandler, EventType, IEventBus
 from .manager import EventBusManager
 
@@ -22,9 +21,8 @@ __all__ = [
     "EventType",
     "IEventBus",
     # 后端实现
-    "MemoryEventBus",
+    "BroadcasterEventBus",
     "RabbitMQEventBus",
-    "RedisEventBus",
 ]
 
 

aury/boot/infrastructure/events/backends/__init__.py

@@ -1,11 +1,9 @@
 """事件总线后端实现。"""
 
-from .memory import MemoryEventBus
+from .broadcaster import BroadcasterEventBus
 from .rabbitmq import RabbitMQEventBus
-from .redis import RedisEventBus
 
 __all__ = [
-    "MemoryEventBus",
+    "BroadcasterEventBus",
     "RabbitMQEventBus",
-    "RedisEventBus",
 ]