befly 3.10.19 → 3.11.1

package/dist/lib/logger.js

@@ -1,14 +1,16 @@
 /**
- * 日志系统 - 基于 pino 实现
+ * 日志系统 - Bun 环境自定义实现（替换 pino / pino-roll）
  */
-import { existsSync, mkdirSync } from "node:fs";
+import { createWriteStream, existsSync, mkdirSync } from "node:fs";
 import { readdir, stat, unlink } 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 "es-toolkit/compat";
-import { escapeRegExp } from "es-toolkit/string";
-import { join } from "pathe";
-import pino from "pino";
-import { getCtx } from "./asyncContext.js";
+import { isPlainObject } 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();
@@ -27,22 +29,445 @@ 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 sensitiveSuffixMatchers = [];
-let sensitivePrefixMatchers = [];
 let sensitiveContainsMatchers = [];
 let sensitiveContainsRegex = null;
+const HOSTNAME = (() => {
+    try {
+        return osHostname();
+    }
+    catch {
+        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 slowInstance = 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 didInstallGracefulExitHooks = false;
 let config = {
     debug: 0,
     dir: "./logs",
     console: 1,
     maxSize: 10
 };
+function installGracefulExitHooks() {
+    if (didInstallGracefulExitHooks)
+        return;
+    didInstallGracefulExitHooks = true;
+    const install = (signal, exitCode) => {
+        // 若业务侧已经注册了 handler，避免我们抢占默认行为
+        try {
+            if (typeof process.listenerCount === "function" && process.listenerCount(signal) > 0) {
+                return;
+            }
+        }
+        catch {
+            // ignore
+        }
+        try {
+            process.once(signal, () => {
+                let exited = false;
+                // 给 flush 一个机会；超过上限则强制退出
+                const timer = setTimeout(() => {
+                    if (exited)
+                        return;
+                    exited = true;
+                    try {
+                        process.exit(exitCode);
+                    }
+                    catch {
+                        // ignore
+                    }
+                }, 2000);
+                void shutdown()
+                    .catch(() => undefined)
+                    .finally(() => {
+                    if (exited)
+                        return;
+                    exited = true;
+                    clearTimeout(timer);
+                    try {
+                        process.exit(exitCode);
+                    }
+                    catch {
+                        // ignore
+                    }
+                });
+            });
+        }
+        catch {
+            // ignore
+        }
+    };
+    install("SIGINT", 130);
+    install("SIGTERM", 143);
+}
+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;
+    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 += nextBytes;
+        pending.shift();
+    }
+    return { chunk: parts.join(""), bytes: bytes };
+}
+class LogStreamSink {
+    kind;
+    minLevel;
+    pending;
+    pendingBytes;
+    scheduled;
+    flushing;
+    maxBufferBytes;
+    flushDelayMs;
+    maxBatchBytes;
+    constructor(options) {
+        this.kind = options.kind;
+        this.minLevel = options.minLevel;
+        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;
+    }
+    enqueue(level, line) {
+        if (!shouldAccept(this.minLevel, level))
+            return;
+        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;
+            }
+        }
+        this.pending.push(line);
+        this.pendingBytes += bytes;
+        this.scheduleFlush();
+    }
+    async flushNow() {
+        await this.flush();
+    }
+    async shutdown() {
+        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;
+    }
+    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);
+                if (!ok) {
+                    await new Promise((resolve) => {
+                        stream.once("drain", () => resolve());
+                    });
+                }
+            }
+        }
+        catch (error) {
+            safeWriteStderrOnce(`[Logger] stream sink error: ${error?.message || error}`);
+        }
+        finally {
+            this.flushing = false;
+            if (this.pending.length > 0) {
+                this.scheduleFlush();
+            }
+        }
+    }
+}
+class LogFileSink {
+    prefix;
+    minLevel;
+    maxFileBytes;
+    pending;
+    pendingBytes;
+    scheduled;
+    flushing;
+    maxBufferBytes;
+    flushDelayMs;
+    maxBatchBytes;
+    stream;
+    streamDate;
+    streamIndex;
+    streamSizeBytes;
+    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;
+    }
+    enqueue(level, 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();
+    }
+    async flushNow() {
+        await this.flush();
+    }
+    async shutdown() {
+        await this.flush();
+        await this.closeStream();
+    }
+    scheduleFlush() {
+        if (this.scheduled)
+            return;
+        this.scheduled = true;
+        setTimeout(() => {
+            void this.flush();
+        }, this.flushDelayMs);
+    }
+    async closeStream() {
+        if (!this.stream)
+            return;
+        const st = this.stream;
+        this.stream = null;
+        await new Promise((resolve) => {
+            try {
+                st.end(() => resolve());
+            }
+            catch {
+                resolve();
+            }
+        });
+    }
+    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());
+        // 日期变化：切新文件
+        if (this.stream && this.streamDate && date !== this.streamDate) {
+            await this.closeStream();
+            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 = typeof st.size === "number" ? st.size : 0;
+            }
+            catch {
+                size = 0;
+            }
+            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;
+                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;
+            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;
+                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();
+            }
+        }
+    }
+}
+export async function flush() {
+    // 测试场景：mock logger 不需要 flush
+    if (mockInstance)
+        return;
+    const sinks = [];
+    if (appFileSink)
+        sinks.push({ flush: () => (appFileSink ? appFileSink.flushNow() : Promise.resolve()) });
+    if (errorFileSink)
+        sinks.push({ flush: () => (errorFileSink ? errorFileSink.flushNow() : Promise.resolve()) });
+    if (appConsoleSink)
+        sinks.push({ flush: () => (appConsoleSink ? appConsoleSink.flushNow() : Promise.resolve()) });
+    for (const item of sinks) {
+        try {
+            await item.flush();
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+export async function shutdown() {
+    // 测试场景：mock logger 不需要 shutdown
+    if (mockInstance)
+        return;
+    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()) });
+    for (const item of sinks) {
+        try {
+            await item.shutdown();
+        }
+        catch {
+            // ignore
+        }
+    }
+    appFileSink = null;
+    errorFileSink = null;
+    appConsoleSink = null;
+    instance = null;
+    errorInstance = null;
+}
 function normalizePositiveInt(value, fallback, min, max) {
     if (typeof value !== "number")
         return fallback;
@@ -91,7 +516,7 @@ async function pruneOldLogFiles() {
                 continue;
             const name = entry.name;
             // 只处理本项目的日志文件前缀
-            const isTarget = name.startsWith("app.") || name.startsWith("slow.") || name.startsWith("error.");
+            const isTarget = name.startsWith("app.") || name.startsWith("error.");
             if (!isTarget)
                 continue;
             const fullPath = nodePathJoin(dir, name);
@@ -121,12 +546,17 @@ async function pruneOldLogFiles() {
  * 配置日志
  */
 export function configure(cfg) {
-    config = { ...config, ...cfg };
+    // 旧实例可能仍持有文件句柄；这里异步关闭（不阻塞主流程）
+    void shutdown();
+    config = Object.assign({}, config, cfg);
     instance = null;
-    slowInstance = 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);
@@ -136,46 +566,34 @@ export function configure(cfg) {
     maxLogArrayItems = normalizePositiveInt(config.maxArrayItems, DEFAULT_LOG_ARRAY_ITEMS, 10, 5000);
     // 仅支持数组配置：excludeFields?: string[]
     const userPatterns = Array.isArray(config.excludeFields) ? config.excludeFields : [];
-    const patterns = [...BUILTIN_SENSITIVE_KEYS, ...userPatterns]
-        .map((item) => String(item).trim())
-        .filter((item) => item.length > 0)
-        .map((item) => item.toLowerCase());
+    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 suffixMatchers = [];
-    const prefixMatchers = [];
     const containsMatchers = [];
     for (const pat of patterns) {
-        // 支持通配符：
-        // - *secret  -> 后缀匹配
-        // - secret*  -> 前缀匹配
-        // - *secret* -> 包含匹配
-        // - 无 *     -> 精确匹配（建议用 *x* 显式开启模糊匹配）
-        const hasStar = pat.includes("*");
-        if (!hasStar) {
+        // 精简策略：
+        // - 无 *：精确匹配
+        // - 有 *：统一按“包含匹配”处理（*x*、x*、*x、a*b 都视为包含 core）
+        if (!pat.includes("*")) {
             exactSet.add(pat);
             continue;
         }
-        const trimmed = pat.replace(/\*+/g, "*");
-        const startsStar = trimmed.startsWith("*");
-        const endsStar = trimmed.endsWith("*");
-        const core = trimmed.replace(/^\*+|\*+$/g, "");
+        const core = pat.replace(/\*+/g, "").trim();
         if (!core) {
             continue;
         }
-        if (startsStar && !endsStar) {
-            suffixMatchers.push(core);
-            continue;
-        }
-        if (!startsStar && endsStar) {
-            prefixMatchers.push(core);
-            continue;
-        }
-        // *core* 或类似 a*b：都降级为包含匹配
         containsMatchers.push(core);
     }
     sensitiveKeySet = exactSet;
-    sensitiveSuffixMatchers = suffixMatchers;
-    sensitivePrefixMatchers = prefixMatchers;
     sensitiveContainsMatchers = containsMatchers;
     // 预编译包含匹配：减少每次 isSensitiveKey 的循环开销
     // 注意：patterns 已全部 lowerCase，因此 regex 不需要 i 标志
@@ -194,13 +612,13 @@ export function configure(cfg) {
 }
 /**
  * 设置 Mock Logger（用于测试）
- * @param mock - Mock pino 实例，传 null 清除 mock
+ * @param mock - Mock Logger 实例（形如 {info/warn/error/debug}），传 null 清除 mock
  */
 export function setMockLogger(mock) {
     mockInstance = mock;
 }
 /**
- * 获取 pino 日志实例
+ * 获取 Logger 实例（延迟初始化）
  */
 export function getLogger() {
     // 优先返回 mock 实例（用于测试）
@@ -209,108 +627,178 @@ export function getLogger() {
     if (instance)
         return instance;
     ensureLogDirExists();
+    installGracefulExitHooks();
     // 启动时清理过期日志（异步，不阻塞初始化）
     void pruneOldLogFiles();
-    const level = config.debug === 1 ? "debug" : "info";
-    const targets = [];
-    // 文件输出
-    targets.push({
-        target: "pino-roll",
-        level: level,
-        options: {
-            file: join(resolveLogDir(), "app"),
-            frequency: "daily",
-            size: `${config.maxSize || 10}m`,
-            mkdir: true,
-            dateFormat: "yyyy-MM-dd"
-        }
-    });
-    // 控制台输出
-    if (config.console === 1) {
-        targets.push({
-            target: "pino/file",
-            level: level,
-            options: { destination: 1 }
-        });
+    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 (config.console === 1 && !appConsoleSink) {
+        appConsoleSink = new LogStreamSink({ kind: "stdout", minLevel: minLevel });
     }
-    instance = pino({
-        level: level,
-        transport: { targets: targets }
-    });
+    instance = createSinkLogger({ kind: "app", minLevel: minLevel, fileSink: appFileSink, consoleSink: config.console === 1 ? appConsoleSink : null });
     return instance;
 }
-function getSlowLogger() {
-    if (mockInstance)
-        return mockInstance;
-    if (slowInstance)
-        return slowInstance;
-    ensureLogDirExists();
-    void pruneOldLogFiles();
-    const level = config.debug === 1 ? "debug" : "info";
-    slowInstance = pino({
-        level: level,
-        transport: {
-            targets: [
-                {
-                    target: "pino-roll",
-                    level: level,
-                    options: {
-                        file: join(resolveLogDir(), "slow"),
-                        // 只按大小分割（frequency 默认不启用）
-                        size: `${config.maxSize || 10}m`,
-                        mkdir: true
-                    }
-                }
-            ]
-        }
-    });
-    return slowInstance;
-}
 function getErrorLogger() {
     if (mockInstance)
         return mockInstance;
     if (errorInstance)
         return errorInstance;
     ensureLogDirExists();
+    installGracefulExitHooks();
     void pruneOldLogFiles();
-    // error 专属文件：只关注 error 及以上
-    errorInstance = pino({
-        level: "error",
-        transport: {
-            targets: [
-                {
-                    target: "pino-roll",
-                    level: "error",
-                    options: {
-                        file: join(resolveLogDir(), "error"),
-                        // 只按大小分割（frequency 默认不启用）
-                        size: `${config.maxSize || 10}m`,
-                        mkdir: true
-                    }
-                }
-            ]
-        }
-    });
+    const maxFileBytes = (typeof config.maxSize === "number" && config.maxSize > 0 ? config.maxSize : 10) * 1024 * 1024;
+    if (!errorFileSink) {
+        // error logger：固定 minLevel=error
+        errorFileSink = new LogFileSink({ prefix: "error", minLevel: "error", maxFileBytes: maxFileBytes });
+    }
+    errorInstance = createSinkLogger({ kind: "error", minLevel: "error", 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(" ");
+}
+function buildLogLine(level, args) {
+    const time = Date.now();
+    const base = {
+        level: LOG_LEVEL_NUM[level],
+        time: 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;
+        }
+        if (typeof second === "string") {
+            const extraMsg = formatExtrasToMsg(args.slice(2));
+            base.msg = extraMsg ? `${second} ${extraMsg}` : second;
+        }
+        else {
+            const extraMsg = formatExtrasToMsg(args.slice(1));
+            base.msg = extraMsg;
+        }
+        return `${safeJsonStringify(base)}\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`;
+    }
+    // 兜底
+    base.msg = formatExtrasToMsg(args);
+    return `${safeJsonStringify(base)}\n`;
+}
+function safeJsonStringify(obj) {
+    try {
+        return JSON.stringify(obj);
+    }
+    catch {
+        try {
+            return JSON.stringify({ level: obj.level, time: obj.time, pid: obj.pid, hostname: obj.hostname, msg: "[Unserializable log record]" });
+        }
+        catch {
+            return '{"msg":"[Unserializable log record]"}';
+        }
+    }
+}
+function createSinkLogger(options) {
+    const minLevel = options.minLevel;
+    const write = (level, args) => {
+        if (!shouldAccept(minLevel, level))
+            return;
+        const line = buildLogLine(level, args);
+        options.fileSink.enqueue(level, line);
+        if (options.consoleSink) {
+            options.consoleSink.enqueue(level, line);
+        }
+    };
+    return {
+        info(...args) {
+            write("info", args);
+        },
+        warn(...args) {
+            write("warn", args);
+        },
+        error(...args) {
+            write("error", args);
+        },
+        debug(...args) {
+            write("debug", args);
+        }
+    };
+}
 function truncateString(val, stats) {
     if (val.length <= maxLogStringLen)
         return val;
-    stats.truncatedStrings = (stats.truncatedStrings || 0) + 1;
     return val.slice(0, maxLogStringLen);
 }
 function isSensitiveKey(key) {
     const lower = String(key).toLowerCase();
     if (sensitiveKeySet.has(lower))
         return true;
-    for (const suffix of sensitiveSuffixMatchers) {
-        if (lower.endsWith(suffix))
-            return true;
-    }
-    for (const prefix of sensitivePrefixMatchers) {
-        if (lower.startsWith(prefix))
-            return true;
-    }
     if (sensitiveContainsRegex) {
         return sensitiveContainsRegex.test(lower);
     }
@@ -341,7 +829,6 @@ function safeToStringMasked(val, visited, stats) {
     }
     if (val && typeof val === "object") {
         if (visited.has(val)) {
-            stats.circularRefs = (stats.circularRefs || 0) + 1;
             return "[Circular]";
         }
     }
@@ -350,12 +837,10 @@ function safeToStringMasked(val, visited, stats) {
         const replacer = (k, v) => {
             // JSON.stringify 的根节点 key 为空字符串
             if (k && isSensitiveKey(k)) {
-                stats.maskedKeys = (stats.maskedKeys || 0) + 1;
                 return "[MASKED]";
             }
             if (v && typeof v === "object") {
                 if (localVisited.has(v)) {
-                    stats.circularRefs = (stats.circularRefs || 0) + 1;
                     return "[Circular]";
                 }
                 localVisited.add(v);
@@ -384,7 +869,6 @@ function sanitizeErrorValue(err, stats) {
     return errObj;
 }
 function stringifyPreview(val, visited, stats) {
-    stats.valuesStringified = (stats.valuesStringified || 0) + 1;
     const str = safeToStringMasked(val, visited, stats);
     return truncateString(str, stats);
 }
@@ -410,7 +894,6 @@ function sanitizeValueLimited(val, visited, stats) {
     }
     // 防环（根节点）
     if (visited.has(val)) {
-        stats.circularRefs = (stats.circularRefs || 0) + 1;
         return "[Circular]";
     }
     visited.add(val);
@@ -442,18 +925,15 @@ function sanitizeValueLimited(val, visited, stats) {
         }
         // 深度/节点数上限：超出则降级为字符串预览
         if (depth >= sanitizeDepthLimit) {
-            stats.depthLimited = (stats.depthLimited || 0) + 1;
             dst[key] = stringifyPreview(child, visited, stats);
             return;
         }
         if (nodes >= sanitizeNodesLimit) {
-            stats.nodesLimited = (stats.nodesLimited || 0) + 1;
             dst[key] = stringifyPreview(child, visited, stats);
             return;
         }
         // 防环
         if (visited.has(child)) {
-            stats.circularRefs = (stats.circularRefs || 0) + 1;
             dst[key] = "[Circular]";
             return;
         }
@@ -467,7 +947,6 @@ function sanitizeValueLimited(val, visited, stats) {
         nodes = nodes + 1;
         if (nodes > sanitizeNodesLimit) {
             // 超出节点上限：不再深入（已入栈的节点会被忽略，留空结构由上层兜底预览）。
-            stats.nodesLimited = (stats.nodesLimited || 0) + 1;
             break;
         }
         if (Array.isArray(frame.src)) {
@@ -478,8 +957,7 @@ function sanitizeValueLimited(val, visited, stats) {
                 tryAssign(frame.dst, i, arr[i], frame.depth);
             }
             if (len > maxLogArrayItems) {
-                stats.arraysTruncated = (stats.arraysTruncated || 0) + 1;
-                stats.arrayItemsOmitted = (stats.arrayItemsOmitted || 0) + (len - maxLogArrayItems);
+                // ignore omitted items
             }
             continue;
         }
@@ -491,15 +969,13 @@ function sanitizeValueLimited(val, visited, stats) {
                 const key = entries[i][0];
                 const child = entries[i][1];
                 if (isSensitiveKey(key)) {
-                    stats.maskedKeys = (stats.maskedKeys || 0) + 1;
                     frame.dst[key] = "[MASKED]";
                     continue;
                 }
                 tryAssign(frame.dst, key, child, frame.depth);
             }
             if (len > sanitizeObjectKeysLimit) {
-                stats.objectKeysLimited = (stats.objectKeysLimited || 0) + 1;
-                stats.objectKeysOmitted = (stats.objectKeysOmitted || 0) + (len - sanitizeObjectKeysLimit);
+                // ignore omitted keys
             }
             continue;
         }
@@ -507,46 +983,18 @@ function sanitizeValueLimited(val, visited, stats) {
     }
     return rootOut;
 }
-function sanitizeTopValue(val, visited, stats) {
-    return sanitizeValueLimited(val, visited, stats);
+function sanitizeTopValue(val, visited) {
+    return sanitizeValueLimited(val, visited, {});
 }
 function sanitizeLogObject(obj) {
     const visited = new WeakSet();
-    const stats = {
-        maskedKeys: 0,
-        truncatedStrings: 0,
-        arraysTruncated: 0,
-        arrayItemsOmitted: 0,
-        valuesStringified: 0,
-        circularRefs: 0,
-        depthLimited: 0,
-        nodesLimited: 0,
-        objectKeysLimited: 0,
-        objectKeysOmitted: 0
-    };
     const out = {};
     for (const [key, val] of Object.entries(obj)) {
         if (isSensitiveKey(key)) {
-            stats.maskedKeys = stats.maskedKeys + 1;
             out[key] = "[MASKED]";
             continue;
         }
-        out[key] = sanitizeTopValue(val, visited, stats);
-    }
-    const hasChanges = stats.maskedKeys > 0 || stats.truncatedStrings > 0 || stats.arraysTruncated > 0 || stats.arrayItemsOmitted > 0 || stats.valuesStringified > 0 || stats.circularRefs > 0 || stats.depthLimited > 0 || stats.nodesLimited > 0 || stats.objectKeysLimited > 0 || stats.objectKeysOmitted > 0;
-    if (hasChanges) {
-        out.logTrimStats = {
-            maskedKeys: stats.maskedKeys,
-            truncatedStrings: stats.truncatedStrings,
-            arraysTruncated: stats.arraysTruncated,
-            arrayItemsOmitted: stats.arrayItemsOmitted,
-            valuesStringified: stats.valuesStringified,
-            circularRefs: stats.circularRefs,
-            depthLimited: stats.depthLimited,
-            nodesLimited: stats.nodesLimited,
-            objectKeysLimited: stats.objectKeysLimited,
-            objectKeysOmitted: stats.objectKeysOmitted
-        };
+        out[key] = sanitizeTopValue(val, visited);
     }
     return out;
 }
@@ -621,25 +1069,6 @@ function withRequestMeta(args) {
     }
     return args;
 }
-function shouldMirrorToSlow(args) {
-    // 测试场景：启用 mock 时不做镜像，避免调用次数翻倍
-    if (mockInstance)
-        return false;
-    if (!args || args.length === 0)
-        return false;
-    const first = args[0];
-    if (!isPlainObject(first))
-        return false;
-    // 优先使用显式标记：event=slow
-    const event = first.event;
-    if (event === "slow")
-        return true;
-    // 兼容旧写法：仅通过 message emoji 判断（尽量少用）
-    const msg = args.length > 1 ? args[1] : undefined;
-    if (typeof msg === "string" && msg.includes("🐌"))
-        return true;
-    return false;
-}
 function withRequestMetaTyped(args) {
     // 复用现有逻辑（保持行为一致），只收敛类型
     return withRequestMeta(args);
@@ -659,12 +1088,6 @@ export const Logger = {
             finalArgs[0] = sanitizeLogObject(finalArgs[0]);
         }
         const ret = logger.info.apply(logger, finalArgs);
-        if (mockInstance)
-            return ret;
-        if (shouldMirrorToSlow(finalArgs)) {
-            const slowLogger = getSlowLogger();
-            slowLogger.info.apply(slowLogger, finalArgs);
-        }
         return ret;
     },
     warn(...args) {
@@ -678,12 +1101,6 @@ export const Logger = {
             finalArgs[0] = sanitizeLogObject(finalArgs[0]);
         }
         const ret = logger.warn.apply(logger, finalArgs);
-        if (mockInstance)
-            return ret;
-        if (shouldMirrorToSlow(finalArgs)) {
-            const slowLogger = getSlowLogger();
-            slowLogger.warn.apply(slowLogger, finalArgs);
-        }
         return ret;
     },
     error(...args) {
@@ -703,11 +1120,6 @@ export const Logger = {
         // error 专属文件：始终镜像一份
         const errorLogger = getErrorLogger();
         errorLogger.error.apply(errorLogger, finalArgs);
-        // error 同时也属于 slow？一般不会，但允许显式 event=slow
-        if (shouldMirrorToSlow(finalArgs)) {
-            const slowLogger = getSlowLogger();
-            slowLogger.error.apply(slowLogger, finalArgs);
-        }
         return ret;
     },
     debug(...args) {
@@ -721,14 +1133,12 @@ export const Logger = {
             finalArgs[0] = sanitizeLogObject(finalArgs[0]);
         }
         const ret = logger.debug.apply(logger, finalArgs);
-        if (mockInstance)
-            return ret;
-        if (shouldMirrorToSlow(finalArgs)) {
-            const slowLogger = getSlowLogger();
-            slowLogger.debug.apply(slowLogger, finalArgs);
-        }
         return ret;
     },
+    async flush() {
+        await flush();
+    },
     configure: configure,
-    setMock: setMockLogger
+    setMock: setMockLogger,
+    shutdown: shutdown
 };