befly 3.60.0 → 3.62.0

package/checks/config.js

@@ -63,10 +63,7 @@ const configSchema = z
         logger: z
             .object({
                 debug: boolIntSchema,
-                excludeFields: z.array(noTrimString),
-                dir: noTrimString,
-                console: boolIntSchema,
-                maxSize: z.int().min(1)
+                excludeFields: z.array(noTrimString)
             })
             .strict(),
 
@@ -78,7 +75,10 @@ const configSchema = z
                 password: noTrimString,
                 database: noTrimString,
                 max: z.number().min(1),
-                beflyMode: beflyModeSchema.optional()
+                beflyMode: beflyModeSchema.optional(),
+                idleTimeout: z.number().min(1).optional(),
+                maxLifetime: z.number().min(0).optional(),
+                connectionTimeout: z.number().min(1).optional()
             })
             .strict(),
 

package/configs/beflyConfig.json

@@ -19,10 +19,7 @@
     "excludeApisLog": ["/api/core/tongJi/*Report"],
     "logger": {
         "debug": 1,
-        "excludeFields": ["password", "token", "secret"],
-        "dir": "./logs",
-        "console": 1,
-        "maxSize": 20
+        "excludeFields": ["password", "token", "secret"]
     },
 
     "mysql": {

package/index.js

@@ -138,6 +138,12 @@ export async function createBefly(env = {}, config = {}, menus = []) {
         });
     }
 
+    // 在插件加载前用项目 runMode 初始化 Logger，确保后续所有日志目录正确
+    Logger.configure({
+        runtimeEnv: mergedConfig.runMode,
+        ...mergedConfig.logger
+    });
+
     return new Befly({
         env: env,
         config: mergedConfig,

package/lib/logger.js

@@ -2,19 +2,18 @@
  * 日志系统 - Bun 环境自定义实现（替换 pino / pino-roll）
  */
 
-import { createWriteStream, existsSync, mkdirSync } from "node:fs";
-import { stat } from "node:fs/promises";
+import { createWriteStream, existsSync, mkdirSync, rmSync, statSync } from "node:fs";
 import { join as nodePathJoin, resolve as nodePathResolve } from "node:path";
 
 import { formatYmdHms } from "../utils/datetime.js";
-import { isFiniteNumber, isNumber, isPlainObject, isString } from "../utils/is.js";
+import { isPlainObject } from "../utils/is.js";
 import { buildSensitiveKeyMatcher, sanitizeLogObject } from "../utils/loggerUtils.js";
 import { normalizePositiveInt } from "../utils/util.js";
 
 // 注意：Logger 可能在运行时/测试中被 process.chdir() 影响。
 // 为避免相对路径的 logs 目录随着 cwd 变化，使用模块加载时的初始 cwd 作为锚点。
-const INITIAL_CWD = process.cwd();
-const RUNTIME_LOG_DIR = nodePathResolve(INITIAL_CWD, "logs");
+const DEFAULT_MAX_SIZE_MB = 20;
+const MAX_FILE_BYTES = DEFAULT_MAX_SIZE_MB * 1024 * 1024;
 
 const BUILTIN_SENSITIVE_KEYS = ["*password*", "pass", "pwd", "*token*", "access_token", "refresh_token", "accessToken", "refreshToken", "authorization", "cookie", "set-cookie", "*secret*", "apiKey", "api_key", "privateKey", "private_key"];
 
@@ -32,168 +31,79 @@ let errorFileSink = null;
 
 let config = {
     debug: 0,
-    dir: RUNTIME_LOG_DIR,
-    maxSize: 20,
+    dir: "",
     runtimeEnv: "production"
 };
 
 function safeWriteStderr(msg) {
-    try {
-        process.stderr.write(`${msg}\n`);
-    } catch {
-        // ignore
-    }
-}
-
-function shiftBatchFromPending(pending, maxBatchBytes) {
-    const parts = [];
-    let bytes = 0;
-
-    while (pending.length > 0) {
-        const next = pending[0];
-        const nextBytes = Buffer.byteLength(next);
-        if (parts.length > 0 && bytes + nextBytes > maxBatchBytes) {
-            break;
-        }
-        parts.push(next);
-        bytes = bytes + nextBytes;
-        pending.shift();
-    }
-
-    return { chunk: parts.join(""), bytes: bytes };
+    process.stderr.write(`${msg}\n`);
 }
 
 class LogFileSink {
-    constructor(options) {
-        this.prefix = options.prefix;
-        this.maxFileBytes = options.maxFileBytes;
+    constructor(prefix) {
+        this.prefix = prefix;
 
         this.stream = null;
         this.streamDate = "";
         this.streamIndex = 0;
         this.streamSizeBytes = 0;
         this.disabled = false;
-
-        this.pending = [];
-        this.pendingBytes = 0;
-        this.scheduledTimer = null;
-        this.flushing = false;
-
-        this.maxBufferBytes = 10 * 1024 * 1024;
-        this.flushDelayMs = 10;
-        this.maxBatchBytes = 64 * 1024;
     }
 
-    enqueue(line) {
+    write(line) {
         if (this.disabled) return;
 
-        const bytes = Buffer.byteLength(line);
-        if (this.pendingBytes + bytes > this.maxBufferBytes) {
-            // buffer 满：统一丢弃新日志（不区分 level）
-            return;
+        this.ensureStreamReady(line.length);
+        if (this.stream) {
+            this.stream.write(line);
+            this.streamSizeBytes += line.length;
         }
-
-        this.pending.push(line);
-        this.pendingBytes = this.pendingBytes + bytes;
-
-        this.scheduleFlush();
     }
 
     async flushNow() {
-        this.clearScheduledFlush();
-        await this.flush();
+        return this.closeStream();
     }
 
     async shutdown() {
-        this.clearScheduledFlush();
-        await this.flush();
-        await this.closeStream();
-    }
-
-    scheduleFlush() {
-        if (this.scheduledTimer) return;
-
-        this.scheduledTimer = setTimeout(() => {
-            // timer 触发时先清空句柄，避免 flush 内再次 schedule 时被认为“已安排”。
-            this.scheduledTimer = null;
-            this.flush();
-        }, this.flushDelayMs);
+        return this.closeStream();
     }
 
-    clearScheduledFlush() {
-        if (!this.scheduledTimer) return;
-        clearTimeout(this.scheduledTimer);
-        this.scheduledTimer = null;
+    getFilePath(date, index) {
+        const suffix = index > 0 ? `.${index}` : "";
+        const filename = this.prefix === "app" ? `${date}${suffix}.log` : `${this.prefix}.${date}${suffix}.log`;
+        return nodePathJoin(config.dir, filename);
     }
 
-    async flush() {
-        if (this.flushing || this.pending.length === 0) return;
-        this.flushing = true;
+    ensureStreamReady(nextChunkBytes) {
+        const date = formatYmdHms(Date.now(), "date");
 
-        try {
-            while (this.pending.length > 0) {
-                const batch = shiftBatchFromPending(this.pending, this.maxBatchBytes);
-                this.pendingBytes = this.pendingBytes - batch.bytes;
-
-                const ok = await this.writeChunk(batch.chunk, batch.bytes);
-                if (!ok) {
-                    // writer 已禁用/失败：清空剩余 pending
-                    this.pending = [];
-                    this.pendingBytes = 0;
-                    break;
-                }
-            }
-        } finally {
-            this.flushing = false;
-            if (this.pending.length > 0) {
-                this.scheduleFlush();
-            }
+        if (this.stream && this.streamDate && date !== this.streamDate) {
+            this.closeStreamSync();
         }
-    }
 
-    async writeChunk(chunk, chunkBytes) {
-        if (this.disabled) return false;
+        if (!this.stream) {
+            this.streamDate = date;
+            this.streamIndex = 0;
+            this.streamSizeBytes = this.getFileSize(this.getFilePath(date, 0));
 
-        try {
-            await this.ensureStreamReady(chunkBytes);
-            if (!this.stream) {
-                // 文件 sink 已被禁用或打开失败
-                return false;
-            }
+            this.openStream(this.getFilePath(date, 0));
+        }
 
-            const ok = this.stream.write(chunk);
-            if (!ok) {
-                await new Promise((resolve) => {
-                    const stream = this.stream;
-                    if (!stream) {
-                        resolve();
-                        return;
-                    }
-                    stream.once("drain", () => resolve());
-                });
-            }
-            this.streamSizeBytes = this.streamSizeBytes + chunkBytes;
-            return true;
-        } catch (error) {
-            safeWriteStderr(`[Logger] file sink flush error (${this.prefix}): ${error?.message || error}`);
-            this.disabled = true;
-            await this.closeStream();
-            return false;
+        if (this.stream && this.streamSizeBytes + nextChunkBytes > MAX_FILE_BYTES) {
+            this.closeStreamSync();
+            this.streamIndex += 1;
+            this.streamSizeBytes = 0;
+
+            this.openStream(this.getFilePath(date, this.streamIndex));
         }
     }
 
-    async closeStream() {
-        if (!this.stream) return;
-        const st = this.stream;
-        this.stream = null;
-
-        await new Promise((resolve) => {
-            try {
-                st.end(() => resolve());
-            } catch {
-                resolve();
-            }
-        });
+    getFileSize(filePath) {
+        try {
+            return statSync(filePath).size;
+        } catch {
+            return 0;
+        }
     }
 
     openStream(filePath) {
@@ -202,7 +112,7 @@ class LogFileSink {
             this.stream.on("error", (error) => {
                 safeWriteStderr(`[Logger] file sink error (${this.prefix}): ${error?.message || error}`);
                 this.disabled = true;
-                this.closeStream();
+                this.closeStreamSync();
             });
         } catch (error) {
             safeWriteStderr(`[Logger] createWriteStream failed (${this.prefix}): ${error?.message || error}`);
@@ -211,91 +121,51 @@ class LogFileSink {
         }
     }
 
-    getFilePath(date, index) {
-        const suffix = index > 0 ? `.${index}` : "";
-        const filename = this.prefix === "app" ? `${date}${suffix}.log` : `${this.prefix}.${date}${suffix}.log`;
-        return nodePathJoin(RUNTIME_LOG_DIR, filename);
-    }
-
-    async ensureStreamReady(nextChunkBytes) {
-        const date = formatYmdHms(Date.now(), "date");
-
-        // 日期变化：切新文件
-        if (this.stream && this.streamDate && date !== this.streamDate) {
-            await this.closeStream();
-            this.streamDate = "";
-            this.streamIndex = 0;
-            this.streamSizeBytes = 0;
+    closeStreamSync() {
+        if (this.stream) {
+            this.stream.end();
         }
+        this.stream = null;
+        this.streamDate = "";
+        this.streamIndex = 0;
+        this.streamSizeBytes = 0;
+    }
 
-        // 首次打开
-        if (!this.stream) {
-            const filePath = this.getFilePath(date, 0);
-            let size = 0;
-            try {
-                const st = await stat(filePath);
-                size = isNumber(st.size) ? st.size : 0;
-            } catch {
-                size = 0;
+    closeStream() {
+        return new Promise((resolve) => {
+            const st = this.stream;
+            if (!st) {
+                resolve();
+                return;
             }
-
-            this.streamDate = date;
+            this.stream = null;
+            this.streamDate = "";
             this.streamIndex = 0;
-            this.streamSizeBytes = size;
-
-            this.openStream(filePath);
-            if (!this.stream) return;
-        }
-
-        // 大小滚动
-        if (this.stream && this.maxFileBytes > 0 && this.streamSizeBytes + nextChunkBytes > this.maxFileBytes) {
-            await this.closeStream();
-            this.streamIndex = this.streamIndex + 1;
-            const filePath = this.getFilePath(date, this.streamIndex);
-            this.streamDate = date;
             this.streamSizeBytes = 0;
-
-            this.openStream(filePath);
-            if (!this.stream) return;
-        }
+            st.end(() => resolve());
+        });
     }
 }
 
 export async function flush() {
-    // 测试场景：mock logger 不需要 flush
     if (mockInstance) return;
 
     for (const sink of [appFileSink, errorFileSink]) {
-        if (!sink) {
-            continue;
-        }
-
-        try {
+        if (sink) {
             await sink.flushNow();
-        } catch {
-            // ignore
         }
     }
 }
 
 export async function shutdown() {
-    // 测试场景：mock logger 不需要 shutdown
     if (mockInstance) return;
 
-    // 重要：shutdown 可能与后续 Logger 调用并发。
-    // 因此这里捕获“当前的旧 sink/instance 快照”，只关闭这些快照，避免把新创建的 sink 一并清掉。
     const currentAppFileSink = appFileSink;
     const currentErrorFileSink = errorFileSink;
 
     for (const sink of [currentAppFileSink, currentErrorFileSink]) {
-        if (!sink) {
-            continue;
-        }
-
-        try {
+        if (sink) {
             await sink.shutdown();
-        } catch {
-            // ignore
         }
     }
 
@@ -305,23 +175,43 @@ export async function shutdown() {
     if (errorFileSink === currentErrorFileSink) {
         errorFileSink = null;
     }
+}
 
-    // shutdown 后允许下一次重新初始化时再次校验/创建目录（测试会清理目录，避免 ENOENT）
-    // 无需缓存状态：确保目录存在是幂等的。
+function getRuntimeLogDir(runtimeEnv) {
+    const cwd = process.cwd();
+    if (runtimeEnv === "development") {
+        return nodePathResolve(cwd, "logsDev");
+    }
+    return nodePathResolve(cwd, "logs");
 }
 
-function ensureLogDirExists() {
+function prepareLogDir(runtimeEnv, shouldClearDev = false) {
+    const logDir = getRuntimeLogDir(runtimeEnv);
+    const devLogDir = nodePathResolve(process.cwd(), "logsDev");
+
     try {
-        if (!existsSync(RUNTIME_LOG_DIR)) {
-            mkdirSync(RUNTIME_LOG_DIR, { recursive: true });
+        if (!existsSync(logDir)) {
+            mkdirSync(logDir, { recursive: true });
+        }
+        if (!existsSync(devLogDir)) {
+            mkdirSync(devLogDir, { recursive: true });
+        }
+        if (shouldClearDev && runtimeEnv === "development" && existsSync(devLogDir)) {
+            rmSync(devLogDir, { recursive: true, force: true });
+            mkdirSync(devLogDir, { recursive: true });
         }
     } catch (error) {
-        // 不能在 Logger 初始化前调用 Logger 本身，直接抛错即可
-        throw new Error(`创建 logs 目录失败: ${RUNTIME_LOG_DIR}. ${error?.message || error}`, {
+        throw new Error(`创建日志目录失败: ${logDir}. ${error?.message || error}`, {
             cause: error,
             code: "runtime"
         });
     }
+
+    return logDir;
+}
+
+function ensureLogDirExists() {
+    config.dir = prepareLogDir(config.runtimeEnv);
 }
 
 // 方案B：删除“启动时清理旧日志”功能（减少 I/O 与复杂度）。
@@ -330,40 +220,23 @@ function ensureLogDirExists() {
  * 配置日志
  */
 export function configure(cfg) {
-    // 旧实例可能仍持有文件句柄；这里异步关闭（不阻塞主流程）
     shutdown();
 
-    // 方案B：每次 configure 都从默认配置重新构建（避免继承上一次配置造成测试/运行时污染）
     config = Object.assign(
         {
             debug: 0,
-            dir: RUNTIME_LOG_DIR,
-            maxSize: 20,
+            dir: "",
             runtimeEnv: "production"
         },
         cfg
     );
 
-    // 约束：日志目录始终固定在当前项目根目录 logs，不允许外部覆盖。
-    config.dir = RUNTIME_LOG_DIR;
-
-    if (cfg && !isString(cfg.runtimeEnv) && isString(cfg.runMode)) {
-        config.runtimeEnv = cfg.runMode;
-    }
-
-    // maxSize：仅按 MB 计算，且强制范围 10..100
-    {
-        const raw = config.maxSize;
-        let mb = isFiniteNumber(raw) ? raw : 20;
-        if (mb < 10) mb = 10;
-        if (mb > 100) mb = 100;
-        config.maxSize = mb;
-    }
+    config.dir = getRuntimeLogDir(config.runtimeEnv);
+    prepareLogDir(config.runtimeEnv, true);
 
     appFileSink = null;
     errorFileSink = null;
 
-    // 运行时清洗上限：只保留深度/节点/对象键数量保护。
     sanitizeOptions = {
         sanitizeDepth: normalizePositiveInt(config.sanitizeDepth, 5, 1, 10),
         sanitizeNodes: normalizePositiveInt(config.sanitizeNodes, 5000, 50, 20000),
@@ -381,87 +254,56 @@ export function setMockLogger(mock) {
 }
 
 function buildJsonLine(level, timeMs, record) {
-    const base = {
+    const out = {
         level: level,
         time: formatYmdHms(timeMs),
         pid: process.pid
     };
 
-    // 目标：让 level/time/timeFormat/pid/hostname 在 JSON 行首出现（更易读），同时保持 JSONL 可解析。
-    // 约束：record 不允许覆盖基础字段。
-    // 实现：先写入基础字段，再按 record 的 key 顺序追加其它字段。
     if (record && isPlainObject(record)) {
-        const out = {};
-        out["level"] = base["level"];
-        out["time"] = base["time"];
-        out["pid"] = base["pid"];
-
         for (const key of Object.keys(record)) {
-            if (key === "level") continue;
-            if (key === "time") continue;
-            if (key === "pid") continue;
+            if (key === "level" || key === "time" || key === "pid") {
+                continue;
+            }
             out[key] = record[key];
         }
 
-        // msg 允许保留 record.msg（若存在），否则补齐空字符串。
-        if (record.msg !== undefined) {
-            out["msg"] = record.msg;
-        } else if (out["msg"] === undefined) {
-            out["msg"] = "";
-        }
-
-        try {
-            return `${JSON.stringify(out)}\n`;
-        } catch {
-            try {
-                return `${JSON.stringify({ level: out["level"], time: out["time"], pid: out["pid"], msg: "[Unserializable log record]" })}\n`;
-            } catch {
-                return '{"msg":"[Unserializable log record]"}\n';
-            }
+        if (out.msg === undefined) {
+            out.msg = "";
         }
-    }
-
-    if (base["msg"] === undefined) {
-        base["msg"] = "";
+    } else {
+        out.msg = "";
     }
 
     try {
-        return `${JSON.stringify(base)}\n`;
+        return `${JSON.stringify(out)}\n`;
     } catch {
-        try {
-            return `${JSON.stringify({ level: base["level"], time: base["time"], pid: base["pid"], msg: "[Unserializable log record]" })}\n`;
-        } catch {
-            return '{"msg":"[Unserializable log record]"}\n';
-        }
+        return `${JSON.stringify({ level: out.level, time: out.time, pid: out.pid, msg: "[Unserializable log record]" })}\n`;
     }
 }
 
 function ensureSinksReady(kind) {
     ensureLogDirExists();
 
-    const maxSizeMb = isFiniteNumber(config.maxSize) ? config.maxSize : 20;
-    const maxFileBytes = Math.floor(maxSizeMb * 1024 * 1024);
-
     if (kind === "app") {
         if (!appFileSink) {
-            appFileSink = new LogFileSink({ prefix: "app", maxFileBytes: maxFileBytes });
+            appFileSink = new LogFileSink("app");
         }
-        return { fileSink: appFileSink };
+        return appFileSink;
     }
 
     if (!errorFileSink) {
-        errorFileSink = new LogFileSink({ prefix: "error", maxFileBytes: maxFileBytes });
+        errorFileSink = new LogFileSink("error");
     }
-
-    return { fileSink: errorFileSink };
+    return errorFileSink;
 }
 
 function writeJsonl(kind, level, record) {
-    const sinks = ensureSinksReady(kind);
+    const sink = ensureSinksReady(kind);
     const time = Date.now();
     const sanitizedRecord = sanitizeLogObject(record, sanitizeOptions);
     const fileLine = buildJsonLine(level, time, sanitizedRecord);
-    sinks.fileSink.enqueue(fileLine);
+    sink.write(fileLine);
 }
 
 // 对象清洗/脱敏逻辑已下沉到 utils/loggerUtils.js（减少 logger.js 复杂度）。
@@ -507,15 +349,7 @@ function logWrite(level, input) {
     // 测试场景：mock logger 走同步写入，并在入口进行清洗/脱敏控制
     if (mockInstance) {
         const sanitized = sanitizeLogObject(record0, sanitizeOptions);
-        if (level === "info") {
-            mockInstance.info(sanitized);
-        } else if (level === "warn") {
-            mockInstance.warn(sanitized);
-        } else if (level === "error") {
-            mockInstance.error(sanitized);
-        } else {
-            mockInstance.debug(sanitized);
-        }
+        mockInstance[level](sanitized);
         return;
     }
 
@@ -527,26 +361,23 @@ function logWrite(level, input) {
     }
 }
 
-/**
- * 日志实例（延迟初始化）
- */
-export const Logger = {
-    info: function (msg, data) {
+function buildLogMethod(level) {
+    return function (msg, data) {
         if (isPlainObject(msg)) {
-            logWrite("info", msg);
+            logWrite(level, msg);
             return;
         }
 
-        logWrite("info", { msg: msg, data: data });
-    },
-    warn: function (msg, data) {
-        if (isPlainObject(msg)) {
-            logWrite("warn", msg);
-            return;
-        }
+        logWrite(level, { msg: msg, data: data });
+    };
+}
 
-        logWrite("warn", { msg: msg, data: data });
-    },
+/**
+ * 日志实例（延迟初始化）
+ */
+export const Logger = {
+    info: buildLogMethod("info"),
+    warn: buildLogMethod("warn"),
     error: function (msg, err, data) {
         if (isPlainObject(msg)) {
             logWrite("error", msg);
@@ -555,14 +386,7 @@ export const Logger = {
 
         logWrite("error", { msg: msg, err: err, data: data });
     },
-    debug: function (msg, data) {
-        if (isPlainObject(msg)) {
-            logWrite("debug", msg);
-            return;
-        }
-
-        logWrite("debug", { msg: msg, data: data });
-    },
+    debug: buildLogMethod("debug"),
     flush: async function () {
         await flush();
     },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.60.0",
+    "version": "3.62.0",
     "gitHead": "49c39d36695036e85fc64083cc43c1652fff96cb",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 JavaScript API 接口框架核心引擎",

package/plugins/logger.js

@@ -10,11 +10,8 @@ import { Logger } from "../lib/logger.js";
  */
 export default {
     order: 2,
-    handler: async function (befly) {
-        // 配置 Logger
-        if (befly.config && befly.config.logger) {
-            Logger.configure(befly.config.logger);
-        }
+    handler: async function () {
+        // 日志已在 createBefly 中按 runMode 初始化，这里只注入 Logger 实例
         return Logger;
     }
 };

package/utils/loggerUtils.js

@@ -162,9 +162,6 @@ function sanitizeAny(value, options, state, depth, visited) {
 
     for (let i = 0; i < limit; i++) {
         const entry = entries[i];
-        if (!entry) {
-            continue;
-        }
         const key = entry[0];
         const child = entry[1];