sycommon-python-lib 0.1.56b2__py3-none-any.whl → 0.1.56b4__py3-none-any.whl

sycommon/llm/get_llm.py

@@ -1,48 +1,137 @@
-from typing import Dict, Type, List, Union, Optional, Callable
-
+from typing import Dict, Type, List, Optional, Callable, Any
 from sycommon.llm.llm_logger import LLMLogger
 from langchain_core.language_models import BaseChatModel
-from langchain_core.runnables import Runnable, RunnableLambda
+from langchain_core.runnables import Runnable, RunnableLambda, RunnableConfig
 from langchain_core.output_parsers import PydanticOutputParser
-from langchain_core.messages import BaseMessage, SystemMessage, HumanMessage
+from langchain_core.messages import BaseMessage, HumanMessage
 from langchain.chat_models import init_chat_model
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from pydantic import BaseModel, ValidationError
+from pydantic import BaseModel, ValidationError, Field
 from sycommon.config.LLMConfig import LLMConfig
+from sycommon.llm.llm_tokens import TokensCallbackHandler
+from sycommon.logging.kafka_log import SYLogger
+
+
+class StructuredRunnableWithToken(Runnable):
+    """带Token统计的Runnable类"""
+
+    def __init__(self, retry_chain: Runnable):
+        super().__init__()
+        self.retry_chain = retry_chain
+
+    def _adapt_input(self, input: Any) -> List[BaseMessage]:
+        """适配输入格式"""
+        if isinstance(input, list) and all(isinstance(x, BaseMessage) for x in input):
+            return input
+        elif isinstance(input, BaseMessage):
+            return [input]
+        elif isinstance(input, str):
+            return [HumanMessage(content=input)]
+        elif isinstance(input, dict) and "input" in input:
+            return [HumanMessage(content=str(input["input"]))]
+        else:
+            raise ValueError(f"不支持的输入格式：{type(input)}")
 
+    def _get_callback_config(self, config: Optional[RunnableConfig] = None) -> tuple[RunnableConfig, TokensCallbackHandler]:
+        """构建包含Token统计的回调配置"""
+        # 每次调用创建新的Token处理器实例
+        token_handler = TokensCallbackHandler()
 
-def get_llm(model: str = None, streaming: bool = False) -> BaseChatModel:
-    if not model:
-        model = "Qwen2.5-72B"
-        # model = "SyMid"
-    llmConfig = LLMConfig.from_config(model)
-    llm = None
-    if llmConfig:
-        llm = init_chat_model(
-            model_provider=llmConfig.provider,
-            model=llmConfig.model,
-            base_url=llmConfig.baseUrl,
-            api_key="-",
-            temperature=0.1,
-            streaming=streaming,
-        )
-    else:
-        raise Exception("Invalid model")
+        # 初始化配置
+        if config is None:
+            processed_config = {"callbacks": []}
+        else:
+            processed_config = config.copy()
+            if "callbacks" not in processed_config:
+                processed_config["callbacks"] = []
+
+        # 添加回调（去重）
+        callbacks = processed_config["callbacks"]
+        # 添加LLMLogger（如果不存在）
+        if not any(isinstance(cb, LLMLogger) for cb in callbacks):
+            callbacks.append(LLMLogger())
+        # 添加Token处理器
+        callbacks.append(token_handler)
+
+        # 按类型去重
+        callback_types = {}
+        unique_callbacks = []
+        for cb in callbacks:
+            cb_type = type(cb)
+            if cb_type not in callback_types:
+                callback_types[cb_type] = cb
+                unique_callbacks.append(cb)
+
+        processed_config["callbacks"] = unique_callbacks
+
+        return processed_config, token_handler
+
+    # 同步调用
+    def invoke(self, input: Any, config: Optional[RunnableConfig] = None, ** kwargs) -> Dict[str, Any]:
+        try:
+            processed_config, token_handler = self._get_callback_config(
+                config)
+            adapted_input = self._adapt_input(input)
+
+            structured_result = self.retry_chain.invoke(
+                {"messages": adapted_input},
+                config=processed_config,
+                **kwargs
+            )
+
+            # 获取Token统计结果
+            token_usage = token_handler.usage_metadata
+            structured_result._token_usage_ = token_usage
+
+            return structured_result
+
+        except Exception as e:
+            SYLogger.error(f"同步LLM调用失败: {str(e)}", exc_info=True)
+            return None
+
+    # 异步调用
+    async def ainvoke(self, input: Any, config: Optional[RunnableConfig] = None, ** kwargs) -> Dict[str, Any]:
+        try:
+            processed_config, token_handler = self._get_callback_config(
+                config)
+            adapted_input = self._adapt_input(input)
+
+            structured_result = await self.retry_chain.ainvoke(
+                {"messages": adapted_input},
+                config=processed_config,
+                **kwargs
+            )
+
+            token_usage = token_handler.usage_metadata
+            structured_result._token_usage_ = token_usage
+
+            return structured_result
+
+        except Exception as e:
+            SYLogger.error(f"异步LLM调用失败: {str(e)}", exc_info=True)
+            return None
+
+
+class LLMWithAutoTokenUsage(BaseChatModel):
+    """自动为结构化调用返回token_usage的LLM包装类"""
+    llm: BaseChatModel = Field(default=None)
+
+    def __init__(self, llm: BaseChatModel, **kwargs):
+        super().__init__(llm=llm, ** kwargs)
 
-    # 为LLM动态添加with_structured_output方法，官方的with_structured_output方法有概率在qwen2.5中导致模型卡死不返回数据，2.5对functioncall支持不好
     def with_structured_output(
-        self: BaseChatModel,
+        self,
         output_model: Type[BaseModel],
         max_retries: int = 3,
         is_extract: bool = False,
         override_prompt: ChatPromptTemplate = None,
-        # 自定义处理函数列表（每个函数接收str，返回str）
         custom_processors: Optional[List[Callable[[str], str]]] = None,
-        # 自定义解析函数（接收str，返回BaseModel）
         custom_parser: Optional[Callable[[str], BaseModel]] = None
-    ) -> Runnable[List[BaseMessage], BaseModel]:
+    ) -> Runnable:
+        """返回支持自动统计Token的结构化Runnable"""
         parser = PydanticOutputParser(pydantic_object=output_model)
 
+        # 提示词模板
         accuracy_instructions = """
         字段值的抽取准确率（0~1之间），评分规则：
         1.0（完全准确）：直接从原文提取，无需任何加工，且格式与原文完全一致
@@ -52,7 +141,6 @@ def get_llm(model: str = None, streaming: bool = False) -> BaseChatModel:
         """
 
         if is_extract:
-            # 抽取模式下使用固定的抽取专用prompt
             prompt = ChatPromptTemplate.from_messages([
                 MessagesPlaceholder(variable_name="messages"),
                 HumanMessage(content=f"""
@@ -62,116 +150,97 @@ def get_llm(model: str = None, streaming: bool = False) -> BaseChatModel:
                 """)
             ])
         else:
-            if override_prompt:
-                prompt = override_prompt
-            else:
-                prompt = ChatPromptTemplate.from_messages([
-                    MessagesPlaceholder(variable_name="messages"),
-                    HumanMessage(content=f"""
-                    输出格式：{parser.get_format_instructions()}
-                    """)
-                ])
-
-        # ========== 基础处理函数 ==========
+            prompt = override_prompt or ChatPromptTemplate.from_messages([
+                MessagesPlaceholder(variable_name="messages"),
+                HumanMessage(content=f"""
+                输出格式：{parser.get_format_instructions()}
+                """)
+            ])
+
+        # 文本处理函数
         def extract_response_content(response: BaseMessage) -> str:
-            """提取响应中的文本内容"""
             try:
                 return response.content
             except Exception as e:
                 raise ValueError(f"提取响应内容失败：{str(e)}") from e
 
         def strip_code_block_markers(content: str) -> str:
-            """移除JSON代码块标记（```json/```）"""
             try:
                 return content.strip("```json").strip("```").strip()
             except Exception as e:
-                raise ValueError(
-                    f"移除代码块标记失败（内容：{str(content)[:100]}）：{str(e)}") from e
+                raise ValueError(f"移除代码块标记失败：{str(e)}") from e
 
         def normalize_in_json(content: str) -> str:
-            """将None替换为null，确保JSON格式合法"""
             try:
-                cleaned = content.replace("None", "null")
-                cleaned = cleaned.replace("none", "null")
-                cleaned = cleaned.replace("NONE", "null")
-                cleaned = cleaned.replace("''", '""')
-                return cleaned
+                return content.replace("None", "null").replace("none", "null").replace("NONE", "null").replace("''", '""')
             except Exception as e:
-                raise ValueError(
-                    f"替换None为null失败（内容：{str(content)[:100]}）：{str(e)}") from e
+                raise ValueError(f"JSON格式化失败：{str(e)}") from e
 
         def default_parse_to_pydantic(content: str) -> BaseModel:
-            """默认解析函数：将处理后的文本解析为Pydantic模型"""
             try:
                 return parser.parse(content)
             except (ValidationError, ValueError) as e:
-                raise type(e)(f"解析失败（原始内容：{content[:200]}）：{str(e)}") from e
-
-        # ========== 构建处理链条 ==========
-        # 基础链 prompt → LLM → 提取响应内容
-        base_chain = (
-            prompt
-            | self
-            | RunnableLambda(extract_response_content)
-        )
+                raise ValueError(f"解析结构化结果失败：{str(e)}") from e
 
-        # 处理函数链 优先使用自定义，否则用默认
-        if custom_processors:
-            # 自定义处理函数 → 转为RunnableLambda列表
-            process_runnables = [RunnableLambda(
-                func) for func in custom_processors]
-        else:
-            # 默认处理函数：移除代码块标记 → 标准化JSON空值
-            process_runnables = [
-                RunnableLambda(strip_code_block_markers),
-                RunnableLambda(normalize_in_json)
-            ]
+        # ========== 构建处理链 ==========
+        base_chain = prompt | self.llm | RunnableLambda(
+            extract_response_content)
 
-        # 拼接处理链
+        # 文本处理链
+        process_runnables = custom_processors or [
+            RunnableLambda(strip_code_block_markers),
+            RunnableLambda(normalize_in_json)
+        ]
         process_chain = base_chain
         for runnable in process_runnables:
             process_chain = process_chain | runnable
 
-        # 解析函数 优先使用自定义，否则用默认
-        parse_func = custom_parser if custom_parser else default_parse_to_pydantic
-        parse_chain = process_chain | RunnableLambda(parse_func)
+        # 解析链
+        parse_chain = process_chain | RunnableLambda(
+            custom_parser or default_parse_to_pydantic)
 
+        # 重试链
         retry_chain = parse_chain.with_retry(
             retry_if_exception_type=(ValidationError, ValueError),
             stop_after_attempt=max_retries,
             wait_exponential_jitter=True,
             exponential_jitter_params={
-                "initial": 0.1,  # 初始等待时间（秒）
-                "max": 3.0,      # 最大等待时间（秒）
-                "exp_base": 2.0,  # 指数基数（默认2）
-                "jitter": 1.0    # 随机抖动值（默认1）
-            }
+                "initial": 0.1, "max": 3.0, "exp_base": 2.0, "jitter": 1.0}
         )
 
-        class StructuredRunnable(Runnable[Union[List[BaseMessage], BaseMessage, str, Dict[str, str]], BaseModel]):
-            def _adapt_input(self, input: Union[List[BaseMessage], BaseMessage, str, Dict[str, str]]) -> List[BaseMessage]:
-                """将多种输入格式统一转换为 List[BaseMessage]"""
-                if isinstance(input, list) and all(isinstance(x, BaseMessage) for x in input):
-                    return input
-                elif isinstance(input, BaseMessage):
-                    return [input]
-                elif isinstance(input, str):
-                    return [HumanMessage(content=input)]
-                elif isinstance(input, dict) and "input" in input:
-                    return [HumanMessage(content=str(input["input"]))]
-                else:
-                    raise ValueError(
-                        "不支持的输入格式，请使用消息列表、单条消息、文本或 {'input': '文本'}")
-
-            def invoke(self, input: Union[List[BaseMessage], BaseMessage, str, Dict[str, str]], config={"callbacks": [LLMLogger()]}):
-                adapted_input = self._adapt_input(input)
-                return retry_chain.invoke({"messages": adapted_input}, config=config)
-
-            async def ainvoke(self, input: Union[List[BaseMessage], BaseMessage, str, Dict[str, str]], config={"callbacks": [LLMLogger()]}):
-                adapted_input = self._adapt_input(input)
-                return await retry_chain.ainvoke({"messages": adapted_input}, config=config)
-
-        return StructuredRunnable()
-
-    llm.__class__.with_structured_output = with_structured_output
-    return llm
+        return StructuredRunnableWithToken(retry_chain)
+
+    # ========== 实现BaseChatModel抽象方法 ==========
+    def _generate(self, messages, stop=None, run_manager=None, ** kwargs):
+        return self.llm._generate(messages, stop=stop, run_manager=run_manager, ** kwargs)
+
+    @property
+    def _llm_type(self) -> str:
+        return self.llm._llm_type
+
+
+def get_llm(
+    model: str = None,
+    streaming: bool = False
+) -> LLMWithAutoTokenUsage:
+    if not model:
+        model = "Qwen2.5-72B"
+
+    llmConfig = LLMConfig.from_config(model)
+    if not llmConfig:
+        raise Exception(f"无效的模型配置：{model}")
+
+    llm = init_chat_model(
+        model_provider=llmConfig.provider,
+        model=llmConfig.model,
+        base_url=llmConfig.baseUrl,
+        api_key="-",
+        temperature=0.1,
+        streaming=streaming,
+        callbacks=[LLMLogger()]
+    )
+
+    if llm is None:
+        raise Exception(f"初始化原始LLM实例失败：{model}")
+
+    return LLMWithAutoTokenUsage(llm)

sycommon/llm/llm_tokens.py

@@ -0,0 +1,119 @@
+from typing import Any
+from langchain_core.callbacks import AsyncCallbackHandler
+from langchain_core.outputs.llm_result import LLMResult
+from sycommon.logging.kafka_log import SYLogger
+
+
+class TokensCallbackHandler(AsyncCallbackHandler):
+    """
+    继承AsyncCallbackHandler的Token统计处理器
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.input_tokens = 0
+        self.output_tokens = 0
+        self.total_tokens = 0
+        self.usage_metadata = {}
+        self.reset()
+
+    def reset(self):
+        """重置Token统计数据"""
+        self.input_tokens = 0
+        self.output_tokens = 0
+        self.total_tokens = 0
+        self.usage_metadata = {
+            "input_tokens": 0,
+            "output_tokens": 0,
+            "total_tokens": 0
+        }
+
+    # ========== 同步回调方法（兼容签名） ==========
+    def on_llm_end(
+        self,
+        response: LLMResult,
+        **kwargs: Any,
+    ) -> None:
+        """同步LLM调用结束时的回调"""
+        self._parse_token_usage(response)
+
+    # ========== 异步回调方法（兼容签名） ==========
+    async def on_llm_end(
+        self,
+        response: LLMResult,
+        **kwargs: Any,
+    ) -> None:
+        """异步LLM调用结束时的回调"""
+        self._parse_token_usage(response)
+
+    def _parse_token_usage(self, response: LLMResult) -> None:
+        """
+        通用Token解析逻辑，不依赖特定类结构
+        兼容各种LLM响应格式
+        """
+        try:
+            # 情况1: 标准LangChain响应（有llm_output属性）
+            if response.llm_output:
+                llm_output = response.llm_output
+                self._parse_from_llm_output(llm_output)
+
+            # 情况2: 包含generations的响应
+            elif response.generations:
+                self._parse_from_generations(response.generations)
+
+            # 计算总Token
+            if self.total_tokens <= 0:
+                self.total_tokens = self.input_tokens + self.output_tokens
+
+            # 更新metadata
+            self.usage_metadata = {
+                "input_tokens": self.input_tokens,
+                "output_tokens": self.output_tokens,
+                "total_tokens": self.total_tokens
+            }
+
+            SYLogger.debug(
+                f"Token统计成功 - 输入: {self.input_tokens}, 输出: {self.output_tokens}")
+
+        except Exception as e:
+            SYLogger.warning(f"Token解析失败: {str(e)}", exc_info=True)
+            self.reset()
+
+    def _parse_from_llm_output(self, llm_output: dict) -> None:
+        """从llm_output字典解析Token信息"""
+        if not isinstance(llm_output, dict):
+            return
+
+        # OpenAI标准格式
+        if 'token_usage' in llm_output:
+            token_usage = llm_output['token_usage']
+            self.input_tokens = token_usage.get(
+                'prompt_tokens', token_usage.get('input_tokens', 0))
+            self.output_tokens = token_usage.get(
+                'completion_tokens', token_usage.get('output_tokens', 0))
+            self.total_tokens = token_usage.get('total_tokens', 0)
+
+        # 直接包含Token信息
+        else:
+            self.input_tokens = llm_output.get(
+                'input_tokens', llm_output.get('prompt_tokens', 0))
+            self.output_tokens = llm_output.get(
+                'output_tokens', llm_output.get('completion_tokens', 0))
+            self.total_tokens = token_usage.get('total_tokens', 0)
+
+    def _parse_from_generations(self, generations: list) -> None:
+        """从generations列表解析Token信息"""
+        if not isinstance(generations, list) or len(generations) == 0:
+            return
+
+        # 遍历generation信息
+        for gen_group in generations:
+            for generation in gen_group:
+                if hasattr(generation, 'generation_info') and generation.generation_info:
+                    gen_info = generation.generation_info
+                    self.input_tokens = gen_info.get(
+                        'input_tokens', gen_info.get('prompt_tokens', 0))
+                    self.output_tokens = gen_info.get(
+                        'output_tokens', gen_info.get('completion_tokens', 0))
+                    self.total_tokens = gen_info.get('total_tokens', 0)
+                    return

sycommon/notice/uvicorn_monitor.py

@@ -0,0 +1,195 @@
+from datetime import datetime
+import sys
+import traceback
+import aiohttp
+import asyncio
+import json
+from typing import Optional
+from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
+from sycommon.config.Config import Config
+
+
+async def send_wechat_markdown_msg(
+    content: str,
+    webhook: str = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=b9992872-ea66-494f-8683-f43411b7713a"
+) -> Optional[dict]:
+    """
+    异步发送企业微信Markdown格式的WebHook消息
+
+    Args:
+        content: Markdown格式的消息内容（支持企业微信支持的markdown语法）
+        webhook: 完整的企业微信WebHook URL（默认值包含key）
+
+    Returns:
+        接口返回的JSON数据（dict），失败返回None
+    """
+    # 设置请求头
+    headers = {
+        "Content-Type": "application/json; charset=utf-8"
+    }
+
+    # 构造请求体（Markdown格式）
+    payload = {
+        "msgtype": "markdown",
+        "markdown": {
+            "content": content
+        }
+    }
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                url=webhook,
+                data=json.dumps(payload, ensure_ascii=False),
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(total=10)
+            ) as response:
+                status = response.status
+                response_text = await response.text()
+                response_data = json.loads(
+                    response_text) if response_text else {}
+
+                if status == 200 and response_data.get("errcode") == 0:
+                    print(f"消息发送成功: {response_data}")
+                    return response_data
+                else:
+                    print(f"消息发送失败 - 状态码: {status}, 响应: {response_data}")
+                    return None
+    except Exception as e:
+        print(f"错误：未知异常 - {str(e)}")
+        return None
+
+
+async def send_webhook(error_info: dict = None, webhook: str = None):
+    """
+    发送服务启动结果的企业微信通知
+    Args:
+        error_info: 错误信息字典（启动失败时必填），包含：error_type, error_msg, stack_trace, elapsed_time
+        webhook: 完整的企业微信WebHook URL（覆盖默认值）
+    """
+    # 获取服务名和环境（兼容配置读取失败）
+    try:
+        service_name = Config().config.get('Name', "未知服务")
+        env = Config().config.get('Nacos', {}).get('namespaceId', '未知环境')
+    except Exception as e:
+        service_name = "未知服务"
+        env = "未知环境"
+        print(f"读取配置失败: {str(e)}")
+
+    start_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+    # 启动失败的通知内容（包含详细错误信息）
+    error_type = error_info.get("error_type", "未知错误")
+    error_msg = error_info.get("error_msg", "无错误信息")
+    stack_trace = error_info.get("stack_trace", "无堆栈信息")[:500]  # 限制长度避免超限
+    elapsed_time = error_info.get("elapsed_time", 0)
+
+    markdown_content = f"""### {service_name}服务启动失败告警 ⚠️
+> 环境: <font color="warning">{env}</font>
+> 启动时间: <font color="comment">{start_time}</font>
+> 耗时: <font color="comment">{elapsed_time:.2f}秒</font>
+> 错误类型: <font color="danger">{error_type}</font>
+> 错误信息: <font color="danger">{error_msg}</font>
+> 错误堆栈: {stack_trace}"""
+
+    # 发送消息（优先使用传入的webhook，否则用默认值）
+    default_webhook = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=b9992872-ea66-494f-8683-f43411b7713a"
+    result = await send_wechat_markdown_msg(
+        content=markdown_content,
+        webhook=webhook if webhook else default_webhook
+    )
+    print(f"通知发送结果: {result}")
+
+
+def run(*args, webhook: str = None, **kwargs):
+    """
+    带企业微信告警的Uvicorn启动监控
+    调用方式1（默认配置）：uvicorn_monitor.run("app:app", **app.state.config)
+    调用方式2（自定义webhook）：uvicorn_monitor.run("app:app", webhook="完整URL", **app.state.config)
+
+    Args:
+        *args: 传递给uvicorn.run的位置参数（如"app:app"）
+        webhook: 完整的企业微信WebHook URL（可选，覆盖默认值）
+        **kwargs: 传递给uvicorn.run的关键字参数（如app.state.config）
+    """
+    # 判断环境
+    env = Config().config.get('Nacos', {}).get('namespaceId', '未知环境')
+    if env == "prod":
+        import uvicorn
+        uvicorn.run(*args, **kwargs)
+        return
+
+    # 记录启动开始时间
+    start_time = datetime.now()
+
+    if webhook:
+        # 脱敏展示webhook（隐藏key的后半部分）
+        parsed = urlparse(webhook)
+        query = parse_qs(parsed.query)
+        if 'key' in query and query['key'][0]:
+            key = query['key'][0]
+            masked_key = key[:8] + "****" if len(key) > 8 else key + "****"
+            query['key'] = [masked_key]
+            masked_query = urlencode(query, doseq=True)
+            masked_webhook = urlunparse(
+                (parsed.scheme, parsed.netloc, parsed.path, parsed.params, masked_query, parsed.fragment))
+            print(f"自定义企业微信WebHook: {masked_webhook}")
+
+    # 初始化错误信息
+    error_info = None
+
+    try:
+        import uvicorn
+        # 执行启动（如果启动成功，此方法会阻塞，不会执行后续except）
+        uvicorn.run(*args, **kwargs)
+
+    except KeyboardInterrupt:
+        # 处理用户手动中断（不算启动失败）
+        elapsed = (datetime.now() - start_time).total_seconds()
+        print(f"\n{'='*50}")
+        print(f"ℹ️  应用被用户手动中断")
+        print(f"启动耗时: {elapsed:.2f} 秒")
+        print(f"{'='*50}\n")
+        sys.exit(0)
+
+    except Exception as e:
+        # 捕获启动失败异常，收集错误信息
+        elapsed = (datetime.now() - start_time).total_seconds()
+        # 捕获堆栈信息
+        stack_trace = traceback.format_exc()
+
+        # 构造错误信息字典
+        error_info = {
+            "error_type": type(e).__name__,
+            "error_msg": str(e),
+            "stack_trace": stack_trace,
+            "elapsed_time": elapsed
+        }
+
+        # 打印错误信息
+        print(f"\n{'='*50}")
+        print(f"🚨 应用启动失败！")
+        print(f"失败时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        print(f"错误类型: {type(e).__name__}")
+        print(f"错误信息: {str(e)}")
+        print(f"\n📝 错误堆栈（关键）:")
+        print(f"-"*50)
+        traceback.print_exc(file=sys.stdout)
+        print(f"\n⏱️  启动耗时: {elapsed:.2f} 秒")
+        print(f"{'='*50}\n")
+
+    finally:
+        # 运行异步通知函数，传递自定义的webhook参数
+        try:
+            asyncio.run(send_webhook(
+                error_info=error_info,
+                webhook=webhook
+            ))
+        except Exception as e:
+            print(f"错误：异步通知失败 - {str(e)}")
+        # 启动失败时退出程序
+        sys.exit(1)
+
+
+# 兼容旧调用方式（可选）
+run_uvicorn_with_monitor = run

sycommon/synacos/nacos_service.py

@@ -1,4 +1,3 @@
-import logging
 import threading
 import json
 from typing import Callable, Dict, List, Optional
@@ -818,6 +817,11 @@ class NacosService(metaclass=SingletonMeta):
                 return []
 
             all_instances = instances.get('hosts', [])
+            # 筛选已上线实例
+            all_instances = [
+                instance for instance in all_instances
+                if instance.get('enabled', True)  # 默认True担心阿里变更sdk
+            ]
             SYLogger.info(
                 f"nacos:共发现 {len(all_instances)} 个 {service_name} 服务实例")
 

{sycommon_python_lib-0.1.56b2.dist-info → sycommon_python_lib-0.1.56b4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.56b2
+Version: 0.1.56b4
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.1.56b2.dist-info → sycommon_python_lib-0.1.56b4.dist-info}/RECORD

@@ -18,8 +18,9 @@ sycommon/health/metrics.py,sha256=fHqO73JuhoZkNPR-xIlxieXiTCvttq-kG-tvxag1s1s,26
 sycommon/health/ping.py,sha256=FTlnIKk5y1mPfS1ZGOeT5IM_2udF5aqVLubEtuBp18M,250
 sycommon/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/llm/embedding.py,sha256=Wcm2W7JU3FyZXvOhMSdyhiZJhJS1MwW8bMqdrOzD2TY,5768
-sycommon/llm/get_llm.py,sha256=QnmNwah2wzO2P1o37lNTrpzg7ZYvaDHjIzgOD9n3Ais,8325
+sycommon/llm/get_llm.py,sha256=wawJO_WSLSYPE8ImL421SYBPtAvWqwbRAcUN7d5i0W0,9434
 sycommon/llm/llm_logger.py,sha256=n4UeNy_-g4oHQOsw-VUzF4uo3JVRLtxaMp1FcI8FiEo,5437
+sycommon/llm/llm_tokens.py,sha256=-udDyFcmyzx6UAwIi6_d_wwI5kMd5w0-WcS2soVPQxg,4309
 sycommon/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/logging/async_sql_logger.py,sha256=_OY36XkUm__U3NhMgiecy-qd-nptZ_0gpE3J8lGAr58,2619
 sycommon/logging/kafka_log.py,sha256=sVw-dFZKEgCosjSUqgTj7YrpK-ggXhleZFwMUVhl-K0,21416
@@ -43,6 +44,8 @@ sycommon/models/mqlistener_config.py,sha256=vXp2uMmd0XQ5B9noSRXWHewTy-juQ2y7IsWt
 sycommon/models/mqmsg_model.py,sha256=cxn0M5b0utQK6crMYmL-1waeGYHvK3AlGaRy23clqTE,277
 sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6D7I,268
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
+sycommon/notice/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sycommon/notice/uvicorn_monitor.py,sha256=NRQVWs3jzZq9IY0M55s7LvOKtacsNpfCGGzH5071dGw,7181
 sycommon/rabbitmq/rabbitmq_client.py,sha256=GkuYILMZJnvgZs4ID46I-w_UGzzI28YUydKgkTIDhIs,20226
 sycommon/rabbitmq/rabbitmq_pool.py,sha256=QtUcK4HuepRqRmy5XkUQo8gDgj74fr77CX7T5rN0y4I,15640
 sycommon/rabbitmq/rabbitmq_service.py,sha256=wpEJynP0gzbnmMyB02sfR9nTWB4hfTTP00xQxDJu644,38119
@@ -54,15 +57,15 @@ sycommon/synacos/example.py,sha256=61XL03tU8WTNOo3FUduf93F2fAwah1S0lbH1ufhRhRk,5
 sycommon/synacos/example2.py,sha256=adUaru3Hy482KrOA17DfaC4nwvLj8etIDS_KrWLWmCU,4811
 sycommon/synacos/feign.py,sha256=frB3D5LeFDtT3pJLFOwFzEOrNAJKeQNGk-BzUg9T3WM,8295
 sycommon/synacos/feign_client.py,sha256=ExO7Pd5B3eFKDjXqBRc260K1jkI49IYguLwJJaD2R-o,16166
-sycommon/synacos/nacos_service.py,sha256=cvmjd9dJIzaOFm6IXGjy2BCq1gHTHRxLYdgt5kBguUw,35976
+sycommon/synacos/nacos_service.py,sha256=9cW2tSjm0vuYFRMPR_cl_EOZPe4axQDCUBcVxoGdPKM,36180
 sycommon/synacos/param.py,sha256=KcfSkxnXOa0TGmCjY8hdzU9pzUsA8-4PeyBKWI2-568,1765
 sycommon/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/tools/docs.py,sha256=OPj2ETheuWjXLyaXtaZPbwmJKfJaYXV5s4XMVAUNrms,1607
 sycommon/tools/merge_headers.py,sha256=HV_i52Q-9se3SP8qh7ZGYl8bP7Fxtal4CGVkyMwEdM8,4373
 sycommon/tools/snowflake.py,sha256=lVEe5mNCOgz5OqGQpf5_nXaGnRJlI2STX2s-ppTtanA,11947
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.56b2.dist-info/METADATA,sha256=HzNJOWrTsJrz8BkzZwJRiq6r9ugYormfdmCEFPM_e_g,7226
-sycommon_python_lib-0.1.56b2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.56b2.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.56b2.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.56b2.dist-info/RECORD,,
+sycommon_python_lib-0.1.56b4.dist-info/METADATA,sha256=c2XIy1w2EUZHGBPqJQvPTb6eYH2i5jTVNmnV-cPD-hs,7226
+sycommon_python_lib-0.1.56b4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.56b4.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.56b4.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.56b4.dist-info/RECORD,,