🎉🍾♻️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_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}) 正在限制中..."
             )