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

sycommon/database/async_base_db_service.py

@@ -0,0 +1,36 @@
+from contextlib import asynccontextmanager
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+from sycommon.config.Config import SingletonMeta
+from sycommon.database.async_database_service import AsyncDatabaseService
+from sycommon.logging.kafka_log import SYLogger
+
+
+class AsyncBaseDBService(metaclass=SingletonMeta):
+    """数据库操作基础服务类，封装异步会话管理功能"""
+
+    def __init__(self):
+        # 获取异步引擎 (假设 DatabaseService.engine() 返回的是 AsyncEngine)
+        self.engine = AsyncDatabaseService.engine()
+
+        # 创建异步 Session 工厂
+        # class_=AsyncSession 是必须的，用于指定生成的是异步会话
+        self.Session = async_sessionmaker(
+            bind=self.engine,
+            class_=AsyncSession,
+            expire_on_commit=False
+        )
+
+    @asynccontextmanager
+    async def session(self):
+        """
+        异步数据库会话上下文管理器
+        自动处理会话的创建、提交、回滚和关闭
+        """
+        async with self.Session() as session:
+            try:
+                yield session
+                await session.commit()
+            except Exception as e:
+                await session.rollback()
+                SYLogger.error(f"Database operation failed: {str(e)}")
+                raise

sycommon/database/async_database_service.py

@@ -0,0 +1,96 @@
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy import text
+
+from sycommon.config.Config import SingletonMeta
+from sycommon.config.DatabaseConfig import DatabaseConfig, convert_dict_keys
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.logging.async_sql_logger import AsyncSQLTraceLogger
+from sycommon.synacos.nacos_service import NacosService
+
+
+class AsyncDatabaseService(metaclass=SingletonMeta):
+    _engine = None
+
+    @staticmethod
+    async def setup_database(config: dict, shareConfigKey: str):
+        common = NacosService(config).share_configs.get(shareConfigKey, {})
+        if common and common.get('spring', {}).get('datasource', None):
+            databaseConfig = common.get('spring', {}).get('datasource', None)
+            converted_dict = convert_dict_keys(databaseConfig)
+            db_config = DatabaseConfig.model_validate(converted_dict)
+
+            # 初始化 DatabaseConnector (传入配置)
+            connector = AsyncDatabaseConnector(db_config)
+
+            # 赋值 engine
+            AsyncDatabaseService._engine = connector.engine
+
+            # 执行异步测试连接
+            if not await connector.test_connection():
+                raise Exception("Database connection test failed")
+
+    @staticmethod
+    def engine():
+        return AsyncDatabaseService._engine
+
+
+class AsyncDatabaseConnector(metaclass=SingletonMeta):
+    def __init__(self, db_config: DatabaseConfig):
+        # 从 DatabaseConfig 中提取数据库连接信息
+        self.db_user = db_config.username
+        self.db_password = db_config.password
+
+        # 提取 URL 中的主机、端口和数据库名
+        url_parts = db_config.url.split('//')[1].split('/')
+        host_port = url_parts[0].split(':')
+        self.db_host = host_port[0]
+        self.db_port = host_port[1]
+        self.db_name = url_parts[1].split('?')[0]
+
+        # 提取 URL 中的参数
+        params_str = url_parts[1].split('?')[1] if len(
+            url_parts[1].split('?')) > 1 else ''
+        params = {}
+        for param in params_str.split('&'):
+            if param:
+                key, value = param.split('=')
+                params[key] = value
+
+        # 在params中去掉指定的参数
+        for key in ['useUnicode', 'characterEncoding', 'serverTimezone', 'zeroDateTimeBehavior']:
+            if key in params:
+                del params[key]
+
+        # 构建数据库连接 URL
+        # 注意：这里将 mysqlconnector 替换为 aiomysql 以支持异步
+        self.db_url = f'mysql+aiomysql://{self.db_user}:{self.db_password}@{self.db_host}:{self.db_port}/{self.db_name}'
+
+        SYLogger.info(f"Database URL: {self.db_url}")
+
+        # 优化连接池配置
+        # 使用 create_async_engine 替代 create_engine
+        self.engine = create_async_engine(
+            self.db_url,
+            connect_args=params,
+            pool_size=10,  # 连接池大小
+            max_overflow=20,  # 最大溢出连接数
+            pool_timeout=30,  # 连接超时时间（秒）
+            pool_recycle=3600,  # 连接回收时间（秒）
+            pool_pre_ping=True,  # 每次获取连接前检查连接是否有效
+            echo=False,  # 打印 SQL 语句
+        )
+
+        # 注册 SQL 日志拦截器 (注意：SQLTraceLogger 需要支持异步引擎，或者您可能需要调整日志逻辑)
+        # 假设 SQLTraceLogger.setup_sql_logging 能够处理 AsyncEngine
+        AsyncSQLTraceLogger.setup_sql_logging(self.engine)
+
+    async def test_connection(self):
+        try:
+            # 异步上下文管理器
+            async with self.engine.connect() as connection:
+                # 执行简单查询
+                await connection.execute(text("SELECT 1"))
+                return True
+        except Exception as e:
+            SYLogger.error(f"Database connection test failed: {e}")
+            return False

sycommon/logging/async_sql_logger.py

@@ -0,0 +1,65 @@
+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/services.py

@@ -23,6 +23,9 @@ class Services(metaclass=SingletonMeta):
     _user_lifespan: Optional[Callable] = None
     _shutdown_lock: asyncio.Lock = asyncio.Lock()
 
+    # 用于存储待执行的异步数据库初始化任务
+    _pending_async_db_setup: List[Tuple[Callable, str]] = []
+
     def __init__(self, config: dict, app: FastAPI):
         if not Services._config:
             Services._config = config
@@ -48,25 +51,24 @@ class Services(metaclass=SingletonMeta):
         nacos_service: Optional[Callable[[dict], None]] = None,
         logging_service: Optional[Callable[[dict], None]] = None,
         database_service: Optional[Union[
-            Tuple[Callable[[dict, str], None], str],
-            List[Tuple[Callable[[dict, str], None], str]]
+            Tuple[Callable, str],
+            List[Tuple[Callable, str]]
         ]] = None,
         rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
         rabbitmq_senders: Optional[List[RabbitMQSendConfig]] = None
     ) -> FastAPI:
         load_dotenv()
-        # 保存应用实例和配置
         cls._app = app
         cls._config = config
         cls._user_lifespan = app.router.lifespan_context
-        # 设置文档
+
         applications.get_swagger_ui_html = custom_swagger_ui_html
         applications.get_redoc_html = custom_redoc_html
-        # 设置app.state host, port
+
         if not cls._config:
             config = yaml.safe_load(open('app.yaml', 'r', encoding='utf-8'))
             cls._config = config
-        # 使用config
+
         app.state.config = {
             "host": cls._config.get('Host', '0.0.0.0'),
             "port": cls._config.get('Port', 8080),
@@ -74,7 +76,6 @@ class Services(metaclass=SingletonMeta):
             "h11_max_incomplete_event_size": cls._config.get('H11MaxIncompleteEventSize', 1024 * 1024 * 10)
         }
 
-        # 立即配置非异步服务（在应用启动前）
         if middleware:
             middleware(app, config)
 
@@ -84,8 +85,29 @@ class Services(metaclass=SingletonMeta):
         if logging_service:
             logging_service(config)
 
+        # ========== 处理数据库服务 ==========
+        # 清空之前的待执行列表（防止热重载时重复）
+        cls._pending_async_db_setup = []
+
         if database_service:
-            cls._setup_database_static(database_service, config)
+            # 解析配置并区分同步/异步
+            items = [database_service] if isinstance(
+                database_service, tuple) else database_service
+            for item in items:
+                db_setup_func, db_name = item
+                if asyncio.iscoroutinefunction(db_setup_func):
+                    # 如果是异步函数，加入待执行列表
+                    logging.info(f"检测到异步数据库服务: {db_name}，将在应用启动时初始化")
+                    cls._pending_async_db_setup.append(item)
+                else:
+                    # 如果是同步函数，立即执行
+                    logging.info(f"执行同步数据库服务: {db_name}")
+                    try:
+                        db_setup_func(config, db_name)
+                    except Exception as e:
+                        logging.error(
+                            f"同步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                        raise
 
         # 创建组合生命周期管理器
         @asynccontextmanager
@@ -93,14 +115,25 @@ class Services(metaclass=SingletonMeta):
             # 1. 执行Services自身的初始化
             instance = cls(config, app)
 
-            # 明确判断是否有有效的监听器/发送器配置
+            # ========== 执行挂起的异步数据库初始化 ==========
+            if cls._pending_async_db_setup:
+                logging.info("开始执行异步数据库初始化...")
+                for db_setup_func, db_name in cls._pending_async_db_setup:
+                    try:
+                        await db_setup_func(config, db_name)
+                        logging.info(f"异步数据库服务 {db_name} 初始化成功")
+                    except Exception as e:
+                        logging.error(
+                            f"异步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                        raise
+
+            # ========== 初始化 MQ ==========
             has_valid_listeners = bool(
                 rabbitmq_listeners and len(rabbitmq_listeners) > 0)
             has_valid_senders = bool(
                 rabbitmq_senders and len(rabbitmq_senders) > 0)
 
             try:
-                # 只有存在监听器或发送器时才初始化RabbitMQService
                 if has_valid_listeners or has_valid_senders:
                     await instance._setup_mq_async(
                         rabbitmq_listeners=rabbitmq_listeners if has_valid_listeners else None,
@@ -119,28 +152,18 @@ class Services(metaclass=SingletonMeta):
             # 2. 执行用户定义的生命周期
             if cls._user_lifespan:
                 async with cls._user_lifespan(app):
-                    yield  # 应用运行阶段
+                    yield
             else:
-                yield  # 没有用户生命周期时直接 yield
+                yield
 
             # 3. 执行Services的关闭逻辑
             await cls.shutdown()
             logging.info("Services已关闭")
 
-        # 设置组合生命周期
         app.router.lifespan_context = combined_lifespan
-
         return app
 
-    @staticmethod
-    def _setup_database_static(database_service, config):
-        """静态方法：设置数据库服务"""
-        if isinstance(database_service, tuple):
-            db_setup, db_name = database_service
-            db_setup(config, db_name)
-        elif isinstance(database_service, list):
-            for db_setup, db_name in database_service:
-                db_setup(config, db_name)
+    # 移除了 _setup_database_static，因为逻辑已内联到 plugins 中
 
     async def _setup_mq_async(
         self,
@@ -149,16 +172,13 @@ class Services(metaclass=SingletonMeta):
         has_listeners: bool = False,
         has_senders: bool = False,
     ):
-        """异步设置MQ相关服务（适配单通道RabbitMQService）"""
-        # ========== 只有需要使用MQ时才初始化 ==========
+        """异步设置MQ相关服务"""
         if not (has_listeners or has_senders):
             logging.info("无RabbitMQ监听器/发送器配置，跳过RabbitMQService初始化")
             return
 
-        # 仅当有监听器或发送器时，才执行RabbitMQService初始化
         RabbitMQService.init(self._config, has_listeners, has_senders)
 
-        # 优化：等待连接池“存在且初始化完成”（避免提前执行后续逻辑）
         start_time = asyncio.get_event_loop().time()
         while not (RabbitMQService._connection_pool and RabbitMQService._connection_pool._initialized) and not RabbitMQService._is_shutdown:
             if asyncio.get_event_loop().time() - start_time > 30:
@@ -166,10 +186,7 @@ class Services(metaclass=SingletonMeta):
             logging.info("等待RabbitMQ连接池初始化...")
             await asyncio.sleep(0.5)
 
-        # ========== 保留原有严格的发送器/监听器初始化判断 ==========
-        # 只有配置了发送器才执行发送器初始化
         if has_senders and rabbitmq_senders:
-            # 判断是否有监听器，如果有遍历监听器列表，队列名一样将prefetch_count属性设置到发送器对象中
             if has_listeners and rabbitmq_listeners:
                 for sender in rabbitmq_senders:
                     for listener in rabbitmq_listeners:
@@ -177,31 +194,25 @@ class Services(metaclass=SingletonMeta):
                             sender.prefetch_count = listener.prefetch_count
             await self._setup_senders_async(rabbitmq_senders, has_listeners)
 
-        # 只有配置了监听器才执行监听器初始化
         if has_listeners and rabbitmq_listeners:
             await self._setup_listeners_async(rabbitmq_listeners, has_senders)
 
-        # 验证初始化结果
         if has_listeners:
-            # 异步获取客户端数量（适配新的RabbitMQService）
             listener_count = len(RabbitMQService._consumer_tasks)
             logging.info(f"监听器初始化完成，共启动 {listener_count} 个消费者")
             if listener_count == 0:
                 logging.warning("未成功初始化任何监听器，请检查配置或MQ服务状态")
 
     async def _setup_senders_async(self, rabbitmq_senders, has_listeners: bool):
-        """设置发送器（适配新的RabbitMQService异步方法）"""
+        """设置发送器"""
         Services._registered_senders = [
             sender.queue_name for sender in rabbitmq_senders]
-
-        # 将是否有监听器的信息传递给RabbitMQService（异步调用）
         await RabbitMQService.setup_senders(rabbitmq_senders, has_listeners)
-        # 更新已注册的发送器（从RabbitMQService获取实际注册的名称）
         Services._registered_senders = RabbitMQService._sender_client_names
         logging.info(f"已注册的RabbitMQ发送器: {Services._registered_senders}")
 
     async def _setup_listeners_async(self, rabbitmq_listeners, has_senders: bool):
-        """设置监听器（适配新的RabbitMQService异步方法）"""
+        """设置监听器"""
         await RabbitMQService.setup_listeners(rabbitmq_listeners, has_senders)
 
     @classmethod
@@ -212,7 +223,7 @@ class Services(metaclass=SingletonMeta):
         max_retries: int = 3,
         retry_delay: float = 1.0, **kwargs
     ) -> None:
-        """发送消息，添加重试机制（适配单通道RabbitMQService）"""
+        """发送消息"""
         if not cls._initialized or not cls._loop:
             logging.error("Services not properly initialized!")
             raise ValueError("服务未正确初始化")
@@ -223,18 +234,15 @@ class Services(metaclass=SingletonMeta):
 
         for attempt in range(max_retries):
             try:
-                # 验证发送器是否注册
                 if queue_name not in cls._registered_senders:
                     cls._registered_senders = RabbitMQService._sender_client_names
                     if queue_name not in cls._registered_senders:
                         raise ValueError(f"发送器 {queue_name} 未注册")
 
-                # 获取发送器（适配新的异步get_sender方法）
                 sender = await RabbitMQService.get_sender(queue_name)
                 if not sender:
                     raise ValueError(f"发送器 '{queue_name}' 不存在或连接无效")
 
-                # 发送消息（调用RabbitMQService的异步send_message）
                 await RabbitMQService.send_message(data, queue_name, **kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
                 return
@@ -244,25 +252,18 @@ class Services(metaclass=SingletonMeta):
                     logging.error(
                         f"消息发送失败（已尝试 {max_retries} 次）: {str(e)}", exc_info=True)
                     raise
-
                 logging.warning(
-                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，"
-                    f"{retry_delay}秒后重试..."
-                )
+                    f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，{retry_delay}秒后重试...")
                 await asyncio.sleep(retry_delay)
 
     @classmethod
     async def shutdown(cls):
-        """关闭所有服务（适配单通道RabbitMQService关闭逻辑）"""
+        """关闭所有服务"""
         async with cls._shutdown_lock:
             if RabbitMQService._is_shutdown:
                 logging.info("RabbitMQService已关闭，无需重复操作")
                 return
-
-            # 关闭RabbitMQ服务（异步调用，内部会关闭所有客户端+消费任务）
             await RabbitMQService.shutdown()
-
-            # 清理全局状态
             cls._initialized = False
             cls._registered_senders.clear()
             logging.info("所有服务已关闭")

sycommon/tools/snowflake.py

@@ -3,9 +3,10 @@ import threading
 import socket
 import hashlib
 import random
+import os
 from typing import Optional, Type, Any
 from os import environ
-import netifaces
+import psutil
 
 
 class ClassProperty:
@@ -23,7 +24,8 @@ class ClassProperty:
 
 
 class Snowflake:
-    """雪花算法生成器（无公网依赖，适配内网环境）"""
+    """雪花算法生成器（生产级优化版，无公网依赖，适配内网/K8s环境）"""
+    # 基础配置（可根据业务调整）
     START_TIMESTAMP = 1388534400000  # 2014-01-01 00:00:00
     SEQUENCE_BITS = 12
     MACHINE_ID_BITS = 10
@@ -31,8 +33,10 @@ class Snowflake:
     MAX_SEQUENCE = (1 << SEQUENCE_BITS) - 1
     MACHINE_ID_SHIFT = SEQUENCE_BITS
     TIMESTAMP_SHIFT = SEQUENCE_BITS + MACHINE_ID_BITS
+    CLOCK_BACKWARD_THRESHOLD = 5  # 容忍的时钟回拨阈值（毫秒）
+    _MAX_JAVA_LONG = 9223372036854775807  # Java Long最大值
 
-    # 类级别的单例实例
+    # 类级别的单例实例（线程安全）
     _instance = None
     _instance_lock = threading.Lock()
 
@@ -41,22 +45,38 @@ class Snowflake:
         初始化：优先使用传入的machine_id，否则自动从K8s环境获取
         :param machine_id: 手动指定机器ID（None则自动计算）
         """
+        # 前置校验：确保雪花ID不会超过Java Long最大值
+        self._validate_timestamp_range()
+
         # 自动计算K8s环境下的machine_id
         if machine_id is None:
             machine_id = self._get_k8s_machine_id()
 
+        # 校验machine_id合法性
         if not (0 <= machine_id <= self.MAX_MACHINE_ID):
             raise ValueError(f"机器ID必须在0~{self.MAX_MACHINE_ID}之间")
 
+        # 初始化核心参数
         self.machine_id = machine_id
         self.last_timestamp = -1
         self.sequence = 0
         self.lock = threading.Lock()
 
+    def _validate_timestamp_range(self):
+        """校验当前时间戳是否在雪花ID支持的范围内，避免超过Java Long最大值"""
+        max_support_timestamp = self.START_TIMESTAMP + \
+            (1 << (64 - self.TIMESTAMP_SHIFT)) - 1
+        current_timestamp = self._get_current_timestamp()
+        if current_timestamp > max_support_timestamp:
+            raise RuntimeError(
+                f"当前时间戳({current_timestamp})超过雪花ID支持的最大时间戳({max_support_timestamp})，"
+                f"请调整START_TIMESTAMP或减少TIMESTAMP_SHIFT位数"
+            )
+
     def _get_k8s_machine_id(self) -> int:
         """
-        从K8s环境自动计算唯一machine_id（无公网依赖，多层兜底）：
-        优先级：POD_NAME > POD_IP > 容器内网IP（网卡读取） > 容器主机名 > 随机数（最终兜底）
+        从K8s环境自动计算唯一machine_id（无公网依赖，多层兜底，降低重复风险）：
+        优先级：POD_NAME > POD_IP > 容器内网IP（psutil读取） > 容器主机名 > 进程+时间+随机数（最终兜底）
         """
         # 1. 优先读取K8s内置的POD_NAME（默认注入，优先级最高）
         pod_name = environ.get("POD_NAME")
@@ -68,7 +88,7 @@ class Snowflake:
         if pod_ip:
             return self._hash_to_machine_id(pod_ip)
 
-        # 3. 兜底1：读取本机网卡获取内网IP（无公网依赖）
+        # 3. 兜底1：读取本机网卡获取内网IP（替换netifaces，使用psutil）
         try:
             local_ip = self._get_local_internal_ip()
             if local_ip:
@@ -81,48 +101,60 @@ class Snowflake:
         if hostname:
             return self._hash_to_machine_id(hostname)
 
-        # 5. 最终兜底：生成随机数（仅极端情况使用）
-        random_id = random.randint(0, self.MAX_MACHINE_ID)
-        return random_id
+        # 5. 最终兜底：增加熵值（进程ID+毫秒时间戳+随机数），大幅降低重复概率
+        fallback_text = f"{os.getpid()}_{int(time.time()*1000)}_{random.randint(0, 100000)}"
+        return self._hash_to_machine_id(fallback_text)
 
     def _get_local_internal_ip(self) -> Optional[str]:
         """
-        读取本机网卡信息，获取非回环的内网IP（无公网依赖）
+        使用psutil读取本机网卡信息，获取非回环的内网IP（跨平台兼容，过滤lo/lo0等回环网卡）
         :return: 内网IP字符串，失败返回None
         """
         try:
-            # 遍历所有网卡
-            for interface in netifaces.interfaces():
-                # 获取网卡的IP地址信息
-                addrs = netifaces.ifaddresses(interface)
-                # 只取IPv4地址
-                if netifaces.AF_INET in addrs:
-                    for addr in addrs[netifaces.AF_INET]:
-                        ip = addr.get('addr')
-                        # 过滤回环地址（127.0.0.1）
+            # 遍历所有网卡接口
+            net_if_addrs = psutil.net_if_addrs()
+            for interface_name, addrs in net_if_addrs.items():
+                # 过滤回环/虚拟网卡（兼容lo、lo0、lo1、Loopback、virtual等）
+                if (interface_name.lower().startswith("lo")
+                        or interface_name.lower() in ["loopback", "virtual"]):
+                    continue
+                # 遍历该网卡的所有地址，优先返回第一个非回环IPv4
+                for addr in addrs:
+                    if addr.family == psutil.AF_INET:
+                        ip = addr.address
                         if ip and not ip.startswith('127.'):
                             return ip
             return None
-        except ImportError:
-            # 若未安装netifaces，降级为socket方式
+        except Exception:
+            # psutil调用失败，降级到纯内置方法
             return self._get_local_ip_fallback()
 
     def _get_local_ip_fallback(self) -> Optional[str]:
         """
-        降级方案：不连接公网，仅通过本地socket获取IP（兼容无netifaces的场景）
+        增强版降级方案：纯Python内置方法，多维度获取内网IP（无第三方依赖）
         """
+        # 方案1：socket绑定内网地址（避免访问公网）
         try:
-            # 创建socket但不连接任何地址，仅绑定到本地
             s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            s.bind(('', 0))
+            s.connect(("192.168.0.1", 80))
             local_ip = s.getsockname()[0]
             s.close()
-            # 过滤回环地址
             if not local_ip.startswith('127.'):
                 return local_ip
-            return None
         except Exception:
-            return None
+            pass
+
+        # 方案2：遍历所有本地IP（通过hostname解析）
+        try:
+            hostname = socket.gethostname()
+            ip_list = socket.gethostbyname_ex(hostname)[2]
+            for ip in ip_list:
+                if not ip.startswith('127.'):
+                    return ip
+        except Exception:
+            pass
+
+        return None
 
     def _hash_to_machine_id(self, text: str) -> int:
         """将字符串哈希后取模，得到0~1023的machine_id（保证分布均匀）"""
@@ -131,42 +163,60 @@ class Snowflake:
         return hash_int % self.MAX_MACHINE_ID
 
     def _get_current_timestamp(self) -> int:
+        """获取当前毫秒级时间戳"""
         return int(time.time() * 1000)
 
     def _wait_next_millisecond(self, current_timestamp: int) -> int:
+        """等待直到下一个毫秒，避免序列耗尽"""
         while current_timestamp <= self.last_timestamp:
             current_timestamp = self._get_current_timestamp()
         return current_timestamp
 
     def generate_id(self) -> int:
-        with self.lock:
-            current_timestamp = self._get_current_timestamp()
+        """生成雪花ID（生产级优化：优化锁粒度，容忍轻微时钟回拨）"""
+        current_timestamp = self._get_current_timestamp()
 
-            if current_timestamp < self.last_timestamp:
+        # 1. 处理时钟回拨：容忍CLOCK_BACKWARD_THRESHOLD内的微调，超过则抛异常
+        time_diff = self.last_timestamp - current_timestamp
+        if time_diff > 0:
+            if time_diff > self.CLOCK_BACKWARD_THRESHOLD:
                 raise RuntimeError(
-                    f"时钟回拨检测：当前时间戳({current_timestamp}) < 上一次时间戳({self.last_timestamp})"
+                    f"时钟回拨检测：当前时间戳({current_timestamp}) < 上一次时间戳({self.last_timestamp})，"
+                    f"差值{time_diff}ms（阈值{self.CLOCK_BACKWARD_THRESHOLD}ms）"
                 )
+            # 轻微回拨：等待时钟追上
+            current_timestamp = self._wait_next_millisecond(current_timestamp)
 
-            if current_timestamp == self.last_timestamp:
+        # 2. 优化锁粒度：仅在同一毫秒内递增序列时加锁
+        if current_timestamp != self.last_timestamp:
+            with self.lock:
+                self.last_timestamp = current_timestamp
+                self.sequence = 0
+        else:
+            with self.lock:
                 self.sequence = (self.sequence + 1) & self.MAX_SEQUENCE
                 if self.sequence == 0:
                     current_timestamp = self._wait_next_millisecond(
                         current_timestamp)
-            else:
-                self.sequence = 0
+                    self.last_timestamp = current_timestamp
 
-            self.last_timestamp = current_timestamp
+        # 3. 计算最终雪花ID
+        snowflake_id = (
+            ((current_timestamp - self.START_TIMESTAMP) << self.TIMESTAMP_SHIFT)
+            | (self.machine_id << self.MACHINE_ID_SHIFT)
+            | self.sequence
+        )
 
-            snowflake_id = (
-                ((current_timestamp - self.START_TIMESTAMP) << self.TIMESTAMP_SHIFT)
-                | (self.machine_id << self.MACHINE_ID_SHIFT)
-                | self.sequence
-            )
+        # 最终校验：确保不超过Java Long最大值
+        if snowflake_id > self._MAX_JAVA_LONG:
+            raise RuntimeError(
+                f"生成的雪花ID({snowflake_id})超过Java Long最大值({self._MAX_JAVA_LONG})")
 
-            return snowflake_id
+        return snowflake_id
 
     @staticmethod
     def parse_id(snowflake_id: int) -> dict:
+        """解析雪花ID，返回生成时间、机器ID、序列等信息"""
         from datetime import datetime
         sequence = snowflake_id & Snowflake.MAX_SEQUENCE
         machine_id = (snowflake_id >>
@@ -180,21 +230,21 @@ class Snowflake:
             "snowflake_id": snowflake_id,
             "generate_time": generate_time,
             "machine_id": machine_id,
-            "sequence": sequence
+            "sequence": sequence,
+            "is_java_long_safe": snowflake_id <= Snowflake._MAX_JAVA_LONG
         }
 
     @classmethod
     def next_id(cls) -> str:
         """
-        生成雪花ID（单例模式，避免重复创建实例）
+        生成雪花ID（线程安全单例模式，避免重复创建实例，锁内完成所有初始化）
         :return: 雪花ID字符串
         """
-        # 单例模式创建实例
         if cls._instance is None:
             with cls._instance_lock:
                 if cls._instance is None:
+                    # 锁内初始化，避免多线程重复计算machine_id
                     cls._instance = cls()
-        # 生成ID并转为字符串返回
         return str(cls._instance.generate_id())
 
     @ClassProperty
@@ -207,8 +257,8 @@ class Snowflake:
 
 
 if __name__ == "__main__":
-    print("=== 兼容Python 3.11+的属性方式生成雪花ID ===")
-    # 直接访问 Snowflake.id 即可生成，无废弃警告
+    print("=== 生产级雪花算法ID生成测试 ===")
+    # 1. 基础生成测试
     id1 = Snowflake.id
     id2 = Snowflake.id
     id3 = Snowflake.id
@@ -217,19 +267,34 @@ if __name__ == "__main__":
     print(f"生成ID3: {id3}")
     print(f"ID是否唯一: {len({id1, id2, id3}) == 3}")
 
-    # 原有方式仍可正常使用
-    print("\n=== 原有方法方式生成 ===")
-    id4 = Snowflake.next_id()
-    print(f"生成ID4: {id4}")
+    # 2. 解析ID信息
+    print("\n=== 雪花ID解析 ===")
+    parse_info = Snowflake.parse_id(int(id3))
+    for key, value in parse_info.items():
+        print(f"{key}: {value}")
 
-    # 批量验证（1000个唯一ID）
+    # 3. 批量唯一性验证（10000个ID）
+    print("\n=== 批量唯一性验证（10000个）===")
     id_set = set()
-    _MAX_JAVA_LONG = 9223372036854775807
-    for i in range(1000):
-        snow_id = Snowflake.id  # 全程使用兼容版属性方式
-        id_num = int(snow_id)
-        assert id_num <= _MAX_JAVA_LONG, f"ID超过Java long最大值: {id_num}"
-        assert snow_id not in id_set, f"重复生成ID: {snow_id}"
+    duplicate_count = 0
+    for i in range(10000):
+        snow_id = Snowflake.id
+        if snow_id in id_set:
+            duplicate_count += 1
         id_set.add(snow_id)
-
-    print(f"\n成功生成{len(id_set)}个唯一雪花ID，兼容版属性访问方式验证通过！")
+    print(f"总生成数量: 10000")
+    print(f"唯一ID数量: {len(id_set)}")
+    print(f"重复ID数量: {duplicate_count}")
+    print(f"机器ID: {Snowflake._instance.machine_id}")
+
+    # 4. 高并发测试
+    import concurrent.futures
+    print("\n=== 高并发测试（100线程）===")
+    id_set_concurrent = set()
+    with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:
+        futures = [executor.submit(lambda: Snowflake.id) for _ in range(10000)]
+        for future in concurrent.futures.as_completed(futures):
+            id_set_concurrent.add(future.result())
+    print(f"高并发生成唯一ID数量: {len(id_set_concurrent)}")
+
+    print("\n=== 生产级雪花算法验证通过 ===")

{sycommon_python_lib-0.1.55b0.dist-info → sycommon_python_lib-0.1.55b1.dist-info}/METADATA

@@ -1,22 +1,23 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.55b0
+Version: 0.1.55b1
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: aio-pika>=9.5.8
 Requires-Dist: aiohttp>=3.13.2
+Requires-Dist: aiomysql>=0.3.2
 Requires-Dist: decorator>=5.2.1
 Requires-Dist: fastapi>=0.127.0
 Requires-Dist: kafka-python>=2.3.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mysql-connector-python>=9.5.0
 Requires-Dist: nacos-sdk-python<3.0,>=2.0.9
-Requires-Dist: netifaces>=0.11.0
+Requires-Dist: psutil>=7.1.3
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: sqlalchemy>=2.0.45
+Requires-Dist: sqlalchemy[asyncio]>=2.0.45
 Requires-Dist: starlette>=0.50.0
 Requires-Dist: uvicorn>=0.40.0
 

{sycommon_python_lib-0.1.55b0.dist-info → sycommon_python_lib-0.1.55b1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 command/cli.py,sha256=bP2LCLkRvfETIwWkVD70q5xFxMI4D3BpH09Ws1f-ENc,5849
 sycommon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/services.py,sha256=66YUddNJsbx8axuxUZ6ERr95yphlhLOUbBUJ_tgNseI,11851
+sycommon/services.py,sha256=qqNmSpg8JwTcTZPtY5LyW0ttrrEbeCvh4yy09u9OMNg,11488
 sycommon/config/Config.py,sha256=9yO5b8WfvEDvkyrGrlwrLFasgh_-MjcEvGF20Gz5Xo4,3041
 sycommon/config/DatabaseConfig.py,sha256=ILiUuYT9_xJZE2W-RYuC3JCt_YLKc1sbH13-MHIOPhg,804
 sycommon/config/EmbeddingConfig.py,sha256=gPKwiDYbeu1GpdIZXMmgqM7JqBIzCXi0yYuGRLZooMI,362
@@ -8,6 +8,8 @@ sycommon/config/LLMConfig.py,sha256=yU-aIqePIeF6msfRVEtGq7SXZVDfHyTi6JduKjhMO_4,
 sycommon/config/MQConfig.py,sha256=_RDcmIdyWKjmgM5ZnriOoI-DpaxgXs7CD0awdAD6z88,252
 sycommon/config/RerankerConfig.py,sha256=dohekaY_eTynmMimIuKHBYGXXQO6rJjSkm94OPLuMik,322
 sycommon/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sycommon/database/async_base_db_service.py,sha256=w6ONUiTtF4-bXRnkBt9QpL9BAy0XUDbQG7F9Hf2rfjw,1337
+sycommon/database/async_database_service.py,sha256=4Ag5PH6DFEcJOXR8MRF9V_Jho5uCoU9Ibo3PqulDsXw,3916
 sycommon/database/base_db_service.py,sha256=J5ELHMNeGfzA6zVcASPSPZ0XNKrRY3_gdGmVkZw3Mto,946
 sycommon/database/database_service.py,sha256=mun5vgM7nkuH6_UyHLHqQ2Qk_5gRgMxJu4_obIKLT6o,3253
 sycommon/health/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -15,6 +17,7 @@ sycommon/health/health_check.py,sha256=EhfbhspRpQiKJaxdtE-PzpKQO_ucaFKtQxIm16F5M
 sycommon/health/metrics.py,sha256=fHqO73JuhoZkNPR-xIlxieXiTCvttq-kG-tvxag1s1s,268
 sycommon/health/ping.py,sha256=FTlnIKk5y1mPfS1ZGOeT5IM_2udF5aqVLubEtuBp18M,250
 sycommon/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sycommon/logging/async_sql_logger.py,sha256=_OY36XkUm__U3NhMgiecy-qd-nptZ_0gpE3J8lGAr58,2619
 sycommon/logging/kafka_log.py,sha256=viqJ2hDqnyX5eUKkhIhU__kytIwe6nLuHIAFGcaRpUI,21118
 sycommon/logging/logger_wrapper.py,sha256=TiHsrIIHiQMzXgXK12-0KIpU9GhwQJOoHslakzmq2zc,357
 sycommon/logging/sql_logger.py,sha256=aEU3OGnI_51Tjyuuf4FpUi9KPTceFRuKAOyQbPzGhzM,2021
@@ -50,10 +53,10 @@ sycommon/synacos/nacos_service.py,sha256=tyh_JOjjoCGiKCr1xfU7MAmu7dDQCZmTzmYsSqN
 sycommon/synacos/param.py,sha256=KcfSkxnXOa0TGmCjY8hdzU9pzUsA8-4PeyBKWI2-568,1765
 sycommon/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/tools/docs.py,sha256=OPj2ETheuWjXLyaXtaZPbwmJKfJaYXV5s4XMVAUNrms,1607
-sycommon/tools/snowflake.py,sha256=wSATJzWGb6HcaZ1u_fdzF6I5seRviQQm2KS3Jf45nm4,8520
+sycommon/tools/snowflake.py,sha256=lVEe5mNCOgz5OqGQpf5_nXaGnRJlI2STX2s-ppTtanA,11947
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.55b0.dist-info/METADATA,sha256=9K3VD62twbBtlxjoty9K0h96O74lp2NFfqtviimdqGM,7050
-sycommon_python_lib-0.1.55b0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.55b0.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.55b0.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.55b0.dist-info/RECORD,,
+sycommon_python_lib-0.1.55b1.dist-info/METADATA,sha256=5TLw8YgSNN_ByzdLmVQ5RBoP3xnSAdhnVlRtY90Gp-4,7086
+sycommon_python_lib-0.1.55b1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.55b1.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.55b1.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.55b1.dist-info/RECORD,,