@globalart/nestjs-logger 1.0.8 → 1.0.10

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

@@ -14,10 +14,15 @@ 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 handleGraphQLRequest;
     private createHttpLogEntry;
     private createLogEntry;
     private getClientIp;
     private sanitizeHeaders;
     private getRequestMethod;
     private shouldExcludeRequest;
+    private sanitizeGraphQLArgs;
+    private getGraphQLResultSize;
+    private extractErrorMessage;
+    private extractErrorTrace;
 }

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

@@ -16,6 +16,14 @@ exports.HttpLoggerInterceptor = void 0;
 const common_1 = require("@nestjs/common");
 const operators_1 = require("rxjs/operators");
 const core_1 = require("@nestjs/core");
+// Опциональный импорт для GraphQL
+let GqlExecutionContext;
+try {
+    GqlExecutionContext = require("@nestjs/graphql").GqlExecutionContext;
+}
+catch {
+    // GraphQL модуль не установлен
+}
 const logger_service_1 = require("./logger.service");
 const constants_1 = require("../constants");
 const os_1 = require("os");
@@ -30,8 +38,15 @@ let HttpLoggerInterceptor = class HttpLoggerInterceptor {
         this.pid = process.pid;
     }
     intercept(context, next) {
+        const contextType = context.getType();
+        if (contextType === "graphql") {
+            return this.handleGraphQLRequest(context, next);
+        }
         const request = context.switchToHttp().getRequest();
         const response = context.switchToHttp().getResponse();
+        if (!request || !request.method) {
+            return next.handle();
+        }
         const requestMethod = this.getRequestMethod(request.method);
         if (this.shouldExcludeRequest(requestMethod, request.url)) {
             return next.handle();
@@ -52,17 +67,91 @@ let HttpLoggerInterceptor = class HttpLoggerInterceptor {
                 this.logger.log(entry);
             }
         }), (0, operators_1.catchError)((error) => {
+            const errorMessage = this.extractErrorMessage(error);
+            const errorTrace = this.extractErrorTrace(error);
             if (this.config.format === "pino") {
-                const entry = this.createHttpLogEntry(request, response, requestId, startTime, 50, "request failed");
+                const entry = this.createHttpLogEntry(request, response, requestId, startTime, 50, errorMessage || "request failed");
                 this.logger.logHttpRequest(entry);
+                const baseEntry = this.createLogEntry(request, response, requestId, startTime);
+                this.logger.error({
+                    ...baseEntry,
+                    message: errorMessage || baseEntry.message,
+                    trace: errorTrace,
+                });
             }
             else {
-                const entry = this.createLogEntry(request, response, requestId, startTime);
-                this.logger.error(entry);
+                const baseEntry = this.createLogEntry(request, response, requestId, startTime);
+                this.logger.error({
+                    ...baseEntry,
+                    message: errorMessage || baseEntry.message,
+                    trace: errorTrace,
+                });
             }
             throw error;
         }));
     }
+    handleGraphQLRequest(context, next) {
+        if (!GqlExecutionContext) {
+            return next.handle();
+        }
+        try {
+            const gqlContext = GqlExecutionContext.create(context);
+            const info = gqlContext.getInfo();
+            const args = gqlContext.getArgs();
+            const startTime = Date.now();
+            const requestId = this.requestIdGenerator.generate();
+            const operationType = info.operation.operation;
+            const operationName = info.operation.name?.value || "Anonymous";
+            const fieldName = info.fieldName;
+            this.logger.log({
+                message: `GraphQL ${operationType}: ${operationName}.${fieldName}`,
+                context: "GraphQL",
+                metadata: {
+                    requestId,
+                    operationType,
+                    operationName,
+                    fieldName,
+                    args: this.sanitizeGraphQLArgs(args),
+                },
+            });
+            return next.handle().pipe((0, operators_1.tap)((result) => {
+                const responseTime = Date.now() - startTime;
+                this.logger.log({
+                    message: `GraphQL ${operationType} completed: ${operationName}.${fieldName} (${responseTime}ms)`,
+                    context: "GraphQL",
+                    metadata: {
+                        requestId,
+                        operationType,
+                        operationName,
+                        fieldName,
+                        responseTime,
+                        resultSize: this.getGraphQLResultSize(result),
+                    },
+                });
+            }), (0, operators_1.catchError)((error) => {
+                const responseTime = Date.now() - startTime;
+                const errorMessage = this.extractErrorMessage(error);
+                const errorTrace = this.extractErrorTrace(error);
+                this.logger.error({
+                    message: errorMessage ||
+                        `GraphQL ${operationType} failed: ${operationName}.${fieldName} (${responseTime}ms)`,
+                    context: "GraphQL",
+                    metadata: {
+                        requestId,
+                        operationType,
+                        operationName,
+                        fieldName,
+                        responseTime,
+                    },
+                    trace: errorTrace,
+                });
+                throw error;
+            }));
+        }
+        catch (gqlError) {
+            return next.handle();
+        }
+    }
     createHttpLogEntry(request, response, requestId, startTime, level, message) {
         const responseTime = Date.now() - startTime;
         const ip = this.getClientIp(request);
@@ -164,6 +253,63 @@ let HttpLoggerInterceptor = class HttpLoggerInterceptor {
             return path === excludeOption.path;
         });
     }
+    sanitizeGraphQLArgs(args) {
+        if (!args || typeof args !== "object") {
+            return args;
+        }
+        const sanitized = { ...args };
+        if (sanitized.input && sanitized.input.password) {
+            sanitized.input = { ...sanitized.input, password: "[HIDDEN]" };
+        }
+        return this.dataSanitizer.sanitize(sanitized);
+    }
+    getGraphQLResultSize(result) {
+        if (Array.isArray(result)) {
+            return `${result.length} items`;
+        }
+        if (result && typeof result === "object") {
+            return "1 object";
+        }
+        return "primitive";
+    }
+    extractErrorMessage(error) {
+        if (!error)
+            return undefined;
+        // Nest HttpException
+        if (typeof error.getResponse === "function") {
+            const resp = error.getResponse();
+            if (typeof resp === "string")
+                return resp;
+            if (resp && typeof resp === "object") {
+                return (resp.message || resp.error || error.message);
+            }
+        }
+        // GraphQL/Apollo ошибки
+        if (error.extensions && error.extensions.exception) {
+            const ex = error.extensions.exception;
+            return ex.message || error.message;
+        }
+        return error.message;
+    }
+    extractErrorTrace(error) {
+        if (!error)
+            return undefined;
+        // Nest HttpException
+        if (typeof error.getResponse === "function") {
+            const ex = error;
+            return ex.stack || ex.trace || undefined;
+        }
+        // GraphQL/Apollo ошибки
+        if (error.extensions && error.extensions.exception) {
+            const ex = error.extensions.exception;
+            return ex.stacktrace
+                ? Array.isArray(ex.stacktrace)
+                    ? ex.stacktrace.join("\n")
+                    : String(ex.stacktrace)
+                : ex.stack || undefined;
+        }
+        return error.stack;
+    }
 };
 exports.HttpLoggerInterceptor = HttpLoggerInterceptor;
 exports.HttpLoggerInterceptor = HttpLoggerInterceptor = __decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@globalart/nestjs-logger",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "A advanced logger for NestJS",
   "author": {
     "name": "GlobalArt, Inc"