@hg-ts/logger 0.5.17 → 0.5.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hg-ts/logger",
-  "version": "0.5.17",
+  "version": "0.5.19",
   "main": "dist/index.js",
   "type": "module",
   "exports": {
@@ -16,11 +16,11 @@
     "lint:ts:fix": "lint-ts --fix"
   },
   "devDependencies": {
-    "@hg-ts-config/typescript": "0.5.17",
-    "@hg-ts/async-context": "0.5.17",
-    "@hg-ts/execution-mode": "0.5.17",
-    "@hg-ts/linter": "0.5.17",
-    "@hg-ts/types": "0.5.17",
+    "@hg-ts-config/typescript": "0.5.19",
+    "@hg-ts/async-context": "0.5.19",
+    "@hg-ts/execution-mode": "0.5.19",
+    "@hg-ts/linter": "0.5.19",
+    "@hg-ts/types": "0.5.19",
     "@nestjs/common": "11.1.0",
     "@nestjs/core": "11.1.0",
     "@types/node": "22.19.1",

package/src/index.ts

@@ -0,0 +1,8 @@
+export {
+	Logger,
+	ConsoleLogger,
+	JSONLogger,
+	MockLogger,
+} from './logger/index.js';
+export * from './logger.module.js';
+export * from './trace.context.js';

package/src/logger/base.formatter.ts

@@ -0,0 +1,63 @@
+import * as assert from 'node:assert';
+import winston from 'winston';
+import {
+	LogLevel,
+	syslogToLoggerMap,
+} from './base.logger.js';
+
+export type LogMessage = winston.Logform.TransformableInfo & {
+	context: Nullable<string>;
+	message: string;
+	level: LogLevel;
+	process: {
+		pid: number;
+		title: Nullable<string>;
+	};
+	timestamp: Date;
+	items: unknown[];
+};
+
+function getLogData(info: winston.Logform.TransformableInfo): LogMessage {
+	const level = syslogToLoggerMap.get(info.level) ?? info.level as LogLevel;
+	const context = info['context'] ?? null;
+
+	assert.ok(typeof context === 'string' || context === null);
+
+	return {
+		level,
+		context,
+		process: {
+			pid: process.pid,
+			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;
+		});
+	return logData;
+});
+
+export function createFormatter(formatter: (info: LogMessage) => LogMessage): winston.Logform.FormatWrap {
+	return winston.format(formatter as any);
+}

package/src/logger/base.logger.ts

@@ -0,0 +1,83 @@
+import { format } from 'node:util';
+import winston from 'winston';
+import { TraceContext } from '../trace.context.js';
+
+import { Logger } from './logger.js';
+
+type Transport = winston.Logger['add'] extends (transport: infer R) => void ? R : never;
+
+export type LogLevel = keyof Omit<Logger, 'setContext'>;
+
+export const syslogToLoggerMap = new Map<string, LogLevel>()
+	.set('emerg', 'emergency')
+	.set('crit', 'critical');
+
+export const loggerToSyslogMap = new Map<LogLevel, string>()
+	.set('emergency', 'emerg')
+	.set('critical', 'crit');
+
+
+export abstract class BaseLogger implements Logger {
+	protected context: Nullable<string> = null;
+	private readonly logger: winston.Logger;
+	private readonly traceContext: TraceContext;
+
+	protected constructor(logLevel: LogLevel, context: string, traceContext: TraceContext) {
+		this.context = context;
+		this.traceContext = traceContext;
+
+		this.logger = winston.createLogger({
+			level: logLevel,
+			levels: winston.config.syslog.levels,
+			transports: [],
+			handleExceptions: true,
+			handleRejections: true,
+			exitOnError: false,
+		});
+	}
+
+	public debug(...messages: unknown[]): void {
+		this.log('debug', messages);
+	}
+	public info(...messages: unknown[]): void {
+		this.log('info', messages);
+	}
+	public notice(...messages: unknown[]): void {
+		this.log('notice', messages);
+	}
+	public warning(...messages: unknown[]): void {
+		this.log('warning', messages);
+	}
+	public error(...messages: unknown[]): void {
+		this.log('error', messages);
+	}
+	public critical(...messages: unknown[]): void {
+		this.log('critical', messages);
+	}
+	public alert(...messages: unknown[]): void {
+		this.log('alert', messages);
+	}
+	public emergency(...messages: unknown[]): void {
+		this.log('emergency', messages);
+	}
+
+	public setContext(context: Nullable<string>): void {
+		this.context = context;
+	}
+
+	protected addTransport(transport: Transport): void {
+		this.logger.add(transport);
+	}
+
+	private log(level: LogLevel, messages: unknown[]): void {
+		const mappedLevel = loggerToSyslogMap.get(level) ?? level;
+
+		this.logger.log({
+			level: mappedLevel,
+			message: format(...messages),
+			items: messages,
+			context: this.context,
+			traceId: this.traceContext.get()?.traceId,
+		});
+	}
+}

package/src/logger/colors.ts

@@ -0,0 +1,18 @@
+const isColorAllowed = !process.env['NO_COLOR'];
+
+export enum COLOR {
+	ORANGE = '38;5;3',
+	GREEN = '32',
+	YELLOW = '33',
+	RED = '31',
+	MAGENTA_BRIGHT = '95',
+	CYAN_BRIGHT = '96',
+}
+
+export function colorize(color: COLOR, text: string): string {
+	if (!isColorAllowed) {
+		return text;
+	}
+
+	return `\x1B[${color}m${text}\x1B[39m`;
+}

package/src/logger/console.logger.ts

@@ -0,0 +1,97 @@
+import { MESSAGE } from 'triple-beam';
+import winston from 'winston';
+import { TraceContext } from '../trace.context.js';
+import {
+	baseFormatter,
+	createFormatter,
+	LogMessage,
+} from './base.formatter.js';
+import {
+	BaseLogger,
+	LogLevel,
+} from './base.logger.js';
+import {
+	COLOR,
+	colorize,
+} from './colors.js';
+
+export const colorsMap = new Map<LogLevel, COLOR>()
+	.set('emergency', COLOR.RED)
+	.set('alert', COLOR.RED)
+	.set('critical', COLOR.RED)
+	.set('error', COLOR.RED)
+	.set('warning', COLOR.YELLOW)
+	.set('notice', COLOR.GREEN)
+	.set('info', COLOR.CYAN_BRIGHT)
+	.set('debug', COLOR.MAGENTA_BRIGHT);
+
+function colorizeLevel(level: LogLevel): string {
+	const levelColor = colorsMap.get(level)!;
+
+	return `<${colorize(levelColor, level)}>`;
+}
+
+function colorizeContext(context: Nullable<string>): string {
+	if (context) {
+		return `[${colorize(COLOR.ORANGE, context)}]`;
+	}
+
+	return '';
+}
+
+function colorizeMessage(level: LogLevel, message: string): string {
+	const levelColor = colorsMap.get(level)!;
+
+	return colorize(levelColor, message);
+}
+
+function formatProcess(process: LogMessage['process']): string {
+	if (process.title) {
+		return `[${process.title}: ${process.pid}]`;
+	}
+	return `[pid: ${process.pid}]`;
+}
+
+function formatTraceId(traceId: string): string {
+	return `[traceId: ${traceId}]`;
+}
+
+function formatTime(time: Date): string {
+	return time.toLocaleString('ru-RU');
+}
+
+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 traceId = info['traceId'] ? formatTraceId(info['traceId'] as string) : null;
+
+	const metaInfoItems: string[] = [timestamp, context, level, process];
+
+	if (traceId) {
+		metaInfoItems.push(traceId);
+	}
+
+	const metaInfo = metaInfoItems.join(' ');
+
+	info[MESSAGE] = `${metaInfo}: ${message}`;
+
+	return info;
+});
+
+const consoleTransport = new winston.transports.Console({
+	format: winston.format.combine(
+		baseFormatter(),
+		customFormat(),
+	),
+});
+
+export class ConsoleLogger extends BaseLogger {
+	public constructor(traceContext: TraceContext) {
+		super('debug', 'test', traceContext);
+
+		this.addTransport(consoleTransport);
+	}
+}

package/src/logger/index.ts

@@ -0,0 +1,4 @@
+export { Logger } 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.ts

@@ -0,0 +1,19 @@
+import winston from 'winston';
+import { TraceContext } from '../trace.context.js';
+import { baseFormatter } from './base.formatter.js';
+import { BaseLogger } from './base.logger.js';
+
+const jsonTransport = new winston.transports.Console({
+	format: winston.format.combine(
+		baseFormatter(),
+		winston.format.json(),
+	),
+});
+
+export class JSONLogger extends BaseLogger {
+	public constructor(traceContext: TraceContext) {
+		super('debug', 'test', traceContext);
+
+		this.addTransport(jsonTransport);
+	}
+}

package/src/logger/logger.ts

@@ -0,0 +1,12 @@
+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 setContext(context: Nullable<string>): void;
+}

package/src/logger/mock.logger.ts

@@ -0,0 +1,14 @@
+import { Logger } from './logger.js';
+
+export class MockLogger extends Logger {
+	public debug(): void {}
+	public info(): void {}
+	public notice(): void {}
+	public warning(): void {}
+	public error(): void {}
+	public critical(): void {}
+	public alert(): void {}
+	public emergency(): void {}
+
+	public setContext(): void {}
+}

package/src/logger.module.ts

@@ -0,0 +1,54 @@
+import {
+	ExecutionMode,
+	ExecutionModeModule,
+	ExecutionModeVariants,
+} from '@hg-ts/execution-mode';
+
+import {
+	Global,
+	Module,
+	Provider,
+	Scope,
+} from '@nestjs/common';
+import { INQUIRER } from '@nestjs/core';
+
+import {
+	ConsoleLogger,
+	JSONLogger,
+	Logger,
+	MockLogger,
+} from './logger/index.js';
+import { NestWrappedLogger } from './nest-wrapped.logger.js';
+import { TraceContext } from './trace.context.js';
+
+@Global()
+@Module({
+	imports: [ExecutionModeModule],
+	providers: [
+		TraceContext,
+		{
+			provide: Logger,
+			useFactory(parent: any, executionMode: ExecutionMode, traceContext: TraceContext): Logger {
+				const context = (parent && Object.getPrototypeOf(parent)?.constructor.name) ?? null;
+				const shouldUseConsoleLogger = executionMode.isValueIn([
+					ExecutionModeVariants.DEBUG,
+					ExecutionModeVariants.DEV,
+				]);
+				const shouldUseMockLogger = executionMode.is(ExecutionModeVariants.TEST);
+
+				if (shouldUseMockLogger) {
+					return new MockLogger();
+				}
+				const logger = shouldUseConsoleLogger ? new ConsoleLogger(traceContext) : new JSONLogger(traceContext);
+
+				logger.setContext(context);
+				return logger;
+			},
+			inject: [INQUIRER, ExecutionMode, TraceContext],
+			scope: Scope.TRANSIENT,
+		} satisfies Provider<Logger>,
+		NestWrappedLogger,
+	],
+	exports: [Logger, TraceContext],
+})
+export class LoggerModule {}

package/src/nest-wrapped.logger.ts

@@ -0,0 +1,51 @@
+import {
+	Inject,
+	Logger as NestLogger,
+	LoggerService,
+	OnModuleInit,
+} from '@nestjs/common';
+import { Logger } from './logger/index.js';
+
+/* eslint-disable @typescript/explicit-module-boundary-types */
+export class NestWrappedLogger implements LoggerService, OnModuleInit {
+	@Inject()
+	protected readonly logger: Logger;
+
+	public debug(message: any, context?: string): any {
+		this.setOptionalContext(context);
+		this.logger.debug(message);
+	}
+
+	public error(message: any, trace?: string, context?: string): any {
+		this.setOptionalContext(context);
+		this.logger.error(message, trace);
+	}
+
+	public log(message: any, context?: string): any {
+		this.setOptionalContext(context);
+		this.logger.info(message);
+	}
+
+	public verbose(message: any, context?: string): any {
+		this.setOptionalContext(context);
+		this.logger.notice(message);
+	}
+
+	public warn(message: any, context?: string): any {
+		this.setOptionalContext(context);
+		this.logger.warning(message);
+	}
+	/* eslint-enable @typescript/explicit-module-boundary-types */
+
+	public async onModuleInit(): Promise<void> {
+		this.logger.setContext(null);
+		NestLogger.overrideLogger(true);
+		NestLogger.overrideLogger(['debug', 'log', 'verbose', 'warn', 'error']);
+		NestLogger.overrideLogger(this);
+		NestLogger.flush();
+	}
+
+	private setOptionalContext(context: Nullable<string> = null): void {
+		this.logger.setContext(context);
+	}
+}

package/src/trace.context.ts

@@ -0,0 +1,7 @@
+import { AsyncContextProvider } from '@hg-ts/async-context';
+
+export type TraceData = {
+	traceId: string;
+};
+
+export class TraceContext extends AsyncContextProvider<TraceData> {}