befly 3.24.17 → 3.24.19

package/apis/admin/cacheRefresh.js

@@ -5,8 +5,8 @@
  * 1. 刷新接口缓存（apis:all）
  * 2. 刷新菜单缓存（menus:all）
  * 3. 刷新角色缓存（role:info:{code}）
- * 4. 重建角色接口权限缓存（role:apis:{code}，Set）
- * 5. 重建角色菜单权限缓存（role:menus:{code}，Set）
+ * 4. 重建角色接口权限缓存（版本化 Set + activeVersion 原子切换）
+ * 5. 重建角色菜单权限缓存（版本化 Set + activeVersion 原子切换）
  *
  * 使用场景：
  * - 执行数据库同步后

package/apis/dashboard/environmentInfo.js

@@ -10,6 +10,10 @@ export default {
     fields: {},
     required: [],
     handler: async (befly) => {
+        const isBunRuntime = typeof Bun !== "undefined";
+        const runtimeVersion = isBunRuntime ? `Bun ${Bun.version}` : `Node.js ${process.version}`;
+        const nodeCompatVersion = process.version;
+
         let databaseVersion = "Unknown";
         try {
             const versionResult = await befly.mysql.execute("SELECT VERSION() as version");
@@ -35,7 +39,8 @@ export default {
         return befly.tool.Yes("获取成功", {
             os: `${os.type()} ${os.arch()}`,
             server: `${os.platform()} ${os.release()}`,
-            nodeVersion: process.version,
+            runtimeVersion: runtimeVersion,
+            nodeVersion: nodeCompatVersion,
             database: `MySQL ${databaseVersion}`,
             cache: `Redis ${redisVersion}`,
             timezone: Intl.DateTimeFormat().resolvedOptions().timeZone

package/apis/dashboard/performanceMetrics.js

@@ -1,3 +1,5 @@
+import { requestMetrics } from "#root/lib/requestMetrics.js";
+
 export default {
     name: "获取性能指标",
     method: "POST",
@@ -6,15 +8,16 @@ export default {
     fields: {},
     required: [],
     handler: async (befly) => {
+        const metrics = requestMetrics.getSnapshot();
+
         return befly.tool.Yes("获取成功", {
-            avgResponseTime: 125,
-            qps: 856,
-            errorRate: 0.8,
-            activeConnections: 45,
-            slowestApi: {
-                path: "/api/core/menu/select",
-                time: 450
-            }
+            avgResponseTime: Number(metrics.avgResponseTime || 0),
+            qps: Number(metrics.qps || 0),
+            errorRate: Number(metrics.errorRate || 0),
+            activeRequests: Number(metrics.activeRequests || 0),
+            activeConnections: Number(metrics.activeRequests || 0),
+            slowestApi: metrics.slowestApi || null,
+            slowestApis: Array.isArray(metrics.slowestApis) ? metrics.slowestApis : []
         });
     }
 };

package/apis/dashboard/serviceStatus.js

@@ -1,3 +1,72 @@
+import cacheHealthApi from "#root/apis/tongJi/cacheHealth.js";
+
+function isEmailConfigured(emailConfig) {
+    if (!emailConfig || typeof emailConfig !== "object") {
+        return false;
+    }
+
+    return Boolean(String(emailConfig.host || "").trim() && String(emailConfig.user || "").trim() && String(emailConfig.pass || "").trim());
+}
+
+function buildServiceItem(name, status, responseTime) {
+    return {
+        name: name,
+        status: status,
+        responseTime: responseTime
+    };
+}
+
+async function probeMysqlService(befly) {
+    try {
+        const startTime = Date.now();
+        await befly.mysql.execute("SELECT 1");
+        const responseTime = Date.now() - startTime;
+        return buildServiceItem("数据库", "running", `${responseTime}ms`);
+    } catch (error) {
+        befly.logger.error("数据库状态检测失败", error);
+        return buildServiceItem("数据库", "stopped", "-");
+    }
+}
+
+async function probeRedisService(befly) {
+    if (!befly.redis) {
+        return buildServiceItem("Redis", "stopped", "-");
+    }
+
+    try {
+        const startTime = Date.now();
+        await befly.redis.ping();
+        const responseTime = Date.now() - startTime;
+        return buildServiceItem("Redis", "running", `${responseTime}ms`);
+    } catch (error) {
+        befly.logger.error("Redis状态检测失败", error);
+        return buildServiceItem("Redis", "stopped", "-");
+    }
+}
+
+function buildStaticServices(befly) {
+    return [buildServiceItem("文件系统", "running", "-"), buildServiceItem("邮件服务", isEmailConfigured(befly.config?.email) ? "running" : "unconfigured", "-"), buildServiceItem("OSS存储", "unconfigured", "-")];
+}
+
+function buildCacheHealthSummary(cacheHealthData) {
+    if (!cacheHealthData) {
+        return null;
+    }
+
+    return {
+        redisStatus: cacheHealthData.redis?.status || "unknown",
+        onlineReady: Boolean(cacheHealthData.online?.ready),
+        infoReady: Boolean(cacheHealthData.info?.ready),
+        errorReady: Boolean(cacheHealthData.error?.ready),
+        roleApisReady: Boolean(cacheHealthData.roleCache?.apis?.ready),
+        roleMenusReady: Boolean(cacheHealthData.roleCache?.menus?.ready),
+        infoFallbackCount: Number(cacheHealthData.fallback?.infoStats || 0),
+        errorFallbackCount: Number(cacheHealthData.fallback?.errorStats || 0),
+        infoFallbackTodayCount: Number(cacheHealthData.fallback?.today?.infoStats || 0),
+        errorFallbackTodayCount: Number(cacheHealthData.fallback?.today?.errorStats || 0)
+    };
+}
+
 export default {
     name: "获取服务状态",
     method: "POST",
@@ -6,70 +75,19 @@ export default {
     fields: {},
     required: [],
     handler: async (befly) => {
-        const services = [];
+        const services = [await probeMysqlService(befly), await probeRedisService(befly), ...buildStaticServices(befly)];
+
+        let cacheHealthSummary = null;
 
         try {
-            const startTime = Date.now();
-            await befly.mysql.execute("SELECT 1");
-            const responseTime = Date.now() - startTime;
-            services.push({
-                name: "数据库",
-                status: "running",
-                responseTime: `${responseTime}ms`
-            });
-        } catch (error) {
-            befly.logger.error("数据库状态检测失败", error);
-            services.push({
-                name: "数据库",
-                status: "stopped",
-                responseTime: "-"
-            });
-        }
+            const cacheHealthResult = await cacheHealthApi.handler(befly);
+            const cacheHealthData = cacheHealthResult?.data || null;
 
-        if (befly.redis) {
-            try {
-                const startTime = Date.now();
-                await befly.redis.ping();
-                const responseTime = Date.now() - startTime;
-                services.push({
-                    name: "Redis",
-                    status: "running",
-                    responseTime: `${responseTime}ms`
-                });
-            } catch (error) {
-                befly.logger.error("Redis状态检测失败", error);
-                services.push({
-                    name: "Redis",
-                    status: "stopped",
-                    responseTime: "-"
-                });
-            }
-        } else {
-            services.push({
-                name: "Redis",
-                status: "stopped",
-                responseTime: "-"
-            });
+            cacheHealthSummary = buildCacheHealthSummary(cacheHealthData);
+        } catch (error) {
+            befly.logger.error("缓存健康状态聚合失败", error);
         }
 
-        services.push({
-            name: "文件系统",
-            status: "running",
-            responseTime: "-"
-        });
-
-        services.push({
-            name: "邮件服务",
-            status: "unconfigured",
-            responseTime: "-"
-        });
-
-        services.push({
-            name: "OSS存储",
-            status: "unconfigured",
-            responseTime: "-"
-        });
-
-        return befly.tool.Yes("获取成功", { services: services });
+        return befly.tool.Yes("获取成功", { services: services, cacheHealth: cacheHealthSummary });
     }
 };

package/apis/tongJi/cacheHealth.js

@@ -0,0 +1,214 @@
+import { addDays, getDateYmdNumber } from "#root/utils/datetime.js";
+
+const ONLINE_ACTIVE_KEY = "online:active";
+const INFO_STATS_FALLBACK_COUNT_KEY = "stats:fallback:infoStats:count";
+const ERROR_STATS_FALLBACK_COUNT_KEY = "stats:fallback:errorStats:count";
+
+function getInfoStatsFallbackDailyCountKey(reportDate) {
+    return `stats:fallback:infoStats:count:day:${reportDate}`;
+}
+
+function getErrorStatsFallbackDailyCountKey(reportDate) {
+    return `stats:fallback:errorStats:count:day:${reportDate}`;
+}
+
+function toNumber(value) {
+    const num = Number(value);
+
+    if (!Number.isFinite(num)) {
+        return 0;
+    }
+
+    return num;
+}
+
+function getWeekStartDate(timestamp = Date.now()) {
+    const date = Reflect.construct(Date, [timestamp]);
+    const day = date.getDay();
+    const offset = day === 0 ? -6 : 1 - day;
+
+    return getDateYmdNumber(addDays(timestamp, offset));
+}
+
+function getMonthStartDate(timestamp = Date.now()) {
+    const date = Reflect.construct(Date, [timestamp]);
+
+    return getDateYmdNumber(Reflect.construct(Date, [date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0]).getTime());
+}
+
+function getOnlineReportTimeKey(periodType, periodValue) {
+    return `online:${periodType}:${periodValue}:reportTime`;
+}
+
+function getInfoReportTimeKey(periodType, periodValue) {
+    return `info:${periodType}:${periodValue}:reportTime`;
+}
+
+function getErrorCountKey(periodType, periodValue) {
+    return `error:${periodType}:${periodValue}:count`;
+}
+
+async function getRedisStringNumber(redis, key) {
+    return toNumber(await redis.getString(key));
+}
+
+async function getRedisSetCount(redis, key) {
+    if (typeof redis.scard !== "function") {
+        return 0;
+    }
+
+    return toNumber(await redis.scard(key));
+}
+
+async function getRedisSortedSetCount(redis, key) {
+    if (typeof redis.zcard !== "function") {
+        return 0;
+    }
+
+    return toNumber(await redis.zcard(key));
+}
+
+async function getRedisConnectivity(redis) {
+    if (!redis || typeof redis.ping !== "function") {
+        return {
+            status: "unavailable",
+            responseTime: -1
+        };
+    }
+
+    try {
+        const start = Date.now();
+        await redis.ping();
+
+        return {
+            status: "running",
+            responseTime: Date.now() - start
+        };
+    } catch {
+        return {
+            status: "stopped",
+            responseTime: -1
+        };
+    }
+}
+
+export default {
+    name: "获取统计缓存健康状态",
+    method: "POST",
+    body: "none",
+    auth: true,
+    fields: {},
+    required: [],
+    handler: async (befly) => {
+        const now = Date.now();
+        const reportDate = getDateYmdNumber(now);
+        const weekStartDate = getWeekStartDate(now);
+        const monthStartDate = getMonthStartDate(now);
+        const redisConnectivity = await getRedisConnectivity(befly.redis);
+
+        if (!befly.redis) {
+            return befly.tool.Yes("获取成功", {
+                queryTime: now,
+                redis: redisConnectivity,
+                online: null,
+                info: null,
+                error: null,
+                roleCache: null,
+                hints: ["Redis 不可用，统计接口将回退到 MySQL 聚合"]
+            });
+        }
+
+        const onlineTodayReportTime = await getRedisStringNumber(befly.redis, getOnlineReportTimeKey("day", reportDate));
+        const onlineWeekReportTime = await getRedisStringNumber(befly.redis, getOnlineReportTimeKey("week", weekStartDate));
+        const onlineMonthReportTime = await getRedisStringNumber(befly.redis, getOnlineReportTimeKey("month", monthStartDate));
+
+        const infoTodayReportTime = await getRedisStringNumber(befly.redis, getInfoReportTimeKey("day", reportDate));
+        const infoWeekReportTime = await getRedisStringNumber(befly.redis, getInfoReportTimeKey("week", weekStartDate));
+        const infoMonthReportTime = await getRedisStringNumber(befly.redis, getInfoReportTimeKey("month", monthStartDate));
+
+        const errorDayCount = await getRedisStringNumber(befly.redis, getErrorCountKey("day", reportDate));
+        const errorWeekCount = await getRedisStringNumber(befly.redis, getErrorCountKey("week", weekStartDate));
+        const errorMonthCount = await getRedisStringNumber(befly.redis, getErrorCountKey("month", monthStartDate));
+
+        const roleApisVersion = String((await befly.redis.getString("role:apis:activeVersion")) || "");
+        const roleMenusVersion = String((await befly.redis.getString("role:menus:activeVersion")) || "");
+
+        const online = {
+            activeMembers: await getRedisSortedSetCount(befly.redis, ONLINE_ACTIVE_KEY),
+            reportTime: {
+                today: onlineTodayReportTime,
+                week: onlineWeekReportTime,
+                month: onlineMonthReportTime
+            },
+            ready: onlineTodayReportTime > 0 || onlineWeekReportTime > 0 || onlineMonthReportTime > 0
+        };
+
+        const info = {
+            reportTime: {
+                today: infoTodayReportTime,
+                week: infoWeekReportTime,
+                month: infoMonthReportTime
+            },
+            daySourcesCount: await getRedisSetCount(befly.redis, `info:day:${reportDate}:sources:names`),
+            ready: infoTodayReportTime > 0 || infoWeekReportTime > 0 || infoMonthReportTime > 0
+        };
+
+        const error = {
+            count: {
+                today: errorDayCount,
+                week: errorWeekCount,
+                month: errorMonthCount
+            },
+            ready: errorDayCount > 0 || errorWeekCount > 0 || errorMonthCount > 0
+        };
+
+        const roleCache = {
+            apis: {
+                activeVersion: roleApisVersion,
+                ready: roleApisVersion.length > 0
+            },
+            menus: {
+                activeVersion: roleMenusVersion,
+                ready: roleMenusVersion.length > 0
+            }
+        };
+
+        const fallback = {
+            infoStats: await getRedisStringNumber(befly.redis, INFO_STATS_FALLBACK_COUNT_KEY),
+            errorStats: await getRedisStringNumber(befly.redis, ERROR_STATS_FALLBACK_COUNT_KEY),
+            today: {
+                infoStats: await getRedisStringNumber(befly.redis, getInfoStatsFallbackDailyCountKey(reportDate)),
+                errorStats: await getRedisStringNumber(befly.redis, getErrorStatsFallbackDailyCountKey(reportDate))
+            }
+        };
+
+        const hints = [];
+
+        if (!online.ready) {
+            hints.push("online 统计预聚合尚未建立，onlineStats 将返回空或低命中结果");
+        }
+        if (!info.ready) {
+            hints.push("info 统计预聚合尚未建立，infoStats 将回退到 MySQL 聚合");
+        }
+        if (!error.ready) {
+            hints.push("error 统计预聚合尚未建立，errorStats 将回退到 MySQL 聚合");
+        }
+        if (!roleCache.apis.ready || !roleCache.menus.ready) {
+            hints.push("角色权限版本缓存未就绪，建议执行一次 cacheRefresh");
+        }
+        if (fallback.infoStats > 0 || fallback.errorStats > 0) {
+            hints.push("检测到统计查询回退到 MySQL，可关注预聚合写入是否稳定，必要时可执行 tongJi/fallbackReset 重置观测计数");
+        }
+
+        return befly.tool.Yes("获取成功", {
+            queryTime: now,
+            redis: redisConnectivity,
+            online: online,
+            info: info,
+            error: error,
+            roleCache: roleCache,
+            fallback: fallback,
+            hints: hints
+        });
+    }
+};

package/apis/tongJi/errorReport.js

@@ -1,8 +1,9 @@
 import { UAParser } from "ua-parser-js";
 
-import { getDateYmdNumber, getTimeBucketStart } from "#root/utils/datetime.js";
+import { addDays, getDateYmdNumber, getTimeBucketStart } from "#root/utils/datetime.js";
 
 const VISIT_STATS_BUCKET_MS = 30 * 60 * 1000;
+const ERROR_STATS_REDIS_TTL_SECONDS = 45 * 24 * 60 * 60;
 
 function getErrorReportUaData(ctx) {
     let userAgent = "";
@@ -29,6 +30,74 @@ function getErrorReportUaData(ctx) {
     };
 }
 
+function getErrorStatsWeekStartDate(timestamp = Date.now()) {
+    const date = Reflect.construct(Date, [timestamp]);
+    const day = date.getDay();
+    const offset = day === 0 ? -6 : 1 - day;
+
+    return getDateYmdNumber(addDays(timestamp, offset));
+}
+
+function getErrorStatsMonthStartDate(timestamp = Date.now()) {
+    const date = Reflect.construct(Date, [timestamp]);
+
+    return getDateYmdNumber(Reflect.construct(Date, [date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0]).getTime());
+}
+
+function getErrorStatsPeriodCountKey(periodType, periodValue) {
+    return `error:${periodType}:${periodValue}:count`;
+}
+
+function getErrorStatsDayBucketsKey(bucketDate) {
+    return `error:day:${bucketDate}:buckets`;
+}
+
+function getErrorStatsDayBucketCountKey(bucketDate, bucketTime) {
+    return `error:day:${bucketDate}:bucket:${bucketTime}:count`;
+}
+
+function getErrorStatsDayTypesKey(bucketDate) {
+    return `error:day:${bucketDate}:types`;
+}
+
+function getErrorStatsDayTypeCountKey(bucketDate, errorType) {
+    return `error:day:${bucketDate}:type:${encodeURIComponent(String(errorType || "unknown"))}:count`;
+}
+
+async function setErrorStatsRedisTtl(befly, keys) {
+    for (const key of keys) {
+        await befly.redis.expire(key, ERROR_STATS_REDIS_TTL_SECONDS);
+    }
+}
+
+async function updateErrorStatsRedis(befly, now, bucketDate, bucketTime, errorType) {
+    if (!befly.redis) {
+        return;
+    }
+
+    const weekStartDate = getErrorStatsWeekStartDate(now);
+    const monthStartDate = getErrorStatsMonthStartDate(now);
+    const dayCountKey = getErrorStatsPeriodCountKey("day", bucketDate);
+    const weekCountKey = getErrorStatsPeriodCountKey("week", weekStartDate);
+    const monthCountKey = getErrorStatsPeriodCountKey("month", monthStartDate);
+    const dayBucketsKey = getErrorStatsDayBucketsKey(bucketDate);
+    const dayBucketCountKey = getErrorStatsDayBucketCountKey(bucketDate, bucketTime);
+    const dayTypesKey = getErrorStatsDayTypesKey(bucketDate);
+    const dayTypeCountKey = getErrorStatsDayTypeCountKey(bucketDate, errorType);
+
+    await befly.redis.incr(dayCountKey);
+    await befly.redis.incr(weekCountKey);
+    await befly.redis.incr(monthCountKey);
+
+    await befly.redis.sadd(dayBucketsKey, [String(bucketTime)]);
+    await befly.redis.incr(dayBucketCountKey);
+
+    await befly.redis.sadd(dayTypesKey, [String(errorType || "unknown")]);
+    await befly.redis.incr(dayTypeCountKey);
+
+    await setErrorStatsRedisTtl(befly, [dayCountKey, weekCountKey, monthCountKey, dayBucketsKey, dayBucketCountKey, dayTypesKey, dayTypeCountKey]);
+}
+
 export default {
     name: "上报错误报告",
     method: "POST",
@@ -82,6 +151,8 @@ export default {
             }
         });
 
+        await updateErrorStatsRedis(befly, now, bucketDate, bucketTime, ctx.body?.errorType || "unknown");
+
         return befly.tool.Yes("上报成功", {
             reportTime: now,
             bucketTime: bucketTime,