@globalart/nestjs-logger 1.0.1

package/dist/decorators/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Decorator to set logging context for a class or method
+ */
+export declare const LogContext: (context: string) => import("@nestjs/common").CustomDecorator<string>;
+/**
+ * Decorator to add metadata to logs
+ */
+export declare const LogMetadata: (metadata: Record<string, unknown>) => import("@nestjs/common").CustomDecorator<string>;

package/dist/decorators/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogMetadata = exports.LogContext = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("../constants");
+/**
+ * Decorator to set logging context for a class or method
+ */
+const LogContext = (context) => (0, common_1.SetMetadata)(constants_1.LOGGER_CONTEXT_METADATA, context);
+exports.LogContext = LogContext;
+/**
+ * Decorator to add metadata to logs
+ */
+const LogMetadata = (metadata) => (0, common_1.SetMetadata)(constants_1.LOGGER_METADATA_METADATA, metadata);
+exports.LogMetadata = LogMetadata;

package/dist/factories/formatter.factory.d.ts

@@ -0,0 +1,5 @@
+import { ILogFormatter } from "../contracts";
+import { LogFormat, FormatterOptions } from "../types";
+export declare class FormatterFactory {
+    create(format: LogFormat, options: FormatterOptions): ILogFormatter;
+}

package/dist/factories/formatter.factory.js

@@ -0,0 +1,31 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormatterFactory = void 0;
+const common_1 = require("@nestjs/common");
+const text_formatter_1 = require("../formatters/text-formatter");
+const json_formatter_1 = require("../formatters/json-formatter");
+const pino_formatter_1 = require("../formatters/pino-formatter");
+let FormatterFactory = class FormatterFactory {
+    create(format, options) {
+        switch (format) {
+            case "text":
+                return new text_formatter_1.TextFormatter(options);
+            case "json":
+                return new json_formatter_1.JsonFormatter(options);
+            case "pino":
+                return new pino_formatter_1.PinoFormatter(options);
+            default:
+                throw new Error(`Unsupported log format: ${format}`);
+        }
+    }
+};
+exports.FormatterFactory = FormatterFactory;
+exports.FormatterFactory = FormatterFactory = __decorate([
+    (0, common_1.Injectable)()
+], FormatterFactory);

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

@@ -0,0 +1,12 @@
+import { ILogFormatter } from "../contracts";
+import { LogEntry, HttpRequestLogEntry, FormatterOptions } from "../types";
+import { COLORS } from "../constants";
+export declare abstract class BaseFormatter implements ILogFormatter {
+    protected readonly options: FormatterOptions;
+    constructor(options: FormatterOptions);
+    abstract format(entry: LogEntry): string;
+    abstract formatHttpRequest(entry: HttpRequestLogEntry): string;
+    protected formatTimestamp(timestamp: Date): string;
+    protected colorize(text: string, color: keyof typeof COLORS): string;
+    protected getColorForLevel(level: string | number): keyof typeof COLORS;
+}

package/dist/formatters/base-formatter.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseFormatter = void 0;
+const constants_1 = require("../constants");
+class BaseFormatter {
+    constructor(options) {
+        this.options = options;
+    }
+    formatTimestamp(timestamp) {
+        return timestamp.toISOString();
+    }
+    colorize(text, color) {
+        if (!this.options.colors)
+            return text;
+        return `${constants_1.COLORS[color]}${text}${constants_1.COLORS.reset}`;
+    }
+    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";
+            }
+        }
+        // Для числовых уровней (Pino)
+        if (level >= 50)
+            return "red";
+        if (level >= 40)
+            return "yellow";
+        if (level >= 30)
+            return "green";
+        return "blue";
+    }
+}
+exports.BaseFormatter = BaseFormatter;

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

@@ -0,0 +1,6 @@
+import { BaseFormatter } from "./base-formatter";
+import { LogEntry, HttpRequestLogEntry } from "../types";
+export declare class JsonFormatter extends BaseFormatter {
+    format(entry: LogEntry): string;
+    formatHttpRequest(entry: HttpRequestLogEntry): string;
+}

package/dist/formatters/json-formatter.js

@@ -0,0 +1,36 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFormatter = void 0;
+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 = {
+            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);
+    }
+    formatHttpRequest(entry) {
+        const jsonString = JSON.stringify(entry);
+        if (this.options.colors) {
+            const color = this.getColorForLevel(entry.level);
+            return this.colorize(jsonString, color);
+        }
+        return jsonString;
+    }
+};
+exports.JsonFormatter = JsonFormatter;
+exports.JsonFormatter = JsonFormatter = __decorate([
+    (0, common_1.Injectable)()
+], JsonFormatter);

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

@@ -0,0 +1,6 @@
+import { BaseFormatter } from "./base-formatter";
+import { LogEntry, HttpRequestLogEntry } from "../types";
+export declare class PinoFormatter extends BaseFormatter {
+    format(entry: LogEntry): string;
+    formatHttpRequest(entry: HttpRequestLogEntry): string;
+}

package/dist/formatters/pino-formatter.js

@@ -0,0 +1,28 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinoFormatter = void 0;
+const common_1 = require("@nestjs/common");
+const base_formatter_1 = require("./base-formatter");
+let PinoFormatter = class PinoFormatter extends base_formatter_1.BaseFormatter {
+    format(entry) {
+        return JSON.stringify(entry);
+    }
+    formatHttpRequest(entry) {
+        const jsonString = JSON.stringify(entry);
+        if (this.options.colors) {
+            const color = this.getColorForLevel(entry.level);
+            return this.colorize(jsonString, color);
+        }
+        return jsonString;
+    }
+};
+exports.PinoFormatter = PinoFormatter;
+exports.PinoFormatter = PinoFormatter = __decorate([
+    (0, common_1.Injectable)()
+], PinoFormatter);

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

@@ -0,0 +1,6 @@
+import { BaseFormatter } from "./base-formatter";
+import { LogEntry, HttpRequestLogEntry } from "../types";
+export declare class TextFormatter extends BaseFormatter {
+    format(entry: LogEntry): string;
+    formatHttpRequest(entry: HttpRequestLogEntry): string;
+}

package/dist/formatters/text-formatter.js

@@ -0,0 +1,45 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextFormatter = void 0;
+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 = [];
+        if (this.options.timestamp) {
+            const timestamp = this.colorize(`[${this.formatTimestamp(entry.timestamp)}]`, "gray");
+            parts.push(timestamp);
+        }
+        const level = this.colorize(`[${entry.level.toUpperCase()}]`, this.getColorForLevel(entry.level));
+        parts.push(level);
+        if (entry.context) {
+            const context = this.colorize(`[${entry.context}]`, "cyan");
+            parts.push(context);
+        }
+        const message = this.colorize(entry.message, "bright");
+        parts.push(message);
+        if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+            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);
+    }
+};
+exports.TextFormatter = TextFormatter;
+exports.TextFormatter = TextFormatter = __decorate([
+    (0, common_1.Injectable)()
+], TextFormatter);

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { LoggerModule, LoggerModuleOptions, LoggerModuleAsyncOptions, } from "./core/logger.module";
+export { LoggerService } from "./core/logger.service";
+export { HttpLoggerInterceptor } from "./core/http-logger.interceptor";
+export { LogContext, LogMetadata } from "./decorators";
+export * from "./types";
+export * from "./contracts";

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.LogMetadata = exports.LogContext = exports.HttpLoggerInterceptor = exports.LoggerService = 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_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");
+Object.defineProperty(exports, "HttpLoggerInterceptor", { enumerable: true, get: function () { return http_logger_interceptor_1.HttpLoggerInterceptor; } });
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "LogContext", { enumerable: true, get: function () { return decorators_1.LogContext; } });
+Object.defineProperty(exports, "LogMetadata", { enumerable: true, get: function () { return decorators_1.LogMetadata; } });
+// Types
+__exportStar(require("./types"), exports);
+// Contracts
+__exportStar(require("./contracts"), exports);

package/dist/interceptors/index.d.ts

@@ -0,0 +1 @@
+export { HttpLoggerInterceptor } from "../core/http-logger.interceptor";

package/dist/interceptors/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpLoggerInterceptor = void 0;
+var http_logger_interceptor_1 = require("../core/http-logger.interceptor");
+Object.defineProperty(exports, "HttpLoggerInterceptor", { enumerable: true, get: function () { return http_logger_interceptor_1.HttpLoggerInterceptor; } });

package/dist/interfaces/index.d.ts

@@ -0,0 +1,59 @@
+export interface LoggerOptions {
+    level?: "error" | "warn" | "log" | "debug" | "verbose";
+    timestamp?: boolean;
+    colors?: boolean;
+    context?: string;
+    format?: "json" | "text" | "pino";
+    transports?: LoggerTransport[];
+    pino?: PinoOptions;
+}
+export interface PinoOptions {
+    level?: string;
+    timestamp?: boolean;
+    base?: boolean;
+    name?: string;
+    enabled?: boolean;
+}
+export interface LoggerTransport {
+    name: string;
+    level?: string;
+    format?: any;
+    filename?: string;
+    dirname?: string;
+    maxsize?: number;
+    maxFiles?: number;
+}
+export interface LogContext {
+    timestamp?: string;
+    level: string;
+    message: string;
+    context?: string;
+    trace?: string;
+    metadata?: Record<string, any>;
+}
+export interface LoggerMetadata {
+    [key: string]: any;
+}
+export interface RequestLogData {
+    req: {
+        id: number;
+        method: string;
+        url: string;
+        query: Record<string, any>;
+        params: Record<string, any>;
+        headers: Record<string, any>;
+        remoteAddress: string;
+        remotePort?: number;
+        body?: any;
+    };
+    res: {
+        statusCode: number;
+        headers: Record<string, any>;
+    };
+    responseTime: number;
+    msg: string;
+    level: number;
+    time: number;
+    pid: number;
+    hostname: string;
+}

package/dist/interfaces/index.js

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

package/dist/types/index.d.ts

@@ -0,0 +1,50 @@
+export type LogLevel = "error" | "warn" | "info" | "debug" | "verbose";
+export type LogFormat = "json" | "text" | "pino";
+export declare const LOG_LEVELS: Record<LogLevel, number>;
+export declare const PINO_LEVELS: Record<number, string>;
+export interface LogEntry {
+    readonly level: LogLevel;
+    readonly message: string;
+    readonly timestamp: Date;
+    readonly context?: string;
+    readonly metadata?: Record<string, unknown>;
+    readonly trace?: string;
+}
+export interface HttpRequestLogEntry {
+    readonly level: number;
+    readonly time: number;
+    readonly pid: number;
+    readonly hostname: string;
+    readonly req: HttpRequest;
+    readonly res: HttpResponse;
+    readonly responseTime: number;
+    readonly msg: string;
+}
+export interface HttpRequest {
+    readonly id: string;
+    readonly method: string;
+    readonly url: string;
+    readonly query: Record<string, unknown>;
+    readonly params: Record<string, unknown>;
+    readonly headers: Record<string, string>;
+    readonly remoteAddress: string;
+    readonly remotePort?: number;
+    readonly body?: unknown;
+}
+export interface HttpResponse {
+    readonly statusCode: number;
+    readonly headers: Record<string, string>;
+}
+export interface LoggerConfiguration {
+    readonly level: LogLevel;
+    readonly timestamp: boolean;
+    readonly colors: boolean;
+    readonly context?: string;
+    readonly format: LogFormat;
+    readonly sensitiveFields: readonly string[];
+}
+export interface FormatterOptions {
+    readonly colors: boolean;
+    readonly timestamp: boolean;
+    readonly context?: string;
+}

package/dist/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PINO_LEVELS = exports.LOG_LEVELS = void 0;
+exports.LOG_LEVELS = {
+    error: 50,
+    warn: 40,
+    info: 30,
+    debug: 20,
+    verbose: 10,
+};
+exports.PINO_LEVELS = {
+    60: "FATAL",
+    50: "ERROR",
+    40: "WARN",
+    30: "INFO",
+    20: "DEBUG",
+    10: "TRACE",
+};

package/dist/utils/context-resolver.d.ts

@@ -0,0 +1,7 @@
+import { IContextResolver } from "../contracts";
+export declare class ContextResolver implements IContextResolver {
+    resolve(): string;
+    private shouldSkipLine;
+    private extractClassName;
+    private isValidClassName;
+}

package/dist/utils/context-resolver.js

@@ -0,0 +1,68 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextResolver = void 0;
+const common_1 = require("@nestjs/common");
+let ContextResolver = class ContextResolver {
+    resolve() {
+        const stack = new Error().stack;
+        if (!stack)
+            return "Unknown";
+        const lines = stack.split("\n");
+        for (let i = 3; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (this.shouldSkipLine(line))
+                continue;
+            const className = this.extractClassName(line);
+            if (className)
+                return className;
+        }
+        return "Unknown";
+    }
+    shouldSkipLine(line) {
+        const skipPatterns = [
+            "ContextResolver",
+            "LoggerService",
+            "Object.writeLog",
+            "Object.log",
+            "Object.error",
+            "Object.warn",
+            "Object.debug",
+            "Object.verbose",
+            "at async",
+            "at processTicksAndRejections",
+        ];
+        return skipPatterns.some((pattern) => line.includes(pattern));
+    }
+    extractClassName(line) {
+        // Пытаемся найти имя класса в различных форматах
+        const patterns = [
+            /at\s+(\w+)\./, // at ClassName.method
+            /at\s+.*\.(\w+)\s+\(/, // at path.ClassName (
+            /(\w+)\..*\s+\(/, // ClassName.method (
+        ];
+        for (const pattern of patterns) {
+            const match = line.match(pattern);
+            if (match && match[1] && this.isValidClassName(match[1])) {
+                return match[1];
+            }
+        }
+        return null;
+    }
+    isValidClassName(name) {
+        // Проверяем, что это валидное имя класса (начинается с заглавной буквы)
+        return (/^[A-Z][a-zA-Z0-9]*$/.test(name) &&
+            name !== "Object" &&
+            name !== "Function" &&
+            name !== "AsyncFunction");
+    }
+};
+exports.ContextResolver = ContextResolver;
+exports.ContextResolver = ContextResolver = __decorate([
+    (0, common_1.Injectable)()
+], ContextResolver);

package/dist/utils/data-sanitizer.d.ts

@@ -0,0 +1,9 @@
+import { IDataSanitizer } from "../contracts";
+export declare class DataSanitizer implements IDataSanitizer {
+    private readonly sensitiveFields;
+    private readonly redactedValue;
+    constructor(sensitiveFields: readonly string[]);
+    sanitize(data: unknown): unknown;
+    private sanitizeObject;
+    private isSensitiveField;
+}

package/dist/utils/data-sanitizer.js

@@ -0,0 +1,56 @@
+"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.DataSanitizer = void 0;
+const common_1 = require("@nestjs/common");
+let DataSanitizer = class DataSanitizer {
+    constructor(sensitiveFields) {
+        this.sensitiveFields = sensitiveFields;
+        this.redactedValue = "[REDACTED]";
+    }
+    sanitize(data) {
+        if (data === null || data === undefined)
+            return data;
+        if (typeof data === "string" ||
+            typeof data === "number" ||
+            typeof data === "boolean") {
+            return data;
+        }
+        if (Array.isArray(data)) {
+            return data.map((item) => this.sanitize(item));
+        }
+        if (typeof data === "object") {
+            return this.sanitizeObject(data);
+        }
+        return data;
+    }
+    sanitizeObject(obj) {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (this.isSensitiveField(key)) {
+                sanitized[key] = this.redactedValue;
+            }
+            else {
+                sanitized[key] = this.sanitize(value);
+            }
+        }
+        return sanitized;
+    }
+    isSensitiveField(fieldName) {
+        const lowerFieldName = fieldName.toLowerCase();
+        return this.sensitiveFields.some((sensitive) => lowerFieldName.includes(sensitive.toLowerCase()));
+    }
+};
+exports.DataSanitizer = DataSanitizer;
+exports.DataSanitizer = DataSanitizer = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Array])
+], DataSanitizer);

package/dist/utils/request-id-generator.d.ts

@@ -0,0 +1,8 @@
+import { IRequestIdGenerator } from "../contracts";
+export declare class RequestIdGenerator implements IRequestIdGenerator {
+    private counter;
+    private readonly machineId;
+    constructor();
+    generate(): string;
+    private generateMachineId;
+}

package/dist/utils/request-id-generator.js

@@ -0,0 +1,34 @@
+"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.RequestIdGenerator = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+let RequestIdGenerator = class RequestIdGenerator {
+    constructor() {
+        this.counter = 0;
+        this.machineId = this.generateMachineId();
+    }
+    generate() {
+        const timestamp = Date.now().toString(36);
+        const counter = (++this.counter).toString(36);
+        const random = (0, crypto_1.randomBytes)(2).toString("hex");
+        return `${timestamp}-${this.machineId}-${counter}-${random}`;
+    }
+    generateMachineId() {
+        return (0, crypto_1.randomBytes)(3).toString("hex");
+    }
+};
+exports.RequestIdGenerator = RequestIdGenerator;
+exports.RequestIdGenerator = RequestIdGenerator = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], RequestIdGenerator);

package/dist/writers/console-writer.d.ts

@@ -0,0 +1,4 @@
+import { ILogWriter } from "../contracts";
+export declare class ConsoleWriter implements ILogWriter {
+    write(formattedLog: string): void;
+}

package/dist/writers/console-writer.js

@@ -0,0 +1,19 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleWriter = void 0;
+const common_1 = require("@nestjs/common");
+let ConsoleWriter = class ConsoleWriter {
+    write(formattedLog) {
+        console.log(formattedLog);
+    }
+};
+exports.ConsoleWriter = ConsoleWriter;
+exports.ConsoleWriter = ConsoleWriter = __decorate([
+    (0, common_1.Injectable)()
+], ConsoleWriter);