sycommon-python-lib 0.1.55__py3-none-any.whl → 0.1.55b0__py3-none-any.whl

sycommon/logging/async_sql_logger.py

@@ -1,65 +0,0 @@
-from sqlalchemy import event
-from sqlalchemy.ext.asyncio import AsyncEngine
-from sycommon.logging.kafka_log import SYLogger
-import time
-from datetime import datetime
-from decimal import Decimal
-
-
-class AsyncSQLTraceLogger:
-    @staticmethod
-    def setup_sql_logging(engine):
-        """
-        为 SQLAlchemy 异步引擎注册事件监听器
-        注意：必须监听 engine.sync_engine，而不能直接监听 AsyncEngine
-        """
-        def serialize_params(params):
-            """处理特殊类型参数的序列化"""
-            if isinstance(params, (list, tuple)):
-                return [serialize_params(p) for p in params]
-            elif isinstance(params, dict):
-                return {k: serialize_params(v) for k, v in params.items()}
-            elif isinstance(params, datetime):
-                return params.isoformat()
-            elif isinstance(params, Decimal):
-                return float(params)
-            else:
-                return params
-
-        # ========== 核心修改 ==========
-        # 必须通过 engine.sync_engine 来获取底层的同步引擎进行监听
-        target = engine.sync_engine
-
-        @event.listens_for(target, "after_cursor_execute")
-        def after_cursor_execute(
-            conn, cursor, statement, parameters, context, executemany
-        ):
-            try:
-                # 从连接选项中获取开始时间
-                # conn 在这里是同步连接对象
-                start_time = conn.info.get('_start_time') or \
-                    conn._execution_options.get("_start_time", time.time())
-
-                execution_time = (time.time() - start_time) * 1000
-
-                sql_log = {
-                    "type": "SQL",
-                    "statement": statement,
-                    "parameters": serialize_params(parameters),
-                    "execution_time_ms": round(execution_time, 2),
-                }
-
-                # 注意：SYLogger.info 必须是线程安全的或非阻塞的，否则可能影响异步性能
-                SYLogger.info(f"SQL执行: {sql_log}")
-            except Exception as e:
-                SYLogger.error(f"SQL日志处理失败: {str(e)}")
-
-        @event.listens_for(target, "before_cursor_execute")
-        def before_cursor_execute(
-            conn, cursor, statement, parameters, context, executemany
-        ):
-            try:
-                # 记录开始时间到 execution_options
-                conn = conn.execution_options(_start_time=time.time())
-            except Exception as e:
-                SYLogger.error(f"SQL开始时间记录失败: {str(e)}")

sycommon/logging/logger_levels.py

@@ -1,23 +0,0 @@
-import logging
-
-
-def setup_logger_levels():
-    """配置各模块的日志级别，抑制无关INFO/DEBUG日志"""
-    # Nacos 客户端：仅输出WARNING及以上（屏蔽INFO级的心跳/注册日志）
-    logging.getLogger("nacos.client").setLevel(logging.WARNING)
-
-    # Kafka Python客户端：屏蔽INFO级的连接/版本检测日志
-    logging.getLogger("kafka.conn").setLevel(logging.WARNING)
-    logging.getLogger("kafka.producer").setLevel(logging.WARNING)
-
-    # Uvicorn/FastAPI：屏蔽启动/应用初始化的INFO日志（保留ERROR/WARNING）
-    # logging.getLogger("uvicorn").setLevel(logging.WARNING)
-    # logging.getLogger("uvicorn.access").setLevel(logging.WARNING)  # 屏蔽访问日志
-    # logging.getLogger("uvicorn.error").setLevel(logging.ERROR)     # 仅保留错误
-
-    # 自定义的root日志（如同步数据库/监听器初始化）：屏蔽INFO
-    logging.getLogger("root").setLevel(logging.WARNING)
-
-    # RabbitMQ相关日志（如果有专属日志器）
-    logging.getLogger("pika").setLevel(logging.WARNING)  # 若使用pika客户端
-    logging.getLogger("rabbitmq").setLevel(logging.WARNING)

sycommon/tools/merge_headers.py

@@ -1,97 +0,0 @@
-def merge_headers(
-    source_headers,  # 来源headers（支持多种格式：字典/MutableHeaders/键值对列表/元组）
-    target_headers,  # 目标headers（原有值需保留，同名覆盖source）
-    keep_keys=None,  # 需保留的key集合（None表示保留所有）
-    delete_keys={'content-length', 'accept',
-                 'content-type', 'sec-fetch-mode',
-                 'sec-fetch-dest', 'sec-fetch-site',
-                 'pragma', 'cache-control',
-                 'accept-encoding', 'priority'},  # 需删除的source key集合
-    encoding='utf-8'  # 字符编码（处理bytes转换）
-) -> dict:
-    """
-    合并headers，最终规则：
-    1. 所有key统一转为小写进行比较判断（完全大小写无关）
-    2. target_headers 同名key 完全覆盖 source_headers（source同名key不生效）
-    3. delete_keys 作用于source_headers：source中所有该列表内的key一律不添加（无论是否新增）
-    4. target_headers 中的key即使在delete_keys也始终保留，不受删除规则影响
-    5. 自动处理bytes/其他类型的键值转换为字符串
-    6. 最终输出的key全部为小写
-    """
-    # 初始化并统一转为小写集合
-    keep_keys = {k.lower() for k in keep_keys} if keep_keys else set()
-    delete_keys = {k.lower() for k in delete_keys} if delete_keys else set()
-
-    # 修复1：兼容 MutableHeaders/普通字典/None 等 target_headers 类型
-    if target_headers is None:
-        target_dict = {}
-    elif hasattr(target_headers, 'items'):
-        # 支持 MutableHeaders/Headers/普通字典（都有items()方法）
-        target_dict = dict(target_headers.items())
-    else:
-        # 兜底：可迭代对象转为字典
-        target_dict = dict(target_headers) if isinstance(
-            target_headers, (list, tuple)) else {}
-
-    # 标准化target_headers：key转为小写，保留原有值
-    processed_headers = {k.lower(): v for k, v in target_dict.items()}
-    target_original_keys = set(processed_headers.keys())
-
-    # 修复2：统一处理 source_headers 格式，确保是键值对迭代器
-    # 步骤1：将source_headers转为标准的键值对列表
-    if source_headers is None:
-        source_kv_list = []
-    elif hasattr(source_headers, 'items'):
-        # 字典/MutableHeaders → 转为键值对列表
-        source_kv_list = list(source_headers.items())
-    elif isinstance(source_headers, (list, tuple)):
-        # 列表/元组 → 校验并过滤合法的键值对（仅保留长度为2的元组/列表）
-        source_kv_list = []
-        for item in source_headers:
-            if isinstance(item, (list, tuple)) and len(item) == 2:
-                source_kv_list.append(item)
-            else:
-                # 跳过非法格式（如长度≠2的元素），避免解包报错
-                continue
-    else:
-        # 其他类型 → 空列表（避免迭代报错）
-        source_kv_list = []
-
-    # 处理来源headers的键值转换和合并（遍历标准化后的键值对）
-    for key, value in source_kv_list:
-        # 转换key为字符串并统一转为小写（判断用）
-        if not isinstance(key, str):
-            try:
-                key = key.decode(encoding, errors='replace') if isinstance(
-                    key, bytes) else str(key)
-            except Exception:
-                # 极端情况：无法转换的key直接跳过
-                continue
-
-        key_lower = key.lower()
-
-        # 转换value为字符串
-        if not isinstance(value, str):
-            try:
-                value = value.decode(encoding, errors='replace') if isinstance(
-                    value, bytes) else str(value)
-            except Exception:
-                # 无法转换的value设为空字符串
-                value = ""
-
-        # 过滤1：source的key在删除列表 → 直接跳过
-        if key_lower in delete_keys:
-            continue
-
-        # 过滤2：仅保留指定的key（如果设置了keep_keys）
-        if keep_keys and key_lower not in keep_keys:
-            continue
-
-        # 过滤3：target已有同名key → 直接跳过（target值覆盖source）
-        if key_lower in target_original_keys:
-            continue
-
-        # 仅添加符合条件的key-value（最终key为小写）
-        processed_headers[key_lower] = value
-
-    return processed_headers