tamar-model-client 0.1.21__tar.gz → 0.1.22__tar.gz

{tamar_model_client-0.1.21 → tamar_model_client-0.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.21
+Version: 0.1.22
 Summary: A Python SDK for interacting with the Model Manager gRPC service
 Home-page: http://gitlab.tamaredge.top/project-tap/AgentOS/model-manager-client
 Author: Oscar Ou

{tamar_model_client-0.1.21 → tamar_model_client-0.1.22}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="tamar-model-client",
-    version="0.1.21",
+    version="0.1.22",
     description="A Python SDK for interacting with the Model Manager gRPC service",
     author="Oscar Ou",
     author_email="oscar.ou@tamaredge.ai",

{tamar_model_client-0.1.21 → tamar_model_client-0.1.22}/tamar_model_client/async_client.py

@@ -244,7 +244,16 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         Raises:
             TamarModelException: 当所有重试都失败时
         """
-        return await self.retry_handler.execute_with_retry(func, *args, **kwargs)
+        # 从kwargs中提取request_id（如果有的话），然后移除它
+        request_id = kwargs.pop('request_id', None) or get_request_id()
+        
+        # 构建包含request_id的上下文
+        context = {
+            'method': func.__name__ if hasattr(func, '__name__') else 'unknown',
+            'client_version': 'async',
+            'request_id': request_id,
+        }
+        return await self.retry_handler.execute_with_retry(func, *args, context=context, **kwargs)
 
     async def _retry_request_stream(self, func, *args, **kwargs):
         """
@@ -260,10 +269,18 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         Returns:
             AsyncIterator: 流式响应迭代器
         """
+        # 记录方法开始时间
+        import time
+        method_start_time = time.time()
+        
+        # 从kwargs中提取request_id（如果有的话），然后移除它
+        request_id = kwargs.pop('request_id', None) or get_request_id()
+        
         last_exception = None
         context = {
             'method': 'stream',
             'client_version': 'async',
+            'request_id': request_id,
         }
         
         for attempt in range(self.max_retries + 1):
@@ -283,10 +300,16 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                 error_context = ErrorContext(e, context)
                 error_code = e.code()
                 policy = get_retry_policy(error_code)
-                retryable = policy.get('retryable', False)
                 
-                should_retry = False
-                if attempt < self.max_retries:
+                # 先检查错误级别的 max_attempts 配置
+                # max_attempts 表示最大重试次数（不包括初始请求）
+                error_max_attempts = policy.get('max_attempts', self.max_retries)
+                if attempt >= error_max_attempts:
+                    should_retry = False
+                elif attempt >= self.max_retries:
+                    should_retry = False
+                else:
+                    retryable = policy.get('retryable', False)
                     if retryable == True:
                         should_retry = True
                     elif retryable == 'conditional':
@@ -295,8 +318,11 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                             should_retry = error_context.is_network_cancelled()
                         else:
                             should_retry = self._check_error_details_for_retry(e)
+                    else:
+                        should_retry = False
                 
                 if should_retry:
+                    current_duration = time.time() - method_start_time
                     log_data = {
                         "log_type": "info",
                         "request_id": context.get('request_id'),
@@ -305,7 +331,8 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                             "retry_count": attempt,
                             "max_retries": self.max_retries,
                             "method": "stream"
-                        }
+                        },
+                        "duration": current_duration
                     }
                     logger.warning(
                         f"Stream attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (will retry)",
@@ -317,6 +344,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                     await asyncio.sleep(delay)
                 else:
                     # 不重试或已达到最大重试次数
+                    current_duration = time.time() - method_start_time
                     log_data = {
                         "log_type": "info",
                         "request_id": context.get('request_id'),
@@ -326,12 +354,14 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                             "max_retries": self.max_retries,
                             "method": "stream",
                             "will_retry": False
-                        }
+                        },
+                        "duration": current_duration
                     }
                     logger.error(
                         f"Stream failed: {e.code()} (no retry)",
                         extra=log_data
                     )
+                    context['duration'] = current_duration
                     last_exception = self.error_handler.handle_error(e, context)
                     break
                     
@@ -454,7 +484,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         chunk_count = 0
 
         # 使用重试逻辑获取流生成器
-        stream_generator = self._retry_request_stream(self._stream, request, metadata, invoke_timeout)
+        stream_generator = self._retry_request_stream(self._stream, request, metadata, invoke_timeout, request_id=get_request_id())
 
         try:
             async for response in stream_generator:
@@ -609,7 +639,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                 # 对于流式响应，直接返回带日志记录的包装器
                 return self._stream_with_logging(request, metadata, invoke_timeout, start_time, model_request)
             else:
-                result = await self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
+                result = await self._retry_request(self._invoke_request, request, metadata, invoke_timeout, request_id=request_id)
 
                 # 记录非流式响应的成功日志
                 duration = time.time() - start_time
@@ -739,7 +769,8 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                 self.stub.BatchInvoke,
                 batch_request,
                 metadata=metadata,
-                timeout=invoke_timeout
+                timeout=invoke_timeout,
+                request_id=request_id
             )
 
             # 构建响应对象

{tamar_model_client-0.1.21 → tamar_model_client-0.1.22}/tamar_model_client/error_handler.py

@@ -62,6 +62,10 @@ class GrpcErrorHandler:
             }
         }
         
+        # 如果上下文中有 duration，添加到日志中
+        if 'duration' in context:
+            log_data['duration'] = context['duration']
+        
         self.logger.error(
             f"gRPC Error occurred: {error_context.error_code.name if error_context.error_code else 'UNKNOWN'}",
             extra=log_data
@@ -211,6 +215,10 @@ class EnhancedRetryHandler:
         Raises:
             TamarModelException: 包装后的异常
         """
+        # 记录开始时间
+        import time
+        method_start_time = time.time()
+        
         context = context or {}
         last_exception = None
         
@@ -226,8 +234,13 @@ class EnhancedRetryHandler:
                 # 判断是否可以重试
                 if not self._should_retry(e, attempt):
                     # 不可重试或已达到最大重试次数
+                    current_duration = time.time() - method_start_time
+                    context['duration'] = current_duration
                     last_exception = self.error_handler.handle_error(e, context)
                     break
+                
+                # 计算当前耗时
+                current_duration = time.time() - method_start_time
                     
                 # 记录重试日志
                 log_data = {
@@ -241,7 +254,8 @@ class EnhancedRetryHandler:
                         "category": error_context._get_error_category(),
                         "is_retryable": True,  # 既然在重试，说明是可重试的
                         "method": error_context.method
-                    }
+                    },
+                    "duration": current_duration
                 }
                 logger.warning(
                     f"Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}",
@@ -253,6 +267,7 @@ class EnhancedRetryHandler:
                     delay = self._calculate_backoff(attempt)
                     await asyncio.sleep(delay)
                 
+                context['duration'] = current_duration
                 last_exception = self.error_handler.handle_error(e, context)
             
             except Exception as e:
@@ -271,12 +286,19 @@ class EnhancedRetryHandler:
     
     def _should_retry(self, error: grpc.RpcError, attempt: int) -> bool:
         """判断是否应该重试"""
-        if attempt >= self.max_retries:
-            return False
-            
         error_code = error.code()
         policy = RETRY_POLICY.get(error_code, {})
         
+        # 先检查错误级别的 max_attempts 配置
+        # max_attempts 表示最大重试次数（不包括初始请求）
+        error_max_attempts = policy.get('max_attempts', self.max_retries)
+        if attempt >= error_max_attempts:
+            return False
+            
+        # 再检查全局的 max_retries
+        if attempt >= self.max_retries:
+            return False
+        
         # 检查基本重试策略
         retryable = policy.get('retryable', False)
         if retryable == False:

{tamar_model_client-0.1.21 → tamar_model_client-0.1.22}/tamar_model_client/exceptions.py

@@ -77,7 +77,7 @@ RETRY_POLICY = {
     grpc.StatusCode.CANCELLED: {
         'retryable': True,
         'backoff': 'linear',        # 线性退避，网络问题通常不需要指数退避
-        'max_attempts': 2,          # 限制重试次数，避免过度重试
+        'max_attempts': 2,          # 最大重试次数（不包括初始请求），总共会尝试3次
         'check_details': False      # 不检查详细信息，统一重试
     },
     grpc.StatusCode.ABORTED: {
@@ -184,6 +184,37 @@ class ErrorContext:
             'DATA': '数据损坏或丢失，请检查输入数据',
         }
         return suggestions.get(self._get_error_category(), '未知错误，请联系技术支持')
+    
+    def is_network_cancelled(self) -> bool:
+        """
+        判断 CANCELLED 错误是否由网络中断导致
+        
+        Returns:
+            bool: 如果是网络中断导致的 CANCELLED 返回 True
+        """
+        if self.error_code != grpc.StatusCode.CANCELLED:
+            return False
+            
+        # 检查错误消息中是否包含网络相关的关键词
+        error_msg = (self.error_message or '').lower()
+        debug_msg = (self.error_debug_string or '').lower()
+        
+        network_patterns = [
+            'connection reset',
+            'connection refused', 
+            'connection closed',
+            'network unreachable',
+            'broken pipe',
+            'socket closed',
+            'eof',
+            'transport'
+        ]
+        
+        for pattern in network_patterns:
+            if pattern in error_msg or pattern in debug_msg:
+                return True
+                
+        return False
 
 
 # ===== 异常类层级 =====

{tamar_model_client-0.1.21 → tamar_model_client-0.1.22}/tamar_model_client/sync_client.py

@@ -201,10 +201,17 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         """
         使用增强的错误处理器进行重试（同步版本）
         """
+        # 记录方法开始时间
+        method_start_time = time.time()
+        
+        # 从kwargs中提取request_id（如果有的话），然后移除它
+        request_id = kwargs.pop('request_id', None) or get_request_id()
+        
         # 构建请求上下文
         context = {
             'method': func.__name__ if hasattr(func, '__name__') else 'unknown',
             'client_version': 'sync',
+            'request_id': request_id,
         }
 
         last_exception = None
@@ -222,9 +229,14 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                 should_retry = self._should_retry(e, attempt)
                 if not should_retry or attempt >= self.max_retries:
                     # 不可重试或已达到最大重试次数
+                    current_duration = time.time() - method_start_time
+                    context['duration'] = current_duration
                     last_exception = self.error_handler.handle_error(e, context)
                     break
 
+                # 计算当前的耗时
+                current_duration = time.time() - method_start_time
+                
                 # 记录重试日志
                 log_data = {
                     "log_type": "info",
@@ -234,7 +246,8 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                         "retry_count": attempt,
                         "max_retries": self.max_retries,
                         "method": context.get('method', 'unknown')
-                    }
+                    },
+                    "duration": current_duration
                 }
                 logger.warning(
                     f"Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}",
@@ -246,6 +259,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                     delay = self._calculate_backoff(attempt, e.code())
                     time.sleep(delay)
 
+                context['duration'] = current_duration
                 last_exception = self.error_handler.handle_error(e, context)
 
             except Exception as e:
@@ -260,6 +274,73 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         else:
             raise TamarModelException("Unknown error occurred")
 
+    def _should_retry(self, error: grpc.RpcError, attempt: int) -> bool:
+        """
+        判断是否应该重试
+        
+        Args:
+            error: gRPC错误
+            attempt: 当前重试次数
+            
+        Returns:
+            bool: 是否应该重试
+        """
+        error_code = error.code()
+        from .exceptions import get_retry_policy, ErrorContext
+        policy = get_retry_policy(error_code)
+        
+        # 先检查错误级别的 max_attempts 配置
+        # max_attempts 表示最大重试次数（不包括初始请求）
+        error_max_attempts = policy.get('max_attempts', self.max_retries)
+        if attempt >= error_max_attempts:
+            return False
+            
+        # 再检查全局的 max_retries
+        if attempt >= self.max_retries:
+            return False
+        
+        retryable = policy.get('retryable', False)
+        
+        if retryable == False:
+            return False
+        elif retryable == True:
+            return True
+        elif retryable == 'conditional':
+            # 条件重试，特殊处理
+            if error_code == grpc.StatusCode.CANCELLED:
+                # 检查是否是网络中断导致的取消
+                context = {'method': 'unknown', 'client_version': 'sync'}
+                error_context = ErrorContext(error, context)
+                return error_context.is_network_cancelled()
+            else:
+                return self._check_error_details_for_retry(error)
+        
+        return False
+    
+    def _check_error_details_for_retry(self, error: grpc.RpcError) -> bool:
+        """
+        检查错误详情决定是否重试
+        
+        Args:
+            error: gRPC错误
+            
+        Returns:
+            bool: 是否应该重试
+        """
+        error_message = error.details().lower() if error.details() else ""
+        
+        # 可重试的错误模式
+        retryable_patterns = [
+            'temporary', 'timeout', 'unavailable', 
+            'connection', 'network', 'try again'
+        ]
+        
+        for pattern in retryable_patterns:
+            if pattern in error_message:
+                return True
+                
+        return False
+
     def _calculate_backoff(self, attempt: int, error_code: grpc.StatusCode = None) -> float:
         """
         计算退避时间，支持不同的退避策略
@@ -316,10 +397,17 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         Yields:
             流式响应的每个元素
         """
+        # 记录方法开始时间
+        method_start_time = time.time()
+        
+        # 从kwargs中提取request_id（如果有的话），然后移除它
+        request_id = kwargs.pop('request_id', None) or get_request_id()
+        
         last_exception = None
         context = {
             'method': 'stream',
             'client_version': 'sync',
+            'request_id': request_id,
         }
         
         for attempt in range(self.max_retries + 1):
@@ -334,6 +422,9 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                 # 使用智能重试判断
                 context['retry_count'] = attempt
                 
+                # 计算当前的耗时
+                current_duration = time.time() - method_start_time
+                
                 # 判断是否应该重试
                 should_retry = self._should_retry(e, attempt)
                 if not should_retry or attempt >= self.max_retries:
@@ -347,12 +438,14 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                             "max_retries": self.max_retries,
                             "method": "stream",
                             "will_retry": False
-                        }
+                        },
+                        "duration": current_duration
                     }
                     logger.error(
                         f"Stream failed: {e.code()} (no retry)",
                         extra=log_data
                     )
+                    context['duration'] = current_duration
                     last_exception = self.error_handler.handle_error(e, context)
                     break
                 
@@ -365,7 +458,8 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                         "retry_count": attempt,
                         "max_retries": self.max_retries,
                         "method": "stream"
-                    }
+                    },
+                    "duration": current_duration
                 }
                 logger.warning(
                     f"Stream attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (will retry)",
@@ -609,10 +703,11 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                 # 对于流式响应，使用重试包装器
                 return self._retry_request_stream(
                     self._stream_with_logging,
-                    request, metadata, invoke_timeout, start_time, model_request
+                    request, metadata, invoke_timeout, start_time, model_request,
+                    request_id=request_id
                 )
             else:
-                result = self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
+                result = self._retry_request(self._invoke_request, request, metadata, invoke_timeout, request_id=request_id)
 
                 # 记录非流式响应的成功日志
                 duration = time.time() - start_time
@@ -742,7 +837,8 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                 self.stub.BatchInvoke,
                 batch_request,
                 metadata=metadata,
-                timeout=invoke_timeout
+                timeout=invoke_timeout,
+                request_id=request_id
             )
 
             # 构建响应对象

{tamar_model_client-0.1.21 → tamar_model_client-0.1.22}/tamar_model_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.21
+Version: 0.1.22
 Summary: A Python SDK for interacting with the Model Manager gRPC service
 Home-page: http://gitlab.tamaredge.top/project-tap/AgentOS/model-manager-client
 Author: Oscar Ou

{tamar_model_client-0.1.21 → tamar_model_client-0.1.22}/tamar_model_client.egg-info/SOURCES.txt

@@ -35,4 +35,5 @@ tamar_model_client/schemas/outputs.py
 tests/__init__.py
 tests/stream_hanging_analysis.py
 tests/test_google_azure_final.py
+tests/test_logging_issue.py
 tests/test_simple.py

{tamar_model_client-0.1.21 → tamar_model_client-0.1.22}/tests/test_google_azure_final.py

@@ -8,6 +8,10 @@ import asyncio
 import logging
 import os
 import sys
+import time
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from typing import List, Dict, Tuple
 
 # 配置测试脚本专用的日志
 # 使用特定的logger名称，避免影响客户端日志
@@ -22,8 +26,8 @@ test_logger.addHandler(test_handler)
 
 logger = test_logger
 
-os.environ['MODEL_MANAGER_SERVER_GRPC_USE_TLS'] = "false"
-os.environ['MODEL_MANAGER_SERVER_ADDRESS'] = "localhost:50051"
+os.environ['MODEL_MANAGER_SERVER_GRPC_USE_TLS'] = "true"
+os.environ['MODEL_MANAGER_SERVER_ADDRESS'] = "model-manager-server-grpc-131786869360.asia-northeast1.run.app"
 os.environ['MODEL_MANAGER_SERVER_JWT_SECRET_KEY'] = "model-manager-server-jwt-key"
 
 # 导入客户端模块
@@ -31,6 +35,12 @@ try:
     from tamar_model_client import TamarModelClient, AsyncTamarModelClient
     from tamar_model_client.schemas import ModelRequest, UserContext
     from tamar_model_client.enums import ProviderType, InvokeType, Channel
+    
+    # 为了调试，临时启用 SDK 的日志输出
+    # 注意：这会输出 JSON 格式的日志
+    import os
+    os.environ['TAMAR_MODEL_CLIENT_LOG_LEVEL'] = 'INFO'
+    
 except ImportError as e:
     logger.error(f"导入模块失败: {e}")
     sys.exit(1)
@@ -39,10 +49,10 @@ except ImportError as e:
 def test_google_ai_studio():
     """测试 Google AI Studio"""
     print("\n🔍 测试 Google AI Studio...")
-    
+
     try:
         client = TamarModelClient()
-        
+
         request = ModelRequest(
             provider=ProviderType.GOOGLE,
             channel=Channel.AI_STUDIO,
@@ -61,12 +71,12 @@ def test_google_ai_studio():
                 "maxOutputTokens": 100
             }
         )
-        
+
         response = client.invoke(request)
         print(f"✅ Google AI Studio 成功")
         print(f"   响应类型: {type(response)}")
         print(f"   响应内容: {str(response)[:200]}...")
-        
+
     except Exception as e:
         print(f"❌ Google AI Studio 失败: {str(e)}")
 
@@ -74,10 +84,10 @@ def test_google_ai_studio():
 def test_google_vertex_ai():
     """测试 Google Vertex AI"""
     print("\n🔍 测试 Google Vertex AI...")
-    
+
     try:
         client = TamarModelClient()
-        
+
         request = ModelRequest(
             provider=ProviderType.GOOGLE,
             channel=Channel.VERTEXAI,
@@ -95,12 +105,12 @@ def test_google_vertex_ai():
                 "temperature": 0.5
             }
         )
-        
+
         response = client.invoke(request)
         print(f"✅ Google Vertex AI 成功")
         print(f"   响应类型: {type(response)}")
         print(f"   响应内容: {str(response)[:200]}...")
-        
+
     except Exception as e:
         print(f"❌ Google Vertex AI 失败: {str(e)}")
 
@@ -108,10 +118,10 @@ def test_google_vertex_ai():
 def test_azure_openai():
     """测试 Azure OpenAI"""
     print("\n☁️  测试 Azure OpenAI...")
-    
+
     try:
         client = TamarModelClient()
-        
+
         request = ModelRequest(
             provider=ProviderType.AZURE,
             invoke_type=InvokeType.CHAT_COMPLETIONS,
@@ -125,11 +135,11 @@ def test_azure_openai():
                 client_type="test_client"
             ),
         )
-        
+
         response = client.invoke(request)
         print(f"✅ Azure OpenAI 成功")
         print(f"   响应内容: {response.model_dump_json()}...")
-        
+
     except Exception as e:
         print(f"❌ Azure OpenAI 失败: {str(e)}")
 
@@ -137,7 +147,7 @@ def test_azure_openai():
 async def test_google_streaming():
     """测试 Google 流式响应"""
     print("\n📡 测试 Google 流式响应...")
-    
+
     try:
         async with AsyncTamarModelClient() as client:
             request = ModelRequest(
@@ -159,18 +169,18 @@ async def test_google_streaming():
                     "maxOutputTokens": 50
                 }
             )
-            
+
             response_gen = await client.invoke(request)
             print(f"✅ Google 流式调用成功")
             print(f"   响应类型: {type(response_gen)}")
-            
+
             chunk_count = 0
             async for chunk in response_gen:
                 chunk_count += 1
                 print(f"   数据块 {chunk_count}: {type(chunk)} - {chunk.model_dump_json()}...")
                 if chunk_count >= 3:  # 只显示前3个数据块
                     break
-        
+
     except Exception as e:
         print(f"❌ Google 流式响应失败: {str(e)}")
 
@@ -178,7 +188,7 @@ async def test_google_streaming():
 async def test_azure_streaming():
     """测试 Azure 流式响应"""
     print("\n📡 测试 Azure 流式响应...")
-    
+
     try:
         async with AsyncTamarModelClient() as client:
             request = ModelRequest(
@@ -196,18 +206,18 @@ async def test_azure_streaming():
                 ),
                 stream=True  # 添加流式参数
             )
-            
+
             response_gen = await client.invoke(request)
             print(f"✅ Azure 流式调用成功")
             print(f"   响应类型: {type(response_gen)}")
-            
+
             chunk_count = 0
             async for chunk in response_gen:
                 chunk_count += 1
                 print(f"   数据块 {chunk_count}: {type(chunk)} - {chunk.model_dump_json()}...")
                 if chunk_count >= 3:  # 只显示前3个数据块
                     break
-        
+
     except Exception as e:
         print(f"❌ Azure 流式响应失败: {str(e)}")
 
@@ -215,10 +225,10 @@ async def test_azure_streaming():
 def test_sync_batch_requests():
     """测试同步批量请求"""
     print("\n📦 测试同步批量请求...")
-    
+
     try:
         from tamar_model_client.schemas import BatchModelRequest, BatchModelRequestItem
-        
+
         with TamarModelClient() as client:
             # 构建批量请求，包含 Google 和 Azure 的多个请求
             batch_request = BatchModelRequest(
@@ -260,18 +270,18 @@ def test_sync_batch_requests():
                     )
                 ]
             )
-            
+
             # 执行批量请求
             batch_response = client.invoke_batch(batch_request)
-            
+
             print(f"✅ 同步批量请求成功")
             print(f"   请求数量: {len(batch_request.items)}")
             print(f"   响应数量: {len(batch_response.responses)}")
             print(f"   批量请求ID: {batch_response.request_id}")
-            
+
             # 显示每个响应的结果
             for i, response in enumerate(batch_response.responses):
-                print(f"\n   响应 {i+1}:")
+                print(f"\n   响应 {i + 1}:")
                 print(f"   - custom_id: {response.custom_id}")
                 print(f"   - 内容长度: {len(response.content) if response.content else 0}")
                 print(f"   - 有错误: {'是' if response.error else '否'}")
@@ -279,7 +289,7 @@ def test_sync_batch_requests():
                     print(f"   - 内容预览: {response.content[:100]}...")
                 if response.error:
                     print(f"   - 错误信息: {response.error}")
-                
+
     except Exception as e:
         print(f"❌ 同步批量请求失败: {str(e)}")
 
@@ -287,10 +297,10 @@ def test_sync_batch_requests():
 async def test_batch_requests():
     """测试异步批量请求"""
     print("\n📦 测试异步批量请求...")
-    
+
     try:
         from tamar_model_client.schemas import BatchModelRequest, BatchModelRequestItem
-        
+
         async with AsyncTamarModelClient() as client:
             # 构建批量请求，包含 Google 和 Azure 的多个请求
             batch_request = BatchModelRequest(
@@ -343,18 +353,18 @@ async def test_batch_requests():
                     )
                 ]
             )
-            
+
             # 执行批量请求
             batch_response = await client.invoke_batch(batch_request)
-            
+
             print(f"✅ 批量请求成功")
             print(f"   请求数量: {len(batch_request.items)}")
             print(f"   响应数量: {len(batch_response.responses)}")
             print(f"   批量请求ID: {batch_response.request_id}")
-            
+
             # 显示每个响应的结果
             for i, response in enumerate(batch_response.responses):
-                print(f"\n   响应 {i+1}:")
+                print(f"\n   响应 {i + 1}:")
                 print(f"   - custom_id: {response.custom_id}")
                 print(f"   - 内容长度: {len(response.content) if response.content else 0}")
                 print(f"   - 有错误: {'是' if response.error else '否'}")
@@ -362,34 +372,286 @@ async def test_batch_requests():
                     print(f"   - 内容预览: {response.content[:100]}...")
                 if response.error:
                     print(f"   - 错误信息: {response.error}")
-                
+
     except Exception as e:
         print(f"❌ 批量请求失败: {str(e)}")
 
 
+def test_concurrent_requests(num_requests: int = 150):
+    """测试并发请求
+    
+    Args:
+        num_requests: 要发送的总请求数，默认150个
+    """
+    print(f"\n🚀 测试并发请求 ({num_requests} 个请求)...")
+
+    # 统计变量
+    total_requests = 0
+    successful_requests = 0
+    failed_requests = 0
+    request_times: List[float] = []
+    errors: Dict[str, int] = {}
+
+    # 线程安全的锁
+    stats_lock = threading.Lock()
+
+    def make_single_request(request_id: int) -> Tuple[bool, float, str]:
+        """执行单个请求并返回结果
+        
+        Returns:
+            (success, duration, error_msg)
+        """
+        start_time = time.time()
+        try:
+            # 每个线程创建自己的客户端实例
+            client = TamarModelClient()
+
+            # Google Vertex AI
+            request = ModelRequest(
+                provider=ProviderType.GOOGLE,
+                channel=Channel.VERTEXAI,
+                invoke_type=InvokeType.GENERATION,
+                model="tamar-google-gemini-flash-lite",
+                contents="1+1等于几？",
+                user_context=UserContext(
+                    user_id=f"concurrent_user_{request_id:03d}",
+                    org_id="test_org",
+                    client_type="concurrent_test"
+                ),
+                config={"temperature": 0.1}
+            )
+
+            response = client.invoke(request, timeout=300000.0)
+            duration = time.time() - start_time
+            return (True, duration, "")
+
+        except Exception as e:
+            duration = time.time() - start_time
+            error_msg = str(e)
+            return (False, duration, error_msg)
+
+    def worker(request_id: int):
+        """工作线程函数"""
+        nonlocal total_requests, successful_requests, failed_requests
+
+        success, duration, error_msg = make_single_request(request_id)
+
+        with stats_lock:
+            total_requests += 1
+            request_times.append(duration)
+
+            if success:
+                successful_requests += 1
+            else:
+                failed_requests += 1
+                # 统计错误类型
+                error_type = error_msg.split(':')[0] if ':' in error_msg else error_msg[:50]
+                errors[error_type] = errors.get(error_type, 0) + 1
+
+            # 每20个请求输出一次进度
+            if total_requests % 20 == 0:
+                print(
+                    f"   进度: {total_requests}/{num_requests} (成功: {successful_requests}, 失败: {failed_requests})")
+
+    # 使用线程池执行并发请求
+    start_time = time.time()
+
+    # 使用线程池，最多50个并发线程
+    with ThreadPoolExecutor(max_workers=50) as executor:
+        # 提交所有任务
+        futures = [executor.submit(worker, i) for i in range(num_requests)]
+
+        # 等待所有任务完成
+        for future in futures:
+            future.result()
+
+    total_duration = time.time() - start_time
+
+    # 计算统计信息
+    avg_request_time = sum(request_times) / len(request_times) if request_times else 0
+    min_request_time = min(request_times) if request_times else 0
+    max_request_time = max(request_times) if request_times else 0
+
+    # 输出结果
+    print(f"\n📊 并发测试结果:")
+    print(f"   总请求数: {total_requests}")
+    print(f"   成功请求: {successful_requests} ({successful_requests / total_requests * 100:.1f}%)")
+    print(f"   失败请求: {failed_requests} ({failed_requests / total_requests * 100:.1f}%)")
+    print(f"   总耗时: {total_duration:.2f} 秒")
+    print(f"   平均QPS: {total_requests / total_duration:.2f}")
+    print(f"\n   请求耗时统计:")
+    print(f"   - 平均: {avg_request_time:.3f} 秒")
+    print(f"   - 最小: {min_request_time:.3f} 秒")
+    print(f"   - 最大: {max_request_time:.3f} 秒")
+
+    if errors:
+        print(f"\n   错误统计:")
+        for error_type, count in sorted(errors.items(), key=lambda x: x[1], reverse=True):
+            print(f"   - {error_type}: {count} 次")
+
+    return {
+        "total": total_requests,
+        "successful": successful_requests,
+        "failed": failed_requests,
+        "duration": total_duration,
+        "qps": total_requests / total_duration
+    }
+
+
+async def test_async_concurrent_requests(num_requests: int = 150):
+    """测试异步并发请求
+    
+    Args:
+        num_requests: 要发送的总请求数，默认150个
+    """
+    print(f"\n🚀 测试异步并发请求 ({num_requests} 个请求)...")
+
+    # 统计变量
+    total_requests = 0
+    successful_requests = 0
+    failed_requests = 0
+    request_times: List[float] = []
+    errors: Dict[str, int] = {}
+
+    # 异步锁
+    stats_lock = asyncio.Lock()
+
+    async def make_single_async_request(client: AsyncTamarModelClient, request_id: int) -> Tuple[bool, float, str]:
+        """执行单个异步请求并返回结果
+        
+        Returns:
+            (success, duration, error_msg)
+        """
+        start_time = time.time()
+        try:
+            # 根据请求ID选择不同的provider，以增加测试多样性
+            # Google Vertex AI
+            request = ModelRequest(
+                provider=ProviderType.GOOGLE,
+                channel=Channel.VERTEXAI,
+                invoke_type=InvokeType.GENERATION,
+                model="tamar-google-gemini-flash-lite",
+                contents="1+1等于几？",
+                user_context=UserContext(
+                    user_id=f"async_concurrent_user_{request_id:03d}",
+                    org_id="test_org",
+                    client_type="async_concurrent_test"
+                ),
+                config={"temperature": 0.1}
+            )
+
+            response = await client.invoke(request, timeout=300000.0)
+            duration = time.time() - start_time
+            return (True, duration, "")
+
+        except Exception as e:
+            duration = time.time() - start_time
+            error_msg = str(e)
+            return (False, duration, error_msg)
+
+    async def async_worker(client: AsyncTamarModelClient, request_id: int):
+        """异步工作协程"""
+        nonlocal total_requests, successful_requests, failed_requests
+
+        success, duration, error_msg = await make_single_async_request(client, request_id)
+
+        async with stats_lock:
+            total_requests += 1
+            request_times.append(duration)
+
+            if success:
+                successful_requests += 1
+            else:
+                failed_requests += 1
+                # 统计错误类型
+                error_type = error_msg.split(':')[0] if ':' in error_msg else error_msg[:50]
+                errors[error_type] = errors.get(error_type, 0) + 1
+
+            # 每20个请求输出一次进度
+            if total_requests % 20 == 0:
+                print(
+                    f"   进度: {total_requests}/{num_requests} (成功: {successful_requests}, 失败: {failed_requests})")
+
+    # 使用异步客户端执行并发请求
+    start_time = time.time()
+
+    # 创建一个共享的异步客户端
+    async with AsyncTamarModelClient() as client:
+        # 创建所有任务，但限制并发数
+        semaphore = asyncio.Semaphore(50)  # 限制最多50个并发请求
+
+        async def limited_worker(request_id: int):
+            async with semaphore:
+                await async_worker(client, request_id)
+
+        # 创建所有任务
+        tasks = [limited_worker(i) for i in range(num_requests)]
+
+        # 等待所有任务完成
+        await asyncio.gather(*tasks)
+
+    total_duration = time.time() - start_time
+
+    # 计算统计信息
+    avg_request_time = sum(request_times) / len(request_times) if request_times else 0
+    min_request_time = min(request_times) if request_times else 0
+    max_request_time = max(request_times) if request_times else 0
+
+    # 输出结果
+    print(f"\n📊 异步并发测试结果:")
+    print(f"   总请求数: {total_requests}")
+    print(f"   成功请求: {successful_requests} ({successful_requests / total_requests * 100:.1f}%)")
+    print(f"   失败请求: {failed_requests} ({failed_requests / total_requests * 100:.1f}%)")
+    print(f"   总耗时: {total_duration:.2f} 秒")
+    print(f"   平均QPS: {total_requests / total_duration:.2f}")
+    print(f"\n   请求耗时统计:")
+    print(f"   - 平均: {avg_request_time:.3f} 秒")
+    print(f"   - 最小: {min_request_time:.3f} 秒")
+    print(f"   - 最大: {max_request_time:.3f} 秒")
+
+    if errors:
+        print(f"\n   错误统计:")
+        for error_type, count in sorted(errors.items(), key=lambda x: x[1], reverse=True):
+            print(f"   - {error_type}: {count} 次")
+
+    return {
+        "total": total_requests,
+        "successful": successful_requests,
+        "failed": failed_requests,
+        "duration": total_duration,
+        "qps": total_requests / total_duration
+    }
+
+
 async def main():
     """主函数"""
     print("🚀 简化版 Google/Azure 测试")
     print("=" * 50)
-    
+
     try:
-        # 同步测试
-        test_google_ai_studio()
-        test_google_vertex_ai()
-        test_azure_openai()
-        
-        # 同步批量测试
-        test_sync_batch_requests()
-        
-        # 异步流式测试
-        await asyncio.wait_for(test_google_streaming(), timeout=60.0)
-        await asyncio.wait_for(test_azure_streaming(), timeout=60.0)
-        
-        # 异步批量测试
-        await asyncio.wait_for(test_batch_requests(), timeout=120.0)
-        
+        # # 同步测试
+        # test_google_ai_studio()
+        # test_google_vertex_ai()
+        # test_azure_openai()
+        #
+        # # 同步批量测试
+        # test_sync_batch_requests()
+        #
+        # # 异步流式测试
+        # await asyncio.wait_for(test_google_streaming(), timeout=60.0)
+        # await asyncio.wait_for(test_azure_streaming(), timeout=60.0)
+        #
+        # # 异步批量测试
+        # await asyncio.wait_for(test_batch_requests(), timeout=120.0)
+
+        # 同步并发测试
+        #test_concurrent_requests(150)  # 测试150个并发请求
+
+        # 异步并发测试
+        await test_async_concurrent_requests(1000)  # 测试150个异步并发请求
+
         print("\n✅ 测试完成")
-        
+
     except asyncio.TimeoutError:
         print("\n⏰ 测试超时")
     except KeyboardInterrupt:
@@ -402,12 +664,12 @@ async def main():
         try:
             # 短暂等待让正在完成的任务自然结束
             await asyncio.sleep(0.5)
-            
+
             # 检查是否还有未完成的任务
             current_task = asyncio.current_task()
-            tasks = [task for task in asyncio.all_tasks() 
-                    if not task.done() and task != current_task]
-            
+            tasks = [task for task in asyncio.all_tasks()
+                     if not task.done() and task != current_task]
+
             if tasks:
                 print(f"   发现 {len(tasks)} 个未完成任务，等待自然完成...")
                 # 简单等待，不强制取消
@@ -418,12 +680,12 @@ async def main():
                     )
                 except asyncio.TimeoutError:
                     pass
-            
+
             print("   任务清理完成")
-                
+
         except Exception as e:
             print(f"   ⚠️ 任务清理时出现异常: {e}")
-        
+
         print("🔚 程序即将退出")
 
 
@@ -433,16 +695,16 @@ if __name__ == "__main__":
         asyncio_logger = logging.getLogger('asyncio')
         original_level = asyncio_logger.level
         asyncio_logger.setLevel(logging.ERROR)
-        
+
         try:
             asyncio.run(main())
         finally:
             # 恢复原始日志级别
             asyncio_logger.setLevel(original_level)
-            
+
     except KeyboardInterrupt:
         print("\n⚠️ 程序被用户中断")
     except Exception as e:
         print(f"\n❌ 程序执行出错: {e}")
     finally:
-        print("🏁 程序已退出")
+        print("🏁 程序已退出")

tamar_model_client-0.1.22/tests/test_logging_issue.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""
+测试日志格式问题
+"""
+
+import asyncio
+import logging
+import os
+import sys
+
+# 设置环境变量
+os.environ['MODEL_MANAGER_SERVER_GRPC_USE_TLS'] = "false"
+os.environ['MODEL_MANAGER_SERVER_ADDRESS'] = "localhost:50051"
+os.environ['MODEL_MANAGER_SERVER_JWT_SECRET_KEY'] = "model-manager-server-jwt-key"
+
+# 先导入 SDK
+from tamar_model_client import AsyncTamarModelClient
+from tamar_model_client.schemas import ModelRequest, UserContext
+from tamar_model_client.enums import ProviderType, InvokeType, Channel
+
+# 检查 SDK 的日志配置
+print("=== SDK Logger Configuration ===")
+sdk_loggers = [
+    'tamar_model_client',
+    'tamar_model_client.async_client',
+    'tamar_model_client.error_handler',
+    'tamar_model_client.core.base_client'
+]
+
+for logger_name in sdk_loggers:
+    logger = logging.getLogger(logger_name)
+    print(f"\nLogger: {logger_name}")
+    print(f"  Level: {logging.getLevelName(logger.level)}")
+    print(f"  Handlers: {len(logger.handlers)}")
+    for i, handler in enumerate(logger.handlers):
+        print(f"    Handler {i}: {type(handler).__name__}")
+        if hasattr(handler, 'formatter'):
+            print(f"      Formatter: {type(handler.formatter).__name__ if handler.formatter else 'None'}")
+    print(f"  Propagate: {logger.propagate}")
+
+
+async def test_error_logging():
+    """测试错误日志格式"""
+    print("\n=== Testing Error Logging ===")
+    
+    try:
+        async with AsyncTamarModelClient() as client:
+            # 故意创建一个会失败的请求
+            request = ModelRequest(
+                provider=ProviderType.GOOGLE,
+                channel=Channel.VERTEXAI,
+                invoke_type=InvokeType.GENERATION,
+                model="invalid-model",
+                contents="test",
+                user_context=UserContext(
+                    user_id="test_user",
+                    org_id="test_org",
+                    client_type="test_client"
+                )
+            )
+            
+            response = await client.invoke(request, timeout=5.0)
+            print(f"Response: {response}")
+            
+    except Exception as e:
+        print(f"Exception caught: {type(e).__name__}: {str(e)}")
+
+
+async def main():
+    await test_error_logging()
+
+
+if __name__ == "__main__":
+    print("Starting logging test...")
+    asyncio.run(main())