@globalart/nestjs-logger 1.0.3 → 1.0.5

package/dist/core/http-logger.interceptor.d.ts

@@ -14,8 +14,10 @@ export declare class HttpLoggerInterceptor implements NestInterceptor {
     private readonly pid;
     constructor(logger: LoggerService, dataSanitizer: IDataSanitizer, requestIdGenerator: IRequestIdGenerator, config: LoggerConfiguration, reflector: Reflector);
     intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+    private createHttpLogEntry;
     private createLogEntry;
     private getClientIp;
     private sanitizeHeaders;
-    private shouldExcludeUrl;
+    private getRequestMethod;
+    private shouldExcludeRequest;
 }

package/dist/core/http-logger.interceptor.js

@@ -32,11 +32,10 @@ let HttpLoggerInterceptor = class HttpLoggerInterceptor {
     intercept(context, next) {
         const request = context.switchToHttp().getRequest();
         const response = context.switchToHttp().getResponse();
-        // Проверяем, нужно ли исключить этот URL из логирования
-        if (this.shouldExcludeUrl(request.url)) {
+        const requestMethod = this.getRequestMethod(request.method);
+        if (this.shouldExcludeRequest(requestMethod, request.url)) {
             return next.handle();
         }
-        // Проверяем, есть ли декоратор ExcludeLogging на контроллере или методе
         const isExcluded = this.reflector.getAllAndOverride(constants_1.LOGGER_EXCLUDE_METADATA, [context.getHandler(), context.getClass()]);
         if (isExcluded) {
             return next.handle();
@@ -44,17 +43,27 @@ let HttpLoggerInterceptor = class HttpLoggerInterceptor {
         const requestId = this.requestIdGenerator.generate();
         const startTime = Date.now();
         return next.handle().pipe((0, operators_1.tap)(() => {
-            const entry = this.createLogEntry(request, response, requestId, startTime, 30, // INFO level
-            "request completed");
-            this.logger.logHttpRequest(entry);
+            if (this.config.format === "pino") {
+                const entry = this.createHttpLogEntry(request, response, requestId, startTime, 30, "request completed");
+                this.logger.logHttpRequest(entry);
+            }
+            else {
+                const entry = this.createLogEntry(request, response, requestId, startTime);
+                this.logger.log(entry);
+            }
         }), (0, operators_1.catchError)((error) => {
-            const entry = this.createLogEntry(request, response, requestId, startTime, 50, // ERROR level
-            "request failed");
-            this.logger.logHttpRequest(entry);
+            if (this.config.format === "pino") {
+                const entry = this.createHttpLogEntry(request, response, requestId, startTime, 50, "request failed");
+                this.logger.logHttpRequest(entry);
+            }
+            else {
+                const entry = this.createLogEntry(request, response, requestId, startTime);
+                this.logger.error(entry);
+            }
             throw error;
         }));
     }
-    createLogEntry(request, response, requestId, startTime, level, message) {
+    createHttpLogEntry(request, response, requestId, startTime, level, message) {
         const responseTime = Date.now() - startTime;
         const ip = this.getClientIp(request);
         const httpRequest = {
@@ -83,6 +92,23 @@ let HttpLoggerInterceptor = class HttpLoggerInterceptor {
             msg: message,
         };
     }
+    createLogEntry(request, response, requestId, startTime) {
+        const responseTime = Date.now() - startTime;
+        const ip = this.getClientIp(request);
+        return {
+            message: `${request.method} ${request.url} - ${response.statusCode || 500} (${responseTime}ms)`,
+            context: "HttpLogger",
+            metadata: {
+                requestId,
+                method: request.method,
+                url: request.url,
+                statusCode: response.statusCode || 500,
+                responseTime,
+                remoteAddress: ip,
+                userAgent: request.headers["user-agent"],
+            },
+        };
+    }
     getClientIp(request) {
         return (request.headers["x-forwarded-for"] ||
             request.headers["x-real-ip"] ||
@@ -105,16 +131,37 @@ let HttpLoggerInterceptor = class HttpLoggerInterceptor {
         }
         return this.dataSanitizer.sanitize(sanitized);
     }
-    shouldExcludeUrl(url) {
-        return this.config.exclude.some((excludeUrl) => {
-            // Поддержка простых паттернов с * (wildcard)
-            if (excludeUrl.includes("*")) {
-                const pattern = excludeUrl.replace(/\*/g, ".*");
+    getRequestMethod(method) {
+        switch (method.toUpperCase()) {
+            case "GET":
+                return common_1.RequestMethod.GET;
+            case "POST":
+                return common_1.RequestMethod.POST;
+            case "PUT":
+                return common_1.RequestMethod.PUT;
+            case "DELETE":
+                return common_1.RequestMethod.DELETE;
+            case "PATCH":
+                return common_1.RequestMethod.PATCH;
+            case "OPTIONS":
+                return common_1.RequestMethod.OPTIONS;
+            case "HEAD":
+                return common_1.RequestMethod.HEAD;
+            default:
+                return common_1.RequestMethod.ALL;
+        }
+    }
+    shouldExcludeRequest(method, path) {
+        return this.config.exclude.some((excludeOption) => {
+            if (excludeOption.method !== method) {
+                return false;
+            }
+            if (excludeOption.path.includes("*")) {
+                const pattern = excludeOption.path.replace(/\*/g, ".*");
                 const regex = new RegExp(`^${pattern}$`);
-                return regex.test(url);
+                return regex.test(path);
             }
-            // Точное совпадение
-            return url === excludeUrl;
+            return path === excludeOption.path;
         });
     }
 };

package/dist/core/logger.module.d.ts

@@ -1,4 +1,5 @@
 import { DynamicModule } from "@nestjs/common";
+import { ExcludeOption } from "../types";
 export interface LoggerModuleOptions {
     level?: "error" | "warn" | "info" | "debug" | "verbose";
     timestamp?: boolean;
@@ -6,7 +7,7 @@ export interface LoggerModuleOptions {
     context?: string;
     format?: "json" | "text" | "pino";
     sensitiveFields?: string[];
-    exclude?: string[];
+    exclude?: ExcludeOption[];
 }
 export interface LoggerModuleAsyncOptions {
     useFactory: (...args: any[]) => LoggerModuleOptions | Promise<LoggerModuleOptions>;

package/dist/formatters/base-formatter.d.ts

@@ -9,4 +9,6 @@ export declare abstract class BaseFormatter implements ILogFormatter {
     protected formatTimestamp(timestamp: Date): string;
     protected colorize(text: string, color: keyof typeof COLORS): string;
     protected getColorForLevel(level: string | number): keyof typeof COLORS;
+    private getColorForStringLevel;
+    private getColorForNumericLevel;
 }

package/dist/formatters/base-formatter.js

@@ -16,22 +16,21 @@ class BaseFormatter {
     }
     getColorForLevel(level) {
         if (typeof level === "string") {
-            switch (level) {
-                case "error":
-                    return "red";
-                case "warn":
-                    return "yellow";
-                case "info":
-                    return "green";
-                case "debug":
-                    return "blue";
-                case "verbose":
-                    return "magenta";
-                default:
-                    return "gray";
-            }
+            return this.getColorForStringLevel(level);
         }
-        // Для числовых уровней (Pino)
+        return this.getColorForNumericLevel(level);
+    }
+    getColorForStringLevel(level) {
+        const colorMap = {
+            error: "red",
+            warn: "yellow",
+            info: "green",
+            debug: "blue",
+            verbose: "magenta",
+        };
+        return colorMap[level] || "gray";
+    }
+    getColorForNumericLevel(level) {
         if (level >= 50)
             return "red";
         if (level >= 40)

package/dist/formatters/json-formatter.d.ts

@@ -3,4 +3,6 @@ import { LogEntry, HttpRequestLogEntry } from "../types";
 export declare class JsonFormatter extends BaseFormatter {
     format(entry: LogEntry): string;
     formatHttpRequest(entry: HttpRequestLogEntry): string;
+    private buildLogObject;
+    private addOptionalFields;
 }

package/dist/formatters/json-formatter.js

@@ -11,23 +11,35 @@ const common_1 = require("@nestjs/common");
 const base_formatter_1 = require("./base-formatter");
 let JsonFormatter = class JsonFormatter extends base_formatter_1.BaseFormatter {
     format(entry) {
-        const logObject = {
+        const logObject = this.buildLogObject(entry);
+        return JSON.stringify(logObject);
+    }
+    formatHttpRequest(entry) {
+        const jsonString = JSON.stringify(entry);
+        return this.options.colors
+            ? this.colorize(jsonString, this.getColorForLevel(entry.level))
+            : jsonString;
+    }
+    buildLogObject(entry) {
+        const baseObject = {
             timestamp: this.formatTimestamp(entry.timestamp),
             level: entry.level,
             message: entry.message,
-            ...(entry.context && { context: entry.context }),
-            ...(entry.metadata && { metadata: entry.metadata }),
-            ...(entry.trace && { trace: entry.trace }),
         };
-        return JSON.stringify(logObject);
+        return this.addOptionalFields(baseObject, entry);
     }
-    formatHttpRequest(entry) {
-        const jsonString = JSON.stringify(entry);
-        if (this.options.colors) {
-            const color = this.getColorForLevel(entry.level);
-            return this.colorize(jsonString, color);
+    addOptionalFields(baseObject, entry) {
+        const result = { ...baseObject };
+        if (entry.context) {
+            result.context = entry.context;
+        }
+        if (entry.metadata) {
+            result.metadata = entry.metadata;
+        }
+        if (entry.trace) {
+            result.trace = entry.trace;
         }
-        return jsonString;
+        return result;
     }
 };
 exports.JsonFormatter = JsonFormatter;

package/dist/formatters/pino-formatter.js

@@ -15,11 +15,9 @@ let PinoFormatter = class PinoFormatter extends base_formatter_1.BaseFormatter {
     }
     formatHttpRequest(entry) {
         const jsonString = JSON.stringify(entry);
-        if (this.options.colors) {
-            const color = this.getColorForLevel(entry.level);
-            return this.colorize(jsonString, color);
-        }
-        return jsonString;
+        return this.options.colors
+            ? this.colorize(jsonString, this.getColorForLevel(entry.level))
+            : jsonString;
     }
 };
 exports.PinoFormatter = PinoFormatter;

package/dist/formatters/text-formatter.d.ts

@@ -3,4 +3,12 @@ import { LogEntry, HttpRequestLogEntry } from "../types";
 export declare class TextFormatter extends BaseFormatter {
     format(entry: LogEntry): string;
     formatHttpRequest(entry: HttpRequestLogEntry): string;
+    private buildLogParts;
+    private addTimestamp;
+    private addLevel;
+    private addContext;
+    private addMessage;
+    private addMetadata;
+    private hasMetadata;
+    private addTrace;
 }

package/dist/formatters/text-formatter.js

@@ -11,32 +11,54 @@ const common_1 = require("@nestjs/common");
 const base_formatter_1 = require("./base-formatter");
 let TextFormatter = class TextFormatter extends base_formatter_1.BaseFormatter {
     format(entry) {
+        const parts = this.buildLogParts(entry);
+        const result = parts.join(" ");
+        return entry.trace ? this.addTrace(result, entry.trace) : result;
+    }
+    formatHttpRequest(entry) {
+        return JSON.stringify(entry);
+    }
+    buildLogParts(entry) {
         const parts = [];
+        this.addTimestamp(parts, entry);
+        this.addLevel(parts, entry);
+        this.addContext(parts, entry);
+        this.addMessage(parts, entry);
+        this.addMetadata(parts, entry);
+        return parts;
+    }
+    addTimestamp(parts, entry) {
         if (this.options.timestamp) {
             const timestamp = this.colorize(`[${this.formatTimestamp(entry.timestamp)}]`, "gray");
             parts.push(timestamp);
         }
+    }
+    addLevel(parts, entry) {
         const level = this.colorize(`[${entry.level.toUpperCase()}]`, this.getColorForLevel(entry.level));
         parts.push(level);
+    }
+    addContext(parts, entry) {
         if (entry.context) {
             const context = this.colorize(`[${entry.context}]`, "cyan");
             parts.push(context);
         }
+    }
+    addMessage(parts, entry) {
         const message = this.colorize(entry.message, "bright");
         parts.push(message);
-        if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+    }
+    addMetadata(parts, entry) {
+        if (this.hasMetadata(entry)) {
             const metadata = this.colorize(JSON.stringify(entry.metadata), "gray");
             parts.push(metadata);
         }
-        let result = parts.join(" ");
-        if (entry.trace) {
-            const trace = this.colorize(entry.trace, "red");
-            result += `\n${trace}`;
-        }
-        return result;
     }
-    formatHttpRequest(entry) {
-        return JSON.stringify(entry);
+    hasMetadata(entry) {
+        return Boolean(entry.metadata && Object.keys(entry.metadata).length > 0);
+    }
+    addTrace(result, trace) {
+        const coloredTrace = this.colorize(trace, "red");
+        return `${result}\n${coloredTrace}`;
     }
 };
 exports.TextFormatter = TextFormatter;

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+import { RequestMethod } from "@nestjs/common";
 export type LogLevel = "error" | "warn" | "info" | "debug" | "verbose";
 export type LogFormat = "json" | "text" | "pino";
 export declare const LOG_LEVELS: Record<LogLevel, number>;
@@ -35,6 +36,10 @@ export interface HttpResponse {
     readonly statusCode: number;
     readonly headers: Record<string, string>;
 }
+export interface ExcludeOption {
+    method: RequestMethod;
+    path: string;
+}
 export interface LoggerConfiguration {
     readonly level: LogLevel;
     readonly timestamp: boolean;
@@ -42,7 +47,7 @@ export interface LoggerConfiguration {
     readonly context?: string;
     readonly format: LogFormat;
     readonly sensitiveFields: readonly string[];
-    readonly exclude: readonly string[];
+    readonly exclude: readonly ExcludeOption[];
 }
 export interface FormatterOptions {
     readonly colors: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@globalart/nestjs-logger",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "A advanced logger for NestJS",
   "author": {
     "name": "GlobalArt, Inc"
@@ -34,6 +34,7 @@
     "test:cov": "jest --coverage --passWithNoTests",
     "coveralls": "yarn run test:cov --coverageReporters=text-lcov | coveralls",
     "build": "rm -rf ./dist && tsc",
+    "build:watch": "tsc --watch",
     "prepublishOnly": "npm run build",
     "publish:dev": "npm publish --access public --tag dev",
     "publish:npm": "release-it"
@@ -41,7 +42,7 @@
   "dependencies": {
     "@nestjs/common": "^11.1.3",
     "@nestjs/core": "^11.1.3",
-    "@nestjs/microservices": "11.1.5",
+    "@nestjs/microservices": "11.1.6",
     "@nestjs/swagger": "^11.2.0",
     "@nestjs/testing": "^11.1.3",
     "@nestjs/typeorm": "^11.0.0"

package/README.md

@@ -1,263 +0,0 @@
-# @globalart/nestjs-logger
-
-Профессиональный модуль логирования для NestJS с чистой архитектурой, строгой типизацией и расширяемостью.
-
-## 🚀 Особенности
-
-- **Clean Architecture** - разделение ответственности, SOLID принципы
-- **Строгая типизация** - полная типобезопасность TypeScript
-- **Производительность** - оптимизированная архитектура без лишних аллокаций
-- **Расширяемость** - легко добавлять новые форматтеры и транспорты
-- **Тестируемость** - dependency injection, легкое мокирование
-- **Автоматический контекст** - определение класса из стека вызовов
-- **HTTP логирование** - детальное логирование запросов
-- **Безопасность** - автоматическая санитизация чувствительных данных
-- **Цветной вывод** - красивые логи в консоли
-
-## 📦 Установка
-
-```bash
-npm install @globalart/nestjs-logger
-```
-
-## 🎯 Быстрый старт
-
-```typescript
-import { Module } from '@nestjs/common';
-import { LoggerModule } from '@globalart/nestjs-logger';
-
-@Module({
-  imports: [
-    LoggerModule.forRoot({
-      level: 'info',
-      timestamp: true,
-      colors: true,
-      format: 'text',
-    }),
-  ],
-})
-export class AppModule {}
-```
-
-## 🔧 Конфигурация
-
-### Синхронная конфигурация
-
-```typescript
-LoggerModule.forRoot({
-  level: 'debug',
-  timestamp: true,
-  colors: true,
-  format: 'pino',
-  sensitiveFields: ['password', 'secret'],
-})
-```
-
-### Асинхронная конфигурация
-
-```typescript
-LoggerModule.forRootAsync({
-  useFactory: (configService: ConfigService) => ({
-    level: configService.get('LOG_LEVEL', 'info'),
-    format: configService.get('LOG_FORMAT', 'text'),
-    colors: !configService.get('PRODUCTION'),
-  }),
-  inject: [ConfigService],
-})
-```
-
-## 📝 Использование
-
-### В сервисах
-
-```typescript
-import { Injectable } from '@nestjs/common';
-import { LoggerService } from '@globalart/nestjs-logger';
-
-@Injectable()
-export class UserService {
-  constructor(private readonly logger: LoggerService) {}
-
-  async createUser(userData: CreateUserDto) {
-    this.logger.log('Creating new user', undefined, { userId: userData.email });
-    
-    try {
-      const user = await this.userRepository.save(userData);
-      this.logger.log('User created successfully', undefined, { id: user.id });
-      return user;
-    } catch (error) {
-      this.logger.error('Failed to create user', error.stack, undefined, { 
-        email: userData.email 
-      });
-      throw error;
-    }
-  }
-}
-```
-
-### HTTP логирование
-
-```typescript
-import { Controller, UseInterceptors } from '@nestjs/common';
-import { HttpLoggerInterceptor, LogContext } from '@globalart/nestjs-logger';
-
-@Controller('users')
-@UseInterceptors(HttpLoggerInterceptor)
-@LogContext('UserController')
-export class UserController {
-  // Все HTTP запросы будут автоматически логироваться
-}
-```
-
-### Глобальное HTTP логирование
-
-```typescript
-import { Module } from '@nestjs/common';
-import { APP_INTERCEPTOR } from '@nestjs/core';
-import { LoggerModule, HttpLoggerInterceptor } from '@globalart/nestjs-logger';
-
-@Module({
-  imports: [LoggerModule.forRoot()],
-  providers: [
-    {
-      provide: APP_INTERCEPTOR,
-      useClass: HttpLoggerInterceptor,
-    },
-  ],
-})
-export class AppModule {}
-```
-
-## 🎨 Форматы вывода
-
-### Text (по умолчанию)
-```
-[2024-01-15T10:30:45.123Z] [INFO] [UserService] Creating new user {"userId":"123"}
-```
-
-### JSON
-```json
-{
-  "timestamp": "2024-01-15T10:30:45.123Z",
-  "level": "info",
-  "message": "Creating new user",
-  "context": "UserService",
-  "metadata": {"userId": "123"}
-}
-```
-
-### Pino (HTTP запросы)
-```json
-{"level":30,"time":1642247445123,"pid":1234,"hostname":"app-server","req":{"id":"req-123","method":"GET","url":"/users","query":{},"params":{},"headers":{},"remoteAddress":"127.0.0.1"},"res":{"statusCode":200,"headers":{}},"responseTime":15,"msg":"request completed"}
-```
-
-## 🎯 API Reference
-
-### LoggerService
-
-| Метод | Описание |
-|-------|----------|
-| `log(message, context?, metadata?)` | Информационное сообщение |
-| `error(message, trace?, context?, metadata?)` | Ошибка с трейсом |
-| `warn(message, context?, metadata?)` | Предупреждение |
-| `debug(message, context?, metadata?)` | Отладочная информация |
-| `verbose(message, context?, metadata?)` | Подробное логирование |
-| `setContext(context)` | Установка контекста |
-
-### Декораторы
-
-- `@LogContext(context)` - Установка контекста для класса/метода
-- `@LogMetadata(metadata)` - Добавление метаданных
-
-### Конфигурация
-
-| Опция | Тип | По умолчанию | Описание |
-|-------|-----|--------------|----------|
-| `level` | `LogLevel` | `'info'` | Уровень логирования |
-| `timestamp` | `boolean` | `true` | Показывать время |
-| `colors` | `boolean` | `true` | Цветной вывод |
-| `format` | `LogFormat` | `'text'` | Формат вывода |
-| `context` | `string` | `undefined` | Контекст по умолчанию |
-| `sensitiveFields` | `string[]` | `[...]` | Поля для санитизации |
-
-## 🏗️ Архитектура
-
-Пакет построен на принципах Clean Architecture:
-
-- **Types** - строгая типизация
-- **Contracts** - интерфейсы для расширяемости  
-- **Core** - основная бизнес-логика
-- **Utils** - вспомогательные утилиты
-- **Formatters** - форматирование логов
-- **Writers** - вывод логов
-
-## 🔒 Безопасность
-
-Автоматическая санитизация чувствительных полей:
-- `password`, `pass`
-- `token`, `accessToken`, `refreshToken`
-- `secret`, `key`, `apiKey`
-- `authorization`, `auth`
-- `credential`, `credentials`
-
-## 🧪 Тестирование
-
-```typescript
-import { LoggerService } from '@globalart/nestjs-logger';
-
-describe('UserService', () => {
-  let service: UserService;
-  let logger: jest.Mocked<LoggerService>;
-
-  beforeEach(() => {
-    logger = {
-      log: jest.fn(),
-      error: jest.fn(),
-      // ... другие методы
-    } as any;
-
-    service = new UserService(logger);
-  });
-
-  it('should log user creation', () => {
-    service.createUser(userData);
-    expect(logger.log).toHaveBeenCalledWith(
-      'Creating new user',
-      undefined,
-      { userId: userData.email }
-    );
-  });
-});
-```
-
-## 🔄 Миграция с v1
-
-```typescript
-// v1 (старый API)
-import { LoggerModule, LoggerInterceptor } from '@globalart/nestjs-logger';
-
-// v2 (новый API)  
-import { LoggerModule, HttpLoggerInterceptor } from '@globalart/nestjs-logger';
-
-// Для совместимости доступны legacy экспорты:
-import { LegacyLoggerModule, LoggerInterceptor } from '@globalart/nestjs-logger';
-```
-
-## 📈 Производительность
-
-- Минимальные аллокации в горячих путях
-- Ленивая инициализация форматтеров
-- Оптимизированное определение контекста
-- Эффективная санитизация данных
-
-## 🤝 Вклад в развитие
-
-1. Fork репозитория
-2. Создайте feature branch
-3. Внесите изменения
-4. Добавьте тесты
-5. Создайте Pull Request
-
-## 📄 Лицензия
-
-MIT License