@eggjs/logger 0.0.0 → 4.0.1-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-present Alibaba Group Holding Limited and other contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/egg/console_logger.d.ts

@@ -0,0 +1,16 @@
+import { EggConsoleLoggerOptions } from "../utils.js";
+import { Logger } from "../logger.js";
+
+//#region src/egg/console_logger.d.ts
+
+/**
+* Terminal Logger: sends all log output to console.
+* Uses egg's server environment (EGG_SERVER_ENV or options.env) to determine default level.
+* Production (prod) defaults to INFO; other environments default to WARN.
+*/
+declare class EggConsoleLogger extends Logger {
+  constructor(options?: Partial<EggConsoleLoggerOptions>);
+  get defaults(): Partial<EggConsoleLoggerOptions>;
+}
+//#endregion
+export { EggConsoleLogger };

package/dist/egg/console_logger.js

@@ -0,0 +1,34 @@
+import { Logger } from "../logger.js";
+import { assign, consoleFormatter } from "../utils.js";
+import { ConsoleTransport } from "../transports/console.js";
+
+//#region src/egg/console_logger.ts
+/**
+* Terminal Logger: sends all log output to console.
+* Uses egg's server environment (EGG_SERVER_ENV or options.env) to determine default level.
+* Production (prod) defaults to INFO; other environments default to WARN.
+*/
+var EggConsoleLogger = class extends Logger {
+	constructor(options) {
+		super();
+		const opts = assign({}, this.defaults, options);
+		const env = opts.env ?? process.env.EGG_SERVER_ENV ?? "";
+		const envLevel = process.env.NODE_CONSOLE_LOGGER_LEVEL;
+		const defaultLevel = env === "prod" ? "INFO" : "WARN";
+		const level = opts.level ?? envLevel ?? defaultLevel;
+		this.set("console", new ConsoleTransport({
+			level,
+			formatter: consoleFormatter,
+			maxCauseChainLength: opts.maxCauseChainLength
+		}));
+	}
+	get defaults() {
+		return {
+			encoding: "utf8",
+			maxCauseChainLength: 10
+		};
+	}
+};
+
+//#endregion
+export { EggConsoleLogger };

package/dist/egg/custom_logger.d.ts

@@ -0,0 +1,10 @@
+import { EggLogger } from "./logger.js";
+
+//#region src/egg/custom_logger.d.ts
+
+/**
+* Custom Logger: same as EggLogger but named for clarity.
+*/
+declare class EggCustomLogger extends EggLogger {}
+//#endregion
+export { EggCustomLogger };

package/dist/egg/custom_logger.js

@@ -0,0 +1,10 @@
+import { EggLogger } from "./logger.js";
+
+//#region src/egg/custom_logger.ts
+/**
+* Custom Logger: same as EggLogger but named for clarity.
+*/
+var EggCustomLogger = class extends EggLogger {};
+
+//#endregion
+export { EggCustomLogger };

package/dist/egg/error_logger.d.ts

@@ -0,0 +1,13 @@
+import { EggLoggerOptions } from "../utils.js";
+import { EggLogger } from "./logger.js";
+
+//#region src/egg/error_logger.d.ts
+
+/**
+* Error Logger: only prints ERROR level and above.
+*/
+declare class EggErrorLogger extends EggLogger {
+  constructor(options?: Partial<EggLoggerOptions>);
+}
+//#endregion
+export { EggErrorLogger };

package/dist/egg/error_logger.js

@@ -0,0 +1,23 @@
+import { levels } from "../level.js";
+import "../utils.js";
+import { EggLogger } from "./logger.js";
+
+//#region src/egg/error_logger.ts
+/**
+* Error Logger: only prints ERROR level and above.
+*/
+var EggErrorLogger = class extends EggLogger {
+	constructor(options) {
+		const opts = options ?? {};
+		opts.level = getMinLevel(opts.level);
+		opts.consoleLevel = getMinLevel(opts.consoleLevel);
+		super(opts);
+	}
+};
+function getMinLevel(level) {
+	if (!level) return "ERROR";
+	return levels[level] >= levels.ERROR ? level : "ERROR";
+}
+
+//#endregion
+export { EggErrorLogger };

package/dist/egg/logger.d.ts

@@ -0,0 +1,20 @@
+import { LoggerLevel } from "../level.js";
+import { EggLoggerOptions } from "../utils.js";
+import { Logger } from "../logger.js";
+
+//#region src/egg/logger.d.ts
+
+/**
+* Egg Logger: supports File, BufferedFile and Console transports.
+*/
+declare class EggLogger extends Logger {
+  readonly opts: EggLoggerOptions;
+  constructor(options?: Partial<EggLoggerOptions>);
+  get level(): LoggerLevel;
+  set level(level: LoggerLevel);
+  get consoleLevel(): LoggerLevel;
+  set consoleLevel(level: LoggerLevel);
+  get defaults(): Partial<EggLoggerOptions>;
+}
+//#endregion
+export { EggLogger };

package/dist/egg/logger.js

@@ -0,0 +1,92 @@
+import { Logger } from "../logger.js";
+import { assign, consoleFormatter, defaultFormatter } from "../utils.js";
+import { ConsoleTransport } from "../transports/console.js";
+import { FileTransport } from "../transports/file.js";
+import { FileBufferTransport } from "../transports/file_buffer.js";
+import path from "node:path";
+
+//#region src/egg/logger.ts
+/**
+* Egg Logger: supports File, BufferedFile and Console transports.
+*/
+var EggLogger = class extends Logger {
+	opts;
+	constructor(options) {
+		super();
+		this.opts = assign({}, this.defaults, options);
+		this.options = this.opts;
+		const { opts } = this;
+		if (opts.file && opts.dir && !path.isAbsolute(opts.file)) opts.file = path.join(opts.dir, opts.file);
+		if (opts.outputJSON === true && opts.file) opts.jsonFile = opts.file.replace(/\.log$/, ".json.log");
+		const EggFileTransport = opts.buffer === true ? FileBufferTransport : FileTransport;
+		if (!opts.outputJSONOnly && opts.file) this.set("file", new EggFileTransport({
+			file: opts.file,
+			level: opts.level ?? "INFO",
+			encoding: opts.encoding,
+			formatter: opts.formatter,
+			contextFormatter: opts.contextFormatter,
+			paddingMessageFormatter: opts.paddingMessageFormatter,
+			flushInterval: opts.flushInterval,
+			eol: opts.eol,
+			localStorage: opts.localStorage,
+			dateISOFormat: opts.dateISOFormat,
+			maxCauseChainLength: opts.maxCauseChainLength
+		}));
+		if (opts.jsonFile) this.set("jsonFile", new EggFileTransport({
+			file: opts.jsonFile,
+			level: opts.level ?? "INFO",
+			encoding: opts.encoding,
+			flushInterval: opts.flushInterval,
+			json: true,
+			eol: opts.eol,
+			localStorage: opts.localStorage,
+			dateISOFormat: opts.dateISOFormat,
+			maxCauseChainLength: opts.maxCauseChainLength
+		}));
+		this.set("console", new ConsoleTransport({
+			level: opts.consoleLevel ?? "NONE",
+			formatter: consoleFormatter,
+			contextFormatter: opts.contextFormatter,
+			paddingMessageFormatter: opts.paddingMessageFormatter,
+			eol: opts.eol,
+			localStorage: opts.localStorage,
+			dateISOFormat: opts.dateISOFormat,
+			maxCauseChainLength: opts.maxCauseChainLength
+		}));
+	}
+	get level() {
+		return this.opts.level;
+	}
+	set level(level) {
+		this.opts.level = level;
+		for (const transport of this.values()) {
+			if (transport instanceof ConsoleTransport) continue;
+			transport.level = level;
+		}
+	}
+	get consoleLevel() {
+		return this.opts.consoleLevel;
+	}
+	set consoleLevel(level) {
+		this.opts.consoleLevel = level;
+		for (const transport of this.values()) if (transport instanceof ConsoleTransport) transport.level = level;
+	}
+	get defaults() {
+		return {
+			file: null,
+			encoding: "utf8",
+			level: "INFO",
+			consoleLevel: "NONE",
+			formatter: defaultFormatter,
+			buffer: true,
+			outputJSON: false,
+			outputJSONOnly: false,
+			dateISOFormat: false,
+			jsonFile: "",
+			maxCauseChainLength: 10
+		};
+	}
+};
+
+//#endregion
+export { EggLogger };

package/dist/egg/loggers.d.ts

@@ -0,0 +1,18 @@
+import { EggLoggersConfig } from "../utils.js";
+import { Logger } from "../logger.js";
+
+//#region src/egg/loggers.d.ts
+
+/**
+* Logger Manager - creates and manages multiple loggers based on configuration.
+*/
+declare class EggLoggers extends Map<string, Logger> {
+  [key: string]: unknown;
+  constructor(config: EggLoggersConfig);
+  set(name: string, logger: Logger): this;
+  disableConsole(): void;
+  reload(): void;
+  setConcentrateError(name: string, logger: Logger): void;
+}
+//#endregion
+export { EggLoggers };

package/dist/egg/loggers.js

@@ -0,0 +1,98 @@
+import { assign } from "../utils.js";
+import { EggLogger } from "./logger.js";
+import { EggErrorLogger } from "./error_logger.js";
+import { EggCustomLogger } from "./custom_logger.js";
+import { debuglog } from "node:util";
+import assert from "node:assert";
+
+//#region src/egg/loggers.ts
+const debug = debuglog("egg:logger");
+const defaults = {
+	env: "default",
+	type: "",
+	dir: "",
+	encoding: "utf8",
+	level: "INFO",
+	outputJSON: false,
+	outputJSONOnly: false,
+	buffer: true,
+	appLogName: "",
+	coreLogName: "",
+	agentLogName: "",
+	errorLogName: "",
+	concentrateError: "duplicate",
+	concentrateErrorLoggerName: "errorLogger"
+};
+/**
+* Logger Manager - creates and manages multiple loggers based on configuration.
+*/
+var EggLoggers = class extends Map {
+	constructor(config) {
+		super();
+		const loggerConfig = assign({}, defaults, config.logger);
+		if (loggerConfig.consoleLevel === void 0) {
+			const env = loggerConfig.env ?? "default";
+			loggerConfig.consoleLevel = env === "local" || env === "unittest" ? "INFO" : "NONE";
+		}
+		const customLoggerConfig = config.customLogger ?? {};
+		debug("Init loggers with options %j", loggerConfig);
+		assert(loggerConfig.type, "should pass config.logger.type");
+		assert(loggerConfig.dir, "should pass config.logger.dir");
+		assert(loggerConfig.appLogName, "should pass config.logger.appLogName");
+		assert(loggerConfig.coreLogName, "should pass config.logger.coreLogName");
+		assert(loggerConfig.agentLogName, "should pass config.logger.agentLogName");
+		assert(loggerConfig.errorLogName, "should pass config.logger.errorLogName");
+		const errorLogger = new EggErrorLogger(assign({}, loggerConfig, { file: loggerConfig.errorLogName }));
+		this.set("errorLogger", errorLogger);
+		let coreLogger;
+		let logger;
+		if (loggerConfig.type === "agent") {
+			logger = new EggLogger(assign({}, loggerConfig, { file: loggerConfig.agentLogName }));
+			coreLogger = new EggLogger(assign({}, loggerConfig, loggerConfig.coreLogger, { file: loggerConfig.agentLogName }));
+		} else {
+			logger = new EggLogger(assign({}, loggerConfig, { file: loggerConfig.appLogName }));
+			coreLogger = new EggLogger(assign({}, loggerConfig, loggerConfig.coreLogger, { file: loggerConfig.coreLogName }));
+		}
+		this.set("logger", logger);
+		this.set("coreLogger", coreLogger);
+		for (const name in customLoggerConfig) {
+			const customLogger = new EggCustomLogger(assign({}, loggerConfig, customLoggerConfig[name]));
+			this.set(name, customLogger);
+		}
+		this.setConcentrateError("logger", logger);
+		this.setConcentrateError("coreLogger", coreLogger);
+		for (const name in customLoggerConfig) this.setConcentrateError(name, this.get(name));
+	}
+	set(name, logger) {
+		if (this.has(name)) return this;
+		this[name] = logger;
+		super.set(name, logger);
+		return this;
+	}
+	disableConsole() {
+		for (const logger of this.values()) logger.disable("console");
+	}
+	reload() {
+		for (const logger of this.values()) logger.reload();
+	}
+	setConcentrateError(name, logger) {
+		if (name === "errorLogger") return;
+		const opts = logger.opts;
+		const concentrateLoggerName = opts.concentrateErrorLoggerName ?? "errorLogger";
+		const concentrateLogger = this.get(concentrateLoggerName);
+		if (!concentrateLogger) return;
+		switch (opts.concentrateError) {
+			case "duplicate":
+				logger.duplicate("ERROR", concentrateLogger, { excludes: ["console"] });
+				break;
+			case "redirect":
+				logger.redirect("ERROR", concentrateLogger);
+				break;
+			case "ignore": break;
+			default: break;
+		}
+	}
+};
+
+//#endregion
+export { EggLoggers };

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { ALL, DEBUG, ERROR, INFO, LoggerLevel, NONE, WARN, levels } from "./level.js";
+import { ConsoleTransportOptions, EggConsoleLoggerOptions, EggLoggerOptions, EggLoggersConfig, EggLoggersOptions, FileTransportOptions, LoggerMeta, TransportOptions, consoleFormatter, defaultContextPaddingMessage, defaultFormatter, formatError } from "./utils.js";
+import { Transport } from "./transports/transport.js";
+import { Logger } from "./logger.js";
+import { EggConsoleLogger } from "./egg/console_logger.js";
+import { EggLogger } from "./egg/logger.js";
+import { EggCustomLogger } from "./egg/custom_logger.js";
+import { EggErrorLogger } from "./egg/error_logger.js";
+import { EggLoggers } from "./egg/loggers.js";
+import { ConsoleTransport } from "./transports/console.js";
+import { FileTransport } from "./transports/file.js";
+import { FileBufferTransport } from "./transports/file_buffer.js";
+export { ALL, ConsoleTransport, type ConsoleTransportOptions, DEBUG, ERROR, EggConsoleLogger, type EggConsoleLoggerOptions, EggCustomLogger, EggErrorLogger, EggLogger, type EggLoggerOptions, EggLoggers, type EggLoggersConfig, type EggLoggersOptions, FileBufferTransport, FileTransport, type FileTransportOptions, INFO, Logger, type LoggerLevel, type LoggerMeta, NONE, Transport, type TransportOptions, WARN, consoleFormatter, defaultContextPaddingMessage, defaultFormatter, formatError, levels };

package/dist/index.js

@@ -0,0 +1,14 @@
+import { ALL, DEBUG, ERROR, INFO, NONE, WARN, levels } from "./level.js";
+import { Logger } from "./logger.js";
+import { consoleFormatter, defaultContextPaddingMessage, defaultFormatter, formatError } from "./utils.js";
+import { Transport } from "./transports/transport.js";
+import { ConsoleTransport } from "./transports/console.js";
+import { FileTransport } from "./transports/file.js";
+import { FileBufferTransport } from "./transports/file_buffer.js";
+import { EggLogger } from "./egg/logger.js";
+import { EggErrorLogger } from "./egg/error_logger.js";
+import { EggConsoleLogger } from "./egg/console_logger.js";
+import { EggCustomLogger } from "./egg/custom_logger.js";
+import { EggLoggers } from "./egg/loggers.js";
+
+export { ALL, ConsoleTransport, DEBUG, ERROR, EggConsoleLogger, EggCustomLogger, EggErrorLogger, EggLogger, EggLoggers, FileBufferTransport, FileTransport, INFO, Logger, NONE, Transport, WARN, consoleFormatter, defaultContextPaddingMessage, defaultFormatter, formatError, levels };

package/dist/level.d.ts

@@ -0,0 +1,15 @@
+//#region src/level.d.ts
+declare const ALL: number;
+/** Debug log for execute tracing */
+declare const DEBUG: number;
+/** Normal information logging */
+declare const INFO: number;
+/** Warning information logging */
+declare const WARN: number;
+/** Error or exception logging */
+declare const ERROR: number;
+declare const NONE: number;
+type LoggerLevel = "ALL" | "DEBUG" | "INFO" | "WARN" | "ERROR" | "NONE";
+declare const levels: Record<string, number>;
+//#endregion
+export { ALL, DEBUG, ERROR, INFO, LoggerLevel, NONE, WARN, levels };

package/dist/level.js

@@ -0,0 +1,22 @@
+//#region src/level.ts
+const ALL = -Infinity;
+/** Debug log for execute tracing */
+const DEBUG = 0;
+/** Normal information logging */
+const INFO = 1;
+/** Warning information logging */
+const WARN = 2;
+/** Error or exception logging */
+const ERROR = 3;
+const NONE = Infinity;
+const levels = {
+	ALL,
+	DEBUG,
+	INFO,
+	WARN,
+	ERROR,
+	NONE
+};
+
+//#endregion
+export { ALL, DEBUG, ERROR, INFO, NONE, WARN, levels };

package/dist/logger.d.ts

@@ -0,0 +1,41 @@
+import { LoggerMeta } from "./utils.js";
+import { Transport } from "./transports/transport.js";
+
+//#region src/logger.d.ts
+interface DuplicateLoggerEntry {
+  logger: Logger;
+  options: {
+    excludes?: string[];
+  };
+}
+/**
+* Base class for all Logger classes.
+* It extends Map and can contain multiple Transports.
+*/
+declare class Logger<T extends Transport = Transport> extends Map<string, T> {
+  options: Record<string, unknown>;
+  name: string;
+  redirectLoggers: Map<string, Logger>;
+  duplicateLoggers: Map<string, DuplicateLoggerEntry>;
+  constructor(options?: Record<string, unknown>);
+  disable(name: string): void;
+  enable(name: string): void;
+  log(level: string, args: unknown[], meta?: LoggerMeta): void;
+  write(msg: string, ...rest: unknown[]): void;
+  redirect(level: string, logger: Logger): void;
+  unredirect(level: string): void;
+  duplicate(level: string, logger: Logger, options?: {
+    excludes?: string[];
+  }): void;
+  unduplicate(level: string): void;
+  reload(): void;
+  close(): void;
+  /** @deprecated use close() instead */
+  end(): void;
+  error(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+}
+//#endregion
+export { DuplicateLoggerEntry, Logger };

package/dist/logger.js

@@ -0,0 +1,95 @@
+import util from "node:util";
+
+//#region src/logger.ts
+/**
+* Base class for all Logger classes.
+* It extends Map and can contain multiple Transports.
+*/
+var Logger = class Logger extends Map {
+	options;
+	name;
+	redirectLoggers;
+	duplicateLoggers;
+	constructor(options) {
+		super();
+		this.options = Object.assign({}, options);
+		this.name = this.constructor.name;
+		this.redirectLoggers = /* @__PURE__ */ new Map();
+		this.duplicateLoggers = /* @__PURE__ */ new Map();
+	}
+	disable(name) {
+		const transport = this.get(name);
+		if (transport) transport.disable();
+	}
+	enable(name) {
+		const transport = this.get(name);
+		if (transport) transport.enable();
+	}
+	log(level, args, meta) {
+		let excludes;
+		const dupEntry = this.duplicateLoggers.get(level);
+		let dupLogger;
+		if (dupEntry) {
+			excludes = dupEntry.options.excludes;
+			dupLogger = dupEntry.logger;
+			dupLogger.log(level, args, meta);
+		} else {
+			const redirectLogger = this.redirectLoggers.get(level);
+			if (redirectLogger) {
+				redirectLogger.log(level, args, meta);
+				return;
+			}
+		}
+		for (const [key, transport] of this.entries()) if (transport.shouldLog(level) && !(excludes && excludes.includes(key))) transport.log(level, args, meta);
+	}
+	write(msg, ...rest) {
+		if (rest.length > 0) msg = util.format(msg, ...rest);
+		this.log("NONE", [msg], { raw: true });
+	}
+	redirect(level, logger) {
+		const lvl = level.toUpperCase();
+		if (!this.redirectLoggers.has(lvl) && logger instanceof Logger) this.redirectLoggers.set(lvl, logger);
+	}
+	unredirect(level) {
+		this.redirectLoggers.delete(level.toUpperCase());
+	}
+	duplicate(level, logger, options = {}) {
+		const lvl = level.toUpperCase();
+		if (!this.duplicateLoggers.has(lvl) && logger instanceof Logger) this.duplicateLoggers.set(lvl, {
+			logger,
+			options
+		});
+	}
+	unduplicate(level) {
+		this.duplicateLoggers.delete(level.toUpperCase());
+	}
+	reload() {
+		for (const transport of this.values()) transport.reload();
+	}
+	close() {
+		for (const transport of this.values()) transport.close();
+	}
+	/** @deprecated use close() instead */
+	end() {
+		process.emitWarning("logger.end() is deprecated, use logger.close()", {
+			type: "DeprecationWarning",
+			code: "DEP_EGG_LOGGER_END"
+		});
+		this.close();
+	}
+	error(...args) {
+		this.log("ERROR", args);
+	}
+	warn(...args) {
+		this.log("WARN", args);
+	}
+	info(...args) {
+		this.log("INFO", args);
+	}
+	debug(...args) {
+		this.log("DEBUG", args);
+	}
+};
+
+//#endregion
+export { Logger };

package/dist/transports/console.d.ts

@@ -0,0 +1,17 @@
+import { ConsoleTransportOptions, LoggerMeta } from "../utils.js";
+import { Transport } from "./transport.js";
+
+//#region src/transports/console.d.ts
+
+/**
+* Output log to console.
+* EGG_LOG env variable has the highest priority for log level.
+*/
+declare class ConsoleTransport extends Transport {
+  options: ConsoleTransportOptions;
+  constructor(options?: Partial<ConsoleTransportOptions>);
+  get defaults(): Partial<ConsoleTransportOptions>;
+  log(level: string, args: unknown[], meta?: LoggerMeta): string | Buffer;
+}
+//#endregion
+export { ConsoleTransport };

package/dist/transports/console.js

@@ -0,0 +1,31 @@
+import { levels } from "../level.js";
+import { normalizeLevel } from "../utils.js";
+import { Transport } from "./transport.js";
+
+//#region src/transports/console.ts
+/**
+* Output log to console.
+* EGG_LOG env variable has the highest priority for log level.
+*/
+var ConsoleTransport = class extends Transport {
+	constructor(options) {
+		super(options);
+		this.options.stderrLevel = normalizeLevel(this.options.stderrLevel);
+		if (process.env.EGG_LOG) this.options.level = normalizeLevel(process.env.EGG_LOG);
+	}
+	get defaults() {
+		return {
+			...super.defaults,
+			stderrLevel: "ERROR"
+		};
+	}
+	log(level, args, meta) {
+		const msg = super.log(level, args, meta);
+		if (levels[level] >= this.options.stderrLevel && levels[level] < levels["NONE"]) process.stderr.write(msg);
+		else process.stdout.write(msg);
+		return msg;
+	}
+};
+
+//#endregion
+export { ConsoleTransport };

package/dist/transports/file.d.ts

@@ -0,0 +1,26 @@
+import { FileTransportOptions, LoggerMeta } from "../utils.js";
+import { Transport } from "./transport.js";
+import fs from "node:fs";
+
+//#region src/transports/file.d.ts
+type WriteStream = fs.WriteStream & {
+  _onError?: (err: Error) => void;
+};
+/**
+* Output log to file.
+*/
+declare class FileTransport extends Transport {
+  options: FileTransportOptions;
+  _stream: WriteStream | null;
+  constructor(options?: Partial<FileTransportOptions>);
+  get defaults(): Partial<FileTransportOptions>;
+  reload(): void;
+  log(level: string, args: unknown[], meta?: LoggerMeta): string | Buffer;
+  close(): void;
+  get writable(): boolean;
+  _write(buf: string | Buffer): void;
+  _createStream(): WriteStream;
+  _closeStream(): void;
+}
+//#endregion
+export { FileTransport };

package/dist/transports/file.js

@@ -0,0 +1,71 @@
+import "../utils.js";
+import { Transport } from "./transport.js";
+import { logDate } from "utility";
+import assert from "node:assert";
+import fs from "node:fs";
+import path from "node:path";
+
+//#region src/transports/file.ts
+/**
+* Output log to file.
+*/
+var FileTransport = class extends Transport {
+	constructor(options) {
+		super(options);
+		assert(this.options.file, "should pass options.file");
+		this._stream = null;
+		this.reload();
+	}
+	get defaults() {
+		return {
+			...super.defaults,
+			file: null,
+			level: "INFO"
+		};
+	}
+	reload() {
+		this._closeStream();
+		this._stream = this._createStream();
+	}
+	log(level, args, meta) {
+		if (!this.writable) {
+			const err = /* @__PURE__ */ new Error(`${this.options.file} log stream had been closed`);
+			console.error(err.stack);
+			return "";
+		}
+		const buf = super.log(level, args, meta);
+		if (buf.length) this._write(buf);
+		return buf;
+	}
+	close() {
+		this._closeStream();
+	}
+	get writable() {
+		return !!(this._stream && !this._stream.closed && this._stream.writable && !this._stream.destroyed);
+	}
+	_write(buf) {
+		this._stream.write(buf);
+	}
+	_createStream() {
+		fs.mkdirSync(path.dirname(this.options.file), { recursive: true });
+		const stream = fs.createWriteStream(this.options.file, { flags: "a" });
+		const onError = (err) => {
+			console.error("%s ERROR %s [egg-logger] [%s] %s", logDate(","), process.pid, this.options.file, err.stack);
+			this.reload();
+			console.warn("%s WARN %s [egg-logger] [%s] reloaded", logDate(","), process.pid, this.options.file);
+		};
+		stream.once("error", onError);
+		stream._onError = onError;
+		return stream;
+	}
+	_closeStream() {
+		if (this._stream) {
+			this._stream.end();
+			if (this._stream._onError) this._stream.removeListener("error", this._stream._onError);
+			this._stream = null;
+		}
+	}
+};
+
+//#endregion
+export { FileTransport };

package/dist/transports/file_buffer.d.ts

@@ -0,0 +1,23 @@
+import { FileTransportOptions } from "../utils.js";
+import { FileTransport } from "./file.js";
+
+//#region src/transports/file_buffer.d.ts
+
+/**
+* Extends FileTransport, saves log in memory and flushes to file at intervals.
+*/
+declare class FileBufferTransport extends FileTransport {
+  _bufSize: number;
+  _buf: Array<string | Buffer>;
+  _timer: ReturnType<typeof setInterval> | null;
+  constructor(options?: Partial<FileTransportOptions>);
+  get defaults(): Partial<FileTransportOptions>;
+  close(): void;
+  flush(): void;
+  _closeStream(): void;
+  _write(buf: string | Buffer): void;
+  _createInterval(): ReturnType<typeof setInterval>;
+  _closeInterval(): void;
+}
+//#endregion
+export { FileBufferTransport };

package/dist/transports/file_buffer.js

@@ -0,0 +1,57 @@
+import "../utils.js";
+import { FileTransport } from "./file.js";
+
+//#region src/transports/file_buffer.ts
+/**
+* Extends FileTransport, saves log in memory and flushes to file at intervals.
+*/
+var FileBufferTransport = class extends FileTransport {
+	constructor(options) {
+		super(options);
+		this._bufSize = 0;
+		this._buf = [];
+		this._timer = this._createInterval();
+	}
+	get defaults() {
+		return {
+			...super.defaults,
+			flushInterval: 1e3,
+			maxBufferLength: 1e3
+		};
+	}
+	close() {
+		this._closeInterval();
+		super.close();
+	}
+	flush() {
+		if (this._buf.length > 0 && this.writable) {
+			if (this.options.encoding === "utf8") this._stream.write(this._buf.join(""));
+			else this._stream.write(Buffer.concat(this._buf, this._bufSize));
+			this._buf = [];
+			this._bufSize = 0;
+		}
+	}
+	_closeStream() {
+		if (this._buf && this._buf.length > 0) this.flush();
+		super._closeStream();
+	}
+	_write(buf) {
+		this._bufSize += typeof buf === "string" ? Buffer.byteLength(buf) : buf.length;
+		this._buf.push(buf);
+		if (this._buf.length > (this.options.maxBufferLength ?? 1e3)) this.flush();
+	}
+	_createInterval() {
+		const timer = setInterval(() => this.flush(), this.options.flushInterval ?? 1e3);
+		timer.unref();
+		return timer;
+	}
+	_closeInterval() {
+		if (this._timer) {
+			clearInterval(this._timer);
+			this._timer = null;
+		}
+	}
+};
+
+//#endregion
+export { FileBufferTransport };

package/dist/transports/transport.d.ts

@@ -0,0 +1,28 @@
+import { LoggerLevel } from "../level.js";
+import { LoggerMeta, TransportOptions } from "../utils.js";
+
+//#region src/transports/transport.d.ts
+
+/**
+* Transport is an output channel of the log that can be output to a file,
+* console or service.
+* A Logger can configure multiple Transports to meet a variety of complex needs.
+*/
+declare class Transport {
+  #private;
+  options: TransportOptions;
+  constructor(options?: Partial<TransportOptions>);
+  get defaults(): Partial<TransportOptions>;
+  get enabled(): boolean;
+  enable(): void;
+  disable(): void;
+  set level(level: LoggerLevel | number);
+  get level(): number;
+  shouldLog(level: string): boolean;
+  log(level: string, args: unknown[], meta?: LoggerMeta): string | Buffer;
+  reload(): void;
+  close(): void;
+  end(): void;
+}
+//#endregion
+export { Transport, type TransportOptions };

package/dist/transports/transport.js

@@ -0,0 +1,67 @@
+import { levels } from "../level.js";
+import { assign, formatLog, normalizeLevel } from "../utils.js";
+import os from "node:os";
+
+//#region src/transports/transport.ts
+/**
+* Transport is an output channel of the log that can be output to a file,
+* console or service.
+* A Logger can configure multiple Transports to meet a variety of complex needs.
+*/
+var Transport = class {
+	options;
+	#enabled = true;
+	constructor(options) {
+		this.options = assign({}, this.defaults, options);
+		if (this.options.encoding === "utf-8") this.options.encoding = "utf8";
+		const normalizedLevel = normalizeLevel(this.options.level);
+		if (normalizedLevel !== void 0) this.options.level = normalizedLevel;
+	}
+	get defaults() {
+		return {
+			level: "NONE",
+			formatter: null,
+			contextFormatter: null,
+			json: false,
+			encoding: "utf8",
+			eol: os.EOL
+		};
+	}
+	get enabled() {
+		return this.#enabled;
+	}
+	enable() {
+		this.#enabled = true;
+	}
+	disable() {
+		this.#enabled = false;
+	}
+	set level(level) {
+		const normalized = normalizeLevel(level);
+		if (normalized !== void 0) this.options.level = normalized;
+	}
+	get level() {
+		return this.options.level;
+	}
+	shouldLog(level) {
+		if (!this.#enabled) return false;
+		if (this.options.level === levels["NONE"]) return false;
+		return this.options.level <= levels[level];
+	}
+	log(level, args, meta) {
+		if (!meta?.ctx && this.options.localStorage) {
+			const ctx = this.options.localStorage.getStore();
+			if (ctx) meta = {
+				...meta,
+				ctx
+			};
+		}
+		return formatLog(level, args, meta, this.options);
+	}
+	reload() {}
+	close() {}
+	end() {}
+};
+
+//#endregion
+export { Transport };

package/dist/utils.d.ts

@@ -0,0 +1,75 @@
+import { LoggerLevel } from "./level.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/utils.d.ts
+interface LoggerMeta {
+  level?: string;
+  date?: string;
+  pid?: number;
+  hostname?: string;
+  message?: string;
+  paddingMessage?: string;
+  ctx?: unknown;
+  raw?: boolean;
+  formatter?: (meta: LoggerMeta) => string;
+  [key: string]: unknown;
+}
+interface TransportOptions {
+  level?: LoggerLevel | number;
+  formatter?: ((meta: LoggerMeta) => string) | null;
+  contextFormatter?: ((meta: LoggerMeta) => string) | null;
+  paddingMessageFormatter?: ((ctx: unknown) => string) | null;
+  json?: boolean;
+  dateISOFormat?: boolean;
+  encoding?: string;
+  eol?: string;
+  localStorage?: AsyncLocalStorage<unknown>;
+  maxCauseChainLength?: number;
+}
+interface FileTransportOptions extends TransportOptions {
+  file?: string | null;
+  flushInterval?: number;
+  maxBufferLength?: number;
+}
+interface ConsoleTransportOptions extends TransportOptions {
+  stderrLevel?: LoggerLevel | number;
+}
+interface EggLoggerOptions extends Omit<TransportOptions, "level"> {
+  level?: LoggerLevel;
+  consoleLevel?: LoggerLevel;
+  file?: string | null;
+  dir?: string;
+  buffer?: boolean;
+  outputJSON?: boolean;
+  outputJSONOnly?: boolean;
+  jsonFile?: string;
+  concentrateError?: "duplicate" | "redirect" | "ignore";
+  concentrateErrorLoggerName?: string;
+  flushInterval?: number;
+  [key: string]: unknown;
+}
+interface EggLoggersOptions extends EggLoggerOptions {
+  type: string;
+  env?: string;
+  appLogName: string;
+  coreLogName: string;
+  agentLogName: string;
+  errorLogName: string;
+  coreLogger?: Partial<EggLoggersOptions>;
+}
+interface EggConsoleLoggerOptions extends TransportOptions {
+  env?: string;
+}
+interface EggLoggersConfig {
+  logger: EggLoggersOptions;
+  customLogger?: Record<string, EggLoggerOptions>;
+}
+declare function normalizeLevel(level?: LoggerLevel | number | string): number | undefined;
+declare function defaultContextPaddingMessage(ctx: Record<string, unknown>): string;
+declare function defaultFormatter(meta: LoggerMeta): string;
+declare function consoleFormatter(meta: LoggerMeta): string;
+declare function formatLog(level: string, args: unknown[], meta: LoggerMeta | undefined, options: TransportOptions): string | Buffer;
+declare function assign<T>(target: Partial<T>, ...sources: Array<Partial<T> | null | undefined>): T;
+declare function formatError(err: Error, options?: TransportOptions, causeLength?: number): string;
+//#endregion
+export { ConsoleTransportOptions, EggConsoleLoggerOptions, EggLoggerOptions, EggLoggersConfig, EggLoggersOptions, FileTransportOptions, LoggerMeta, TransportOptions, assign, consoleFormatter, defaultContextPaddingMessage, defaultFormatter, formatError, formatLog, normalizeLevel };

package/dist/utils.js

@@ -0,0 +1,146 @@
+import { levels } from "./level.js";
+import util from "node:util";
+import os from "node:os";
+import { performance } from "node:perf_hooks";
+import { FrameworkBaseError, FrameworkErrorFormatter } from "@eggjs/errors";
+import chalk from "chalk";
+import circularJSON from "circular-json-for-egg";
+import iconv from "iconv-lite";
+import { logDate } from "utility";
+
+//#region src/utils.ts
+const hostname = os.hostname();
+const durationRegexp = /\b(\d+ms)\b/g;
+const categoryRegexp = /(\[[\w\-_.:]+\])/g;
+const httpMethodRegexp = /(GET|POST|PUT|PATCH|HEAD|DELETE) /g;
+function normalizeLevel(level) {
+	if (typeof level === "number") return level;
+	if (typeof level === "string" && level) return levels[level.toUpperCase()];
+}
+function defaultContextPaddingMessage(ctx) {
+	const userId = ctx.userId || "-";
+	const traceId = ctx.tracer?.traceId || "-";
+	let use = 0;
+	if (ctx.performanceStarttime) use = Math.floor((performance.now() - ctx.performanceStarttime) * 1e3) / 1e3;
+	else if (ctx.starttime) use = Date.now() - ctx.starttime;
+	return "[" + userId + "/" + ctx.ip + "/" + traceId + "/" + use + "ms " + ctx.method + " " + ctx.url + "]";
+}
+function defaultFormatter(meta) {
+	let paddingMessage = " ";
+	if (meta.paddingMessage) paddingMessage = ` ${meta.paddingMessage} `;
+	else {
+		const ctx = meta.ctx;
+		if (ctx) paddingMessage = ` ${defaultContextPaddingMessage(ctx)} `;
+	}
+	return meta.date + " " + meta.level + " " + meta.pid + paddingMessage + meta.message;
+}
+function consoleFormatter(meta) {
+	let paddingMessage = " ";
+	if (meta.paddingMessage) paddingMessage = ` ${meta.paddingMessage} `;
+	let msg = meta.date + " " + meta.level + " " + meta.pid + paddingMessage + meta.message;
+	if (chalk.level === 0) return msg;
+	if (meta.level === "ERROR") return chalk.red(msg);
+	if (meta.level === "WARN") return chalk.yellow(msg);
+	msg = msg.replace(durationRegexp, chalk.green("$1"));
+	msg = msg.replace(categoryRegexp, chalk.blue("$1"));
+	msg = msg.replace(httpMethodRegexp, chalk.cyan("$1 "));
+	return msg;
+}
+function formatLog(level, args, meta, options) {
+	meta = meta ?? {};
+	let message;
+	let output;
+	let formatter = meta.formatter ?? options.formatter;
+	if (meta.ctx) {
+		if (options.contextFormatter) {
+			formatter = options.contextFormatter;
+			if (!meta.paddingMessage) meta.paddingMessage = options.paddingMessageFormatter ? options.paddingMessageFormatter(meta.ctx) : defaultContextPaddingMessage(meta.ctx);
+		} else if (options.paddingMessageFormatter && !meta.paddingMessage) meta.paddingMessage = options.paddingMessageFormatter(meta.ctx);
+	}
+	if (args[0] instanceof Error) message = formatError(args[0], options);
+	else message = util.format(...args);
+	if (meta.raw === true) output = message;
+	else if (options.json === true || formatter) {
+		meta.level = level;
+		meta.date = options.dateISOFormat ? (/* @__PURE__ */ new Date()).toISOString() : logDate(",");
+		meta.pid = process.pid;
+		meta.hostname = hostname;
+		meta.message = message;
+		if (options.json === true) {
+			const outputMeta = {
+				...meta,
+				ctx: void 0
+			};
+			output = JSON.stringify(outputMeta);
+		} else output = formatter(meta);
+	} else output = message;
+	if (!output) return Buffer.from("");
+	output += options.eol;
+	return options.encoding === "utf8" ? output : iconv.encode(output, options.encoding);
+}
+function assign(target, ...sources) {
+	const t = target;
+	for (const source of sources) {
+		if (source == null) continue;
+		const s = source;
+		for (const key of Object.keys(s)) {
+			const val = s[key];
+			if (val !== void 0) t[key] = val;
+		}
+	}
+	return target;
+}
+function formatError(err, options, causeLength) {
+	if (FrameworkBaseError.isFrameworkError(err)) return FrameworkErrorFormatter.format(err);
+	const msg = errorToString(err, options, causeLength);
+	return util.format("%s\npid: %s\nhostname: %s\n", msg, process.pid, hostname);
+}
+function errorToString(err, options, causeLength = 0) {
+	if (causeLength > (options?.maxCauseChainLength ?? 10)) return "too long cause chain";
+	const e = err;
+	let errName = e.name || "no_name";
+	if (e.name === "Error" && typeof e.code === "string") errName = e.code + errName;
+	let errMessage = e.message || "no_message";
+	if (e.host) errMessage += ` (${e.host})`;
+	const errStack = e.stack || "no_stack";
+	const errProperties = Object.keys(e).map((key) => inspectProp(key, e[key])).join("\n");
+	let errorString = util.format("nodejs.%s: %s\n%s\n%s", errName, errMessage, errStack.substring(errStack.indexOf("\n") + 1), errProperties);
+	if (e.name === "AggregateError" && e.errors) for (let i = 0; i < e.errors.length; i++) {
+		const subErrorMsg = errorToString(e.errors[i], options, causeLength + 1);
+		errorString = util.format("%s\n[error-%d]:\n\n%s", errorString, i, subErrorMsg);
+	}
+	if (e.cause) {
+		const causeMsg = errorToString(e.cause, options, causeLength + 1);
+		errorString = util.format("%s\ncause:\n\n%s", errorString, causeMsg);
+	}
+	return errorString;
+}
+function inspectProp(key, value) {
+	return `${key}: ${formatObject(value)}`;
+}
+function formatString(str) {
+	if (str.length > 1e4) return `${str.substring(0, 1e4)}...(${str.length})`;
+	return str;
+}
+function formatBuffer(buf) {
+	const tail = buf.data.length > 50 ? ` ...(${buf.data.length}) ` : "";
+	return `<Buffer ${buf.data.slice(0, 50).map((i) => {
+		const hex = i.toString(16);
+		return hex.length === 1 ? `0${hex}` : hex;
+	}).join(" ")}${tail}>`;
+}
+function formatObject(obj) {
+	try {
+		return circularJSON.stringify(obj, (_key, v) => {
+			if (typeof v === "string") return formatString(v);
+			if (v && v.type === "Buffer" && Array.isArray(v.data)) return formatBuffer(v);
+			if (v instanceof RegExp) return util.inspect(v);
+			return v;
+		});
+	} catch {
+		return String(obj);
+	}
+}
+
+//#endregion
+export { assign, consoleFormatter, defaultContextPaddingMessage, defaultFormatter, formatError, formatLog, normalizeLevel };

package/dist/vendor.d.ts

@@ -0,0 +1,8 @@
+//#region src/vendor.d.ts
+declare module 'circular-json-for-egg' {
+  const circularJSON: {
+    stringify(obj: unknown, replacer?: (key: string, value: unknown) => unknown, space?: string | number): string;
+    parse(text: string): unknown;
+  };
+  export default circularJSON;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/logger",
-  "version": "0.0.0",
+  "version": "4.0.1-beta.0",
   "description": "egg logger",
   "keywords": [
     "egg",
@@ -17,15 +17,59 @@
     "url": "git+https://github.com/eggjs/egg.git",
     "directory": "packages/logger"
   },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./egg/console_logger": "./dist/egg/console_logger.js",
+    "./egg/custom_logger": "./dist/egg/custom_logger.js",
+    "./egg/error_logger": "./dist/egg/error_logger.js",
+    "./egg/logger": "./dist/egg/logger.js",
+    "./egg/loggers": "./dist/egg/loggers.js",
+    "./level": "./dist/level.js",
+    "./logger": "./dist/logger.js",
+    "./transports/console": "./dist/transports/console.js",
+    "./transports/file": "./dist/transports/file.js",
+    "./transports/file_buffer": "./dist/transports/file_buffer.js",
+    "./transports/transport": "./dist/transports/transport.js",
+    "./utils": "./dist/utils.js",
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
+    "chalk": "^5.4.1",
+    "circular-json-for-egg": "^1.0.0",
+    "iconv-lite": "^0.6.3",
+    "utility": "^2.5.0",
+    "@eggjs/errors": "3.0.1-beta.0"
   },
   "devDependencies": {
+    "@types/node": "^24.10.2",
+    "coffee": "5",
+    "mm": "^4.0.2",
+    "oxlint": "^1.32.0",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15",
+    "@eggjs/supertest": "9.0.1-beta.0",
+    "@eggjs/koa": "3.1.1-beta.0",
+    "@eggjs/tsconfig": "3.1.1-beta.0"
   },
   "engines": {
     "node": ">= 22.18.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rimraf dist",
+    "lint": "oxlint --type-aware",
+    "typecheck": "tsgo --noEmit",
+    "test": "vitest run"
   }
-}
-
+}