tamar-model-client 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

tamar_model_client/__init__.py

@@ -1,6 +1,8 @@
 from .sync_client import TamarModelClient
 from .async_client import AsyncTamarModelClient
 from .exceptions import ModelManagerClientError, ConnectionError, ValidationError
+from .json_formatter import JSONFormatter
+from . import logging_icons
 
 __all__ = [
     "TamarModelClient",
@@ -8,4 +10,6 @@ __all__ = [
     "ModelManagerClientError",
     "ConnectionError",
     "ValidationError",
+    "JSONFormatter",
+    "logging_icons",
 ]

tamar_model_client/async_client.py

@@ -4,6 +4,7 @@ import base64
 import json
 import logging
 import os
+import time
 import uuid
 from contextvars import ContextVar
 
@@ -20,6 +21,7 @@ from .schemas import ModelRequest, ModelResponse, BatchModelRequest, BatchModelR
 from .generated import model_service_pb2, model_service_pb2_grpc
 from .schemas.inputs import GoogleGenAiInput, OpenAIResponsesInput, OpenAIChatCompletionsInput, \
     GoogleVertexAIImagesInput, OpenAIImagesInput, OpenAIImagesEditInput
+from .json_formatter import JSONFormatter
 
 logger = logging.getLogger(__name__)
 
@@ -40,8 +42,8 @@ if not logger.hasHandlers():
     # 创建日志处理器，输出到控制台
     console_handler = logging.StreamHandler()
 
-    # 设置日志格式
-    formatter = logging.Formatter('%(asctime)s [%(levelname)s] [%(request_id)s] %(message)s')
+    # 使用 JSON 格式化器
+    formatter = JSONFormatter()
     console_handler.setFormatter(formatter)
 
     # 为当前记录器添加处理器
@@ -181,26 +183,31 @@ class AsyncTamarModelClient:
                 # 对于取消的情况进行指数退避重试
                 if isinstance(e, grpc.aio.AioRpcError) and e.code() == grpc.StatusCode.CANCELLED:
                     retry_count += 1
-                    logger.warning(f"❌ RPC cancelled, retrying {retry_count}/{self.max_retries}...")
+                    logger.warning(f"⚠️ RPC cancelled, retrying {retry_count}/{self.max_retries}...",
+                                 extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "error_code": "CANCELLED"}})
                     if retry_count < self.max_retries:
                         delay = self.retry_delay * (2 ** (retry_count - 1))
                         await asyncio.sleep(delay)
                     else:
-                        logger.error("❌ Max retry reached for CANCELLED")
+                        logger.error("❌ Max retry reached for CANCELLED",
+                                   extra={"log_type": "info", "data": {"error_code": "CANCELLED", "max_retries_reached": True}})
                         raise
                 # 针对其他 RPC 错误类型，如暂时的连接问题、服务器超时等
                 elif isinstance(e, grpc.RpcError) and e.code() in {grpc.StatusCode.UNAVAILABLE,
                                                                    grpc.StatusCode.DEADLINE_EXCEEDED}:
                     retry_count += 1
-                    logger.warning(f"❌ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...")
+                    logger.warning(f"⚠️ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...",
+                                 extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "error_code": str(e.code())}})
                     if retry_count < self.max_retries:
                         delay = self.retry_delay * (2 ** (retry_count - 1))
                         await asyncio.sleep(delay)
                     else:
-                        logger.error(f"❌ Max retry reached for {e.code()}")
+                        logger.error(f"❌ Max retry reached for {e.code()}",
+                                   extra={"log_type": "info", "data": {"error_code": str(e.code()), "max_retries_reached": True}})
                         raise
                 else:
-                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True)
+                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True,
+                               extra={"log_type": "info", "data": {"error_code": str(e.code()) if hasattr(e, 'code') else None, "retryable": False}})
                     raise
 
     async def _retry_request_stream(self, func, *args, **kwargs):
@@ -212,26 +219,31 @@ class AsyncTamarModelClient:
                 # 对于取消的情况进行指数退避重试
                 if isinstance(e, grpc.aio.AioRpcError) and e.code() == grpc.StatusCode.CANCELLED:
                     retry_count += 1
-                    logger.warning(f"❌ RPC cancelled, retrying {retry_count}/{self.max_retries}...")
+                    logger.warning(f"⚠️ RPC cancelled, retrying {retry_count}/{self.max_retries}...",
+                                 extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "error_code": "CANCELLED"}})
                     if retry_count < self.max_retries:
                         delay = self.retry_delay * (2 ** (retry_count - 1))
                         await asyncio.sleep(delay)
                     else:
-                        logger.error("❌ Max retry reached for CANCELLED")
+                        logger.error("❌ Max retry reached for CANCELLED",
+                                   extra={"log_type": "info", "data": {"error_code": "CANCELLED", "max_retries_reached": True}})
                         raise
                 # 针对其他 RPC 错误类型，如暂时的连接问题、服务器超时等
                 elif isinstance(e, grpc.RpcError) and e.code() in {grpc.StatusCode.UNAVAILABLE,
                                                                    grpc.StatusCode.DEADLINE_EXCEEDED}:
                     retry_count += 1
-                    logger.warning(f"❌ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...")
+                    logger.warning(f"⚠️ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...",
+                                 extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "error_code": str(e.code())}})
                     if retry_count < self.max_retries:
                         delay = self.retry_delay * (2 ** (retry_count - 1))
                         await asyncio.sleep(delay)
                     else:
-                        logger.error(f"❌ Max retry reached for {e.code()}")
+                        logger.error(f"❌ Max retry reached for {e.code()}",
+                                   extra={"log_type": "info", "data": {"error_code": str(e.code()), "max_retries_reached": True}})
                         raise
                 else:
-                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True)
+                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True,
+                               extra={"log_type": "info", "data": {"error_code": str(e.code()) if hasattr(e, 'code') else None, "retryable": False}})
                     raise
 
     def _build_auth_metadata(self, request_id: str) -> list:
@@ -266,32 +278,40 @@ class AsyncTamarModelClient:
                         credentials,
                         options=options
                     )
-                    logger.info("🔐 Using secure gRPC channel (TLS enabled)")
+                    logger.info("🔐 Using secure gRPC channel (TLS enabled)",
+                              extra={"log_type": "info", "data": {"tls_enabled": True, "server_address": self.server_address}})
                 else:
                     self.channel = grpc.aio.insecure_channel(
                         self.server_address,
                         options=options
                     )
-                    logger.info("🔓 Using insecure gRPC channel (TLS disabled)")
+                    logger.info("🔓 Using insecure gRPC channel (TLS disabled)",
+                              extra={"log_type": "info", "data": {"tls_enabled": False, "server_address": self.server_address}})
                 await self.channel.channel_ready()
                 self.stub = model_service_pb2_grpc.ModelServiceStub(self.channel)
-                logger.info(f"✅ gRPC channel initialized to {self.server_address}")
+                logger.info(f"✅ gRPC channel initialized to {self.server_address}",
+                          extra={"log_type": "info", "data": {"status": "success", "server_address": self.server_address}})
                 return
             except grpc.FutureTimeoutError as e:
-                logger.error(f"❌ gRPC channel initialization timed out: {str(e)}", exc_info=True)
+                logger.error(f"❌ gRPC channel initialization timed out: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "timeout", "server_address": self.server_address}})
             except grpc.RpcError as e:
-                logger.error(f"❌ gRPC channel initialization failed: {str(e)}", exc_info=True)
+                logger.error(f"❌ gRPC channel initialization failed: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "rpc_error", "server_address": self.server_address}})
             except Exception as e:
-                logger.error(f"❌ Unexpected error during channel initialization: {str(e)}", exc_info=True)
+                logger.error(f"❌ Unexpected error during channel initialization: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "unexpected", "server_address": self.server_address}})
 
             retry_count += 1
             if retry_count > self.max_retries:
-                logger.error(f"❌ Failed to initialize gRPC channel after {self.max_retries} retries.", exc_info=True)
+                logger.error(f"❌ Failed to initialize gRPC channel after {self.max_retries} retries.", exc_info=True,
+                           extra={"log_type": "info", "data": {"max_retries_reached": True, "server_address": self.server_address}})
                 raise ConnectionError(f"❌ Failed to initialize gRPC channel after {self.max_retries} retries.")
 
             # 指数退避：延迟时间 = retry_delay * (2 ^ (retry_count - 1))
             delay = self.retry_delay * (2 ** (retry_count - 1))
-            logger.info(f"🚀 Retrying connection (attempt {retry_count}/{self.max_retries}) after {delay:.2f}s delay...")
+            logger.warning(f"🔄 Retrying connection (attempt {retry_count}/{self.max_retries}) after {delay:.2f}s delay...",
+                      extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "delay": delay}})
             await asyncio.sleep(delay)
 
     async def _stream(self, request, metadata, invoke_timeout) -> AsyncIterator[ModelResponse]:
@@ -303,6 +323,66 @@ class AsyncTamarModelClient:
                 raw_response=json.loads(response.raw_response) if response.raw_response else None,
                 request_id=response.request_id if response.request_id else None,
             )
+    
+    async def _stream_with_logging(self, request, metadata, invoke_timeout, start_time, model_request) -> AsyncIterator[ModelResponse]:
+        """流式响应的包装器，用于记录完整的响应日志"""
+        total_content = ""
+        final_usage = None
+        error_occurred = None
+        chunk_count = 0
+        
+        try:
+            async for response in self._stream(request, metadata, invoke_timeout):
+                chunk_count += 1
+                if response.content:
+                    total_content += response.content
+                if response.usage:
+                    final_usage = response.usage
+                if response.error:
+                    error_occurred = response.error
+                yield response
+            
+            # 流式响应完成，记录成功日志
+            duration = time.time() - start_time
+            logger.info(
+                f"✅ Stream completed successfully | chunks: {chunk_count}",
+                extra={
+                    "log_type": "response",
+                    "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                    "duration": duration,
+                    "data": {
+                        "provider": model_request.provider.value,
+                        "invoke_type": model_request.invoke_type.value,
+                        "model": model_request.model,
+                        "stream": True,
+                        "chunks_count": chunk_count,
+                        "total_length": len(total_content),
+                        "usage": final_usage
+                    }
+                }
+            )
+        except Exception as e:
+            # 流式响应出错，记录错误日志
+            duration = time.time() - start_time
+            logger.error(
+                f"❌ Stream failed after {chunk_count} chunks: {str(e)}",
+                exc_info=True,
+                extra={
+                    "log_type": "response",
+                    "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                    "duration": duration,
+                    "data": {
+                        "provider": model_request.provider.value,
+                        "invoke_type": model_request.invoke_type.value,
+                        "model": model_request.model,
+                        "stream": True,
+                        "chunks_count": chunk_count,
+                        "error_type": type(e).__name__,
+                        "partial_content_length": len(total_content)
+                    }
+                }
+            )
+            raise
 
     async def _invoke_request(self, request, metadata, invoke_timeout):
         async for response in self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout):
@@ -345,8 +425,22 @@ class AsyncTamarModelClient:
         metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
 
         # 记录开始日志
+        start_time = time.time()
         logger.info(
-            f"🔵 Request Start | request_id: {request_id} | provider: {model_request.provider} | invoke_type: {model_request.invoke_type}")
+            f"🔵 Request Start | request_id: {request_id} | provider: {model_request.provider} | invoke_type: {model_request.invoke_type}",
+            extra={
+                "log_type": "request",
+                "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                "data": {
+                    "provider": model_request.provider.value,
+                    "invoke_type": model_request.invoke_type.value,
+                    "model": model_request.model,
+                    "stream": model_request.stream,
+                    "org_id": model_request.user_context.org_id,
+                    "user_id": model_request.user_context.user_id,
+                    "client_type": model_request.user_context.client_type
+                }
+            })
 
         # 动态根据 provider/invoke_type 决定使用哪个 input 字段
         try:
@@ -404,16 +498,63 @@ class AsyncTamarModelClient:
         try:
             invoke_timeout = timeout or self.default_invoke_timeout
             if model_request.stream:
-                return await self._retry_request_stream(self._stream, request, metadata, invoke_timeout)
+                # 对于流式响应，使用带日志记录的包装器
+                stream_generator = await self._retry_request_stream(self._stream, request, metadata, invoke_timeout)
+                return self._stream_with_logging(request, metadata, invoke_timeout, start_time, model_request)
             else:
-                return await self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
+                result = await self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
+                
+                # 记录非流式响应的成功日志
+                duration = time.time() - start_time
+                logger.info(
+                    f"✅ Request completed successfully",
+                    extra={
+                        "log_type": "response",
+                        "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                        "duration": duration,
+                        "data": {
+                            "provider": model_request.provider.value,
+                            "invoke_type": model_request.invoke_type.value,
+                            "model": model_request.model,
+                            "stream": False,
+                            "content_length": len(result.content) if result.content else 0,
+                            "usage": result.usage
+                        }
+                    }
+                )
+                return result
         except grpc.RpcError as e:
+            duration = time.time() - start_time
             error_message = f"❌ Invoke gRPC failed: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "grpc_error",
+                               "error_code": str(e.code()) if hasattr(e, 'code') else None,
+                               "provider": model_request.provider.value,
+                               "invoke_type": model_request.invoke_type.value,
+                               "model": model_request.model
+                           }
+                       })
             raise e
         except Exception as e:
+            duration = time.time() - start_time
             error_message = f"❌ Invoke other error: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "other_error",
+                               "provider": model_request.provider.value,
+                               "invoke_type": model_request.invoke_type.value,
+                               "model": model_request.model
+                           }
+                       })
             raise e
 
     async def invoke_batch(self, batch_request_model: BatchModelRequest, timeout: Optional[float] = None,
@@ -444,8 +585,19 @@ class AsyncTamarModelClient:
         metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
 
         # 记录开始日志
+        start_time = time.time()
         logger.info(
-            f"🔵 Batch Request Start | request_id: {request_id} | batch_size: {len(batch_request_model.items)}")
+            f"🔵 Batch Request Start | request_id: {request_id} | batch_size: {len(batch_request_model.items)}",
+            extra={
+                "log_type": "request",
+                "uri": "/batch_invoke",
+                "data": {
+                    "batch_size": len(batch_request_model.items),
+                    "org_id": batch_request_model.user_context.org_id,
+                    "user_id": batch_request_model.user_context.user_id,
+                    "client_type": batch_request_model.user_context.client_type
+                }
+            })
 
         # 构造批量请求
         items = []
@@ -520,17 +672,54 @@ class AsyncTamarModelClient:
                     error=res_item.error or None,
                     custom_id=res_item.custom_id if res_item.custom_id else None
                 ))
-            return BatchModelResponse(
+            batch_response = BatchModelResponse(
                 request_id=response.request_id if response.request_id else None,
                 responses=result
             )
+            
+            # 记录成功日志
+            duration = time.time() - start_time
+            logger.info(
+                f"✅ Batch request completed successfully",
+                extra={
+                    "log_type": "response",
+                    "uri": "/batch_invoke",
+                    "duration": duration,
+                    "data": {
+                        "batch_size": len(batch_request_model.items),
+                        "responses_count": len(result)
+                    }
+                }
+            )
+            return batch_response
         except grpc.RpcError as e:
+            duration = time.time() - start_time
             error_message = f"❌ BatchInvoke gRPC failed: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": "/batch_invoke",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "grpc_error",
+                               "error_code": str(e.code()) if hasattr(e, 'code') else None,
+                               "batch_size": len(batch_request_model.items)
+                           }
+                       })
             raise e
         except Exception as e:
+            duration = time.time() - start_time
             error_message = f"❌ BatchInvoke other error: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": "/batch_invoke",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "other_error",
+                               "batch_size": len(batch_request_model.items)
+                           }
+                       })
             raise e
 
     async def close(self):
@@ -538,7 +727,8 @@ class AsyncTamarModelClient:
         if self.channel and not self._closed:
             await self.channel.close()
             self._closed = True
-            logger.info("✅ gRPC channel closed")
+            logger.info("✅ gRPC channel closed",
+                      extra={"log_type": "info", "data": {"status": "success"}})
 
     def _safe_sync_close(self):
         """进程退出时自动关闭 channel（事件循环处理兼容）"""
@@ -550,7 +740,8 @@ class AsyncTamarModelClient:
                 else:
                     loop.run_until_complete(self.close())
             except Exception as e:
-                logger.warning(f"❌ gRPC channel close failed at exit: {e}")
+                logger.warning(f"⚠️ gRPC channel close failed at exit: {e}",
+                             extra={"log_type": "info", "data": {"status": "failed", "error": str(e)}})
 
     async def __aenter__(self):
         """支持 async with 自动初始化连接"""

tamar_model_client/json_formatter.py

@@ -0,0 +1,26 @@
+import json
+import logging
+from datetime import datetime
+
+
+class JSONFormatter(logging.Formatter):
+    def format(self, record):
+        # log_type 只能是 request、response 或 info
+        log_type = getattr(record, "log_type", "info")
+        if log_type not in ["request", "response", "info"]:
+            log_type = "info"
+            
+        log_data = {
+            "timestamp": datetime.fromtimestamp(record.created).isoformat(),
+            "level": record.levelname,
+            "type": log_type,
+            "uri": getattr(record, "uri", None),
+            "request_id": getattr(record, "request_id", None),
+            "data": getattr(record, "data", None),
+            "message": record.getMessage(),
+            "duration": getattr(record, "duration", None),
+        }
+        # 增加 trace 支持
+        if hasattr(record, "trace"):
+            log_data["trace"] = getattr(record, "trace")
+        return json.dumps(log_data, ensure_ascii=False)

tamar_model_client/logging_icons.py

@@ -0,0 +1,60 @@
+"""
+日志图标规范
+
+本模块定义了统一的日志图标标准，确保整个项目中日志消息的视觉一致性。
+"""
+
+# 请求生命周期图标
+REQUEST_START = "🔵"      # 请求开始
+RESPONSE_SUCCESS = "✅"   # 响应成功
+RESPONSE_ERROR = "❌"     # 响应错误
+
+# 连接和网络图标
+SECURE_CONNECTION = "🔐"  # 安全连接 (TLS)
+INSECURE_CONNECTION = "🔓"  # 不安全连接 (无TLS)
+CONNECTION_SUCCESS = "✅"  # 连接成功
+CONNECTION_RETRY = "🔄"   # 连接重试
+CONNECTION_ERROR = "❌"   # 连接错误
+
+# 操作状态图标
+SUCCESS = "✅"           # 成功
+ERROR = "❌"             # 错误
+WARNING = "⚠️"           # 警告
+INFO = "ℹ️"              # 信息
+RETRY = "🔄"             # 重试
+PROCESSING = "⚙️"        # 处理中
+
+# 流式响应图标
+STREAM_SUCCESS = "✅"     # 流完成
+STREAM_ERROR = "❌"       # 流错误
+STREAM_CHUNK = "📦"       # 流数据块
+
+# 批量操作图标
+BATCH_START = "🔵"        # 批量开始
+BATCH_SUCCESS = "✅"      # 批量成功
+BATCH_ERROR = "❌"        # 批量错误
+
+# 系统操作图标
+INIT = "🚀"              # 初始化
+CLOSE = "🔚"             # 关闭
+CLEANUP = "🧹"           # 清理
+
+def get_icon_for_log_type(log_type: str, is_success: bool = True) -> str:
+    """
+    根据日志类型和状态获取合适的图标
+    
+    Args:
+        log_type: 日志类型 (request, response, info)
+        is_success: 是否成功
+    
+    Returns:
+        对应的图标字符串
+    """
+    if log_type == "request":
+        return REQUEST_START
+    elif log_type == "response":
+        return RESPONSE_SUCCESS if is_success else RESPONSE_ERROR
+    elif log_type == "info":
+        return INFO if is_success else WARNING
+    else:
+        return INFO

tamar_model_client/sync_client.py

@@ -18,6 +18,7 @@ from .generated import model_service_pb2, model_service_pb2_grpc
 from .schemas import BatchModelResponse, ModelResponse
 from .schemas.inputs import GoogleGenAiInput, GoogleVertexAIImagesInput, OpenAIResponsesInput, \
     OpenAIChatCompletionsInput, OpenAIImagesInput, OpenAIImagesEditInput, BatchModelRequest, ModelRequest
+from .json_formatter import JSONFormatter
 
 logger = logging.getLogger(__name__)
 
@@ -37,8 +38,8 @@ if not logger.hasHandlers():
     # 创建日志处理器，输出到控制台
     console_handler = logging.StreamHandler()
 
-    # 设置日志格式
-    formatter = logging.Formatter('%(asctime)s [%(levelname)s] [%(request_id)s] %(message)s')
+    # 使用 JSON 格式化器
+    formatter = JSONFormatter()
     console_handler.setFormatter(formatter)
 
     # 为当前记录器添加处理器
@@ -175,15 +176,18 @@ class TamarModelClient:
             except (grpc.RpcError) as e:
                 if e.code() in {grpc.StatusCode.UNAVAILABLE, grpc.StatusCode.DEADLINE_EXCEEDED}:
                     retry_count += 1
-                    logger.error(f"❌ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...")
+                    logger.warning(f"⚠️ gRPC error {e.code()}, retrying {retry_count}/{self.max_retries}...",
+                                 extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "error_code": str(e.code())}})
                     if retry_count < self.max_retries:
                         delay = self.retry_delay * (2 ** (retry_count - 1))
                         time.sleep(delay)
                     else:
-                        logger.error(f"❌ Max retry reached for {e.code()}")
+                        logger.error(f"❌ Max retry reached for {e.code()}",
+                                   extra={"log_type": "info", "data": {"error_code": str(e.code()), "max_retries_reached": True}})
                         raise
                 else:
-                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True)
+                    logger.error(f"❌ Non-retryable gRPC error: {e}", exc_info=True,
+                               extra={"log_type": "info", "data": {"error_code": str(e.code()) if hasattr(e, 'code') else None, "retryable": False}})
                     raise
 
     def _build_auth_metadata(self, request_id: str) -> list:
@@ -216,35 +220,43 @@ class TamarModelClient:
                         credentials,
                         options=options
                     )
-                    logger.info("🔐 Using secure gRPC channel (TLS enabled)")
+                    logger.info("🔐 Using secure gRPC channel (TLS enabled)",
+                              extra={"log_type": "info", "data": {"tls_enabled": True, "server_address": self.server_address}})
                 else:
                     self.channel = grpc.insecure_channel(
                         self.server_address,
                         options=options
                     )
-                    logger.info("🔓 Using insecure gRPC channel (TLS disabled)")
+                    logger.info("🔓 Using insecure gRPC channel (TLS disabled)",
+                              extra={"log_type": "info", "data": {"tls_enabled": False, "server_address": self.server_address}})
 
                 # Wait for the channel to be ready (synchronously)
                 grpc.channel_ready_future(self.channel).result()  # This is blocking in sync mode
 
                 self.stub = model_service_pb2_grpc.ModelServiceStub(self.channel)
-                logger.info(f"✅ gRPC channel initialized to {self.server_address}")
+                logger.info(f"✅ gRPC channel initialized to {self.server_address}",
+                          extra={"log_type": "info", "data": {"status": "success", "server_address": self.server_address}})
                 return
             except grpc.FutureTimeoutError as e:
-                logger.error(f"❌ gRPC channel initialization timed out: {str(e)}", exc_info=True)
+                logger.error(f"❌ gRPC channel initialization timed out: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "timeout", "server_address": self.server_address}})
             except grpc.RpcError as e:
-                logger.error(f"❌ gRPC channel initialization failed: {str(e)}", exc_info=True)
+                logger.error(f"❌ gRPC channel initialization failed: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "rpc_error", "server_address": self.server_address}})
             except Exception as e:
-                logger.error(f"❌ Unexpected error during channel initialization: {str(e)}", exc_info=True)
+                logger.error(f"❌ Unexpected error during channel initialization: {str(e)}", exc_info=True,
+                           extra={"log_type": "info", "data": {"error_type": "unexpected", "server_address": self.server_address}})
 
             retry_count += 1
             if retry_count > self.max_retries:
-                logger.error(f"❌ Failed to initialize gRPC channel after {self.max_retries} retries.", exc_info=True)
+                logger.error(f"❌ Failed to initialize gRPC channel after {self.max_retries} retries.", exc_info=True,
+                           extra={"log_type": "info", "data": {"max_retries_reached": True, "server_address": self.server_address}})
                 raise ConnectionError(f"❌ Failed to initialize gRPC channel after {self.max_retries} retries.")
 
             # 指数退避：延迟时间 = retry_delay * (2 ^ (retry_count - 1))
             delay = self.retry_delay * (2 ** (retry_count - 1))
-            logger.info(f"🚀 Retrying connection (attempt {retry_count}/{self.max_retries}) after {delay:.2f}s delay...")
+            logger.warning(f"🔄 Retrying connection (attempt {retry_count}/{self.max_retries}) after {delay:.2f}s delay...",
+                      extra={"log_type": "info", "data": {"retry_count": retry_count, "max_retries": self.max_retries, "delay": delay}})
             time.sleep(delay)  # Blocking sleep in sync version
 
     def _stream(self, request, metadata, invoke_timeout) -> Iterator[ModelResponse]:
@@ -256,6 +268,66 @@ class TamarModelClient:
                 raw_response=json.loads(response.raw_response) if response.raw_response else None,
                 request_id=response.request_id if response.request_id else None,
             )
+    
+    def _stream_with_logging(self, request, metadata, invoke_timeout, start_time, model_request) -> Iterator[ModelResponse]:
+        """流式响应的包装器，用于记录完整的响应日志"""
+        total_content = ""
+        final_usage = None
+        error_occurred = None
+        chunk_count = 0
+        
+        try:
+            for response in self._stream(request, metadata, invoke_timeout):
+                chunk_count += 1
+                if response.content:
+                    total_content += response.content
+                if response.usage:
+                    final_usage = response.usage
+                if response.error:
+                    error_occurred = response.error
+                yield response
+            
+            # 流式响应完成，记录成功日志
+            duration = time.time() - start_time
+            logger.info(
+                f"✅ Stream completed successfully | chunks: {chunk_count}",
+                extra={
+                    "log_type": "response",
+                    "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                    "duration": duration,
+                    "data": {
+                        "provider": model_request.provider.value,
+                        "invoke_type": model_request.invoke_type.value,
+                        "model": model_request.model,
+                        "stream": True,
+                        "chunks_count": chunk_count,
+                        "total_length": len(total_content),
+                        "usage": final_usage
+                    }
+                }
+            )
+        except Exception as e:
+            # 流式响应出错，记录错误日志
+            duration = time.time() - start_time
+            logger.error(
+                f"❌ Stream failed after {chunk_count} chunks: {str(e)}",
+                exc_info=True,
+                extra={
+                    "log_type": "response",
+                    "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                    "duration": duration,
+                    "data": {
+                        "provider": model_request.provider.value,
+                        "invoke_type": model_request.invoke_type.value,
+                        "model": model_request.model,
+                        "stream": True,
+                        "chunks_count": chunk_count,
+                        "error_type": type(e).__name__,
+                        "partial_content_length": len(total_content)
+                    }
+                }
+            )
+            raise
 
     def _invoke_request(self, request, metadata, invoke_timeout):
         response = self.stub.Invoke(request, metadata=metadata, timeout=invoke_timeout)
@@ -298,8 +370,22 @@ class TamarModelClient:
         metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
 
         # 记录开始日志
+        start_time = time.time()
         logger.info(
-            f"🔵 Request Start |provider: {model_request.provider} | invoke_type: {model_request.invoke_type}")
+            f"🔵 Request Start | request_id: {request_id} | provider: {model_request.provider} | invoke_type: {model_request.invoke_type}",
+            extra={
+                "log_type": "request",
+                "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                "data": {
+                    "provider": model_request.provider.value,
+                    "invoke_type": model_request.invoke_type.value,
+                    "model": model_request.model,
+                    "stream": model_request.stream,
+                    "org_id": model_request.user_context.org_id,
+                    "user_id": model_request.user_context.user_id,
+                    "client_type": model_request.user_context.client_type
+                }
+            })
 
         # 动态根据 provider/invoke_type 决定使用哪个 input 字段
         try:
@@ -357,16 +443,62 @@ class TamarModelClient:
         try:
             invoke_timeout = timeout or self.default_invoke_timeout
             if model_request.stream:
-                return self._retry_request(self._stream, request, metadata, invoke_timeout)
+                # 对于流式响应，使用带日志记录的包装器
+                return self._stream_with_logging(request, metadata, invoke_timeout, start_time, model_request)
             else:
-                return self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
+                result = self._retry_request(self._invoke_request, request, metadata, invoke_timeout)
+                
+                # 记录非流式响应的成功日志
+                duration = time.time() - start_time
+                logger.info(
+                    f"✅ Request completed successfully",
+                    extra={
+                        "log_type": "response",
+                        "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                        "duration": duration,
+                        "data": {
+                            "provider": model_request.provider.value,
+                            "invoke_type": model_request.invoke_type.value,
+                            "model": model_request.model,
+                            "stream": False,
+                            "content_length": len(result.content) if result.content else 0,
+                            "usage": result.usage
+                        }
+                    }
+                )
+                return result
         except grpc.RpcError as e:
+            duration = time.time() - start_time
             error_message = f"❌ Invoke gRPC failed: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "grpc_error",
+                               "error_code": str(e.code()) if hasattr(e, 'code') else None,
+                               "provider": model_request.provider.value,
+                               "invoke_type": model_request.invoke_type.value,
+                               "model": model_request.model
+                           }
+                       })
             raise e
         except Exception as e:
+            duration = time.time() - start_time
             error_message = f"❌ Invoke other error: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": f"/invoke/{model_request.provider.value}/{model_request.invoke_type.value}",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "other_error",
+                               "provider": model_request.provider.value,
+                               "invoke_type": model_request.invoke_type.value,
+                               "model": model_request.model
+                           }
+                       })
             raise e
 
     def invoke_batch(self, batch_request_model: BatchModelRequest, timeout: Optional[float] = None,
@@ -396,8 +528,19 @@ class TamarModelClient:
         metadata = self._build_auth_metadata(request_id)  # 将 request_id 加入到请求头
 
         # 记录开始日志
+        start_time = time.time()
         logger.info(
-            f"🔵 Batch Request Start | batch_size: {len(batch_request_model.items)}")
+            f"🔵 Batch Request Start | request_id: {request_id} | batch_size: {len(batch_request_model.items)}",
+            extra={
+                "log_type": "request",
+                "uri": "/batch_invoke",
+                "data": {
+                    "batch_size": len(batch_request_model.items),
+                    "org_id": batch_request_model.user_context.org_id,
+                    "user_id": batch_request_model.user_context.user_id,
+                    "client_type": batch_request_model.user_context.client_type
+                }
+            })
 
         # 构造批量请求
         items = []
@@ -472,17 +615,54 @@ class TamarModelClient:
                     error=res_item.error or None,
                     custom_id=res_item.custom_id if res_item.custom_id else None
                 ))
-            return BatchModelResponse(
+            batch_response = BatchModelResponse(
                 request_id=response.request_id if response.request_id else None,
                 responses=result
             )
+            
+            # 记录成功日志
+            duration = time.time() - start_time
+            logger.info(
+                f"✅ Batch request completed successfully",
+                extra={
+                    "log_type": "response",
+                    "uri": "/batch_invoke",
+                    "duration": duration,
+                    "data": {
+                        "batch_size": len(batch_request_model.items),
+                        "responses_count": len(result)
+                    }
+                }
+            )
+            return batch_response
         except grpc.RpcError as e:
+            duration = time.time() - start_time
             error_message = f"❌ BatchInvoke gRPC failed: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": "/batch_invoke",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "grpc_error",
+                               "error_code": str(e.code()) if hasattr(e, 'code') else None,
+                               "batch_size": len(batch_request_model.items)
+                           }
+                       })
             raise e
         except Exception as e:
+            duration = time.time() - start_time
             error_message = f"❌ BatchInvoke other error: {str(e)}"
-            logger.error(error_message, exc_info=True)
+            logger.error(error_message, exc_info=True,
+                       extra={
+                           "log_type": "response",
+                           "uri": "/batch_invoke",
+                           "duration": duration,
+                           "data": {
+                               "error_type": "other_error",
+                               "batch_size": len(batch_request_model.items)
+                           }
+                       })
             raise e
 
     def close(self):
@@ -490,7 +670,8 @@ class TamarModelClient:
         if self.channel and not self._closed:
             self.channel.close()
             self._closed = True
-            logger.info("✅ gRPC channel closed")
+            logger.info("✅ gRPC channel closed",
+                      extra={"log_type": "info", "data": {"status": "success"}})
 
     def _safe_sync_close(self):
         """进程退出时自动关闭 channel（事件循环处理兼容）"""
@@ -498,7 +679,8 @@ class TamarModelClient:
             try:
                 self.close()  # 直接调用关闭方法
             except Exception as e:
-                logger.error(f"❌ gRPC channel close failed at exit: {e}")
+                logger.warning(f"⚠️ gRPC channel close failed at exit: {e}",
+                           extra={"log_type": "info", "data": {"status": "failed", "error": str(e)}})
 
     def __enter__(self):
         """同步初始化连接"""

{tamar_model_client-0.1.17.dist-info → tamar_model_client-0.1.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tamar-model-client
-Version: 0.1.17
+Version: 0.1.19
 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.17.dist-info → tamar_model_client-0.1.19.dist-info}/RECORD

@@ -1,8 +1,10 @@
-tamar_model_client/__init__.py,sha256=LMECAuDARWHV1XzH3msoDXcyurS2eihRQmBy26_PUE0,328
-tamar_model_client/async_client.py,sha256=fTQMLWz7DxW1fynmfUxlS3anmYOxv6giVUGq6ZG4kzk,25972
+tamar_model_client/__init__.py,sha256=4DEIUGlLTeiaECjJQbGYik7C0JO6hHwwfbLYpYpMdzg,444
+tamar_model_client/async_client.py,sha256=PaI0a-hSkp7s99Aib-eL2-Ouh8d3A4E-L6EdSsfeE3w,36843
 tamar_model_client/auth.py,sha256=gbwW5Aakeb49PMbmYvrYlVx1mfyn1LEDJ4qQVs-9DA4,438
 tamar_model_client/exceptions.py,sha256=jYU494OU_NeIa4X393V-Y73mTNm0JZ9yZApnlOM9CJQ,332
-tamar_model_client/sync_client.py,sha256=-Gbx1DP4LRFZZZd4sKpY5Fi-_WHZEVayl1ABD3k7O6I,22748
+tamar_model_client/json_formatter.py,sha256=9iO4Qn7FiyPTjcn07uHuP4q80upVlmqI_P1UV12YPxI,991
+tamar_model_client/logging_icons.py,sha256=MRTZ1Xvkep9ce_jdltj54_XZUXvIpQ95soRNmLdJ4qw,1837
+tamar_model_client/sync_client.py,sha256=FXdBeAqCHuLDPKzOyLMsPi33ibbNFLf9hWYfP1NFHuw,32507
 tamar_model_client/utils.py,sha256=Kn6pFz9GEC96H4eejEax66AkzvsrXI3WCSDtgDjnVTI,5238
 tamar_model_client/enums/__init__.py,sha256=3cYYn8ztNGBa_pI_5JGRVYf2QX8fkBVWdjID1PLvoBQ,182
 tamar_model_client/enums/channel.py,sha256=wCzX579nNpTtwzGeS6S3Ls0UzVAgsOlfy4fXMzQTCAw,199
@@ -14,7 +16,7 @@ tamar_model_client/generated/model_service_pb2_grpc.py,sha256=k4tIbp3XBxdyuOVR18
 tamar_model_client/schemas/__init__.py,sha256=AxuI-TcvA4OMTj2FtK4wAItvz9LrK_293pu3cmMLE7k,394
 tamar_model_client/schemas/inputs.py,sha256=dz1m8NbUIxA99JXZc8WlyzbKpDuz1lEzx3VghC33zYI,14625
 tamar_model_client/schemas/outputs.py,sha256=M_fcqUtXPJnfiLabHlyA8BorlC5pYkf5KLjXO1ysKIQ,1031
-tamar_model_client-0.1.17.dist-info/METADATA,sha256=eP0oGK9qWIJXNu0YX2Q4LjERRPTWI0Hn8JgOJCJWW1w,16562
-tamar_model_client-0.1.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tamar_model_client-0.1.17.dist-info/top_level.txt,sha256=_LfDhPv_fvON0PoZgQuo4M7EjoWtxPRoQOBJziJmip8,19
-tamar_model_client-0.1.17.dist-info/RECORD,,
+tamar_model_client-0.1.19.dist-info/METADATA,sha256=-eCR9u_ULva97BJ0GwuaAuwEL7xyXGlmD2TwQUNSMxw,16562
+tamar_model_client-0.1.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tamar_model_client-0.1.19.dist-info/top_level.txt,sha256=_LfDhPv_fvON0PoZgQuo4M7EjoWtxPRoQOBJziJmip8,19
+tamar_model_client-0.1.19.dist-info/RECORD,,