befly 3.16.10 → 3.16.11

package/dist/lib/logger.js

@@ -1,731 +0,0 @@
-/**
- * 日志系统 - Bun 环境自定义实现（替换 pino / pino-roll）
- */
-import { createWriteStream, existsSync, mkdirSync } from "node:fs";
-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 { formatYmdHms } from "../utils/formatYmdHms";
-import { buildSensitiveKeyMatcher, sanitizeLogObject } from "../utils/loggerUtils";
-import { isPlainObject, normalizePositiveInt } from "../utils/util";
-import { getCtx } from "./asyncContext";
-// 注意：Logger 可能在运行时/测试中被 process.chdir() 影响。
-// 为避免相对路径的 logs 目录随着 cwd 变化，使用模块加载时的初始 cwd 作为锚点。
-const INITIAL_CWD = process.cwd();
-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 sanitizeOptions = {
-    maxStringLen: 200,
-    maxArrayItems: 500,
-    sanitizeDepth: 5,
-    sanitizeNodes: 5000,
-    sanitizeObjectKeys: 500,
-    sensitiveKeyMatcher: buildSensitiveKeyMatcher({ builtinPatterns: BUILTIN_SENSITIVE_KEYS, userPatterns: [] })
-};
-function buildSanitizeOptionsForWriteOptions(writeOptions) {
-    if (!writeOptions || writeOptions.truncate !== false)
-        return sanitizeOptions;
-    // 仅关闭“截断”，仍保留敏感字段掩码与结构化清洗（避免泄露敏感信息）。
-    return {
-        maxStringLen: 200000,
-        maxArrayItems: 5000,
-        sanitizeDepth: sanitizeOptions.sanitizeDepth,
-        sanitizeNodes: sanitizeOptions.sanitizeNodes,
-        sanitizeObjectKeys: sanitizeOptions.sanitizeObjectKeys,
-        sensitiveKeyMatcher: sanitizeOptions.sensitiveKeyMatcher
-    };
-}
-const HOSTNAME = (() => {
-    try {
-        return osHostname();
-    }
-    catch {
-        return "unknown";
-    }
-})();
-let mockInstance = null;
-let appFileSink = null;
-let errorFileSink = null;
-let appConsoleSink = null;
-let config = {
-    debug: 0,
-    dir: "./logs",
-    console: 1,
-    maxSize: 20
-};
-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 };
-}
-class BufferedSink {
-    pending;
-    pendingBytes;
-    scheduledTimer;
-    flushing;
-    maxBufferBytes;
-    flushDelayMs;
-    maxBatchBytes;
-    writeChunk;
-    onShutdown;
-    constructor(options) {
-        this.pending = [];
-        this.pendingBytes = 0;
-        this.scheduledTimer = null;
-        this.flushing = false;
-        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);
-    }
-    cancelScheduledFlush() {
-        if (!this.scheduledTimer)
-            return;
-        clearTimeout(this.scheduledTimer);
-        this.scheduledTimer = null;
-    }
-    enqueue(line) {
-        const bytes = Buffer.byteLength(line);
-        if (this.pendingBytes + bytes > this.maxBufferBytes) {
-            // buffer 满：统一丢弃新日志（不区分 level）
-            return;
-        }
-        this.pending.push(line);
-        this.pendingBytes = this.pendingBytes + bytes;
-        this.scheduleFlush();
-    }
-    async flushNow() {
-        // 若已安排了定时 flush，flushNow 会覆盖它，避免出现多个 timer 并存。
-        this.cancelScheduledFlush();
-        await this.flush();
-    }
-    async shutdown() {
-        this.cancelScheduledFlush();
-        await this.flush();
-        if (this.onShutdown) {
-            await this.onShutdown();
-        }
-    }
-    async flush() {
-        if (this.flushing)
-            return;
-        this.flushing = true;
-        try {
-            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 = await this.writeChunk(chunk, chunkBytes);
-                if (!ok) {
-                    // writer 已禁用/失败：清空剩余 pending
-                    this.pending = [];
-                    this.pendingBytes = 0;
-                    break;
-                }
-            }
-        }
-        finally {
-            this.flushing = false;
-            if (this.pending.length > 0) {
-                this.scheduleFlush();
-            }
-        }
-    }
-}
-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;
-    maxFileBytes;
-    buffer;
-    stream;
-    streamDate;
-    streamIndex;
-    streamSizeBytes;
-    disabled;
-    constructor(options) {
-        this.prefix = options.prefix;
-        this.maxFileBytes = options.maxFileBytes;
-        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) => {
-                            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;
-                }
-            },
-            onShutdown: async () => {
-                await this.closeStream();
-            }
-        });
-    }
-    enqueue(line) {
-        if (this.disabled)
-            return;
-        this.buffer.enqueue(line);
-    }
-    async flushNow() {
-        await this.buffer.flushNow();
-    }
-    async shutdown() {
-        await this.buffer.shutdown();
-    }
-    async closeStream() {
-        if (!this.stream)
-            return;
-        const st = this.stream;
-        this.stream = null;
-        await new Promise((resolve) => {
-            try {
-                st.end(() => resolve());
-            }
-            catch {
-                resolve();
-            }
-        });
-    }
-    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 = formatYmdHms(new Date(), "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;
-            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;
-        }
-    }
-}
-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;
-    // 重要：shutdown 可能与后续 Logger.getLogger() 并发。
-    // 因此这里捕获“当前的旧 sink/instance 快照”，只关闭这些快照，避免把新创建的 sink 一并清掉。
-    const currentAppFileSink = appFileSink;
-    const currentErrorFileSink = errorFileSink;
-    const currentAppConsoleSink = appConsoleSink;
-    const sinks = [];
-    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();
-        }
-        catch {
-            // ignore
-        }
-    }
-    if (appFileSink === currentAppFileSink) {
-        appFileSink = null;
-    }
-    if (errorFileSink === currentErrorFileSink) {
-        errorFileSink = null;
-    }
-    if (appConsoleSink === currentAppConsoleSink) {
-        appConsoleSink = null;
-    }
-    // shutdown 后允许下一次重新初始化时再次校验/创建目录（测试会清理目录，避免 ENOENT）
-    // 无需缓存状态：确保目录存在是幂等的。
-}
-function resolveLogDir() {
-    const rawDir = config.dir || "./logs";
-    if (nodePathIsAbsolute(rawDir)) {
-        return rawDir;
-    }
-    return nodePathResolve(INITIAL_CWD, rawDir);
-}
-function ensureLogDirExists() {
-    const dir = resolveLogDir();
-    try {
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-    }
-    catch (error) {
-        // 不能在 Logger 初始化前调用 Logger 本身，直接抛错即可
-        throw new Error(`创建 logs 目录失败: ${dir}. ${error?.message || error}`);
-    }
-}
-// 方案B：删除“启动时清理旧日志”功能（减少 I/O 与复杂度）。
-/**
- * 配置日志
- */
-export function configure(cfg) {
-    // 旧实例可能仍持有文件句柄；这里异步关闭（不阻塞主流程）
-    void shutdown();
-    // 方案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;
-    }
-    appFileSink = null;
-    errorFileSink = null;
-    appConsoleSink = null;
-    // 运行时清洗/截断上限（可配置）
-    sanitizeOptions = {
-        maxStringLen: normalizePositiveInt(config.maxStringLen, 200, 20, 200000),
-        maxArrayItems: normalizePositiveInt(config.maxArrayItems, 500, 10, 5000),
-        sanitizeDepth: normalizePositiveInt(config.sanitizeDepth, 5, 1, 10),
-        sanitizeNodes: normalizePositiveInt(config.sanitizeNodes, 5000, 50, 20000),
-        sanitizeObjectKeys: normalizePositiveInt(config.sanitizeObjectKeys, 500, 10, 5000),
-        sensitiveKeyMatcher: buildSensitiveKeyMatcher({ builtinPatterns: BUILTIN_SENSITIVE_KEYS, userPatterns: config.excludeFields })
-    };
-}
-/**
- * 设置 Mock Logger（用于测试）
- * @param mock - Mock Logger 实例（形如 {info/warn/error/debug}），传 null 清除 mock
- */
-export function setMockLogger(mock) {
-    mockInstance = mock;
-}
-function getSink(kind) {
-    // 优先返回 mock 实例（用于测试）
-    if (mockInstance)
-        return mockInstance;
-    return {
-        info(record) {
-            writeJsonl(kind, "info", record, undefined);
-        },
-        warn(record) {
-            writeJsonl(kind, "warn", record, undefined);
-        },
-        error(record) {
-            writeJsonl(kind, "error", record, undefined);
-        },
-        debug(record) {
-            writeJsonl(kind, "debug", record, undefined);
-        }
-    };
-}
-/**
- * 获取 Logger 实例（延迟初始化）
- */
-export function getLogger() {
-    return getSink("app");
-}
-function buildBaseFields(level, timeMs) {
-    const base = {
-        level: level,
-        time: timeMs,
-        timeFormat: formatYmdHms(new Date(timeMs)),
-        pid: process.pid,
-        hostname: HOSTNAME
-    };
-    return base;
-}
-function buildLogLineWithBase(base, record) {
-    // 目标：让 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["timeFormat"] = base["timeFormat"];
-        out["pid"] = base["pid"];
-        out["hostname"] = base["hostname"];
-        for (const key of Object.keys(record)) {
-            if (key === "level")
-                continue;
-            if (key === "time")
-                continue;
-            if (key === "timeFormat")
-                continue;
-            if (key === "pid")
-                continue;
-            if (key === "hostname")
-                continue;
-            out[key] = record[key];
-        }
-        // msg 允许保留 record.msg（若存在），否则补齐空字符串。
-        if (record.msg !== undefined) {
-            out["msg"] = record.msg;
-        }
-        else if (out["msg"] === undefined) {
-            out["msg"] = "";
-        }
-        return `${safeJsonStringify(out)}\n`;
-    }
-    if (base["msg"] === undefined) {
-        base["msg"] = "";
-    }
-    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 ensureSinksReady(kind) {
-    ensureLogDirExists();
-    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");
-        }
-        return { fileSink: appFileSink, consoleSink: config.console === 1 ? appConsoleSink : null };
-    }
-    if (!errorFileSink) {
-        errorFileSink = new LogFileSink({ prefix: "error", maxFileBytes: maxFileBytes });
-    }
-    return { fileSink: errorFileSink, consoleSink: null };
-}
-function writeJsonl(kind, level, record, options) {
-    if (level === "debug" && config.debug !== 1)
-        return;
-    const sinks = ensureSinksReady(kind);
-    const time = Date.now();
-    const base = buildBaseFields(level, time);
-    const effectiveSanitizeOptions = buildSanitizeOptionsForWriteOptions(options);
-    const sanitizedRecord = sanitizeLogObject(record, effectiveSanitizeOptions);
-    const fileLine = buildLogLineWithBase(base, sanitizedRecord);
-    sinks.fileSink.enqueue(fileLine);
-    if (sinks.consoleSink) {
-        if (!options || options.console !== false) {
-            sinks.consoleSink.enqueue(fileLine);
-        }
-    }
-}
-// 对象清洗/脱敏/截断逻辑已下沉到 utils/loggerUtils.ts（减少 logger.ts 复杂度）。
-function metaToObject() {
-    const meta = getCtx();
-    if (!meta)
-        return null;
-    const durationSinceNowMs = Date.now() - meta.now;
-    const obj = {
-        requestId: meta.requestId,
-        method: meta.method,
-        route: meta.route,
-        ip: meta.ip,
-        now: meta.now,
-        durationSinceNowMs: durationSinceNowMs
-    };
-    // userId / roleCode 默认写入
-    obj["userId"] = meta.userId;
-    obj["roleCode"] = meta.roleCode;
-    obj["nickname"] = meta.nickname;
-    obj["roleType"] = meta.roleType;
-    return obj;
-}
-function mergeMetaIntoObject(input, meta) {
-    const merged = {};
-    for (const key of Object.keys(input)) {
-        merged[key] = input[key];
-    }
-    // 只补齐、不覆盖：允许把 undefined / null / 空字符串写入（由日志底层序列化决定是否展示）
-    const keys = ["requestId", "method", "route", "ip", "now", "durationSinceNowMs", "userId", "roleCode", "nickname", "roleType"];
-    for (const key of keys) {
-        if (merged[key] === undefined)
-            merged[key] = meta[key];
-    }
-    return merged;
-}
-// 日志仅接受 1 个入参（任意类型）。
-// - plain object（{}）直接作为 record
-// - 其他任何类型：包装成对象再写入（避免 sink 层依赖入参类型）
-function toRecord(input) {
-    if (isPlainObject(input)) {
-        return input;
-    }
-    if (input instanceof Error) {
-        return { err: input, msg: input.message || input.name || "Error" };
-    }
-    if (input === undefined) {
-        return { msg: "" };
-    }
-    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]" };
-    }
-}
-function withRequestMetaRecord(record) {
-    const meta = metaToObject();
-    if (!meta)
-        return record;
-    return mergeMetaIntoObject(record, meta);
-}
-class LoggerFacade {
-    write(level, input, options) {
-        // debug!=1 则完全不记录 debug 日志（包括文件与控制台）
-        if (level === "debug" && config.debug !== 1)
-            return;
-        const record0 = withRequestMetaRecord(toRecord(input));
-        // 测试场景：mock logger 走同步写入，并在 facade 层进行清洗/脱敏/截断控制
-        if (mockInstance) {
-            const effective = buildSanitizeOptionsForWriteOptions(options);
-            const sanitized = sanitizeLogObject(record0, effective);
-            if (level === "info") {
-                mockInstance.info(sanitized);
-            }
-            else if (level === "warn") {
-                mockInstance.warn(sanitized);
-            }
-            else if (level === "error") {
-                mockInstance.error(sanitized);
-            }
-            else {
-                mockInstance.debug(sanitized);
-            }
-            return;
-        }
-        writeJsonl("app", level, record0, options);
-        if (level === "error") {
-            // error 专属文件：始终镜像一份
-            writeJsonl("error", "error", record0, options);
-        }
-    }
-    info(input, options) {
-        this.write("info", input, options);
-    }
-    warn(input, options) {
-        this.write("warn", input, options);
-    }
-    error(input, options) {
-        this.write("error", input, options);
-    }
-    debug(input, options) {
-        this.write("debug", input, options);
-    }
-    /**
-     * 打印多行纯文本到控制台（stdout/stderr）。
-     *
-     * 说明：
-     * - 该方法不写入 JSONL 文件、不做清洗/脱敏/截断；仅用于“人类可读”的多行输出。
-     * - 若需要落盘/采集：请先调用 Logger.info/warn/error/debug 写入 JSONL（可选 console:false），再调用本方法输出多行。
-     */
-    printPlainLines(input, options) {
-        const kind = options && options.stream === "stderr" ? "stderr" : "stdout";
-        const stream = kind === "stderr" ? process.stderr : process.stdout;
-        try {
-            if (Array.isArray(input)) {
-                for (const line of input) {
-                    stream.write(`${String(line)}\n`);
-                }
-                return;
-            }
-            const parts = String(input).split("\n");
-            for (let i = 0; i < parts.length; i = i + 1) {
-                stream.write(`${parts[i]}\n`);
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    async flush() {
-        await flush();
-    }
-    configure(cfg) {
-        configure(cfg);
-    }
-    setMock(mock) {
-        setMockLogger(mock);
-    }
-    async shutdown() {
-        await shutdown();
-    }
-}
-/**
- * 日志实例（延迟初始化）
- */
-export const Logger = new LoggerFacade();