funboost 49.1__py3-none-any.whl → 49.2__py3-none-any.whl

funboost/__init__.py

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

funboost/concurrent_pool/async_helper.py

@@ -9,6 +9,21 @@ async_executor_default = ThreadPoolExecutorShrinkAble(500)
 # async_executor_default = FlexibleThreadPool(50)  # 这个不支持future特性
 
 
+def get_or_create_event_loop():
+    try:
+        # Python 3.7+
+        return asyncio.get_running_loop()
+    except RuntimeError:
+        # 没有正在运行的 loop
+        try:
+            # Python 3.6~3.9：get_event_loop 会自动创建
+            return asyncio.get_event_loop()
+        except RuntimeError:
+            # Python 3.10+：get_event_loop 不再自动创建
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            return loop
+        
 async def simple_run_in_executor(f, *args, async_executor: Executor = None, async_loop=None, **kwargs):
     """
     一个很强的函数，使任意同步同步函数f，转化成asyncio异步api语法，
@@ -31,13 +46,17 @@ async def simple_run_in_executor(f, *args, async_executor: Executor = None, asyn
     :param kwargs:f函数的关键字方式入参
     :return:
     """
-    loopx = async_loop or asyncio.get_event_loop()
+    loopx = async_loop or get_or_create_event_loop()
     async_executorx = async_executor or async_executor_default
     # print(id(loopx))
     result = await loopx.run_in_executor(async_executorx, partial(f, *args, **kwargs))
     return result
 
 
+
+
+
+
 if __name__ == '__main__':
     import time
     import requests

funboost/concurrent_pool/async_pool_executor.py

@@ -62,28 +62,27 @@ class AsyncPoolExecutorLtPy310(FunboostFileLoggerMixin,FunboostBaseConcurrentPoo
         self._size = size
         self.loop = loop or asyncio.new_event_loop()
         asyncio.set_event_loop(self.loop)
-        self._sem = asyncio.Semaphore(self._size, loop=self.loop)
-        self._queue = asyncio.Queue(maxsize=size, loop=self.loop)
-        self._lock = threading.Lock()
-        t = Thread(target=self._start_loop_in_new_thread, daemon=True)
+        self._diff_init()
+        # self._lock = threading.Lock()
+        t = Thread(target=self._start_loop_in_new_thread, daemon=False)
         # t.setDaemon(True)  # 设置守护线程是为了有机会触发atexit，使程序自动结束，不用手动调用shutdown
         t.start()
-        self._can_be_closed_flag = False
-        atexit.register(self.shutdown)
-
-        self._event = threading.Event()
-        # print(self._event.is_set())
-        self._event.set()
-
-    def submit000(self, func, *args, **kwargs):
-        # 这个性能比下面的采用 run_coroutine_threadsafe + result返回快了3倍多。
-        with self._lock:
-            while 1:
-                if not self._queue.full():
-                    self.loop.call_soon_threadsafe(self._queue.put_nowait, (func, args, kwargs))
-                    break
-                else:
-                    time.sleep(0.01)
+     
+
+    # def submit000(self, func, *args, **kwargs):
+    #     # 这个性能比下面的采用 run_coroutine_threadsafe + result返回快了3倍多。
+    #     with self._lock:
+    #         while 1:
+    #             if not self._queue.full():
+    #                 self.loop.call_soon_threadsafe(self._queue.put_nowait, (func, args, kwargs))
+    #                 break
+    #             else:
+    #                 time.sleep(0.01)
+
+    def _diff_init(self):
+        self._sem = asyncio.Semaphore(self._size, loop=self.loop)
+        self._queue = asyncio.Queue(maxsize=self._size, loop=self.loop)
+
 
     def submit(self, func, *args, **kwargs):
         future = asyncio.run_coroutine_threadsafe(self._produce(func, *args, **kwargs), self.loop)  # 这个 run_coroutine_threadsafe 方法也有缺点，消耗的性能巨大。
@@ -114,51 +113,36 @@ class AsyncPoolExecutorLtPy310(FunboostFileLoggerMixin,FunboostBaseConcurrentPoo
         # self._loop.run_forever()
 
         # asyncio.set_event_loop(self.loop)
-        self.loop.run_until_complete(asyncio.wait([self._consume() for _ in range(self._size)], loop=self.loop))
-        self._can_be_closed_flag = True
+        # self.loop.run_until_complete(asyncio.wait([self._consume() for _ in range(self._size)], loop=self.loop))
+        # self._can_be_closed_flag = True
+        [self.loop.create_task(self._consume()) for _ in range(self._size)]
+        try:
+            self.loop.run_forever()
+        except Exception as e:
+            self.logger.warning(f'{e}')   # 如果多个线程使用一个loop，不能重复启动loop，否则会报错。
+
+
 
-    def shutdown(self):
-        if self.loop.is_running():  # 这个可能是atregster触发，也可能是用户手动调用，需要判断一下，不能关闭两次。
-            for i in range(self._size):
-                self.submit(f'stop{i}', )
-            while not self._can_be_closed_flag:
-                time.sleep(0.1)
-            self.loop.stop()
-            self.loop.close()
-            print('关闭循环')
+    # def shutdown(self):
+    #     if self.loop.is_running():  # 这个可能是atregster触发，也可能是用户手动调用，需要判断一下，不能关闭两次。
+    #         for i in range(self._size):
+    #             self.submit(f'stop{i}', )
+    #         while not self._can_be_closed_flag:
+    #             time.sleep(0.1)
+    #         self.loop.stop()
+    #         self.loop.close()
+    #         print('关闭循环')
 
 
 
 class AsyncPoolExecutorGtPy310(AsyncPoolExecutorLtPy310):
-    # noinspection PyMissingConstructor
-    def __init__(self, size, loop=None):
-        """
 
-        :param size: 同时并发运行的协程任务数量。
-        :param loop:
-        """
-        self._size = size
-        self.loop = loop or asyncio.new_event_loop()
-        self._sem = asyncio.Semaphore(self._size, )
-        self._queue = asyncio.Queue(maxsize=size, )
-        self._lock = threading.Lock()
-        t = Thread(target=self._start_loop_in_new_thread, daemon=True)
-        # t.setDaemon(True)  # 设置守护线程是为了有机会触发atexit，使程序自动结束，不用手动调用shutdown
-        t.start()
-        self._can_be_closed_flag = False
-        atexit.register(self.shutdown)
+    def _diff_init(self):
+        self._sem = asyncio.Semaphore(self._size, ) # python3.10后，很多类和方法都删除了loop传参
+        self._queue = asyncio.Queue(maxsize=self._size, )
 
-        self._event = threading.Event()
-        # print(self._event.is_set())
-        self._event.set()
 
-    def _start_loop_in_new_thread(self, ):
-        # self._loop.run_until_complete(self.__run())  # 这种也可以。
-        # self._loop.run_forever()
 
-        # asyncio.set_event_loop(self.loop)
-        self.loop.run_until_complete(asyncio.wait([self.loop.create_task(self._consume()) for _ in range(self._size)], ))
-        self._can_be_closed_flag = True
 
 
 AsyncPoolExecutor = AsyncPoolExecutorLtPy310 if sys.version_info.minor < 10 else AsyncPoolExecutorGtPy310

funboost/concurrent_pool/backup/async_pool_executor_back.py

@@ -4,7 +4,9 @@ import threading
 import time
 import traceback
 from threading import Thread
-import nb_log  # noqa
+import nb_log
+
+from funboost.concurrent_pool.async_helper import get_or_create_event_loop  # noqa
 
 # if os.name == 'posix':
 #     import uvloop
@@ -215,7 +217,7 @@ class AsyncProducerConsumer:
             task.cancel()
 
     def start_run(self):
-        loop = asyncio.get_event_loop()
+        loop = get_or_create_event_loop()
         loop.run_until_complete(self.__run())
         # loop.close()
 

funboost/constant.py

@@ -1,9 +1,9 @@
 # coding= utf-8
-from calendar import c
+
 
 
 class BrokerEnum:
-    EMPTY = 'empty'  # 空的实现，需要搭配 boost入参的 consumer_override_cls 和 publisher_override_cls使用，或者被继承。
+    EMPTY = 'EMPTY'  # 空的实现，需要搭配 boost入参的 consumer_override_cls 和 publisher_override_cls使用，或者被继承。
 
     RABBITMQ_AMQPSTORM = 'RABBITMQ_AMQPSTORM'  # 使用 amqpstorm 包操作rabbitmq  作为 分布式消息队列，支持消费确认.强烈推荐这个作为funboost中间件。
     RABBITMQ = RABBITMQ_AMQPSTORM
@@ -73,7 +73,7 @@ class BrokerEnum:
     PEEWEE = 'PEEWEE'  # peewee包操作mysql，使用表模拟消息队列
 
     CELERY = 'CELERY'  # funboost支持celery框架来发布和消费任务，由celery框架来调度执行任务，但是写法简单远远暴击用户亲自使用celery的麻烦程度，
-    # 用户永无无需关心和操作Celery对象实例,无需关心celery的task_routes和include配置,funboost来自动化设置这些celery配置。
+    # 用户永无无需关心和操作Celery对象实例,无需关心celery的task_routes和includes配置,funboost来自动化设置这些celery配置。
 
     DRAMATIQ = 'DRAMATIQ'  # funboost使用 dramatiq 框架作为消息队列，dramatiq类似celery也是任务队列框架。用户使用funboost api来操作dramatiq核心调度。
 
@@ -108,7 +108,10 @@ class ConstStrForClassMethod:
     OBJ_INIT_PARAMS = 'obj_init_params'
     CLS_MODULE = 'cls_module'
     CLS_FILE = 'cls_file'
+
+
 class RedisKeys:
+
     REDIS_KEY_PAUSE_FLAG  = 'funboost_pause_flag' 
     REDIS_KEY_STOP_FLAG = 'funboost_stop_flag'
     QUEUE__MSG_COUNT_MAP = 'funboost_queue__msg_count_map'
@@ -117,10 +120,17 @@ class RedisKeys:
     FUNBOOST_QUEUE__RUN_FAIL_COUNT_MAP = 'funboost_queue__run_fail_count_map'
     FUNBOOST_ALL_QUEUE_NAMES = 'funboost_all_queue_names'
     FUNBOOST_ALL_IPS = 'funboost_all_ips'
+    FUNBOOST_LAST_GET_QUEUE_PARAMS_AND_ACTIVE_CONSUMERS_AND_REPORT__UUID_TS = 'funboost_last_get_queue_params_and_active_consumers_and_report__uuid_ts'
+
 
     FUNBOOST_HEARTBEAT_QUEUE__DICT_PREFIX = 'funboost_hearbeat_queue__dict:'
     FUNBOOST_HEARTBEAT_SERVER__DICT_PREFIX = 'funboost_hearbeat_server__dict:'
 
+
+    @staticmethod
+    def gen_funboost_apscheduler_redis_lock_key_by_queue_name(queue_name):
+        return f'funboost.BackgroundSchedulerProcessJobsWithinRedisLock:{queue_name}'
+
     @staticmethod
     def gen_funboost_hearbeat_queue__dict_key_by_queue_name(queue_name):
         return f'{RedisKeys.FUNBOOST_HEARTBEAT_QUEUE__DICT_PREFIX}{queue_name}'
@@ -128,3 +138,17 @@ class RedisKeys:
     @staticmethod
     def gen_funboost_hearbeat_server__dict_key_by_ip(ip):
         return f'{RedisKeys.FUNBOOST_HEARTBEAT_SERVER__DICT_PREFIX}{ip}'
+    
+    @staticmethod
+    def gen_funboost_queue_time_series_data_key_by_queue_name(queue_name):
+        return f'funboost_queue_time_series_data:{queue_name}'
+    
+    @staticmethod
+    def gen_funboost_redis_apscheduler_jobs_key_by_queue_name(queue_name):
+        jobs_key=f'funboost.apscheduler.jobs:{queue_name}'
+        return jobs_key
+    
+    @staticmethod
+    def gen_funboost_redis_apscheduler_run_times_key_by_queue_name(queue_name):
+        run_times_key=f'funboost.apscheduler.run_times:{queue_name}'
+        return run_times_key

funboost/consumers/base_consumer.py

@@ -58,7 +58,7 @@ from funboost.core.function_result_status_saver import ResultPersistenceHelper,
 
 from funboost.core.helper_funs import delete_keys_and_return_new_dict, get_publish_time, MsgGenerater
 
-from funboost.concurrent_pool.async_helper import simple_run_in_executor
+from funboost.concurrent_pool.async_helper import get_or_create_event_loop, simple_run_in_executor
 from funboost.concurrent_pool.async_pool_executor import AsyncPoolExecutor
 # noinspection PyUnresolvedReferences
 from funboost.concurrent_pool.bounded_threadpoolexcutor import \
@@ -163,9 +163,13 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         self._redis_filter_key_name = f'filter_zset:{consumer_params.queue_name}' if consumer_params.task_filtering_expire_seconds else f'filter_set:{consumer_params.queue_name}'
         filter_class = RedisFilter if consumer_params.task_filtering_expire_seconds == 0 else RedisImpermanencyFilter
         self._redis_filter = filter_class(self._redis_filter_key_name, consumer_params.task_filtering_expire_seconds)
-
+        self._redis_filter.delete_expire_filter_task_cycle()
+ 
+        # if  self.consumer_params.concurrent_mode == ConcurrentModeEnum.ASYNC and self.consumer_params.specify_async_loop is None:
+        #     self.consumer_params.specify_async_loop= get_or_create_event_loop()
         self._lock_for_count_execute_task_times_every_unit_time = Lock()
-        self._async_lock_for_count_execute_task_times_every_unit_time = asyncio.Lock()
+        if self.consumer_params.concurrent_mode == ConcurrentModeEnum.ASYNC:
+            self._async_lock_for_count_execute_task_times_every_unit_time = asyncio.Lock()
         # self._unit_time_for_count = 10  # 每隔多少秒计数，显示单位时间内执行多少次，暂时固定为10秒。
         # self._execute_task_times_every_unit_time = 0  # 每单位时间执行了多少次任务。
         # self._execute_task_times_every_unit_time_fail =0  # 每单位时间执行了多少次任务失败。
@@ -398,14 +402,15 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         if self.consumer_params.delay_task_apscheduler_jobstores_kind == 'redis':
             jobstores = {
                 "default": RedisJobStore(**redis_manager.get_redis_conn_kwargs(),
-                                         jobs_key=f'funboost.apscheduler.{self.queue_name}.jobs',
-                                         run_times_key=f'funboost.apscheduler.{self.queue_name}.run_times',
+                                         jobs_key=RedisKeys.gen_funboost_redis_apscheduler_jobs_key_by_queue_name(self.queue_name),
+                                         run_times_key=RedisKeys.gen_funboost_redis_apscheduler_run_times_key_by_queue_name(self.queue_name),
                                          )
             }
             self._delay_task_scheduler = FunboostBackgroundSchedulerProcessJobsWithinRedisLock(timezone=FunboostCommonConfig.TIMEZONE, daemon=False,
                                                        jobstores=jobstores  # push 方法的序列化带thredignn.lock
                                                        )
-            self._delay_task_scheduler.set_process_jobs_redis_lock_key(f'funboost.BackgroundSchedulerProcessJobsWithinRedisLock.{self.queue_name}')
+            self._delay_task_scheduler.set_process_jobs_redis_lock_key(
+                RedisKeys.gen_funboost_apscheduler_redis_lock_key_by_queue_name(self.queue_name))
         elif self.consumer_params.delay_task_apscheduler_jobstores_kind == 'memory':
             jobstores = {"default": MemoryJobStore()}
             self._delay_task_scheduler = FsdfBackgroundScheduler(timezone=FunboostCommonConfig.TIMEZONE, daemon=False,

funboost/core/active_cousumer_info_getter.py

@@ -1,6 +1,8 @@
 import json
+import threading
 import time
 import typing
+import uuid
 
 from pydantic import main
 
@@ -107,7 +109,7 @@ class ActiveCousumerProcessInfoGetter(RedisMixin, FunboostFileLoggerMixin):
         """获取所有队列对应的活跃消费者进程信息，按队列名划分,不需要传入队列名，自动扫描redis键。请不要在 funboost_config.py 的redis 指定的db中放太多其他业务的缓存键值对"""
         queue_names = self.get_all_queue_names()
         infos_map = self._get_all_hearbeat_info_partition_by_redis_keys([RedisKeys.gen_funboost_hearbeat_queue__dict_key_by_queue_name(queue_name) for queue_name in queue_names])
-        self.logger.info(f'获取所有队列对应的活跃消费者进程信息，按队列名划分，结果是 {json.dumps(infos_map, indent=4)}')
+        # self.logger.info(f'获取所有队列对应的活跃消费者进程信息，按队列名划分，结果是 {json.dumps(infos_map, indent=4)}')
         return infos_map
 
     def get_all_hearbeat_info_partition_by_ip(self) -> typing.Dict[typing.AnyStr, typing.List[typing.Dict]]:
@@ -157,7 +159,7 @@ class QueueConusmerParamsGetter(RedisMixin, FunboostFileLoggerMixin):
     def get_queue_params_and_active_consumers(self):
         queue__active_consumers_map = ActiveCousumerProcessInfoGetter().get_all_hearbeat_info_partition_by_queue_name()
 
-        queue_name_list = list(queue__active_consumers_map.keys())
+        # queue_name_list = list(queue__active_consumers_map.keys())
         queue__history_run_count_map = self.get_queues_history_run_count()
         queue__history_run_fail_count_map = self.get_queues_history_run_fail_count()
 
@@ -196,7 +198,52 @@ class QueueConusmerParamsGetter(RedisMixin, FunboostFileLoggerMixin):
                 'all_consumers_total_consume_count_from_start_fail':self._sum_filed_from_active_consumers(active_consumers, 'total_consume_count_from_start_fail'),
             }
         return queue_params_and_active_consumers
-
+    
+    def cycle_get_queue_params_and_active_consumers_and_report(self,daemon=False):
+        time_interval = 10
+        report_uuid = str(uuid.uuid4()) 
+        def _inner():
+            while True:
+                t_start = time.time()
+                # 这个函数确保只有一个地方在上报数据，避免重复上报
+                report_ts = self.timestamp()
+                redis_report_uuid_ts_str = self.redis_db_frame.get(RedisKeys.FUNBOOST_LAST_GET_QUEUE_PARAMS_AND_ACTIVE_CONSUMERS_AND_REPORT__UUID_TS, )
+                if redis_report_uuid_ts_str:
+                    redis_report_uuid_ts = Serialization.to_dict(redis_report_uuid_ts_str)
+                    if redis_report_uuid_ts['report_uuid'] != report_uuid and redis_report_uuid_ts['report_ts'] > report_ts - time_interval - 10 :
+                        continue
+                self.redis_db_frame.set(RedisKeys.FUNBOOST_LAST_GET_QUEUE_PARAMS_AND_ACTIVE_CONSUMERS_AND_REPORT__UUID_TS,
+                                        Serialization.to_json_str({'report_uuid':report_uuid, 'report_ts':report_ts}))
+                
+                queue_params_and_active_consumers = self.get_queue_params_and_active_consumers()
+                for queue,item in queue_params_and_active_consumers.items():
+                    if len(item['active_consumers']) == 0:
+                        continue
+                    report_data = {k:v for k,v in item.items() if k not in ['queue_params','active_consumers']}
+                    
+                    report_data['report_ts'] = report_ts
+                    self.redis_db_frame.zadd(RedisKeys.gen_funboost_queue_time_series_data_key_by_queue_name(queue),
+                                            {Serialization.to_json_str(report_data):report_ts} )
+                    # 删除过期时序数据,只保留最近1天数据
+                    self.redis_db_frame.zremrangebyscore(
+                        RedisKeys.gen_funboost_queue_time_series_data_key_by_queue_name(queue),
+                        0, report_ts - 86400
+                    )
+                self.logger.info(f'上报时序数据耗时 {time.time() - t_start} 秒')
+
+                time.sleep(time_interval)
+        threading.Thread(target=_inner, daemon=daemon).start()
+
+    def get_time_series_data_by_queue_name(self,queue_name,start_ts=None,end_ts=None):
+        res = self.redis_db_frame.zrangebyscore(
+            RedisKeys.gen_funboost_queue_time_series_data_key_by_queue_name(queue_name),
+            max(float(start_ts or 0),self.timestamp() - 86400) ,float(end_ts or -1),withscores=True)
+        # print(res)
+        return [{'report_data':Serialization.to_dict(item[0]),'report_ts':item[1]} for item in res]
 
 if __name__ == '__main__':
-    print(Serialization.to_json_str(QueueConusmerParamsGetter().get_queue_params_and_active_consumers()))
+    # print(Serialization.to_json_str(QueueConusmerParamsGetter().get_queue_params_and_active_consumers()))
+    # QueueConusmerParamsGetter().cycle_get_queue_params_and_active_consumers_and_report()
+    print(QueueConusmerParamsGetter().get_time_series_data_by_queue_name('queue_test_g03t',1749617883,1749621483))
+    # print(QueueConusmerParamsGetter().get_time_series_data_by_queue_name('queue_test_g03t',))
+    

funboost/function_result_web/app.py

@@ -259,8 +259,20 @@ def get_message_count(broker_kind,queue_name):
             return jsonify({'count':publisher.get_message_count(),'success':True})
     return jsonify({'success':False,'msg':f'队列{queue_name}不存在'})
 
-    publisher = BoostersManager.get_cross_project_publisher(PublisherParams(queue_name=queue_name, broker_kind=broker_kind, publish_msg_log_use_full_msg=True))
-    return jsonify({'count':publisher.get_message_count(),'success':True})
+@app.route('/queue/get_time_series_data/<queue_name>',methods=['GET'])
+def get_time_series_data_by_queue_name(queue_name,):
+    """_summary_
+
+    Args:
+        queue_name (_type_): _description_
+
+    Returns:
+        _type_: _description_
+    
+    返回例如  [{'report_data': {'pause_flag': -1, 'msg_num_in_broker': 936748, 'history_run_count': '150180', 'history_run_fail_count': '46511', 'all_consumers_last_x_s_execute_count': 7, 'all_consumers_last_x_s_execute_count_fail': 0, 'all_consumers_last_x_s_avarage_function_spend_time': 3.441, 'all_consumers_avarage_function_spend_time_from_start': 4.598, 'all_consumers_total_consume_count_from_start': 1296, 'all_consumers_total_consume_count_from_start_fail': 314, 'report_ts': 1749617360.597841}, 'report_ts': 1749617360.597841}, {'report_data': {'pause_flag': -1, 'msg_num_in_broker': 936748, 'history_run_count': '150184', 'history_run_fail_count': '46514', 'all_consumers_last_x_s_execute_count': 7, 'all_consumers_last_x_s_execute_count_fail': 0, 'all_consumers_last_x_s_avarage_function_spend_time': 3.441, 'all_consumers_avarage_function_spend_time_from_start': 4.599, 'all_consumers_total_consume_count_from_start': 1299, 'all_consumers_total_consume_count_from_start_fail': 316, 'report_ts': 1749617370.628166}, 'report_ts': 1749617370.628166}] 
+    """
+    return jsonify(QueueConusmerParamsGetter().get_time_series_data_by_queue_name(
+        queue_name,request.args.get('start_ts'),request.args.get('end_ts')))
         
 @app.route('/rpc/rpc_call',methods=['POST'])
 def rpc_call():
@@ -295,6 +307,7 @@ def start_funboost_web_manager(host='0.0.0.0', port=27018,block=False):
     print('start_funboost_web_manager , sys.path :', sys.path)
     def _start_funboost_web_manager():
         app.run(debug=False, threaded=True, host=host, port=port)
+    QueueConusmerParamsGetter().cycle_get_queue_params_and_active_consumers_and_report()
     if block is  True:
         _start_funboost_web_manager()
     else:
@@ -306,7 +319,7 @@ if __name__ == '__main__':
     # app.jinja_env.auto_reload = True
     # with app.test_request_context():
     #     print(url_for('query_cols_view'))
-
+    QueueConusmerParamsGetter().cycle_get_queue_params_and_active_consumers_and_report(daemon=True)
     app.run(debug=False, threaded=True, host='0.0.0.0', port=27018)
 
     

funboost/function_result_web/app_debug_start.py

@@ -1,6 +1,10 @@
+
+
+from funboost.core.active_cousumer_info_getter import QueueConusmerParamsGetter
 from funboost.function_result_web.app import app
 
 
 if __name__ == '__main__':
+    QueueConusmerParamsGetter().cycle_get_queue_params_and_active_consumers_and_report(daemon=True)
     app.run(debug=True, threaded=True, host='0.0.0.0', port=27019)