befly 3.12.3 → 3.13.0

package/dist/lib/logger.js

@@ -2,35 +2,25 @@
  * 日志系统 - Bun 环境自定义实现（替换 pino / pino-roll）
  */
 import { createWriteStream, existsSync, mkdirSync } from "node:fs";
-import { readdir, stat, unlink } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 import { hostname as osHostname } from "node:os";
 import { isAbsolute as nodePathIsAbsolute, join as nodePathJoin, resolve as nodePathResolve } from "node:path";
-import { isPlainObject } from "../utils/util";
+import { formatYmdHms } from "../utils/formatYmdHms";
+import { buildSensitiveKeyMatcher, sanitizeLogObject } from "../utils/loggerUtils";
+import { isPlainObject, normalizePositiveInt } from "../utils/util";
 import { getCtx } from "./asyncContext";
-const REGEXP_SPECIAL = /[\\^$.*+?()[\]{}|]/g;
-export function escapeRegExp(input) {
-    return String(input).replace(REGEXP_SPECIAL, "\\$&");
-}
 // 注意：Logger 可能在运行时/测试中被 process.chdir() 影响。
 // 为避免相对路径的 logs 目录随着 cwd 变化，使用模块加载时的初始 cwd 作为锚点。
 const INITIAL_CWD = process.cwd();
-const DEFAULT_LOG_STRING_LEN = 100;
-const DEFAULT_LOG_ARRAY_ITEMS = 100;
-let maxLogStringLen = DEFAULT_LOG_STRING_LEN;
-let maxLogArrayItems = DEFAULT_LOG_ARRAY_ITEMS;
-// 为避免递归导致栈溢出/性能抖动：使用非递归遍历，并对深度/节点数做硬限制。
-// 说明：这不是业务数据结构的“真实深度”，而是日志清洗的最大深入层级（越大越重）。
-const DEFAULT_LOG_SANITIZE_DEPTH = 3;
-const DEFAULT_LOG_OBJECT_KEYS = 100;
-const DEFAULT_LOG_SANITIZE_NODES = 500;
-let sanitizeDepthLimit = DEFAULT_LOG_SANITIZE_DEPTH;
-let sanitizeObjectKeysLimit = DEFAULT_LOG_OBJECT_KEYS;
-let sanitizeNodesLimit = DEFAULT_LOG_SANITIZE_NODES;
-const ONE_YEAR_MS = 365 * 24 * 60 * 60 * 1000;
 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"];
-let sensitiveKeySet = new Set();
-let sensitiveContainsMatchers = [];
-let sensitiveContainsRegex = null;
+let sanitizeOptions = {
+    maxStringLen: 100,
+    maxArrayItems: 100,
+    sanitizeDepth: 3,
+    sanitizeNodes: 500,
+    sanitizeObjectKeys: 100,
+    sensitiveKeyMatcher: buildSensitiveKeyMatcher({ builtinPatterns: BUILTIN_SENSITIVE_KEYS, userPatterns: [] })
+};
 const HOSTNAME = (() => {
     try {
         return osHostname();
@@ -39,49 +29,19 @@ const HOSTNAME = (() => {
         return "unknown";
     }
 })();
-const LOG_LEVEL_NUM = {
-    debug: 20,
-    info: 30,
-    warn: 40,
-    error: 50
-};
-const DEFAULT_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
-const DEFAULT_FLUSH_DELAY_MS = 10;
-const DEFAULT_MAX_BATCH_BYTES = 64 * 1024;
 let instance = null;
 let errorInstance = null;
 let mockInstance = null;
 let appFileSink = null;
 let errorFileSink = null;
 let appConsoleSink = null;
-let didWarnIoError = false;
-let didPruneOldLogFiles = false;
-let didEnsureLogDir = false;
 let config = {
     debug: 0,
     dir: "./logs",
     console: 1,
-    maxSize: 10
+    maxSize: 20
 };
-function formatLocalDate(date) {
-    const y = date.getFullYear();
-    const m = date.getMonth() + 1;
-    const d = date.getDate();
-    const mm = m < 10 ? `0${m}` : String(m);
-    const dd = d < 10 ? `0${d}` : String(d);
-    return `${y}-${mm}-${dd}`;
-}
-function normalizeLogLevelName() {
-    // 与旧行为保持一致：debug=1 -> debug，否则 -> info
-    return config.debug === 1 ? "debug" : "info";
-}
-function shouldAccept(minLevel, level) {
-    return LOG_LEVEL_NUM[level] >= LOG_LEVEL_NUM[minLevel];
-}
-function safeWriteStderrOnce(msg) {
-    if (didWarnIoError)
-        return;
-    didWarnIoError = true;
+function safeWriteStderr(msg) {
     try {
         process.stderr.write(`${msg}\n`);
     }
@@ -99,86 +59,88 @@ function shiftBatchFromPending(pending, maxBatchBytes) {
             break;
         }
         parts.push(next);
-        bytes += nextBytes;
+        bytes = bytes + nextBytes;
         pending.shift();
     }
     return { chunk: parts.join(""), bytes: bytes };
 }
-class LogStreamSink {
-    kind;
-    minLevel;
+class BufferedSink {
     pending;
     pendingBytes;
-    scheduled;
+    scheduledTimer;
     flushing;
     maxBufferBytes;
     flushDelayMs;
     maxBatchBytes;
+    writeChunk;
+    onShutdown;
     constructor(options) {
-        this.kind = options.kind;
-        this.minLevel = options.minLevel;
         this.pending = [];
         this.pendingBytes = 0;
-        this.scheduled = false;
+        this.scheduledTimer = null;
         this.flushing = false;
-        this.maxBufferBytes = DEFAULT_MAX_BUFFER_BYTES;
-        this.flushDelayMs = DEFAULT_FLUSH_DELAY_MS;
-        this.maxBatchBytes = DEFAULT_MAX_BATCH_BYTES;
+        this.maxBufferBytes = options.maxBufferBytes;
+        this.flushDelayMs = options.flushDelayMs;
+        this.maxBatchBytes = options.maxBatchBytes;
+        this.writeChunk = options.writeChunk;
+        this.onShutdown = options.onShutdown ? options.onShutdown : null;
+    }
+    scheduleFlush() {
+        if (this.scheduledTimer)
+            return;
+        this.scheduledTimer = setTimeout(() => {
+            // timer 触发时先清空句柄，避免 flush 内再次 schedule 时被认为“已安排”。
+            this.scheduledTimer = null;
+            void this.flush();
+        }, this.flushDelayMs);
     }
-    enqueue(level, line) {
-        if (!shouldAccept(this.minLevel, level))
+    cancelScheduledFlush() {
+        if (!this.scheduledTimer)
             return;
+        clearTimeout(this.scheduledTimer);
+        this.scheduledTimer = null;
+    }
+    enqueue(line) {
         const bytes = Buffer.byteLength(line);
         if (this.pendingBytes + bytes > this.maxBufferBytes) {
-            // stream sink：优先丢 debug/info，保留 warn/error
-            if (LOG_LEVEL_NUM[level] < LOG_LEVEL_NUM.warn) {
-                return;
-            }
+            // buffer 满：统一丢弃新日志（不区分 level）
+            return;
         }
         this.pending.push(line);
-        this.pendingBytes += bytes;
+        this.pendingBytes = this.pendingBytes + bytes;
         this.scheduleFlush();
     }
     async flushNow() {
+        // 若已安排了定时 flush，flushNow 会覆盖它，避免出现多个 timer 并存。
+        this.cancelScheduledFlush();
         await this.flush();
     }
     async shutdown() {
+        this.cancelScheduledFlush();
         await this.flush();
-    }
-    scheduleFlush() {
-        if (this.scheduled)
-            return;
-        this.scheduled = true;
-        setTimeout(() => {
-            void this.flush();
-        }, this.flushDelayMs);
-    }
-    getStream() {
-        return this.kind === "stderr" ? process.stderr : process.stdout;
+        if (this.onShutdown) {
+            await this.onShutdown();
+        }
     }
     async flush() {
         if (this.flushing)
             return;
-        this.scheduled = false;
         this.flushing = true;
         try {
-            const stream = this.getStream();
             while (this.pending.length > 0) {
                 const batch = shiftBatchFromPending(this.pending, this.maxBatchBytes);
                 const chunk = batch.chunk;
                 const chunkBytes = Buffer.byteLength(chunk);
                 this.pendingBytes = this.pendingBytes - chunkBytes;
-                const ok = stream.write(chunk);
+                const ok = await this.writeChunk(chunk, chunkBytes);
                 if (!ok) {
-                    await new Promise((resolve) => {
-                        stream.once("drain", () => resolve());
-                    });
+                    // writer 已禁用/失败：清空剩余 pending
+                    this.pending = [];
+                    this.pendingBytes = 0;
+                    break;
                 }
             }
         }
-        catch (error) {
-            safeWriteStderrOnce(`[Logger] stream sink error: ${error?.message || error}`);
-        }
         finally {
             this.flushing = false;
             if (this.pending.length > 0) {
@@ -187,17 +149,47 @@ class LogStreamSink {
         }
     }
 }
+function createStreamSink(kind) {
+    const getStream = () => {
+        return kind === "stderr" ? process.stderr : process.stdout;
+    };
+    const buffer = new BufferedSink({
+        maxBufferBytes: 10 * 1024 * 1024,
+        flushDelayMs: 10,
+        maxBatchBytes: 64 * 1024,
+        writeChunk: async (chunk) => {
+            try {
+                const stream = getStream();
+                const ok = stream.write(chunk);
+                if (!ok) {
+                    await new Promise((resolve) => {
+                        stream.once("drain", () => resolve());
+                    });
+                }
+                return true;
+            }
+            catch (error) {
+                safeWriteStderr(`[Logger] stream sink error: ${error?.message || error}`);
+                return false;
+            }
+        }
+    });
+    return {
+        enqueue(line) {
+            buffer.enqueue(line);
+        },
+        async flushNow() {
+            await buffer.flushNow();
+        },
+        async shutdown() {
+            await buffer.shutdown();
+        }
+    };
+}
 class LogFileSink {
     prefix;
-    minLevel;
     maxFileBytes;
-    pending;
-    pendingBytes;
-    scheduled;
-    flushing;
-    maxBufferBytes;
-    flushDelayMs;
-    maxBatchBytes;
+    buffer;
     stream;
     streamDate;
     streamIndex;
@@ -205,51 +197,56 @@ class LogFileSink {
     disabled;
     constructor(options) {
         this.prefix = options.prefix;
-        this.minLevel = options.minLevel;
         this.maxFileBytes = options.maxFileBytes;
-        this.pending = [];
-        this.pendingBytes = 0;
-        this.scheduled = false;
-        this.flushing = false;
-        this.maxBufferBytes = DEFAULT_MAX_BUFFER_BYTES;
-        this.flushDelayMs = DEFAULT_FLUSH_DELAY_MS;
-        this.maxBatchBytes = DEFAULT_MAX_BATCH_BYTES;
         this.stream = null;
         this.streamDate = "";
         this.streamIndex = 0;
         this.streamSizeBytes = 0;
         this.disabled = false;
+        this.buffer = new BufferedSink({
+            maxBufferBytes: 10 * 1024 * 1024,
+            flushDelayMs: 10,
+            maxBatchBytes: 64 * 1024,
+            writeChunk: async (chunk, chunkBytes) => {
+                if (this.disabled)
+                    return false;
+                try {
+                    await this.ensureStreamReady(chunkBytes);
+                    if (!this.stream) {
+                        // 文件 sink 已被禁用或打开失败
+                        return false;
+                    }
+                    const ok = this.stream.write(chunk);
+                    if (!ok) {
+                        await new Promise((resolve) => {
+                            this.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;
+                }
+            },
+            onShutdown: async () => {
+                await this.closeStream();
+            }
+        });
     }
-    enqueue(level, line) {
+    enqueue(line) {
         if (this.disabled)
             return;
-        if (!shouldAccept(this.minLevel, level))
-            return;
-        const bytes = Buffer.byteLength(line);
-        if (this.pendingBytes + bytes > this.maxBufferBytes) {
-            // 文件 sink：优先丢 debug/info，保留 warn/error
-            if (LOG_LEVEL_NUM[level] < LOG_LEVEL_NUM.warn) {
-                return;
-            }
-        }
-        this.pending.push(line);
-        this.pendingBytes += bytes;
-        this.scheduleFlush();
+        this.buffer.enqueue(line);
     }
     async flushNow() {
-        await this.flush();
+        await this.buffer.flushNow();
     }
     async shutdown() {
-        await this.flush();
-        await this.closeStream();
-    }
-    scheduleFlush() {
-        if (this.scheduled)
-            return;
-        this.scheduled = true;
-        setTimeout(() => {
-            void this.flush();
-        }, this.flushDelayMs);
+        await this.buffer.shutdown();
     }
     async closeStream() {
         if (!this.stream)
@@ -265,13 +262,28 @@ class LogFileSink {
             }
         });
     }
+    openStream(filePath) {
+        try {
+            this.stream = createWriteStream(filePath, { flags: "a" });
+            this.stream.on("error", (error) => {
+                safeWriteStderr(`[Logger] file sink error (${this.prefix}): ${error?.message || error}`);
+                this.disabled = true;
+                void this.closeStream();
+            });
+        }
+        catch (error) {
+            safeWriteStderr(`[Logger] createWriteStream failed (${this.prefix}): ${error?.message || error}`);
+            this.disabled = true;
+            this.stream = null;
+        }
+    }
     getFilePath(date, index) {
         const suffix = index > 0 ? `.${index}` : "";
         const filename = `${this.prefix}.${date}${suffix}.log`;
         return nodePathJoin(resolveLogDir(), filename);
     }
     async ensureStreamReady(nextChunkBytes) {
-        const date = formatLocalDate(new Date());
+        const date = formatYmdHms(new Date(), "date");
         // 日期变化：切新文件
         if (this.stream && this.streamDate && date !== this.streamDate) {
             await this.closeStream();
@@ -293,19 +305,9 @@ class LogFileSink {
             this.streamDate = date;
             this.streamIndex = 0;
             this.streamSizeBytes = size;
-            try {
-                this.stream = createWriteStream(filePath, { flags: "a" });
-                this.stream.on("error", (error) => {
-                    safeWriteStderrOnce(`[Logger] file sink error (${this.prefix}): ${error?.message || error}`);
-                    this.disabled = true;
-                    void this.closeStream();
-                });
-            }
-            catch (error) {
-                safeWriteStderrOnce(`[Logger] createWriteStream failed (${this.prefix}): ${error?.message || error}`);
-                this.disabled = true;
+            this.openStream(filePath);
+            if (!this.stream)
                 return;
-            }
         }
         // 大小滚动
         if (this.stream && this.maxFileBytes > 0 && this.streamSizeBytes + nextChunkBytes > this.maxFileBytes) {
@@ -314,59 +316,9 @@ class LogFileSink {
             const filePath = this.getFilePath(date, this.streamIndex);
             this.streamDate = date;
             this.streamSizeBytes = 0;
-            try {
-                this.stream = createWriteStream(filePath, { flags: "a" });
-                this.stream.on("error", (error) => {
-                    safeWriteStderrOnce(`[Logger] file sink error (${this.prefix}): ${error?.message || error}`);
-                    this.disabled = true;
-                    void this.closeStream();
-                });
-            }
-            catch (error) {
-                safeWriteStderrOnce(`[Logger] createWriteStream failed (${this.prefix}): ${error?.message || error}`);
-                this.disabled = true;
+            this.openStream(filePath);
+            if (!this.stream)
                 return;
-            }
-        }
-    }
-    async flush() {
-        if (this.disabled) {
-            this.pending = [];
-            this.pendingBytes = 0;
-            return;
-        }
-        if (this.flushing)
-            return;
-        this.scheduled = false;
-        this.flushing = true;
-        try {
-            while (this.pending.length > 0 && !this.disabled) {
-                const batch = shiftBatchFromPending(this.pending, this.maxBatchBytes);
-                const chunk = batch.chunk;
-                const chunkBytes = Buffer.byteLength(chunk);
-                this.pendingBytes = this.pendingBytes - chunkBytes;
-                await this.ensureStreamReady(chunkBytes);
-                if (!this.stream) {
-                    // 文件 sink 已被禁用或打开失败
-                    break;
-                }
-                const ok = this.stream.write(chunk);
-                if (!ok) {
-                    await new Promise((resolve) => {
-                        this.stream.once("drain", () => resolve());
-                    });
-                }
-                this.streamSizeBytes = this.streamSizeBytes + chunkBytes;
-            }
-        }
-        catch (error) {
-            safeWriteStderrOnce(`[Logger] file sink flush error (${this.prefix}): ${error?.message || error}`);
-        }
-        finally {
-            this.flushing = false;
-            if (this.pending.length > 0 && !this.disabled) {
-                this.scheduleFlush();
-            }
         }
     }
 }
@@ -394,13 +346,20 @@ export async function shutdown() {
     // 测试场景：mock logger 不需要 shutdown
     if (mockInstance)
         return;
+    // 重要：shutdown 可能与后续 Logger.getLogger() 并发。
+    // 因此这里捕获“当前的旧 sink/instance 快照”，只关闭这些快照，避免把新创建的 sink 一并清掉。
+    const currentInstance = instance;
+    const currentErrorInstance = errorInstance;
+    const currentAppFileSink = appFileSink;
+    const currentErrorFileSink = errorFileSink;
+    const currentAppConsoleSink = appConsoleSink;
     const sinks = [];
-    if (appFileSink)
-        sinks.push({ shutdown: () => (appFileSink ? appFileSink.shutdown() : Promise.resolve()) });
-    if (errorFileSink)
-        sinks.push({ shutdown: () => (errorFileSink ? errorFileSink.shutdown() : Promise.resolve()) });
-    if (appConsoleSink)
-        sinks.push({ shutdown: () => (appConsoleSink ? appConsoleSink.shutdown() : Promise.resolve()) });
+    if (currentAppFileSink)
+        sinks.push({ shutdown: () => currentAppFileSink.shutdown() });
+    if (currentErrorFileSink)
+        sinks.push({ shutdown: () => currentErrorFileSink.shutdown() });
+    if (currentAppConsoleSink)
+        sinks.push({ shutdown: () => currentAppConsoleSink.shutdown() });
     for (const item of sinks) {
         try {
             await item.shutdown();
@@ -409,25 +368,23 @@ export async function shutdown() {
             // ignore
         }
     }
-    appFileSink = null;
-    errorFileSink = null;
-    appConsoleSink = null;
-    instance = null;
-    errorInstance = null;
+    if (appFileSink === currentAppFileSink) {
+        appFileSink = null;
+    }
+    if (errorFileSink === currentErrorFileSink) {
+        errorFileSink = null;
+    }
+    if (appConsoleSink === currentAppConsoleSink) {
+        appConsoleSink = null;
+    }
+    if (instance === currentInstance) {
+        instance = null;
+    }
+    if (errorInstance === currentErrorInstance) {
+        errorInstance = null;
+    }
     // shutdown 后允许下一次重新初始化时再次校验/创建目录（测试会清理目录，避免 ENOENT）
-    didEnsureLogDir = false;
-}
-function normalizePositiveInt(value, fallback, min, max) {
-    if (typeof value !== "number")
-        return fallback;
-    if (!Number.isFinite(value))
-        return fallback;
-    const v = Math.floor(value);
-    if (v < min)
-        return fallback;
-    if (v > max)
-        return max;
-    return v;
+    // 无需缓存状态：确保目录存在是幂等的。
 }
 function resolveLogDir() {
     const rawDir = config.dir || "./logs";
@@ -447,115 +404,45 @@ function ensureLogDirExists() {
         // 不能在 Logger 初始化前调用 Logger 本身，直接抛错即可
         throw new Error(`创建 logs 目录失败: ${dir}. ${error?.message || error}`);
     }
-    didEnsureLogDir = true;
-}
-async function pruneOldLogFiles() {
-    if (didPruneOldLogFiles)
-        return;
-    didPruneOldLogFiles = true;
-    const dir = resolveLogDir();
-    const now = Date.now();
-    const cutoff = now - ONE_YEAR_MS;
-    try {
-        const entries = await readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isFile())
-                continue;
-            const name = entry.name;
-            // 只处理本项目的日志文件前缀
-            const isTarget = name.startsWith("app.") || name.startsWith("error.");
-            if (!isTarget)
-                continue;
-            const fullPath = nodePathJoin(dir, name);
-            let st;
-            try {
-                st = await stat(fullPath);
-            }
-            catch {
-                continue;
-            }
-            const mtimeMs = typeof st.mtimeMs === "number" ? st.mtimeMs : 0;
-            if (mtimeMs > 0 && mtimeMs < cutoff) {
-                try {
-                    await unlink(fullPath);
-                }
-                catch {
-                    // 忽略删除失败（权限/占用等），避免影响服务启动
-                }
-            }
-        }
-    }
-    catch {
-        // 忽略：目录不存在或无权限等
-    }
 }
+// 方案B：删除“启动时清理旧日志”功能（减少 I/O 与复杂度）。
 /**
  * 配置日志
  */
 export function configure(cfg) {
     // 旧实例可能仍持有文件句柄；这里异步关闭（不阻塞主流程）
     void shutdown();
-    config = Object.assign({}, config, cfg);
+    // 方案B：每次 configure 都从默认配置重新构建（避免继承上一次配置造成测试/运行时污染）
+    config = Object.assign({
+        debug: 0,
+        dir: "./logs",
+        console: 1,
+        maxSize: 20
+    }, cfg);
+    // maxSize：仅按 MB 计算，且强制范围 10..100
+    {
+        const raw = config.maxSize;
+        let mb = typeof raw === "number" && Number.isFinite(raw) ? raw : 20;
+        if (mb < 10)
+            mb = 10;
+        if (mb > 100)
+            mb = 100;
+        config.maxSize = mb;
+    }
     instance = null;
     errorInstance = null;
-    didPruneOldLogFiles = false;
-    didEnsureLogDir = false;
-    didWarnIoError = false;
     appFileSink = null;
     errorFileSink = null;
     appConsoleSink = null;
-    // 运行时清洗上限（可配置）
-    sanitizeDepthLimit = normalizePositiveInt(config.sanitizeDepth, DEFAULT_LOG_SANITIZE_DEPTH, 1, 10);
-    sanitizeNodesLimit = normalizePositiveInt(config.sanitizeNodes, DEFAULT_LOG_SANITIZE_NODES, 50, 20000);
-    sanitizeObjectKeysLimit = normalizePositiveInt(config.sanitizeObjectKeys, DEFAULT_LOG_OBJECT_KEYS, 10, 5000);
-    // 运行时截断上限（可配置）
-    maxLogStringLen = normalizePositiveInt(config.maxStringLen, DEFAULT_LOG_STRING_LEN, 20, 200000);
-    maxLogArrayItems = normalizePositiveInt(config.maxArrayItems, DEFAULT_LOG_ARRAY_ITEMS, 10, 5000);
-    // 仅支持数组配置：excludeFields?: string[]
-    const userPatterns = Array.isArray(config.excludeFields) ? config.excludeFields : [];
-    const patterns = [];
-    for (const item of BUILTIN_SENSITIVE_KEYS) {
-        const trimmed = String(item).trim();
-        if (trimmed.length > 0)
-            patterns.push(trimmed.toLowerCase());
-    }
-    for (const item of userPatterns) {
-        const trimmed = String(item).trim();
-        if (trimmed.length > 0)
-            patterns.push(trimmed.toLowerCase());
-    }
-    const exactSet = new Set();
-    const containsMatchers = [];
-    for (const pat of patterns) {
-        // 精简策略：
-        // - 无 *：精确匹配
-        // - 有 *：统一按“包含匹配”处理（*x*、x*、*x、a*b 都视为包含 core）
-        if (!pat.includes("*")) {
-            exactSet.add(pat);
-            continue;
-        }
-        const core = pat.replace(/\*+/g, "").trim();
-        if (!core) {
-            continue;
-        }
-        containsMatchers.push(core);
-    }
-    sensitiveKeySet = exactSet;
-    sensitiveContainsMatchers = containsMatchers;
-    // 预编译包含匹配：减少每次 isSensitiveKey 的循环开销
-    // 注意：patterns 已全部 lowerCase，因此 regex 不需要 i 标志
-    if (containsMatchers.length > 0) {
-        const escaped = containsMatchers.map((item) => escapeRegExp(item)).filter((item) => item.length > 0);
-        if (escaped.length > 0) {
-            sensitiveContainsRegex = new RegExp(escaped.join("|"));
-        }
-        else {
-            sensitiveContainsRegex = null;
-        }
-    }
-    else {
-        sensitiveContainsRegex = null;
-    }
+    // 运行时清洗/截断上限（可配置）
+    sanitizeOptions = {
+        maxStringLen: normalizePositiveInt(config.maxStringLen, 100, 20, 200000),
+        maxArrayItems: normalizePositiveInt(config.maxArrayItems, 100, 10, 5000),
+        sanitizeDepth: normalizePositiveInt(config.sanitizeDepth, 3, 1, 10),
+        sanitizeNodes: normalizePositiveInt(config.sanitizeNodes, 500, 50, 20000),
+        sanitizeObjectKeys: normalizePositiveInt(config.sanitizeObjectKeys, 100, 10, 5000),
+        sensitiveKeyMatcher: buildSensitiveKeyMatcher({ builtinPatterns: BUILTIN_SENSITIVE_KEYS, userPatterns: config.excludeFields })
+    };
 }
 /**
  * 设置 Mock Logger（用于测试）
@@ -564,136 +451,67 @@ export function configure(cfg) {
 export function setMockLogger(mock) {
     mockInstance = mock;
 }
-/**
- * 获取 Logger 实例（延迟初始化）
- */
-export function getLogger() {
+function getSink(kind) {
     // 优先返回 mock 实例（用于测试）
     if (mockInstance)
         return mockInstance;
-    if (instance)
-        return instance;
-    ensureLogDirExists();
-    // 启动时清理过期日志（异步，不阻塞初始化）
-    void pruneOldLogFiles();
-    const minLevel = normalizeLogLevelName();
-    const maxFileBytes = (typeof config.maxSize === "number" && config.maxSize > 0 ? config.maxSize : 10) * 1024 * 1024;
-    if (!appFileSink) {
-        appFileSink = new LogFileSink({ prefix: "app", minLevel: minLevel, maxFileBytes: maxFileBytes });
+    if (kind === "app") {
+        if (instance)
+            return instance;
     }
-    if (config.console === 1 && !appConsoleSink) {
-        appConsoleSink = new LogStreamSink({ kind: "stdout", minLevel: minLevel });
+    else {
+        if (errorInstance)
+            return errorInstance;
     }
-    instance = createSinkLogger({ kind: "app", minLevel: minLevel, fileSink: appFileSink, consoleSink: config.console === 1 ? appConsoleSink : null });
-    return instance;
-}
-function getErrorLogger() {
-    if (mockInstance)
-        return mockInstance;
-    if (errorInstance)
-        return errorInstance;
     ensureLogDirExists();
-    void pruneOldLogFiles();
-    const maxFileBytes = (typeof config.maxSize === "number" && config.maxSize > 0 ? config.maxSize : 10) * 1024 * 1024;
+    const maxSizeMb = typeof config.maxSize === "number" ? config.maxSize : 20;
+    const maxFileBytes = Math.floor(maxSizeMb * 1024 * 1024);
+    if (kind === "app") {
+        if (!appFileSink) {
+            appFileSink = new LogFileSink({ prefix: "app", maxFileBytes: maxFileBytes });
+        }
+        if (config.console === 1 && !appConsoleSink) {
+            appConsoleSink = createStreamSink("stdout");
+        }
+        instance = createSinkLogger({ fileSink: appFileSink, consoleSink: config.console === 1 ? appConsoleSink : null });
+        return instance;
+    }
     if (!errorFileSink) {
-        // error logger：固定 minLevel=error
-        errorFileSink = new LogFileSink({ prefix: "error", minLevel: "error", maxFileBytes: maxFileBytes });
+        errorFileSink = new LogFileSink({ prefix: "error", maxFileBytes: maxFileBytes });
     }
-    errorInstance = createSinkLogger({ kind: "error", minLevel: "error", fileSink: errorFileSink, consoleSink: null });
+    errorInstance = createSinkLogger({ fileSink: errorFileSink, consoleSink: null });
     return errorInstance;
 }
-function formatExtrasToMsg(extras) {
-    if (!extras || extras.length === 0)
-        return "";
-    const parts = [];
-    for (const item of extras) {
-        if (item === null) {
-            parts.push("null");
-            continue;
-        }
-        if (item === undefined) {
-            parts.push("undefined");
-            continue;
-        }
-        if (typeof item === "string") {
-            parts.push(item);
-            continue;
-        }
-        if (typeof item === "number" || typeof item === "boolean" || typeof item === "bigint") {
-            parts.push(String(item));
-            continue;
-        }
-        if (item instanceof Error) {
-            parts.push(item.stack || item.message || item.name);
-            continue;
-        }
-        if (isPlainObject(item) || Array.isArray(item)) {
-            try {
-                parts.push(JSON.stringify(item));
-            }
-            catch {
-                parts.push("[Unserializable]");
-            }
-            continue;
-        }
-        try {
-            parts.push(String(item));
-        }
-        catch {
-            parts.push("[Unknown]");
-        }
-    }
-    return parts.join(" ");
+/**
+ * 获取 Logger 实例（延迟初始化）
+ */
+export function getLogger() {
+    return getSink("app");
 }
-function buildLogLine(level, args) {
+function buildLogLine(level, record) {
     const time = Date.now();
     const base = {
-        level: LOG_LEVEL_NUM[level],
+        level: level,
         time: time,
+        timeFormat: formatYmdHms(new Date(time)),
         pid: process.pid,
         hostname: HOSTNAME
     };
-    if (!args || args.length === 0) {
-        base.msg = "";
-        return `${JSON.stringify(base)}\n`;
-    }
-    const first = args[0];
-    const second = args.length > 1 ? args[1] : undefined;
-    // 兼容：logger.(level)(obj, msg?, ...)
-    if (isPlainObject(first)) {
-        for (const [k, v] of Object.entries(first)) {
-            base[k] = v;
+    // record 先写入，再用 base 覆盖基础字段（避免 record 覆盖 level/time/pid/hostname 等）
+    // msg 允许保留 record.msg（若存在），否则补齐空字符串。
+    if (record && isPlainObject(record)) {
+        const out = Object.assign({}, record, base);
+        if (record.msg !== undefined) {
+            out.msg = record.msg;
         }
-        if (typeof second === "string") {
-            const extraMsg = formatExtrasToMsg(args.slice(2));
-            base.msg = extraMsg ? `${second} ${extraMsg}` : second;
+        else if (out.msg === undefined) {
+            out.msg = "";
         }
-        else {
-            const extraMsg = formatExtrasToMsg(args.slice(1));
-            base.msg = extraMsg;
-        }
-        return `${safeJsonStringify(base)}\n`;
+        return `${safeJsonStringify(out)}\n`;
     }
-    // 兼容：logger.(level)(err, msg?)
-    if (first instanceof Error) {
-        base.err = sanitizeErrorValue(first);
-        if (typeof second === "string") {
-            const extraMsg = formatExtrasToMsg(args.slice(2));
-            base.msg = extraMsg ? `${second} ${extraMsg}` : second;
-        }
-        else {
-            base.msg = formatExtrasToMsg(args.slice(1));
-        }
-        return `${safeJsonStringify(base)}\n`;
-    }
-    // 兼容：logger.(level)(msg, ...)
-    if (typeof first === "string") {
-        const extraMsg = formatExtrasToMsg(args.slice(1));
-        base.msg = extraMsg ? `${first} ${extraMsg}` : first;
-        return `${safeJsonStringify(base)}\n`;
+    if (base.msg === undefined) {
+        base.msg = "";
     }
-    // 兜底
-    base.msg = formatExtrasToMsg(args);
     return `${safeJsonStringify(base)}\n`;
 }
 function safeJsonStringify(obj) {
@@ -710,239 +528,33 @@ function safeJsonStringify(obj) {
     }
 }
 function createSinkLogger(options) {
-    const minLevel = options.minLevel;
-    const write = (level, args) => {
-        if (!shouldAccept(minLevel, level))
+    const fileSink = options.fileSink;
+    const consoleSink = options.consoleSink;
+    const write = (level, record) => {
+        if (level === "debug" && config.debug !== 1)
             return;
-        const line = buildLogLine(level, args);
-        options.fileSink.enqueue(level, line);
-        if (options.consoleSink) {
-            options.consoleSink.enqueue(level, line);
-        }
+        const sanitizedRecord = sanitizeLogObject(record, sanitizeOptions);
+        const line = buildLogLine(level, sanitizedRecord);
+        fileSink.enqueue(line);
+        if (consoleSink)
+            consoleSink.enqueue(line);
     };
     return {
-        info(...args) {
-            write("info", args);
+        info(record) {
+            write("info", record);
         },
-        warn(...args) {
-            write("warn", args);
+        warn(record) {
+            write("warn", record);
         },
-        error(...args) {
-            write("error", args);
+        error(record) {
+            write("error", record);
         },
-        debug(...args) {
-            write("debug", args);
-        }
-    };
-}
-function truncateString(val) {
-    if (val.length <= maxLogStringLen)
-        return val;
-    return val.slice(0, maxLogStringLen);
-}
-function isSensitiveKey(key) {
-    const lower = String(key).toLowerCase();
-    if (sensitiveKeySet.has(lower))
-        return true;
-    if (sensitiveContainsRegex) {
-        return sensitiveContainsRegex.test(lower);
-    }
-    for (const part of sensitiveContainsMatchers) {
-        if (lower.includes(part))
-            return true;
-    }
-    return false;
-}
-function safeToStringMasked(val, visited) {
-    if (typeof val === "string")
-        return val;
-    if (val instanceof Error) {
-        const name = val.name || "Error";
-        const message = val.message || "";
-        const stack = typeof val.stack === "string" ? val.stack : "";
-        const errObj = {
-            name: name,
-            message: message,
-            stack: stack
-        };
-        try {
-            return JSON.stringify(errObj);
-        }
-        catch {
-            return `${name}: ${message}`;
-        }
-    }
-    if (val && typeof val === "object") {
-        if (visited.has(val)) {
-            return "[Circular]";
-        }
-    }
-    try {
-        const localVisited = visited;
-        const replacer = (k, v) => {
-            // JSON.stringify 的根节点 key 为空字符串
-            if (k && isSensitiveKey(k)) {
-                return "[MASKED]";
-            }
-            if (v && typeof v === "object") {
-                if (localVisited.has(v)) {
-                    return "[Circular]";
-                }
-                localVisited.add(v);
-            }
-            return v;
-        };
-        return JSON.stringify(val, replacer);
-    }
-    catch {
-        try {
-            return String(val);
-        }
-        catch {
-            return "[Unserializable]";
-        }
-    }
-}
-function sanitizeErrorValue(err) {
-    const errObj = {
-        name: err.name || "Error",
-        message: truncateString(err.message || "")
-    };
-    if (typeof err.stack === "string") {
-        errObj.stack = truncateString(err.stack);
-    }
-    return errObj;
-}
-function stringifyPreview(val, visited) {
-    const str = safeToStringMasked(val, visited);
-    return truncateString(str);
-}
-function sanitizeValueLimited(val, visited) {
-    if (val === null || val === undefined)
-        return val;
-    if (typeof val === "string")
-        return truncateString(val);
-    if (typeof val === "number")
-        return val;
-    if (typeof val === "boolean")
-        return val;
-    if (typeof val === "bigint")
-        return val;
-    if (val instanceof Error) {
-        return sanitizeErrorValue(val);
-    }
-    // 仅支持数组 + plain object 的结构化清洗，其余类型走字符串预览。
-    const isArr = Array.isArray(val);
-    const isObj = isPlainObject(val);
-    if (!isArr && !isObj) {
-        return stringifyPreview(val, visited);
-    }
-    // 防环（根节点）
-    if (visited.has(val)) {
-        return "[Circular]";
-    }
-    visited.add(val);
-    const rootOut = isArr ? [] : {};
-    const stack = [{ src: val, dst: rootOut, depth: 1 }];
-    let nodes = 0;
-    const tryAssign = (dst, key, child, depth) => {
-        if (child === null || child === undefined) {
-            dst[key] = child;
-            return;
-        }
-        if (typeof child === "string") {
-            dst[key] = truncateString(child);
-            return;
-        }
-        if (typeof child === "number" || typeof child === "boolean" || typeof child === "bigint") {
-            dst[key] = child;
-            return;
-        }
-        if (child instanceof Error) {
-            dst[key] = sanitizeErrorValue(child);
-            return;
-        }
-        const childIsArr = Array.isArray(child);
-        const childIsObj = isPlainObject(child);
-        if (!childIsArr && !childIsObj) {
-            dst[key] = stringifyPreview(child, visited);
-            return;
-        }
-        // 深度/节点数上限：超出则降级为字符串预览
-        if (depth >= sanitizeDepthLimit) {
-            dst[key] = stringifyPreview(child, visited);
-            return;
+        debug(record) {
+            write("debug", record);
         }
-        if (nodes >= sanitizeNodesLimit) {
-            dst[key] = stringifyPreview(child, visited);
-            return;
-        }
-        // 防环
-        if (visited.has(child)) {
-            dst[key] = "[Circular]";
-            return;
-        }
-        visited.add(child);
-        const childOut = childIsArr ? [] : {};
-        dst[key] = childOut;
-        stack.push({ src: child, dst: childOut, depth: depth + 1 });
     };
-    while (stack.length > 0) {
-        const frame = stack.pop();
-        nodes = nodes + 1;
-        if (nodes > sanitizeNodesLimit) {
-            // 超出节点上限：不再深入（已入栈的节点会被忽略，留空结构由上层兜底预览）。
-            break;
-        }
-        if (Array.isArray(frame.src)) {
-            const arr = frame.src;
-            const len = arr.length;
-            const limit = len > maxLogArrayItems ? maxLogArrayItems : len;
-            for (let i = 0; i < limit; i++) {
-                tryAssign(frame.dst, i, arr[i], frame.depth);
-            }
-            if (len > maxLogArrayItems) {
-                // ignore omitted items
-            }
-            continue;
-        }
-        if (isPlainObject(frame.src)) {
-            const entries = Object.entries(frame.src);
-            const len = entries.length;
-            const limit = len > sanitizeObjectKeysLimit ? sanitizeObjectKeysLimit : len;
-            for (let i = 0; i < limit; i++) {
-                const key = entries[i][0];
-                const child = entries[i][1];
-                if (isSensitiveKey(key)) {
-                    frame.dst[key] = "[MASKED]";
-                    continue;
-                }
-                tryAssign(frame.dst, key, child, frame.depth);
-            }
-            if (len > sanitizeObjectKeysLimit) {
-                // ignore omitted keys
-            }
-            continue;
-        }
-        // 兜底：理论上不会到这里（frame 只会压入 array/plain object）
-    }
-    return rootOut;
-}
-function sanitizeTopValue(val, visited) {
-    return sanitizeValueLimited(val, visited);
-}
-function sanitizeLogObject(obj) {
-    const visited = new WeakSet();
-    const out = {};
-    for (const [key, val] of Object.entries(obj)) {
-        if (isSensitiveKey(key)) {
-            out[key] = "[MASKED]";
-            continue;
-        }
-        out[key] = sanitizeTopValue(val, visited);
-    }
-    return out;
 }
+// 对象清洗/脱敏/截断逻辑已下沉到 utils/loggerUtils.ts（减少 logger.ts 复杂度）。
 function metaToObject() {
     const meta = getCtx();
     if (!meta)
@@ -976,114 +588,88 @@ function mergeMetaIntoObject(input, meta) {
     }
     return merged;
 }
-function withRequestMeta(args) {
-    const meta = metaToObject();
-    if (!meta)
-        return args;
-    if (args.length === 0)
-        return args;
-    const first = args[0];
-    const second = args.length > 1 ? args[1] : undefined;
-    // 兼容：Logger.error("xxx", err)
-    if (typeof first === "string" && second instanceof Error) {
-        const obj = {
-            err: second
-        };
-        const merged = mergeMetaIntoObject(obj, meta);
-        return [merged, first, ...args.slice(2)];
+// 日志仅接受 1 个入参（任意类型）。
+// - plain object（{}）直接作为 record
+// - 其他任何类型：包装成对象再写入（避免 sink 层依赖入参类型）
+function toRecord(input) {
+    if (isPlainObject(input)) {
+        return input;
     }
-    // pino 原生：logger.error(err, msg)
-    if (first instanceof Error) {
-        const msg = typeof second === "string" ? second : undefined;
-        const obj = {
-            err: first
-        };
-        const merged = mergeMetaIntoObject(obj, meta);
-        if (msg)
-            return [merged, msg, ...args.slice(2)];
-        return [merged, ...args.slice(1)];
+    if (input instanceof Error) {
+        return { err: input, msg: input.message || input.name || "Error" };
     }
-    // 纯字符串：Logger.info("msg") -> logger.info(meta, "msg")
-    if (typeof first === "string") {
-        return [meta, ...args];
+    if (input === undefined) {
+        return { msg: "" };
     }
-    // 对象：Logger.info(obj, msg?) -> 合并 meta（不覆盖显式字段）
-    if (isPlainObject(first)) {
-        const merged = mergeMetaIntoObject(first, meta);
-        return [merged, ...args.slice(1)];
+    if (input === null) {
+        return { msg: "null" };
+    }
+    // 非 plain object（数组/Date/Map/...）也走 value 包装，由 sanitize 负责做安全预览/截断。
+    if (typeof input === "object") {
+        return { value: input };
+    }
+    try {
+        return { msg: String(input) };
+    }
+    catch {
+        return { msg: "[Unserializable]" };
     }
-    return args;
-}
-function withRequestMetaTyped(args) {
-    // 复用现有逻辑（保持行为一致），只收敛类型
-    return withRequestMeta(args);
 }
-/**
- * 日志实例（延迟初始化）
- */
-export const Logger = {
-    info(...args) {
-        if (args.length === 0)
-            return;
-        const logger = getLogger();
-        const finalArgs = withRequestMetaTyped(args);
-        if (finalArgs.length === 0)
-            return;
-        if (finalArgs.length > 0 && isPlainObject(finalArgs[0])) {
-            finalArgs[0] = sanitizeLogObject(finalArgs[0]);
-        }
-        const ret = logger.info.apply(logger, finalArgs);
-        return ret;
-    },
-    warn(...args) {
-        if (args.length === 0)
-            return;
-        const logger = getLogger();
-        const finalArgs = withRequestMetaTyped(args);
-        if (finalArgs.length === 0)
-            return;
-        if (finalArgs.length > 0 && isPlainObject(finalArgs[0])) {
-            finalArgs[0] = sanitizeLogObject(finalArgs[0]);
-        }
-        const ret = logger.warn.apply(logger, finalArgs);
-        return ret;
-    },
-    error(...args) {
-        if (args.length === 0)
-            return;
-        const logger = getLogger();
-        const finalArgs = withRequestMetaTyped(args);
-        if (finalArgs.length === 0)
-            return;
-        if (finalArgs.length > 0 && isPlainObject(finalArgs[0])) {
-            finalArgs[0] = sanitizeLogObject(finalArgs[0]);
-        }
-        const ret = logger.error.apply(logger, finalArgs);
+function withRequestMetaRecord(record) {
+    const meta = metaToObject();
+    if (!meta)
+        return record;
+    return mergeMetaIntoObject(record, meta);
+}
+class LoggerFacade {
+    maybeSanitizeForMock(record) {
+        if (!mockInstance)
+            return record;
+        return sanitizeLogObject(record, sanitizeOptions);
+    }
+    info(input) {
+        const record0 = withRequestMetaRecord(toRecord(input));
+        const record = this.maybeSanitizeForMock(record0);
+        return getSink("app").info(record);
+    }
+    warn(input) {
+        const record0 = withRequestMetaRecord(toRecord(input));
+        const record = this.maybeSanitizeForMock(record0);
+        return getSink("app").warn(record);
+    }
+    error(input) {
+        const record0 = withRequestMetaRecord(toRecord(input));
+        const record = this.maybeSanitizeForMock(record0);
+        const ret = getSink("app").error(record);
         // 测试场景：启用 mock 时不做镜像，避免调用次数翻倍
         if (mockInstance)
             return ret;
         // error 专属文件：始终镜像一份
-        const errorLogger = getErrorLogger();
-        errorLogger.error.apply(errorLogger, finalArgs);
+        getSink("error").error(record);
         return ret;
-    },
-    debug(...args) {
-        if (args.length === 0)
-            return;
-        const logger = getLogger();
-        const finalArgs = withRequestMetaTyped(args);
-        if (finalArgs.length === 0)
+    }
+    debug(input) {
+        // debug!=1 则完全不记录 debug 日志（包括文件与控制台）
+        if (config.debug !== 1)
             return;
-        if (finalArgs.length > 0 && isPlainObject(finalArgs[0])) {
-            finalArgs[0] = sanitizeLogObject(finalArgs[0]);
-        }
-        const ret = logger.debug.apply(logger, finalArgs);
-        return ret;
-    },
+        const record0 = withRequestMetaRecord(toRecord(input));
+        const record = this.maybeSanitizeForMock(record0);
+        return getSink("app").debug(record);
+    }
     async flush() {
         await flush();
-    },
-    configure: configure,
-    setMock: setMockLogger,
-    shutdown: shutdown
-};
+    }
+    configure(cfg) {
+        configure(cfg);
+    }
+    setMock(mock) {
+        setMockLogger(mock);
+    }
+    async shutdown() {
+        await shutdown();
+    }
+}
+/**
+ * 日志实例（延迟初始化）
+ */
+export const Logger = new LoggerFacade();