api: логирование через pino

Логгер на pino + nestjs-pino вместо стандартного ConsoleLogger: уровни
trace…fatal, details объектом, человекочитаемый вывод в dev и JSON в
проде,
автоматические HTTP-логи (reqId, url, statusCode, responseTime). Для
тестов —
LocalLoggerModule.forTesting() со своим TestingLogger и матчерами.

Документация по логированию — в docs/55-logging.
This commit is contained in:
arswarog committed 2026-10-27 10:44:15 +03:00
1 parent 157d79932a
commit bd6f349dc4
21 files changed
+1992 -11

No files matched your search

+9 -3
View File
@@ -1,11 +1,17 @@
import { Module } from '@nestjs/common';
import { Module, OnModuleDestroy } from '@nestjs/common';
import { LocalLoggerModule, Logger } from '../logger';
import { AppController } from './app.controller';
import { AppService } from './app.service';
@Module({
imports: [],
imports: [LocalLoggerModule.forRoot()],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
export class AppModule implements OnModuleDestroy {
onModuleDestroy() {
new Logger('AppModule').warn('Backend is shutting down');
}
}
+36
View File
@@ -0,0 +1,36 @@
import pino, { Logger as PinoLogger } from 'pino';
import type { PrettyOptions } from 'pino-pretty';
/**
* В продакшене пишем машиночитаемый JSON, в остальных окружениях — человекочитаемый вывод.
* LOG_PRETTY явно перекрывает определение по NODE_ENV (нужно, когда образ собран под прод,
* а контейнер поднят локально).
*/
const isProduction = process.env.NODE_ENV === 'production' || process.env.LOG_PRETTY === 'false';
const baseLogger = pino({
level: process.env.LOG_LEVEL ?? (isProduction ? 'info' : 'debug'),
transport: isProduction
? undefined
: {
target: 'pino-pretty',
options: {
colorize: true,
translateTime: 'HH:MM:ss.l',
ignore: 'pid,hostname,context,reqId,res,url,statusCode,responseTime',
messageFormat: [
'\x1b[36m{reqId}\x1b[0m',
'\x1b[33m{context}\x1b[0m',
'\x1b[34m{msg}\x1b[0m',
].join(' '),
} as PrettyOptions,
},
});
/**
* Единственный экземпляр pino на процесс: и корневой логгер приложения, и pino-http
* пишут через него, поэтому транспорт (воркер pino-pretty) создаётся один раз.
*/
export function getBaseLogger(): PinoLogger {
return baseLogger;
}
+3
View File
@@ -0,0 +1,3 @@
export * from './base';
export * from './logger.class';
export * from './logger.module';
+167
View File
@@ -0,0 +1,167 @@
import { Inject, Injectable, LoggerService, Scope } from '@nestjs/common';
import { PinoLogger } from 'nestjs-pino';
import { Bindings } from 'pino';
import { getBaseLogger } from './base';
export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
@Injectable({ scope: Scope.TRANSIENT })
export class Logger implements LoggerService {
private readonly logger: PinoLogger;
constructor();
constructor(context: string);
constructor(
@Inject(PinoLogger)
context?: string | PinoLogger,
) {
if (context && context instanceof PinoLogger) {
this.logger = context;
} else {
const bindings: Bindings = context ? { context } : {};
this.logger = getBaseLogger().child(bindings) as unknown as PinoLogger;
}
}
setContext(context: string) {
if (this.logger instanceof PinoLogger) {
this.logger.setContext(context);
} else {
throw new Error('Cannot set context on child logger');
}
}
/**
* Трассировка, максимальная детализация
*
* Log level: 10
*
* Самый подробный уровень. Используется для сложных расследований и поиска причин ошибок.
*
* Примеры:
* - пошаговое логирование алгоритма
* - шаги в обработке запроса
* - переходы между этапами обработки
* - детали бизнес-логики
*/
trace(message: string, details?: object) {
this.logInner('trace', message, details);
}
/**
* Отладка, подробности бизнес-логики
*
* Log level: 20
*
* Сообщения для разработчиков, полезные при разборе логики работы.
*
* Примеры:
* - запрос разрешений
* - ключевые шаги алгоритма
* - получение данных из внешних сервисов
* - события жизненного цикла приложения
* - ответы от внешних сервисов
*/
debug(message: string, details?: object) {
this.logInner('debug', message, details);
}
/**
* Ключевые события приложения
*
* Log level: 30
*
* Информационные сообщения о нормальной работе приложения.
*
* Примеры:
* - запрос к API
* - пользователь успешно вошёл в систему
* - заявка создана
* - бизнес-операция успешно выполнена
*/
log(message: string, details?: object) {
this.logInner('info', message, details);
}
/**
* Потенциальная проблема, нестандартное поведение
*
* Log level: 40
*
* Предупреждения о нежелательных или подозрительных ситуациях, которые не приводят к немедленной поломке.
*
* Примеры:
* - потенциально опасное поведение пользователя
* - использование устаревшего API
* - медленный запрос
*/
warn(message: string, details?: object) {
this.logInner('warn', message, details);
}
/**
* Ошибка, требующая реакции
*
* Log level: 50
*
* Серьёзные ошибки в работе приложения, которые нужно обрабатывать.
*
* Примеры:
* - API отдало 500
* - не удалось выполнить бизнес-операцию.
*/
error(message: string, details?: object): void;
/**
* Ошибка, требующая реакции
*
* Log level: 50
*
* Серьёзные ошибки в работе приложения, которые нужно обрабатывать.
*
* Примеры:
* - API отдало 500
* - не удалось выполнить бизнес-операцию.
*/
error(message: string, trace?: string, details?: object): void;
error(message: string, traceOrDetails?: string | object, details?: object | string) {
if (typeof details === 'string') {
details = { context: details };
}
if (typeof traceOrDetails === 'string') {
details = { ...details, trace: traceOrDetails };
}
this.logInner('error', message, details);
}
/**
* Критическая ошибка, завершение работы
*
* Log level: 60
*
* Используется для ситуаций, после которых приложение не может продолжать работу.
*
* Примеры:
* - падение основного процесса
* - невозможность поднять сервер на указанном порту
* - не корректная конфигурация
* - не удалось подключиться к базе данных
*/
fatal(message: string, details?: object) {
this.logInner('fatal', message, details);
}
protected logInner(level: LogLevel, message: string, details?: object | string) {
if (typeof details === 'object' && details !== null) {
this.logger[level](details, message);
} else if (typeof details === 'string') {
// Для совместимости с логгером по умолчанию в NestJS
this.logger[level]({ context: details }, message);
} else {
this.logger[level](message);
}
}
}
+113
View File
@@ -0,0 +1,113 @@
import { IncomingMessage, ServerResponse } from 'http';
import { DynamicModule, INestApplication, Module } from '@nestjs/common';
import { LoggerModule, PinoLogger } from 'nestjs-pino';
import { getBaseLogger } from './base';
import { Logger } from './logger.class';
import { MockLogger, TestingLogger } from './testing';
@Module({})
export class LocalLoggerModule {
/**
* Рабочая конфигурация: наш pino (base.ts) + автоматические HTTP-логи через pino-http.
*/
public static forRoot(): DynamicModule {
return {
global: true,
module: LocalLoggerModule,
imports: [
LoggerModule.forRoot({
pinoHttp: {
// важное место: используем наш СУЩЕСТВУЮЩИЙ pino, а не создаём новый
logger: getBaseLogger(),
autoLogging: true,
customProps: (req: IncomingMessage) => ({
url: req.method + ' ' + req.url,
context: 'HTTP',
}),
quietReqLogger: true,
quietResLogger: true,
customLogLevel: function (
_req: IncomingMessage,
res: ServerResponse,
err?: Error,
) {
if (res.statusCode >= 500 || err) {
return 'error';
} else if (res.statusCode >= 300 && res.statusCode < 400) {
return 'silent';
}
return 'info';
},
customSuccessMessage(req: IncomingMessage, res: ServerResponse) {
return `Request completed: ${res.statusCode} ${req.method} ${req.url}`;
},
customSuccessObject(
_req: IncomingMessage,
res: ServerResponse,
val: { responseTime: number },
) {
return {
statusCode: res.statusCode,
responseTime: val.responseTime,
};
},
customErrorMessage(req: IncomingMessage, res: ServerResponse, err: Error) {
return `Request error: ${res.statusCode} ${req.method} ${req.url} ${err.message}`;
},
customErrorObject(
req: IncomingMessage,
res: ServerResponse,
_err: Error,
val: { responseTime: number },
) {
return {
url: req.method + ' ' + req.url,
statusCode: res.statusCode,
responseTime: val.responseTime,
};
},
},
}),
],
providers: [Logger],
exports: [Logger],
};
}
/**
* Конфигурация для тестов: логи складываются в память и проверяются через TestingLogger.
*/
public static forTesting(): DynamicModule {
return {
global: true,
module: LocalLoggerModule,
providers: [
TestingLogger,
{
provide: Logger,
useFactory: (testingLogger: TestingLogger) => new MockLogger(testingLogger),
inject: [TestingLogger],
},
{
provide: PinoLogger,
useValue: {},
},
],
exports: [Logger, TestingLogger],
};
}
/**
* Подмена логгера Nest нашим. Вызывать после NestFactory.create с bufferLogs: true —
* useLogger сбрасывает буфер в наш логгер.
*/
public static setup(app: INestApplication) {
app.useLogger(new Logger());
}
}
+2
View File
@@ -0,0 +1,2 @@
export * from './logger.class';
export * from './testing-logger.class';
@@ -0,0 +1,19 @@
import { Logger, LogLevel } from '../logger.class';
import { TestingLogger } from './testing-logger.class';
export class MockLogger extends Logger {
private context: string;
constructor(private readonly testingLogger: TestingLogger) {
super();
}
override setContext(context: string) {
this.context = context;
}
protected override logInner(level: LogLevel, message: string, details?: object) {
this.testingLogger.log(level, message, this.context, details);
}
}
@@ -0,0 +1,265 @@
import * as colorette from 'colorette';
import { LogLevel } from '../logger.class';
import { fail, LogEntry, PrettifyStackTrace, showLogDetails, showLogObject } from './utils';
export type { LogEntry };
export class TestingLogger {
private readonly entries: LogEntry[] = [];
/**
* Добавление записи лога
*/
log(level: LogLevel, message: string, context: string, details?: object) {
this.entries.push({
level,
message,
context,
...details,
});
}
/**
* Очистка всех записей логов
*/
clear() {
this.entries.length = 0;
}
/**
* Любые логи (старт без фильтра)
*/
any(): TestingLoggerMatcher {
return new TestingLoggerMatcher(this.entries, {});
}
/**
* Старт от фильтра по сообщению
*/
withMessage(message: string): TestingLoggerMatcher {
return new TestingLoggerMatcher(this.entries, { message });
}
/**
* Старт от фильтра по уровню
*/
withLevel(level: LogLevel): TestingLoggerMatcher {
return new TestingLoggerMatcher(this.entries, { level });
}
/**
* Старт от фильтра по контексту
*/
withContext(context: string): TestingLoggerMatcher {
return new TestingLoggerMatcher(this.entries, { context });
}
}
const BASE_FIELDS: (keyof LogEntry)[] = ['level', 'message', 'context'];
export class TestingLoggerMatcher {
constructor(
private readonly entries: LogEntry[],
private readonly filter: Partial<LogEntry>,
private readonly strict = false,
) {}
get logs() {
// В режиме strict мы хотим строгое совпадение деталей: все ключи деталей должны совпадать
// и не должно быть лишних ключей деталей у записи.
if (this.strict) {
return this.entries.filter((log) => {
// проверяем базовые поля, если они заданы в фильтре
for (const field of BASE_FIELDS) {
if (this.filter[field] !== undefined && log[field] !== this.filter[field]) {
return false;
}
}
// ключи деталей в фильтре и в самой записи
const detailFilterKeys = Object.keys(this.filter).filter((k) => {
return !BASE_FIELDS.includes(k as keyof LogEntry);
});
const entryDetailKeys = Object.keys(log).filter((k) => {
return !BASE_FIELDS.includes(k as keyof LogEntry);
});
// размеры наборов деталей должны совпадать
if (detailFilterKeys.length !== entryDetailKeys.length) {
return false;
}
// все ключи из фильтра должны присутствовать и иметь одинаковые значения
return detailFilterKeys.every((key) => {
return log[key] === this.filter[key];
});
});
}
return this.entries.filter((log) => {
for (const key in this.filter) {
if (log[key] !== this.filter[key]) {
return false;
}
}
return true;
});
}
showLogs(options: { hideFilter?: boolean; logs?: LogEntry[] } = {}): this {
const { hideFilter = false, logs = this.logs } = options;
process.stdout.write(colorette.bold(colorette.white('--- Logs ---')) + '\n');
if (!hideFilter) {
process.stdout.write(colorette.bold(colorette.cyan('Filter:')) + '\n');
if (Object.keys(this.filter).length === 0) {
process.stdout.write(' (no filter, showing all logs)\n');
} else {
showLogDetails({
level: this.filter.level,
context: this.filter.context,
message: this.filter.message,
...this.filter,
});
}
}
process.stdout.write(colorette.bold(colorette.white('Found logs:')) + '\n');
logs.forEach((log) => {
showLogObject(log);
process.stdout.write('\n'); // пустая строка между логами
});
process.stdout.write(` Found ${logs.length} log(s) total\n\n`);
return this;
}
/**
* Фильтр по сообщению
*/
withMessage(message: string): TestingLoggerMatcher {
return new TestingLoggerMatcher(this.entries, { ...this.filter, message }, this.strict);
}
/**
* Фильтр по уровню
*/
withLevel(level: LogLevel): TestingLoggerMatcher {
return new TestingLoggerMatcher(this.entries, { ...this.filter, level }, this.strict);
}
/**
* Фильтр по контексту
*/
withContext(context: string): TestingLoggerMatcher {
return new TestingLoggerMatcher(this.entries, { ...this.filter, context }, this.strict);
}
/**
* Фильтр по дополнительным деталям
*/
withDetails(obj: Record<string, boolean | number | string>): TestingLoggerMatcher {
return new TestingLoggerMatcher(this.entries, { ...this.filter, ...obj }, this.strict);
}
/**
* Фильтр по дополнительным деталям - строгий (все детали должны совпадать, лишних быть не должно)
*/
strictDetails(): TestingLoggerMatcher {
return new TestingLoggerMatcher(this.entries, { ...this.filter }, true);
}
/**
* Проверка наличия логов
*/
@PrettifyStackTrace()
toBeLogged(): void {
if (this.logs.length === 0) {
if (this.entries.length) {
this.toBeLoggedTimes(1);
} else {
return fail('No logs recorded');
}
}
}
/**
* Проверка отсутствия логов
*/
@PrettifyStackTrace()
toBeNotLogged(): void {
this.toBeLoggedTimes(0);
}
/**
* Проверка, что лог был записан ровно один раз
*/
@PrettifyStackTrace()
toBeLoggedOnce(): void {
this.toBeLoggedTimes(1);
}
/**
* Проверка, что лог был записан ровно n раз
*/
@PrettifyStackTrace()
toBeLoggedTimes(n: number): void {
if (this.logs.length === n) {
return;
}
this.throwDiff(n);
}
private throwDiff(n: number) {
if (!this.entries.length) {
return fail('No logs recorded');
}
throw new Error(
[
`Expected ${n} log(s)` + describedFilter(this.filter),
this.logs.length ? '\nFound:' : '',
...this.logs.map((entry) => ` ${logEntryToString(this.filter)(entry)}`),
this.logs.length ? '' : ' (none)',
].join('\n'),
);
}
}
function describedFilter(filter: Partial<LogEntry>): string {
const keys = Object.keys(filter);
if (!keys.length) {
return '';
}
return ` matching ${keys.map((key) => `${key}=${String(filter[key])}`).join(', ')}`;
}
function logEntryToString(filter: Partial<LogEntry>) {
return (entry: LogEntry): string => {
let result = '';
if (filter.context) {
result += `${entry.context} `;
}
if (filter.level) {
result += `[${entry.level}] `;
}
if (filter.message) {
result += `${entry.message}`;
}
return result;
};
}
@@ -0,0 +1,567 @@
import { Test } from '@nestjs/testing';
import { beforeEach, describe, expect, it } from 'vitest';
import { Logger } from '../logger.class';
import { LocalLoggerModule } from '../logger.module';
import { TestingLogger } from './testing-logger.class';
describe('TestingLogger', () => {
let mockLogger: Logger;
let logger: TestingLogger;
beforeEach(async () => {
const module = await Test.createTestingModule({
imports: [LocalLoggerModule.forTesting()],
}).compile();
mockLogger = await module.resolve(Logger);
logger = module.get(TestingLogger);
});
it('complex test', () => {
// Arrange
mockLogger.setContext('RBAC');
// Act
mockLogger.debug('Access granted', { user: 1, permissions: ['read'] });
mockLogger.log('Access granted', { user: 2, permissions: ['read', 'write'] });
mockLogger.warn('Access denied', { user: 1 });
mockLogger.log('User logged in', { user: 1 });
mockLogger.error('Unexpected error', { error: new Error('Test error') });
// Assert
const rbacLogger = logger.withContext('RBAC');
rbacLogger.withMessage('Access denied').toBeLogged();
rbacLogger.withMessage('Access granted').withLevel('debug').toBeLogged();
rbacLogger.withMessage('Access granted').withLevel('info').toBeLogged();
rbacLogger.withMessage('User logged in').withLevel('info').toBeLogged();
rbacLogger.withMessage('Unexpected error').withLevel('error').toBeLogged();
rbacLogger.toBeLoggedTimes(5);
rbacLogger.withMessage('Access granted').toBeLoggedTimes(2);
rbacLogger.withMessage('Access denied').toBeLoggedOnce();
rbacLogger.withMessage('User logged in').toBeLoggedOnce();
rbacLogger.withMessage('Unexpected error').toBeLoggedOnce();
rbacLogger.withMessage('Access granted').withDetails({ user: 1 }).toBeLoggedOnce();
});
describe('TestingLogger — базовые операции', () => {
it('сохраняет запись через log() (все поля + details)', () => {
// Arrange
logger.log('info', 'msg', 'CTX', { a: 1 });
// Act
const matcher = logger.any();
// Assert
matcher.toBeLoggedOnce();
// Проверяем точное соответствие
const entries = matcher.logs;
expect(entries[0]).toEqual({
level: 'info',
message: 'msg',
context: 'CTX',
a: 1,
});
});
it('log() без details не добавляет лишних ключей', () => {
// Arrange
logger.log('warn', 'msg', 'CTX');
// Act
const matcher = logger.any();
matcher.toBeLoggedOnce();
const entry = matcher.logs[0];
// Assert
expect(entry).toEqual({
level: 'warn',
message: 'msg',
context: 'CTX',
});
// Проверяем отсутствие произвольных ключей
expect(entry.a).toBeUndefined();
expect(entry.b).toBeUndefined();
});
it('поля из details перекрывают базовые при совпадении ключей', () => {
// Arrange
logger.log('info', 'base', 'CTX', {
message: 'override',
level: 'error',
context: 'OVR',
});
// Act
const matcher = logger.any();
matcher.toBeLoggedOnce();
const entry = matcher.logs[0];
// Assert
expect(entry).toEqual({
level: 'error',
message: 'override',
context: 'OVR',
});
});
it('clear() очищает все записи', () => {
// Arrange
logger.log('info', 'A', 'CTX');
logger.log('warn', 'B', 'CTX');
// Act
logger.clear();
const matcher = logger.any();
// Assert
matcher.toBeNotLogged();
});
});
describe('TestingLogger — входные точки фильтрации', () => {
it('any() возвращает матчёр со всеми текущими записями', () => {
// Arrange
logger.log('info', 'A', 'CTX1');
logger.log('warn', 'B', 'CTX2');
logger.log('error', 'C', 'CTX3');
// Act & Assert
logger.any().toBeLoggedTimes(3);
});
it('withMessage("X") создаёт стартовый матчёр с фильтром по message', () => {
// Arrange
logger.log('info', 'X', 'CTX1');
logger.log('warn', 'Y', 'CTX2');
logger.log('error', 'X', 'CTX3');
// Act & Assert
logger.withMessage('X').toBeLoggedTimes(2);
logger.withMessage('Y').toBeLoggedTimes(1);
logger.withMessage('Z').toBeLoggedTimes(0);
});
it('withLevel(L) создаёт стартовый матчёр с фильтром по level', () => {
// Arrange
logger.log('info', 'A', 'CTX1');
logger.log('error', 'B', 'CTX2');
logger.log('error', 'C', 'CTX3');
// Act & Assert
logger.withLevel('info').toBeLoggedTimes(1);
logger.withLevel('error').toBeLoggedTimes(2);
logger.withLevel('warn').toBeLoggedTimes(0);
});
it('withContext("C") создаёт стартовый матчёр с фильтром по context', () => {
// Arrange
logger.log('info', 'A', 'C');
logger.log('warn', 'B', 'CTX2');
logger.log('error', 'C', 'C');
// Act & Assert
logger.withContext('C').toBeLoggedTimes(2);
logger.withContext('CTX2').toBeLoggedTimes(1);
logger.withContext('CTX3').toBeLoggedTimes(0);
});
it('повторные вызовы стартовых фильтров независимы (каждый — новый матчёр)', () => {
// Arrange
logger.log('info', 'A', 'CTX');
logger.log('info', 'B', 'CTX');
// Act
const mA = logger.withMessage('A');
const mB = logger.withMessage('B');
// Assert
mA.toBeLoggedTimes(1);
mB.toBeLoggedTimes(1);
// Проверяем, что фильтры независимы
expect(mA.logs[0].message).toBe('A');
expect(mB.logs[0].message).toBe('B');
});
});
describe('TestingLoggerMatcher — фильтры (локальные)', () => {
it('withMessage("X") фильтрует текущий набор по message', () => {
// Arrange
logger.log('info', 'X', 'CTX1');
logger.log('warn', 'Y', 'CTX2');
logger.log('error', 'X', 'CTX3');
logger.log('debug', 'Z', 'CTX4');
// Act
const filtered = logger.any().withMessage('X');
// Assert
filtered.toBeLoggedTimes(2); // Должно остаться только 2 записи с message === 'X'
});
it('withLevel(L) фильтрует текущий набор по level', () => {
// Arrange
logger.log('warn', 'A', 'CTX1');
logger.log('info', 'B', 'CTX2');
logger.log('warn', 'C', 'CTX3');
logger.log('error', 'D', 'CTX4');
// Act
const filtered = logger.any().withLevel('warn');
// Assert
filtered.toBeLoggedTimes(2); // Должно остаться только 2 записи с level === 'warn'
});
it('withContext("C") фильтрует текущий набор по context', () => {
// Arrange
logger.log('warn', 'A', 'C');
logger.log('info', 'B', 'CTX2');
logger.log('warn', 'C', 'C');
logger.log('error', 'D', 'CTX4');
// Act
const filtered = logger.any().withContext('C');
// Assert
filtered.toBeLoggedTimes(2); // Должно остаться только 2 записи с context === 'C'
});
it('withDetails({k:v}) оставляет записи, где все пары совпали (логическое И)', () => {
// Arrange
logger.log('info', 'A', 'CTX', { a: 1, b: 'x' });
logger.log('info', 'B', 'CTX', { a: 1 });
logger.log('info', 'C', 'CTX', { b: 'x' });
logger.log('info', 'D', 'CTX', { a: 1, b: 'x', c: true });
// Act
const filtered = logger.any().withDetails({ a: 1, b: 'x' });
// Assert
filtered.toBeLoggedTimes(2); // Должны остаться только записи, где одновременно a=1 и b='x'
});
it('комбинация фильтров даёт пересечение условий', () => {
// Arrange
logger.log('info', 'X', 'C', { a: 1 }); // подходит
logger.log('info', 'X', 'C', { a: 2 }); // не подходит
logger.log('info', 'Y', 'C', { a: 1 }); // не подходит
logger.log('warn', 'X', 'C', { a: 1 }); // не подходит
// Act
const filtered = logger
.any()
.withMessage('X')
.withLevel('info')
.withContext('C')
.withDetails({ a: 1 });
// Assert
filtered.toBeLoggedTimes(1); // Только одна запись удовлетворяет всем условиям
});
it('порядок применения with* не влияет на результат (коммутативность)', () => {
// Arrange
logger.log('info', 'X', 'C', { a: 1 }); // подходит
logger.log('info', 'X', 'C', { a: 2 }); // не подходит
logger.log('info', 'Y', 'C', { a: 1 }); // не подходит
logger.log('warn', 'X', 'C', { a: 1 }); // не подходит
// Act
const filtered1 = logger
.any()
.withMessage('X')
.withLevel('info')
.withContext('C')
.withDetails({ a: 1 });
const filtered2 = logger
.any()
.withDetails({ a: 1 })
.withContext('C')
.withLevel('info')
.withMessage('X');
// Assert
filtered1.toBeLoggedTimes(1);
filtered2.toBeLoggedTimes(1);
});
it('фильтры не мутируют исходный матчёр (иммутабельность)', () => {
// Arrange
logger.log('info', 'X', 'CTX');
logger.log('info', 'Y', 'CTX');
// Act
const m0 = logger.any();
const m1 = m0.withMessage('X');
// Assert
m0.toBeLoggedTimes(2); // исходный набор
m1.toBeLoggedTimes(1); // отфильтрованный
m0.toBeLoggedTimes(2); // повторно исходный набор
});
it('фильтр на пустом наборе остаётся пустым', () => {
// Arrange
logger.log('info', 'A', 'CTX');
// Act & Assert
logger
.any()
.withMessage('non-existent')
.withLevel('warn')
.withContext('none')
.toBeLoggedTimes(0);
});
it('через withDetails можно проверять и другие поля', () => {
// Arrange
logger.log('info', 'A', 'CTX');
// Act & Assert
logger
.any()
.withMessage('A')
.withDetails({ level: 'info', context: 'CTX' })
.toBeLoggedOnce();
});
});
describe('Паритет фильтров в обоих классах', () => {
it('старт с TestingLogger.withX(...).withY(...).withZ(...) == any().withX(...).withY(...).withZ(...)', () => {
// Arrange
logger.log('info', 'X', 'C', { a: 1 }); // подходит
logger.log('info', 'X', 'C', { a: 2 }); // не подходит
logger.log('info', 'Y', 'C', { a: 1 }); // не подходит
logger.log('warn', 'X', 'C', { a: 1 }); // не подходит
// Act
const fromStart = logger
.withMessage('X')
.withLevel('info')
.withContext('C')
.withDetails({ a: 1 });
const fromAny = logger
.any()
.withMessage('X')
.withLevel('info')
.withContext('C')
.withDetails({ a: 1 });
// Assert
fromStart.toBeLoggedTimes(1);
fromAny.toBeLoggedTimes(1);
// Проверяем, что состав совпадает
expect(JSON.stringify(fromStart.logs)).toBe(JSON.stringify(fromAny.logs));
});
});
describe('Матчеры наличия/отсутствия', () => {
it('toBeLogged() проходит при >= 1 записи', () => {
// Arrange
logger.log('info', 'A', 'CTX');
// Act & Assert
expect(() => logger.any().toBeLogged()).not.toThrow();
});
it('toBeLogged() падает на пустом наборе', () => {
// Arrange: ничего не добавляем
// Act & Assert
expect(() => logger.any().toBeLogged()).toThrowError('No logs recorded');
});
it('toBeNotLogged() проходит при 0 записях', () => {
// Arrange: ничего не добавляем
// Act & Assert
expect(() => logger.any().toBeNotLogged()).not.toThrow();
});
it('toBeNotLogged() падает при >= 1 записи', () => {
// Arrange
logger.log('info', 'A', 'CTX');
logger.log('warn', 'B', 'CTX');
// Act & Assert
expect(() => logger.any().toBeNotLogged()).toThrow();
});
});
describe('Матчеры количества', () => {
it('toBeLoggedOnce() проходит при ровно 1 записи', () => {
// Arrange
logger.log('info', 'A', 'CTX');
// Act & Assert
expect(() => logger.any().toBeLoggedOnce()).not.toThrow();
});
it('toBeLoggedOnce() падает при 0', () => {
// Сценарий A: 0 записей
expect(() => logger.any().toBeLoggedOnce()).toThrow();
});
it('toBeLoggedOnce() падает при >1, сообщение содержит count и JSON', () => {
// Сценарий B: >1 записей
logger.log('info', 'A', 'CTX');
logger.log('info', 'B', 'CTX');
expect(() => logger.any().toBeLoggedOnce()).toThrow();
});
it('toBeLoggedTimes(n) проходит при точном совпадении количества', () => {
// Arrange
logger.log('info', 'A', 'CTX');
logger.log('info', 'B', 'CTX');
// Act & Assert
expect(() => logger.any().toBeLoggedTimes(2)).not.toThrow();
});
it('toBeLoggedTimes(n) падает при несовпадении (сообщение: ожидаемое и фактическое)', () => {
// Arrange
logger.log('info', 'A', 'CTX');
// Act & Assert
expect(() => logger.any().toBeLoggedTimes(2)).toThrow();
});
it('toBeLoggedTimes(0) проходит на пустом наборе', () => {
// Arrange: ничего не добавляем
// Act & Assert
expect(() => logger.any().toBeLoggedTimes(0)).not.toThrow();
});
});
describe('Детали и типы значений (withDetails / details)', () => {
it('совпадение по string/number/boolean', () => {
// Arrange
logger.log('info', 'A', 'CTX', { a: 'x' });
logger.log('info', 'B', 'CTX', { b: 1 });
logger.log('info', 'C', 'CTX', { c: true });
// Act & Assert
logger.any().withDetails({ a: 'x' }).toBeLoggedOnce();
logger.any().withDetails({ b: 1 }).toBeLoggedOnce();
logger.any().withDetails({ c: true }).toBeLoggedOnce();
});
it('несуществующий ключ в фильтре исключает запись', () => {
// Arrange
logger.log('info', 'A', 'CTX', { a: 1 });
// Act & Assert
logger.any().withDetails({ d: 42 }).toBeLoggedTimes(0);
});
it('частичное несоответствие по одному из ключей исключает запись', () => {
// Arrange
logger.log('info', 'A', 'CTX', { a: 1, b: 2 });
// Act & Assert
logger.any().withDetails({ a: 1, b: 999 }).toBeLoggedTimes(0);
});
it('различие по типу (число vs строка) не считается совпадением', () => {
// Arrange
logger.log('info', 'A', 'CTX', { a: 1 });
// Act & Assert
logger
.any()
.withDetails({ a: '1' as unknown as number })
.toBeLoggedTimes(0);
});
it('дополнительные поля в записи не мешают совпадению (подмножество)', () => {
// Arrange
logger.log('info', 'A', 'CTX', { a: 1, b: 2, c: 3 });
// Act & Assert
logger.any().withDetails({ a: 1 }).toBeLoggedOnce();
});
it('strictDetails требует точного совпадения ключей деталей (не допускает лишних полей)', () => {
// Arrange
logger.log('info', 'X', 'CTX', { a: 1, b: 2 });
// Act & Assert
// Обычный withDetails допускает совпадение по подмножеству
logger.any().withDetails({ a: 1 }).toBeLoggedOnce();
// strictDetails требует точного совпадения — запись с лишним полем не должна подходить
logger.any().withDetails({ a: 1 }).strictDetails().toBeLoggedTimes(0);
});
it('strictDetails проходит при полном совпадении деталей', () => {
// Arrange
logger.log('info', 'Y', 'CTX', { a: 1 });
// Act & Assert
logger.any().withDetails({ a: 1 }).strictDetails().toBeLoggedOnce();
});
});
describe('Граничные случаи', () => {
it('дубликаты идентичных логов учитываются поштучно в подсчёте', () => {
// Arrange
logger.log('info', 'A', 'CTX', { a: 1 });
logger.log('info', 'A', 'CTX', { a: 1 });
logger.log('info', 'A', 'CTX', { a: 1 });
// Act & Assert
logger.any().withDetails({ a: 1 }).toBeLoggedTimes(3);
});
it('одинаковые level/message/context, но разные details различаются withDetails', () => {
// Arrange
logger.log('info', 'A', 'CTX', { a: 1 });
logger.log('info', 'A', 'CTX', { a: 2 });
// Act & Assert
logger.any().withDetails({ a: 1 }).toBeLoggedOnce();
logger.any().withDetails({ a: 2 }).toBeLoggedOnce();
});
it('пустые строки корректно фильтруются: withMessage("") / withContext("")', () => {
// Arrange
logger.log('info', '', 'CTX', { a: 1 });
logger.log('info', 'A', '', { a: 2 });
logger.log('info', '', '', { a: 3 });
// Act & Assert
logger.withMessage('').toBeLoggedTimes(2); // две записи с пустым message
logger.withContext('').toBeLoggedTimes(2); // две записи с пустым context
});
it('smoke: большое количество записей не ломает фильтры', () => {
// Arrange
const N = 1000;
for (let i = 0; i < N; i++) {
logger.log('info', `msg${i % 10}`, `CTX${i % 5}`, { a: i % 3, b: i });
}
// Act & Assert
logger.withMessage('msg1').toBeLoggedTimes(100);
logger.withContext('CTX2').toBeLoggedTimes(200);
logger
.any()
.withDetails({ a: 0 })
.toBeLoggedTimes(Math.floor(N / 3) + (N % 3 > 0 ? 1 : 0));
logger.any().withDetails({ b: 42 }).toBeLoggedOnce();
});
});
});
+65
View File
@@ -0,0 +1,65 @@
import * as colorette from 'colorette';
import { LogLevel } from '../logger.class';
export interface LogEntry {
level: LogLevel;
message: string;
context: string;
[extra: string]: unknown;
}
export function fail(message: string): void {
throw new Error(message);
}
type ErrorConstructorWithCapture = ErrorConstructor & {
captureStackTrace?: (targetObject: object, constructorOpt?: unknown) => void;
};
/**
* Декоратор для методов матчеров:
* Если метод бросил ошибку — стек "подрезается" так,
* чтобы указать на строку вызова матчера в тесте (а не внутрь реализации).
*/
export function PrettifyStackTrace(): MethodDecorator {
return (_target, _key, descriptor: PropertyDescriptor) => {
const original = descriptor.value as (...args: unknown[]) => unknown;
function wrap(this: unknown, ...args: unknown[]) {
try {
return original.apply(this, args);
} catch (err) {
(Error as ErrorConstructorWithCapture).captureStackTrace?.(err as object, wrap);
throw err;
}
}
descriptor.value = wrap;
return descriptor;
};
}
export function showLogObject({ level, context, message, ...details }: LogEntry) {
const l = colorette.blue(level);
const c = colorette.bold(colorette.magenta(context));
const m = colorette.underline(colorette.white(message));
process.stdout.write(` ${l} ${c} ${m}\n`);
showLogDetails(details);
}
export function showLogDetails(details: Record<string, unknown>) {
Object.keys(details).forEach((key) => {
if (details[key] === undefined) {
return;
}
process.stdout.write(
` ${colorette.blue(key)}: ${colorette.yellow(String(details[key]))}\n`,
);
});
}
+18 -2
View File
@@ -2,11 +2,24 @@ import { NestFactory } from '@nestjs/core';
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
import { AppModule } from './app/app.module';
import { getBaseLogger, LocalLoggerModule, Logger } from './logger';
async function start() {
const PORT = process.env.PORT || 5000;
const app = await NestFactory.create(AppModule);
const app = await NestFactory.create(AppModule, {
bufferLogs: true,
});
// Подменяем логгер Nest на pino; накопленный в буфере вывод сбрасывается в него же
LocalLoggerModule.setup(app);
const logger = new Logger('Bootstrap');
logger.log('Logging started', {
level: getBaseLogger().level,
pretty: process.env.NODE_ENV !== 'production' && process.env.LOG_PRETTY !== 'false',
});
// настройка swaggera
const config = new DocumentBuilder()
@@ -41,6 +54,9 @@ async function start() {
allowedHeaders: 'Content-Type, Authorization',
credentials: true,
});
await app.listen(PORT, () => console.log(`Server started on ${PORT}`));
await app.listen(PORT);
logger.log('Server started', { port: PORT });
}
start();