funboost 48.0__py3-none-any.whl → 48.2__py3-none-any.whl

funboost/__init__.py

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

funboost/constant.py

@@ -1,4 +1,7 @@
 # coding= utf-8
+from calendar import c
+
+
 class BrokerEnum:
     EMPTY = 'empty'  # 空的实现，需要搭配 boost入参的 consumer_override_cls 和 publisher_override_cls使用，或者被继承。
 
@@ -106,3 +109,7 @@ class ConstStrForClassMethod:
     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'

funboost/consumers/base_consumer.py

@@ -74,7 +74,7 @@ from funboost.consumers.redis_filter import RedisFilter, RedisImpermanencyFilter
 from funboost.factories.publisher_factotry import get_publisher
 
 from funboost.utils import decorators, time_util, redis_manager
-from funboost.constant import ConcurrentModeEnum, BrokerEnum, ConstStrForClassMethod
+from funboost.constant import ConcurrentModeEnum, BrokerEnum, ConstStrForClassMethod,RedisKeys
 from funboost.core import kill_remote_task
 from funboost.core.exceptions import ExceptionForRequeue, ExceptionForPushToDlxqueue
 
@@ -164,19 +164,25 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         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._unit_time_for_count = 10  # 每隔多少秒计数，显示单位时间内执行多少次，暂时固定为10秒。
-        self._execute_task_times_every_unit_time = 0  # 每单位时间执行了多少次任务。
         self._lock_for_count_execute_task_times_every_unit_time = Lock()
-        self._current_time_for_execute_task_times_every_unit_time = time.time()
-        self._consuming_function_cost_time_total_every_unit_time = 0
-        self._last_execute_task_time = time.time()  # 最近一次执行任务的时间。
-
-        self._last_show_remaining_execution_time = 0
-        self._show_remaining_execution_time_interval = 300
-
-        self._msg_num_in_broker = 0
-        self._last_timestamp_when_has_task_in_queue = 0
-        self._last_timestamp_print_msg_num = 0
+        # self._unit_time_for_count = 10  # 每隔多少秒计数，显示单位时间内执行多少次，暂时固定为10秒。
+        # self._execute_task_times_every_unit_time = 0  # 每单位时间执行了多少次任务。
+        # self._execute_task_times_every_unit_time_fail =0  # 每单位时间执行了多少次任务失败。
+        # self._lock_for_count_execute_task_times_every_unit_time = Lock()
+        # self._current_time_for_execute_task_times_every_unit_time = time.time()
+        # self._consuming_function_cost_time_total_every_unit_time = 0
+        # self._last_execute_task_time = time.time()  # 最近一次执行任务的时间。
+        # self._last_10s_execute_count = 0
+        # self._last_10s_execute_count_fail = 0
+        #
+        # self._last_show_remaining_execution_time = 0
+        # self._show_remaining_execution_time_interval = 300
+        #
+        # self._msg_num_in_broker = 0
+        # self._last_timestamp_when_has_task_in_queue = 0
+        # self._last_timestamp_print_msg_num = 0
+
+        self.metric_calculation = MetricCalculation(self)
 
         self._result_persistence_helper: ResultPersistenceHelper
         self._check_broker_exclusive_config()
@@ -189,8 +195,8 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         self._stop_flag = None
         self._pause_flag = None  # 暂停消费标志，从reids读取
         self._last_show_pause_log_time = 0
-        self._redis_key_stop_flag = f'funboost_stop_flag:{self.queue_name}'
-        self._redis_key_pause_flag = f'funboost_pause_flag:{self.queue_name}'
+        # self._redis_key_stop_flag = f'funboost_stop_flag'
+        # self._redis_key_pause_flag = RedisKeys.REDIS_KEY_PAUSE_FLAG
 
         # 控频要用到的成员变量
         self._last_submit_task_timestamp = 0
@@ -358,7 +364,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             self._distributed_consumer_statistics.run()
             self.logger.warning(f'启动了分布式环境 使用 redis 的键 hearbeat:{self._queue_name} 统计活跃消费者 ，当前消费者唯一标识为 {self.consumer_identification}')
 
-        self.keep_circulating(60, block=False, daemon=False)(self.check_heartbeat_and_message_count)()  # 间隔时间最好比self._unit_time_for_count小整数倍，不然日志不准。
+        self.keep_circulating(60, block=False, daemon=False)(self.check_heartbeat_and_message_count)()
         if self.consumer_params.is_support_remote_kill_task:
             kill_remote_task.RemoteTaskKiller(self.queue_name, None).start_cycle_kill_task()
             self.consumer_params.is_show_message_get_from_broker = True  # 方便用户看到从消息队列取出来的消息的task_id,然后使用task_id杀死运行中的消息。
@@ -677,26 +683,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                         p.execute()
 
             with self._lock_for_count_execute_task_times_every_unit_time:
-                self._execute_task_times_every_unit_time += 1
-                self._consuming_function_cost_time_total_every_unit_time += time.time() - t_start_run_fun
-                self._last_execute_task_time = time.time()
-                if time.time() - self._current_time_for_execute_task_times_every_unit_time > self._unit_time_for_count:
-                    avarage_function_spend_time = round(self._consuming_function_cost_time_total_every_unit_time / self._execute_task_times_every_unit_time, 4)
-                    msg = f'{self._unit_time_for_count} 秒内执行了 {self._execute_task_times_every_unit_time} 次函数 [ {self.consuming_function.__name__} ] ,' \
-                          f'函数平均运行耗时 {avarage_function_spend_time} 秒。 '
-                    self.logger.info(msg)
-                    if time.time() - self._last_show_remaining_execution_time > self._show_remaining_execution_time_interval:
-                        self._msg_num_in_broker = self.publisher_of_same_queue.get_message_count()
-                        if self._msg_num_in_broker != -1:  # 有的中间件无法统计或没实现统计队列剩余数量的，统一返回的是-1，不显示这句话。
-                            # msg += f''' ，预计还需要 {time_util.seconds_to_hour_minute_second(self._msg_num_in_broker * avarage_function_spend_time / active_consumer_num)} 时间 才能执行完成 {self._msg_num_in_broker}个剩余的任务'''
-                            need_time = time_util.seconds_to_hour_minute_second(self._msg_num_in_broker / (self._execute_task_times_every_unit_time / self._unit_time_for_count) /
-                                                                                self._distributed_consumer_statistics.active_consumer_num)
-                            msg += f''' 预计还需要 {need_time} 时间 才能执行完成 队列 {self.queue_name} 中的 {self._msg_num_in_broker} 个剩余任务'''
-                            self.logger.info(msg)
-                            self._last_show_remaining_execution_time = time.time()
-                    self._current_time_for_execute_task_times_every_unit_time = time.time()
-                    self._consuming_function_cost_time_total_every_unit_time = 0
-                    self._execute_task_times_every_unit_time = 0
+                self.metric_calculation.cal(t_start_run_fun,current_function_result_status)
             self.user_custom_record_process_info_func(current_function_result_status)  # 两种方式都可以自定义,记录结果,建议继承方式,不使用boost中指定 user_custom_record_process_info_func
             if self.consumer_params.user_custom_record_process_info_func:
                 self.consumer_params.user_custom_record_process_info_func(current_function_result_status)
@@ -850,24 +837,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                     await simple_run_in_executor(push_result)
 
             # 异步执行不存在线程并发，不需要加锁。
-            self._execute_task_times_every_unit_time += 1
-            self._consuming_function_cost_time_total_every_unit_time += time.time() - t_start_run_fun
-            self._last_execute_task_time = time.time()
-            if time.time() - self._current_time_for_execute_task_times_every_unit_time > self._unit_time_for_count:
-                avarage_function_spend_time = round(self._consuming_function_cost_time_total_every_unit_time / self._execute_task_times_every_unit_time, 4)
-                msg = f'{self._unit_time_for_count} 秒内执行了 {self._execute_task_times_every_unit_time} 次函数 [ {self.consuming_function.__name__} ] ,' \
-                      f'函数平均运行耗时 {avarage_function_spend_time} 秒。 '
-                self.logger.info(msg)
-                if self._msg_num_in_broker != -1 and time.time() - self._last_show_remaining_execution_time > self._show_remaining_execution_time_interval:  # 有的中间件无法统计或没实现统计队列剩余数量的，统一返回的是-1，不显示这句话。
-                    # msg += f''' ，预计还需要 {time_util.seconds_to_hour_minute_second(self._msg_num_in_broker * avarage_function_spend_time / active_consumer_num)} 时间 才能执行完成 {self._msg_num_in_broker}个剩余的任务'''
-                    need_time = time_util.seconds_to_hour_minute_second(self._msg_num_in_broker / (self._execute_task_times_every_unit_time / self._unit_time_for_count) /
-                                                                        self._distributed_consumer_statistics.active_consumer_num)
-                    msg += f''' 预计还需要 {need_time} 时间 才能执行完成 队列 {self.queue_name} 中的 {self._msg_num_in_broker} 个剩余任务'''
-                    self.logger.info(msg)
-                    self._last_show_remaining_execution_time = time.time()
-                self._current_time_for_execute_task_times_every_unit_time = time.time()
-                self._consuming_function_cost_time_total_every_unit_time = 0
-                self._execute_task_times_every_unit_time = 0
+            self.metric_calculation.cal(t_start_run_fun, current_function_result_status)
 
             self.user_custom_record_process_info_func(current_function_result_status)  # 两种方式都可以自定义,记录结果.建议使用文档4.21.b的方式继承来重写
             await self.aio_user_custom_record_process_info_func(current_function_result_status)
@@ -954,14 +924,15 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         raise NotImplementedError
 
     def check_heartbeat_and_message_count(self):
-        self._msg_num_in_broker = self.publisher_of_same_queue.get_message_count()
-        if time.time() - self._last_timestamp_print_msg_num > 600:
-            if self._msg_num_in_broker != -1:
-                self.logger.info(f'队列 [{self._queue_name}] 中还有 [{self._msg_num_in_broker}] 个任务')
-            self._last_timestamp_print_msg_num = time.time()
-        if self._msg_num_in_broker != 0:
-            self._last_timestamp_when_has_task_in_queue = time.time()
-        return self._msg_num_in_broker
+        self.metric_calculation.msg_num_in_broker = self.publisher_of_same_queue.get_message_count()
+        self.metric_calculation.last_get_msg_num_ts = time.time()
+        if time.time() - self.metric_calculation.last_timestamp_print_msg_num > 600:
+            if self.metric_calculation.msg_num_in_broker != -1:
+                self.logger.info(f'队列 [{self._queue_name}] 中还有 [{self.metric_calculation.msg_num_in_broker}] 个任务')
+            self.metric_calculation.last_timestamp_print_msg_num = time.time()
+        if self.metric_calculation.msg_num_in_broker != 0:
+            self.metric_calculation.last_timestamp_when_has_task_in_queue = time.time()
+        return self.metric_calculation.msg_num_in_broker
 
     @abc.abstractmethod
     def _requeue(self, kw):
@@ -999,11 +970,11 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
 
     def pause_consume(self):
         """从远程机器可以设置队列为暂停消费状态，funboost框架会自动停止消费，此功能需要配置好redis"""
-        RedisMixin().redis_db_frame.set(self._redis_key_pause_flag, 1)
+        RedisMixin().redis_db_frame.hset(RedisKeys.REDIS_KEY_PAUSE_FLAG, self.queue_name,'1')
 
     def continue_consume(self):
         """从远程机器可以设置队列为暂停消费状态，funboost框架会自动继续消费，此功能需要配置好redis"""
-        RedisMixin().redis_db_frame.set(self._redis_key_pause_flag, 0)
+        RedisMixin().redis_db_frame.hset(RedisKeys.REDIS_KEY_PAUSE_FLAG, self.queue_name,'0')
 
     @decorators.FunctionResultCacher.cached_function_result_for_a_time(120)
     def _judge_is_daylight(self):
@@ -1027,9 +998,9 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         no_task_time = 0
         while 1:
             # noinspection PyBroadException
-            message_count = self._msg_num_in_broker
+            message_count = self.metric_calculation.msg_num_in_broker
             # print(message_count,self._last_execute_task_time,time.time() - self._last_execute_task_time,no_task_time)
-            if message_count == 0 and self._last_execute_task_time != 0 and (time.time() - self._last_execute_task_time) > minutes * 60:
+            if message_count == 0 and self.metric_calculation.last_execute_task_time != 0 and (time.time() - self.metric_calculation.last_execute_task_time) > minutes * 60:
                 no_task_time += 30
             else:
                 no_task_time = 0
@@ -1150,6 +1121,85 @@ def wait_for_possible_has_finish_all_tasks_by_conusmer_list(consumer_list: typin
             pool.submit(consumer.wait_for_possible_has_finish_all_tasks(minutes))
 
 
+class MetricCalculation:
+    UNIT_TIME_FOR_COUNT = 10 # 这个不要随意改,需要其他地方配合,每隔多少秒计数，显示单位时间内执行多少次，暂时固定为10秒。
+
+    def __init__(self,conusmer:AbstractConsumer) -> None:
+        self.consumer = conusmer
+
+        self.unit_time_for_count = self.UNIT_TIME_FOR_COUNT  # 
+        self.execute_task_times_every_unit_time_temp = 0  # 每单位时间执行了多少次任务。
+        self.execute_task_times_every_unit_time_temp_fail =0  # 每单位时间执行了多少次任务失败。
+        self.current_time_for_execute_task_times_every_unit_time = time.time()
+        self.consuming_function_cost_time_total_every_unit_time_tmp = 0
+        self.last_execute_task_time = time.time()  # 最近一次执行任务的时间。
+        self.last_x_s_execute_count = 0
+        self.last_x_s_execute_count_fail = 0
+        self.last_x_s_avarage_function_spend_time = None
+        self.last_show_remaining_execution_time = 0
+        self.show_remaining_execution_time_interval = 300
+        self.msg_num_in_broker = 0
+        self.last_get_msg_num_ts = 0
+        self.last_timestamp_when_has_task_in_queue = 0
+        self.last_timestamp_print_msg_num = 0
+
+        self.total_consume_count_from_start =0
+        self.total_consume_count_from_start_fail =0
+        self.total_cost_time_from_start = 0  # 函数运行累计花费时间
+        self.last_x_s_total_cost_time = None
+
+    def cal(self,t_start_run_fun:float,current_function_result_status:FunctionResultStatus):
+        self.last_execute_task_time = time.time()
+        current_msg_cost_time = time.time() - t_start_run_fun
+        self.execute_task_times_every_unit_time_temp += 1
+        self.total_consume_count_from_start  +=1
+        self.total_cost_time_from_start += current_msg_cost_time
+        if current_function_result_status.success is False:
+            self.execute_task_times_every_unit_time_temp_fail += 1
+            self.total_consume_count_from_start_fail +=1
+        self.consuming_function_cost_time_total_every_unit_time_tmp += current_msg_cost_time
+        
+        if time.time() - self.current_time_for_execute_task_times_every_unit_time > self.unit_time_for_count:
+            self.last_x_s_execute_count = self.execute_task_times_every_unit_time_temp
+            self.last_x_s_execute_count_fail = self.execute_task_times_every_unit_time_temp_fail
+            self.last_x_s_total_cost_time = self.consuming_function_cost_time_total_every_unit_time_tmp
+            self.last_x_s_avarage_function_spend_time = round(self.last_x_s_total_cost_time / self.last_x_s_execute_count, 3)
+            msg = f'{self.unit_time_for_count} 秒内执行了 {self.last_x_s_execute_count} 次函数 [ {self.consumer.consuming_function.__name__} ] ,' \
+                  f'失败了{self.last_x_s_execute_count_fail} 次,函数平均运行耗时 {self.last_x_s_avarage_function_spend_time} 秒。 '
+            self.consumer.logger.info(msg)
+            if time.time() - self.last_show_remaining_execution_time > self.show_remaining_execution_time_interval:
+                self.msg_num_in_broker = self.consumer.publisher_of_same_queue.get_message_count()
+                self.last_get_msg_num_ts = time.time()
+                if self.msg_num_in_broker != -1:  # 有的中间件无法统计或没实现统计队列剩余数量的，统一返回的是-1，不显示这句话。
+                    need_time = time_util.seconds_to_hour_minute_second(self.msg_num_in_broker / (self.execute_task_times_every_unit_time_temp / self.unit_time_for_count) /
+                                                                        self.consumer._distributed_consumer_statistics.active_consumer_num)
+                    msg += f''' 预计还需要 {need_time} 时间 才能执行完成 队列 {self.consumer.queue_name} 中的 {self.msg_num_in_broker} 个剩余任务'''
+                    self.consumer.logger.info(msg)
+                    self.last_show_remaining_execution_time = time.time()
+            self.current_time_for_execute_task_times_every_unit_time = time.time()
+            self.consuming_function_cost_time_total_every_unit_time_tmp = 0
+            self.execute_task_times_every_unit_time_temp = 0
+            self.execute_task_times_every_unit_time_temp_fail = 0
+
+    def get_report_hearbeat_info(self) ->dict:
+        return {
+            'unit_time_for_count':self.unit_time_for_count,
+            'last_x_s_execute_count':self.last_x_s_execute_count,
+            'last_x_s_execute_count_fail':self.last_x_s_execute_count_fail,
+            'last_execute_task_time':self.last_execute_task_time,
+            'last_x_s_avarage_function_spend_time':self.last_x_s_avarage_function_spend_time,
+            # 'last_show_remaining_execution_time':self.last_show_remaining_execution_time,
+            'msg_num_in_broker':self.msg_num_in_broker,
+            'current_time_for_execute_task_times_every_unit_time':self.current_time_for_execute_task_times_every_unit_time,
+            'last_timestamp_when_has_task_in_queue':self.last_timestamp_when_has_task_in_queue,
+            'total_consume_count_from_start':self.total_consume_count_from_start,
+            'total_consume_count_from_start_fail':self.total_consume_count_from_start_fail,
+            'total_cost_time_from_start':self.total_cost_time_from_start,
+            'last_x_s_total_cost_time':self.last_x_s_total_cost_time,
+            'avarage_function_spend_time_from_start':round(self.total_cost_time_from_start / self.total_consume_count_from_start,3) if self.total_consume_count_from_start else None,
+        }
+
+
 class DistributedConsumerStatistics(RedisMixin, FunboostFileLoggerMixin):
     """
     为了兼容模拟mq的中间件（例如redis，他没有实现amqp协议，redis的list结构和真mq差远了），获取一个队列有几个连接活跃消费者数量。
@@ -1186,9 +1236,18 @@ class DistributedConsumerStatistics(RedisMixin, FunboostFileLoggerMixin):
         self._server__consumer_identification_map_key_name = f'funboost_hearbeat_server__dict:{nb_log_config_default.computer_ip}'
 
     def run(self):
+        self._send_consumer_params()
         self.send_heartbeat()
         self._consumer.keep_circulating(self.SEND_HEARTBEAT_INTERVAL, block=False, daemon=False)(self.send_heartbeat)()
 
+    def _send_consumer_params(self):
+        """
+        保存队列的消费者参数，以便在web界面查看。
+        :return:
+        """
+        self.redis_db_frame.hmset('funboost_queue__consumer_parmas',{self._consumer.queue_name: self._consumer.consumer_params.json_str_value()})
+
+
     def _send_heartbeat_with_dict_value(self, redis_key, ):
         # 发送当前消费者进程心跳的，值是字典，按一个机器或者一个队列运行了哪些进程。
 
@@ -1202,10 +1261,19 @@ class DistributedConsumerStatistics(RedisMixin, FunboostFileLoggerMixin):
                     p.srem(redis_key, result)
             self._consumer_identification_map['hearbeat_datetime_str'] = time_util.DatetimeConverter().datetime_str
             self._consumer_identification_map['hearbeat_timestamp'] = self.timestamp()
+            self._consumer_identification_map.update(self._consumer.metric_calculation.get_report_hearbeat_info())
             value = Serialization.to_json_str(self._consumer_identification_map, )
             p.sadd(redis_key, value)
             p.execute()
 
+
+    def _send_msg_num(self):
+        dic = {'msg_num_in_broker':self._consumer.metric_calculation.msg_num_in_broker,
+               'last_get_msg_num_ts':self._consumer.metric_calculation.last_get_msg_num_ts,
+               'report_ts':time.time(),
+               }
+        self.redis_db_frame.hset(RedisKeys.QUEUE__MSG_COUNT_MAP, self._consumer.queue_name, json.dumps(dic))
+
     def send_heartbeat(self):
         # 根据队列名心跳的，值是字符串，方便值作为其他redis的键名
 
@@ -1222,6 +1290,7 @@ class DistributedConsumerStatistics(RedisMixin, FunboostFileLoggerMixin):
         self._send_heartbeat_with_dict_value(self._server__consumer_identification_map_key_name)
         self._show_active_consumer_num()
         self._get_stop_and_pause_flag_from_redis()
+        self._send_msg_num()
 
     def _show_active_consumer_num(self):
         self.active_consumer_num = self.redis_db_frame.scard(self._redis_key_name) or 1
@@ -1237,13 +1306,13 @@ class DistributedConsumerStatistics(RedisMixin, FunboostFileLoggerMixin):
 
     # noinspection PyProtectedMember
     def _get_stop_and_pause_flag_from_redis(self):
-        stop_flag = self.redis_db_frame.get(self._consumer._redis_key_stop_flag)
+        stop_flag = self.redis_db_frame.hget(RedisKeys.REDIS_KEY_STOP_FLAG,self._consumer.queue_name)
         if stop_flag is not None and int(stop_flag) == 1:
             self._consumer._stop_flag = 1
         else:
             self._consumer._stop_flag = 0
 
-        pause_flag = self.redis_db_frame.get(self._consumer._redis_key_pause_flag)
+        pause_flag = self.redis_db_frame.hget(RedisKeys.REDIS_KEY_PAUSE_FLAG,self._consumer.queue_name)
         if pause_flag is not None and int(pause_flag) == 1:
             self._consumer._pause_flag = 1
         else:

funboost/core/active_cousumer_info_getter.py

@@ -1,9 +1,14 @@
 import json
+import time
 import typing
 
+from pydantic import main
+
 from funboost.utils.redis_manager import RedisMixin
 
 from funboost.core.loggers import FunboostFileLoggerMixin,nb_log_config_default
+from funboost.core.serialization import Serialization
+from funboost.constant import RedisKeys
 
 class ActiveCousumerProcessInfoGetter(RedisMixin, FunboostFileLoggerMixin):
     """
@@ -23,6 +28,9 @@ class ActiveCousumerProcessInfoGetter(RedisMixin, FunboostFileLoggerMixin):
             result_dict = json.loads(result)
             if self.timestamp() - result_dict['hearbeat_timestamp'] < 15:
                 active_consumers_processor_info_list.append(result_dict)
+                if self.timestamp() - result_dict['current_time_for_execute_task_times_every_unit_time'] > 30:
+                    result_dict['last_x_s_execute_count'] = 0
+                    result_dict['last_x_s_execute_count_fail'] = 0
         return active_consumers_processor_info_list
 
     def get_all_hearbeat_info_by_queue_name(self, queue_name) -> typing.List[typing.Dict]:
@@ -67,6 +75,9 @@ class ActiveCousumerProcessInfoGetter(RedisMixin, FunboostFileLoggerMixin):
                 info_dict = json.loads(info_str)
                 if self.timestamp() - info_dict['hearbeat_timestamp'] < 15:
                     infos_map[dict_key].append(info_dict)
+                    if self.timestamp() - info_dict['current_time_for_execute_task_times_every_unit_time'] > 30:
+                        info_dict['last_x_s_execute_count'] = 0
+                        info_dict['last_x_s_execute_count_fail'] = 0
         return infos_map
 
     def get_all_hearbeat_info_partition_by_queue_name(self) -> typing.Dict[typing.AnyStr, typing.List[typing.Dict]]:
@@ -80,3 +91,72 @@ class ActiveCousumerProcessInfoGetter(RedisMixin, FunboostFileLoggerMixin):
         infos_map = self._get_all_hearbeat_info_partition_by_redis_key_prefix('funboost_hearbeat_server__dict:')
         self.logger.info(f'获取所有机器ip对应的活跃消费者进程信息，按机器ip划分，结果是 {json.dumps(infos_map, indent=4)}')
         return infos_map
+
+
+
+class QueueConusmerParamsGetter(RedisMixin, FunboostFileLoggerMixin):
+
+    def get_queue_params(self):
+        queue__consumer_params_map  = self.redis_db_frame.hgetall('funboost_queue__consumer_parmas')
+        return {k:Serialization.to_dict(v)  for k,v in queue__consumer_params_map.items()}
+
+    def get_pause_flag(self):
+        queue__pause_map = self.redis_db_frame.hgetall(RedisKeys.REDIS_KEY_PAUSE_FLAG)
+        return {k:int(v)  for k,v in queue__pause_map.items()}
+
+    def get_msg_num(self):
+        queue__msg_count_info_map = self.redis_db_frame.hgetall(RedisKeys.QUEUE__MSG_COUNT_MAP)
+        queue__msg_count_dict = {}
+        for queue_name,info_json in queue__msg_count_info_map.items():
+            info_dict = json.loads(info_json)
+            if info_dict['report_ts'] > time.time() - 15 and info_dict['last_get_msg_num_ts'] > time.time() - 1200:
+                queue__msg_count_dict[queue_name] = info_dict['msg_num_in_broker']
+        return queue__msg_count_dict
+
+    @staticmethod
+    def _sum_filed_from_active_consumers(active_consumers:typing.List[dict],filed:str):
+        s = 0
+        for c in active_consumers:
+            # print(c)
+            if c[filed]:
+                # print(c[filed])
+                s+=c[filed]
+        return s
+    
+    def get_queue_params_and_active_consumers(self):
+        queue__active_consumers_map = ActiveCousumerProcessInfoGetter().get_all_hearbeat_info_partition_by_queue_name()
+        queue__consumer_params_map  = self.get_queue_params()
+        queue__pause_map = self.get_pause_flag()
+        queue__msg_count_dict = self.get_msg_num()
+        queue_params_and_active_consumers = {}
+
+        for queue, consumer_params in  queue__consumer_params_map.items():
+            
+            active_consumers = queue__active_consumers_map.get(queue, [])
+            # print(queue,active_consumers)
+            all_consumers_last_x_s_execute_count = self._sum_filed_from_active_consumers(active_consumers,'last_x_s_execute_count')
+            all_consumers_last_x_s_execute_count_fail = self._sum_filed_from_active_consumers(active_consumers, 'last_x_s_execute_count_fail')
+            all_consumers_last_x_s_total_cost_time = self._sum_filed_from_active_consumers(active_consumers, 'last_x_s_total_cost_time')
+            all_consumers_last_x_s_avarage_function_spend_time = round( all_consumers_last_x_s_total_cost_time / all_consumers_last_x_s_execute_count,3) if all_consumers_last_x_s_execute_count else None
+            
+            all_consumers_total_consume_count_from_start = self._sum_filed_from_active_consumers(active_consumers, 'total_consume_count_from_start')
+            all_consumers_total_cost_time_from_start =self._sum_filed_from_active_consumers(active_consumers, 'total_cost_time_from_start')
+            all_consumers_avarage_function_spend_time_from_start = round(all_consumers_total_cost_time_from_start / all_consumers_total_consume_count_from_start,3) if all_consumers_total_consume_count_from_start else None
+
+            queue_params_and_active_consumers[queue] = {
+                'queue_params':consumer_params,
+                'active_consumers':active_consumers,
+                'pause_flag':queue__pause_map.get(queue,-1),
+                'msg_num_in_broker':queue__msg_count_dict.get(queue,None),
+                'all_consumers_last_x_s_execute_count':all_consumers_last_x_s_execute_count,
+                'all_consumers_last_x_s_execute_count_fail':all_consumers_last_x_s_execute_count_fail,
+                'all_consumers_last_x_s_avarage_function_spend_time':all_consumers_last_x_s_avarage_function_spend_time,
+                'all_consumers_avarage_function_spend_time_from_start':all_consumers_avarage_function_spend_time_from_start,
+                'all_consumers_total_consume_count_from_start':self._sum_filed_from_active_consumers(active_consumers, 'total_consume_count_from_start'),
+                '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
+
+
+if __name__ == '__main__':
+    print(Serialization.to_json_str(QueueConusmerParamsGetter().get_queue_params_and_active_consumers()))

funboost/core/function_result_status_saver.py

@@ -87,7 +87,7 @@ class FunctionResultStatus():
                      'insert_minutes': datetime_str[:-3],
                      })
         if not without_datetime_obj:
-            item.update({'insert_time': datetime.datetime.now(),
+            item.update({'insert_time': time_util.DatetimeConverter().datetime_obj,
                          'utime': datetime.datetime.utcnow(),
                          })
         else:

funboost/function_result_web/app.py

@@ -1,6 +1,12 @@
 # -*- coding: utf-8 -*-
 # @Author  : ydf
 # @Time    : 2022/9/18 0018 14:46
+import sys
+print(sys.path)
+
+import os
+print("PYTHONPATH:", os.environ.get('PYTHONPATH'))
+
 
 import datetime
 import json
@@ -16,8 +22,10 @@ from wtforms.validators import DataRequired, Length
 from flask_login import login_user, logout_user, login_required, LoginManager, UserMixin
 
 import nb_log
-from funboost import nb_print
+from funboost import nb_print,ActiveCousumerProcessInfoGetter,BoostersManager,PublisherParams,RedisMixin
 from funboost.function_result_web.functions import get_cols, query_result, get_speed, Statistic
+from funboost.core.active_cousumer_info_getter import QueueConusmerParamsGetter
+from funboost.constant import RedisKeys
 
 app = Flask(__name__)
 app.secret_key = 'mtfy54321'
@@ -70,11 +78,11 @@ def login():
     form = LoginForm()
     if request.method == 'POST':
 
-        nb_print(form.validate())
-        nb_print(form.password.data)
-        nb_print(form.user_name.data)
-        nb_print(form.user_name.errors)
-        nb_print(form.password.errors)
+        # nb_print(form.validate())
+        # nb_print(form.password.data)
+        # nb_print(form.user_name.data)
+        # nb_print(form.user_name.errors)
+        # nb_print(form.password.errors)
         if form.validate_on_submit():
             user = query_user(form.user_name.data)
             if user is not None and request.form['password'] == user['password']:
@@ -139,13 +147,102 @@ def speed_statistic_for_echarts():
     stat.build_result()
     return jsonify(stat.result)
 
+@app.route('/tpl/<template>')
+@login_required
+def serve_template(template):
+    # 安全检查：确保只能访问templates目录下的html文件
+    if not template.endswith('.html'):
+        return 'Invalid request', 400
+    try:
+        return render_template(template)
+    except Exception as e:
+        return f'Template not found: {template}', 404
+
+
+@app.route('/running_consumer/hearbeat_info_by_queue_name')
+def hearbeat_info_by_queue_name():
+    if request.args.get('queue_name') in ('所有',None):
+        info_map = ActiveCousumerProcessInfoGetter().get_all_hearbeat_info_partition_by_queue_name()
+        ret_list = []
+        for queue_name,dic in info_map.items():
+            ret_list.extend(dic)
+        return jsonify(ret_list)
+    else:
+        return jsonify(ActiveCousumerProcessInfoGetter().get_all_hearbeat_info_by_queue_name(request.args.get('queue_name')))
+    
+        
+
+@app.route('/running_consumer/hearbeat_info_by_ip')
+def hearbeat_info_by_ip():
+    if request.args.get('ip') in ('所有',None):
+        info_map = ActiveCousumerProcessInfoGetter().get_all_hearbeat_info_partition_by_ip()
+        ret_list = []
+        for queue_name,dic in info_map.items():
+            ret_list.extend(dic)
+        return jsonify(ret_list)
+    else:
+        return jsonify(ActiveCousumerProcessInfoGetter().get_all_hearbeat_info_by_ip(request.args.get('ip')))
+
+
+@app.route('/running_consumer/hearbeat_info_partion_by_queue_name')
+def hearbeat_info_partion_by_queue_name():
+    info_map = ActiveCousumerProcessInfoGetter().get_all_hearbeat_info_partition_by_queue_name()
+    ret_list = []
+    total_count = 0
+    for k,v in info_map.items():
+        ret_list.append({'collection_name':k,'count':len(v)})
+        total_count +=len(v)
+    ret_list = sorted(ret_list, key=lambda x: x['collection_name'])
+    ret_list.insert(0,{'collection_name':'所有','count':total_count})
+    return jsonify(ret_list)
+
+@app.route('/running_consumer/hearbeat_info_partion_by_ip')
+def hearbeat_info_partion_by_ip():
+    info_map = ActiveCousumerProcessInfoGetter().get_all_hearbeat_info_partition_by_ip()
+    ret_list = []
+    total_count = 0
+    for k,v in info_map.items():
+        ret_list.append({'collection_name':k,'count':len(v)})
+        total_count +=len(v)
+    ret_list = sorted(ret_list, key=lambda x: x['collection_name'])
+    ret_list.insert(0,{'collection_name':'所有','count':total_count})
+    print(ret_list)
+    return jsonify(ret_list)
+
+
+@app.route('/queue/params_and_active_consumers')
+def get_queue_params_and_active_consumers():
+    return jsonify(QueueConusmerParamsGetter().get_queue_params_and_active_consumers())
+
+@app.route('/queue/message_count/<broker_kind>/<queue_name>')
+def get_message_count(broker_kind,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/clear/<broker_kind>/<queue_name>',methods=['POST'])
+def clear_queue(broker_kind,queue_name):
+    publisher = BoostersManager.get_cross_project_publisher(PublisherParams(queue_name=queue_name, broker_kind=broker_kind, publish_msg_log_use_full_msg=True))
+    publisher.clear()
+    return jsonify({'success':True})
+
+@app.route('/queue/pause/<queue_name>', methods=['POST'])
+def pause_cousume(queue_name):
+    RedisMixin().redis_db_frame.hset(RedisKeys.REDIS_KEY_PAUSE_FLAG, queue_name,'1')
+    return jsonify({'success':True})
+
+@app.route('/queue/resume/<queue_name>',methods=['POST'])
+def resume_consume(queue_name):
+    RedisMixin().redis_db_frame.hset(RedisKeys.REDIS_KEY_PAUSE_FLAG, queue_name,'0')
+    return jsonify({'success':True})
+
 
 if __name__ == '__main__':
     # app.jinja_env.auto_reload = True
     # with app.test_request_context():
     #     print(url_for('query_cols_view'))
 
-    app.run(debug=False, threaded=True, host='0.0.0.0', port=27019)
+    app.run(debug=False, threaded=True, host='0.0.0.0', port=27018)
 
     '''
     linux 是export , win是 set

funboost/function_result_web/functions.py

@@ -93,8 +93,21 @@ class Statistic(LoggerMixin):
                        'recent_60_seconds': {'time_arr': [], 'count_arr': []}}
 
     def statistic_by_period(self, t_start: str, t_end: str):
-        return self.col.count_documents({'insert_time': {'$gt': time_util.DatetimeConverter(t_start).datetime_obj,
-                                                         '$lt': time_util.DatetimeConverter(t_end).datetime_obj}})
+        condition = {'insert_time': {'$gt': time_util.DatetimeConverter(t_start).datetime_obj,
+                                                         '$lt': time_util.DatetimeConverter(t_end).datetime_obj}}
+        
+        # now = datetime.datetime.now()
+        # start_time = now - datetime.timedelta(hours=1)
+        # end_time = now
+        # condition = {
+        #     'insert_time': {
+        #         '$gt': start_time,
+        #         '$lt': end_time
+        #     }
+        # }
+        count =  self.col.count_documents(condition)
+        print(count,t_start,t_end,time_util.DatetimeConverter(t_start).datetime_obj.timestamp(),condition)
+        return count
 
     def build_result(self):
         with decorators.TimerContextManager():
@@ -133,12 +146,12 @@ class Statistic(LoggerMixin):
 
 
 if __name__ == '__main__':
-    print(get_cols('4'))
+    # print(get_cols('4'))
     # pprint(query_result('queue_test54_task_status', '2019-09-15 00:00:00', '2019-09-25 00:00:00', True, '999', 0))
     # print(json.dumps(query_result(**{'col_name': 'queue_test56', 'start_time': '2019-09-18 16:03:29', 'end_time': '2019-09-21 16:03:29', 'is_success': '1', 'function_params': '', 'page': '0'}))[:1000])
     # nb_print(get_speed_last_minute('queue_test54'))
 
     # nb_print(get_speed('queue_test56', '2019-09-18 16:03:29', '2019-09-23 16:03:29'))
-    stat = Statistic('queue_test56')
+    stat = Statistic('queue_test_f01t')
     stat.build_result()
     nb_print(stat.result)