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

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
                 )
                 
@@ -734,14 +742,16 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         else:
             raise TamarModelException("Unknown streaming error occurred")
 
-    def _stream(self, request, metadata, invoke_timeout) -> Iterator[ModelResponse]:
+    def _stream(self, request, metadata, invoke_timeout, request_id=None, origin_request_id=None) -> Iterator[ModelResponse]:
         """
         处理流式响应
         
         Args:
             request: gRPC 请求对象
-            metadata: 请求元数据
+            metadata: 请求元数据（为了兼容性保留，但会被忽略）
             invoke_timeout: 总体超时时间
+            request_id: 请求ID
+            origin_request_id: 原始请求ID
             
         Yields:
             ModelResponse: 流式响应的每个数据块
@@ -749,6 +759,11 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         Raises:
             TimeoutError: 当等待下一个数据块超时时
         """
+        # 每次调用时重新生成metadata，确保JWT token是最新的
+        fresh_metadata = self._build_auth_metadata(
+            request_id or get_request_id(), 
+            origin_request_id
+        )
         import threading
         import queue
         
@@ -759,7 +774,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         def fetch_responses():
             """在单独线程中获取流式响应"""
             try:
-                for response in self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout):
+                for response in self.stub.Invoke(request, metadata=fresh_metadata, timeout=invoke_timeout):
                     response_queue.put(response)
                 response_queue.put(None)  # 标记流结束
             except Exception as e:
@@ -791,7 +806,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             except queue.Empty:
                 raise TimeoutError(f"流式响应在等待下一个数据块时超时 ({chunk_timeout}s)")
 
-    def _stream_with_logging(self, request, metadata, invoke_timeout, start_time, model_request) -> Iterator[
+    def _stream_with_logging(self, request, metadata, invoke_timeout, start_time, model_request, request_id=None, origin_request_id=None) -> Iterator[
         ModelResponse]:
         """流式响应的包装器，用于记录完整的响应日志并处理重试"""
         total_content = ""
@@ -800,7 +815,7 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
         chunk_count = 0
 
         try:
-            for response in self._stream(request, metadata, invoke_timeout):
+            for response in self._stream(request, metadata, invoke_timeout, request_id, origin_request_id):
                 chunk_count += 1
                 if response.content:
                     total_content += response.content
@@ -871,9 +886,22 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
             )
             raise
 
-    def _invoke_request(self, request, metadata, invoke_timeout):
-        """执行单个非流式请求"""
-        response = self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout)
+    def _invoke_request(self, request, metadata, invoke_timeout, request_id=None, origin_request_id=None):
+        """执行单个非流式请求
+        
+        Args:
+            request: gRPC请求对象
+            metadata: 请求元数据（为了兼容性保留，但会被忽略）
+            invoke_timeout: 请求超时时间
+            request_id: 请求ID
+            origin_request_id: 原始请求ID
+        """
+        # 每次调用时重新生成metadata，确保JWT token是最新的
+        fresh_metadata = self._build_auth_metadata(
+            request_id or get_request_id(), 
+            origin_request_id
+        )
+        response = self.stub.Invoke(request, metadata=fresh_metadata, timeout=invoke_timeout)
         for response in response:
             return ResponseHandler.build_model_response(response)
 
@@ -972,14 +1000,14 @@ class TamarModelClient(BaseClient, HttpFallbackMixin):
                 return self._retry_request_stream(
                     self._stream_with_logging,
                     request, metadata, invoke_timeout, start_time, model_request,
-                    request_id=request_id
+                    request_id=request_id, origin_request_id=origin_request_id
                 )
             else:
                 # 存储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)
+                    result = self._retry_request(self._invoke_request, request, metadata, invoke_timeout, request_id=request_id, origin_request_id=origin_request_id)
                 finally:
                     # 清理临时存储
                     if hasattr(self, '_current_model_request'):
@@ -1191,6 +1219,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