feat(api): use logfmt as logging format (#909)

* feat(api): use logfmt as logging format

* feat(api): create specific logfmt logger file

* chore(logger): use logfmt format in general logger

* chore(rest-api-server): revert custom logger

* chore(rest-api-server): format morgan request fields

---------

Co-authored-by: PJColombo <[email protected]>

Author: PabloCastellano

apps/rest-api-server/src/morgan.ts

@@ -3,7 +3,56 @@ import morgan from "morgan";
 import { logger } from "@blobscan/logger";
 
 const stream = {
-  write: (message: string) => logger.http(message),
+  write: (message: string) => {
+    try {
+      const parsed = JSON.parse(message);
+      logger.http("HTTP request handled", parsed);
+    } catch {
+      logger.http(message.trim());
+    }
+  },
 };
 
-export const morganMiddleware = morgan("short", { stream });
+export const morganMiddleware = morgan(
+  (tokens, req, res) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const get = (name: string, ...args: any[]) =>
+      tokens[name]?.(req, res, ...args);
+
+    const data: Record<string, string> = {};
+
+    const ip = get("remote-addr");
+    const method = get("method");
+    const url = get("url");
+    const status = get("status");
+    const responseTime = get("response-time");
+    const contentLength = get("res", "content-length");
+
+    if (ip) {
+      data.ip = ip;
+    }
+
+    if (method) {
+      data.method = method;
+    }
+
+    if (url) {
+      data.url = url;
+    }
+
+    if (status) {
+      data.status = status;
+    }
+
+    if (responseTime) {
+      data.res_time = `${responseTime}ms`;
+    }
+
+    if (contentLength) {
+      data.res_length = contentLength;
+    }
+
+    return JSON.stringify(data);
+  },
+  { stream }
+);

packages/logger/package.json

@@ -13,8 +13,12 @@
   },
   "dependencies": {
     "@blobscan/zod": "workspace:^0.1.0",
+    "logfmt": "^1.4.0",
     "winston": "^3.18.3"
   },
+  "devDependencies": {
+    "@types/logfmt": "^1.2.1"
+  },
   "eslintConfig": {
     "root": true,
     "extends": [

packages/logger/src/index.ts

@@ -1,3 +1,4 @@
+import logfmt from "logfmt";
 import winston from "winston";
 
 import { z } from "@blobscan/zod";
@@ -6,19 +7,6 @@ export const logLevelEnum = z.enum(["error", "warn", "info", "http", "debug"]);
 
 export type LoggerLevel = z.output<typeof logLevelEnum>;
 
-function buildErrorCause(err: Error) {
-  let msg = `\n - Cause: ${err.message}`;
-
-  const cause = err.cause;
-  if (cause instanceof Error || typeof cause === "string") {
-    const errorCause = typeof cause === "string" ? new Error(cause) : cause;
-
-    msg += buildErrorCause(errorCause);
-  }
-
-  return msg;
-}
-
 const LOG_LEVELS = {
   error: 0,
   warn: 1,
@@ -38,37 +26,59 @@ const colorFormat = winston.format.colorize({
   },
 });
 
-const format = winston.format.combine(
+// Logfmt formatter for Winston
+const logfmtFormat = winston.format.combine(
   winston.format.errors({ cause: true, stack: true }),
   winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
   winston.format.printf((info) => {
-    const { timestamp, level, message, cause, service } = info;
-
-    const formattedLevel = colorFormat.colorize(level, level.toUpperCase());
-    const formattedService =
-      typeof service === "string"
-        ? colorFormat.colorize("service", service ?? "app")
-        : "";
-    const formattedMessage =
-      typeof message === "string"
-        ? colorFormat.colorize(level, message)
-        : message;
-
-    let msg = `${timestamp} ${formattedLevel} ${formattedService}: ${formattedMessage}`;
+    const { timestamp, level, message, service, cause, ...meta } = info;
+
+    const logData: Record<string, string | number | boolean> = {
+      ts: String(timestamp),
+      level: colorFormat.colorize(level, level),
+      message: colorFormat.colorize(
+        level,
+        typeof message === "string" ? message : JSON.stringify(message)
+      ),
+    };
+
+    if (typeof service === "string") {
+      logData.service = colorFormat.colorize("service", service);
+    }
 
+    // Add any additional metadata
+    Object.keys(meta).forEach((key) => {
+      const value = meta[key];
+      if (value !== undefined && key !== "cause") {
+        if (
+          typeof value === "string" ||
+          typeof value === "number" ||
+          typeof value === "boolean"
+        ) {
+          logData[key] = value;
+        } else {
+          logData[key] = JSON.stringify(value);
+        }
+      }
+    });
+
+    // Handle error causes
     if (cause instanceof Error) {
-      msg += colorFormat.colorize(level, buildErrorCause(cause));
+      logData.error_cause = cause.message;
+      if (cause.stack) {
+        logData.error_stack = cause.stack;
+      }
     }
 
-    return msg;
+    return logfmt.stringify(logData);
   })
 );
 
 export function createLogger(name?: string, opts: winston.LoggerOptions = {}) {
   return winston.createLogger({
     level: process.env.LOG_LEVEL ?? "info",
     levels: LOG_LEVELS,
-    format,
+    format: logfmtFormat,
     transports: [new winston.transports.Console()],
     silent: process.env.MODE === "test",
     ...opts,
@@ -79,7 +89,7 @@ export function createLogger(name?: string, opts: winston.LoggerOptions = {}) {
   });
 }
 
-export const logger = createLogger();
+export const logger = createLogger("rest-api-server");
 
 export async function perfOperation<T>(
   operation: () => T