tamar-model-client 0.1.28__py3-none-any.whl → 0.1.30__py3-none-any.whl

tamar_model_client/async_client.py

@@ -103,7 +103,6 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         self.stub: Optional[model_service_pb2_grpc.ModelServiceStub] = None
         self._channel_error_count = 0
         self._last_channel_error_time = None
-        self._channel_lock = asyncio.Lock()  # 异步锁
         
         # === Request ID 管理 ===
         self._request_id_manager = RequestIdManager()
@@ -194,7 +193,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         # 如果 channel 存在但不健康，记录日志
         if self.channel and self.stub:
             logger.warning(
-                "Channel exists but unhealthy, will recreate",
+                "⚠️ Channel exists but unhealthy, will recreate",
                 extra={
                     "log_type": "channel_recreate", 
                     "data": {
@@ -222,7 +221,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                                        "data": {"tls_enabled": True, "server_address": self.server_address}})
                 else:
                     self.channel = grpc.aio.insecure_channel(
-                        self.server_address,
+                        f"dns:///{self.server_address}",
                         options=options
                     )
                     logger.info("🔓 Using insecure gRPC channel (TLS disabled)",
@@ -272,7 +271,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             # 如果处于关闭或失败状态，需要重建
             if state in [grpc.ChannelConnectivity.SHUTDOWN, 
                         grpc.ChannelConnectivity.TRANSIENT_FAILURE]:
-                logger.warning(f"Channel in unhealthy state: {state}",
+                logger.warning(f"⚠️ Channel in unhealthy state: {state}",
                              extra={"log_type": "info", 
                                    "data": {"channel_state": str(state)}})
                 return False
@@ -280,7 +279,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             # 如果最近有多次错误，也需要重建
             if self._channel_error_count > 3 and self._last_channel_error_time:
                 if time.time() - self._last_channel_error_time < 60:  # 60秒内
-                    logger.warning("Too many channel errors recently, marking as unhealthy",
+                    logger.warning("⚠️ Too many channel errors recently, marking as unhealthy",
                                  extra={"log_type": "info",
                                        "data": {"error_count": self._channel_error_count}})
                     return False
@@ -288,7 +287,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             return True
             
         except Exception as e:
-            logger.error(f"Error checking channel health: {e}",
+            logger.error(f"❌ Error checking channel health: {e}",
                         extra={"log_type": "info", 
                               "data": {"error": str(e)}})
             return False
@@ -299,27 +298,26 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
         
         关闭旧的 channel 并创建新的连接
         """
-        async with self._channel_lock:
-            # 关闭旧 channel
-            if self.channel:
-                try:
-                    await self.channel.close()
-                    logger.info("Closed unhealthy channel",
-                              extra={"log_type": "info"})
-                except Exception as e:
-                    logger.warning(f"Error closing channel: {e}",
-                                 extra={"log_type": "info"})
-                    
-            # 清空引用
-            self.channel = None
-            self.stub = None
-            
-            # 重置错误计数
-            self._channel_error_count = 0
-            self._last_channel_error_time = None
-            
-            logger.info("Recreating gRPC channel...",
-                       extra={"log_type": "info"})
+        # 关闭旧 channel
+        if self.channel:
+            try:
+                await self.channel.close()
+                logger.info("🔚 Closed unhealthy channel",
+                          extra={"log_type": "info"})
+            except Exception as e:
+                logger.warning(f"⚠️ Error closing channel: {e}",
+                             extra={"log_type": "info"})
+                
+        # 清空引用
+        self.channel = None
+        self.stub = None
+        
+        # 重置错误计数
+        self._channel_error_count = 0
+        self._last_channel_error_time = None
+        
+        logger.info("🔄 Recreating gRPC channel...",
+                   extra={"log_type": "info"})
     
     def _record_channel_error(self, error: grpc.RpcError):
         """
@@ -346,7 +344,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
             
         # 记录详细的错误信息
         logger.warning(
-            f"Channel error recorded: {error.code().name}",
+            f"⚠️ Channel error recorded: {error.code().name}",
             extra={
                 "log_type": "channel_error",
                 "data": {
@@ -457,7 +455,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                             is_network_cancelled = error_context.is_network_cancelled()
                             
                             logger.warning(
-                                f"CANCELLED error in stream, channel state: {channel_state}",
+                                f"⚠️ CANCELLED error in stream, channel state: {channel_state}",
                                 extra={
                                     "log_type": "cancelled_debug",
                                     "request_id": context.get('request_id'),
@@ -485,14 +483,16 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                         "request_id": context.get('request_id'),
                         "data": {
                             "error_code": e.code().name if e.code() else 'UNKNOWN',
+                            "error_details": e.details() if hasattr(e, 'details') else '',
                             "retry_count": attempt,
                             "max_retries": self.max_retries,
                             "method": "stream"
                         },
                         "duration": current_duration
                     }
+                    error_detail = f" - {e.details()}" if e.details() else ""
                     logger.warning(
-                        f"Stream attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (will retry)",
+                        f"🔄 Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (will retry)",
                         extra=log_data
                     )
                     
@@ -507,6 +507,7 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                         "request_id": context.get('request_id'),
                         "data": {
                             "error_code": e.code().name if e.code() else 'UNKNOWN',
+                            "error_details": e.details() if hasattr(e, 'details') else '',
                             "retry_count": attempt,
                             "max_retries": self.max_retries,
                             "method": "stream",
@@ -514,8 +515,9 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                         },
                         "duration": current_duration
                     }
-                    logger.error(
-                        f"Stream failed: {e.code()} (no retry)",
+                    error_detail = f" - {e.details()}" if e.details() else ""
+                    logger.warning(
+                        f"⚠️ Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (no more retries)",
                         extra=log_data
                     )
                     context['duration'] = current_duration
@@ -1033,6 +1035,13 @@ class AsyncTamarModelClient(BaseClient, AsyncHttpFallbackMixin):
                                  "batch_size": len(batch_request_model.items)
                              }
                          })
+            
+            # 记录失败（如果启用了熔断）
+            if self.resilient_enabled and self.circuit_breaker:
+                # 将错误码传递给熔断器，用于智能失败统计
+                error_code = e.code() if hasattr(e, 'code') else None
+                self.circuit_breaker.record_failure(error_code)
+            
             raise e
         except Exception as e:
             duration = time.time() - start_time

tamar_model_client/core/base_client.py

@@ -136,10 +136,7 @@ class BaseClient(ABC):
             ('grpc.resource_quota_size', 1048576000),  # 设置资源配额为1GB
 
             # 启用负载均衡配置
-            ('grpc.lb_policy', 'round_robin'),  # 设置负载均衡策略为 round_robin（轮询）
-
-            # 启用详细的日志记录
-            ('grpc.debug', 1),  # 启用 gRPC 的调试日志，记录更多的连接和请求信息
+            ('grpc.lb_policy_name', 'round_robin'), # 设置负载均衡策略为 round_robin（轮询）
         ]
 
         if self.default_authority:
@@ -240,9 +237,13 @@ class BaseClient(ABC):
 
         return {
             "enabled": self.resilient_enabled,
-            "circuit_state": self.circuit_breaker.get_state(),
-            "failure_count": self.circuit_breaker.failure_count,
-            "last_failure_time": self.circuit_breaker.last_failure_time,
+            "circuit_breaker": {
+                "state": self.circuit_breaker.get_state(),
+                "failure_count": self.circuit_breaker.failure_count,
+                "last_failure_time": self.circuit_breaker.last_failure_time,
+                "failure_threshold": self.circuit_breaker.failure_threshold,
+                "recovery_timeout": self.circuit_breaker.recovery_timeout
+            },
             "http_fallback_url": self.http_fallback_url
         }
 

tamar_model_client/core/http_fallback.py

@@ -15,6 +15,59 @@ from ..schemas import ModelRequest, ModelResponse
 logger = get_protected_logger(__name__)
 
 
+def safe_serialize(obj: Any) -> Any:
+    """
+    安全地序列化对象，避免 Pydantic ValidatorIterator 序列化问题
+    """
+    if obj is None:
+        return None
+    
+    # 处理基本类型
+    if isinstance(obj, (str, int, float, bool)):
+        return obj
+    
+    # 处理列表
+    if isinstance(obj, (list, tuple)):
+        return [safe_serialize(item) for item in obj]
+    
+    # 处理字典
+    if isinstance(obj, dict):
+        return {key: safe_serialize(value) for key, value in obj.items()}
+    
+    # 处理 Pydantic 模型
+    if hasattr(obj, 'model_dump'):
+        try:
+            return obj.model_dump(exclude_unset=True)
+        except Exception:
+            # 如果 model_dump 失败，尝试手动提取字段
+            try:
+                if hasattr(obj, '__dict__'):
+                    return {k: safe_serialize(v) for k, v in obj.__dict__.items() 
+                           if not k.startswith('_') and not callable(v)}
+                elif hasattr(obj, '__slots__'):
+                    return {slot: safe_serialize(getattr(obj, slot, None)) 
+                           for slot in obj.__slots__ if hasattr(obj, slot)}
+            except Exception:
+                pass
+    
+    # 处理 Pydantic v1 模型
+    if hasattr(obj, 'dict'):
+        try:
+            return obj.dict(exclude_unset=True)
+        except Exception:
+            pass
+    
+    # 处理枚举
+    if hasattr(obj, 'value'):
+        return obj.value
+    
+    # 最后的尝试：转换为字符串
+    try:
+        return str(obj)
+    except Exception:
+        return None
+
+
 class HttpFallbackMixin:
     """HTTP fallback functionality for synchronous clients
     
@@ -43,30 +96,37 @@ class HttpFallbackMixin:
     
     def _convert_to_http_format(self, model_request: ModelRequest) -> Dict[str, Any]:
         """Convert ModelRequest to HTTP payload format"""
+        # Use safe serialization to avoid Pydantic ValidatorIterator issues
         payload = {
-            "provider": model_request.provider.value,
-            "model": model_request.model,
-            "user_context": model_request.user_context.model_dump(),
-            "stream": model_request.stream
+            "provider": safe_serialize(model_request.provider),
+            "model": safe_serialize(model_request.model),
+            "user_context": safe_serialize(model_request.user_context),
+            "stream": safe_serialize(model_request.stream)
         }
         
         # Add provider-specific fields
         if hasattr(model_request, 'messages') and model_request.messages:
-            payload['messages'] = model_request.messages
+            payload['messages'] = safe_serialize(model_request.messages)
         if hasattr(model_request, 'contents') and model_request.contents:
-            payload['contents'] = model_request.contents
+            payload['contents'] = safe_serialize(model_request.contents)
         
         # Add optional fields
         if model_request.channel:
-            payload['channel'] = model_request.channel.value
+            payload['channel'] = safe_serialize(model_request.channel)
         if model_request.invoke_type:
-            payload['invoke_type'] = model_request.invoke_type.value
+            payload['invoke_type'] = safe_serialize(model_request.invoke_type)
             
-        # Add extra parameters
+        # Add config parameters safely
+        if hasattr(model_request, 'config') and model_request.config:
+            payload['config'] = safe_serialize(model_request.config)
+        
+        # Add extra parameters safely
         if hasattr(model_request, 'model_extra') and model_request.model_extra:
-            for key, value in model_request.model_extra.items():
-                if key not in payload:
-                    payload[key] = value
+            serialized_extra = safe_serialize(model_request.model_extra)
+            if isinstance(serialized_extra, dict):
+                for key, value in serialized_extra.items():
+                    if key not in payload:
+                        payload[key] = value
                 
         return payload
     
@@ -96,7 +156,7 @@ class HttpFallbackMixin:
                         data = json.loads(data_str)
                         yield ModelResponse(**data)
                     except json.JSONDecodeError:
-                        logger.warning(f"Failed to parse streaming response: {data_str}")
+                        logger.warning(f"⚠️ Failed to parse streaming response: {data_str}")
     
     def _invoke_http_fallback(self, model_request: ModelRequest, 
                              timeout: Optional[float] = None,
@@ -305,7 +365,7 @@ class AsyncHttpFallbackMixin:
                             data = json.loads(data_str)
                             yield ModelResponse(**data)
                         except json.JSONDecodeError:
-                            logger.warning(f"Failed to parse streaming response: {data_str}")
+                            logger.warning(f"⚠️ Failed to parse streaming response: {data_str}")
     
     async def _invoke_http_fallback(self, model_request: ModelRequest,
                                    timeout: Optional[float] = None,
@@ -339,6 +399,7 @@ class AsyncHttpFallbackMixin:
         
         # Convert to HTTP format
         http_payload = self._convert_to_http_format(model_request)
+        print(http_payload)
         
         # Construct URL
         url = f"{self.http_fallback_url}/v1/invoke"

tamar_model_client/error_handler.py

@@ -67,7 +67,7 @@ class GrpcErrorHandler:
             log_data['duration'] = context['duration']
 
         self.logger.error(
-            f"gRPC Error occurred: {error_context.error_code.name if error_context.error_code else 'UNKNOWN'}",
+            f"❌ gRPC Error occurred: {error_context.error_code.name if error_context.error_code else 'UNKNOWN'}",
             extra=log_data
         )
 
@@ -151,14 +151,14 @@ class ErrorRecoveryStrategy:
 
     async def handle_token_refresh(self, error_context: ErrorContext):
         """处理 Token 刷新"""
-        self.client.logger.info("Attempting to refresh JWT token")
+        self.client.logger.info("🔄 Attempting to refresh JWT token")
         # 这里需要客户端实现 _refresh_jwt_token 方法
         if hasattr(self.client, '_refresh_jwt_token'):
             await self.client._refresh_jwt_token()
 
     async def handle_reconnect(self, error_context: ErrorContext):
         """处理重连"""
-        self.client.logger.info("Attempting to reconnect channel")
+        self.client.logger.info("🔄 Attempting to reconnect channel")
         # 这里需要客户端实现 _reconnect_channel 方法
         if hasattr(self.client, '_reconnect_channel'):
             await self.client._reconnect_channel()
@@ -170,7 +170,7 @@ class ErrorRecoveryStrategy:
 
     async def handle_circuit_break(self, error_context: ErrorContext):
         """处理熔断"""
-        self.client.logger.warning("Circuit breaker activated")
+        self.client.logger.warning("⚠️ Circuit breaker activated")
         # 这里可以实现熔断逻辑
         pass
 
@@ -322,8 +322,9 @@ class EnhancedRetryHandler:
                         },
                         "duration": current_duration
                     }
+                    error_detail = f" - {error_context.error_message}" if error_context.error_message else ""
                     logger.warning(
-                        f"Final attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (no more retries)",
+                        f"⚠️ Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (no more retries)",
                         extra=log_data
                     )
                     last_exception = self.error_handler.handle_error(e, context)
@@ -346,8 +347,9 @@ class EnhancedRetryHandler:
                     },
                     "duration": current_duration
                 }
+                error_detail = f" - {error_context.error_message}" if error_context.error_message else ""
                 logger.warning(
-                    f"Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (will retry)",
+                    f"🔄 Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (will retry)",
                     extra=log_data
                 )
 

tamar_model_client/json_formatter.py

@@ -57,5 +57,14 @@ class JSONFormatter(logging.Formatter):
         if hasattr(record, "trace"):
             log_data["trace"] = getattr(record, "trace")
         
+        # 添加异常信息（如果有的话）
+        if record.exc_info:
+            import traceback
+            log_data["exception"] = {
+                "type": record.exc_info[0].__name__ if record.exc_info[0] else None,
+                "message": str(record.exc_info[1]) if record.exc_info[1] else None,
+                "traceback": traceback.format_exception(*record.exc_info)
+            }
+        
         # 使用安全的 JSON 编码器
         return json.dumps(log_data, ensure_ascii=False, cls=SafeJSONEncoder)

tamar_model_client/sync_client.py

@@ -159,7 +159,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         # 如果 channel 存在但不健康，记录日志
         if self.channel and self.stub:
             logger.warning(
-                "Channel exists but unhealthy, will recreate",
+                "⚠️ Channel exists but unhealthy, will recreate",
                 extra={
                     "log_type": "channel_recreate",
                     "data": {
@@ -187,7 +187,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                                        "data": {"tls_enabled": True, "server_address": self.server_address}})
                 else:
                     self.channel = grpc.insecure_channel(
-                        self.server_address,
+                        f"dns:///{self.server_address}",
                         options=options
                     )
                     logger.info("🔓 Using insecure gRPC channel (TLS disabled)",
@@ -238,7 +238,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             # 如果处于关闭或失败状态，需要重建
             if state in [grpc.ChannelConnectivity.SHUTDOWN, 
                         grpc.ChannelConnectivity.TRANSIENT_FAILURE]:
-                logger.warning(f"Channel in unhealthy state: {state}",
+                logger.warning(f"⚠️ Channel in unhealthy state: {state}",
                              extra={"log_type": "info", 
                                    "data": {"channel_state": str(state)}})
                 return False
@@ -246,7 +246,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             # 如果最近有多次错误，也需要重建
             if self._channel_error_count > 3 and self._last_channel_error_time:
                 if time.time() - self._last_channel_error_time < 60:  # 60秒内
-                    logger.warning("Too many channel errors recently, marking as unhealthy",
+                    logger.warning("⚠️ Too many channel errors recently, marking as unhealthy",
                                  extra={"log_type": "info",
                                        "data": {"error_count": self._channel_error_count}})
                     return False
@@ -254,7 +254,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             return True
             
         except Exception as e:
-            logger.error(f"Error checking channel health: {e}",
+            logger.error(f"❌ Error checking channel health: {e}",
                         extra={"log_type": "info", 
                               "data": {"error": str(e)}})
             return False
@@ -270,10 +270,10 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             if self.channel:
                 try:
                     self.channel.close()
-                    logger.info("Closed unhealthy channel",
+                    logger.info("🔚 Closed unhealthy channel",
                               extra={"log_type": "info"})
                 except Exception as e:
-                    logger.warning(f"Error closing channel: {e}",
+                    logger.warning(f"⚠️ Error closing channel: {e}",
                                  extra={"log_type": "info"})
                     
             # 清空引用
@@ -284,7 +284,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             self._channel_error_count = 0
             self._last_channel_error_time = None
             
-            logger.info("Recreating gRPC channel...",
+            logger.info("🔄 Recreating gRPC channel...",
                        extra={"log_type": "info"})
     
     def _record_channel_error(self, error: grpc.RpcError):
@@ -312,7 +312,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             
         # 记录详细的错误信息
         logger.warning(
-            f"Channel error recorded: {error.code().name}",
+            f"⚠️ Channel error recorded: {error.code().name}",
             extra={
                 "log_type": "channel_error",
                 "data": {
@@ -371,7 +371,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                             channel_state = "UNKNOWN"
                     
                     logger.warning(
-                        f"CANCELLED error detected, channel state: {channel_state}",
+                        f"⚠️ CANCELLED error detected, channel state: {channel_state}",
                         extra={
                             "log_type": "cancelled_debug",
                             "request_id": context.get('request_id'),
@@ -469,6 +469,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                         "request_id": context.get('request_id'),
                         "data": {
                             "error_code": e.code().name if e.code() else 'UNKNOWN',
+                            "error_details": e.details() if hasattr(e, 'details') else '',
                             "retry_count": attempt,
                             "max_retries": self.max_retries,
                             "method": context.get('method', 'unknown'),
@@ -476,8 +477,9 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                         },
                         "duration": current_duration
                     }
+                    error_detail = f" - {e.details()}" if e.details() else ""
                     logger.warning(
-                        f"Final attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (no more retries)",
+                        f"⚠️ Final attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (no more retries)",
                         extra=log_data
                     )
                     
@@ -490,6 +492,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                     "request_id": context.get('request_id'),
                     "data": {
                         "error_code": e.code().name if e.code() else 'UNKNOWN',
+                        "error_details": e.details() if hasattr(e, 'details') else '',
                         "retry_count": attempt,
                         "max_retries": self.max_retries,
                         "method": context.get('method', 'unknown'),
@@ -498,8 +501,9 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                     },
                     "duration": current_duration
                 }
+                error_detail = f" - {e.details()}" if e.details() else ""
                 logger.warning(
-                    f"Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (will retry)",
+                    f"🔄 Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (will retry)",
                     extra=log_data
                 )
 
@@ -683,6 +687,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                         "request_id": context.get('request_id'),
                         "data": {
                             "error_code": e.code().name if e.code() else 'UNKNOWN',
+                            "error_details": e.details() if hasattr(e, 'details') else '',
                             "retry_count": attempt,
                             "max_retries": self.max_retries,
                             "method": "stream",
@@ -690,8 +695,9 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                         },
                         "duration": current_duration
                     }
+                    error_detail = f" - {e.details()}" if e.details() else ""
                     logger.error(
-                        f"Stream failed: {e.code()} (no retry)",
+                        f"❌ Stream failed: {e.code()}{error_detail} (no retry)",
                         extra=log_data
                     )
                     context['duration'] = current_duration
@@ -704,14 +710,16 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                     "request_id": context.get('request_id'),
                     "data": {
                         "error_code": e.code().name if e.code() else 'UNKNOWN',
+                        "error_details": e.details() if hasattr(e, 'details') else '',
                         "retry_count": attempt,
                         "max_retries": self.max_retries,
                         "method": "stream"
                     },
                     "duration": current_duration
                 }
+                error_detail = f" - {e.details()}" if e.details() else ""
                 logger.warning(
-                    f"Stream attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()} (will retry)",
+                    f"🔄 Stream attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (will retry)",
                     extra=log_data
                 )
                 
@@ -1191,6 +1199,13 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                                  "batch_size": len(batch_request_model.items)
                              }
                          })
+            
+            # 记录失败（如果启用了熔断）
+            if self.resilient_enabled and self.circuit_breaker:
+                # 将错误码传递给熔断器，用于智能失败统计
+                error_code = e.code() if hasattr(e, 'code') else None
+                self.circuit_breaker.record_failure(error_code)
+            
             raise e
         except Exception as e:
             duration = time.time() - start_time