sycommon-python-lib 0.1.28__py3-none-any.whl → 0.1.30__py3-none-any.whl

sycommon/logging/kafka_log.py

@@ -470,12 +470,22 @@ class SYLogger:
         thread_info = SYLogger._get_execution_context()
 
         # 构建日志结构，添加线程/协程信息到threadName字段
-        request_log = {
-            "trace_id": str(trace_id) if trace_id else Snowflake.next_id(),
-            "message": msg_str,
-            "level": level,
-            "threadName": thread_info
-        }
+        request_log = {}
+        if level == "ERROR":
+            request_log = {
+                "trace_id": str(trace_id) if trace_id else Snowflake.next_id(),
+                "message": msg_str,
+                "traceback": traceback.format_exc(),
+                "level": level,
+                "threadName": thread_info
+            }
+        else:
+            request_log = {
+                "trace_id": str(trace_id) if trace_id else Snowflake.next_id(),
+                "message": msg_str,
+                "level": level,
+                "threadName": thread_info
+            }
 
         # 选择日志级别
         _log = ''

sycommon/models/mqlistener_config.py

@@ -31,6 +31,7 @@ class RabbitMQListenerConfig(BaseModel):
     durable: bool = Field(True, description="是否持久化")
     auto_delete: bool = Field(False, description="是否自动删除队列")
     auto_parse_json: bool = Field(True, description="是否自动解析JSON消息")
+    prefetch_count: int = Field(2, description="mq同时消费数量")
 
     class Config:
         """模型配置"""

sycommon/rabbitmq/rabbitmq_client.py

@@ -608,6 +608,10 @@ class RabbitMQClient:
         if not self.message_handler or not self._is_consuming:
             logger.warning("未设置消息处理器或已停止消费")
             # await message.ack()
+            try:
+                await message.reject(requeue=True)
+            except Exception as e:
+                logger.error(f"拒绝消息失败: {e}")
             return
 
         message_id = message.message_id or str(id(message))

sycommon/rabbitmq/rabbitmq_service.py

@@ -167,7 +167,7 @@ class RabbitMQService:
                 'max_reconnection_attempts', 5),
             prefetch_count=kwargs.get('prefetch_count', 2),
             consumption_stall_threshold=kwargs.get(
-                'consumption_stall_threshold', 10)
+                'consumption_stall_threshold', 10),
         )
 
         # 使用declare_queue控制是否声明队列（发送器不声明，监听器声明）
@@ -276,7 +276,7 @@ class RabbitMQService:
 
     # 以下方法逻辑与原有保持一致（无需修改）
     @classmethod
-    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False) -> None:
+    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False, ** kwargs) -> None:
         """设置消息发送器"""
         cls._has_senders = True
         cls._has_listeners = has_listeners
@@ -287,6 +287,7 @@ class RabbitMQService:
                 if not sender_config.queue_name:
                     raise ValueError(f"发送器配置第{idx+1}项缺少queue_name")
 
+                prefetch_count = sender_config.prefetch_count
                 queue_name = sender_config.queue_name
                 app_name = cls._config.get(
                     "APP_NAME", "") if cls._config else ""
@@ -315,7 +316,9 @@ class RabbitMQService:
                         auto_delete=sender_config.auto_delete,
                         auto_parse_json=sender_config.auto_parse_json,
                         queue_name=queue_name,
-                        create_if_not_exists=False
+                        create_if_not_exists=False,
+                        prefetch_count=prefetch_count,
+                        ** kwargs
                     )
 
                 # 记录客户端
@@ -334,7 +337,7 @@ class RabbitMQService:
         logger.info(f"消息发送器设置完成，共 {len(cls._sender_client_names)} 个发送器")
 
     @classmethod
-    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False) -> None:
+    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False, ** kwargs) -> None:
         """设置消息监听器"""
         cls._has_listeners = True
         cls._has_senders = has_senders

sycommon/services.py

@@ -145,6 +145,12 @@ class Services(metaclass=SingletonMeta):
 
         # 设置发送器，传递是否有监听器的标志
         if rabbitmq_senders:
+            # 判断是否有监听器，如果有遍历监听器列表，队列名一样将prefetch_count属性设置到发送器对象中
+            if rabbitmq_listeners:
+                for sender in rabbitmq_senders:
+                    for listener in rabbitmq_listeners:
+                        if sender.queue_name == listener.queue_name:
+                            sender.prefetch_count = listener.prefetch_count
             await self._setup_senders_async(rabbitmq_senders, has_listeners)
 
         # 设置监听器，传递是否有发送器的标志

sycommon/synacos/example.py

@@ -0,0 +1,153 @@
+from typing import Dict, Any, Optional, List, Union
+
+from sycommon.synacos.param import Body, Cookie, File, Form, Header, Path, Query
+from sycommon.synacos.feign_client import feign_client, feign_request, feign_upload
+
+
+@feign_client(
+    service_name="product-service",
+    path_prefix="/api/v1",
+    default_headers={
+        "User-Agent": "Feign-Client/1.0",
+        "Accept": "application/json"
+    }
+)
+class ProductServiceClient:
+    """商品服务Feign客户端（优化版）"""
+
+    # ------------------------------
+    # 场景1: 基础参数 + 动态Header + Cookie
+    # ------------------------------
+    @feign_request(
+        "GET",
+        "/products/{product_id}/reviews",
+        headers={"X-Request-Source": "mobile"},  # 固定头
+        timeout=10  # 接口级超时（10秒）
+    )
+    async def get_product_reviews(
+        self,
+        product_id: int = Path(..., description="商品ID"),
+        status: Optional[str] = Query(None, description="评价状态"),
+        page: int = Query(1, description="页码"),
+        size: int = Query(10, description="每页条数"),
+        x_auth_token: str = Header(..., description="动态令牌头"),  # 动态头
+        session_id: str = Cookie(..., description="会话Cookie")  # Cookie
+    ) -> Dict[str, Any]:
+        """获取商品评价列表"""
+        pass
+
+    # ------------------------------
+    # 场景2: 仅Query参数（默认不超时）
+    # ------------------------------
+    @feign_request("GET", "/products")  # 未指定timeout，使用客户端默认（不超时）
+    async def search_products(
+        self,
+        category: str = Query(..., description="商品分类"),
+        min_price: Optional[float] = Query(None, description="最低价格"),
+        max_price: Optional[float] = Query(None, description="最高价格"),
+        sort: str = Query("created_desc", description="排序方式")
+    ) -> Dict[str, Any]:
+        """搜索商品"""
+        pass
+
+    # ------------------------------
+    # 场景3: JSON请求体 + 动态签名头
+    # （通过Header参数传递动态生成的签名）
+    # ------------------------------
+    @feign_request(
+        "POST",
+        "/products",
+        headers={"s-y-version": "2.1"},
+        timeout=15  # 15秒超时
+    )
+    async def create_product(
+        self,
+        product_data: Dict[str, Any] = Body(..., description="商品信息"),
+        x_signature: str = Header(..., description="动态生成的签名头")  # 签名头
+    ) -> Dict[str, Any]:
+        """创建商品（动态签名通过Header参数传递）"""
+        pass
+
+    # ------------------------------
+    # 场景4: 文件上传 + 分片上传头
+    # ------------------------------
+    @feign_upload(field_name="image_file")
+    @feign_request(
+        "POST",
+        "/products/{product_id}/images",
+        headers={"X-Upload-Type": "product-image"},
+        timeout=60  # 上传超时60秒
+    )
+    async def upload_product_image(
+        self,
+        product_id: int = Path(..., description="商品ID"),
+        file_paths: Union[str, List[str]] = File(..., description="文件路径"),
+        image_type: str = Form(..., description="图片类型"),
+        is_primary: bool = Form(False, description="是否主图"),
+        x_chunked: bool = Header(False, description="是否分片上传")  # 分片上传头
+    ) -> Dict[str, Any]:
+        """上传商品图片（支持分片上传标记）"""
+        pass
+
+    # ------------------------------
+    # 场景5: 表单提交 + 操作时间头
+    # ------------------------------
+    @feign_request(
+        "POST",
+        "/products/batch-status",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        timeout=5
+    )
+    async def batch_update_status(
+        self,
+        product_ids: str = Form(..., description="商品ID列表"),
+        status: str = Form(..., description="目标状态"),
+        operator: str = Form(..., description="操作人"),
+        x_operate_time: str = Header(..., description="操作时间戳头")  # 动态时间头
+    ) -> Dict[str, Any]:
+        """批量更新商品状态"""
+        pass
+
+
+# ------------------------------
+# 2. 完整调用示例（含Session和Header用法）
+# ------------------------------
+async def feign_advanced_demo():
+    client = ProductServiceClient()
+
+    # 场景1: 动态Header和Cookie
+    reviews = await client.get_product_reviews(
+        product_id=10086,
+        status="APPROVED",
+        x_auth_token="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",  # 动态令牌
+        session_id="sid_123456"  # Cookie
+    )
+    print(f"场景1 - 评价数: {reviews.get('total', 0)}")
+
+    # 场景3: 动态生成签名头（直接通过Header参数传递）
+    import hashlib
+    product_data = {
+        "name": "无线蓝牙耳机",
+        "price": 299.99,
+        "stock": 500
+    }
+    # 生成签名（业务逻辑）
+    sign_str = f"{product_data['name']}_{product_data['price']}_secret"
+    signature = hashlib.md5(sign_str.encode()).hexdigest()
+    # 传递签名头
+    new_product = await client.create_product(
+        product_data=product_data,
+        x_signature=signature  # 动态签名通过Header参数传入
+    )
+    print(f"场景3 - 商品ID: {new_product.get('id')}")
+
+    # 场景4: 分片上传（通过x_chunked头控制）
+    product_id = new_product.get('id')
+    if product_id:
+        upload_result = await client.upload_product_image(
+            product_id=product_id,
+            file_paths=["/tmp/main.jpg", "/tmp/detail.jpg"],
+            image_type="detail",
+            x_chunked=True  # 启用分片上传
+        )
+        print(f"场景4 - 上传图片数: {len(upload_result.get('image_urls', []))}")

sycommon/synacos/example2.py

@@ -0,0 +1,129 @@
+from pydantic import BaseModel, Field
+from typing import Any, Optional, List, Dict
+
+from sycommon.synacos.feign_client import feign_client, feign_request
+from sycommon.synacos.param import Body, Form, Query
+
+
+# ------------------------------
+# 请求模型（req）
+# ------------------------------
+class ProductCreateReq(BaseModel):
+    """创建商品的请求模型"""
+    name: str = Field(..., description="商品名称")
+    category: str = Field(..., description="商品分类")
+    price: float = Field(..., gt=0, description="商品价格（必须>0）")
+    stock: int = Field(..., ge=0, description="库存（必须>=0）")
+    attributes: Optional[Dict[str, str]] = Field(None, description="商品属性")
+
+
+class BatchUpdateStatusReq(BaseModel):
+    """批量更新状态的请求模型（表单提交）"""
+    product_ids: str = Field(..., description="商品ID列表（逗号分隔）")
+    status: str = Field(..., description="目标状态（如ON_SALE/OFF_SALE）")
+    operator: str = Field(..., description="操作人")
+
+
+# ------------------------------
+# 响应模型（resp）
+# ------------------------------
+class ProductResp(BaseModel):
+    """商品详情响应模型"""
+    id: int = Field(..., description="商品ID")
+    name: str = Field(..., description="商品名称")
+    category: str = Field(..., description="分类")
+    price: float = Field(..., description="价格")
+    stock: int = Field(..., description="库存")
+    created_at: str = Field(..., description="创建时间")
+
+
+class PageResp(BaseModel):
+    """分页响应模型"""
+    total: int = Field(..., description="总条数")
+    items: List[ProductResp] = Field(..., description="商品列表")
+    page: int = Field(..., description="当前页码")
+    size: int = Field(..., description="每页条数")
+
+
+@feign_client(
+    service_name="product-service",
+    path_prefix="/api/v2",
+    default_headers={"Accept": "application/json"}
+)
+class ProductServiceClient:
+    # ------------------------------
+    # 场景1: Pydantic 作为请求体（Body）
+    # ------------------------------
+    @feign_request("POST", "/products", timeout=15)
+    async def create_product(
+        self,
+        # 使用 Pydantic 模型作为请求体
+        product: ProductCreateReq = Body(..., description="商品信息")
+    ) -> ProductResp:  # 响应自动解析为 ProductResp 模型
+        """创建商品（Pydantic请求体 + Pydantic响应）"""
+        pass
+
+    # ------------------------------
+    # 场景2: Pydantic 作为表单参数（Form）
+    # ------------------------------
+    @feign_request(
+        "POST",
+        "/products/batch-status",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        timeout=5
+    )
+    async def batch_update_status(
+        self,
+        # 使用 Pydantic 模型作为表单参数
+        update_data: BatchUpdateStatusReq = Form(..., description="批量更新信息")
+    ) -> Dict[str, Any]:  # 普通字典响应
+        """批量更新商品状态（Pydantic表单）"""
+        pass
+
+    # ------------------------------
+    # 场景3: 响应为分页模型（嵌套Pydantic）
+    # ------------------------------
+    @feign_request("GET", "/products", timeout=10)
+    async def search_products(
+        self,
+        category: str = Query(..., description="商品分类"),
+        page: int = Query(1, description="页码"),
+        size: int = Query(10, description="每页条数")
+    ) -> PageResp:  # 响应自动解析为 PageResp（嵌套 ProductResp）
+        """搜索商品（Pydantic分页响应）"""
+        pass
+
+
+async def pydantic_feign_demo():
+    client = ProductServiceClient()
+
+    # 场景1: 创建商品（Pydantic请求体 + 响应）
+    create_req = ProductCreateReq(
+        name="无线蓝牙耳机",
+        category="electronics",
+        price=299.99,
+        stock=500,
+        attributes={"brand": "Feign", "battery_life": "24h"}
+    )
+    product = await client.create_product(product=create_req)
+    # 直接使用 Pydantic 模型的属性
+    print(f"创建商品: ID={product.id}, 名称={product.name}, 价格={product.price}")
+
+    # 场景2: 批量更新（Pydantic表单）
+    batch_req = BatchUpdateStatusReq(
+        product_ids=f"{product.id},1002,1003",
+        status="ON_SALE",
+        operator="system"
+    )
+    batch_result = await client.batch_update_status(update_data=batch_req)
+    print(f"批量更新成功: {batch_result.get('success_count')}个")
+
+    # 场景3: 搜索商品（Pydantic分页响应）
+    page_resp = await client.search_products(
+        category="electronics",
+        page=1,
+        size=10
+    )
+    # 分页模型的属性和嵌套列表
+    print(
+        f"搜索结果: 共{page_resp.total}条，第1页商品: {[p.name for p in page_resp.items]}")