@globalart/nestjs-logger 1.0.1

package/README.md

@@ -0,0 +1,263 @@
+# @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 

package/dist/constants/index.d.ts

@@ -0,0 +1,22 @@
+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 DEFAULT_SENSITIVE_FIELDS: readonly ["password", "pass", "token", "accessToken", "refreshToken", "secret", "key", "apiKey", "authorization", "auth", "credential", "credentials"];
+export declare const COLORS: {
+    readonly reset: "\u001B[0m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+    readonly gray: "\u001B[90m";
+    readonly bright: "\u001B[1m";
+};
+export declare const DEFAULT_LOGGER_CONFIG: {
+    readonly level: "info";
+    readonly timestamp: true;
+    readonly colors: true;
+    readonly format: "text";
+    readonly sensitiveFields: readonly ["password", "pass", "token", "accessToken", "refreshToken", "secret", "key", "apiKey", "authorization", "auth", "credential", "credentials"];
+};

package/dist/constants/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LOGGER_CONFIG = exports.COLORS = exports.DEFAULT_SENSITIVE_FIELDS = 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.DEFAULT_SENSITIVE_FIELDS = [
+    "password",
+    "pass",
+    "token",
+    "accessToken",
+    "refreshToken",
+    "secret",
+    "key",
+    "apiKey",
+    "authorization",
+    "auth",
+    "credential",
+    "credentials",
+];
+exports.COLORS = {
+    reset: "\x1b[0m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[90m",
+    bright: "\x1b[1m",
+};
+exports.DEFAULT_LOGGER_CONFIG = {
+    level: "info",
+    timestamp: true,
+    colors: true,
+    format: "text",
+    sensitiveFields: exports.DEFAULT_SENSITIVE_FIELDS,
+};

package/dist/contracts/index.d.ts

@@ -0,0 +1,26 @@
+import { LogEntry, HttpRequestLogEntry } from "../types";
+export interface ILogger {
+    log(message: string, context?: string, metadata?: Record<string, unknown>): void;
+    error(message: string, trace?: string, context?: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, context?: string, metadata?: Record<string, unknown>): void;
+    debug(message: string, context?: string, metadata?: Record<string, unknown>): void;
+    verbose(message: string, context?: string, metadata?: Record<string, unknown>): void;
+    setContext(context: string): void;
+    logHttpRequest(entry: HttpRequestLogEntry): void;
+}
+export interface ILogFormatter {
+    format(entry: LogEntry): string;
+    formatHttpRequest(entry: HttpRequestLogEntry): string;
+}
+export interface ILogWriter {
+    write(formattedLog: string): void;
+}
+export interface IContextResolver {
+    resolve(): string;
+}
+export interface IDataSanitizer {
+    sanitize(data: unknown): unknown;
+}
+export interface IRequestIdGenerator {
+    generate(): string;
+}

package/dist/contracts/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,16 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from "@nestjs/common";
+import { Observable } from "rxjs";
+import { LoggerService } from "./logger.service";
+import { IDataSanitizer, IRequestIdGenerator } from "../contracts";
+export declare class HttpLoggerInterceptor implements NestInterceptor {
+    private readonly logger;
+    private readonly dataSanitizer;
+    private readonly requestIdGenerator;
+    private readonly hostname;
+    private readonly pid;
+    constructor(logger: LoggerService, dataSanitizer: IDataSanitizer, requestIdGenerator: IRequestIdGenerator);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+    private createLogEntry;
+    private getClientIp;
+    private sanitizeHeaders;
+}

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

@@ -0,0 +1,97 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpLoggerInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const operators_1 = require("rxjs/operators");
+const logger_service_1 = require("./logger.service");
+const os_1 = require("os");
+let HttpLoggerInterceptor = class HttpLoggerInterceptor {
+    constructor(logger, dataSanitizer, requestIdGenerator) {
+        this.logger = logger;
+        this.dataSanitizer = dataSanitizer;
+        this.requestIdGenerator = requestIdGenerator;
+        this.hostname = (0, os_1.hostname)();
+        this.pid = process.pid;
+    }
+    intercept(context, next) {
+        const request = context.switchToHttp().getRequest();
+        const response = context.switchToHttp().getResponse();
+        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);
+        }), (0, operators_1.catchError)((error) => {
+            const entry = this.createLogEntry(request, response, requestId, startTime, 50, // ERROR level
+            "request failed");
+            this.logger.logHttpRequest(entry);
+            throw error;
+        }));
+    }
+    createLogEntry(request, response, requestId, startTime, level, message) {
+        const responseTime = Date.now() - startTime;
+        const ip = this.getClientIp(request);
+        const httpRequest = {
+            id: requestId,
+            method: request.method,
+            url: request.url,
+            query: request.query || {},
+            params: request.params || {},
+            headers: this.sanitizeHeaders(request.headers || {}),
+            remoteAddress: ip,
+            remotePort: request.connection?.remotePort,
+            body: this.dataSanitizer.sanitize(request.body),
+        };
+        const httpResponse = {
+            statusCode: response.statusCode || 500,
+            headers: this.sanitizeHeaders(response.getHeaders?.() || {}),
+        };
+        return {
+            level,
+            time: Date.now(),
+            pid: this.pid,
+            hostname: this.hostname,
+            req: httpRequest,
+            res: httpResponse,
+            responseTime,
+            msg: message,
+        };
+    }
+    getClientIp(request) {
+        return (request.headers["x-forwarded-for"] ||
+            request.headers["x-real-ip"] ||
+            request.connection?.remoteAddress ||
+            request.socket?.remoteAddress ||
+            "unknown");
+    }
+    sanitizeHeaders(headers) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(headers)) {
+            if (typeof value === "string") {
+                sanitized[key] = value;
+            }
+            else if (Array.isArray(value)) {
+                sanitized[key] = value.join(", ");
+            }
+            else {
+                sanitized[key] = String(value);
+            }
+        }
+        return this.dataSanitizer.sanitize(sanitized);
+    }
+};
+exports.HttpLoggerInterceptor = HttpLoggerInterceptor;
+exports.HttpLoggerInterceptor = HttpLoggerInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [logger_service_1.LoggerService, Object, Object])
+], HttpLoggerInterceptor);

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

@@ -0,0 +1,20 @@
+import { DynamicModule } from "@nestjs/common";
+export interface LoggerModuleOptions {
+    level?: "error" | "warn" | "info" | "debug" | "verbose";
+    timestamp?: boolean;
+    colors?: boolean;
+    context?: string;
+    format?: "json" | "text" | "pino";
+    sensitiveFields?: string[];
+}
+export interface LoggerModuleAsyncOptions {
+    useFactory: (...args: any[]) => LoggerModuleOptions | Promise<LoggerModuleOptions>;
+    inject?: any[];
+}
+export declare class LoggerModule {
+    static forRoot(options?: LoggerModuleOptions): DynamicModule;
+    static forRootAsync(options: LoggerModuleAsyncOptions): DynamicModule;
+    private static createConfiguration;
+    private static createProviders;
+    private static createCoreProviders;
+}

package/dist/core/logger.module.js

@@ -0,0 +1,103 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var LoggerModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerModule = void 0;
+const common_1 = require("@nestjs/common");
+const logger_service_1 = require("./logger.service");
+const http_logger_interceptor_1 = require("./http-logger.interceptor");
+const formatter_factory_1 = require("../factories/formatter.factory");
+const console_writer_1 = require("../writers/console-writer");
+const context_resolver_1 = require("../utils/context-resolver");
+const data_sanitizer_1 = require("../utils/data-sanitizer");
+const request_id_generator_1 = require("../utils/request-id-generator");
+const constants_1 = require("../constants");
+let LoggerModule = LoggerModule_1 = class LoggerModule {
+    static forRoot(options = {}) {
+        const config = this.createConfiguration(options);
+        const providers = this.createProviders(config);
+        return {
+            module: LoggerModule_1,
+            providers,
+            exports: [logger_service_1.LoggerService, http_logger_interceptor_1.HttpLoggerInterceptor],
+            global: true,
+        };
+    }
+    static forRootAsync(options) {
+        const configProvider = {
+            provide: constants_1.LOGGER_CONFIG_TOKEN,
+            useFactory: async (...args) => {
+                const userOptions = await options.useFactory(...args);
+                return this.createConfiguration(userOptions);
+            },
+            inject: options.inject || [],
+        };
+        const providers = [configProvider, ...this.createCoreProviders()];
+        return {
+            module: LoggerModule_1,
+            providers,
+            exports: [logger_service_1.LoggerService, http_logger_interceptor_1.HttpLoggerInterceptor],
+            global: true,
+        };
+    }
+    static createConfiguration(options) {
+        return {
+            ...constants_1.DEFAULT_LOGGER_CONFIG,
+            ...options,
+            sensitiveFields: options.sensitiveFields ?? constants_1.DEFAULT_LOGGER_CONFIG.sensitiveFields,
+        };
+    }
+    static createProviders(config) {
+        return [
+            {
+                provide: constants_1.LOGGER_CONFIG_TOKEN,
+                useValue: config,
+            },
+            ...this.createCoreProviders(),
+        ];
+    }
+    static createCoreProviders() {
+        return [
+            formatter_factory_1.FormatterFactory,
+            console_writer_1.ConsoleWriter,
+            context_resolver_1.ContextResolver,
+            request_id_generator_1.RequestIdGenerator,
+            {
+                provide: data_sanitizer_1.DataSanitizer,
+                useFactory: (config) => new data_sanitizer_1.DataSanitizer(config.sensitiveFields),
+                inject: [constants_1.LOGGER_CONFIG_TOKEN],
+            },
+            {
+                provide: logger_service_1.LoggerService,
+                useFactory: (config, formatterFactory, writer, contextResolver) => {
+                    const formatter = formatterFactory.create(config.format, {
+                        colors: config.colors,
+                        timestamp: config.timestamp,
+                        context: config.context,
+                    });
+                    return new logger_service_1.LoggerService(config, formatter, writer, contextResolver);
+                },
+                inject: [
+                    constants_1.LOGGER_CONFIG_TOKEN,
+                    formatter_factory_1.FormatterFactory,
+                    console_writer_1.ConsoleWriter,
+                    context_resolver_1.ContextResolver,
+                ],
+            },
+            {
+                provide: http_logger_interceptor_1.HttpLoggerInterceptor,
+                useFactory: (logger, dataSanitizer, requestIdGenerator) => new http_logger_interceptor_1.HttpLoggerInterceptor(logger, dataSanitizer, requestIdGenerator),
+                inject: [logger_service_1.LoggerService, data_sanitizer_1.DataSanitizer, request_id_generator_1.RequestIdGenerator],
+            },
+        ];
+    }
+};
+exports.LoggerModule = LoggerModule;
+exports.LoggerModule = LoggerModule = LoggerModule_1 = __decorate([
+    (0, common_1.Module)({})
+], LoggerModule);

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

@@ -0,0 +1,19 @@
+import { LoggerService as NestLoggerService } from "@nestjs/common";
+import { ILogger, ILogFormatter, ILogWriter, IContextResolver } from "../contracts";
+import { HttpRequestLogEntry, LoggerConfiguration } from "../types";
+export declare class LoggerService implements NestLoggerService, ILogger {
+    private readonly config;
+    private readonly formatter;
+    private readonly writer;
+    private readonly contextResolver;
+    private context?;
+    constructor(config: LoggerConfiguration, formatter: ILogFormatter, writer: ILogWriter, contextResolver: IContextResolver);
+    setContext(context: string): void;
+    log(message: string, context?: string, metadata?: Record<string, unknown>): void;
+    error(message: string, trace?: string, context?: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, context?: string, metadata?: Record<string, unknown>): void;
+    debug(message: string, context?: string, metadata?: Record<string, unknown>): void;
+    verbose(message: string, context?: string, metadata?: Record<string, unknown>): void;
+    logHttpRequest(entry: HttpRequestLogEntry): void;
+    private writeLog;
+}

package/dist/core/logger.service.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerService = void 0;
+const common_1 = require("@nestjs/common");
+let LoggerService = class LoggerService {
+    constructor(config, formatter, writer, contextResolver) {
+        this.config = config;
+        this.formatter = formatter;
+        this.writer = writer;
+        this.contextResolver = contextResolver;
+    }
+    setContext(context) {
+        this.context = context;
+    }
+    log(message, context, metadata) {
+        this.writeLog("info", message, context, metadata);
+    }
+    error(message, trace, context, metadata) {
+        this.writeLog("error", message, context, metadata, trace);
+    }
+    warn(message, context, metadata) {
+        this.writeLog("warn", message, context, metadata);
+    }
+    debug(message, context, metadata) {
+        this.writeLog("debug", message, context, metadata);
+    }
+    verbose(message, context, metadata) {
+        this.writeLog("verbose", message, context, metadata);
+    }
+    logHttpRequest(entry) {
+        const formatted = this.formatter.formatHttpRequest(entry);
+        this.writer.write(formatted);
+    }
+    writeLog(level, message, context, metadata, trace) {
+        const entry = {
+            level,
+            message,
+            timestamp: new Date(),
+            context: context ?? this.context ?? this.contextResolver.resolve(),
+            metadata,
+            trace,
+        };
+        const formatted = this.formatter.format(entry);
+        this.writer.write(formatted);
+    }
+};
+exports.LoggerService = LoggerService;
+exports.LoggerService = LoggerService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], LoggerService);