🎉🍾♻️refactor(core): 重构核心鉴权与缓存机制，引入异步发送队列以提升性能 🚀 (#2088)

* 添加测试插件

* ✨ feat(auth): 添加缓存机制以优化用户和插件数据查询性能

* 🗑️ chore(help): 删除笨蛋检测插件代码

* ✨ feat(bot): 添加对扩展插件的加载支持

* ✨ feat(auth): 优化权限检查和缓存机制，增加用户和插件数据的并行查询

* ✨ feat(cache): 引入运行时缓存机制，优化用户和插件的ban记录管理

* ✨ feat(auth): 更新is_ban函数文档，添加参数和返回值说明

* ```
feat(auth): 使用内存缓存优化权限验证性能

- 移除数据库查询超时控制，改用 LevelUserMemoryCache、BotMemoryCache
  和 PluginLimitMemoryCache 进行缓存查询
- 优化 auth_admin、auth_bot、auth_limit 权限验证逻辑，提升响应速度
- 添加 background 参数支持异步发送权限不足提示消息
- 移除 asyncio 依赖，简化代码结构

fix(auth): 修复限制通知频率控制问题

- 实现限制通知冷却机制，避免重复发送相同限制消息
- 添加 AUTH_LIMIT_NOTICE_CD 配置项，默认值为 2 秒
- 使用 FreqLimiter 控制限制通知发送频率

refactor(models): 增强模型数据变更时的缓存同步

- 在 BotConsole、GroupConsole、LevelUser、PluginLimit 模型的
  create、update_or_create、save、delete 方法中自动更新对应缓存
- 确保数据库和内存缓存数据一致性

docs(ban_console): 修正文档注释并优化日志信息

- 修正 BanConsole 类中方法的文档字符串，使用标准参数和返回值格式
- 优化调试日志信息，使描述更加清晰准确
```

* ✨ feat(auth): 更新Limit类以支持PluginLimitSnapshot，优化限制信息处理

* ✨ feat(bot_manage): 优化Bot控制台初始化逻辑，处理IntegrityError异常

* ✨ feat(mmm1): 新增消息推送功能，支持私聊和群聊事件处理

* ✨ feat(group_member_update): 优化群组成员更新逻辑，增加活动跟踪和消息记录功能

* ✨ feat(mmm1): 删除冗余的消息推送功能代码

* ✨ feat(auth): 优化权限检查逻辑，增加模块阻止功能和缓存处理

* ✨ feat(auth): 优化权限检查逻辑，增加快速ban检测和前置检查功能

* ✨ feat(chat_history): 增强消息处理规则，添加时间间隔限制以防止重复消息
✨ feat(data_source): 引入异步获取群成员信息的功能，优化用户信息更新逻辑

* ✨ feat(send_queue): 添加异步发送队列以优化API调用和速率限制

* ✨ feat(auth): 添加缓存就绪检查以优化权限处理逻辑

* ✨ feat(plugins): 移除不必要的插件加载以简化插件管理

* ✨ feat(group_console): 优化群组获取逻辑，添加缓存检查以提升性能
✨ 只接收缓存完成之后时间的消息

* ✨ feat(auth): 添加异步任务管理和超载检测，优化权限处理逻辑
✨ feat(chat_history): 修改规则函数为异步，提升消息处理效率
✨ feat(group_handle): 增加安全获取群组信息的异步方法，添加超时处理
✨ feat(record_request): 引入安全获取群组信息的异步方法，优化群邀请处理
✨ feat(ban_memory_cache): 增强禁言内存缓存，添加负缓存机制
✨ feat(message_load): 新增消息负载检测功能，优化任务调度
✨ feat(scheduler): 在调度器中集成消息压力检测，优化任务执行
✨ feat(send_queue): 引入异步任务管理，优化发送队列处理

* ✨ feat(auth): 添加对 LevelUserSnapshot 和 BotSnapshot 的支持，优化权限检查逻辑
✨ 格式化

* ✨ feat(db_context): 增强 get_or_create 方法，处理并发创建冲突并回退查询已存在记录

* ✨ feat(bot_manage): 增强 init_bot_console 方法，处理并发创建冲突并回退查询已存在的 bot 数据

* 🚨 auto fix by pre-commit hooks

* ✨ feat(runtime_cache): 优化消息处理逻辑，支持 bytes 和 bytearray 类型的联合判断

* ✨ style(runtime_cache): 格式化代码，优化多行表达式的可读性

* 🚨 auto fix by pre-commit hooks

* ✨ refactor: 优化类型注解，改进群组成员更新逻辑和平台处理
✨ 格式化

* 🚨 auto fix by pre-commit hooks

* ✨ refactor: 优化代码格式，增强可读性并修复类型注解

* 🚨 auto fix by pre-commit hooks

* ✨ refactor: 更新文档注释，增强is_ban函数的可读性

* ✨ refactor: 优化代码结构，移除冗余函数，增强可读性并改进任务调度逻辑

* ✨ refactor: 调整定时任务时间，优化渲染服务的初始化逻辑，增强代码可读性

---------

Co-authored-by: ATTomatoo <1126160939@qq.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

zhenxun/builtin_plugins/hooks/auth/auth_admin.py

@@ -1,4 +1,3 @@
-import asyncio
 import time
 
 from nonebot_plugin_alconna import At
@@ -6,8 +5,7 @@ from nonebot_plugin_uninfo import Uninfo
 
 from zhenxun.models.level_user import LevelUser
 from zhenxun.models.plugin_info import PluginInfo
-from zhenxun.services.data_access import DataAccess
-from zhenxun.services.db_context import DB_TIMEOUT_SECONDS
+from zhenxun.services.cache.runtime_cache import LevelUserMemoryCache, LevelUserSnapshot
 from zhenxun.services.log import logger
 from zhenxun.utils.utils import get_entity_ids
 
@@ -16,7 +14,14 @@ from .exception import SkipPluginException
 from .utils import send_message
 
 
-async def auth_admin(plugin: PluginInfo, session: Uninfo):
+async def auth_admin(
+    plugin: PluginInfo,
+    session: Uninfo,
+    cached_levels: tuple[
+        LevelUser | LevelUserSnapshot | None, LevelUser | LevelUserSnapshot | None
+    ]
+    | None = None,
+):
     """管理员命令 个人权限
 
     参数:
@@ -30,37 +35,17 @@ async def auth_admin(plugin: PluginInfo, session: Uninfo):
 
     try:
         entity = get_entity_ids(session)
-        level_dao = DataAccess(LevelUser)
 
-        # 并行查询用户权限数据
-        global_user: LevelUser | None = None
-        group_users: LevelUser | None = None
+        global_user: LevelUser | LevelUserSnapshot | None = None
+        group_users: LevelUser | LevelUserSnapshot | None = None
 
-        # 查询全局权限
-        global_user_task = level_dao.safe_get_or_none(
-            user_id=session.user.id, group_id__isnull=True
-        )
-
-        # 如果在群组中，查询群组权限
-        group_users_task = None
-        if entity.group_id:
-            group_users_task = level_dao.safe_get_or_none(
-                user_id=session.user.id, group_id=entity.group_id
+        if cached_levels is not None:
+            global_user, group_users = cached_levels
+        else:
+            global_user, group_users = await LevelUserMemoryCache.get_levels(
+                session.user.id, entity.group_id
             )
 
-        # 等待查询完成，添加超时控制
-        try:
-            results = await asyncio.wait_for(
-                asyncio.gather(global_user_task, group_users_task or asyncio.sleep(0)),
-                timeout=DB_TIMEOUT_SECONDS,
-            )
-            global_user = results[0]
-            group_users = results[1] if group_users_task else None
-        except asyncio.TimeoutError:
-            logger.error(f"查询用户权限超时: user_id={session.user.id}", LOGGER_COMMAND)
-            # 超时时不阻塞，继续执行
-            return
-
         user_level = global_user.user_level if global_user else 0
         if entity.group_id and group_users:
             user_level = max(user_level, group_users.user_level)
@@ -73,6 +58,7 @@ async def auth_admin(plugin: PluginInfo, session: Uninfo):
                         f"你的权限不足喔，该功能需要的权限等级: {plugin.admin_level}",
                     ],
                     entity.user_id,
+                    background=True,
                 )
 
                 raise SkipPluginException(
@@ -83,6 +69,7 @@ async def auth_admin(plugin: PluginInfo, session: Uninfo):
                 await send_message(
                     session,
                     f"你的权限不足喔，该功能需要的权限等级: {plugin.admin_level}",
+                    background=True,
                 )
 
                 raise SkipPluginException(

zhenxun/builtin_plugins/hooks/auth/auth_ban.py

@@ -9,7 +9,8 @@ from nonebot_plugin_uninfo import Uninfo
 from zhenxun.configs.config import Config
 from zhenxun.models.ban_console import BanConsole
 from zhenxun.models.plugin_info import PluginInfo
-from zhenxun.services.data_access import DataAccess
+from zhenxun.services.cache.cache_containers import CacheDict
+from zhenxun.services.cache.runtime_cache import BanMemoryCache
 from zhenxun.services.db_context import DB_TIMEOUT_SECONDS
 from zhenxun.services.log import logger
 from zhenxun.utils.enum import PluginType
@@ -25,6 +26,76 @@ Config.add_plugin_config(
     "才不会给你发消息.",
     help="对被ban用户发送的消息",
 )
+Config.add_plugin_config(
+    "hook",
+    "BAN_CACHE_TTL",
+    2,
+    help="ban cache ttl seconds",
+)
+Config.add_plugin_config(
+    "hook",
+    "BAN_CACHE_TTL_POSITIVE",
+    30,
+    help="ban cache ttl seconds for banned users",
+)
+Config.add_plugin_config(
+    "hook",
+    "BAN_CACHE_TTL_NEGATIVE",
+    5,
+    help="ban cache ttl seconds for non-banned users",
+)
+
+
+def _coerce_ttl(value, default):
+    try:
+        value_int = int(value)
+    except (TypeError, ValueError):
+        return default
+    return value_int if value_int >= 0 else default
+
+
+_ban_cache_ttl_value = Config.get_config("hook", "BAN_CACHE_TTL", 2)
+try:
+    _ban_cache_ttl_value = int(_ban_cache_ttl_value)
+except (TypeError, ValueError):
+    _ban_cache_ttl_value = 2
+
+_ban_cache_ttl_positive = _coerce_ttl(
+    Config.get_config("hook", "BAN_CACHE_TTL_POSITIVE", _ban_cache_ttl_value),
+    _ban_cache_ttl_value,
+)
+_ban_cache_ttl_negative = _coerce_ttl(
+    Config.get_config("hook", "BAN_CACHE_TTL_NEGATIVE", _ban_cache_ttl_value),
+    _ban_cache_ttl_value,
+)
+
+BAN_CACHE = (
+    CacheDict("AUTH_BAN_CACHE", expire=0)
+    if max(_ban_cache_ttl_positive, _ban_cache_ttl_negative) > 0
+    else None
+)
+
+
+def _ban_cache_key(user_id: str | None, group_id: str | None) -> str:
+    return f"{user_id or ''}:{group_id or ''}"
+
+
+def _ban_cache_get(key: str) -> int | None:
+    if not BAN_CACHE:
+        return None
+    try:
+        return BAN_CACHE[key]
+    except KeyError:
+        return None
+
+
+def _ban_cache_set(key: str, value: int) -> None:
+    if not BAN_CACHE:
+        return
+    ttl = _ban_cache_ttl_positive if value else _ban_cache_ttl_negative
+    if ttl <= 0:
+        return
+    BAN_CACHE.set(key, value, expire=ttl)
 
 
 async def calculate_ban_time(ban_record: BanConsole | None) -> int:
@@ -57,79 +128,13 @@ async def is_ban(user_id: str | None, group_id: str | None) -> int:
         group_id: 群组ID
 
     返回:
-        int: ban的剩余时间，0表示未被ban
+        int: ban剩余时长，-1时为永久ban，0表示未被ban
     """
     if not user_id and not group_id:
         return 0
-
-    start_time = time.time()
-    ban_dao = DataAccess(BanConsole)
-
-    # 分别获取用户在群组中的ban记录和全局ban记录
-    group_user = None
-    user = None
-
-    try:
-        # 并行查询用户和群组的 ban 记录
-        tasks = []
-        if user_id and group_id:
-            tasks.append(ban_dao.safe_get_or_none(user_id=user_id, group_id=group_id))
-        if user_id:
-            tasks.append(
-                ban_dao.safe_get_or_none(user_id=user_id, group_id__isnull=True)
-            )
-
-        # 等待所有查询完成，添加超时控制
-        if tasks:
-            try:
-                ban_records = await asyncio.wait_for(
-                    asyncio.gather(*tasks), timeout=DB_TIMEOUT_SECONDS
-                )
-                if len(tasks) == 2:
-                    group_user, user = ban_records
-                elif user_id and group_id:
-                    group_user = ban_records[0]
-                else:
-                    user = ban_records[0]
-            except asyncio.TimeoutError:
-                logger.error(
-                    f"查询ban记录超时: user_id={user_id}, group_id={group_id}",
-                    LOGGER_COMMAND,
-                )
-                return 0
-
-        # 检查记录并计算ban时间
-        results = []
-        if group_user:
-            results.append(group_user)
-        if user:
-            results.append(user)
-
-        # 如果没有找到记录，返回0
-        if not results:
-            return 0
-
-        logger.debug(f"查询到的ban记录: {results}", LOGGER_COMMAND)
-        # 检查所有记录，找出最严格的ban（时间最长的）
-        max_ban_time: int = 0
-        for result in results:
-            if result.duration > 0 or result.duration == -1:
-                # 直接计算ban时间，避免再次查询数据库
-                ban_time = await calculate_ban_time(result)
-                if ban_time == -1 or ban_time > max_ban_time:
-                    max_ban_time = ban_time
-
-        return max_ban_time
-    finally:
-        # 记录执行时间
-        elapsed = time.time() - start_time
-        if elapsed > WARNING_THRESHOLD:  # 记录耗时超过500ms的检查
-            logger.warning(
-                f"is_ban 耗时: {elapsed:.3f}s",
-                LOGGER_COMMAND,
-                session=user_id,
-                group_id=group_id,
-            )
+    if not BanMemoryCache.is_loaded():
+        return 0
+    return BanMemoryCache.remaining_time(user_id, group_id)
 
 
 def check_plugin_type(matcher: Matcher) -> bool:

zhenxun/builtin_plugins/hooks/auth/auth_bot.py

@@ -1,10 +1,8 @@
-import asyncio
 import time
 
 from zhenxun.models.bot_console import BotConsole
 from zhenxun.models.plugin_info import PluginInfo
-from zhenxun.services.data_access import DataAccess
-from zhenxun.services.db_context import DB_TIMEOUT_SECONDS
+from zhenxun.services.cache.runtime_cache import BotMemoryCache, BotSnapshot
 from zhenxun.services.log import logger
 from zhenxun.utils.common_utils import CommonUtils
 
@@ -12,7 +10,12 @@ from .config import LOGGER_COMMAND, WARNING_THRESHOLD
 from .exception import SkipPluginException
 
 
-async def auth_bot(plugin: PluginInfo, bot_id: str):
+async def auth_bot(
+    plugin: PluginInfo,
+    bot_id: str,
+    bot_data: BotConsole | BotSnapshot | None = None,
+    skip_fetch: bool = False,
+):
     """bot层面的权限检查
 
     参数:
@@ -26,17 +29,9 @@ async def auth_bot(plugin: PluginInfo, bot_id: str):
     start_time = time.time()
 
     try:
-        # 从数据库或缓存中获取 bot 信息
-        bot_dao = DataAccess(BotConsole)
-
-        try:
-            bot: BotConsole | None = await asyncio.wait_for(
-                bot_dao.safe_get_or_none(bot_id=bot_id), timeout=DB_TIMEOUT_SECONDS
-            )
-        except asyncio.TimeoutError:
-            logger.error(f"查询Bot信息超时: bot_id={bot_id}", LOGGER_COMMAND)
-            # 超时时不阻塞，继续执行
-            return
+        bot: BotConsole | BotSnapshot | None = bot_data
+        if bot is None and not skip_fetch:
+            bot = await BotMemoryCache.get(bot_id)
 
         if not bot or not bot.status:
             raise SkipPluginException("Bot不存在或休眠中阻断权限检测...")

zhenxun/builtin_plugins/hooks/auth/auth_cost.py

@@ -10,12 +10,16 @@ from .config import LOGGER_COMMAND, WARNING_THRESHOLD
 from .exception import SkipPluginException
 from .utils import send_message
 
+DEFAULT_GOLD = 100
 
-async def auth_cost(user: UserConsole, plugin: PluginInfo, session: Uninfo) -> int:
+
+async def auth_cost(
+    user: UserConsole | None, plugin: PluginInfo, session: Uninfo
+) -> int:
     """检测是否满足金币条件
 
     参数:
-        user: UserConsole
+        user: UserConsole | None
         plugin: PluginInfo
         session: Uninfo
 
@@ -25,7 +29,8 @@ async def auth_cost(user: UserConsole, plugin: PluginInfo, session: Uninfo) -> i
     start_time = time.time()
 
     try:
-        if user.gold < plugin.cost_gold:
+        user_gold = user.gold if user else DEFAULT_GOLD
+        if user_gold < plugin.cost_gold:
             """插件消耗金币不足"""
             await send_message(session, f"金币不足..该功能需要{plugin.cost_gold}金币..")
             raise SkipPluginException(f"{plugin.name}({plugin.module}) 金币限制...")

zhenxun/builtin_plugins/hooks/auth/auth_group.py

@@ -1,9 +1,8 @@
 import time
 
-from nonebot_plugin_alconna import UniMsg
-
 from zhenxun.models.group_console import GroupConsole
 from zhenxun.models.plugin_info import PluginInfo
+from zhenxun.services.cache.runtime_cache import GroupSnapshot
 from zhenxun.services.log import logger
 
 from .config import LOGGER_COMMAND, WARNING_THRESHOLD, SwitchEnum
@@ -12,8 +11,8 @@ from .exception import SkipPluginException
 
 async def auth_group(
     plugin: PluginInfo,
-    group: GroupConsole | None,
-    message: UniMsg,
+    group: GroupConsole | GroupSnapshot | None,
+    text: str | None,
     group_id: str | None,
 ):
     """群黑名单检测 群总开关检测
@@ -29,7 +28,7 @@ async def auth_group(
     start_time = time.time()
 
     try:
-        text = message.extract_plain_text()
+        text = text or ""
 
         if not group:
             raise SkipPluginException("群组信息不存在...")

zhenxun/builtin_plugins/hooks/auth/auth_limit.py

@@ -1,13 +1,18 @@
 import asyncio
 import time
-from typing import ClassVar
+from typing import Any, ClassVar
 
 import nonebot
 from nonebot_plugin_uninfo import Uninfo
 from pydantic import BaseModel
 
+from zhenxun.configs.config import Config
 from zhenxun.models.plugin_info import PluginInfo
 from zhenxun.models.plugin_limit import PluginLimit
+from zhenxun.services.cache.runtime_cache import (
+    PluginLimitMemoryCache,
+    PluginLimitSnapshot,
+)
 from zhenxun.services.db_context import DB_TIMEOUT_SECONDS
 from zhenxun.services.log import logger
 from zhenxun.utils.enum import LimitWatchType, PluginLimitType
@@ -22,6 +27,16 @@ from .exception import SkipPluginException
 
 driver = nonebot.get_driver()
 
+Config.add_plugin_config(
+    "hook",
+    "AUTH_LIMIT_NOTICE_CD",
+    2,
+    help="auth limit notice cooldown seconds",
+)
+_LIMIT_NOTICE_CD = int(Config.get_config("hook", "AUTH_LIMIT_NOTICE_CD", 2) or 2)
+_LIMIT_NOTICE_LIMITER = FreqLimiter(_LIMIT_NOTICE_CD)
+_LIMIT_NOTICE_TASKS: set[asyncio.Task] = set()
+
 
 @PriorityLifecycle.on_startup(priority=5)
 async def _():
@@ -30,13 +45,41 @@ async def _():
 
 
 class Limit(BaseModel):
-    limit: PluginLimit
+    limit: PluginLimit | PluginLimitSnapshot
     limiter: FreqLimiter | UserBlockLimiter | CountLimiter
 
     class Config:
         arbitrary_types_allowed = True
 
 
+def _limit_notice_key(
+    limit: PluginLimit | PluginLimitSnapshot,
+    user_id: str,
+    group_id: str | None,
+    channel_id: str | None,
+) -> str:
+    key = user_id
+    if group_id and limit.watch_type == LimitWatchType.GROUP:
+        key = channel_id or group_id
+    return f"{limit.module}:{limit.limit_type}:{key}"
+
+
+def _send_limit_notice(message: str, format_kwargs: dict[str, Any], key: str) -> None:
+    if not _LIMIT_NOTICE_LIMITER.check(key):
+        return
+    _LIMIT_NOTICE_LIMITER.start_cd(key)
+
+    async def _send():
+        try:
+            await MessageUtils.build_message(message, format_args=format_kwargs).send()
+        except Exception as exc:
+            logger.error("limit notice send failed", LOGGER_COMMAND, e=exc)
+
+    task = asyncio.create_task(_send())
+    _LIMIT_NOTICE_TASKS.add(task)
+    task.add_done_callback(_LIMIT_NOTICE_TASKS.discard)
+
+
 class LimitManager:
     add_module: ClassVar[list] = []
     last_update_time: ClassVar[float] = 0
@@ -48,8 +91,11 @@ class LimitManager:
     count_limit: ClassVar[dict[str, Limit]] = {}
 
     # 模块限制缓存，避免频繁查询数据库
-    module_limit_cache: ClassVar[dict[str, tuple[float, list[PluginLimit]]]] = {}
+    module_limit_cache: ClassVar[
+        dict[str, tuple[float, list[PluginLimitSnapshot], bool]]
+    ] = {}
     module_cache_ttl: ClassVar[float] = 60  # 模块缓存有效期（秒）
+    module_cache_error_ttl: ClassVar[float] = 5  # 超时缓存有效期（秒）
 
     @classmethod
     async def init_limit(cls):
@@ -70,14 +116,8 @@ class LimitManager:
         cls.is_updating = True
         try:
             start_time = time.time()
-            try:
-                limit_list = await asyncio.wait_for(
-                    PluginLimit.filter(status=True).all(), timeout=DB_TIMEOUT_SECONDS
-                )
-            except asyncio.TimeoutError:
-                logger.error("查询限制信息超时", LOGGER_COMMAND)
-                cls.is_updating = False
-                return
+            await PluginLimitMemoryCache.ensure_loaded()
+            limit_list = PluginLimitMemoryCache.get_all_limits()
 
             # 清空旧数据
             cls.add_module = []
@@ -96,7 +136,7 @@ class LimitManager:
             cls.is_updating = False
 
     @classmethod
-    def add_limit(cls, limit: PluginLimit):
+    def add_limit(cls, limit: PluginLimit | PluginLimitSnapshot):
         """添加限制
 
         参数:
@@ -109,12 +149,16 @@ class LimitManager:
                     limit=limit, limiter=UserBlockLimiter()
                 )
             elif limit.limit_type == PluginLimitType.CD:
+                cd_value = int(limit.cd or 0)
                 cls.cd_limit[limit.module] = Limit(
-                    limit=limit, limiter=FreqLimiter(limit.cd)
+                    limit=limit, limiter=FreqLimiter(cd_value)
                 )
             elif limit.limit_type == PluginLimitType.COUNT:
+                max_count = int(limit.max_count or 0)
+                if max_count <= 0:
+                    return
                 cls.count_limit[limit.module] = Limit(
-                    limit=limit, limiter=CountLimiter(limit.max_count)
+                    limit=limit, limiter=CountLimiter(max_count)
                 )
 
     @classmethod
@@ -144,7 +188,7 @@ class LimitManager:
             limiter.set_false(key_type)
 
     @classmethod
-    async def get_module_limits(cls, module: str) -> list[PluginLimit]:
+    async def get_module_limits(cls, module: str) -> list[PluginLimitSnapshot]:
         """获取模块的限制信息，使用缓存减少数据库查询
 
         参数:
@@ -157,30 +201,20 @@ class LimitManager:
 
         # 检查缓存
         if module in cls.module_limit_cache:
-            cache_time, limits = cls.module_limit_cache[module]
-            if current_time - cache_time < cls.module_cache_ttl:
+            cache_time, limits, is_error = cls.module_limit_cache[module]
+            ttl = cls.module_cache_error_ttl if is_error else cls.module_cache_ttl
+            if current_time - cache_time < ttl:
                 return limits
 
-        # 缓存不存在或已过期，从数据库查询
+        # 缓存不存在或已过期，从内存缓存获取
         try:
-            start_time = time.time()
-            limits = await asyncio.wait_for(
-                PluginLimit.filter(module=module, status=True).all(),
-                timeout=DB_TIMEOUT_SECONDS,
-            )
-            elapsed = time.time() - start_time
-            if elapsed > WARNING_THRESHOLD:  # 记录耗时超过500ms的查询
-                logger.warning(
-                    f"查询模块限制信息耗时: {elapsed:.3f}s, 模块: {module}",
-                    LOGGER_COMMAND,
-                )
-
-            # 更新缓存
-            cls.module_limit_cache[module] = (current_time, limits)
+            await PluginLimitMemoryCache.ensure_loaded()
+            limits = await PluginLimitMemoryCache.get_limits(module)
+            cls.module_limit_cache[module] = (current_time, limits, False)
             return limits
-        except asyncio.TimeoutError:
-            logger.error(f"查询模块限制信息超时: {module}", LOGGER_COMMAND)
-            # 超时时返回空列表，避免阻塞
+        except Exception as exc:
+            logger.error(f"get module limits failed: {module}", LOGGER_COMMAND, e=exc)
+            cls.module_limit_cache[module] = (current_time, [], True)
             return []
 
     @classmethod
@@ -275,15 +309,8 @@ class LimitManager:
                     left_time = limiter.left_time(key_type)
                     cd_str = TimeUtils.format_duration(left_time)
                     format_kwargs = {"cd": cd_str}
-                try:
-                    await asyncio.wait_for(
-                        MessageUtils.build_message(
-                            limit.result, format_args=format_kwargs
-                        ).send(),
-                        timeout=DB_TIMEOUT_SECONDS,
-                    )
-                except asyncio.TimeoutError:
-                    logger.error(f"发送限制消息超时: {limit.module}", LOGGER_COMMAND)
+                notice_key = _limit_notice_key(limit, user_id, group_id, channel_id)
+                _send_limit_notice(limit.result, format_kwargs, notice_key)
             raise SkipPluginException(
                 f"{limit.module}({limit.limit_type}) 正在限制中..."
             )

zhenxun/builtin_plugins/hooks/auth/auth_plugin.py

@@ -1,4 +1,3 @@
-import asyncio
 import time
 
 from nonebot.adapters import Event
@@ -6,9 +5,8 @@ from nonebot_plugin_uninfo import Uninfo
 
 from zhenxun.models.group_console import GroupConsole
 from zhenxun.models.plugin_info import PluginInfo
-from zhenxun.services.db_context import DB_TIMEOUT_SECONDS
+from zhenxun.services.cache.runtime_cache import GroupSnapshot, _parse_block_modules
 from zhenxun.services.log import logger
-from zhenxun.utils.common_utils import CommonUtils
 from zhenxun.utils.enum import BlockType
 
 from .config import LOGGER_COMMAND, WARNING_THRESHOLD
@@ -16,74 +14,89 @@ from .exception import IsSuperuserException, SkipPluginException
 from .utils import freq, is_poke, send_message
 
 
+def _get_group_block_sets(
+    group: GroupConsole | GroupSnapshot,
+) -> tuple[frozenset[str], frozenset[str]]:
+    block_set = getattr(group, "block_plugin_set", None)
+    super_block_set = getattr(group, "superuser_block_plugin_set", None)
+    if block_set is None:
+        block_set = _parse_block_modules(getattr(group, "block_plugin", "") or "")
+        setattr(group, "block_plugin_set", block_set)
+    if super_block_set is None:
+        super_block_set = _parse_block_modules(
+            getattr(group, "superuser_block_plugin", "") or ""
+        )
+        setattr(group, "superuser_block_plugin_set", super_block_set)
+    return block_set, super_block_set
+
+
 class GroupCheck:
     def __init__(
-        self, plugin: PluginInfo, group: GroupConsole, session: Uninfo, is_poke: bool
+        self,
+        plugin: PluginInfo,
+        group: GroupConsole | GroupSnapshot,
+        session: Uninfo,
+        is_poke: bool,
+        skip_group_block: bool,
     ) -> None:
         self.session = session
         self.is_poke = is_poke
         self.plugin = plugin
         self.group_data = group
         self.group_id = group.group_id
+        self.skip_group_block = skip_group_block
+        (
+            self.block_plugin_set,
+            self.superuser_block_plugin_set,
+        ) = _get_group_block_sets(group)
 
     async def check(self):
         start_time = time.time()
         try:
-            # 检查超级用户禁用
-            if (
-                self.group_data
-                and CommonUtils.format(self.plugin.module)
-                in self.group_data.superuser_block_plugin
-            ):
-                if freq.is_send_limit_message(self.plugin, self.group_id, self.is_poke):
-                    try:
-                        await asyncio.wait_for(
-                            send_message(
-                                self.session,
-                                "超级管理员禁用了该群此功能...",
-                                self.group_id,
-                            ),
-                            timeout=DB_TIMEOUT_SECONDS,
+            if not self.skip_group_block:
+                # 检查超级用户禁用
+                if (
+                    self.group_data
+                    and self.plugin.module in self.superuser_block_plugin_set
+                ):
+                    if freq.is_send_limit_message(
+                        self.plugin, self.group_id, self.is_poke
+                    ):
+                        await send_message(
+                            self.session,
+                            "超级管理员禁用了该群此功能...",
+                            self.group_id,
+                            background=True,
                         )
-                    except asyncio.TimeoutError:
-                        logger.error(f"发送消息超时: {self.group_id}", LOGGER_COMMAND)
-                raise SkipPluginException(
-                    f"{self.plugin.name}({self.plugin.module})"
-                    f" 超级管理员禁用了该群此功能..."
-                )
+                    raise SkipPluginException(
+                        f"{self.plugin.name}({self.plugin.module})"
+                        f" 超级管理员禁用了该群此功能..."
+                    )
 
-            # 检查普通禁用
-            if (
-                self.group_data
-                and CommonUtils.format(self.plugin.module)
-                in self.group_data.block_plugin
-            ):
-                if freq.is_send_limit_message(self.plugin, self.group_id, self.is_poke):
-                    try:
-                        await asyncio.wait_for(
-                            send_message(
-                                self.session, "该群未开启此功能...", self.group_id
-                            ),
-                            timeout=DB_TIMEOUT_SECONDS,
+                # 检查普通禁用
+                if self.group_data and self.plugin.module in self.block_plugin_set:
+                    if freq.is_send_limit_message(
+                        self.plugin, self.group_id, self.is_poke
+                    ):
+                        await send_message(
+                            self.session,
+                            "该群未开启此功能...",
+                            self.group_id,
+                            background=True,
                         )
-                    except asyncio.TimeoutError:
-                        logger.error(f"发送消息超时: {self.group_id}", LOGGER_COMMAND)
-                raise SkipPluginException(
-                    f"{self.plugin.name}({self.plugin.module}) 未开启此功能..."
-                )
+                    raise SkipPluginException(
+                        f"{self.plugin.name}({self.plugin.module}) 未开启此功能..."
+                    )
 
             # 检查全局禁用
             if self.plugin.block_type == BlockType.GROUP:
                 if freq.is_send_limit_message(self.plugin, self.group_id, self.is_poke):
-                    try:
-                        await asyncio.wait_for(
-                            send_message(
-                                self.session, "该功能在群组中已被禁用...", self.group_id
-                            ),
-                            timeout=DB_TIMEOUT_SECONDS,
-                        )
-                    except asyncio.TimeoutError:
-                        logger.error(f"发送消息超时: {self.group_id}", LOGGER_COMMAND)
+                    await send_message(
+                        self.session,
+                        "该功能在群组中已被禁用...",
+                        self.group_id,
+                        background=True,
+                    )
                 raise SkipPluginException(
                     f"{self.plugin.name}({self.plugin.module})该插件在群组中已被禁用..."
                 )
@@ -98,7 +111,9 @@ class GroupCheck:
 
 
 class PluginCheck:
-    def __init__(self, group: GroupConsole | None, session: Uninfo, is_poke: bool):
+    def __init__(
+        self, group: GroupConsole | GroupSnapshot | None, session: Uninfo, is_poke: bool
+    ):
         self.session = session
         self.is_poke = is_poke
         self.group_data = group
@@ -117,13 +132,11 @@ class PluginCheck:
         """
         if plugin.block_type == BlockType.PRIVATE:
             if freq.is_send_limit_message(plugin, self.session.user.id, self.is_poke):
-                try:
-                    await asyncio.wait_for(
-                        send_message(self.session, "该功能在私聊中已被禁用..."),
-                        timeout=DB_TIMEOUT_SECONDS,
-                    )
-                except asyncio.TimeoutError:
-                    logger.error("发送消息超时", LOGGER_COMMAND)
+                await send_message(
+                    self.session,
+                    "该功能在私聊中已被禁用...",
+                    background=True,
+                )
             raise SkipPluginException(
                 f"{plugin.name}({plugin.module}) 该插件在私聊中已被禁用..."
             )
@@ -147,13 +160,12 @@ class PluginCheck:
 
             sid = self.group_id or self.session.user.id
             if freq.is_send_limit_message(plugin, sid, self.is_poke):
-                try:
-                    await asyncio.wait_for(
-                        send_message(self.session, "全局未开启此功能...", sid),
-                        timeout=DB_TIMEOUT_SECONDS,
-                    )
-                except asyncio.TimeoutError:
-                    logger.error(f"发送消息超时: {sid}", LOGGER_COMMAND)
+                await send_message(
+                    self.session,
+                    "全局未开启此功能...",
+                    sid,
+                    background=True,
+                )
             raise SkipPluginException(
                 f"{plugin.name}({plugin.module}) 全局未开启此功能..."
             )
@@ -167,7 +179,12 @@ class PluginCheck:
 
 
 async def auth_plugin(
-    plugin: PluginInfo, group: GroupConsole | None, session: Uninfo, event: Event
+    plugin: PluginInfo,
+    group: GroupConsole | GroupSnapshot | None,
+    session: Uninfo,
+    event: Event,
+    *,
+    skip_group_block: bool = False,
 ):
     """插件状态
 
@@ -181,19 +198,21 @@ async def auth_plugin(
         is_poke_event = is_poke(event)
         user_check = PluginCheck(group, session, is_poke_event)
 
-        tasks = []
         if group:
-            tasks.append(GroupCheck(plugin, group, session, is_poke_event).check())
+            block_set, super_block_set = _get_group_block_sets(group)
+            if (
+                plugin.status
+                and plugin.block_type != BlockType.GROUP
+                and not block_set
+                and not super_block_set
+            ):
+                return
+            await GroupCheck(
+                plugin, group, session, is_poke_event, skip_group_block
+            ).check()
         else:
-            tasks.append(user_check.check_user(plugin))
-        tasks.append(user_check.check_global(plugin))
-
-        try:
-            await asyncio.wait_for(
-                asyncio.gather(*tasks), timeout=DB_TIMEOUT_SECONDS * 2
-            )
-        except asyncio.TimeoutError:
-            logger.error("插件用户/群组/全局检查超时...", LOGGER_COMMAND)
+            await user_check.check_user(plugin)
+        await user_check.check_global(plugin)
 
     finally:
         # 记录总执行时间

zhenxun/builtin_plugins/hooks/auth/utils.py

@@ -1,3 +1,4 @@
+import asyncio
 import contextlib
 
 from nonebot.adapters import Event
@@ -13,6 +14,7 @@ from zhenxun.utils.utils import FreqLimiter
 from .config import LOGGER_COMMAND
 
 base_config = Config.get("hook")
+_SEND_TASKS: set[asyncio.Task] = set()
 
 
 def is_poke(event: Event) -> bool:
@@ -32,7 +34,10 @@ def is_poke(event: Event) -> bool:
 
 
 async def send_message(
-    session: Uninfo, message: list | str, check_tag: str | None = None
+    session: Uninfo,
+    message: list | str,
+    check_tag: str | None = None,
+    background: bool = False,
 ):
     """发送消息
 
@@ -41,19 +46,28 @@ async def send_message(
         message: 消息
         check_tag: cd flag
     """
-    try:
-        if not check_tag:
-            await MessageUtils.build_message(message).send(reply_to=True)
-        elif freq._flmt.check(check_tag):
-            freq._flmt.start_cd(check_tag)
-            await MessageUtils.build_message(message).send(reply_to=True)
-    except Exception as e:
-        logger.error(
-            "发送消息失败",
-            LOGGER_COMMAND,
-            session=session,
-            e=e,
-        )
+
+    async def _send():
+        try:
+            if not check_tag:
+                await MessageUtils.build_message(message).send(reply_to=True)
+            elif freq._flmt.check(check_tag):
+                freq._flmt.start_cd(check_tag)
+                await MessageUtils.build_message(message).send(reply_to=True)
+        except Exception as e:
+            logger.error(
+                "发送消息失败",
+                LOGGER_COMMAND,
+                session=session,
+                e=e,
+            )
+
+    if background:
+        task = asyncio.create_task(_send())
+        _SEND_TASKS.add(task)
+        task.add_done_callback(_SEND_TASKS.discard)
+        return
+    await _send()
 
 
 class FreqUtils: