@globalart/nestjs-logger 1.0.4 → 1.0.6

package/dist/constants/index.d.ts

@@ -1,7 +1,8 @@
-export declare const LOGGER_CONFIG_TOKEN = "LOGGER_CONFIG";
-export declare const LOGGER_CONTEXT_METADATA = "LOGGER_CONTEXT";
-export declare const LOGGER_METADATA_METADATA = "LOGGER_METADATA";
-export declare const LOGGER_EXCLUDE_METADATA = "LOGGER_EXCLUDE";
+export declare const LOGGER_CONFIG_TOKEN: unique symbol;
+export declare const LOGGER_SERVICE_TOKEN: unique symbol;
+export declare const LOGGER_CONTEXT_METADATA: unique symbol;
+export declare const LOGGER_METADATA_METADATA: unique symbol;
+export declare const LOGGER_EXCLUDE_METADATA: unique symbol;
 export declare const DEFAULT_SENSITIVE_FIELDS: readonly ["password", "pass", "token", "accessToken", "refreshToken", "secret", "key", "apiKey", "authorization", "auth", "credential", "credentials"];
 export declare const COLORS: {
     readonly reset: "\u001B[0m";

package/dist/constants/index.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_LOGGER_CONFIG = exports.COLORS = exports.DEFAULT_SENSITIVE_FIELDS = exports.LOGGER_EXCLUDE_METADATA = exports.LOGGER_METADATA_METADATA = exports.LOGGER_CONTEXT_METADATA = exports.LOGGER_CONFIG_TOKEN = void 0;
-exports.LOGGER_CONFIG_TOKEN = "LOGGER_CONFIG";
-exports.LOGGER_CONTEXT_METADATA = "LOGGER_CONTEXT";
-exports.LOGGER_METADATA_METADATA = "LOGGER_METADATA";
-exports.LOGGER_EXCLUDE_METADATA = "LOGGER_EXCLUDE";
+exports.DEFAULT_LOGGER_CONFIG = exports.COLORS = exports.DEFAULT_SENSITIVE_FIELDS = exports.LOGGER_EXCLUDE_METADATA = exports.LOGGER_METADATA_METADATA = exports.LOGGER_CONTEXT_METADATA = exports.LOGGER_SERVICE_TOKEN = exports.LOGGER_CONFIG_TOKEN = void 0;
+exports.LOGGER_CONFIG_TOKEN = Symbol("LOGGER_CONFIG");
+exports.LOGGER_SERVICE_TOKEN = Symbol("LOGGER_SERVICE");
+exports.LOGGER_CONTEXT_METADATA = Symbol("LOGGER_CONTEXT");
+exports.LOGGER_METADATA_METADATA = Symbol("LOGGER_METADATA");
+exports.LOGGER_EXCLUDE_METADATA = Symbol("LOGGER_EXCLUDE");
 exports.DEFAULT_SENSITIVE_FIELDS = [
     "password",
     "pass",

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

@@ -18,5 +18,6 @@ export declare class HttpLoggerInterceptor implements NestInterceptor {
     private createLogEntry;
     private getClientIp;
     private sanitizeHeaders;
-    private shouldExcludeUrl;
+    private getRequestMethod;
+    private shouldExcludeRequest;
 }

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

@@ -32,7 +32,8 @@ let HttpLoggerInterceptor = class HttpLoggerInterceptor {
     intercept(context, next) {
         const request = context.switchToHttp().getRequest();
         const response = context.switchToHttp().getResponse();
-        if (this.shouldExcludeUrl(request.url)) {
+        const requestMethod = this.getRequestMethod(request.method);
+        if (this.shouldExcludeRequest(requestMethod, request.url)) {
             return next.handle();
         }
         const isExcluded = this.reflector.getAllAndOverride(constants_1.LOGGER_EXCLUDE_METADATA, [context.getHandler(), context.getClass()]);
@@ -130,14 +131,37 @@ let HttpLoggerInterceptor = class HttpLoggerInterceptor {
         }
         return this.dataSanitizer.sanitize(sanitized);
     }
-    shouldExcludeUrl(url) {
-        return this.config.exclude.some((excludeUrl) => {
-            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.di-tokens.d.ts

@@ -0,0 +1 @@
+export declare const InjectLogger: () => PropertyDecorator & ParameterDecorator;

package/dist/core/logger.di-tokens.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectLogger = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("../constants");
+const InjectLogger = () => (0, common_1.Inject)(constants_1.LOGGER_SERVICE_TOKEN);
+exports.InjectLogger = InjectLogger;

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/core/logger.module.js

@@ -25,7 +25,7 @@ let LoggerModule = LoggerModule_1 = class LoggerModule {
         return {
             module: LoggerModule_1,
             providers,
-            exports: [logger_service_1.LoggerService, http_logger_interceptor_1.HttpLoggerInterceptor],
+            exports: [constants_1.LOGGER_SERVICE_TOKEN, http_logger_interceptor_1.HttpLoggerInterceptor],
             global: true,
         };
     }
@@ -42,7 +42,7 @@ let LoggerModule = LoggerModule_1 = class LoggerModule {
         return {
             module: LoggerModule_1,
             providers,
-            exports: [logger_service_1.LoggerService, http_logger_interceptor_1.HttpLoggerInterceptor],
+            exports: [constants_1.LOGGER_SERVICE_TOKEN, http_logger_interceptor_1.HttpLoggerInterceptor],
             global: true,
         };
     }
@@ -75,7 +75,7 @@ let LoggerModule = LoggerModule_1 = class LoggerModule {
                 inject: [constants_1.LOGGER_CONFIG_TOKEN],
             },
             {
-                provide: logger_service_1.LoggerService,
+                provide: constants_1.LOGGER_SERVICE_TOKEN,
                 useFactory: (config, formatterFactory, writer, contextResolver) => {
                     const formatter = formatterFactory.create(config.format, {
                         colors: config.colors,
@@ -98,7 +98,7 @@ let LoggerModule = LoggerModule_1 = class LoggerModule {
                     return new http_logger_interceptor_1.HttpLoggerInterceptor(logger, dataSanitizer, requestIdGenerator, config, reflector);
                 },
                 inject: [
-                    logger_service_1.LoggerService,
+                    constants_1.LOGGER_SERVICE_TOKEN,
                     data_sanitizer_1.DataSanitizer,
                     request_id_generator_1.RequestIdGenerator,
                     constants_1.LOGGER_CONFIG_TOKEN,

package/dist/decorators/index.d.ts

@@ -1,12 +1,13 @@
+import { LOGGER_CONTEXT_METADATA, LOGGER_METADATA_METADATA, LOGGER_EXCLUDE_METADATA } from "../constants";
 /**
  * Decorator to set logging context for a class or method
  */
-export declare const LogContext: (context: string) => import("@nestjs/common").CustomDecorator<string>;
+export declare const LogContext: (context: string) => import("@nestjs/common").CustomDecorator<typeof LOGGER_CONTEXT_METADATA>;
 /**
  * Decorator to add metadata to logs
  */
-export declare const LogMetadata: (metadata: Record<string, unknown>) => import("@nestjs/common").CustomDecorator<string>;
+export declare const LogMetadata: (metadata: Record<string, unknown>) => import("@nestjs/common").CustomDecorator<typeof LOGGER_METADATA_METADATA>;
 /**
  * Decorator to exclude logging for a controller or method
  */
-export declare const ExcludeLogging: () => import("@nestjs/common").CustomDecorator<string>;
+export declare const ExcludeLogging: () => import("@nestjs/common").CustomDecorator<typeof LOGGER_EXCLUDE_METADATA>;

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/index.d.ts

@@ -1,4 +1,5 @@
 export { LoggerModule, LoggerModuleOptions, LoggerModuleAsyncOptions, } from "./core/logger.module";
+export { InjectLogger } from "./core/logger.di-tokens";
 export { LoggerService } from "./core/logger.service";
 export { HttpLoggerInterceptor } from "./core/http-logger.interceptor";
 export { LogContext, LogMetadata, ExcludeLogging } from "./decorators";

package/dist/index.js

@@ -14,10 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExcludeLogging = exports.LogMetadata = exports.LogContext = exports.HttpLoggerInterceptor = exports.LoggerService = exports.LoggerModule = void 0;
+exports.ExcludeLogging = exports.LogMetadata = exports.LogContext = exports.HttpLoggerInterceptor = exports.LoggerService = exports.InjectLogger = exports.LoggerModule = void 0;
 // Core
 var logger_module_1 = require("./core/logger.module");
 Object.defineProperty(exports, "LoggerModule", { enumerable: true, get: function () { return logger_module_1.LoggerModule; } });
+var logger_di_tokens_1 = require("./core/logger.di-tokens");
+Object.defineProperty(exports, "InjectLogger", { enumerable: true, get: function () { return logger_di_tokens_1.InjectLogger; } });
 var logger_service_1 = require("./core/logger.service");
 Object.defineProperty(exports, "LoggerService", { enumerable: true, get: function () { return logger_service_1.LoggerService; } });
 var http_logger_interceptor_1 = require("./core/http-logger.interceptor");

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.4",
+  "version": "1.0.6",
   "description": "A advanced logger for NestJS",
   "author": {
     "name": "GlobalArt, Inc"
@@ -42,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,364 +0,0 @@
-# @globalart/nestjs-logger
-
-A professional logging module for NestJS with clean architecture, strict typing, and extensibility.
-
-## 🚀 Features
-
-- **Clean Architecture** - separation of concerns, SOLID principles
-- **Strict Typing** - full TypeScript type safety
-- **Performance** - optimized architecture with minimal allocations
-- **Extensibility** - easy to add new formatters and transports
-- **Testability** - dependency injection, easy mocking
-- **Automatic Context** - class detection from call stack
-- **HTTP Logging** - detailed request logging with format consistency
-- **Security** - automatic sanitization of sensitive data
-- **Colored Output** - beautiful console logs
-- **Multiple Formats** - Text, JSON, and Pino support
-
-## 📦 Installation
-
-```bash
-npm install @globalart/nestjs-logger
-```
-
-## 🎯 Quick Start
-
-```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 {}
-```
-
-## 🔧 Configuration
-
-### Synchronous Configuration
-
-```typescript
-LoggerModule.forRoot({
-  level: 'debug',
-  timestamp: true,
-  colors: true,
-  format: 'pino',
-  sensitiveFields: ['password', 'secret'],
-  exclude: ['/health', '/metrics'],
-})
-```
-
-### Asynchronous Configuration
-
-```typescript
-LoggerModule.forRootAsync({
-  useFactory: (configService: ConfigService) => ({
-    level: configService.get('LOG_LEVEL', 'info'),
-    format: configService.get('LOG_FORMAT', 'text'),
-    colors: !configService.get('PRODUCTION'),
-    sensitiveFields: configService.get('SENSITIVE_FIELDS', []),
-  }),
-  inject: [ConfigService],
-})
-```
-
-## 📝 Usage
-
-### In Services
-
-```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({
-      message: 'Creating new user',
-      metadata: { userId: userData.email }
-    });
-    
-    try {
-      const user = await this.userRepository.save(userData);
-      this.logger.log({
-        message: 'User created successfully',
-        metadata: { id: user.id }
-      });
-      return user;
-    } catch (error) {
-      this.logger.error({
-        message: 'Failed to create user',
-        trace: error.stack,
-        metadata: { email: userData.email }
-      });
-      throw error;
-    }
-  }
-}
-```
-
-### HTTP Logging
-
-```typescript
-import { Controller, UseInterceptors } from '@nestjs/common';
-import { HttpLoggerInterceptor, LogContext } from '@globalart/nestjs-logger';
-
-@Controller('users')
-@UseInterceptors(HttpLoggerInterceptor)
-@LogContext('UserController')
-export class UserController {
-  // All HTTP requests will be automatically logged
-}
-```
-
-### Global HTTP Logging
-
-```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 {}
-```
-
-## 🎨 Output Formats
-
-### Text Format (Default)
-```
-[2024-01-15T10:30:45.123Z] [INFO] [UserService] Creating new user {"userId":"123"}
-[2024-01-15T10:30:45.335Z] [INFO] [HttpLogger] GET /users - 200 (12ms)
-```
-
-### JSON Format
-```json
-{
-  "timestamp": "2024-01-15T10:30:45.123Z",
-  "level": "info",
-  "message": "Creating new user",
-  "context": "UserService",
-  "metadata": {"userId": "123"}
-}
-{
-  "timestamp": "2024-01-15T10:30:45.335Z",
-  "level": "info",
-  "message": "GET /users - 200 (12ms)",
-  "context": "HttpLogger",
-  "metadata": {
-    "requestId": "req-123",
-    "method": "GET",
-    "url": "/users",
-    "statusCode": 200,
-    "responseTime": 12,
-    "remoteAddress": "127.0.0.1"
-  }
-}
-```
-
-### Pino Format
-```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":12,"msg":"request completed"}
-```
-
-## 🎯 API Reference
-
-### LoggerService
-
-| Method | Description |
-|--------|-------------|
-| `log(options: LogOptions)` | Information message |
-| `error(options: LogOptions)` | Error with trace |
-| `warn(options: LogOptions)` | Warning message |
-| `debug(options: LogOptions)` | Debug information |
-| `verbose(options: LogOptions)` | Verbose logging |
-| `setContext(context: string)` | Set context |
-| `logHttpRequest(entry: HttpRequestLogEntry)` | Log HTTP request (Pino format only) |
-
-### LogOptions Interface
-
-```typescript
-interface LogOptions {
-  message: string;
-  context?: string;
-  metadata?: Record<string, unknown>;
-  trace?: string;
-}
-```
-
-### Decorators
-
-- `@LogContext(context: string)` - Set context for class/method
-- `@LogMetadata(metadata: Record<string, unknown>)` - Add metadata to logs
-- `@ExcludeLogging()` - Exclude logging for controller/method
-
-### Configuration Options
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `level` | `LogLevel` | `'info'` | Logging level |
-| `timestamp` | `boolean` | `true` | Show timestamp |
-| `colors` | `boolean` | `true` | Colored output |
-| `format` | `LogFormat` | `'text'` | Output format |
-| `context` | `string` | `undefined` | Default context |
-| `sensitiveFields` | `string[]` | `[...]` | Fields to sanitize |
-| `exclude` | `string[]` | `[]` | URLs to exclude from HTTP logging |
-
-## 🏗️ Architecture
-
-The package is built on Clean Architecture principles:
-
-### Core Components
-
-- **LoggerModule** - Main module with configuration
-- **LoggerService** - Primary logging service
-- **HttpLoggerInterceptor** - HTTP request logging interceptor
-
-### Formatters
-
-- **TextFormatter** - Human-readable text output
-- **JsonFormatter** - Structured JSON output
-- **PinoFormatter** - Pino-compatible JSON output
-
-### Utilities
-
-- **ContextResolver** - Automatic context detection
-- **DataSanitizer** - Sensitive data sanitization
-- **RequestIdGenerator** - Unique request ID generation
-
-### Writers
-
-- **ConsoleWriter** - Console output (extensible for other transports)
-
-### Contracts & Types
-
-- **ILogger** - Logger interface
-- **ILogFormatter** - Formatter interface
-- **ILogWriter** - Writer interface
-- **LogEntry** - Standard log entry structure
-- **HttpRequestLogEntry** - HTTP-specific log entry structure
-
-## 🔒 Security
-
-Automatic sanitization of sensitive fields:
-- `password`, `pass`
-- `token`, `accessToken`, `refreshToken`
-- `secret`, `key`, `apiKey`
-- `authorization`, `auth`
-- `credential`, `credentials`
-
-## 🧪 Testing
-
-```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(),
-      warn: jest.fn(),
-      debug: jest.fn(),
-      verbose: jest.fn(),
-      setContext: jest.fn(),
-      logHttpRequest: jest.fn(),
-    } as any;
-
-    service = new UserService(logger);
-  });
-
-  it('should log user creation', () => {
-    service.createUser(userData);
-    expect(logger.log).toHaveBeenCalledWith({
-      message: 'Creating new user',
-      metadata: { userId: userData.email }
-    });
-  });
-});
-```
-
-## 🔄 Migration from v1
-
-```typescript
-// v1 (old API)
-import { LoggerModule, LoggerInterceptor } from '@globalart/nestjs-logger';
-
-// v2 (new API)  
-import { LoggerModule, HttpLoggerInterceptor } from '@globalart/nestjs-logger';
-
-// Legacy exports available for compatibility:
-import { LegacyLoggerModule, LoggerInterceptor } from '@globalart/nestjs-logger';
-```
-
-## 📈 Performance
-
-- Minimal allocations in hot paths
-- Lazy formatter initialization
-- Optimized context resolution
-- Efficient data sanitization
-- Format-specific HTTP logging optimization
-
-## 🎨 Customization
-
-### Custom Formatter
-
-```typescript
-import { Injectable } from '@nestjs/common';
-import { BaseFormatter } from '@globalart/nestjs-logger';
-
-@Injectable()
-export class CustomFormatter extends BaseFormatter {
-  format(entry: LogEntry): string {
-    return `[${entry.level.toUpperCase()}] ${entry.message}`;
-  }
-
-  formatHttpRequest(entry: HttpRequestLogEntry): string {
-    return JSON.stringify(entry);
-  }
-}
-```
-
-### Custom Writer
-
-```typescript
-import { Injectable } from '@nestjs/common';
-import { ILogWriter } from '@globalart/nestjs-logger';
-
-@Injectable()
-export class FileWriter implements ILogWriter {
-  write(formattedLog: string): void {
-    // Write to file
-  }
-}
-```
-
-## 🤝 Contributing
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Add tests
-5. Create a Pull Request
-
-## 📄 License
-
-MIT License