befly 3.24.17 → 3.24.19

package/lib/requestMetrics.js

@@ -0,0 +1,203 @@
+const WINDOW_SECONDS = 60;
+const SLOWEST_WINDOW_MS = 60 * 60 * 1000;
+const SLOWEST_API_LIMIT = 5;
+
+const requestBuckets = new Map();
+const activeRequestState = {
+    count: 0
+};
+const slowestState = {
+    apiPath: "",
+    duration: 0,
+    timestamp: 0
+};
+const slowestListState = [];
+
+function toSecondTimestamp(timestamp) {
+    return Math.floor(timestamp / 1000);
+}
+
+function getOrCreateBucket(secondTimestamp) {
+    let bucket = requestBuckets.get(secondTimestamp);
+
+    if (bucket) {
+        return bucket;
+    }
+
+    bucket = {
+        requestCount: 0,
+        errorCount: 0,
+        durationTotal: 0
+    };
+    requestBuckets.set(secondTimestamp, bucket);
+
+    return bucket;
+}
+
+function cleanupBuckets(nowSecondTimestamp) {
+    const minSecondTimestamp = nowSecondTimestamp - WINDOW_SECONDS + 1;
+
+    for (const key of requestBuckets.keys()) {
+        if (key >= minSecondTimestamp) {
+            continue;
+        }
+
+        requestBuckets.delete(key);
+    }
+}
+
+function cleanupSlowest(nowTimestamp) {
+    if (slowestState.timestamp <= 0) {
+        return;
+    }
+
+    if (nowTimestamp - slowestState.timestamp <= SLOWEST_WINDOW_MS) {
+        return;
+    }
+
+    slowestState.apiPath = "";
+    slowestState.duration = 0;
+    slowestState.timestamp = 0;
+}
+
+function cleanupSlowestList(nowTimestamp) {
+    for (let index = slowestListState.length - 1; index >= 0; index -= 1) {
+        if (nowTimestamp - slowestListState[index].timestamp <= SLOWEST_WINDOW_MS) {
+            continue;
+        }
+
+        slowestListState.splice(index, 1);
+    }
+}
+
+function updateSlowestList(apiPath, duration, nowTimestamp) {
+    const safePath = String(apiPath || "");
+
+    if (!safePath) {
+        return;
+    }
+
+    let existing = null;
+
+    for (const item of slowestListState) {
+        if (item.path !== safePath) {
+            continue;
+        }
+
+        existing = item;
+        break;
+    }
+
+    if (existing) {
+        if (duration > existing.time) {
+            existing.time = duration;
+        }
+
+        existing.timestamp = nowTimestamp;
+    } else {
+        slowestListState.push({
+            path: safePath,
+            time: duration,
+            timestamp: nowTimestamp
+        });
+    }
+
+    slowestListState.sort((left, right) => {
+        if (right.time !== left.time) {
+            return right.time - left.time;
+        }
+
+        return right.timestamp - left.timestamp;
+    });
+
+    if (slowestListState.length > SLOWEST_API_LIMIT) {
+        slowestListState.length = SLOWEST_API_LIMIT;
+    }
+}
+
+export const requestMetrics = {
+    reset: function () {
+        requestBuckets.clear();
+        activeRequestState.count = 0;
+        slowestState.apiPath = "";
+        slowestState.duration = 0;
+        slowestState.timestamp = 0;
+        slowestListState.length = 0;
+    },
+
+    onRequestStart: function () {
+        activeRequestState.count += 1;
+    },
+
+    onRequestEnd: function (apiPath, duration, isError) {
+        const nowTimestamp = Date.now();
+        const secondTimestamp = toSecondTimestamp(nowTimestamp);
+        const safeDuration = Number.isFinite(Number(duration)) ? Number(duration) : 0;
+        const bucket = getOrCreateBucket(secondTimestamp);
+
+        bucket.requestCount += 1;
+        bucket.durationTotal += safeDuration;
+
+        if (isError === true) {
+            bucket.errorCount += 1;
+        }
+
+        if (safeDuration > slowestState.duration || nowTimestamp - slowestState.timestamp > SLOWEST_WINDOW_MS) {
+            slowestState.apiPath = String(apiPath || "");
+            slowestState.duration = safeDuration;
+            slowestState.timestamp = nowTimestamp;
+        }
+
+        updateSlowestList(apiPath, safeDuration, nowTimestamp);
+
+        if (activeRequestState.count > 0) {
+            activeRequestState.count -= 1;
+        } else {
+            activeRequestState.count = 0;
+        }
+    },
+
+    getSnapshot: function () {
+        const nowTimestamp = Date.now();
+        const nowSecondTimestamp = toSecondTimestamp(nowTimestamp);
+
+        cleanupBuckets(nowSecondTimestamp);
+        cleanupSlowest(nowTimestamp);
+        cleanupSlowestList(nowTimestamp);
+
+        let requestCount = 0;
+        let errorCount = 0;
+        let durationTotal = 0;
+
+        for (const bucket of requestBuckets.values()) {
+            requestCount += bucket.requestCount;
+            errorCount += bucket.errorCount;
+            durationTotal += bucket.durationTotal;
+        }
+
+        const qps = Number((requestCount / WINDOW_SECONDS).toFixed(2));
+        const errorRate = requestCount > 0 ? Number(((errorCount / requestCount) * 100).toFixed(2)) : 0;
+        const avgResponseTime = requestCount > 0 ? Math.round(durationTotal / requestCount) : 0;
+        const slowestApi = slowestState.apiPath
+            ? {
+                  path: slowestState.apiPath,
+                  time: slowestState.duration
+              }
+            : null;
+        const slowestApis = slowestListState.map((item) => {
+            return {
+                path: item.path,
+                time: item.time
+            };
+        });
+
+        return {
+            qps: qps,
+            errorRate: errorRate,
+            avgResponseTime: avgResponseTime,
+            activeRequests: activeRequestState.count,
+            slowestApi: slowestApi,
+            slowestApis: slowestApis
+        };
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.24.17",
+    "version": "3.24.19",
     "gitHead": "49c39d36695036e85fc64083cc43c1652fff96cb",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 JavaScript API 接口框架核心引擎",
@@ -56,7 +56,7 @@
     },
     "dependencies": {
         "fast-xml-parser": "^5.8.0",
-        "nodemailer": "^8.0.7",
+        "nodemailer": "^8.0.9",
         "pathe": "^2.0.3",
         "picomatch": "^4.0.4",
         "ua-parser-js": "^2.0.10",

package/plugins/email.js

@@ -7,18 +7,22 @@ import nodemailer from "nodemailer";
 
 import { Logger } from "../lib/logger.js";
 
+function canCreateTransport(config) {
+    return Boolean(String(config?.host || "").trim() && String(config?.user || "").trim() && String(config?.pass || "").trim());
+}
+
 export default {
     order: 7,
     handler: async function (befly) {
         const config = befly?.config?.email || {};
         let transporter = null;
 
-        if (config && config.host && config.user) {
+        if (canCreateTransport(config)) {
             try {
                 transporter = nodemailer.createTransport({
                     host: config.host,
                     port: config.port || 25,
-                    secure: config.ssl,
+                    secure: config.secure ?? config.ssl,
                     auth: {
                         user: config.user,
                         pass: config.pass

package/router/api.js

@@ -6,6 +6,7 @@
 import picomatch from "picomatch";
 
 import { Logger } from "../lib/logger.js";
+import { requestMetrics } from "../lib/requestMetrics.js";
 // 相对导入
 import { setCorsOptions } from "../utils/cors.js";
 import { getClientIp } from "../utils/getClientIp.js";
@@ -94,6 +95,9 @@ export function apiHandler(apis, hooks, context) {
             apiRequired: apiData.required,
             apiFile: apiData.filePath
         };
+        const requestStartTime = Date.now();
+        let requestHasError = false;
+        requestMetrics.onRequestStart();
 
         try {
             // 4. 串联执行所有钩子
@@ -143,6 +147,7 @@ export function apiHandler(apis, hooks, context) {
             // 7. 返回响应（自动处理 response/result/日志）
             return FinalResponse(ctx);
         } catch (err) {
+            requestHasError = true;
             // 全局错误处理
             Logger.error("请求错误", err, {
                 path: ctx.apiPath,
@@ -162,6 +167,8 @@ export function apiHandler(apis, hooks, context) {
                 msg: "内部服务错误"
             };
             return FinalResponse(ctx);
+        } finally {
+            requestMetrics.onRequestEnd(ctx.apiPath, Date.now() - requestStartTime, requestHasError);
         }
     };
 }