sycommon-python-lib 0.1.57b1__py3-none-any.whl → 0.1.57b7__py3-none-any.whl

sycommon/llm/embedding.py

@@ -1,8 +1,7 @@
 import asyncio
-import json
 import aiohttp
-from typing import Union, List, Optional
-
+import atexit
+from typing import Union, List, Optional, Dict
 from sycommon.config.Config import SingletonMeta
 from sycommon.config.EmbeddingConfig import EmbeddingConfig
 from sycommon.config.RerankerConfig import RerankerConfig
@@ -23,12 +22,78 @@ class Embedding(metaclass=SingletonMeta):
         self.reranker_base_url = RerankerConfig.from_config(
             self.default_reranker_model).baseUrl
 
+        # [修复] 缓存配置URL，避免高并发下重复读取配置文件
+        self._embedding_url_cache: Dict[str, str] = {
+            self.default_embedding_model: self.embeddings_base_url
+        }
+        self._reranker_url_cache: Dict[str, str] = {
+            self.default_reranker_model: self.reranker_base_url
+        }
+
         # 并发信号量
         self.semaphore = asyncio.Semaphore(self.max_concurrency)
-        # 全局默认超时：永不超时（None）
         self.default_timeout = aiohttp.ClientTimeout(total=None)
 
-    async def _get_embeddings_http_async(
+        # 核心优化：创建全局可复用的ClientSession（连接池复用）
+        self.session = None
+
+        # [修复] 注册退出钩子，确保程序结束时关闭连接池
+        atexit.register(self._sync_close_session)
+
+    async def init_session(self):
+        """初始化全局ClientSession（仅创建一次）"""
+        if self.session is None or self.session.closed:
+            # 配置连接池参数，适配高并发
+            connector = aiohttp.TCPConnector(
+                limit=self.max_concurrency,  # 连接池最大连接数
+                limit_per_host=self.max_concurrency,  # 每个域名的最大连接数
+                ttl_dns_cache=300,  # DNS缓存时间
+                enable_cleanup_closed=True  # 自动清理关闭的连接
+            )
+            self.session = aiohttp.ClientSession(
+                connector=connector,
+                timeout=self.default_timeout
+            )
+
+    async def close_session(self):
+        """关闭全局Session（程序退出时调用）"""
+        if self.session and not self.session.closed:
+            await self.session.close()
+
+    def _sync_close_session(self):
+        """同步关闭Session的封装，供atexit调用"""
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # [修复] 修正缩进，确保 create_task 的异常能被捕获
+                try:
+                    loop.create_task(self.close_session())
+                except Exception:
+                    pass
+            else:
+                try:
+                    loop.run_until_complete(self.close_session())
+                except Exception:
+                    pass
+        except Exception:
+            # 捕获获取 loop 时的异常
+            pass
+
+    def _get_embedding_url(self, model: str) -> str:
+        """获取Embedding URL（带缓存）"""
+        if model not in self._embedding_url_cache:
+            self._embedding_url_cache[model] = EmbeddingConfig.from_config(
+                model).baseUrl
+        return self._embedding_url_cache[model]
+
+    def _get_reranker_url(self, model: str) -> str:
+        """获取Reranker URL（带缓存）"""
+        if model not in self._reranker_url_cache:
+            self._reranker_url_cache[model] = RerankerConfig.from_config(
+                model).baseUrl
+        return self._reranker_url_cache[model]
+
+    async def _get_embeddings_http_core(
         self,
         input: Union[str, List[str]],
         encoding_format: str = None,
@@ -36,13 +101,14 @@ class Embedding(metaclass=SingletonMeta):
         timeout: aiohttp.ClientTimeout = None,
         **kwargs
     ):
+        """embedding请求核心逻辑"""
+        await self.init_session()  # 确保Session已初始化
         async with self.semaphore:
-            # 优先使用传入的超时，无则用全局默认
             request_timeout = timeout or self.default_timeout
-
-            # 优先使用传入的模型名，无则用默认值
             target_model = model or self.default_embedding_model
-            target_base_url = EmbeddingConfig.from_config(target_model).baseUrl
+
+            # [修复] 使用缓存获取URL
+            target_base_url = self._get_embedding_url(target_model)
             url = f"{target_base_url}/v1/embeddings"
 
             request_body = {
@@ -52,25 +118,48 @@ class Embedding(metaclass=SingletonMeta):
             }
             request_body.update(kwargs)
 
+            # 复用全局Session
             try:
-                async with aiohttp.ClientSession(timeout=request_timeout) as session:
-                    async with session.post(url, json=request_body) as response:
-                        if response.status != 200:
-                            error_detail = await response.text()
-                            SYLogger.error(
-                                f"Embedding request failed (model: {target_model}): {error_detail}")
-                            return None
-                        return await response.json()
-            except asyncio.TimeoutError:
+                async with self.session.post(
+                    url,
+                    json=request_body,
+                    timeout=request_timeout
+                ) as response:
+                    if response.status != 200:
+                        error_detail = await response.text()
+                        # [日志] 记录详细的HTTP错误响应
+                        SYLogger.error(
+                            f"Embedding request HTTP Error. Status: {response.status}, "
+                            f"Model: {target_model}, URL: {url}. Detail: {error_detail}"
+                        )
+                        return None
+                    return await response.json()
+            except (aiohttp.ClientConnectionResetError, asyncio.TimeoutError, aiohttp.ClientError) as e:
+                # [日志] 记录网络错误
                 SYLogger.error(
-                    f"Embedding request timeout (model: {target_model})")
+                    f"Embedding request Network Error. Model: {target_model}, URL: {url}. "
+                    f"Error: {e.__class__.__name__} - {str(e)}"
+                )
                 return None
             except Exception as e:
+                # 记录其他未预期的异常
                 SYLogger.error(
-                    f"Embedding request unexpected error (model: {target_model}): {str(e)}")
+                    f"Unexpected error in _get_embeddings_http_core: {str(e)}", exc_info=True)
                 return None
 
-    async def _get_reranker_http_async(
+    async def _get_embeddings_http_async(
+        self,
+        input: Union[str, List[str]],
+        encoding_format: str = None,
+        model: str = None,
+        timeout: aiohttp.ClientTimeout = None, ** kwargs
+    ):
+        """对外暴露的embedding请求方法"""
+        return await self._get_embeddings_http_core(
+            input, encoding_format, model, timeout, ** kwargs
+        )
+
+    async def _get_reranker_http_core(
         self,
         documents: List[str],
         query: str,
@@ -79,16 +168,16 @@ class Embedding(metaclass=SingletonMeta):
         max_chunks_per_doc: Optional[int] = None,
         return_documents: Optional[bool] = True,
         return_len: Optional[bool] = True,
-        timeout: aiohttp.ClientTimeout = None,
-        **kwargs
+        timeout: aiohttp.ClientTimeout = None, ** kwargs
     ):
+        """reranker请求核心逻辑"""
+        await self.init_session()  # 确保Session已初始化
         async with self.semaphore:
-            # 优先使用传入的超时，无则用全局默认
             request_timeout = timeout or self.default_timeout
-
-            # 优先使用传入的模型名，无则用默认值
             target_model = model or self.default_reranker_model
-            target_base_url = RerankerConfig.from_config(target_model).baseUrl
+
+            # [修复] 使用缓存获取URL
+            target_base_url = self._get_reranker_url(target_model)
             url = f"{target_base_url}/v1/rerank"
 
             request_body = {
@@ -99,28 +188,66 @@ class Embedding(metaclass=SingletonMeta):
                 "max_chunks_per_doc": max_chunks_per_doc,
                 "return_documents": return_documents,
                 "return_len": return_len,
-                "kwargs": json.dumps(kwargs),
             }
             request_body.update(kwargs)
 
+            # 复用全局Session
             try:
-                async with aiohttp.ClientSession(timeout=request_timeout) as session:
-                    async with session.post(url, json=request_body) as response:
-                        if response.status != 200:
-                            error_detail = await response.text()
-                            SYLogger.error(
-                                f"Rerank request failed (model: {target_model}): {error_detail}")
-                            return None
-                        return await response.json()
-            except asyncio.TimeoutError:
+                async with self.session.post(
+                    url,
+                    json=request_body,
+                    timeout=request_timeout
+                ) as response:
+                    if response.status != 200:
+                        error_detail = await response.text()
+                        # [日志] 记录详细的HTTP错误响应
+                        SYLogger.error(
+                            f"Reranker request HTTP Error. Status: {response.status}, "
+                            f"Model: {target_model}, URL: {url}. Detail: {error_detail}"
+                        )
+                        return None
+                    return await response.json()
+            except (aiohttp.ClientConnectionResetError, asyncio.TimeoutError, aiohttp.ClientError) as e:
+                # [日志] 记录网络错误
                 SYLogger.error(
-                    f"Rerank request timeout (model: {target_model})")
+                    f"Reranker request Network Error. Model: {target_model}, URL: {url}. "
+                    f"Error: {e.__class__.__name__} - {str(e)}"
+                )
                 return None
             except Exception as e:
+                # 记录其他未预期的异常
                 SYLogger.error(
-                    f"Rerank request unexpected error (model: {target_model}): {str(e)}")
+                    f"Unexpected error in _get_reranker_http_core: {str(e)}", exc_info=True)
                 return None
 
+    async def _get_reranker_http_async(
+        self,
+        documents: List[str],
+        query: str,
+        top_n: Optional[int] = None,
+        model: str = None,
+        max_chunks_per_doc: Optional[int] = None,
+        return_documents: Optional[bool] = True,
+        return_len: Optional[bool] = True,
+        timeout: aiohttp.ClientTimeout = None, ** kwargs
+    ):
+        """对外暴露的reranker请求方法"""
+        return await self._get_reranker_http_core(
+            documents, query, top_n, model, max_chunks_per_doc,
+            return_documents, return_len, timeout, **kwargs
+        )
+
+    def _get_dimension(self, model: str) -> int:
+        """获取模型维度，用于生成兜底零向量"""
+        try:
+            config = EmbeddingConfig.from_config(model)
+            if hasattr(config, 'dimension'):
+                return int(config.dimension)
+        except Exception:
+            pass
+        # 默认兜底 1024
+        return 1024
+
     async def get_embeddings(
         self,
         corpus: List[str],
@@ -145,28 +272,52 @@ class Embedding(metaclass=SingletonMeta):
                 SYLogger.warning(
                     f"Invalid timeout type: {type(timeout)}, must be int/float, use default timeout")
 
+        actual_model = model or self.default_embedding_model
+
         SYLogger.info(
-            f"Requesting embeddings for corpus: {corpus} (model: {model or self.default_embedding_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
-
-        # 给每个异步任务传入模型名称和超时配置
-        tasks = [self._get_embeddings_http_async(
-            text, model=model, timeout=request_timeout) for text in corpus]
-        results = await asyncio.gather(*tasks)
-
-        vectors = []
-        for result in results:
-            if result is None:
-                zero_vector = [0.0] * 1024
-                vectors.append(zero_vector)
-                SYLogger.warning(
-                    f"Embedding request failed, append zero vector (1024D)")
-                continue
-            for item in result["data"]:
-                vectors.append(item["embedding"])
+            f"Requesting embeddings for corpus: {len(corpus)} items (model: {actual_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
+
+        all_vectors = []
+
+        # [修复] 增加 Chunk 处理逻辑，防止 corpus 过大导致内存溢出或协程过多
+        # 每次最多处理 max_concurrency * 2 个请求，避免一次性创建几十万个协程
+        batch_size = self.max_concurrency * 2
+
+        for i in range(0, len(corpus), batch_size):
+            batch_texts = corpus[i: i + batch_size]
+
+            SYLogger.info(
+                f"Requesting embeddings for text: {len(batch_texts)} items (model: {actual_model}, timeout: {timeout or 'None'})")
+
+            # 给每个异步任务传入模型名称和超时配置
+            tasks = [self._get_embeddings_http_async(
+                text, model=actual_model, timeout=request_timeout) for text in batch_texts]
+            results = await asyncio.gather(*tasks)
+
+            for result in results:
+                if result is None:
+                    dim = self._get_dimension(actual_model)
+
+                    zero_vector = [0.0] * dim
+                    all_vectors.append(zero_vector)
+                    # [日志] 补充日志，明确是补零操作
+                    SYLogger.warning(
+                        f"Embedding request failed (returned None), appending zero vector ({dim}D) for model {actual_model}")
+                    continue
+
+                # 从返回结果中提取向量
+                try:
+                    for item in result["data"]:
+                        embedding = item["embedding"]
+                        all_vectors.append(embedding)
+                except (KeyError, TypeError) as e:
+                    SYLogger.error(f"Failed to parse embedding result: {e}")
+                    dim = self._get_dimension(actual_model)
+                    all_vectors.append([0.0] * dim)
 
         SYLogger.info(
-            f"Embeddings for corpus: {corpus} created (model: {model or self.default_embedding_model})")
-        return vectors
+            f"Embeddings for corpus created: {len(all_vectors)} vectors (model: {actual_model})")
+        return all_vectors
 
     async def get_reranker(
         self,
@@ -194,11 +345,14 @@ class Embedding(metaclass=SingletonMeta):
                 SYLogger.warning(
                     f"Invalid timeout type: {type(timeout)}, must be int/float, use default timeout")
 
+        actual_model = model or self.default_reranker_model
         SYLogger.info(
-            f"Requesting reranker for top_results: {top_results} (model: {model or self.default_reranker_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
-
+            f"Requesting reranker for top_results: {top_results} (model: {actual_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
+        # 打印请求参数
+        SYLogger.info(
+            f"Requesting reranker for top_results: {top_results} (model: {actual_model}) (query: {query}) (timeout: {timeout or 'None'})")
         data = await self._get_reranker_http_async(
-            top_results, query, model=model, timeout=request_timeout)
+            top_results, query, model=actual_model, timeout=request_timeout)
         SYLogger.info(
-            f"Reranker for top_results: {top_results} completed (model: {model or self.default_reranker_model})")
+            f"Reranker for top_results completed (model: {actual_model})")
         return data

sycommon/llm/get_llm.py

@@ -3,11 +3,15 @@ from langchain.chat_models import init_chat_model
 from sycommon.config.LLMConfig import LLMConfig
 from sycommon.llm.sy_langfuse import LangfuseInitializer
 from sycommon.llm.usage_token import LLMWithAutoTokenUsage
+from typing import Any
 
 
 def get_llm(
     model: str = None,
-    streaming: bool = False
+    *,
+    streaming: bool = False,
+    temperature: float = 0.1,
+    **kwargs: Any
 ) -> LLMWithAutoTokenUsage:
     if not model:
         model = "Qwen2.5-72B"
@@ -16,22 +20,25 @@ def get_llm(
     if not llmConfig:
         raise Exception(f"无效的模型配置：{model}")
 
-    # 初始化Langfuse
+    # 初始化 Langfuse
     langfuse_callbacks, langfuse = LangfuseInitializer.get()
-
     callbacks = [LLMLogger()] + langfuse_callbacks
 
-    llm = init_chat_model(
-        model_provider=llmConfig.provider,
-        model=llmConfig.model,
-        base_url=llmConfig.baseUrl,
-        api_key="-",
-        temperature=0.1,
-        streaming=streaming,
-        callbacks=callbacks
-    )
+    init_params = {
+        "model_provider": llmConfig.provider,
+        "model": llmConfig.model,
+        "base_url": llmConfig.baseUrl,
+        "api_key": "-",
+        "callbacks": callbacks,
+        "temperature": temperature,
+        "streaming": streaming,
+    }
+
+    init_params.update(kwargs)
+
+    llm = init_chat_model(**init_params)
 
     if llm is None:
         raise Exception(f"初始化原始LLM实例失败：{model}")
 
-    return LLMWithAutoTokenUsage(llm, langfuse)
+    return LLMWithAutoTokenUsage(llm, langfuse, llmConfig)

sycommon/llm/struct_token.py

@@ -1,21 +1,109 @@
+import tiktoken
 from typing import Dict, List, Optional, Any
 from langfuse import Langfuse, LangfuseSpan, propagate_attributes
 from sycommon.llm.llm_logger import LLMLogger
 from langchain_core.runnables import Runnable, RunnableConfig
-from langchain_core.messages import BaseMessage, HumanMessage
+from langchain_core.messages import BaseMessage, SystemMessage, HumanMessage
 from sycommon.llm.llm_tokens import TokensCallbackHandler
 from sycommon.logging.kafka_log import SYLogger
+from sycommon.config.LLMConfig import LLMConfig
 from sycommon.tools.env import get_env_var
 from sycommon.tools.merge_headers import get_header_value
 
 
 class StructuredRunnableWithToken(Runnable):
-    """带Token统计的Runnable类"""
+    """
+    统一功能 Runnable：Trace追踪 + Token统计 + 自动上下文压缩
+    """
 
-    def __init__(self, retry_chain: Runnable, langfuse: Optional[Langfuse]):
+    def __init__(
+        self,
+        retry_chain: Runnable,
+        langfuse: Optional[Langfuse] = None,
+        llmConfig: Optional[LLMConfig] = None,
+        model_name: str = "Qwen2.5-72B",
+        enable_compression: bool = True,
+        threshold_ratio: float = 0.8
+    ):
         super().__init__()
         self.retry_chain = retry_chain
         self.langfuse = langfuse
+        self.llmConfig = llmConfig
+        self.model_name = model_name
+        self.enable_compression = enable_compression
+        self.threshold_ratio = threshold_ratio
+
+        # 初始化 Tokenizer
+        try:
+            self.encoding = tiktoken.encoding_for_model(model_name)
+        except KeyError:
+            self.encoding = tiktoken.get_encoding("cl100k_base")
+
+    def _count_tokens(self, messages: List[BaseMessage]) -> int:
+        """快速估算 Token 数量"""
+        num_tokens = 0
+        for message in messages:
+            num_tokens += 4  # 每条消息的固定开销
+            # 兼容 content 是字符串或者 dict 的情况
+            content = message.content
+            if isinstance(content, str):
+                num_tokens += len(self.encoding.encode(content))
+            elif isinstance(content, list):  # 多模态或复杂结构
+                for item in content:
+                    if isinstance(item, dict) and "text" in item:
+                        num_tokens += len(self.encoding.encode(item["text"]))
+            elif isinstance(content, dict):
+                num_tokens += len(self.encoding.encode(str(content)))
+        return num_tokens
+
+    async def _acompress_context(self, messages: List[BaseMessage]) -> List[BaseMessage]:
+        """执行异步上下文压缩"""
+        # 策略：保留 System Prompt + 最近 N 条，中间的摘要
+        keep_last_n = 4
+
+        # 分离系统消息和对话消息
+        system_msgs = [m for m in messages if isinstance(m, SystemMessage)]
+        conversation = [
+            m for m in messages if not isinstance(m, SystemMessage)]
+
+        if len(conversation) <= keep_last_n:
+            return messages
+
+        to_summarize = conversation[:-keep_last_n]
+        keep_recent = conversation[-keep_last_n:]
+
+        # 构造摘要 Prompt
+        # 注意：这里直接使用 retry_chain 进行摘要，防止死循环
+        summary_prompt = [
+            SystemMessage(
+                content="请将上下文内容进行摘要，保留关键信息，将内容压缩到原来长度的50%左右，保留关键信息。"),
+            HumanMessage(content=f"历史记录:\n{to_summarize}\n\n摘要:")
+        ]
+
+        try:
+            SYLogger.info(
+                f"🚀 Triggering compression: {len(to_summarize)} messages -> summary")
+
+            # 调用子链生成摘要
+            # 【关键】必须清空 callbacks，否则 Langfuse 会递归追踪，导致死循环或噪音
+            summary_result = await self.retry_chain.ainvoke(
+                {"messages": summary_prompt},
+                config=RunnableConfig(callbacks=[])
+            )
+
+            summary_text = summary_result.content if hasattr(
+                summary_result, 'content') else str(summary_result)
+
+            # 重组消息：System + Summary + Recent
+            new_messages = system_msgs + \
+                [SystemMessage(
+                    content=f"[History Summary]: {summary_text}")] + keep_recent
+            return new_messages
+
+        except Exception as e:
+            SYLogger.error(
+                f"❌ Compression failed: {e}, using original context.")
+            return messages
 
     def _adapt_input(self, input: Any) -> List[BaseMessage]:
         """适配输入格式"""
@@ -25,6 +113,10 @@ class StructuredRunnableWithToken(Runnable):
             return [input]
         elif isinstance(input, str):
             return [HumanMessage(content=input)]
+        elif isinstance(input, dict) and "messages" in input:
+            # 如果已经是标准格式字典，直接提取
+            msgs = input["messages"]
+            return msgs if isinstance(msgs, list) else [msgs]
         elif isinstance(input, dict) and "input" in input:
             return [HumanMessage(content=str(input["input"]))]
         else:
@@ -40,7 +132,7 @@ class StructuredRunnableWithToken(Runnable):
         token_handler = TokensCallbackHandler()
 
         if config is None:
-            processed_config = {"callbacks": [], "metadata": {}}
+            processed_config = RunnableConfig(callbacks=[], metadata={})
         else:
             processed_config = config.copy()
             if "callbacks" not in processed_config:
@@ -59,6 +151,7 @@ class StructuredRunnableWithToken(Runnable):
             callbacks.append(LLMLogger())
         callbacks.append(token_handler)
 
+        # 去重
         callback_types = {}
         unique_callbacks = []
         for cb in callbacks:
@@ -131,6 +224,8 @@ class StructuredRunnableWithToken(Runnable):
                 user_id=user_id
             )
 
+            # 【同步模式下不建议触发压缩，因为压缩本身是异步调用 LLM】
+            # 如果同步也要压缩，需要用 asyncio.run(...)，这里暂时保持原逻辑直接透传
             adapted_input = self._adapt_input(input)
             input_data = {"messages": adapted_input}
 
@@ -169,12 +264,26 @@ class StructuredRunnableWithToken(Runnable):
                 user_id=user_id
             )
 
+            # 1. 适配输入
             adapted_input = self._adapt_input(input)
+
+            # 2. 检查并执行上下文压缩 (仅在异步模式且开启时)
+            if self.enable_compression:
+                max_tokens = self.llmConfig.maxTokens
+                current_tokens = self._count_tokens(adapted_input)
+
+                if current_tokens > max_tokens * self.threshold_ratio:
+                    SYLogger.warning(
+                        f"⚠️ Context limit reached: {current_tokens}/{max_tokens}")
+                    # 执行压缩，替换 adapted_input
+                    adapted_input = await self._acompress_context(adapted_input)
+
             input_data = {"messages": adapted_input}
 
             if span:
                 span.update_trace(input=input_data)
 
+            # 3. 调用子链
             structured_result = await self.retry_chain.ainvoke(
                 input_data,
                 config=processed_config

sycommon/llm/usage_token.py

@@ -6,6 +6,7 @@ from langchain_core.output_parsers import PydanticOutputParser
 from langchain_core.messages import BaseMessage, HumanMessage
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 from pydantic import BaseModel, ValidationError, Field
+from sycommon.config.LLMConfig import LLMConfig
 from sycommon.llm.struct_token import StructuredRunnableWithToken
 
 
@@ -13,9 +14,10 @@ class LLMWithAutoTokenUsage(BaseChatModel):
     """自动为结构化调用返回token_usage的LLM包装类"""
     llm: BaseChatModel = Field(default=None)
     langfuse: Optional[Langfuse] = Field(default=None, exclude=True)
+    llmConfig: Optional[LLMConfig] = Field(default=None, exclude=True)
 
-    def __init__(self, llm: BaseChatModel, langfuse: Langfuse, **kwargs):
-        super().__init__(llm=llm, langfuse=langfuse, **kwargs)
+    def __init__(self, llm: BaseChatModel, langfuse: Langfuse, llmConfig: LLMConfig, **kwargs):
+        super().__init__(llm=llm, langfuse=langfuse, llmConfig=llmConfig, **kwargs)
 
     def with_structured_output(
         self,
@@ -106,7 +108,7 @@ class LLMWithAutoTokenUsage(BaseChatModel):
                 "initial": 0.1, "max": 3.0, "exp_base": 2.0, "jitter": 1.0}
         )
 
-        return StructuredRunnableWithToken(retry_chain, self.langfuse)
+        return StructuredRunnableWithToken(retry_chain, self.langfuse, self.llmConfig)
 
     # ========== 实现BaseChatModel抽象方法 ==========
     def _generate(self, messages, stop=None, run_manager=None, ** kwargs):

sycommon/rabbitmq/rabbitmq_client.py

@@ -117,112 +117,112 @@ class RabbitMQClient:
             logger.info(f"队列重建成功: {self.queue_name}")
 
     async def connect(self) -> None:
+        """连接方法（修复恢复消费失效问题）"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
-        # 1. 并发控制：使用 _connect_lock 保证只有一个协程在执行连接流程
-        async with self._connect_lock:
-            # 如果已经在连了，等待其完成
+        # 1. 获取 Condition 锁
+        await self._connect_condition.acquire()
+
+        try:
+            # ===== 阶段 A: 快速检查与等待 =====
+            if await self.is_connected:
+                self._connect_condition.release()
+                return
+
             if self._connecting:
-                logger.debug("连接正在进行中，等待现有连接完成...")
                 try:
-                    # 等待条件变量，超时设为 60 秒防止死等
-                    await asyncio.wait_for(
-                        self._connect_condition.wait_for(
-                            lambda: not self._connecting),
-                        timeout=60.0
-                    )
+                    logger.debug("连接正在进行中，等待现有连接完成...")
+                    await asyncio.wait_for(self._connect_condition.wait(), timeout=60.0)
                 except asyncio.TimeoutError:
+                    self._connect_condition.release()
                     raise RuntimeError("等待连接超时")
 
-                # 等待结束后，再次检查状态
-                if not await self.is_connected:
+                if await self.is_connected:
+                    self._connect_condition.release()
+                    return
+                else:
+                    self._connect_condition.release()
                     raise RuntimeError("等待重连后，连接状态依然无效")
-                return
 
-            # 标记开始连接
+            # ===== 阶段 B: 标记开始连接 =====
             self._connecting = True
+            # 【关键】释放锁，允许其他协程进入等待逻辑
+            self._connect_condition.release()
 
-        # 释放 _connect_lock，允许其他协程读取状态，但在连接完成前阻止新的连接请求
-        # 注意：这里释放了 _connect_lock，但 self._connecting = True 阻止了新的连接流程
+        except Exception as e:
+            if self._connect_condition.locked():
+                self._connect_condition.release()
+            raise
 
+        # === 阶段 C: 执行耗时的连接逻辑 (此时已释放锁，不阻塞其他协程) ===
         try:
-            # --- 阶段1: 清理旧资源 ---
-            # 重新获取锁进行资源清理
-            async with self._connect_lock:
-                was_consuming = self._consumer_tag is not None
-
-                if self._channel_conn and self._conn_close_callback:
-                    try:
-                        self._channel_conn.close_callbacks.discard(
-                            self._conn_close_callback)
-                    except Exception:
-                        pass
-
-                self._channel = None
-                self._channel_conn = None
-                self._exchange = None
-                self._queue = None
-                self._conn_close_callback = None
-
-            # --- 阶段2: 获取新连接 (耗时IO) ---
+            # --- 步骤 1: 记录旧状态并清理资源 ---
+            # 必须在清理前记录状态
+            was_consuming = self._consumer_tag is not None
+
+            # 清理连接回调，防止旧的连接关闭触发新的重连
+            if self._channel_conn:
+                try:
+                    if self._channel_conn.close_callbacks:
+                        self._channel_conn.close_callbacks.clear()
+                except Exception:
+                    pass
+
+            # 统一重置资源状态
+            self._channel = None
+            self._channel_conn = None
+            self._exchange = None
+            self._queue = None
+            self._consumer_tag = None
+
+            # --- 步骤 2: 获取新连接 ---
             self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
-            # 设置回调
+            # 设置连接关闭回调
             def on_conn_closed(conn, exc):
-                logger.warning(f"检测到连接关闭: {exc}")
+                logger.warning(f"检测到底层连接关闭: {exc}")
                 if not self._closed and not self._connecting:
                     asyncio.create_task(self._safe_reconnect())
 
-            self._conn_close_callback = on_conn_closed
             if self._channel_conn:
-                self._channel_conn.close_callbacks.add(
-                    self._conn_close_callback)
+                self._channel_conn.close_callbacks.add(on_conn_closed)
 
-            # 重建资源
+            # --- 步骤 3: 重建基础资源 (交换机和队列) ---
             await self._rebuild_resources()
 
-            # --- 阶段3: 恢复消费 ---
-            if was_consuming and self._message_handler and self.queue_name and self.queue_name.endswith(f".{self.app_name}"):
-                logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复...")
+            # --- 步骤 4: 恢复消费 ---
+            if was_consuming and self._message_handler:
+                logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复消费...")
                 try:
-                    self._queue = await self._channel.declare_queue(
-                        name=self.queue_name,
-                        durable=self.durable,
-                        auto_delete=self.auto_delete,
-                        passive=False,
-                    )
-                    await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
-                    self._consumer_tag = await self._queue.consume(self._process_message_callback)
+                    # 直接调用 start_consuming 来恢复，它内部包含了完整的队列检查和绑定逻辑
+                    self._consumer_tag = await self.start_consuming()
                     logger.info(f"✅ 消费已自动恢复: {self._consumer_tag}")
                 except Exception as e:
                     logger.error(f"❌ 自动恢复消费失败: {e}")
                     self._consumer_tag = None
-            else:
-                self._consumer_tag = None
 
             logger.info("客户端连接初始化完成")
 
         except Exception as e:
             logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
-
-            # 异常时清理资源
-            async with self._connect_lock:
-                if self._channel_conn and self._conn_close_callback:
-                    self._channel_conn.close_callbacks.discard(
-                        self._conn_close_callback)
-                self._channel = None
-                self._channel_conn = None
-                self._consumer_tag = None
-
+            # 异常时彻底清理
+            if self._channel_conn and self._channel_conn.close_callbacks:
+                self._channel_conn.close_callbacks.clear()
+            self._channel = None
+            self._channel_conn = None
+            self._queue = None
+            self._consumer_tag = None
             raise
 
         finally:
-            # 【关键修复】必须在持有 Condition 内部锁的情况下调用 notify_all
-            # 这里使用 async with self._connect_condition: 自动完成 acquire() ... notify_all() ... release()
-            async with self._connect_condition:
+            # === 阶段 D: 恢复状态并通知 ===
+            await self._connect_condition.acquire()
+            try:
                 self._connecting = False
                 self._connect_condition.notify_all()
+            finally:
+                self._connect_condition.release()
 
     async def _safe_reconnect(self):
         """安全重连任务（仅用于被动监听连接关闭）"""
@@ -258,24 +258,28 @@ class RabbitMQClient:
     async def _process_message_callback(self, message: AbstractIncomingMessage):
         try:
             msg_obj: MQMsgModel
+
+            # 1. 解析消息
             if self.auto_parse_json:
                 try:
                     body_dict = json.loads(message.body.decode("utf-8"))
                     msg_obj = MQMsgModel(**body_dict)
                 except json.JSONDecodeError as e:
                     logger.error(f"JSON解析失败: {e}")
-                    await message.nack(requeue=False)
+                    await message.reject(requeue=False)
                     return
             else:
                 msg_obj = MQMsgModel(
                     body=message.body.decode("utf-8"),
                     routing_key=message.routing_key,
                     delivery_tag=message.delivery_tag,
-                    traceId=message.headers.get("trace-id"),
+                    traceId=message.headers.get(
+                        "trace-id") if message.headers else SYLogger.get_trace_id(),
                 )
 
             SYLogger.set_trace_id(msg_obj.traceId)
 
+            # 3. 执行业务逻辑
             if self._message_handler:
                 await self._message_handler(msg_obj, message)
 
@@ -283,28 +287,7 @@ class RabbitMQClient:
 
         except Exception as e:
             logger.error(f"消息处理异常: {e}", exc_info=True)
-            headers = dict(message.headers) if message.headers else {}
-            current_retry = int(headers.get("x-retry-count", 0))
-
-            if current_retry >= 3:
-                logger.warning(f"重试次数超限，丢弃消息: {message.delivery_tag}")
-                await message.reject(requeue=False)
-            else:
-                headers["x-retry-count"] = current_retry + 1
-                try:
-                    new_msg = Message(
-                        body=message.body,
-                        headers=headers,
-                        content_type=message.content_type,
-                        delivery_mode=message.delivery_mode
-                    )
-                    # 这里的 publish 如果失败，会触发重连机制
-                    # 但注意，当前是在回调线程中，建议做好异常捕获
-                    await self._exchange.publish(new_msg, routing_key=message.routing_key)
-                    await message.ack()
-                except Exception as pub_err:
-                    logger.error(f"重试发布失败: {pub_err}")
-                    await message.reject(requeue=False)
+            await message.ack()
 
     async def start_consuming(self) -> Optional[ConsumerTag]:
         if self._closed:

sycommon/synacos/nacos_client_base.py

@@ -2,6 +2,7 @@ import threading
 import time
 from typing import Optional
 import nacos
+from sycommon.config.Config import Config
 from sycommon.logging.kafka_log import SYLogger
 
 
@@ -94,8 +95,9 @@ class NacosClientBase:
 
         try:
             namespace_id = self.nacos_config['namespaceId']
+            service_name = Config().config.get('Name', '')
             self.nacos_client.list_naming_instance(
-                service_name="",  # 空服务名仅用于验证连接
+                service_name=service_name,
                 namespace_id=namespace_id,
                 group_name="DEFAULT_GROUP",
                 healthy_only=True

{sycommon_python_lib-0.1.57b1.dist-info → sycommon_python_lib-0.1.57b7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.57b1
+Version: 0.1.57b7
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -25,6 +25,7 @@ Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: sentry-sdk[fastapi]>=2.49.0
 Requires-Dist: sqlalchemy[asyncio]>=2.0.45
 Requires-Dist: starlette>=0.50.0
+Requires-Dist: tiktoken>=0.12.0
 Requires-Dist: uvicorn>=0.40.0
 
 # sycommon-python-lib

{sycommon_python_lib-0.1.57b1.dist-info → sycommon_python_lib-0.1.57b7.dist-info}/RECORD

@@ -19,13 +19,13 @@ sycommon/health/health_check.py,sha256=EhfbhspRpQiKJaxdtE-PzpKQO_ucaFKtQxIm16F5M
 sycommon/health/metrics.py,sha256=fHqO73JuhoZkNPR-xIlxieXiTCvttq-kG-tvxag1s1s,268
 sycommon/health/ping.py,sha256=FTlnIKk5y1mPfS1ZGOeT5IM_2udF5aqVLubEtuBp18M,250
 sycommon/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/llm/embedding.py,sha256=HknwDqXmRQcAZ8-6d8wZ6n7Bv7HtxTajDt1vvzHGeFQ,8411
-sycommon/llm/get_llm.py,sha256=C48gt9GCwEpR26M-cUjM74_t-el18ZvlwpGhcQfR3gs,1054
+sycommon/llm/embedding.py,sha256=Qi9mHQiOUVEcZd4elAaqsAyofdeLtPgU_LF35KlIFU4,14735
+sycommon/llm/get_llm.py,sha256=eZtVx9yNl-VO3O6AhZzCECRTDXRsUTcR88os8hGyJIY,1241
 sycommon/llm/llm_logger.py,sha256=n4UeNy_-g4oHQOsw-VUzF4uo3JVRLtxaMp1FcI8FiEo,5437
 sycommon/llm/llm_tokens.py,sha256=-udDyFcmyzx6UAwIi6_d_wwI5kMd5w0-WcS2soVPQxg,4309
-sycommon/llm/struct_token.py,sha256=jlpZnTOLDmRDdrCuxZe-1pQopd6OmCM9B_gWZ48CnEQ,7655
+sycommon/llm/struct_token.py,sha256=s8HQf6ZdqKRAnanAo8yPwAM-Ez4P9gGlhI_zBEffphM,12301
 sycommon/llm/sy_langfuse.py,sha256=NZv6ydfn3-cxqQvuB5WdnM9GYliO9qB_RWh_XqIS3VU,3692
-sycommon/llm/usage_token.py,sha256=n0hytuaHI4tJi6wuOS3bd-yWzQjZ-lx5w9egHs8uYgg,5140
+sycommon/llm/usage_token.py,sha256=CDoA_UeZKpNvxH0vNZ8f58tfLV3wC4kd5e1Oferyy9s,5318
 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=gfOqdZe0HJ3PkIFfnNWG4DZVadxsCKJ6AmelR7_Z1Xs,9960
@@ -51,7 +51,7 @@ sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
 sycommon/notice/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/notice/uvicorn_monitor.py,sha256=VryQYcAtjijJuGDBimbVurgwxlsLaLtkNnABPDY5Tao,7332
-sycommon/rabbitmq/rabbitmq_client.py,sha256=hAbLOioU_clucJ9xq88Oo-waZOuU0ii4yBVGIjz1nBE,17992
+sycommon/rabbitmq/rabbitmq_client.py,sha256=pAhyLfuHl72szLBr-nRqv-QKseT9x_QCR6Mu-IonP1U,16689
 sycommon/rabbitmq/rabbitmq_pool.py,sha256=BiFQgZPzSAFR-n5XhyIafoeWQXETF_31nFRDhMbe6aU,15577
 sycommon/rabbitmq/rabbitmq_service.py,sha256=XSHo9HuIJ_lq-vizRh4xJVdZr_2zLqeLhot09qb0euA,2025
 sycommon/rabbitmq/rabbitmq_service_client_manager.py,sha256=IP9TMFeG5LSrwFPEmOy1ce4baPxBUZnWJZR3nN_-XR4,8009
@@ -69,7 +69,7 @@ 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_client_base.py,sha256=l5jpall6nEt0Hy07Wk-PVU0VN0BmD_Mmtldmtyvvksg,4526
+sycommon/synacos/nacos_client_base.py,sha256=KZgQAg9Imfr_TfM-4LXdtrnTdJ-beu6bcNJa0c2HauE,4600
 sycommon/synacos/nacos_config_manager.py,sha256=Cff-4gpp0aD7sQVi-nEvDO4BWqK9abEDDDJ9qXKFQgs,4399
 sycommon/synacos/nacos_heartbeat_manager.py,sha256=G80_pOn37WdO_HpYUiAfpwMqAxW0ff0Bnw0NEuge9v0,5568
 sycommon/synacos/nacos_service.py,sha256=BezQ1eDIYwBPE567Po_Qh1Ki_z9WmhZy1J1NiTPbdHY,6118
@@ -82,8 +82,8 @@ sycommon/tools/env.py,sha256=Ah-tBwG2C0_hwLGFebVQgKdWWXCjTzBuF23gCkLHYy4,2437
 sycommon/tools/merge_headers.py,sha256=u9u8_1ZIuGIminWsw45YJ5qnsx9MB-Fot0VPge7itPw,4941
 sycommon/tools/snowflake.py,sha256=xQlYXwYnI85kSJ1rZ89gMVBhzemP03xrMPVX9vVa3MY,9228
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.57b1.dist-info/METADATA,sha256=SSwWUy9hRgJhiqL1ulY91dBhEegshkvsXXLTKxNnXTc,7301
-sycommon_python_lib-0.1.57b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.57b1.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.57b1.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.57b1.dist-info/RECORD,,
+sycommon_python_lib-0.1.57b7.dist-info/METADATA,sha256=e43DQ_eU9kbXuhiZpJF4ys1betxau0wepQuOm6v4l1c,7333
+sycommon_python_lib-0.1.57b7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.57b7.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.57b7.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.57b7.dist-info/RECORD,,