@taicode/common-base 3.7.7 → 3.7.8

package/output/logger/logger.d.ts

@@ -0,0 +1,64 @@
+import type { LogTransport } from './transport.js';
+import { type LogFormatter } from './formatter.js';
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+export interface LoggerOptions {
+    level?: LogLevel;
+    /** LogTransport 实例数组，用于处理结构化日志数据 */
+    transports?: LogTransport[];
+    /** 格式化器实例 */
+    formatter?: LogFormatter;
+    /** 传统的 print 函数，用于向后兼容 */
+    print?: (level: LogLevel, ...args: any[]) => void;
+}
+export declare class Logger {
+    private _level;
+    private formatter;
+    private transports;
+    private print?;
+    constructor(options?: LoggerOptions);
+    private defaultPrint;
+    private shouldLog;
+    /**
+     * 记录日志到所有 transports
+     */
+    private logToTransports;
+    /**
+     * 使用传统 print 方式记录日志（向后兼容）
+     */
+    private logToPrint;
+    trace(...args: any[]): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    fatal(...args: any[]): void;
+    silent(): void;
+    /**
+     * 添加 LogTransport
+     */
+    addTransport(transport: LogTransport): void;
+    /**
+     * 移除 LogTransport
+     */
+    removeTransport(transportName: string): void;
+    /**
+     * 获取所有 LogTransports
+     */
+    getTransports(): readonly LogTransport[];
+    /**
+     * 关闭所有 LogTransports
+     */
+    closeTransports(): Promise<void>;
+    /**
+     * Pino 兼容的 child 方法
+     * 创建一个共享配置的子 logger
+     */
+    child(bindings?: Record<string, any>, options?: Partial<LoggerOptions>): Logger;
+    /**
+     * Pino 兼容的 level getter/setter
+     */
+    get level(): LogLevel;
+    set level(newLevel: LogLevel);
+}
+export declare const logger: Logger;
+//# sourceMappingURL=logger.d.ts.map

package/output/logger/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../source/logger/logger.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAa,MAAM,gBAAgB,CAAA;AAC7D,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAEvE,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;AAE9E,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,oCAAoC;IACpC,UAAU,CAAC,EAAE,YAAY,EAAE,CAAA;IAC3B,aAAa;IACb,SAAS,CAAC,EAAE,YAAY,CAAA;IACxB,0BAA0B;IAC1B,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;CAClD;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,KAAK,CAAC,CAA2C;gBAE7C,OAAO,GAAE,aAAkB;IAYvC,OAAO,CAAC,YAAY;IA0BpB,OAAO,CAAC,SAAS;IAKjB;;OAEG;IACH,OAAO,CAAC,eAAe;IA2BvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAUlB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOnB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOnB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAOpB,MAAM;IAIN;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,YAAY,GAAG,IAAI;IAI3C;;OAEG;IACH,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IAI5C;;OAEG;IACH,aAAa,IAAI,SAAS,YAAY,EAAE;IAIxC;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAQtC;;;OAGG;IACH,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,MAAM;IAkB/E;;OAEG;IACH,IAAI,KAAK,IAAI,QAAQ,CAEpB;IAED,IAAI,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAE3B;CACF;AAED,eAAO,MAAM,MAAM,QAAe,CAAA"}

package/output/logger/logger.js

@@ -0,0 +1,179 @@
+import { defaultLogFormatter } from './formatter.js';
+export class Logger {
+    _level;
+    formatter;
+    transports;
+    print;
+    constructor(options = {}) {
+        this._level = options.level || 'info';
+        this.formatter = options.formatter || defaultLogFormatter;
+        this.transports = options.transports || [];
+        this.print = options.print;
+        // 如果没有 transports 且没有 print，使用默认的控制台输出
+        if (this.transports.length === 0 && !this.print) {
+            this.print = this.defaultPrint;
+        }
+    }
+    defaultPrint(level, ...args) {
+        const prefix = `[${level.toUpperCase()}]`;
+        // 映射 pino 兼容的 level 到 console 方法
+        let consoleMethod;
+        switch (level) {
+            case 'trace':
+            case 'debug':
+                consoleMethod = console.debug || console.log;
+                break;
+            case 'info':
+                consoleMethod = console.info || console.log;
+                break;
+            case 'warn':
+                consoleMethod = console.warn || console.log;
+                break;
+            case 'error':
+            case 'fatal':
+                consoleMethod = console.error || console.log;
+                break;
+            default:
+                consoleMethod = console.log;
+        }
+        // eslint-disable-next-line no-console
+        consoleMethod(prefix, ...args);
+    }
+    shouldLog(level) {
+        const order = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+        return order.indexOf(level) >= order.indexOf(this._level);
+    }
+    /**
+     * 记录日志到所有 transports
+     */
+    logToTransports(level, args) {
+        if (this.transports.length === 0) {
+            return;
+        }
+        const record = {
+            level,
+            timestamp: new Date(),
+            args: [...args] // 创建副本避免引用问题
+        };
+        // 并行发送到所有 transports
+        this.transports.forEach(transport => {
+            try {
+                const result = transport.log(record);
+                // 如果返回 Promise，静默处理错误
+                if (result && typeof result.catch === 'function') {
+                    result.catch(() => {
+                        // 静默处理 transport 错误，避免影响主程序
+                    });
+                }
+            }
+            catch {
+                // 静默处理 transport 错误，避免影响主程序
+            }
+        });
+    }
+    /**
+     * 使用传统 print 方式记录日志（向后兼容）
+     */
+    logToPrint(level, args) {
+        if (!this.print) {
+            return;
+        }
+        // 为了向后兼容，保持原始行为：传递格式化后的参数
+        const formattedArgs = this.formatter.formatArguments(args);
+        this.print(level, ...formattedArgs);
+    }
+    trace(...args) {
+        if (this.shouldLog('trace')) {
+            this.logToTransports('trace', args);
+            this.logToPrint('trace', args);
+        }
+    }
+    debug(...args) {
+        if (this.shouldLog('debug')) {
+            this.logToTransports('debug', args);
+            this.logToPrint('debug', args);
+        }
+    }
+    info(...args) {
+        if (this.shouldLog('info')) {
+            this.logToTransports('info', args);
+            this.logToPrint('info', args);
+        }
+    }
+    warn(...args) {
+        if (this.shouldLog('warn')) {
+            this.logToTransports('warn', args);
+            this.logToPrint('warn', args);
+        }
+    }
+    error(...args) {
+        if (this.shouldLog('error')) {
+            this.logToTransports('error', args);
+            this.logToPrint('error', args);
+        }
+    }
+    fatal(...args) {
+        if (this.shouldLog('fatal')) {
+            this.logToTransports('fatal', args);
+            this.logToPrint('fatal', args);
+        }
+    }
+    silent() {
+        // Pino 兼容的 silent 方法 - 无操作
+    }
+    /**
+     * 添加 LogTransport
+     */
+    addTransport(transport) {
+        this.transports.push(transport);
+    }
+    /**
+     * 移除 LogTransport
+     */
+    removeTransport(transportName) {
+        this.transports = this.transports.filter(t => t.name !== transportName);
+    }
+    /**
+     * 获取所有 LogTransports
+     */
+    getTransports() {
+        return [...this.transports];
+    }
+    /**
+     * 关闭所有 LogTransports
+     */
+    async closeTransports() {
+        const closePromises = this.transports
+            .map(transport => transport.close?.())
+            .filter(Boolean);
+        await Promise.all(closePromises);
+    }
+    /**
+     * Pino 兼容的 child 方法
+     * 创建一个共享配置的子 logger
+     */
+    child(bindings, options) {
+        // 合并选项，子 logger 继承父 logger 的配置
+        const childOptions = {
+            level: options?.level || this._level,
+            transports: options?.transports || this.transports,
+            formatter: options?.formatter || this.formatter,
+            print: options?.print || this.print
+        };
+        const childLogger = new Logger(childOptions);
+        // 如果提供了 bindings，我们可以在这里处理
+        // 目前的实现中，bindings 主要用于标识，不直接影响日志输出
+        // 在更完整的实现中，这些 bindings 会被添加到每个日志条目中
+        return childLogger;
+    }
+    /**
+     * Pino 兼容的 level getter/setter
+     */
+    get level() {
+        return this._level;
+    }
+    set level(newLevel) {
+        this._level = newLevel;
+    }
+}
+export const logger = new Logger();

package/output/logger/logger.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logger.test.d.ts.map

package/output/logger/logger.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.test.d.ts","sourceRoot":"","sources":["../../source/logger/logger.test.ts"],"names":[],"mappings":""}

package/output/logger/logger.test.js

@@ -0,0 +1,299 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Logger } from './logger.js';
+import { DefaultLogFormatter } from './formatter.js';
+import { UserError, SystemError } from '../error/index.js';
+import { MemoryTransport } from './transport.js'; // 测试向后兼容性
+describe('Logger', () => {
+    it('应该默认记录 info 及以上级别', () => {
+        const print = vi.fn();
+        const logger = new Logger({ print });
+        logger.trace('trace');
+        logger.debug('debug');
+        logger.info('info');
+        logger.warn('warn');
+        logger.error('error');
+        logger.fatal('fatal');
+        expect(print).not.toHaveBeenCalledWith('trace', 'trace');
+        expect(print).not.toHaveBeenCalledWith('debug', 'debug');
+        expect(print).toHaveBeenCalledWith('info', 'info');
+        expect(print).toHaveBeenCalledWith('warn', 'warn');
+        expect(print).toHaveBeenCalledWith('error', 'error');
+        expect(print).toHaveBeenCalledWith('fatal', 'fatal');
+    });
+    it('应该遵守日志级别', () => {
+        const print = vi.fn();
+        const logger = new Logger({ level: 'warn', print });
+        logger.trace('trace');
+        logger.debug('debug');
+        logger.info('info');
+        logger.warn('warn');
+        logger.error('error');
+        logger.fatal('fatal');
+        expect(print).not.toHaveBeenCalledWith('trace', 'trace');
+        expect(print).not.toHaveBeenCalledWith('debug', 'debug');
+        expect(print).not.toHaveBeenCalledWith('info', 'info');
+        expect(print).toHaveBeenCalledWith('warn', 'warn');
+        expect(print).toHaveBeenCalledWith('error', 'error');
+        expect(print).toHaveBeenCalledWith('fatal', 'fatal');
+    });
+    it('应该支持 trace 级别日志', () => {
+        const print = vi.fn();
+        const logger = new Logger({ level: 'trace', print });
+        logger.trace('trace message');
+        expect(print).toHaveBeenCalledWith('trace', 'trace message');
+    });
+    it('应该支持 fatal 级别日志', () => {
+        const print = vi.fn();
+        const logger = new Logger({ level: 'fatal', print });
+        logger.fatal('fatal error');
+        expect(print).toHaveBeenCalledWith('fatal', 'fatal error');
+    });
+    it('silent 方法应该是无操作函数', () => {
+        const print = vi.fn();
+        const logger = new Logger({ print });
+        logger.silent();
+        expect(print).not.toHaveBeenCalled();
+    });
+    it('应该允许自定义处理器', () => {
+        const logs = [];
+        const print = (level, ...args) => logs.push([level, ...args]);
+        const logger = new Logger({ print });
+        logger.error('err', 123);
+        expect(logs).toContainEqual(['error', 'err', "123"]);
+    });
+});
+describe('Logger 错误处理', () => {
+    it('应该正确格式化 UserError', () => {
+        const mockPrint = vi.fn();
+        const logger = new Logger({ print: mockPrint });
+        const userError = new UserError('validation-failed', {
+            field: 'email',
+            value: 'invalid-email',
+            rule: 'email-format'
+        }, '邮箱格式无效');
+        logger.error('测试用户错误:', userError);
+        expect(mockPrint).toHaveBeenCalledWith('error', '测试用户错误:', expect.stringContaining('🚫 User Error [validation-failed]'));
+        expect(mockPrint).toHaveBeenCalledWith('error', '测试用户错误:', expect.stringContaining('邮箱格式无效'));
+    });
+    it('应该正确格式化 SystemError', () => {
+        const mockPrint = vi.fn();
+        const logger = new Logger({ print: mockPrint });
+        const systemError = new SystemError('database-error', {
+            table: 'users',
+            query: 'SELECT * FROM users',
+            operation: 'select'
+        }, '数据库连接失败');
+        logger.error('测试系统错误:', systemError);
+        expect(mockPrint).toHaveBeenCalledWith('error', '测试系统错误:', expect.stringContaining('⚠️ System Error [database-error]'));
+        expect(mockPrint).toHaveBeenCalledWith('error', '测试系统错误:', expect.stringContaining('数据库连接失败'));
+    });
+    it('应该正确格式化普通 Error', () => {
+        const mockPrint = vi.fn();
+        const logger = new Logger({ print: mockPrint });
+        const genericError = new Error('普通错误');
+        logger.error('测试普通错误:', genericError);
+        expect(mockPrint).toHaveBeenCalledWith('error', '测试普通错误:', expect.stringContaining('💥 Error'));
+        expect(mockPrint).toHaveBeenCalledWith('error', '测试普通错误:', expect.stringContaining('普通错误'));
+    });
+    it('应该支持自定义 LogFormatter 实例', () => {
+        const customFormatter = new DefaultLogFormatter({}, {
+            showStack: false,
+            useColors: false
+        });
+        const mockPrint = vi.fn();
+        const logger = new Logger({
+            print: mockPrint,
+            formatter: customFormatter
+        });
+        const error = new Error('测试错误');
+        logger.error(error);
+        const formattedError = mockPrint.mock.calls[0][1];
+        expect(formattedError).not.toContain('Stack:');
+        expect(formattedError).not.toContain('\x1b['); // ANSI color codes
+    });
+    it('应该支持自定义格式化选项', () => {
+        const customFormatter = new DefaultLogFormatter({}, {
+            showStack: false,
+            showContext: false,
+            useColors: false
+        });
+        const mockPrint = vi.fn();
+        const logger = new Logger({
+            print: mockPrint,
+            formatter: customFormatter
+        });
+        const userError = new UserError('test-error', { field: 'test' }, '测试错误');
+        logger.error(userError);
+        const formattedError = mockPrint.mock.calls[0][1];
+        expect(formattedError).not.toContain('Stack:');
+        expect(formattedError).not.toContain('Context:');
+        expect(formattedError).not.toContain('\x1b['); // ANSI color codes
+    });
+});
+describe('Logger Transport 集成', () => {
+    it('应该支持 Transport 记录日志', () => {
+        const transport = new MemoryTransport();
+        const logger = new Logger({ transports: [transport] });
+        logger.info('测试消息', { data: 'value' });
+        const records = transport.getRecords();
+        expect(records).toHaveLength(1);
+        expect(records[0].level).toBe('info');
+        expect(records[0].args).toEqual(['测试消息', { data: 'value' }]);
+        expect(records[0].timestamp).toBeInstanceOf(Date);
+    });
+    it('应该支持多个 Transport', () => {
+        const transport1 = new MemoryTransport({ maxRecords: 10 });
+        const transport2 = new MemoryTransport({ maxRecords: 10 });
+        const logger = new Logger({ transports: [transport1, transport2] });
+        logger.error('错误消息');
+        expect(transport1.getRecords()).toHaveLength(1);
+        expect(transport2.getRecords()).toHaveLength(1);
+        expect(transport1.getRecords()[0].args).toEqual(['错误消息']);
+        expect(transport2.getRecords()[0].args).toEqual(['错误消息']);
+    });
+    it('应该支持动态添加和移除 Transport', () => {
+        const logger = new Logger();
+        const transport = new MemoryTransport();
+        // 添加 transport
+        logger.addTransport(transport);
+        logger.info('消息1');
+        expect(transport.getRecords()).toHaveLength(1);
+        // 移除 transport
+        logger.removeTransport('memory');
+        logger.info('消息2');
+        expect(transport.getRecords()).toHaveLength(1); // 应该还是1条
+    });
+    it('应该获取所有 Transport', () => {
+        const transport1 = new MemoryTransport();
+        const transport2 = new MemoryTransport();
+        const logger = new Logger({ transports: [transport1, transport2] });
+        const transports = logger.getTransports();
+        expect(transports).toHaveLength(2);
+        expect(transports[0].name).toBe('memory');
+        expect(transports[1].name).toBe('memory');
+    });
+    it('应该同时支持 Transport 和 print', () => {
+        const transport = new MemoryTransport();
+        const mockPrint = vi.fn();
+        const logger = new Logger({
+            transports: [transport],
+            print: mockPrint
+        });
+        logger.warn('警告消息');
+        // Transport 应该收到结构化数据
+        const records = transport.getRecords();
+        expect(records).toHaveLength(1);
+        expect(records[0].args).toEqual(['警告消息']);
+        // print 应该收到格式化的数据
+        expect(mockPrint).toHaveBeenCalledWith('warn', '警告消息');
+    });
+    it('应该处理 Transport 错误而不影响主程序', () => {
+        const faultyTransport = {
+            name: 'faulty',
+            log: () => { throw new Error('Transport 错误'); }
+        };
+        const logger = new Logger({ transports: [faultyTransport] });
+        // 不应该抛出错误
+        expect(() => {
+            logger.error('测试消息');
+        }).not.toThrow();
+    });
+    it('应该在没有 Transport 和 print 时使用默认输出', () => {
+        const consoleSpy = vi.spyOn(console, 'info').mockImplementation(() => { });
+        const logger = new Logger();
+        logger.info('默认输出测试');
+        expect(consoleSpy).toHaveBeenCalledWith('[INFO]', '默认输出测试');
+        consoleSpy.mockRestore();
+    });
+    it('应该关闭所有 Transport', async () => {
+        const mockClose1 = vi.fn();
+        const mockClose2 = vi.fn();
+        const transport1 = {
+            name: 'test1',
+            log: () => { },
+            close: mockClose1
+        };
+        const transport2 = {
+            name: 'test2',
+            log: () => { },
+            close: mockClose2
+        };
+        const logger = new Logger({ transports: [transport1, transport2] });
+        await logger.closeTransports();
+        expect(mockClose1).toHaveBeenCalled();
+        expect(mockClose2).toHaveBeenCalled();
+    });
+});
+describe('向后兼容性测试', () => {
+    it('Transport 类型别名应该正常工作', () => {
+        // 测试 Transport 类型别名是否可以正常使用
+        const transport = new MemoryTransport();
+        const logger = new Logger({ transports: [transport] });
+        logger.info('测试向后兼容性');
+        const records = transport.getRecords();
+        expect(records).toHaveLength(1);
+        expect(records[0].args).toEqual(['测试向后兼容性']);
+    });
+});
+describe('Pino 兼容性测试', () => {
+    it('应该支持 child 方法创建子 logger', () => {
+        const print = vi.fn();
+        const logger = new Logger({ print });
+        const child = logger.child({ requestId: '123' });
+        expect(child).toBeInstanceOf(Logger);
+        expect(child.level).toBe(logger.level);
+        child.info('child log');
+        expect(print).toHaveBeenCalledWith('info', 'child log');
+    });
+    it('child logger 应该继承父 logger 的配置', () => {
+        const print = vi.fn();
+        const parent = new Logger({ level: 'warn', print });
+        const child = parent.child();
+        expect(child.level).toBe('warn');
+        child.info('info message');
+        child.warn('warn message');
+        expect(print).not.toHaveBeenCalledWith('info', 'info message');
+        expect(print).toHaveBeenCalledWith('warn', 'warn message');
+    });
+    it('child logger 可以有自己的配置选项', () => {
+        const parentPrint = vi.fn();
+        const childPrint = vi.fn();
+        const parent = new Logger({ level: 'info', print: parentPrint });
+        const child = parent.child({}, { level: 'debug', print: childPrint });
+        expect(child.level).toBe('debug');
+        child.debug('debug message');
+        expect(parentPrint).not.toHaveBeenCalled();
+        expect(childPrint).toHaveBeenCalledWith('debug', 'debug message');
+    });
+    it('应该支持 level 属性的 getter 和 setter', () => {
+        const logger = new Logger();
+        expect(logger.level).toBe('info'); // 默认级别
+        logger.level = 'debug';
+        expect(logger.level).toBe('debug');
+        logger.level = 'error';
+        expect(logger.level).toBe('error');
+    });
+    it('level 变更应该影响日志输出', () => {
+        const print = vi.fn();
+        const logger = new Logger({ print });
+        logger.level = 'error';
+        logger.info('info message');
+        logger.error('error message');
+        expect(print).not.toHaveBeenCalledWith('info', 'info message');
+        expect(print).toHaveBeenCalledWith('error', 'error message');
+    });
+    it('应该包含所有 Pino 兼容的方法', () => {
+        const logger = new Logger();
+        // 检查所有必需的方法是否存在
+        expect(typeof logger.trace).toBe('function');
+        expect(typeof logger.debug).toBe('function');
+        expect(typeof logger.info).toBe('function');
+        expect(typeof logger.warn).toBe('function');
+        expect(typeof logger.error).toBe('function');
+        expect(typeof logger.fatal).toBe('function');
+        expect(typeof logger.silent).toBe('function');
+        expect(typeof logger.child).toBe('function');
+        // 检查 level 属性
+        expect(typeof logger.level).toBe('string');
+    });
+});

package/output/logger/transport.d.ts

@@ -0,0 +1,124 @@
+/**
+ * LogTransport 抽象接口和实现
+ * LogTransport 负责处理和存储结构化的日志数据
+ */
+import type { LogLevel } from './logger.js';
+/**
+ * 日志记录接口
+ * 包含完整的结构化日志信息
+ */
+export interface LogRecord {
+    /** 日志级别 */
+    level: LogLevel;
+    /** 时间戳 */
+    timestamp: Date;
+    /** 原始参数数组 */
+    args: any[];
+    /** 可选的附加元数据 */
+    metadata?: Record<string, any>;
+}
+/**
+ * LogTransport 抽象接口
+ * 负责处理结构化日志数据的存储和管理
+ */
+export interface LogTransport {
+    /** LogTransport 名称 */
+    readonly name: string;
+    /** 最低日志级别 */
+    level?: LogLevel;
+    /** 是否启用 */
+    enabled?: boolean;
+    /**
+     * 处理日志记录
+     * @param record 结构化的日志记录
+     */
+    log(record: LogRecord): void | Promise<void>;
+    /**
+     * 关闭 LogTransport，清理资源
+     */
+    close?(): void | Promise<void>;
+}
+/**
+ * 内存 LogTransport 配置选项
+ */
+export interface MemoryTransportOptions {
+    /** 最大存储的日志条数 */
+    maxRecords?: number;
+    /** 最低日志级别 */
+    level?: LogLevel;
+    /** 是否启用 */
+    enabled?: boolean;
+}
+/**
+ * 内存中的日志条目
+ */
+export interface MemoryLogEntry extends LogRecord {
+    /** 唯一标识符 */
+    id: string;
+}
+/**
+ * 内存 LogTransport 实现
+ * 将结构化日志数据存储在内存中，支持查询和分析
+ * 使用RingCache实现高效的FIFO行为
+ */
+export declare class MemoryTransport implements LogTransport {
+    readonly name: string;
+    level?: LogLevel;
+    enabled: boolean;
+    private cache;
+    private static readonly LOG_LEVELS;
+    constructor(options?: MemoryTransportOptions);
+    /**
+     * 检查是否应该处理此级别的日志
+     */
+    private shouldLog;
+    log(record: LogRecord): void;
+    /**
+     * 获取所有日志记录
+     */
+    getRecords(): readonly MemoryLogEntry[];
+    /**
+     * 根据级别获取日志记录
+     */
+    getRecordsByLevel(level: LogLevel): MemoryLogEntry[];
+    /**
+     * 根据时间范围获取日志记录
+     */
+    getRecordsByTimeRange(start: Date, end: Date): MemoryLogEntry[];
+    /**
+     * 搜索日志记录
+     * @param predicate 搜索条件函数
+     */
+    searchRecords(predicate: (record: MemoryLogEntry) => boolean): MemoryLogEntry[];
+    /**
+     * 根据参数内容搜索
+     * @param searchText 搜索文本
+     */
+    searchByContent(searchText: string): MemoryLogEntry[];
+    /**
+     * 获取最近的 N 条记录
+     */
+    getRecentRecords(count: number): MemoryLogEntry[];
+    /**
+     * 获取统计信息
+     */
+    getStats(): {
+        total: number;
+        byLevel: Record<LogLevel, number>;
+        oldestTimestamp?: Date;
+        newestTimestamp?: Date;
+    };
+    /**
+     * 清空所有记录
+     */
+    clear(): void;
+    /**
+     * 导出为 JSON 格式
+     */
+    exportToJSON(): string;
+    /**
+     * 关闭 LogTransport
+     */
+    close(): void;
+}
+//# sourceMappingURL=transport.d.ts.map

package/output/logger/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../source/logger/transport.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAG3C;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,WAAW;IACX,KAAK,EAAE,QAAQ,CAAA;IACf,UAAU;IACV,SAAS,EAAE,IAAI,CAAA;IACf,aAAa;IACb,IAAI,EAAE,GAAG,EAAE,CAAA;IACX,eAAe;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,sBAAsB;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB,aAAa;IACb,KAAK,CAAC,EAAE,QAAQ,CAAA;IAEhB,WAAW;IACX,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;;OAGG;IACH,GAAG,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE5C;;OAEG;IACH,KAAK,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,gBAAgB;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa;IACb,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,WAAW;IACX,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAe,SAAQ,SAAS;IAC/C,YAAY;IACZ,EAAE,EAAE,MAAM,CAAA;CACX;AAED;;;;GAIG;AACH,qBAAa,eAAgB,YAAW,YAAY;IAClD,SAAgB,IAAI,EAAE,MAAM,CAAY;IACjC,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,OAAO,EAAE,OAAO,CAAQ;IAE/B,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAoE;gBAE1F,OAAO,GAAE,sBAA2B;IAQhD;;OAEG;IACH,OAAO,CAAC,SAAS;IAeV,GAAG,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IAQnC;;OAEG;IACI,UAAU,IAAI,SAAS,cAAc,EAAE;IAO9C;;OAEG;IACI,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,cAAc,EAAE;IAQ3D;;OAEG;IACI,qBAAqB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,cAAc,EAAE;IAQtE;;;OAGG;IACI,aAAa,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,OAAO,GAAG,cAAc,EAAE;IAItF;;;OAGG;IACI,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,EAAE;IAsB5D;;OAEG;IACI,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE;IAOxD;;OAEG;IACI,QAAQ,IAAI;QACjB,KAAK,EAAE,MAAM,CAAA;QACb,OAAO,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;QACjC,eAAe,CAAC,EAAE,IAAI,CAAA;QACtB,eAAe,CAAC,EAAE,IAAI,CAAA;KACvB;IA4BD;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;OAEG;IACI,YAAY,IAAI,MAAM;IAI7B;;OAEG;IACI,KAAK,IAAI,IAAI;CAGrB"}