mm_logger 0.0.0-stage → 1.0.0

package/lib/logger.js

@@ -0,0 +1,1098 @@
+/**
+ * mm_logger 日志模块
+ * @module mm_logger
+ */
+const fs = require('fs');
+const path = require('path');
+const log4js = require('log4js');
+const LEVEL = require('./level');
+const { timeFormat } = require('mm_helper').date;
+const color_tools = require('./colors').colors;
+
+/**
+ * 日志级别到颜色的映射
+ * @type {Object}
+ * @constant
+ */
+const LEVEL_COLOR = {
+	info: 'blue',
+	success: 'green',
+	warn: 'yellow',
+	error: 'red',
+	fatal: 'magenta'
+};
+
+console.debug = console.log;
+console.success = console.info;
+console.fatal = console.error;
+
+/**
+ * 日志类
+ * @class Log
+ */
+class Logger {
+	/**
+	 * 日志类默认配置
+	 * @type {Object}
+	 * @static
+	 */
+	static config = {
+		/**
+		 * 日志级别
+		 * @type {string}
+		 */
+		level: 'debug',
+		/**
+		 * 日志目录
+		 * @type {string}
+		 */
+		dir: './log',
+		/**
+		 * 是否启用控制台日志记录
+		 * @type {boolean}
+		 */
+		console: true,
+		/**
+		 * 控制台日志记录格式
+		 * @type {string}
+		 */
+		console_format: '{time} [{level}] {msg}',
+		/**
+		 * 是否启用文件日志记录
+		 * @type {boolean}
+		 */
+		file: false,
+		/**
+		 * 文件名格式
+		 * @type {string}
+		 */
+		filename: '{type}.log',
+		/**
+		 * 文件日志记录轮转文件名格式
+		 * @type {string}
+		 */
+		rotation_filename_format: '{type}_{date}_{index}.log',
+		/**
+		 * 文件日志记录格式
+		 * @type {string}
+		 */
+		content_format: '{time} [{level}] {msg}',
+		/**
+		 * 文件日志记录最大文件大小
+		 * @type {number}
+		 */
+		max_size: 1024 * 1024 * 3,
+		/**
+		 * 文件日志记录最大文件数量
+		 * @type {number}
+		 */
+		max_files: 7
+	};
+
+	/**
+	 * 构造函数，用于初始化日志类
+	 * @param {Object} config - 配置对象，包含日志相关配置信息
+	 */
+	constructor(config) {
+		/**
+		 * 日志配置
+		 * @type {Object}
+		 */
+		this.config = Object.assign({}, Logger.config);
+		this.setConfig(config);
+	}
+}
+
+/**
+ * 设置配置
+ * @param {Object} config - 配置对象
+ */
+Logger.prototype.setConfig = function(config = {}) {
+	if (typeof config !== 'object' || config === null) {
+		throw new Error('配置参数必须是对象类型');
+	}
+	Object.assign(this.config, config);
+	this._preset();
+};
+
+/**
+ * 初始化
+ * @private
+ * @returns {Logger} - 日志类实例
+ */
+Logger.prototype._preset = function() {
+	/**
+	 * 控制台日志记录器
+	 * @private
+	 */
+	this._console = console;
+
+	/**
+	 * 文件日志记录器对象
+	 * @private
+	 */
+	this._filer = {};
+
+	if (this.config.console) {
+		this._createConsoleLogger();
+	}
+
+	if (this.config.file) {
+		this._initLog4js();
+		this._createFileLoggers();
+	}
+
+	return this;
+};
+
+/**
+ * 创建控制台日志记录器
+ * @private
+ */
+Logger.prototype._createConsoleLogger = function() {
+	try {
+		// 自定义日志记录器，更好地控制Windows环境下的中文输出
+		const logger = {};
+
+		// 级别到函数的映射
+		const level_funcs = {
+			debug: console.debug,
+			info: console.info,
+			success: console.success,
+			warn: console.warn,
+			error: console.error,
+			fatal: console.fatal
+		};
+		const console_format = this.config.console_format;
+		// 创建各级别日志方法
+		Object.keys(level_funcs).forEach(function(level) {
+			logger[level] = function() {
+				const now = new Date();
+				const time_str = timeFormat(now, 'hh:mm:ss');
+				const args = Array.from(arguments);
+
+				// 格式化日志信息
+				let prefix = console_format.replace('{time}', time_str)
+					.replace('{level}', level.toUpperCase())
+					.replace('{msg}', args[0]);
+
+				// 按级别着色（colors 会根据终端能力自动禁用颜色）
+				const color_name = LEVEL_COLOR[level];
+				if (color_name) {
+					prefix = color_tools[color_name](prefix);
+				}
+
+				level_funcs[level].apply(console, [prefix, ...args.slice(1)]);
+			};
+		});
+
+		this._console = logger;
+	} catch (error) {
+		console.error('创建控制台日志记录器失败:', error);
+	}
+};
+
+/**
+ * 检查是否需要轮转日志
+ * @private
+ * @param {string} type - 日志类型
+ */
+Logger.prototype._checkRotation = function(type) {
+	if (this._roller) {
+		if (this._roller.check(type)) {
+			this._roller.roll(type);
+		}
+	}
+};
+
+/**
+ * 清理超过max_files数量的旧日志文件
+ * @private
+ * @param {string} type - 日志类型
+ */
+Logger.prototype._cleanupOldLogs = function(type) {
+	// 此方法现在由 LogRoll 内部实现
+	// 保留这个方法是为了向后兼容
+	this._checkRotation(type);
+};
+
+/**
+ * 获取当前日期字符串，格式：YYYY-MM-DD
+ * @private
+ * @returns {string} - 当前日期字符串
+ */
+Logger.prototype._getDate = function() {
+	const now = new Date();
+	const year = now.getFullYear();
+	const month = String(now.getMonth() + 1).padStart(2, '0');
+	const day = String(now.getDate()).padStart(2, '0');
+	return `${year}-${month}-${day}`;
+}
+
+/**
+ * 创建单个文件日志记录器
+ * @private
+ * @param {string} type - 日志类型
+ */
+Logger.prototype._createFileLogger = function(type) {
+	// 创建并保存logger
+	const appender_name = `file_${type}`;
+	this._filer[type] = log4js.getLogger(appender_name);
+};
+
+/**
+ * 重命名日志备份文件
+ * @private
+ */
+Logger.prototype._renameLogBackupFiles = function() {
+	if (!this.config.file || !this._dir) return;
+
+	const types = ['debug', 'error', 'http'];
+	let files;
+
+	try {
+		files = fs.readdirSync(this._dir);
+	} catch (error) {
+		// 忽略错误，继续处理
+		return;
+	}
+
+	types.forEach(type => {
+		// 获取基础文件名
+		const base_filename = this.config.filename.replace('{type}', type);
+
+		// 查找所有原始格式的备份文件 (如: debug.Logger.1, app-debug.Logger.1)
+		const original_backups = files.filter(file =>
+			file.startsWith(base_filename) && /\.\d+$/.test(file)
+		);
+
+		// 重命名原始格式的备份文件
+		original_backups.forEach(backup_file => {
+			// 获取索引
+			const index = backup_file.match(/\.(\d+)$/)[1];
+
+			// 获取文件的创建时间
+			const old_path = path.join(this._dir, backup_file);
+			let date;
+
+			try {
+				const stats = fs.statSync(old_path);
+				// 格式化日期 (YYYY-MM-DD)
+				date = new Date(stats.birthtime).toISOString().split('T')[0];
+			} catch (error) {
+				// 如果获取文件信息失败，使用当前日期
+				date = new Date().toISOString().split('T')[0];
+			}
+
+			// 构建新的文件名
+			const new_filename = this.config.rotation_filename_format
+				.replace('{type}', type)
+				.replace('{date}', date)
+				.replace('{index}', index);
+			const new_path = path.join(this._dir, new_filename);
+
+			// 检查新文件是否已存在
+			if (!fs.existsSync(new_path)) {
+				// 重命名文件
+				try {
+					fs.renameSync(old_path, new_path);
+				} catch (error) {
+					// 忽略错误，继续处理其他文件
+				}
+			} else {
+				// 如果新文件已存在，删除旧文件
+				try {
+					fs.unlinkSync(old_path);
+				} catch (error) {
+					// 忽略错误，继续处理其他文件
+				}
+			}
+		});
+	});
+};
+
+/**
+ * 初始化log4js配置
+ * @private
+ */
+Logger.prototype._initLog4js = function() {
+	let dir = this.config.dir;
+	const types = ['debug', 'error', 'http'];
+	const appenders = {};
+	const categories = {};
+
+	// 确保日志目录存在
+	if (!fs.existsSync(dir)) {
+		const absoluteDir = path.isAbsolute(dir) ?
+			dir : path.resolve(dir);
+		fs.mkdirSync(absoluteDir, {
+			recursive: true
+		});
+		dir = absoluteDir;
+		this.config.dir = absoluteDir;
+	}
+
+	// 配置所有appender
+	for (const type of types) {
+		// 完整的基础文件名（包含扩展名）
+		const full_filename = this.config.filename.replace('{type}', type);
+		const filename = path.join(dir, full_filename);
+		const appender_name = `file_${type}`;
+
+		// 将自定义格式转换为log4js支持的pattern格式
+		let pattern = this.config.content_format
+			.replace('{time}', '%d')
+			.replace('{level}', '%p')
+			.replace('{msg}', '%m');
+
+		// 使用file appender
+		appenders[appender_name] = {
+			type: 'file',
+			filename: filename,
+			maxLogSize: this.config.max_size,
+			backups: this.config.max_files,
+			encoding: 'utf8',
+			compress: false,
+			layout: {
+				type: 'pattern',
+				pattern: pattern
+			}
+		};
+
+		categories[appender_name] = {
+			appenders: [appender_name],
+			level: this.config.level
+		};
+	}
+
+	// 保存日志目录路径
+	this._dir = dir;
+
+	// 添加默认类别
+	categories.default = {
+		appenders: ['file_debug'],
+		level: this.config.level
+	};
+
+	// 一次性配置log4js
+	log4js.configure({
+		appenders: appenders,
+		categories: categories
+	});
+};
+
+/**
+ * 创建文件日志记录器
+ * @private
+ */
+Logger.prototype._createFileLoggers = function() {
+	try {
+		// 创建多种类型的日志记录器
+		const types = ['debug', 'error', 'http'];
+		for (let i = 0; i < types.length; i++) {
+			const type = types[i];
+			this._createFileLogger(type);
+		}
+	} catch (error) {
+		console.error('创建文件日志记录器失败:', error);
+	}
+};
+
+/**
+ * 检查日志级别
+ * @param {String} level - 日志级别
+ * @returns {Boolean} - 是否应该记录
+ * @private
+ */
+Logger.prototype._checkLevel = function(level) {
+	const currentLevel = LEVEL[this.config.level] || LEVEL.info;
+	const targetLevel = LEVEL[level] || LEVEL.info;
+	return targetLevel >= currentLevel;
+};
+
+/**
+ * 更新文件日志记录器（Windows兼容版本）
+ * @private
+ * @param {string} type - 日志类型
+ */
+Logger.prototype._updateFileLogger = function(type) {
+	// 如果logger不存在，创建一个
+	if (!this._filer[type]) {
+		this._createFileLogger(type);
+	}
+};
+
+/**
+ * 通用日志记录方法
+ * @param {String} level - 日志级别
+ * @param {String} message - 日志消息
+ * @param {...*} args - 额外参数
+ * @private
+ */
+Logger.prototype._log = function(level, message, ...args) {
+	try {
+		// 校验参数
+		if (!LEVEL.hasOwnProperty(level)) {
+			throw new Error(`无效的日志级别: ${level}`);
+		}
+		if (typeof message !== 'string') {
+			throw new Error('日志消息必须是字符串类型');
+		}
+
+		// 检查级别
+		if (!this._checkLevel(level)) {
+			return;
+		}
+
+		// 控制台日志
+		if (this._console) {
+			this._console[level](message, ...args);
+		}
+
+		// 文件日志
+		if (this.config.file) {
+			// 在写入前更新所有可能用到的logger
+			this._updateFileLogger('debug');
+
+			// debug日志包含所有级别的日志
+			if (this._filer.debug) {
+				this._filer.debug[level === 'success' ? 'info' : level](message, ...args);
+			}
+
+			// error日志只包含warn、error、fatal三个级别的日志
+			const error_levels = ['warn', 'error', 'fatal'];
+			if (error_levels.includes(level)) {
+				this._updateFileLogger('error');
+				if (this._filer.error) {
+					this._filer.error[level === 'success' ? 'info' : level](message, ...args);
+				}
+			}
+
+			// 检查并重命名备份文件
+			setImmediate(() => {
+				this._renameLogBackupFiles();
+			});
+		}
+	} catch (error) {
+		console.error(`日志记录错误: ${error.message}`);
+	}
+};
+
+/**
+ * 记录debug级别日志
+ * @param {String} message - 日志消息
+ * @param {...*} args - 额外参数
+ */
+Logger.prototype.debug = function(message, ...args) {
+	this._log('debug', message, ...args);
+};
+
+/**
+ * 记录info级别日志
+ * @param {String} message - 日志消息
+ * @param {...*} args - 额外参数
+ */
+Logger.prototype.info = function(message, ...args) {
+	this._log('info', message, ...args);
+};
+
+/**
+ * 记录success级别日志
+ * @param {String} message - 日志消息
+ * @param {...*} args - 额外参数
+ */
+Logger.prototype.success = function(message, ...args) {
+	this._log('success', message, ...args);
+};
+
+/**
+ * 记录warn级别日志
+ * @param {String} message - 日志消息
+ * @param {...*} args - 额外参数
+ */
+Logger.prototype.warn = function(message, ...args) {
+	this._log('warn', message, ...args);
+};
+
+/**
+ * 记录error级别日志
+ * @param {String} message - 日志消息
+ * @param {...*} args - 额外参数
+ */
+Logger.prototype.error = function(message, ...args) {
+	this._log('error', message, ...args);
+};
+
+/**
+ * 记录fatal级别日志
+ * @param {String} message - 日志消息
+ * @param {...*} args - 额外参数
+ */
+Logger.prototype.fatal = function(message, ...args) {
+	this._log('fatal', message, ...args);
+};
+
+/**
+ * 记录日志
+ * @param {String} level - 日志级别
+ * @param {String} message - 日志消息
+ * @param {...*} args - 额外参数
+ */
+Logger.prototype.log = function(level, message, ...args) {
+	this._log(level, message, ...args);
+};
+
+/**
+ * 记录HTTP请求日志
+ * @param {String} level - HTTP方法
+ * @param {String} message - 日志消息
+ * @param {...*} args - 额外参数
+ * @returns {Object} - 日志数据
+ */
+Logger.prototype.http = function(level, message, ...args) {
+	try {
+
+		// 记录到控制台
+		if (this.config.console) {
+			const logger = this._console;
+			if (logger[level]) {
+				logger[level](message, ...args);
+			}
+		}
+
+		// 记录到文件
+		if (this.config.file) {
+			// 更新http logger并记录日志
+			this._updateFileLogger('http');
+			// 单独输出到http.log
+			if (this._filer.http) {
+				this._filer.http.info(message, ...args);
+			}
+
+			// 根据级别决定是否输出到error.log
+			if (LEVEL[level] >= LEVEL.warn) {
+				this._updateFileLogger('error');
+				if (this._filer.error) {
+					this._filer.error.info(message, ...args);
+				}
+			}
+		}
+	} catch (error) {
+		console.error(`HTTP日志记录错误: ${error.message}`);
+	}
+};
+
+/**
+ * 解析并规范化分页参数
+ * @param {Object} query - 查询条件
+ * @param {number} [query.page_now] - 当前页码，从1开始，默认1
+ * @param {number} [query.page_size] - 每页条数，默认30
+ * @returns {Object} - 规范化后的分页参数 { page_now, page_size }
+ * @private
+ */
+Logger.prototype._normalizePagination = function(query = {}) {
+	const page_now = Math.max(1, Number(query.page_now) || 1);
+	const page_size = Math.max(1, Number(query.page_size) || 30);
+	return { page_now, page_size };
+};
+
+/**
+ * 校验查询条件的字段类型
+ * @param {Object} query - 查询条件
+ * @throws {TypeError} - 当字段类型非法时
+ * @private
+ */
+Logger.prototype._checkQuery = function(query = {}) {
+	if (query.keyword !== undefined && typeof query.keyword !== 'string') {
+		throw new TypeError('keyword参数必须是字符串类型');
+	}
+	if (query.level !== undefined && typeof query.level !== 'string') {
+		throw new TypeError('level参数必须是字符串类型');
+	}
+	if (query.date !== undefined && typeof query.date !== 'string') {
+		throw new TypeError('date参数必须是字符串类型');
+	}
+};
+
+/**
+ * 判断日志条目是否匹配关键词
+ * @param {Object} log_entry - 日志条目
+ * @param {string} keyword - 关键词，空则匹配所有
+ * @returns {boolean} - 是否匹配
+ * @private
+ */
+Logger.prototype._matchKeyword = function(log_entry, keyword) {
+	if (!keyword) {
+		return true;
+	}
+	return String(log_entry.message || '').toLowerCase().includes(keyword.toLowerCase());
+};
+
+/**
+ * 判断日志条目是否匹配级别
+ * @param {Object} log_entry - 日志条目
+ * @param {string} level - 日志级别，空则匹配所有
+ * @returns {boolean} - 是否匹配
+ * @private
+ */
+Logger.prototype._matchLevel = function(log_entry, level) {
+	if (!level) {
+		return true;
+	}
+	return log_entry.level === level.toLowerCase();
+};
+
+/**
+ * 判断日志条目是否匹配日期
+ * @param {Object} log_entry - 日志条目
+ * @param {string} date - 日期字符串（YYYY-MM-DD），空则匹配所有
+ * @returns {boolean} - 是否匹配
+ * @private
+ */
+Logger.prototype._matchDate = function(log_entry, date) {
+	if (!date) {
+		return true;
+	}
+	return String(log_entry.timestamp || '').startsWith(date);
+};
+
+/**
+ * 按查询条件过滤日志条目
+ * @param {Array} logs - 日志条目数组
+ * @param {Object} query - 查询条件
+ * @returns {Array} - 过滤后的日志条目数组
+ * @private
+ */
+Logger.prototype._filterLogs = function(logs, query = {}) {
+	const keyword = query.keyword || '';
+	const level = query.level || '';
+	const date = query.date || '';
+	if (!keyword && !level && !date) {
+		return logs;
+	}
+	return logs.filter((log_entry) => {
+		return this._matchKeyword(log_entry, keyword)
+			&& this._matchLevel(log_entry, level)
+			&& this._matchDate(log_entry, date);
+	});
+};
+
+/**
+ * 查询日志
+ * @param {Object} query - 查询条件
+ * @param {number} [query.page_now] - 当前页码，从1开始，默认1
+ * @param {number} [query.page_size] - 每页条数，默认30
+ * @param {string} [query.keyword] - 关键词，匹配消息内容（不区分大小写）
+ * @param {string} [query.level] - 日志级别，精确匹配
+ * @param {string} [query.date] - 日期前缀，格式 YYYY-MM-DD
+ * @returns {Object} - 查询结果，包含 list、count、page_now、page_size、page_total
+ */
+Logger.prototype.find = function(query = {}) {
+	if (typeof query !== 'object' || query === null) {
+		throw new Error('查询参数必须是对象类型');
+	}
+	this._checkQuery(query);
+
+	try {
+		const { page_now, page_size } = this._normalizePagination(query);
+
+		const dir = this.config.dir;
+		if (!fs.existsSync(dir)) {
+			return {
+				list: [],
+				count: 0,
+				page_now,
+				page_size,
+				page_total: 0
+			};
+		}
+
+		// 简单获取所有日志文件
+		const files = fs.readdirSync(dir)
+			.filter(function(file) {
+				return file.endsWith('.log');
+			})
+			.map(function(file) {
+				return path.join(dir, file);
+			});
+
+		let logs = [];
+
+		// 读取并解析日志文件
+		for (let i = 0; i < files.length; i++) {
+			const file_path = files[i];
+			try {
+				const content = fs.readFileSync(file_path, 'utf8');
+				const lines = content.trim().split('\n');
+
+				for (let j = 0; j < lines.length; j++) {
+					let line = lines[j];
+					// 去除换行符和回车符
+					line = line.replace(/[\r\n]/g, '').trim();
+					if (line) {
+						// 根据配置的content_format动态生成正则表达式
+						let content_format = this.config.content_format || '{time} [{level}] {msg}';
+
+						// 先保存占位符的位置，避免转义
+						const placeholders = [];
+						let temp_format = content_format.replace(/\{(time|level|msg)\}/g, (match, type) => {
+							const placeholder = `__${type.toUpperCase()}__`;
+							placeholders.push({
+								placeholder,
+								type
+							});
+							return placeholder;
+						});
+
+						// 转义正则表达式特殊字符
+						temp_format = temp_format.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+						// 替换占位符为对应的正则表达式模式
+						placeholders.forEach(({
+							placeholder,
+							type
+						}) => {
+							let pattern = '';
+							switch (type) {
+								case 'time':
+									pattern = '(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3})';
+									break;
+								case 'level':
+									pattern = '(DEBUG|INFO|SUCCESS|WARN|ERROR|FATAL|TRACE)';
+									break;
+								case 'msg':
+									pattern = '(.+)';
+									break;
+							}
+							temp_format = temp_format.replace(new RegExp(placeholder.replace(
+								/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), pattern);
+						});
+
+						const regex = new RegExp(`^${temp_format}$`);
+						const match = line.match(regex);
+
+						if (match) {
+							logs.push({
+								timestamp: match[1],
+								level: match[2].toLowerCase(),
+								message: match[3],
+								file: path.basename(file_path)
+							});
+						} else {
+							// 尝试解析JSON格式（兼容旧日志）
+							try {
+								const log = JSON.parse(line);
+								logs.push({
+									timestamp: log.time || new Date().toISOString(),
+									level: log.level || 'info',
+									message: log.msg || log.message || '',
+									file: path.basename(file_path)
+								});
+							} catch (e) {
+								// 跳过无法解析的行
+							}
+						}
+					}
+				}
+			} catch (error) {
+				console.error(`读取日志文件失败: ${file_path}`);
+			}
+		}
+
+		// 按查询条件过滤
+		logs = this._filterLogs(logs, query);
+
+		// 排序
+		logs.sort(function(a, b) {
+			return new Date(b.timestamp) - new Date(a.timestamp);
+		});
+
+		// 计算总数
+		const count = logs.length;
+
+		// 计算总页数并截取当前页
+		const page_total = Math.ceil(count / page_size);
+		const list = logs.slice(page_size * (page_now - 1), page_size * page_now);
+
+		// 返回标准格式的结果，包含分页信息
+		return {
+			list,
+			count,
+			page_now,
+			page_size,
+			page_total
+		};
+	} catch (error) {
+		console.error('查询日志失败:', error);
+		return {
+			list: [],
+			count: 0,
+			page_now: 1,
+			page_size: 30,
+			page_total: 0
+		};
+	}
+};
+
+/**
+ * 删除指定类型的日志文件
+ * @param {string} type - 日志类型，可选值：debug、error、http
+ * @returns {Object} - 删除结果，包含删除的文件数量
+ * @throws {Error} - 当type参数无效时
+ */
+Logger.prototype.remove = function(type = 'debug') {
+	// 验证参数
+	if (!type || typeof type !== 'string') {
+		throw new Error('type参数必须是字符串');
+	}
+
+	// 验证日志类型
+	const valid_types = ['debug', 'error', 'http'];
+	if (!valid_types.includes(type)) {
+		throw new Error(`无效的日志类型: ${type}，可选值：${valid_types.join(', ')}`);
+	}
+
+	let deleted_count = 0;
+
+	try {
+		// 检查日志目录是否存在
+		if (!fs.existsSync(this._dir)) {
+			return {
+				deleted: deleted_count
+			};
+		}
+
+		// 获取日志目录下的所有文件
+		const files = fs.readdirSync(this._dir);
+
+		// 查找并删除指定类型的日志文件
+		files.forEach(file => {
+			if (file.startsWith(`${type}_`) || file === `${type}.log`) {
+				const file_path = path.join(this._dir, file);
+				try {
+					fs.unlinkSync(file_path);
+					deleted_count++;
+				} catch (error) {
+					console.error(`删除日志文件失败: ${file_path}`, error);
+				}
+			}
+		});
+
+		// 重新创建日志记录器
+		if (this._filer && this._filer[type]) {
+			delete this._filer[type];
+			this._createFileLogger(type);
+		}
+	} catch (error) {
+		console.error(`删除日志文件失败: ${type}`, error);
+	}
+
+	return {
+		deleted: deleted_count
+	};
+};
+
+/**
+ * 清空指定类型的日志（删除日志内容，保留文件）
+ * @param {string} type - 日志类型，可选值：debug、error、http
+ * @param {string} [keyword] - 关键词，只删除包含该关键词的日志条目
+ * @returns {Object} - 清空结果，包含删除的日志条目数
+ * @throws {Error} - 当type参数无效时
+ */
+Logger.prototype.clear = function(type = 'debug', keyword) {
+	// 验证参数
+	if (!type || typeof type !== 'string') {
+		throw new Error('type参数必须是字符串');
+	}
+	if (keyword && typeof keyword !== 'string') {
+		throw new TypeError('keyword参数必须是字符串类型');
+	}
+
+	// 验证日志类型
+	const valid_types = ['debug', 'error', 'http'];
+	if (!valid_types.includes(type)) {
+		throw new Error(`无效的日志类型: ${type}，可选值：${valid_types.join(', ')}`);
+	}
+
+	let deleted_count = 0;
+
+	try {
+		// 检查日志目录是否存在
+		if (!fs.existsSync(this._dir)) {
+			return {
+				deleted: deleted_count
+			};
+		}
+
+		// 获取日志目录下的所有文件
+		const files = fs.readdirSync(this._dir);
+
+		// 查找并处理指定类型的日志文件
+		files.forEach(file => {
+			// 匹配日志文件名格式：type_YYYY-MM-DD_index.log 或 type.log
+			if (file.startsWith(`${type}_`) || file === `${type}.log`) {
+				const file_path = path.join(this._dir, file);
+				try {
+					const content = fs.readFileSync(file_path, 'utf8');
+					const parsed_logs = this._parseLogContent(content);
+					let filtered_logs;
+
+					if (keyword && typeof keyword === 'string') {
+						// 删除包含关键词的日志条目
+						filtered_logs = parsed_logs.filter(log_entry => !log_entry.includes(keyword));
+					} else {
+						// 清空所有日志条目（保留文件）
+						filtered_logs = [];
+					}
+
+					const removed_count = parsed_logs.length - filtered_logs.length;
+
+					if (removed_count > 0) {
+						fs.writeFileSync(file_path, filtered_logs.join('\n') + '\n');
+						deleted_count += removed_count;
+					}
+				} catch (error) {
+					console.error(`清空日志失败: ${file_path}`, error);
+				}
+			}
+		});
+	} catch (error) {
+		console.error(`清空日志失败: ${type}`, error);
+	}
+
+	return {
+		deleted: deleted_count
+	};
+};
+
+/**
+ * 删除所有类型的日志文件
+ * @returns {Object} - 删除结果，包含每种类型删除的文件数量
+ */
+Logger.prototype.removeAll = function() {
+	const result = {};
+	const types = ['debug', 'error', 'http'];
+
+	types.forEach(type => {
+		try {
+			result[type] = this.remove(type);
+		} catch (error) {
+			result[type] = {
+				deleted: 0,
+				error: error.message
+			};
+		}
+	});
+
+	return result;
+};
+
+/**
+ * 解析日志内容，正确处理跨行日志
+ * @param {string} content - 日志文件内容
+ * @returns {Array} - 日志条目数组
+ */
+Logger.prototype._parseLogContent = function(content) {
+  if (!content || typeof content !== 'string') {
+    return [];
+  }
+
+  // 日志起始模式：YYYY-MM-DDTHH:mm:ss.SSS [TYPE]
+  const log_start_pattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3} \[.*?\]/;
+  const lines = content.split('\n');
+  const logs = [];
+  let current_log = '';
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    
+    if (log_start_pattern.test(line)) {
+      // 遇到新的日志条目
+      if (current_log) {
+        logs.push(current_log.trim());
+      }
+      current_log = line;
+    } else if (current_log) {
+      // 继续拼接跨行日志
+      current_log += '\n' + line;
+    }
+  }
+
+  // 添加最后一条日志
+  if (current_log) {
+    logs.push(current_log.trim());
+  }
+
+  return logs;
+};
+
+/**
+ * 读取日志内容
+ * @param {string} type - 日志类型，可选值：debug、error、http，不传则读取所有类型
+ * @param {string} keyword - 关键词，不传则读取所有内容
+ * @returns {Array} - 日志内容数组
+ */
+Logger.prototype.read = function(type = 'debug', keyword = '') {
+  // 参数校验
+  if (type && typeof type !== 'string') {
+    throw new TypeError('type参数必须是字符串类型');
+  }
+  if (keyword && typeof keyword !== 'string') {
+    throw new TypeError('keyword参数必须是字符串类型');
+  }
+
+  try {
+    const dir = this.config.dir;
+    if (!fs.existsSync(dir)) {
+      return [];
+    }
+
+    const valid_types = ['debug', 'error', 'http'];
+    let target_types = valid_types;
+    
+    // 如果指定了type参数，只读取该类型
+    if (type && valid_types.includes(type)) {
+      target_types = [type];
+    }
+
+    let logs = [];
+
+    // 遍历所有目标类型
+    for (let i = 0; i < target_types.length; i++) {
+      const log_type = target_types[i];
+      const filename = this.config.filename.replace('{type}', log_type);
+      const file_path = path.join(dir, filename);
+
+      if (!fs.existsSync(file_path)) {
+        continue;
+      }
+
+      try {
+        const content = fs.readFileSync(file_path, 'utf8');
+        const parsed_logs = this._parseLogContent(content);
+
+        for (let j = 0; j < parsed_logs.length; j++) {
+          const log_entry = parsed_logs[j];
+          
+          if (log_entry) {
+            // 如果指定了keyword，只保留包含关键词的日志
+            if (keyword && !log_entry.includes(keyword)) {
+              continue;
+            }
+            logs.push(log_entry);
+          }
+        }
+      } catch (error) {
+        console.error(`读取日志文件失败: ${file_path}`, error);
+      }
+    }
+
+    return logs;
+  } catch (error) {
+    console.error('读取日志失败:', error);
+    return [];
+  }
+};
+
+// 导出模块
+module.exports = Logger;