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

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
 
@@ -230,19 +230,107 @@ class EnhancedRetryHandler:
             except (grpc.RpcError, grpc.aio.AioRpcError) as e:
                 # 创建错误上下文
                 error_context = ErrorContext(e, context)
+                current_duration = time.time() - method_start_time
+                context['duration'] = current_duration
 
                 # 判断是否可以重试
-                if not self._should_retry(e, attempt):
+                should_retry = self._should_retry(e, attempt)
+                
+                # 检查是否应该尝试快速降级（需要从外部注入client引用）
+                should_try_fallback = False
+                if hasattr(self.error_handler, 'client') and hasattr(self.error_handler.client, '_should_try_fallback'):
+                    should_try_fallback = self.error_handler.client._should_try_fallback(e.code(), attempt)
+                
+                if should_try_fallback:
+                    # 尝试快速降级到HTTP
+                    logger.warning(
+                        f"🚀 Fast fallback triggered for {e.code().name} after {attempt + 1} attempts",
+                        extra={
+                            "log_type": "fast_fallback",
+                            "request_id": error_context.request_id,
+                            "data": {
+                                "error_code": e.code().name,
+                                "attempt": attempt,
+                                "fallback_reason": "immediate" if hasattr(self.error_handler.client, 'immediate_fallback_errors') and e.code() in self.error_handler.client.immediate_fallback_errors else "after_retries"
+                            }
+                        }
+                    )
+                    
+                    try:
+                        # 尝试HTTP降级（需要从context获取必要参数）
+                        if hasattr(self.error_handler, 'client'):
+                            # 检查是否是批量请求
+                            if hasattr(self.error_handler.client, '_current_batch_request'):
+                                batch_request = self.error_handler.client._current_batch_request
+                                origin_request_id = getattr(self.error_handler.client, '_current_origin_request_id', None)
+                                timeout = context.get('timeout')
+                                request_id = context.get('request_id')
+                                
+                                # 尝试批量HTTP降级
+                                result = await self.error_handler.client._invoke_batch_http_fallback(batch_request, timeout, request_id, origin_request_id)
+                            elif hasattr(self.error_handler.client, '_current_model_request'):
+                                model_request = self.error_handler.client._current_model_request
+                                origin_request_id = getattr(self.error_handler.client, '_current_origin_request_id', None)
+                                timeout = context.get('timeout')
+                                request_id = context.get('request_id')
+                                
+                                # 尝试HTTP降级
+                                result = await self.error_handler.client._invoke_http_fallback(model_request, timeout, request_id, origin_request_id)
+                            
+                            logger.info(
+                                f"✅ Fast fallback to HTTP succeeded",
+                                extra={
+                                    "log_type": "fast_fallback_success",
+                                    "request_id": request_id,
+                                    "data": {
+                                        "grpc_attempts": attempt + 1,
+                                        "fallback_duration": time.time() - method_start_time
+                                    }
+                                }
+                            )
+                            
+                            return result
+                    except Exception as fallback_error:
+                        # 降级失败，记录日志但继续原有重试逻辑
+                        logger.warning(
+                            f"⚠️ Fast fallback to HTTP failed: {str(fallback_error)}",
+                            extra={
+                                "log_type": "fast_fallback_failed",
+                                "request_id": error_context.request_id,
+                                "data": {
+                                    "fallback_error": str(fallback_error),
+                                    "will_continue_grpc_retry": should_retry and attempt < self.max_retries
+                                }
+                            }
+                        )
+
+                if not should_retry:
                     # 不可重试或已达到最大重试次数
-                    current_duration = time.time() - method_start_time
-                    context['duration'] = current_duration
+                    # 记录最终失败日志
+                    log_data = {
+                        "log_type": "info",
+                        "request_id": error_context.request_id,
+                        "data": {
+                            "error_code": error_context.error_code.name if error_context.error_code else 'UNKNOWN',
+                            "error_message": error_context.error_message,
+                            "retry_count": attempt,
+                            "max_retries": self.max_retries,
+                            "category": error_context._get_error_category(),
+                            "is_retryable": False,
+                            "method": error_context.method,
+                            "final_failure": True
+                        },
+                        "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()}{error_detail} (no more retries)",
+                        extra=log_data
+                    )
                     last_exception = self.error_handler.handle_error(e, context)
                     break
 
-                # 计算当前耗时
-                current_duration = time.time() - method_start_time
-
-                # 记录重试日志
+                # 可以重试，记录重试日志
                 log_data = {
                     "log_type": "info",
                     "request_id": error_context.request_id,
@@ -252,13 +340,16 @@ class EnhancedRetryHandler:
                         "retry_count": attempt,
                         "max_retries": self.max_retries,
                         "category": error_context._get_error_category(),
-                        "is_retryable": True,  # 既然在重试，说明是可重试的
-                        "method": error_context.method
+                        "is_retryable": True,
+                        "method": error_context.method,
+                        "will_retry": True,
+                        "fallback_attempted": should_try_fallback
                     },
                     "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()}",
+                    f"🔄 Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (will retry)",
                     extra=log_data
                 )
 
@@ -267,8 +358,8 @@ class EnhancedRetryHandler:
                     delay = self._calculate_backoff(attempt)
                     await asyncio.sleep(delay)
 
-                context['duration'] = current_duration
-                last_exception = self.error_handler.handle_error(e, context)
+                # 保存异常，以备后续使用
+                last_exception = e
 
             except Exception as e:
                 # 非 gRPC 错误，直接包装抛出
@@ -280,7 +371,11 @@ class EnhancedRetryHandler:
 
         # 抛出最后的异常
         if last_exception:
-            raise last_exception
+            if isinstance(last_exception, TamarModelException):
+                raise last_exception
+            else:
+                # 对于原始的 gRPC 异常，需要包装
+                raise self.error_handler.handle_error(last_exception, context)
         else:
             raise TamarModelException("Unknown error occurred")
 

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

@@ -31,6 +31,7 @@ import grpc
 from .core import (
     generate_request_id,
     set_request_id,
+    set_origin_request_id,
     get_protected_logger,
     MAX_MESSAGE_LENGTH, 
     get_request_id,
@@ -158,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": {
@@ -186,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)",
@@ -237,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
@@ -245,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
@@ -253,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
@@ -269,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"})
                     
             # 清空引用
@@ -283,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):
@@ -311,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": {
@@ -352,20 +353,15 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             except grpc.RpcError as e:
                 # 使用新的错误处理逻辑
                 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:
-                    # 不可重试或已达到最大重试次数
-                    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
                 
-                # 特殊处理 CANCELLED 错误
+                # 记录 channel 错误
+                self._record_channel_error(e)
+                
+                # 特殊处理 CANCELLED 错误的日志
                 if e.code() == grpc.StatusCode.CANCELLED:
                     channel_state = None
                     if self.channel:
@@ -375,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'),
@@ -389,20 +385,125 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                         }
                     )
                 
-                # 记录重试日志
+                # 检查是否应该尝试快速降级
+                should_try_fallback = self._should_try_fallback(e.code(), attempt)
+                
+                if should_try_fallback:
+                    # 尝试快速降级到HTTP
+                    logger.warning(
+                        f"🚀 Fast fallback triggered for {e.code().name} after {attempt + 1} attempts",
+                        extra={
+                            "log_type": "fast_fallback",
+                            "request_id": context.get('request_id'),
+                            "data": {
+                                "error_code": e.code().name,
+                                "attempt": attempt,
+                                "fallback_reason": "immediate" if e.code() in self.immediate_fallback_errors else "after_retries"
+                            }
+                        }
+                    )
+                    
+                    try:
+                        # 从 kwargs 中提取降级所需的参数
+                        fallback_kwargs = kwargs.copy()
+                        
+                        # 如果是 _invoke_request，需要提取 model_request
+                        if func.__name__ == '_invoke_request' and len(args) >= 3:
+                            # args 结构: (request, metadata, invoke_timeout)
+                            # 需要从原始参数中恢复 model_request
+                            if hasattr(self, '_current_model_request'):
+                                model_request = self._current_model_request
+                                origin_request_id = getattr(self, '_current_origin_request_id', None)
+                                timeout = args[2] if len(args) > 2 else None
+                                request_id = context.get('request_id')
+                                
+                                # 尝试HTTP降级
+                                result = self._invoke_http_fallback(model_request, timeout, request_id, origin_request_id)
+                        # 如果是 BatchInvoke，需要使用批量降级
+                        elif func.__name__ == 'BatchInvoke' and hasattr(self, '_current_batch_request'):
+                            batch_request = self._current_batch_request
+                            origin_request_id = getattr(self, '_current_origin_request_id', None)
+                            timeout = fallback_kwargs.get('timeout')
+                            request_id = context.get('request_id')
+                            
+                            # 尝试批量HTTP降级
+                            result = self._invoke_batch_http_fallback(batch_request, timeout, request_id, origin_request_id)
+                        else:
+                            # 其他情况，无法处理降级
+                            raise ValueError(f"Unable to perform HTTP fallback for {func.__name__}")
+                                
+                        logger.info(
+                            f"✅ Fast fallback to HTTP succeeded",
+                            extra={
+                                "log_type": "fast_fallback_success",
+                                "request_id": request_id,
+                                "data": {
+                                    "grpc_attempts": attempt + 1,
+                                    "fallback_duration": time.time() - method_start_time
+                                }
+                            }
+                        )
+                        
+                        return result
+                    except Exception as fallback_error:
+                        # 降级失败，记录日志但继续原有重试逻辑
+                        logger.warning(
+                            f"⚠️ Fast fallback to HTTP failed: {str(fallback_error)}",
+                            extra={
+                                "log_type": "fast_fallback_failed",
+                                "request_id": context.get('request_id'),
+                                "data": {
+                                    "fallback_error": str(fallback_error),
+                                    "will_continue_grpc_retry": should_retry and attempt < self.max_retries
+                                }
+                            }
+                        )
+                
+                if not should_retry or attempt >= self.max_retries:
+                    # 不可重试或已达到最大重试次数
+                    context['duration'] = current_duration
+                    
+                    # 记录最终失败日志
+                    log_data = {
+                        "log_type": "info",
+                        "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'),
+                            "final_failure": True
+                        },
+                        "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()}{error_detail} (no more retries)",
+                        extra=log_data
+                    )
+                    
+                    last_exception = self.error_handler.handle_error(e, context)
+                    break
+                
+                # 可以重试，记录重试日志
                 log_data = {
                     "log_type": "info",
                     "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')
+                        "method": context.get('method', 'unknown'),
+                        "will_retry": True,
+                        "fallback_attempted": should_try_fallback
                     },
                     "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()}",
+                    f"🔄 Attempt {attempt + 1}/{self.max_retries + 1} failed: {e.code()}{error_detail} (will retry)",
                     extra=log_data
                 )
 
@@ -410,12 +511,9 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                 if attempt < self.max_retries:
                     delay = self._calculate_backoff(attempt, e.code())
                     time.sleep(delay)
-
-                context['duration'] = current_duration
-                last_exception = self.error_handler.handle_error(e, context)
                 
-                # 记录 channel 错误
-                self._record_channel_error(e)
+                # 保存异常，以备后续使用
+                last_exception = e
 
             except Exception as e:
                 # 非 gRPC 错误，直接包装抛出
@@ -589,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",
@@ -596,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
@@ -610,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
                 )
                 
@@ -803,7 +905,12 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         if self.resilient_enabled and self.circuit_breaker and self.circuit_breaker.is_open:
             if self.http_fallback_url:
                 logger.warning("🔻 Circuit breaker is OPEN, using HTTP fallback")
-                return self._invoke_http_fallback(model_request, timeout, request_id)
+                # 在这里还没有计算origin_request_id，所以先计算
+                temp_origin_request_id = None
+                temp_request_id = request_id
+                if request_id:
+                    temp_request_id, temp_origin_request_id = self._request_id_manager.get_composite_id(request_id)
+                return self._invoke_http_fallback(model_request, timeout, temp_request_id, temp_origin_request_id)
                 
         self._ensure_initialized()
 
@@ -823,6 +930,8 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             request_id = generate_request_id()
             
         set_request_id(request_id)
+        if origin_request_id:
+            set_origin_request_id(origin_request_id)
         metadata = self._build_auth_metadata(request_id, origin_request_id)
 
         # 构建日志数据
@@ -874,7 +983,17 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                     request_id=request_id
                 )
             else:
-                result = self._retry_request(self._invoke_request, request, metadata, invoke_timeout, request_id=request_id)
+                # 存储model_request和origin_request_id供重试方法使用
+                self._current_model_request = model_request
+                self._current_origin_request_id = origin_request_id
+                try:
+                    result = self._retry_request(self._invoke_request, request, metadata, invoke_timeout, request_id=request_id)
+                finally:
+                    # 清理临时存储
+                    if hasattr(self, '_current_model_request'):
+                        delattr(self, '_current_model_request')
+                    if hasattr(self, '_current_origin_request_id'):
+                        delattr(self, '_current_origin_request_id')
 
                 # 记录非流式响应的成功日志
                 duration = time.time() - start_time
@@ -922,16 +1041,11 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             if isinstance(e, grpc.RpcError):
                 self._record_channel_error(e)
             
-            # 记录失败并尝试降级（如果启用了熔断）
+            # 记录失败（如果启用了熔断）
             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)
-                
-                # 如果可以降级，则降级
-                if self.http_fallback_url and self.circuit_breaker.should_fallback():
-                    logger.warning(f"🔻 gRPC failed, falling back to HTTP: {str(e)}")
-                    return self._invoke_http_fallback(model_request, timeout, request_id)
             
             raise e
         except Exception as e:
@@ -961,6 +1075,17 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         Returns:
             BatchModelResponse: 批量请求的结果
         """
+        # 如果启用了熔断且熔断器打开，直接走 HTTP
+        if self.resilient_enabled and self.circuit_breaker and self.circuit_breaker.is_open:
+            if self.http_fallback_url:
+                logger.warning("🔻 Circuit breaker is OPEN, using HTTP fallback for batch request")
+                # 在这里还没有计算origin_request_id，所以先计算
+                temp_origin_request_id = None
+                temp_request_id = request_id
+                if request_id:
+                    temp_request_id, temp_origin_request_id = self._request_id_manager.get_composite_id(request_id)
+                return self._invoke_batch_http_fallback(batch_request_model, timeout, temp_request_id, temp_origin_request_id)
+                
         self._ensure_initialized()
 
         if not self.default_payload:
@@ -979,6 +1104,8 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             request_id = generate_request_id()
             
         set_request_id(request_id)
+        if origin_request_id:
+            set_origin_request_id(origin_request_id)
         metadata = self._build_auth_metadata(request_id, origin_request_id)
 
         # 构建日志数据
@@ -1025,6 +1152,11 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
 
         try:
             invoke_timeout = timeout or self.default_invoke_timeout
+            
+            # 保存批量请求信息用于降级
+            self._current_batch_request = batch_request_model
+            self._current_origin_request_id = origin_request_id
+            
             batch_response = self._retry_request(
                 self.stub.BatchInvoke,
                 batch_request,
@@ -1067,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