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

funboost/function_result_web/templates/queue_op.html

@@ -76,7 +76,15 @@
                     <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
                 </div>
                 <div class="modal-body">
-                    <canvas id="queueDataChart"></canvas>
+                    <!-- 新增：时间范围筛选控件 -->
+                    <div style="margin-bottom: 10px; display: flex; align-items: center;">
+                        <label style="margin-right:5px;">起始时间：</label>
+                        <input type="datetime-local" id="chartStartTime" style="margin-right: 10px;">
+                        <label style="margin-right:5px;">结束时间：</label>
+                        <input type="datetime-local" id="chartEndTime" style="margin-right: 10px;">
+                        <button class="btn btn-primary btn-sm" onclick="reloadQueueChartWithTimeRange()">查询</button>
+                    </div>
+                    <canvas id="queueDataChart" style="height:600px;max-height:600px;"></canvas>
                 </div>
                 <div class="modal-footer">
                     <button type="button" class="btn btn-default" data-dismiss="modal">关闭</button>
@@ -159,22 +167,36 @@
                     frozen: true,
                     formatter: function(cell, formatterParams, onRendered) {
                         const queueName = cell.getValue();
-                        // 根据 isAutoRefreshing 状态动态设置按钮的显示样式
-                        const buttonDisplay = isAutoRefreshing ? 'inline-block' : 'none'; 
+                        // 让按钮始终显示，不再依赖 isAutoRefreshing
                         return `<div style="display: flex; justify-content: space-between; align-items: center;">
                                     <span>${queueName}</span>
                                     <button class="btn btn-xs btn-info view-chart-btn"
                                             data-queue-name="${queueName}"
-                                            style="margin-left: 10px; display: ${buttonDisplay};"
+                                            style="margin-left: 10px; display: inline-block;"
                                             onclick="showQueueChart('${queueName}')">
                                         <i class="glyphicon glyphicon-stats"></i> 查看曲线图
                                     </button>
                                 </div>`;
                     }
                 },
+                { title: "<br><br>consumer数量", field: "consumer_count", sorter: "number", width: 200,
+                formatter: function(cell) {
+                    const row = cell.getRow().getData();
+                    var consumers = row.active_consumers;
+                    return `
+                        <div style="display: flex; align-items: center; justify-content: space-between; width: 100%; padding-right: 10px;">
+                            <span style="min-width: 50px; text-align: right; padding-right: 15px;">${cell.getValue() || ''}</span>
+                            <button class="btn btn-primary btn-sm" onclick='showConsumerDetails(${JSON.stringify(consumers)}, "${row.queue_name}")'>
+                                查看消费者详情
+                            </button>
+                        </div>
+                    `;
+                }
+            },
                 
                 { title: "<br>broker<br>类型", field: "broker_kind", sorter: "string"  },
                 { title: "<br>消费<br>函数", field: "consuming_function_name", sorter: "string"  },
+              
                 { title: "<br>历史运<br>行次数", field: "history_run_count", sorter: "number", width: 150 },
                 { title: "<br>历史运<br>行失败<br>次数", field: "history_run_fail_count", sorter: "number", width: 150 },
                 { title: "<br>近10秒<br>完成", field: "all_consumers_last_x_s_execute_count", sorter: "number", width: 100 },
@@ -196,20 +218,7 @@
                         `;
                     }
                 },
-                { title: "<br><br>consumer数量", field: "consumer_count", sorter: "number", width: 200,
-                    formatter: function(cell) {
-                        const row = cell.getRow().getData();
-                        var consumers = row.active_consumers;
-                        return `
-                            <div style="display: flex; align-items: center; justify-content: space-between; width: 100%; padding-right: 10px;">
-                                <span style="min-width: 50px; text-align: right; padding-right: 15px;">${cell.getValue() || ''}</span>
-                                <button class="btn btn-primary btn-sm" onclick='showConsumerDetails(${JSON.stringify(consumers)}, "${row.queue_name}")'>
-                                    查看消费者详情
-                                </button>
-                            </div>
-                        `;
-                    }
-                },
+
                 { 
                     title: "暂停<br>消费<br>状态",
                     field: "pause_flag",
@@ -256,16 +265,6 @@
                     all_consumers_avarage_function_spend_time_from_start:data.all_consumers_avarage_function_spend_time_from_start
                 }));
 
-                const processedTableDataForHistory = tableData.map(item => {
-                    // 确保 msg_count 用于历史记录时是数字
-                    const numericMsgCount = parseFloat(item.msg_count);
-                    return {
-                        ...item,
-                        msg_count_numeric: isNaN(numericMsgCount) ? 0 : numericMsgCount 
-                    };
-                });
-                updateHistoricalData(processedTableDataForHistory);
-
                 return tableData;
             },
         });
@@ -502,9 +501,8 @@
         let isAutoRefreshing = false;
         let autoRefreshIntervalId = null;
         const AUTO_REFRESH_INTERVAL = 10000; // 10 秒
-        let historicalData = {}; // 结构: { queueName: [{timestamp: Date.now(), history_run_count: val, ...}, ...], ... }
-        const MAX_DATA_AGE_MS = 60 * 60 * 1000; // 1 小时
-        
+        let chartInstance = null; // 用于存储Chart.js的实例
+
         // 定义需要记录并展示在图表中的列字段及其显示名称
         const CHARTABLE_FIELDS_MAP = {
             "history_run_count": "历史运行次数",
@@ -513,186 +511,165 @@
             "all_consumers_last_x_s_execute_count_fail": "近10秒失败",
             "all_consumers_last_x_s_avarage_function_spend_time": "近10秒函数运行平均耗时",
             "all_consumers_avarage_function_spend_time_from_start": "累计函数运行平均耗时",
-            "msg_count_numeric": "消息数量" // 注意：这是我们将在ajaxResponse中处理得到的数值型消息数量
+            "msg_num_in_broker": "消息数量"
         };
-        let chartInstance = null; // 用于存储Chart.js的实例
-        let activeChartQueueName = null; // 新增：跟踪当前活动图表的队列名称
-
-        // 新增：预定义的颜色数组，用于图表线条 (更新后的高区分度颜色)
+        // 预定义颜色
         const PREDEFINED_COLORS = [
-            '#E60012', // 鲜红 (Red)
-            '#005AC8', // 鲜蓝 (Blue)
-            '#00A600', // 鲜绿 (Green)
-            '#FF9900', // 亮橙 (Orange)
-            '#8B28B7', // 紫色 (Purple)
-            '#9A6324', // 棕色 (Brown)
-            '#5E8C78', // 暗青色 (Teal)
-            '#F58231', // 亮橙红 (Vermilion)
-            '#42D4F4', // 天蓝色 (Cyan)
-            '#BF6131', // 锈红色 (Rust)
-            '#3CB44B', // 另一种绿色 (Lime Green)
-            '#4363D8', // 另一种蓝色 (Indigo)
-            '#F032E6', // 品红色 (Magenta)
-            '#BCF60C', // 黄绿色 (Chartreuse)
-            '#FABEBE', // 浅粉色 (Light Pink)
-            '#AAFFC3', // 浅绿色 (Mint Green)
-            '#E6BEFF', // 浅紫色 (Lavender)
-            '#FFFAC8'  // 浅黄色 (Cream)
+            '#E60012', '#005AC8', '#00A600', '#FF9900', '#8B28B7', '#9A6324', '#5E8C78', '#F58231', '#42D4F4', '#BF6131', '#3CB44B', '#4363D8', '#F032E6', '#BCF60C', '#FABEBE', '#AAFFC3', '#E6BEFF', '#FFFAC8'
         ];
 
-        function updateHistoricalData(newDataFromTable) {
-            const now = Date.now();
-            newDataFromTable.forEach(item => {
-                const queueName = item.queue_name;
-                if (!historicalData[queueName]) {
-                    historicalData[queueName] = [];
-                }
-
-                let dataPoint = { timestamp: now };
-                Object.keys(CHARTABLE_FIELDS_MAP).forEach(fieldKey => {
-                    dataPoint[fieldKey] = item[fieldKey]; // item已经包含了转换后的msg_count_numeric
-                });
-                historicalData[queueName].push(dataPoint);
-
-                // 清理超过1小时的旧数据
-                historicalData[queueName] = historicalData[queueName].filter(dp => (now - dp.timestamp) <= MAX_DATA_AGE_MS);
-            });
-            updateActiveChartIfVisible(); // 在历史数据更新后，尝试更新活动图表
-        }
-
         function refreshTableData() {
-            console.log("Auto-refresh: refreshing table data...");
-            table.replaceData() // replaceData会重新调用ajaxURL，进而触发ajaxResponse中的updateHistoricalData
+            table.replaceData()
                 .then(() => {
                     console.log("Auto-refresh: table data refreshed successfully.");
                 })
                 .catch(error => {
                     console.error("Auto-refresh: error refreshing table data:", error);
-                    // 可以考虑在这里停止自动刷新或通知用户
                 });
         }
 
         function toggleAutoRefresh() {
             const button = document.getElementById("toggle-auto-refresh");
-            // const chartButtons = document.querySelectorAll(".view-chart-btn"); // 不再直接通过此方式控制显隐
-
-            if (isAutoRefreshing) { // 如果正在刷新，则停止
+            if (isAutoRefreshing) {
                 clearInterval(autoRefreshIntervalId);
                 isAutoRefreshing = false;
                 button.textContent = "启动自动刷新";
                 button.classList.remove("btn-danger");
                 button.classList.add("btn-success");
-                // chartButtons.forEach(btn => btn.style.display = 'none'); // Formatter将处理
-                console.log("Auto-refresh stopped.");
                 if (table) {
-                    table.redraw(true); // 强制表格重绘，formatter会根据isAutoRefreshing=false隐藏按钮
+                    table.redraw(true);
                 }
-            } else { // 如果未刷新，则启动
+            } else {
                 isAutoRefreshing = true;
                 button.textContent = "暂停自动刷新";
                 button.classList.remove("btn-success");
                 button.classList.add("btn-danger");
-                // chartButtons.forEach(btn => btn.style.display = 'inline-block'); // Formatter将处理
-                
-                refreshTableData(); // 立即执行一次刷新, 这会调用replaceData, 触发重绘, formatter会显示按钮
+                refreshTableData();
                 autoRefreshIntervalId = setInterval(refreshTableData, AUTO_REFRESH_INTERVAL);
-                console.log("Auto-refresh started. Interval ID:", autoRefreshIntervalId);
             }
         }
 
         document.getElementById("toggle-auto-refresh").addEventListener("click", toggleAutoRefresh);
 
-        // 这个函数由表格中每行的"查看图表"按钮调用
+        let currentChartQueueName = null;
+        let endTimeUserChanged = false;
+        document.getElementById("chartEndTime").addEventListener("input", function() {
+            endTimeUserChanged = true;
+        });
+        // 工具函数：将Date对象转为input[type=datetime-local]需要的本地时间字符串
+        function toDatetimeLocalString(date) {
+            const pad = n => n < 10 ? '0' + n : n;
+            return date.getFullYear() + '-' +
+                pad(date.getMonth() + 1) + '-' +
+                pad(date.getDate()) + 'T' +
+                pad(date.getHours()) + ':' +
+                pad(date.getMinutes());
+        }
         function showQueueChart(queueName) {
-            const dataForChart = historicalData[queueName] || [];
-            document.getElementById("chartQueueName").textContent = queueName; // 设置模态框标题中的队列名
-            activeChartQueueName = queueName; // 设置当前活动的图表队列名
-
-            if (chartInstance) {
-                chartInstance.destroy(); // 销毁已存在的图表实例，避免重复渲染
+            currentChartQueueName = queueName;
+            document.getElementById("chartQueueName").textContent = queueName;
+            // 设置默认时间范围：最近1小时（本地时区字符串）
+            const now = new Date();
+            const start = new Date(now.getTime() - 60 * 60 * 1000); // 1小时
+            const startStr = toDatetimeLocalString(start);
+            const endStr = toDatetimeLocalString(now);
+            const minStart = toDatetimeLocalString(new Date(now.getTime() - 24 * 60 * 60 * 1000)); // 24小时
+            document.getElementById("chartStartTime").value = startStr;
+            document.getElementById("chartEndTime").value = endStr;
+            document.getElementById("chartStartTime").setAttribute('max', endStr);
+            document.getElementById("chartStartTime").setAttribute('min', minStart);
+            document.getElementById("chartEndTime").removeAttribute('max');
+            document.getElementById("chartEndTime").setAttribute('min', minStart);
+            endTimeUserChanged = false; // 重置
+            loadQueueChartData(queueName, Math.floor(start.getTime() / 1000), Math.floor(now.getTime() / 1000));
+        }
+        function reloadQueueChartWithTimeRange() {
+            const start = document.getElementById("chartStartTime").value;
+            const end = document.getElementById("chartEndTime").value;
+            let start_ts = start ? (new Date(start).getTime() / 1000) : null;
+            let end_ts = end ? (new Date(end).getTime() / 1000) : null;
+            if (endTimeUserChanged) {
+                console.log('用户手动填写了结束时间:', end);
+            } else {
+                console.log('结束时间为默认值:', end);
             }
-            
+            loadQueueChartData(currentChartQueueName, start_ts, end_ts);
+        }
+        function loadQueueChartData(queueName, start_ts, end_ts) {
+            if (chartInstance) chartInstance.destroy();
             const chartCanvas = document.getElementById('queueDataChart');
             const ctx = chartCanvas.getContext('2d');
-
-            if (dataForChart.length === 0) {
-                // alert("队列 " + queueName + " 暂无历史数据可供展示。请等待自动刷新收集更多数据。");
-                // 可以在canvas上绘制提示信息
-                ctx.clearRect(0, 0, chartCanvas.width, chartCanvas.height); // 清空画布
-                ctx.font = "16px Arial";
-                ctx.textAlign = "center";
-                ctx.fillText("队列 " + queueName + " 暂无历史数据，请等待数据收集。", chartCanvas.width / 2, chartCanvas.height / 2);
-                $('#chartModal').modal('show');
-                return;
-            }
-
-            const labels = dataForChart.map(dp => new Date(dp.timestamp).toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit', second: '2-digit' }));
-            
-            const datasets = Object.keys(CHARTABLE_FIELDS_MAP).map((fieldKey, index) => {
-                const displayName = CHARTABLE_FIELDS_MAP[fieldKey];
-                
-                // 设置默认显示或隐藏
-                const isDefaultVisible = fieldKey === 'all_consumers_last_x_s_execute_count' || fieldKey === 'all_consumers_last_x_s_execute_count_fail';
-
-                return {
-                    label: displayName,
-                    data: dataForChart.map(dp => dp[fieldKey] === undefined || dp[fieldKey] === null ? NaN : dp[fieldKey]), // 处理可能存在的undefined或null
-                    fill: false,
-                    borderColor: PREDEFINED_COLORS[index % PREDEFINED_COLORS.length], // 使用预定义颜色
-                    backgroundColor: PREDEFINED_COLORS[index % PREDEFINED_COLORS.length] + '33', // 面积图或点的背景颜色（带透明度）
-                    tension: 0.1,
-                    pointRadius: 3, // 点的大小
-                    pointHoverRadius: 5, // 鼠标悬浮时点的大小
-                    borderWidth: 2, // 线条宽度
-                    hidden: !isDefaultVisible // 控制默认是否隐藏
-                };
-            });
-
-            chartInstance = new Chart(ctx, {
-                type: 'line',
-                data: {
-                    labels: labels,
-                    datasets: datasets
-                },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false, // 允许图表填充模态框主体
-                    scales: {
-                        x: {
-                            title: {
-                                display: true,
-                                text: '时间'
-                            }
-                        },
-                        y: {
-                            beginAtZero: false, // Y轴不一定从0开始，根据数据自适应
-                            title: {
-                                display: true,
-                                text: '数值'
-                            }
-                        }
-                    },
-                    plugins: {
-                        legend: {
-                            position: 'top',
+            ctx.clearRect(0, 0, chartCanvas.width, chartCanvas.height);
+            ctx.font = "16px Arial";
+            ctx.textAlign = "center";
+            ctx.fillText("正在加载数据...", chartCanvas.width / 2, chartCanvas.height / 2);
+            let url = `/queue/get_time_series_data/${queueName}`;
+            let params = [];
+            if (start_ts) params.push(`start_ts=${start_ts}`);
+            if (end_ts) params.push(`end_ts=${end_ts}`);
+            if (params.length > 0) url += '?' + params.join('&');
+            $.get(url, function(response) {
+                if (!response || response.length === 0) {
+                    ctx.clearRect(0, 0, chartCanvas.width, chartCanvas.height);
+                    ctx.fillText("暂无历史数据", chartCanvas.width / 2, chartCanvas.height / 2);
+                    $('#chartModal').modal('show');
+                    return;
+                }
+                // 横坐标用本地时间字符串显示
+                const labels = response.map(dp => {
+                    const d = new Date(dp.report_ts * 1000);
+                    return d.toLocaleString('zh-CN', { hour12: false });
+                });
+                const datasets = Object.keys(CHARTABLE_FIELDS_MAP).map((fieldKey, index) => {
+                    const displayName = CHARTABLE_FIELDS_MAP[fieldKey];
+                    const isDefaultVisible = fieldKey === 'all_consumers_last_x_s_execute_count' || fieldKey === 'all_consumers_last_x_s_execute_count_fail';
+                    return {
+                        label: displayName,
+                        data: response.map(dp => {
+                            let v = dp.report_data[fieldKey];
+                            if (typeof v === 'string') v = parseFloat(v);
+                            return v === undefined || v === null ? NaN : v;
+                        }),
+                        fill: false,
+                        borderColor: PREDEFINED_COLORS[index % PREDEFINED_COLORS.length],
+                        backgroundColor: PREDEFINED_COLORS[index % PREDEFINED_COLORS.length] + '33',
+                        tension: 0.4,
+                        pointRadius: 1,
+                        pointHoverRadius: 3,
+                        borderWidth: 2,
+                        hidden: !isDefaultVisible
+                    };
+                });
+                chartInstance = new Chart(ctx, {
+                    type: 'line',
+                    data: { labels, datasets },
+                    options: {
+                        responsive: true,
+                        maintainAspectRatio: false,
+                        scales: {
+                            x: {
+                                title: { display: true, text: '时间' },
+                                ticks: {
+                                    autoSkip: true,
+                                    maxTicksLimit: 20
+                                }
+                            },
+                            y: { beginAtZero: false, title: { display: true, text: '数值' } }
                         },
-                        title: {
-                            display: true,
-                            text: `队列 [${queueName}] 各项指标变化趋势`
+                        plugins: {
+                            legend: { position: 'top' },
+                            title: { display: true, text: `队列 [${queueName}] 各项指标变化趋势` },
+                            tooltip: { mode: 'index', intersect: false }
                         },
-                        tooltip: {
-                            mode: 'index',
-                            intersect: false,
-                        }
-                    },
-                    interaction: { // 增强交互性
-                        mode: 'nearest',
-                        axis: 'x',
-                        intersect: false
+                        interaction: { mode: 'nearest', axis: 'x', intersect: false }
                     }
-                }
+                });
+                $('#chartModal').modal('show');
+            }).fail(function() {
+                ctx.clearRect(0, 0, chartCanvas.width, chartCanvas.height);
+                ctx.fillText("获取数据失败", chartCanvas.width / 2, chartCanvas.height / 2);
+                $('#chartModal').modal('show');
             });
-            $('#chartModal').modal('show'); // 显示模态框
         }
 
         // 新增：模态框关闭时的处理
@@ -701,35 +678,15 @@
                 chartInstance.destroy();
                 chartInstance = null;
             }
-            activeChartQueueName = null; // 清除活动图表队列名
             console.log("Chart modal closed and instance destroyed.");
         });
 
-        // 新增：如果图表可见，则用最新数据更新它
-        function updateActiveChartIfVisible() {
-            if (activeChartQueueName && chartInstance && historicalData[activeChartQueueName]) {
-                const dataForChart = historicalData[activeChartQueueName];
-                if (dataForChart.length > 0) {
-                    const newLabels = dataForChart.map(dp => new Date(dp.timestamp).toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit', second: '2-digit' }));
-                    
-                    chartInstance.data.labels = newLabels;
-                    Object.keys(CHARTABLE_FIELDS_MAP).forEach((fieldKey, index) => {
-                        if (chartInstance.data.datasets[index]) { 
-                             chartInstance.data.datasets[index].data = dataForChart.map(dp => dp[fieldKey] === undefined || dp[fieldKey] === null ? NaN : dp[fieldKey]);
-                        }
-                    });
-                    chartInstance.update(); // 更新图表
-                    console.log(`Chart for ${activeChartQueueName} updated dynamically.`);
-                }
-            }
-        }
-
         // 新增：显示说明模态框的函数
         function showExplanationModal() {
             const explanationTextHtml = `
                 <li>消息队列的各项指标数据是 funboost 消费者每隔10秒周期上报到 redis 的，所以不是毫秒级实时，而是10秒级实时。</li>
                 <li>"更新所有队列消息数量"按钮和表格"消息数量"列的获取按钮，是实时查询 broker 的消息数量，不是基于消费者上报到 redis 的数据。（因为有的队列可能没有启动相应的消费者，也就没有上报方）</li>
-                <li>点击"启动自动刷新"按钮后，会每隔10秒更新表格的数据，并在前端内存中维护近1小时内的各种指标数据；同时，"消息队列"这一列的每行会出现"查看曲线图"按钮，点击后弹出的曲线图会动态显示内存中保存的指标数据变化趋势。</li>
+                
             `;
             document.getElementById('explanation-text').innerHTML = explanationTextHtml;
             $('#explanationModal').modal('show');

funboost/publishers/faststream_publisher.py

@@ -9,6 +9,7 @@ import time
 import typing
 
 from funboost import PriorityConsumingControlConfig
+from funboost.concurrent_pool.async_helper import get_or_create_event_loop
 from funboost.core.serialization import Serialization
 from funboost.publishers.base_publisher import AbstractPublisher
 from funboost.assist.faststream_helper import app,get_broker
@@ -23,13 +24,13 @@ class FastStreamPublisher(AbstractPublisher, metaclass=abc.ABCMeta):
         pass
         # asyncio.get_event_loop().run_until_complete(broker.start())
         self.broker = get_broker()
-        asyncio.get_event_loop().run_until_complete(self.broker.connect())
+        get_or_create_event_loop().run_until_complete(self.broker.connect())
 
     def publish(self, msg: typing.Union[str, dict], task_id=None,
                 priority_control_config: PriorityConsumingControlConfig = None) :
         msg, msg_function_kw, extra_params, task_id = self._convert_msg(msg, task_id, priority_control_config)
         t_start = time.time()
-        faststream_result =  asyncio.get_event_loop().run_until_complete(self.broker.publish(Serialization.to_json_str(msg), self.queue_name))
+        faststream_result =  get_or_create_event_loop().run_until_complete(self.broker.publish(Serialization.to_json_str(msg), self.queue_name))
         self.logger.debug(f'向{self._queue_name} 队列，推送消息 耗时{round(time.time() - t_start, 4)}秒  {msg_function_kw}')  # 显示msg太长了。
         with self._lock_for_count:
             self.count_per_minute += 1

funboost/set_frame_config.py

@@ -165,7 +165,8 @@ def _auto_creat_config_file_to_project_root_path():
     #     return
     if '/lib/python' in sys.path[1] or r'\lib\python' in sys.path[1] or '.zip' in sys.path[1]:
         raise EnvironmentError(f'''如果是cmd 或者shell启动而不是pycharm 这种ide启动脚本，请先在会话窗口设置临时PYTHONPATH为你的项目路径，
-                               windwos 使用 set PYTHONNPATH=你的当前python项目根目录,
+                               windwos cmd 使用 set PYTHONNPATH=你的当前python项目根目录,
+                               windows powershell 使用 $env:PYTHONPATH=你的当前python项目根目录,
                                linux 使用 export PYTHONPATH=你的当前你python项目根目录,
                                PYTHONPATH 作用是python的基本常识，请百度一下。
                                需要在会话窗口命令行设置临时的环境变量，而不是修改linux配置文件的方式设置永久环境变量，每个python项目的PYTHONPATH都要不一样，不要在配置文件写死

funboost/timing_job/apscheduler_use_redis_store.py

@@ -20,10 +20,11 @@ class FunboostBackgroundSchedulerProcessJobsWithinRedisLock(FunboostBackgroundSc
     继承 Custom schedulers https://apscheduler.readthedocs.io/en/3.x/extending.html   可以重写 _create_lock
     """
 
-    process_jobs_redis_lock_key = f'funboost.BackgroundSchedulerProcessJobsWithinRedisLock'
+    process_jobs_redis_lock_key = None
 
     def set_process_jobs_redis_lock_key(self, lock_key):
         self.process_jobs_redis_lock_key = lock_key
+        return self
 
     # def  _create_lock(self):
     #     return RedisDistributedBlockLockContextManager(RedisMixin().redis_db_frame,self.process_jobs_redis_lock_key,) 这个类的写法不适合固定的单例，
@@ -40,6 +41,8 @@ class FunboostBackgroundSchedulerProcessJobsWithinRedisLock(FunboostBackgroundSc
     #     return 0.1
 
     def _process_jobs(self):
+        if self.process_jobs_redis_lock_key is None:
+            raise ValueError('process_jobs_redis_lock_key is not set')
         with RedisDistributedBlockLockContextManager(RedisMixin().redis_db_frame, self.process_jobs_redis_lock_key, ):
             return super()._process_jobs()
 
@@ -50,6 +53,10 @@ jobstores = {
                              username=BrokerConnConfig.REDIS_USERNAME, jobs_key='funboost.apscheduler.jobs',run_times_key="funboost.apscheduler.run_times")
 }
 
+"""
+建议不要亲自使用这个 funboost_background_scheduler_redis_store 对象，而是 ApsJobAdder来添加定时任务，自动多个apscheduler对象实例，
+尤其是redis作为jobstores时候，使用不同的jobstores，每个消费函数使用各自单独的jobs_key和 run_times_key
+"""
 funboost_background_scheduler_redis_store = FunboostBackgroundSchedulerProcessJobsWithinRedisLock(timezone=FunboostCommonConfig.TIMEZONE, daemon=False, jobstores=jobstores)
 
 

funboost/timing_job/timing_job_base.py

@@ -131,13 +131,14 @@ class FunboostBackgroundScheduler(BackgroundScheduler):
         #
         # threading.Thread(target=_block_exit,).start()  # 既不希望用BlockingScheduler阻塞主进程也不希望定时退出。
         # self._daemon = False
-        def _when_exit():
-            while 1:
-                # print('阻止退出')
-                time.sleep(100)
-
-        if block_exit:
-            atexit.register(_when_exit)
+        # def _when_exit():
+        #     while 1:
+        #         # print('阻止退出')
+        #         time.sleep(100)
+
+        # if block_exit:
+        #     atexit.register(_when_exit)
+        self._daemon = False   # 这里强制默认改成非守护线程。默认是守护线程，主线程退出会报错。
         super().start(paused=paused, )
         # _block_exit()   # python3.9 判断守护线程结束必须主线程在运行。你自己在你的运行代碼的最末尾加上 while 1： time.sleep(100)  ,来阻止主线程退出。
 
@@ -179,10 +180,22 @@ class FunboostBackgroundScheduler(BackgroundScheduler):
 FsdfBackgroundScheduler = FunboostBackgroundScheduler  # 兼容一下名字，fsdf是 function-scheduling-distributed-framework 老框架名字的缩写
 # funboost_aps_scheduler定时配置基于内存的，不可以跨机器远程动态添加/修改/删除定时任务配置。如果需要动态增删改查定时任务，可以使用funboost_background_scheduler_redis_store
 
+"""
+建议不要亲自使用这个 funboost_aps_scheduler 对象，而是 ApsJobAdder来添加定时任务，自动多个apscheduler对象实例，
+尤其是redis作为jobstores时候，使用不同的jobstores，每个消费函数使用各自单独的jobs_key和 run_times_key
+"""
 funboost_aps_scheduler = FunboostBackgroundScheduler(timezone=FunboostCommonConfig.TIMEZONE, daemon=False, )
 fsdf_background_scheduler = funboost_aps_scheduler  # 兼容一下老名字。
 
+
+
 if __name__ == '__main__':
+
+    """
+    下面的例子过时了，可以用但不建议，建议统一使用 ApsJobAdder 来添加定时任务。
+
+    """
+
     # 定时运行消费演示
     import datetime
     from funboost import boost, BrokerEnum, fsdf_background_scheduler, timing_publish_deco, run_forever

funboost/timing_job/timing_push.py

@@ -6,7 +6,7 @@ from funboost.timing_job.timing_job_base import funboost_aps_scheduler, undefine
 from funboost.timing_job.apscheduler_use_redis_store import FunboostBackgroundSchedulerProcessJobsWithinRedisLock
 from funboost.funboost_config_deafult import FunboostCommonConfig
 from apscheduler.schedulers.base import BaseScheduler
-
+from funboost.constant import RedisKeys
 
 class ApsJobAdder:
     """
@@ -52,12 +52,13 @@ class ApsJobAdder:
         redis_jobstores = {
 
             "default": RedisJobStore(**redis_manager.get_redis_conn_kwargs(),
-                                     jobs_key=f'funboost.apscheduler.{queue_name}.jobs',
-                                     run_times_key=f'funboost.apscheduler.{queue_name}.run_times',
+                                    jobs_key=RedisKeys.gen_funboost_redis_apscheduler_jobs_key_by_queue_name(queue_name),
+                                    run_times_key=RedisKeys.gen_funboost_redis_apscheduler_run_times_key_by_queue_name(queue_name),
                                      )
         }
         redis_aps = FunboostBackgroundSchedulerProcessJobsWithinRedisLock(timezone=FunboostCommonConfig.TIMEZONE,
                                                                           daemon=False, jobstores=redis_jobstores)
+        redis_aps.set_process_jobs_redis_lock_key(RedisKeys.gen_funboost_apscheduler_redis_lock_key_by_queue_name(queue_name))
         cls.queue__redis_aps_map[queue_name] = redis_aps
         return redis_aps
 
@@ -107,6 +108,7 @@ class ApsJobAdder:
 if __name__ == '__main__':
     """
     2025年后定时任务现在推荐使用 ApsJobAdder 写法 ，用户不需要亲自选择使用 apscheduler对象来添加定时任务
+    特别是使用redis作为jobstores时候，你可以看源码就知道了。
     """
     from funboost import boost, BrokerEnum, ctrl_c_recv, BoosterParams, ApsJobAdder
 
@@ -118,7 +120,7 @@ if __name__ == '__main__':
         print(f'The sum of {x} and {y} is {result}')
 
     # 启动消费者
-    sum_two_numbers.consume()
+    # sum_two_numbers.consume()
 
     # 发布任务
     sum_two_numbers.push(3, 5)
@@ -155,4 +157,4 @@ if __name__ == '__main__':
         replace_existing=True,
         id='cron_job1')
 
-    ctrl_c_recv()
+    ctrl_c_recv() # 启动了守护线程的定时器，一定要阻止主线程退出。 你可以代码最末尾加这个 ctrl_c_recv() 或者加个 while 1:time.sleep(10)

funboost/utils/dependency_packages_in_pythonpath/aioredis/readme.md

@@ -1,9 +1,3 @@
----
-noteId: "6d96e13045e411f0ab0bf59d9f569ed4"
-tags: []
-
----
-
 
 ## 1 asioredis包将不再更新 ，ptyhon 3.11 版本 import aioredis会出错。
 

funboost/utils/dependency_packages_in_pythonpath/readme.md

@@ -1,9 +1,3 @@
----
-noteId: "6d97084045e411f0ab0bf59d9f569ed4"
-tags: []
-
----
-
 ## 这个文件夹被添加到 sys.path中去了。
 
 funboost __init__.py 第一行就把这个添加到 sys.path了,相当于 export PYTHONPATH 了。