funboost 42.9__tar.gz → 43.1__tar.gz

{funboost-42.9/funboost.egg-info → funboost-43.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 42.9
+Version: 43.1
 Summary: pip install funboost，python全功能分布式函数调度框架,。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs

{funboost-42.9 → funboost-43.1}/funboost/__init__.py

@@ -13,7 +13,7 @@ set_frame_config这个模块的 use_config_form_funboost_config_module() 是核
 这段注释说明和使用的用户无关,只和框架开发人员有关.
 '''
 
-__version__ = "42.9"
+__version__ = "43.1"
 
 from funboost.set_frame_config import show_frame_config
 

{funboost-42.9 → funboost-43.1}/funboost/constant.py

@@ -89,5 +89,6 @@ class ConcurrentModeEnum:
     EVENTLET = 'eventlet'
     ASYNC = 'async'  # asyncio并发，适用于async def定义的函数。
     SINGLE_THREAD = 'single_thread'  # 如果你不想并发，不想预先从消息队列中间件拉取消息到python程序的内存queue队列缓冲中，那么就适合使用此并发模式。
+    SOLO = SINGLE_THREAD
 
 # is_fsdf_remote_run = 0

{funboost-42.9 → funboost-43.1}/funboost/consumers/base_consumer.py

@@ -7,6 +7,7 @@
 
 框架做主要的功能都是在这个文件里面实现的.
 """
+import functools
 import typing
 import abc
 import copy
@@ -29,10 +30,11 @@ from threading import Lock
 import asyncio
 
 import nb_log
-from funboost.core.current_task import funboost_current_task
+from funboost.core.current_task import funboost_current_task, get_current_taskid
 from funboost.core.loggers import develop_logger
 
 from funboost.core.func_params_model import BoosterParams, PublisherParams
+from funboost.core.task_id_logger import TaskIdLogger
 from nb_log import (get_logger, LoggerLevelSetterMixin, LogManager, CompatibleLogger,
                     LoggerMixinDefaultWithFileHandler, stdout_write, is_main_process,
                     nb_log_config_default)
@@ -67,6 +69,8 @@ from funboost.utils import decorators, time_util, redis_manager
 from funboost.constant import ConcurrentModeEnum, BrokerEnum
 from funboost.core import kill_remote_task
 from funboost.core.exceptions import ExceptionForRequeue, ExceptionForPushToDlxqueue
+# from funboost.core.booster import BoostersManager  互相导入
+from funboost.core.lazy_impoter import LazyImpoter
 
 
 # patch_apscheduler_run_job()
@@ -76,9 +80,6 @@ class GlobalVars:
     has_start_a_consumer_flag = False
 
 
-
-
-
 # noinspection DuplicatedCode
 class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
     time_interval_for_check_do_not_run_time = 60
@@ -218,6 +219,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                                                 logger_prefix=consumer_params.logger_prefix,
                                                 create_logger_file=consumer_params.create_logger_file,
                                                 log_filename=consumer_params.log_filename,
+                                                logger_name=consumer_params.logger_name,
                                                 broker_exclusive_config=self.consumer_params.broker_exclusive_config)
         if is_main_process:
             self.logger.info(f'{self.queue_name} consumer 的消费者配置:\n {self.consumer_params.json_str_value()}')
@@ -228,13 +230,14 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         if logger_prefix != '':
             logger_prefix += '--'
             # logger_name = f'{logger_prefix}{self.__class__.__name__}--{concurrent_name}--{queue_name}--{self.consuming_function.__name__}'
-        logger_name = f'funboost.{logger_prefix}{self.__class__.__name__}--{self.queue_name}'
+        logger_name = self.consumer_params.logger_name or  f'funboost.{logger_prefix}{self.__class__.__name__}--{self.queue_name}'
+        self.logger_name = logger_name
         log_filename = self.consumer_params.log_filename or f'funboost.{self.queue_name}.log'
-        self.logger = get_logger(logger_name,
-                                 log_level_int=self.consumer_params.log_level,
-                                 log_filename=log_filename if self.consumer_params.create_logger_file else None,
-                                 error_log_filename=nb_log.generate_error_file_name(log_filename),
-                                 formatter_template=FunboostCommonConfig.NB_LOG_FORMATER_INDEX_FOR_CONSUMER_AND_PUBLISHER, )
+        self.logger = LogManager(logger_name, logger_cls=TaskIdLogger).get_logger_and_add_handlers(
+            log_level_int=self.consumer_params.log_level,
+            log_filename=log_filename if self.consumer_params.create_logger_file else None,
+            error_log_filename=nb_log.generate_error_file_name(log_filename),
+            formatter_template=FunboostCommonConfig.NB_LOG_FORMATER_INDEX_FOR_CONSUMER_AND_PUBLISHER, )
         self.logger.info(f'队列 {self.queue_name} 的日志写入到 {nb_log_config_default.LOG_PATH} 文件夹的 {log_filename} 和 {nb_log.generate_error_file_name(log_filename)} 文件中')
 
     def _check_broker_exclusive_config(self):
@@ -362,8 +365,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         key = 'apscheduler.redisjobstore_runonce'
         if RedisMixin().redis_db_frame.sadd(key, runonce_uuid):  # 这样可以阻止多次启动同队列名消费者 redis jobstore多次运行函数.
             cls.logger_apscheduler.debug(f'延时任务用普通消息重新发布到普通队列 {msg}')
-            from funboost.core.booster import BoostersManager
-            BoostersManager.get_or_create_booster_by_queue_name(queue_name).publish(msg)
+            LazyImpoter().BoostersManager.get_or_create_booster_by_queue_name(queue_name).publish(msg)
 
     @abc.abstractmethod
     def _shedual_task(self):
@@ -603,9 +605,10 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         t_start = time.time()
         # function_result_status.run_times = current_retry_times + 1
         fct = funboost_current_task()
-        fct.function_params=function_only_params
-        fct.full_msg=kw['body']
+        fct.function_params = function_only_params
+        fct.full_msg = kw['body']
         fct.function_result_status = function_result_status
+        fct.logger = self.logger
         try:
             function_run = self.consuming_function
             if self._consuming_function_is_asyncio:
@@ -633,6 +636,9 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             function_result_status.success = True
             if self.consumer_params.log_level <= logging.DEBUG:
                 result_str_to_be_print = str(function_result_status.result)[:100] if len(str(function_result_status.result)) < 100 else str(function_result_status.result)[:100] + '  。。。。。  '
+                # print(funboost_current_task().task_id)
+                # print(fct.function_result_status.task_id)
+                # print(get_current_taskid())
                 self.logger.debug(f' 函数 {self.consuming_function.__name__}  '
                                   f'第{current_retry_times + 1}次 运行, 正确了，函数运行时间是 {round(time.time() - t_start, 4)} 秒,入参是 {function_only_params} , '
                                   f'结果是  {result_str_to_be_print}   {self._get_concurrent_info()}  ')
@@ -768,6 +774,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         fct.function_params = function_only_params
         fct.full_msg = kw['body']
         fct.function_result_status = function_result_status
+        fct.logger = self.logger
         try:
             corotinue_obj = self.consuming_function(**function_only_params)
             if not asyncio.iscoroutine(corotinue_obj):

{funboost-42.9 → funboost-43.1}/funboost/core/cli/discovery_boosters.py

@@ -7,7 +7,7 @@ import importlib.util
 # import nb_log
 from funboost.core.loggers import FunboostFileLoggerMixin
 from funboost.utils.decorators import flyweight
-
+from funboost.core.lazy_impoter import lazy_impoter
 
 @flyweight
 class BoosterDiscovery(FunboostFileLoggerMixin):
@@ -63,11 +63,12 @@ class BoosterDiscovery(FunboostFileLoggerMixin):
                 if Path(file_path) == Path(sys._getframe(1).f_code.co_filename):
                     self.logger.warning(f'排除导入调用auto_discovery的模块自身 {file_path}')  # 否则下面的import这个文件,会造成无限懵逼死循环
                     continue
-                spec = importlib.util.spec_from_file_location('module', file_path)
+
+                module_name = Path(file_path).as_posix().replace('/', '.') + '.' + Path(file_path).stem
+                spec = importlib.util.spec_from_file_location(module_name, file_path)
                 module = importlib.util.module_from_spec(spec)
                 spec.loader.exec_module(module)
-        from funboost.core.booster import BoostersManager
-        BoostersManager.show_all_boosters()
+        lazy_impoter.BoostersManager.show_all_boosters()
 
 
 if __name__ == '__main__':

{funboost-42.9 → funboost-43.1}/funboost/core/current_task.py

@@ -1,14 +1,10 @@
 import contextvars
+import logging
 import threading
 import asyncio
 from funboost.core.function_result_status_saver import FunctionResultStatus
 
-
-class ThreadCurrentTask:
-    """
-    用于在用户自己函数内部去获取 消息的完整体,当前重试次数等.
-    """
-    """ 用法例子 
+""" 用法例子 
     '''
     fct = funboost_current_task()
     print(fct.function_result_status.get_status_dict())
@@ -49,33 +45,54 @@ if __name__ == '__main__':
     f.consume()
 
     """
-    _local_data = threading.local()
+
+
+class __ThreadCurrentTask:
+    """
+    用于在用户自己函数内部去获取 消息的完整体,当前重试次数等.
+    """
+
+
+    _fct_local_data = threading.local()
+
 
     @property
     def function_params(self):
-        return self._local_data.function_params
+        return self._fct_local_data.function_params
 
     @function_params.setter
     def function_params(self, function_params: dict):
-        self._local_data.function_params = function_params
+        self._fct_local_data.function_params = function_params
 
     @property
     def full_msg(self) -> dict:
-        return self._local_data.full_msg
+        return self._fct_local_data.full_msg
 
     @full_msg.setter
     def full_msg(self, full_msg: dict):
-        self._local_data.full_msg = full_msg
+        self._fct_local_data.full_msg = full_msg
 
     @property
     def function_result_status(self) -> FunctionResultStatus:
-        return self._local_data.function_result_status
+        return self._fct_local_data.function_result_status
 
     @function_result_status.setter
     def function_result_status(self, function_result_status: FunctionResultStatus):
-        self._local_data.function_result_status = function_result_status
+        self._fct_local_data.function_result_status = function_result_status
 
+    @property
+    def task_id(self) -> FunctionResultStatus:
+        return self.function_result_status.task_id
+
+    @property
+    def logger(self) -> logging.Logger:
+        return self._fct_local_data.logger
 
+    @logger.setter
+    def logger(self, logger: logging.Logger):
+        self._fct_local_data.logger = logger
+
+thread_current_task = __ThreadCurrentTask()
 def is_asyncio_environment():
     try:
         loop = asyncio.get_running_loop()
@@ -84,10 +101,11 @@ def is_asyncio_environment():
         return False
 
 
-class AsyncioCurrentTask:
+class __AsyncioCurrentTask:
     _function_params = contextvars.ContextVar("function_params")
     _full_msg = contextvars.ContextVar("full_msg")
     _function_result_status = contextvars.ContextVar("function_result_status")
+    _logger = contextvars.ContextVar('logger')
 
     @property
     def function_params(self):
@@ -113,14 +131,37 @@ class AsyncioCurrentTask:
     def function_result_status(self, function_result_status: FunctionResultStatus):
         self._function_result_status.set(function_result_status)
 
+    @property
+    def task_id(self) :
+        return self.function_result_status.task_id
+
+    @property
+    def logger(self) -> logging.Logger:
+        return self._logger.get()
+
+    @logger.setter
+    def logger(self, logger: logging.Logger):
+        self._logger.set(logger)
+
+asyncio_current_task = __AsyncioCurrentTask()
 
 def funboost_current_task():
-    return AsyncioCurrentTask() if is_asyncio_environment() else ThreadCurrentTask()
+    return asyncio_current_task if is_asyncio_environment() else thread_current_task
 
 
+def get_current_taskid():
+    fct = funboost_current_task()
+    # return fct.function_result_status.task_id
+    try:
+        return fct.task_id  # 不在funboost的消费函数里面就获取不到上下文了
+    except (AttributeError,LookupError) as e:
+        # print(e,type(e))
+        return 'no_task_id'
+
 if __name__ == '__main__':
     print(is_asyncio_environment())
     print()
     for i in range(100000):
         funboost_current_task()
+        get_current_taskid()
     print()

{funboost-42.9 → funboost-43.1}/funboost/core/func_params_model.py

@@ -138,11 +138,12 @@ class BoosterParams(BaseJsonAbleModel):
     is_push_to_dlx_queue_when_retry_max_times: bool = False  # 函数达到最大重试次数仍然没成功，是否发送到死信队列,死信队列的名字是 队列名字 + _dlx。
 
     consumin_function_decorator: typing.Callable = None  # 函数的装饰器。因为此框架做参数自动转指点，需要获取精准的入参名称，不支持在消费函数上叠加 @ *args  **kwargs的装饰器，如果想用装饰器可以这里指定。
-    function_timeout: typing.Union[int, float] = 0  # 超时秒数，函数运行超过这个时间，则自动杀死函数。为0是不限制。
+    function_timeout: typing.Union[int, float] = 0  # 超时秒数，函数运行超过这个时间，则自动杀死函数。为0是不限制。 谨慎使用,非必要别去设置超时时间,设置后性能会降低(因为需要把用户函数包装到另一个线单独的程中去运行),而且突然强制超时杀死运行中函数,可能会造成死锁.(例如用户函数在获得线程锁后突然杀死函数,别的线程再也无法获得锁了)
 
     log_level: int = logging.DEBUG  # 消费者和发布者的日志级别,建议设置DEBUG级别,不然无法知道正在运行什么消息
     logger_prefix: str = ''  # 日志名字前缀,可以设置前缀
     create_logger_file: bool = True  # 发布者和消费者是否创建文件文件日志,为False则只打印控制台不写文件.
+    logger_name: str = ''  # 队列消费者发布者的日志命名空间.
     log_filename: typing.Union[str, None] = None  # 消费者发布者的文件日志名字.如果为None,则自动使用 funboost.队列 名字作为文件日志名字.  日志文件夹是在nb_log_config.py的 LOG_PATH中决定的.
     is_show_message_get_from_broker: bool = False  # 运行时候,是否记录从消息队列获取出来的消息内容
     is_print_detail_exception: bool = True  # 消费函数出错时候,是否打印详细的报错堆栈,为False则只打印简略的报错信息不包含堆栈.
@@ -160,7 +161,7 @@ class BoosterParams(BaseJsonAbleModel):
     is_using_rpc_mode: bool = False  # 是否使用rpc模式，可以在发布端获取消费端的结果回调，但消耗一定性能，使用async_result.result时候会等待阻塞住当前线程。
     rpc_result_expire_seconds: int = 600  # 保存rpc结果的过期时间.
 
-    is_support_remote_kill_task: bool = False  # 是否支持远程任务杀死功能，如果任务数量少，单个任务耗时长，确实需要远程发送命令来杀死正在运行的函数，才设置为true，否则不建议开启此功能。
+    is_support_remote_kill_task: bool = False  # 是否支持远程任务杀死功能，如果任务数量少，单个任务耗时长，确实需要远程发送命令来杀死正在运行的函数，才设置为true，否则不建议开启此功能。(是把函数放在单独的线程中实现的,随时准备线程被远程命令杀死,所以性能会降低)
 
     is_do_not_run_by_specify_time_effect: bool = False  # 是否使不运行的时间段生效
     do_not_run_by_specify_time: tuple = ('10:00:00', '22:00:00')  # 不运行的时间段,在这个时间段自动不运行函数.
@@ -193,7 +194,7 @@ class BoosterParams(BaseJsonAbleModel):
         # if not set(values.keys()).issubset(set(BoosterParams.__fields__.keys())):
         #     raise ValueError(f'{cls.__name__} 的字段包含了父类 BoosterParams 不存在的字段')
         for k in values.keys():
-            if k not in BoosterParams.__fields__.keys():
+            if k not in BoosterParams.model_fields.keys():
                 raise ValueError(f'{cls.__name__} 的字段新增了父类 BoosterParams 不存在的字段 "{k}"')  # 使 BoosterParams的子类,不能增加字段,只能覆盖字段.
         return values
 
@@ -224,7 +225,7 @@ class PriorityConsumingControlConfig(BaseJsonAbleModel):
     例如消费为add函数，可以每个独立的任务设置不同的超时时间，不同的重试次数，是否使用rpc模式。这里的配置优先，可以覆盖生成消费者时候的配置。
     """
 
-    function_timeout: typing.Union[float, int] = None
+    function_timeout: typing.Union[float, int] = 0
     max_retry_times: int = None
     is_print_detail_exception: bool = None
     msg_expire_senconds: int = None
@@ -248,6 +249,7 @@ class PublisherParams(BaseJsonAbleModel):
     log_level: int = logging.DEBUG
     logger_prefix: str = ''
     create_logger_file: bool = True
+    logger_name: str = ''  # 队列消费者发布者的日志命名空间.
     log_filename: typing.Optional[str] = None
     clear_queue_within_init: bool = False  # with 语法发布时候,先清空消息队列
     consuming_function: typing.Callable = None  # consuming_function 作用是 inspect 模块获取函数的入参信息

funboost-43.1/funboost/core/lazy_impoter.py

@@ -0,0 +1,26 @@
+from funboost.utils.decorators import cached_method_result
+
+
+class LazyImpoter:
+    """
+    延迟导入,避免需要互相导入.
+    """
+
+    @property
+    @cached_method_result
+    def BoostersManager(self):
+        from funboost.core.booster import BoostersManager
+        return BoostersManager
+
+    # @property
+    # @cached_method_result
+    # def get_current_taskid(self):
+    #     from funboost.core.current_task import get_current_taskid
+    #     return get_current_taskid
+
+lazy_impoter = LazyImpoter()
+
+if __name__ == '__main__':
+    for i in range(10000):
+        lazy_impoter.BoostersManager
+        lazy_impoter.BoostersManager

{funboost-42.9 → funboost-43.1}/funboost/core/muliti_process_enhance.py

@@ -7,12 +7,11 @@ from concurrent.futures import ProcessPoolExecutor
 from funboost.core.booster import Booster
 from funboost.core.helper_funs import run_forever
 from funboost.core.loggers import flogger
-
+from funboost.core.lazy_impoter import lazy_impoter
 
 
 def _run_consumer_in_new_process(queue_name, ):
-    from funboost.core.booster import BoostersManager
-    booster_current_pid = BoostersManager.get_or_create_booster_by_queue_name(queue_name)
+    booster_current_pid = lazy_impoter.BoostersManager.get_or_create_booster_by_queue_name(queue_name)
     # booster_current_pid = boost(**boost_params)(consuming_function)
     booster_current_pid.consume()
     # ConsumersManager.join_all_consumer_shedual_task_thread()
@@ -50,8 +49,7 @@ def run_consumer_with_multi_process(booster: Booster, process_num=1):
 
 
 def _multi_process_pub_params_list_in_new_process(queue_name, msgs: List[dict]):
-    from funboost.core.booster import BoostersManager
-    booster_current_pid = BoostersManager.get_or_create_booster_by_queue_name(queue_name)
+    booster_current_pid = lazy_impoter.BoostersManager.get_or_create_booster_by_queue_name(queue_name)
     publisher = booster_current_pid.publisher
     publisher.set_log_level(20)  # 超高速发布，如果打印详细debug日志会卡死屏幕和严重降低代码速度。
     for msg in msgs:

funboost-43.1/funboost/core/task_id_logger.py

@@ -0,0 +1,19 @@
+import functools
+
+from nb_log import CompatibleLogger
+from funboost.core.current_task import get_current_taskid
+
+
+class TaskIdLogger(CompatibleLogger):
+    """
+    如果你要使用带taskid的日志模板,一定要使用
+     LogManager('namexx',logger_cls=TaskIdLogger).get_logger_and_add_handlers(....)
+     的方式来创建logger, 就是需要指定logger_cls=TaskIdLogger ,否则的话你需要在打印日志时候 手动传递extra logger.info(msg,extra={'task_id':task_idxxx})
+     """
+    def _log(self, level, msg, args, exc_info=None, extra=None, stack_info=False):
+        extra = extra or {}
+        if 'task_id' not in extra:
+            extra['task_id'] = get_current_taskid()
+        if 'sys_getframe_n' not in extra:
+            extra['sys_getframe_n'] = 3
+        super()._log(level, msg, args, exc_info, extra, stack_info)

{funboost-42.9 → funboost-43.1}/funboost/funboost_config_deafult.py

@@ -5,6 +5,7 @@ import pytz
 from funboost.constant import BrokerEnum, ConcurrentModeEnum
 from funboost.core.func_params_model import FunctionResultStatusPersistanceConfig
 from funboost.utils.simple_data_class import DataClassBase
+from nb_log import nb_log_config_default
 
 '''
 funboost_config.py 文件是第一次运行框架自动生成到你的项目根目录的，不需要用由户手动创建。
@@ -96,7 +97,11 @@ class BrokerConnConfig(DataClassBase):
 
 class FunboostCommonConfig(DataClassBase):
     # nb_log包的第几个日志模板，内置了7个模板，可以在你当前项目根目录下的nb_log_config.py文件扩展模板。
-    NB_LOG_FORMATER_INDEX_FOR_CONSUMER_AND_PUBLISHER = 11  # 7是简短的不可跳转，5是可点击跳转的，11是可显示ip 进程 线程的模板。
+    # NB_LOG_FORMATER_INDEX_FOR_CONSUMER_AND_PUBLISHER = 11  # 7是简短的不可跳转，5是可点击跳转的，11是可显示ip 进程 线程的模板,也可以亲自设置日志模板不传递数字。
+    NB_LOG_FORMATER_INDEX_FOR_CONSUMER_AND_PUBLISHER = logging.Formatter(
+        f'%(asctime)s-({nb_log_config_default.computer_ip},{nb_log_config_default.computer_name})-[p%(process)d_t%(thread)d] - %(name)s - "%(filename)s:%(lineno)d" - %(funcName)s - %(levelname)s - %(task_id)s - %(message)s',
+        "%Y-%m-%d %H:%M:%S",)   # 这个是带task_id的日志模板,日志可以显示task_id,方便用户串联起来排查某一个人物消息的所有日志.
+
     TIMEZONE = 'Asia/Shanghai'  # 时区
 
     # 以下配置是修改funboost的一些命名空间和启动时候的日志级别,新手不熟练就别去屏蔽日志了

{funboost-42.9 → funboost-43.1}/funboost/publishers/base_publisher.py

@@ -26,6 +26,7 @@ from pikav1.exceptions import AMQPError as PikaAMQPError
 # from nb_log import LoggerLevelSetterMixin, LoggerMixin
 from funboost.core.loggers import LoggerLevelSetterMixin, FunboostFileLoggerMixin, get_logger
 from funboost.core.msg_result_getter import AsyncResult, AioAsyncResult
+from funboost.core.task_id_logger import TaskIdLogger
 from funboost.utils import decorators, time_util
 from funboost.funboost_config_deafult import BrokerConnConfig, FunboostCommonConfig
 
@@ -158,13 +159,13 @@ class AbstractPublisher(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         logger_prefix = self.publisher_params.logger_prefix
         if logger_prefix != '':
             logger_prefix += '--'
-        logger_name = f'funboost.{logger_prefix}{self.__class__.__name__}--{self.queue_name}'
-        log_filename = self.publisher_params.log_filename or f'funboost.{self.queue_name}.log'
-        self.logger = get_logger(logger_name,
-                                 log_level_int=self.publisher_params.log_level,
-                                 log_filename=log_filename if self.publisher_params.create_logger_file else None,
-                                 error_log_filename=nb_log.generate_error_file_name(log_filename),
-                                 formatter_template=FunboostCommonConfig.NB_LOG_FORMATER_INDEX_FOR_CONSUMER_AND_PUBLISHER, )
+        self.logger_name = self.publisher_params.logger_name or f'funboost.{logger_prefix}{self.__class__.__name__}--{self.queue_name}'
+        self.log_filename = self.publisher_params.log_filename or f'funboost.{self.queue_name}.log'
+        self.logger = nb_log.LogManager(self.logger_name, logger_cls=TaskIdLogger).get_logger_and_add_handlers(
+            log_level_int=self.publisher_params.log_level,
+            log_filename=self.log_filename if self.publisher_params.create_logger_file else None,
+            error_log_filename=nb_log.generate_error_file_name(self.log_filename),
+            formatter_template=FunboostCommonConfig.NB_LOG_FORMATER_INDEX_FOR_CONSUMER_AND_PUBLISHER, )
 
     def _init_count(self):
         self._current_time = time.time()
@@ -213,7 +214,7 @@ class AbstractPublisher(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         decorators.handle_exception(retry_times=10, is_throw_error=True, time_sleep=0.1)(
             self.concrete_realization_of_publish)(json.dumps(msg, ensure_ascii=False))
 
-        self.logger.debug(f'向{self._queue_name} 队列，推送消息 耗时{round(time.time() - t_start, 4)}秒  {msg_function_kw}')  # 显示msg太长了。
+        self.logger.debug(f'向{self._queue_name} 队列，推送消息 耗时{round(time.time() - t_start, 4)}秒  {msg_function_kw}', extra={'task_id': task_id})  # 显示msg太长了。
         with self._lock_for_count:
             self.count_per_minute += 1
             self.publish_msg_num_total += 1
@@ -223,9 +224,9 @@ class AbstractPublisher(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                 self._init_count()
         return AsyncResult(task_id)
 
-    def send_msg(self,msg:typing.Union[dict,str]):
+    def send_msg(self, msg: typing.Union[dict, str]):
         """直接发送任意消息内容到消息队列,不生成辅助参数,无视函数入参名字,不校验入参个数和键名"""
-        if isinstance(msg,dict):
+        if isinstance(msg, dict):
             msg = json.dumps(msg, ensure_ascii=False)
         decorators.handle_exception(retry_times=10, is_throw_error=True, time_sleep=0.1)(
             self.concrete_realization_of_publish)(msg)

{funboost-42.9 → funboost-43.1}/funboost/utils/dependency_packages_in_pythonpath/func_timeout/dafunc.py

@@ -9,12 +9,14 @@
 '''
 
 import copy
+import functools
 import inspect
 import threading
 import time
 import types
 import sys
 
+
 from .exceptions import FunctionTimedOut
 from .StoppableThread import StoppableThread
 
@@ -27,6 +29,8 @@ from functools import wraps
 __all__ = ('func_timeout', 'func_set_timeout')
 
 
+
+
 def func_timeout(timeout, func, args=(), kwargs=None):
     '''
         func_timeout - Runs the given function for up to #timeout# seconds.
@@ -60,7 +64,11 @@ def func_timeout(timeout, func, args=(), kwargs=None):
     exception = []
     isStopped = False
 
-    def funcwrap(args2, kwargs2):
+    from funboost.core.current_task import thread_current_task
+
+    def funcwrap(args2, kwargs2,_fct_local_data_dict):
+        fct = thread_current_task
+        fct._fct_local_data.__dict__.update(_fct_local_data_dict)  # 把funboost的消费线程上下文需要传递到超时线程上下文里面来.
         try:
             ret.append( func(*args2, **kwargs2) )
         except FunctionTimedOut:
@@ -76,7 +84,9 @@ def func_timeout(timeout, func, args=(), kwargs=None):
                 e.__traceback__ = exc_info[2].tb_next
                 exception.append( e )
 
-    thread = StoppableThread(target=funcwrap, args=(args, kwargs))
+
+    # fct = funboost_current_task()
+    thread = StoppableThread(target=funcwrap, args=(args, kwargs,thread_current_task._fct_local_data.__dict__))
     thread.daemon = True
 
     thread.start()

{funboost-42.9 → funboost-43.1}/funboost/utils/mongo_util.py

@@ -1,12 +1,17 @@
 # -*- coding: utf-8 -*-
 # @Author  : ydf
 # @Time    : 2022/9/17 0017 15:26
+import functools
 import os
 import pymongo
-from funboost.funboost_config_deafult import BrokerConnConfig
 from funboost.utils import decorators
 
 
+@functools.lru_cache()
+def _get_mongo_url():
+    from funboost.funboost_config_deafult import BrokerConnConfig
+    return BrokerConnConfig.MONGO_CONNECT_URL
+
 class MongoMixin0000:
     """
     mixin类被继承，也可以直接实例化。
@@ -20,7 +25,7 @@ class MongoMixin0000:
     @property
     @decorators.cached_method_result
     def mongo_client(self):
-        return pymongo.MongoClient(BrokerConnConfig.MONGO_CONNECT_URL, connect=False)  # connect等于False原因见注释
+        return pymongo.MongoClient(_get_mongo_url(), connect=False)  # connect等于False原因见注释
 
     @property
     @decorators.cached_method_result
@@ -46,7 +51,7 @@ class MongoMixin:
         pid = os.getpid()
         key = pid
         if key not in MongoMixin.processid__client_map:
-            MongoMixin.processid__client_map[key] = pymongo.MongoClient(BrokerConnConfig.MONGO_CONNECT_URL,
+            MongoMixin.processid__client_map[key] = pymongo.MongoClient(_get_mongo_url(),
                                                                         connect=False, maxIdleTimeMS=60 * 1000, minPoolSize=3, maxPoolSize=20)
         return MongoMixin.processid__client_map[key]
 

{funboost-42.9 → funboost-43.1}/funboost/utils/time_util.py

@@ -1,13 +1,18 @@
 # coding=utf-8
+import functools
 import typing
 import datetime
 import time
 import re
 import pytz
-from funboost.funboost_config_deafult import BrokerConnConfig,FunboostCommonConfig
+
 
 from funboost.utils import nb_print
 
+@functools.lru_cache()
+def _get_funboost_timezone():
+    from funboost.funboost_config_deafult import FunboostCommonConfig
+    return FunboostCommonConfig.TIMEZONE
 
 def build_defualt_date():
     """
@@ -78,11 +83,11 @@ class DatetimeConverter:
         elif isinstance(datetimex, (int, float)):
             if datetimex < 1:
                 datetimex += 86400
-            self.datetime_obj = datetime.datetime.fromtimestamp(datetimex, tz=pytz.timezone(FunboostCommonConfig.TIMEZONE))  # 时间戳0在windows会出错。
+            self.datetime_obj = datetime.datetime.fromtimestamp(datetimex, tz=pytz.timezone(_get_funboost_timezone()))  # 时间戳0在windows会出错。
         elif isinstance(datetimex, datetime.datetime):
             self.datetime_obj = datetimex
         elif datetimex is None:
-            self.datetime_obj = datetime.datetime.now(tz=pytz.timezone(FunboostCommonConfig.TIMEZONE))
+            self.datetime_obj = datetime.datetime.now(tz=pytz.timezone(_get_funboost_timezone()))
         else:
             raise ValueError('实例化时候的传参不符合规定')
 

{funboost-42.9 → funboost-43.1/funboost.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 42.9
+Version: 43.1
 Summary: pip install funboost，python全功能分布式函数调度框架,。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs

{funboost-42.9 → funboost-43.1}/funboost.egg-info/SOURCES.txt

@@ -100,9 +100,11 @@ funboost/core/function_result_status_config.py
 funboost/core/function_result_status_saver.py
 funboost/core/helper_funs.py
 funboost/core/kill_remote_task.py
+funboost/core/lazy_impoter.py
 funboost/core/loggers.py
 funboost/core/msg_result_getter.py
 funboost/core/muliti_process_enhance.py
+funboost/core/task_id_logger.py
 funboost/core/try_get_user_funboost_common_config.py
 funboost/core/cli/__init__.py
 funboost/core/cli/discovery_boosters.py

{funboost-42.9 → funboost-43.1}/funboost.egg-info/requires.txt

@@ -1,4 +1,4 @@
-nb_log>=12.2
+nb_log>=12.4
 eventlet==0.33.3
 gevent==22.10.2
 pymongo==4.3.3

{funboost-42.9 → funboost-43.1}/setup.py

@@ -62,7 +62,7 @@ setup(
         'Topic :: Software Development :: Libraries'
     ],
     install_requires=[
-        'nb_log>=12.2',
+        'nb_log>=12.4',
         'eventlet==0.33.3',
         'gevent==22.10.2',
         'pymongo==4.3.3',  # 3.5.1  -> 4.0.2