@hg-ts/logger 0.7.27 → 0.8.1

package/dist/nest-wrapped.logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nest-wrapped.logger.d.ts","sourceRoot":"","sources":["../src/nest-wrapped.logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAGN,aAAa,EACb,YAAY,EACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,qBAAa,iBAAkB,YAAW,aAAa,EAAE,YAAY;IAEpE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAE3B,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAK1C,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAK1D,GAAG,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAKxC,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAK5C,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAMnC,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ1C,OAAO,CAAC,kBAAkB;CAG1B"}
+{"version":3,"file":"nest-wrapped.logger.d.ts","sourceRoot":"","sources":["../src/nest-wrapped.logger.ts"],"names":[],"mappings":"AACA,OAAO,EAGN,aAAa,EACb,YAAY,EACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,qBAAa,iBAAkB,YAAW,aAAa,EAAE,YAAY;IAEpE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAE3B,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAK1C,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAe1D,GAAG,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAKxC,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAK5C,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAMnC,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ1C,OAAO,CAAC,kBAAkB;CAG1B"}

package/dist/nest-wrapped.logger.js

@@ -1,27 +1,36 @@
 import { __decorate, __metadata } from "tslib";
+import { BaseException } from '@hg-ts/exception';
 import { Inject, Logger as NestLogger, } from '@nestjs/common';
 import { Logger } from './logger/index.js';
 export class NestWrappedLogger {
     logger;
     debug(message, context) {
         this.setOptionalContext(context);
-        this.logger.debug(message);
+        this.logger.debug(String(message));
     }
     error(message, trace, context) {
-        this.setOptionalContext(context);
-        this.logger.error(message, trace);
+        if (message instanceof Error) {
+            this.setOptionalContext(context);
+            const exception = message instanceof BaseException
+                ? message
+                : BaseException.fromError(message);
+            this.logger.error(exception, trace ?? message.message);
+            return;
+        }
+        this.setOptionalContext(trace);
+        this.logger.error(String(message));
     }
     log(message, context) {
         this.setOptionalContext(context);
-        this.logger.info(message);
+        this.logger.info(String(message));
     }
     verbose(message, context) {
         this.setOptionalContext(context);
-        this.logger.notice(message);
+        this.logger.notice(String(message));
     }
     warn(message, context) {
         this.setOptionalContext(context);
-        this.logger.warning(message);
+        this.logger.warning(String(message));
     }
     async onModuleInit() {
         this.logger.setContext(null);

package/dist/nest-wrapped.logger.js.map

@@ -1 +1 @@
-{"version":3,"file":"nest-wrapped.logger.js","sourceRoot":"","sources":["../src/nest-wrapped.logger.ts"],"names":[],"mappings":";AAAA,OAAO,EACN,MAAM,EACN,MAAM,IAAI,UAAU,GAGpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,MAAM,OAAO,iBAAiB;IAEV,MAAM,CAAS;IAE3B,KAAK,CAAC,OAAY,EAAE,OAAgB;QAC1C,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC5B,CAAC;IAEM,KAAK,CAAC,OAAY,EAAE,KAAc,EAAE,OAAgB;QAC1D,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IAEM,GAAG,CAAC,OAAY,EAAE,OAAgB;QACxC,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAEM,OAAO,CAAC,OAAY,EAAE,OAAgB;QAC5C,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAEM,IAAI,CAAC,OAAY,EAAE,OAAgB;QACzC,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9B,CAAC;IAGM,KAAK,CAAC,YAAY;QACxB,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC7B,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAChC,UAAU,CAAC,cAAc,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QACxE,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAChC,UAAU,CAAC,KAAK,EAAE,CAAC;IACpB,CAAC;IAEO,kBAAkB,CAAC,UAA4B,IAAI;QAC1D,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;CACD;AAvCmB;IADlB,MAAM,EAAE;8BACkB,MAAM;iDAAC"}
+{"version":3,"file":"nest-wrapped.logger.js","sourceRoot":"","sources":["../src/nest-wrapped.logger.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EACN,MAAM,EACN,MAAM,IAAI,UAAU,GAGpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,MAAM,OAAO,iBAAiB;IAEV,MAAM,CAAS;IAE3B,KAAK,CAAC,OAAY,EAAE,OAAgB;QAC1C,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACpC,CAAC;IAEM,KAAK,CAAC,OAAY,EAAE,KAAc,EAAE,OAAgB;QAC1D,IAAI,OAAO,YAAY,KAAK,EAAE,CAAC;YAC9B,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;YACjC,MAAM,SAAS,GAAG,OAAO,YAAY,aAAa;gBACjD,CAAC,CAAC,OAAO;gBACT,CAAC,CAAC,aAAa,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;YAEpC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;YACvD,OAAO;QACR,CAAC;QAED,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;QAC/B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACpC,CAAC;IAEM,GAAG,CAAC,OAAY,EAAE,OAAgB;QACxC,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACnC,CAAC;IAEM,OAAO,CAAC,OAAY,EAAE,OAAgB;QAC5C,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACrC,CAAC;IAEM,IAAI,CAAC,OAAY,EAAE,OAAgB;QACzC,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACtC,CAAC;IAGM,KAAK,CAAC,YAAY;QACxB,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC7B,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAChC,UAAU,CAAC,cAAc,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QACxE,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAChC,UAAU,CAAC,KAAK,EAAE,CAAC;IACpB,CAAC;IAEO,kBAAkB,CAAC,UAA4B,IAAI;QAC1D,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;CACD;AAjDmB;IADlB,MAAM,EAAE;8BACkB,MAAM;iDAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hg-ts/logger",
-  "version": "0.7.27",
+  "version": "0.8.1",
   "main": "dist/index.js",
   "type": "module",
   "exports": {
@@ -13,27 +13,33 @@
     "build": "tsc",
     "build:dev": "tsc-watch",
     "lint:ts": "lint-ts",
-    "lint:ts:fix": "lint-ts --fix"
+    "lint:ts:fix": "lint-ts --fix",
+    "test": "vitest run",
+    "test:dev": "vitest watch"
   },
   "devDependencies": {
-    "@hg-ts-config/typescript": "0.7.27",
-    "@hg-ts/async-context": "0.7.27",
-    "@hg-ts/execution-mode": "0.7.27",
-    "@hg-ts/linter": "0.7.27",
-    "@hg-ts/types": "0.7.27",
+    "@hg-ts-config/typescript": "0.8.1",
+    "@hg-ts/async-context": "0.8.1",
+    "@hg-ts/execution-mode": "0.8.1",
+    "@hg-ts/linter": "0.8.1",
+    "@hg-ts/tests": "0.8.1",
+    "@hg-ts/types": "0.8.1",
     "@nestjs/common": "11.1.0",
     "@nestjs/core": "11.1.0",
     "@types/node": "22.19.1",
     "@types/triple-beam": "1.3.5",
+    "@vitest/coverage-v8": "4.0.14",
     "eslint": "9.18.0",
     "reflect-metadata": "0.2.2",
     "rxjs": "7.8.1",
     "tsc-watch": "6.3.0",
     "tslib": "2.8.1",
-    "typescript": "5.7.3"
+    "typescript": "5.7.3",
+    "vitest": "4.0.14"
   },
   "peerDependencies": {
     "@hg-ts/async-context": "*",
+    "@hg-ts/exception": "*",
     "@hg-ts/execution-mode": "*",
     "@hg-ts/types": "*",
     "@nestjs/common": "*",
@@ -43,6 +49,7 @@
     "tslib": "*"
   },
   "dependencies": {
+    "@hg-ts/exception": "0.8.1",
     "triple-beam": "1.4.1",
     "winston": "3.17.0",
     "winston-syslog": "2.7.1"

package/src/index.ts

@@ -3,6 +3,9 @@ export {
 	ConsoleLogger,
 	JSONLogger,
 	MockLogger,
+	type InlineMeta,
+	type InlineMetaValue,
+	type LogMeta,
 } from './logger/index.js';
 export * from './logger.module.js';
 export * from './trace.context.js';

package/src/logger/base.formatter.ts

@@ -1,4 +1,8 @@
 import * as assert from 'node:assert';
+import {
+	BaseException,
+	type JSONBaseException,
+} from '@hg-ts/exception';
 import winston from 'winston';
 import {
 	LogLevel,
@@ -9,21 +13,43 @@ export type LogMessage = winston.Logform.TransformableInfo & {
 	context: Nullable<string>;
 	message: string;
 	level: LogLevel;
+	meta?: Record<string, unknown>;
+	error?: JSONBaseException;
+	traceId?: string;
 	process: {
 		pid: number;
 		title: Nullable<string>;
 	};
 	timestamp: Date;
-	items: unknown[];
 };
 
+function serializeMeta(meta: unknown): Nullable<Record<string, unknown>> {
+	if (!meta || typeof meta !== 'object' || Array.isArray(meta)) {
+		return null;
+	}
+
+	return meta as Record<string, unknown>;
+}
+
+function serializeError(error: unknown): Nullable<JSONBaseException> {
+	if (!(error instanceof BaseException)) {
+		return null;
+	}
+
+	return error.toJSON();
+}
+
 function getLogData(info: winston.Logform.TransformableInfo): LogMessage {
 	const level = syslogToLoggerMap.get(info.level) ?? info.level as LogLevel;
 	const context = info['context'] ?? null;
+	const meta = serializeMeta(info['meta']);
+	const error = serializeError(info['error']);
+	const { traceId } = info;
 
 	assert.ok(typeof context === 'string' || context === null);
+	assert.ok(typeof traceId === 'string' || typeof traceId === 'undefined');
 
-	return {
+	const logData: LogMessage = {
 		level,
 		context,
 		process: {
@@ -31,32 +57,25 @@ function getLogData(info: winston.Logform.TransformableInfo): LogMessage {
 			title: process.title.endsWith('node') ? null : process.title,
 		},
 		message: info.message as string,
-		items: Array.isArray(info['items']) ? info['items'] : [info['items']],
 		timestamp: new Date(),
 	};
-}
 
-export const baseFormatter = winston.format(info => {
-	const logData = getLogData(info);
-
-	logData['items'] = logData.items
-		.map(item => {
-			if (typeof item === 'bigint') {
-				return `${item}n`;
-			}
-
-			if (item instanceof Error && !('toJSON' in item)) {
-				return {
-					name: item.name,
-					message: item.message,
-					stack: item.stack,
-				};
-			}
-
-			return item;
-		});
+	if (meta) {
+		logData.meta = meta;
+	}
+
+	if (error) {
+		logData.error = error;
+	}
+
+	if (traceId) {
+		logData.traceId = traceId;
+	}
+
 	return logData;
-});
+}
+
+export const baseFormatter = winston.format(info => getLogData(info));
 
 export function createFormatter(formatter: (info: LogMessage) => LogMessage): winston.Logform.FormatWrap {
 	return winston.format(formatter as any);

package/src/logger/base.logger.ts

@@ -1,10 +1,27 @@
-import { format } from 'node:util';
+import { BaseException } from '@hg-ts/exception';
 import winston from 'winston';
 import { TraceContext } from '../trace.context.js';
 
-import { Logger } from './logger.js';
+import {
+	InlineMeta,
+	InlineMetaPrimitive,
+	Logger,
+	LogMeta,
+} from './logger.js';
 
 type Transport = winston.Logger['add'] extends (transport: infer R) => void ? R : never;
+type LogOptions = {
+	error?: BaseException;
+	meta: Optional<LogMeta>;
+	inlineMeta: Optional<InlineMeta>;
+};
+type ErrorLogOptions = {
+	errorOrMessage: BaseException | string;
+	messageOrMeta: Optional<string | LogMeta>;
+	metaOrInlineMeta: Optional<LogMeta | InlineMeta>;
+	inlineMeta: Optional<InlineMeta>;
+};
+type NormalizedLogPayload = LogOptions & { message: string };
 
 export type LogLevel = keyof Omit<Logger, 'setContext'>;
 
@@ -36,29 +53,103 @@ export abstract class BaseLogger implements Logger {
 		});
 	}
 
-	public debug(...messages: unknown[]): void {
-		this.log('debug', messages);
+	public debug(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void {
+		this.log('debug', message, {
+			meta,
+			inlineMeta,
+		});
 	}
-	public info(...messages: unknown[]): void {
-		this.log('info', messages);
+	public info(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void {
+		this.log('info', message, {
+			meta,
+			inlineMeta,
+		});
 	}
-	public notice(...messages: unknown[]): void {
-		this.log('notice', messages);
+	public notice(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void {
+		this.log('notice', message, {
+			meta,
+			inlineMeta,
+		});
 	}
-	public warning(...messages: unknown[]): void {
-		this.log('warning', messages);
+	public warning(error: BaseException, message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public warning(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	// eslint-disable-next-line max-params
+	public warning(
+		errorOrMessage: BaseException | string,
+		messageOrMeta?: string | LogMeta,
+		metaOrInlineMeta?: LogMeta | InlineMeta,
+		inlineMeta?: InlineMeta,
+	): void {
+		this.logErrorLevel('warning', {
+			errorOrMessage,
+			messageOrMeta,
+			metaOrInlineMeta,
+			inlineMeta,
+		});
 	}
-	public error(...messages: unknown[]): void {
-		this.log('error', messages);
+	public error(error: BaseException, message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public error(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	// eslint-disable-next-line max-params
+	public error(
+		errorOrMessage: BaseException | string,
+		messageOrMeta?: string | LogMeta,
+		metaOrInlineMeta?: LogMeta | InlineMeta,
+		inlineMeta?: InlineMeta,
+	): void {
+		this.logErrorLevel('error', {
+			errorOrMessage,
+			messageOrMeta,
+			metaOrInlineMeta,
+			inlineMeta,
+		});
 	}
-	public critical(...messages: unknown[]): void {
-		this.log('critical', messages);
+	public critical(error: BaseException, message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public critical(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	// eslint-disable-next-line max-params
+	public critical(
+		errorOrMessage: BaseException | string,
+		messageOrMeta?: string | LogMeta,
+		metaOrInlineMeta?: LogMeta | InlineMeta,
+		inlineMeta?: InlineMeta,
+	): void {
+		this.logErrorLevel('critical', {
+			errorOrMessage,
+			messageOrMeta,
+			metaOrInlineMeta,
+			inlineMeta,
+		});
 	}
-	public alert(...messages: unknown[]): void {
-		this.log('alert', messages);
+	public alert(error: BaseException, message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public alert(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	// eslint-disable-next-line max-params
+	public alert(
+		errorOrMessage: BaseException | string,
+		messageOrMeta?: string | LogMeta,
+		metaOrInlineMeta?: LogMeta | InlineMeta,
+		inlineMeta?: InlineMeta,
+	): void {
+		this.logErrorLevel('alert', {
+			errorOrMessage,
+			messageOrMeta,
+			metaOrInlineMeta,
+			inlineMeta,
+		});
 	}
-	public emergency(...messages: unknown[]): void {
-		this.log('emergency', messages);
+	public emergency(error: BaseException, message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public emergency(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	// eslint-disable-next-line max-params
+	public emergency(
+		errorOrMessage: BaseException | string,
+		messageOrMeta?: string | LogMeta,
+		metaOrInlineMeta?: LogMeta | InlineMeta,
+		inlineMeta?: InlineMeta,
+	): void {
+		this.logErrorLevel('emergency', {
+			errorOrMessage,
+			messageOrMeta,
+			metaOrInlineMeta,
+			inlineMeta,
+		});
 	}
 
 	public setContext(context: Nullable<string>): void {
@@ -69,15 +160,99 @@ export abstract class BaseLogger implements Logger {
 		this.logger.add(transport);
 	}
 
-	private log(level: LogLevel, messages: unknown[]): void {
+	private logErrorLevel(level: LogLevel, args: ErrorLogOptions): void {
+		const payload = this.normalizeErrorLogPayload(args);
+		const options: LogOptions = {
+			meta: payload.meta,
+			inlineMeta: payload.inlineMeta,
+		};
+
+		if (payload.error) {
+			options.error = payload.error;
+		}
+
+		this.log(level, payload.message, options);
+	}
+
+	private log(level: LogLevel, message: string, options: LogOptions): void {
+		const {
+			error,
+			meta,
+			inlineMeta,
+		} = options;
 		const mappedLevel = loggerToSyslogMap.get(level) ?? level;
 
-		this.logger.log({
+		const payload: winston.LogEntry = {
 			level: mappedLevel,
-			message: format(...messages),
-			items: messages,
+			message: `${message}${this.formatInlineMeta(inlineMeta)}`,
 			context: this.context,
 			traceId: this.traceContext.get()?.traceId,
-		});
+		};
+
+		if (meta) {
+			payload['meta'] = meta;
+		}
+
+		if (error) {
+			payload['error'] = error;
+		}
+
+		this.logger.log(payload);
+	}
+
+	private normalizeErrorLogPayload(args: ErrorLogOptions): NormalizedLogPayload {
+		const {
+			errorOrMessage,
+			messageOrMeta,
+			metaOrInlineMeta,
+			inlineMeta,
+		} = args;
+
+		if (errorOrMessage instanceof BaseException) {
+			return {
+				error: errorOrMessage,
+				message: messageOrMeta as string,
+				meta: metaOrInlineMeta as LogMeta,
+				inlineMeta,
+			};
+		}
+
+		return {
+			message: errorOrMessage,
+			meta: messageOrMeta as LogMeta,
+			inlineMeta: metaOrInlineMeta as InlineMeta,
+		};
+	}
+
+	private formatInlineMeta(inlineMeta: Optional<InlineMeta>): string {
+		if (!inlineMeta || Object.keys(inlineMeta).length === 0) {
+			return '';
+		}
+
+		const items = Object
+			.entries(inlineMeta)
+			.map(([key, value]) => `${key}=${this.formatInlineMetaValue(value)}`);
+
+		return `: ${items.join(', ')}`;
+	}
+
+	private formatInlineMetaValue(value: InlineMeta[keyof InlineMeta]): string {
+		if (Array.isArray(value)) {
+			return `[${value.map(item => this.formatInlineMetaPrimitive(item)).join(',')}]`;
+		}
+
+		return this.formatInlineMetaPrimitive(value);
+	}
+
+	private formatInlineMetaPrimitive(value: InlineMetaPrimitive): string {
+		if (value instanceof Date) {
+			return value.toISOString();
+		}
+
+		if (Buffer.isBuffer(value)) {
+			return value.toString('base64');
+		}
+
+		return String(value);
 	}
 }

package/src/logger/console.logger.test.ts

@@ -0,0 +1,56 @@
+import {
+	Describe,
+	expect,
+	Suite,
+	Test,
+} from '@hg-ts/tests';
+import { vi } from 'vitest';
+
+type ConsoleStdout = {
+	_stdout: {
+		write: typeof process.stdout.write;
+	};
+};
+
+@Describe()
+export class ConsoleLoggerTest extends Suite {
+	private output: string[] = [];
+
+	@Test()
+	public async writesMessageInlineMetaAndMetaToStdout(): Promise<void> {
+		const { TraceContext } = await import('../trace.context.js');
+		const { ConsoleLogger } = await import('./console.logger.js');
+		const logger = new ConsoleLogger(new TraceContext());
+
+		logger.info(
+			'message',
+			{ metaKey: 'metaValue' },
+			{
+				inlineMetaKey: 123,
+				anotherKey: true,
+			},
+		);
+
+		expect(this.getOutput()).toContain('message: inlineMetaKey=123, anotherKey=true {"metaKey":"metaValue"}');
+	}
+
+	public override async beforeEach(): Promise<void> {
+		this.output = [];
+		vi.resetModules();
+		const stdout = (console as unknown as ConsoleStdout)['_stdout'];
+
+		vi.spyOn(stdout, 'write').mockImplementation(((chunk: string | Uint8Array): boolean => {
+			this.output.push(chunk.toString());
+
+			return true;
+		}) as typeof process.stdout.write);
+	}
+
+	public override async afterEach(): Promise<void> {
+		vi.restoreAllMocks();
+	}
+
+	private getOutput(): string {
+		return this.output.join('');
+	}
+}

package/src/logger/console.logger.ts

@@ -60,12 +60,21 @@ function formatTime(time: Date): string {
 	return time.toLocaleString('ru-RU');
 }
 
+function formatMeta(meta?: Record<string, unknown>): string {
+	if (!meta || Object.keys(meta).length === 0) {
+		return '';
+	}
+
+	return ` ${JSON.stringify(meta)}`;
+}
+
 const customFormat = createFormatter(info => {
 	const process = formatProcess(info.process);
 	const timestamp = formatTime(info.timestamp);
 	const context = colorizeContext(info.context);
 	const level = colorizeLevel(info.level);
-	const message = colorizeMessage(info.level, info.message);
+	const rawMessage = `${info.message}${formatMeta(info.meta)}`;
+	const message = colorizeMessage(info.level, rawMessage);
 	const traceId = info['traceId'] ? formatTraceId(info['traceId'] as string) : null;
 
 	const metaInfoItems: string[] = [timestamp, context, level, process];

package/src/logger/index.ts

@@ -1,4 +1,9 @@
-export { Logger } from './logger.js';
+export {
+	Logger,
+	type InlineMeta,
+	type InlineMetaValue,
+	type LogMeta,
+} from './logger.js';
 export { MockLogger } from './mock.logger.js';
 export { ConsoleLogger } from './console.logger.js';
 export { JSONLogger } from './json.logger.js';

package/src/logger/json.logger.test.ts

@@ -0,0 +1,59 @@
+import {
+	Describe,
+	expect,
+	Suite,
+	Test,
+} from '@hg-ts/tests';
+import { vi } from 'vitest';
+
+type ConsoleStdout = {
+	_stdout: {
+		write: typeof process.stdout.write;
+	};
+};
+
+@Describe()
+export class JSONLoggerTest extends Suite {
+	private output: string[] = [];
+
+	@Test()
+	public async writesMessageInlineMetaAndMetaToStdout(): Promise<void> {
+		const { TraceContext } = await import('../trace.context.js');
+		const { JSONLogger } = await import('./json.logger.js');
+		const traceContext = new TraceContext();
+		const logger = new JSONLogger(traceContext);
+		const traceId = 'test-trace-id';
+
+		traceContext.run({ traceId }, () => logger.info(
+			'message',
+			{ metaKey: 'metaValue' },
+			{
+				inlineMetaKey: 123,
+				anotherKey: true,
+			},
+		));
+
+		const log = JSON.parse(this.output.join('')) as Record<string, unknown>;
+
+		expect(log['message']).toBe('message: inlineMetaKey=123, anotherKey=true');
+		expect(log['meta']).toEqual({ metaKey: 'metaValue' });
+		expect(log['inlineMeta']).toBeUndefined();
+		expect(log['traceId']).toBe(traceId);
+	}
+
+	public override async beforeEach(): Promise<void> {
+		this.output = [];
+		vi.resetModules();
+		const stdout = (console as unknown as ConsoleStdout)['_stdout'];
+
+		vi.spyOn(stdout, 'write').mockImplementation(((chunk: string | Uint8Array): boolean => {
+			this.output.push(chunk.toString());
+
+			return true;
+		}) as typeof process.stdout.write);
+	}
+
+	public override async afterEach(): Promise<void> {
+		vi.restoreAllMocks();
+	}
+}

package/src/logger/logger.ts

@@ -1,12 +1,30 @@
+import { type BaseException } from '@hg-ts/exception';
+
+export type InlineMetaPrimitive = string | number | boolean | Date | Buffer;
+
+export type InlineMetaValue = InlineMetaPrimitive | InlineMetaPrimitive[];
+export type InlineMeta = Record<string, InlineMetaValue>;
+export type LogMeta = Record<string, unknown>;
+
 export abstract class Logger {
-	public abstract debug(...messages: unknown[]): void;
-	public abstract info(...messages: unknown[]): void;
-	public abstract notice(...messages: unknown[]): void;
-	public abstract warning(...messages: unknown[]): void;
-	public abstract error(...messages: unknown[]): void;
-	public abstract critical(...messages: unknown[]): void;
-	public abstract alert(...messages: unknown[]): void;
-	public abstract emergency(...messages: unknown[]): void;
+	public abstract debug(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public abstract info(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public abstract notice(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+
+	public abstract warning(error: BaseException, message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public abstract warning(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+
+	public abstract error(error: BaseException, message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public abstract error(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+
+	public abstract critical(error: BaseException, message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public abstract critical(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+
+	public abstract alert(error: BaseException, message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public abstract alert(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+
+	public abstract emergency(error: BaseException, message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
+	public abstract emergency(message: string, meta?: LogMeta, inlineMeta?: InlineMeta): void;
 
 	public abstract setContext(context: Nullable<string>): void;
 }