@lark-apaas/nestjs-logger 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/index.cjs

@@ -14375,6 +14375,7 @@ __export(index_exports, {
   AppLogger: () => AppLogger,
   LoggerContextMiddleware: () => LoggerContextMiddleware,
   LoggerModule: () => LoggerModule,
+  PinoLoggerService: () => PinoLoggerService,
   TRACE_LOGGER: () => TRACE_LOGGER
 });
 module.exports = __toCommonJS(index_exports);
@@ -14449,13 +14450,7 @@ var LogLevelState = class LogLevelState2 {
   static {
     __name(this, "LogLevelState");
   }
-  levels = /* @__PURE__ */ new Set([
-    "log",
-    "error",
-    "warn",
-    "debug",
-    "verbose"
-  ]);
+  levels = /* @__PURE__ */ new Set();
   set(levels) {
     this.levels = new Set(levels);
   }
@@ -14486,6 +14481,61 @@ var LogLevelState = class LogLevelState2 {
     }
     return "fatal";
   }
+  /**
+  * 根据 Pino 级别转换为 NestJS LogLevel 数组
+  */
+  static fromPinoLevel(pinoLevel) {
+    switch (pinoLevel) {
+      case "trace":
+        return [
+          "verbose",
+          "debug",
+          "log",
+          "warn",
+          "error",
+          "fatal"
+        ];
+      case "debug":
+        return [
+          "debug",
+          "log",
+          "warn",
+          "error",
+          "fatal"
+        ];
+      case "info":
+        return [
+          "log",
+          "warn",
+          "error",
+          "fatal"
+        ];
+      case "warn":
+        return [
+          "warn",
+          "error",
+          "fatal"
+        ];
+      case "error":
+        return [
+          "error",
+          "fatal"
+        ];
+      case "fatal":
+        return [
+          "fatal"
+        ];
+      case "silent":
+        return [];
+      default:
+        return [
+          "log",
+          "warn",
+          "error",
+          "fatal"
+        ];
+    }
+  }
 };
 var BasePinoLogger = class _BasePinoLogger {
   static {
@@ -14497,7 +14547,9 @@ var BasePinoLogger = class _BasePinoLogger {
   constructor(logger, contextStore) {
     this.logger = logger;
     this.contextStore = contextStore;
-    this.logger.level = this.levelState.getMinPinoLevel();
+    const pinoLevel = this.logger.level;
+    const nestLevels = LogLevelState.fromPinoLevel(pinoLevel);
+    this.levelState.set(nestLevels);
   }
   setLogLevels(levels) {
     this.levelState.set(levels);
@@ -14521,6 +14573,36 @@ var BasePinoLogger = class _BasePinoLogger {
   fatal(message, ...optionalParams) {
     this.write("fatal", message, optionalParams, true);
   }
+  /**
+  * 记录结构化日志，将 meta 对象合并到日志字段中
+  * @param level 日志级别
+  * @param message 消息文本
+  * @param meta 要合并的元数据对象
+  * @param context 上下文标识
+  */
+  logStructured(level, message, meta, context) {
+    if (!this.levelState.isEnabled(level)) {
+      return;
+    }
+    const requestState = this.contextStore.getContext();
+    const traceId = requestState?.requestId ?? null;
+    const payload = {
+      trace_id: traceId,
+      path: requestState?.path,
+      method: requestState?.method,
+      user_id: requestState?.userId ?? null,
+      app_id: requestState?.appId ?? null,
+      tenant_id: requestState?.tenantId ?? null,
+      pid: process.pid,
+      ...sanitizeValue(meta)
+    };
+    if (context) {
+      payload.context = context;
+    }
+    const pinoLevel = mapLogLevelToPino(level);
+    const sanitizedPayload = sanitizeValue(payload);
+    this.logger[pinoLevel](sanitizedPayload, message);
+  }
   write(level, message, optionalParams, treatStack = false) {
     if (!this.levelState.isEnabled(level)) {
       return;
@@ -14530,13 +14612,11 @@ var BasePinoLogger = class _BasePinoLogger {
     const traceId = requestState?.requestId ?? null;
     const payload = {
       trace_id: traceId,
-      requestId: traceId,
       path: requestState?.path,
       method: requestState?.method,
       user_id: requestState?.userId ?? null,
       app_id: requestState?.appId ?? null,
       tenant_id: requestState?.tenantId ?? null,
-      ip: requestState?.ip ?? null,
       pid: process.pid
     };
     if (context) {
@@ -14683,7 +14763,7 @@ __name(sanitizeValue, "sanitizeValue");
 // src/module.ts
 var import_common5 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
-var import_config2 = __toESM(require_config2(), 1);
+var import_config3 = __toESM(require_config2(), 1);
 
 // src/config/logger.config.ts
 var import_config = __toESM(require_config2(), 1);
@@ -14703,49 +14783,22 @@ function normalizeLevel(level) {
   }
 }
 __name(normalizeLevel, "normalizeLevel");
-function parseDestinations(raw) {
-  if (!raw) {
-    return [
-      {
-        type: "stdout"
-      }
-    ];
-  }
-  return raw.split(",").map((token) => token.trim()).filter(Boolean).map((token) => {
-    const [typeAndPath, level] = token.split("@");
-    const [type, path] = typeAndPath.split(":");
-    const normalizedType = (type ?? "stdout").toLowerCase();
-    if (normalizedType === "file") {
-      return {
-        type: "file",
-        path: path || "logs/app.log",
-        level
-      };
-    }
-    if (normalizedType === "stderr") {
-      return {
-        type: "stderr",
-        level
-      };
-    }
-    return {
-      type: "stdout",
-      level
-    };
-  });
-}
-__name(parseDestinations, "parseDestinations");
 var logger_config_default = (0, import_config.registerAs)("logger", () => {
-  const level = normalizeLevel(process.env.LOGGER_LEVEL || (process.env.NODE_ENV === "production" ? "info" : "debug"));
-  const destinations = parseDestinations(process.env.LOGGER_DESTINATIONS);
+  const level = normalizeLevel(process.env.LOGGER_LEVEL || (process.env.NODE_ENV === "production" ? "info" : "trace"));
+  const maxBodyLengthEnv = process.env.LOG_MAX_BODY_LENGTH;
+  const maxBodyLength = maxBodyLengthEnv ? Number(maxBodyLengthEnv) : null;
   return {
     level,
-    destinations
+    logDir: process.env.LOG_DIR || "logs",
+    logRequestBody: process.env.LOG_REQUEST_BODY === "true",
+    logResponseBody: process.env.LOG_RESPONSE_BODY === "true",
+    maxBodyLength
   };
 });
 
 // src/interceptor/logging.interceptor.ts
 var import_common3 = require("@nestjs/common");
+var import_config2 = __toESM(require_config2(), 1);
 var import_operators = __toESM(require_operators(), 1);
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -14770,9 +14823,13 @@ var LoggingInterceptor = class {
   }
   traceLogger;
   requestContext;
-  constructor(traceLogger, requestContext) {
+  appLogger;
+  config;
+  constructor(traceLogger, requestContext, appLogger, config) {
     this.traceLogger = traceLogger;
     this.requestContext = requestContext;
+    this.appLogger = appLogger;
+    this.config = config;
   }
   intercept(context, next) {
     if (context.getType() !== "http") {
@@ -14782,16 +14839,15 @@ var LoggingInterceptor = class {
     const req = httpContext.getRequest();
     const res = httpContext.getResponse();
     const method = req.method;
-    const url = req.originalUrl ?? req.url;
+    const path = req.path;
     this.requestContext.setContext({
       method,
-      path: url
+      path
     });
     const startedAt = Date.now();
     const baseMeta = {
       method,
-      path: url,
-      requestId: req.requestId ?? req.id,
+      path,
       trace_id: req.requestId ?? req.id,
       user_id: req.userContext?.userId ?? null,
       tenant_id: req.userContext?.tenantId ?? null,
@@ -14799,39 +14855,101 @@ var LoggingInterceptor = class {
       ip: req.ip ?? null,
       pid: process.pid
     };
-    this.traceLogger.log("HTTP request started", baseMeta, "HTTP");
-    return next.handle().pipe((0, import_operators.tap)(() => {
+    this.appLogger.logStructured("log", "HTTP request started", baseMeta, "HTTPTraceInterceptor");
+    const requestMeta = {
+      ...baseMeta
+    };
+    if (this.config.logRequestBody && req.body) {
+      requestMeta["request_body"] = this.sanitizeAndTruncate(req.body);
+    }
+    if (this.config.logRequestBody && Object.keys(req.query || {}).length > 0) {
+      requestMeta["query_params"] = this.sanitizeAndTruncate(req.query);
+    }
+    this.traceLogger.logStructured("verbose", "HTTP request started", requestMeta, "HTTPTraceInterceptor");
+    return next.handle().pipe((0, import_operators.tap)((responseData) => {
       const durationMs = Date.now() - startedAt;
       const statusCode = res.statusCode;
-      this.traceLogger.log("HTTP request completed", {
+      this.appLogger.logStructured("log", "HTTP request completed", {
+        ...baseMeta,
+        status_code: statusCode,
+        duration_ms: durationMs
+      }, "HTTPTraceInterceptor");
+      const responseMeta = {
         ...baseMeta,
-        statusCode,
-        durationMs
-      }, "HTTP");
+        status_code: statusCode,
+        duration_ms: durationMs
+      };
+      if (this.config.logResponseBody && responseData !== void 0) {
+        responseMeta["response_body"] = this.sanitizeAndTruncate(responseData);
+      }
+      const traceLevel = res.statusCode >= 400 ? "error" : "verbose";
+      this.traceLogger.logStructured(traceLevel, "HTTP request completed", responseMeta, "HTTPTraceInterceptor");
     }), (0, import_operators.catchError)((error) => {
       const durationMs = Date.now() - startedAt;
       const statusCode = res.statusCode >= 400 ? res.statusCode : 500;
+      const linkMeta = {
+        ...baseMeta,
+        status_code: statusCode,
+        duration_ms: durationMs
+      };
+      if (error instanceof Error) {
+        linkMeta["error_message"] = error.message;
+      }
+      this.appLogger.logStructured("log", "HTTP request failed", linkMeta, "HTTPTraceInterceptor");
       const meta = {
         ...baseMeta,
-        statusCode,
-        durationMs
+        status_code: statusCode,
+        duration_ms: durationMs
       };
       if (error instanceof Error) {
-        this.traceLogger.error(error, meta, "HTTP");
+        meta["error"] = {
+          message: error.message,
+          stack: error.stack
+        };
       } else {
-        this.traceLogger.error("Unknown error thrown", meta, "HTTP");
+        meta["error"] = String(error);
       }
+      this.traceLogger.logStructured("verbose", "HTTP request failed", meta, "HTTPTraceInterceptor");
       throw error;
     }));
   }
+  /**
+  * 对数据进行截断处理
+  */
+  sanitizeAndTruncate(data) {
+    try {
+      if (this.config.maxBodyLength === null) {
+        return data;
+      }
+      const jsonStr = JSON.stringify(data);
+      if (jsonStr.length > this.config.maxBodyLength) {
+        return {
+          _truncated: true,
+          _originalLength: jsonStr.length,
+          _data: jsonStr.substring(0, this.config.maxBodyLength) + "..."
+        };
+      }
+      return data;
+    } catch (error) {
+      return {
+        _error: "Failed to serialize data",
+        _type: typeof data,
+        _constructor: data?.constructor?.name
+      };
+    }
+  }
 };
 LoggingInterceptor = _ts_decorate3([
   (0, import_common3.Injectable)(),
   _ts_param2(0, (0, import_common3.Inject)(TRACE_LOGGER)),
+  _ts_param2(2, (0, import_common3.Inject)(AppLogger)),
+  _ts_param2(3, (0, import_common3.Inject)(logger_config_default.KEY)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
-    typeof import_common3.LoggerService === "undefined" ? Object : import_common3.LoggerService,
-    typeof RequestContextService === "undefined" ? Object : RequestContextService
+    typeof PinoLoggerService === "undefined" ? Object : PinoLoggerService,
+    typeof RequestContextService === "undefined" ? Object : RequestContextService,
+    typeof AppLogger === "undefined" ? Object : AppLogger,
+    typeof import_config2.ConfigType === "undefined" ? Object : import_config2.ConfigType
   ])
 ], LoggingInterceptor);
 
@@ -14854,12 +14972,12 @@ function createPinoLogger(config) {
       }
     }
   };
-  const destinations = config.destinations.length > 0 ? config.destinations : [
+  const streams = [
     {
-      type: "stdout"
+      level: config.level,
+      stream: createFileDestination(config.filePath)
     }
   ];
-  const streams = buildStreams(destinations, baseLevel);
   if (streams.length === 0) {
     return (0, import_pino.default)(options);
   }
@@ -14869,30 +14987,6 @@ function createPinoLogger(config) {
   return (0, import_pino.default)(options, import_pino.default.multistream(streams));
 }
 __name(createPinoLogger, "createPinoLogger");
-function buildStreams(destinations, fallbackLevel) {
-  return destinations.map((destination) => {
-    const level = normalizeLevel(destination.level ?? fallbackLevel);
-    switch (destination.type) {
-      case "stderr":
-        return {
-          level,
-          stream: process.stderr
-        };
-      case "file":
-        return {
-          level,
-          stream: createFileDestination(destination.path)
-        };
-      case "stdout":
-      default:
-        return {
-          level,
-          stream: process.stdout
-        };
-    }
-  });
-}
-__name(buildStreams, "buildStreams");
 function createFileDestination(pathname) {
   const target = pathname && pathname.length > 0 ? pathname : "logs/app.log";
   const resolved = (0, import_path.isAbsolute)(target) ? target : (0, import_path.join)(process.cwd(), target);
@@ -14973,32 +15067,32 @@ LoggerModule = _ts_decorate5([
   (0, import_common5.Global)(),
   (0, import_common5.Module)({
     imports: [
-      import_config2.ConfigModule.forFeature(logger_config_default)
+      import_config3.ConfigModule.forFeature(logger_config_default)
     ],
     providers: [
       RequestContextService,
       LoggerContextMiddleware,
       {
         provide: PINO_ROOT_LOGGER,
-        useFactory: /* @__PURE__ */ __name((config) => createPinoLogger(config), "useFactory"),
+        useFactory: /* @__PURE__ */ __name((config) => {
+          return createPinoLogger({
+            level: config.level,
+            filePath: `${config.logDir}/app.log`
+          });
+        }, "useFactory"),
         inject: [
           logger_config_default.KEY
         ]
       },
       {
         provide: TRACE_LOGGER,
-        useFactory: /* @__PURE__ */ __name((requestContext) => new PinoLoggerService(createPinoLogger({
-          level: "trace",
-          destinations: [
-            {
-              type: "file",
-              path: "logs/trace.log",
-              level: "trace"
-            }
-          ]
+        useFactory: /* @__PURE__ */ __name((requestContext, config) => new PinoLoggerService(createPinoLogger({
+          level: config.level,
+          filePath: `${config.logDir}/trace.log`
         }), requestContext), "useFactory"),
         inject: [
-          RequestContextService
+          RequestContextService,
+          logger_config_default.KEY
         ]
       },
       AppLogger,
@@ -15021,6 +15115,7 @@ LoggerModule = _ts_decorate5([
   AppLogger,
   LoggerContextMiddleware,
   LoggerModule,
+  PinoLoggerService,
   TRACE_LOGGER
 });
 //# sourceMappingURL=index.cjs.map