@nm-logger/logger 1.2.0 → 1.2.1

package/package.json

@@ -1 +1 @@
-{"name":"@nm-logger/logger","version":"1.2.0","description":"Express JSON logger with daily success/error/external logs and S3 append uploads.","main":"index.js","types":"index.d.ts","license":"MIT","dependencies":{"@aws-sdk/client-s3":"^3.600.0","fs-extra":"^11.1.1"}}
+{"name":"@nm-logger/logger","version":"1.2.1","description":"Express JSON logger with daily success/error/external logs and S3 append uploads.","main":"index.js","types":"index.d.ts","license":"MIT","dependencies":{"@aws-sdk/client-s3":"^3.600.0","fs-extra":"^11.1.1"}}

package/src/Logger.js

@@ -1,12 +1,268 @@
-const LogWriter=require("./LogWriter");const Queue=require("./Queue");const S3Uploader=require("./S3Uploader");const DailyWatcher=require("./DailyWatcher");const{getApiType,maskSensitive}=require("./utils");
-class Logger{constructor(s3cfg={},opt={}){this.baseDir=opt.baseDir||"logs";this.logWriter=new LogWriter(this.baseDir);this.queue=new Queue();this.s3=new S3Uploader(s3cfg);this.maskFields=(opt.maskFields||[]).map(x=>String(x).toLowerCase());new DailyWatcher(this.baseDir,this.queue,this.s3,{uploadIntervalMs:opt.uploadIntervalMs});}
-mask(v){return maskSensitive(v,this.maskFields);}
-buildBaseLog(req,employee_id=""){const url=req&&req.originalUrl||"";const body=req&&req.body||{};const params={params:req&&req.params||{},query:req&&req.query||{}};const mBody=this.mask(body);const mParams=this.mask(params);const method=(req&&req.method||"").toUpperCase();const emp=employee_id||(req&&req.user&&(req.user.employee_id||req.user.emp_code||req.user.id))||"";return{url,body:JSON.stringify(mBody||{}),params:JSON.stringify(mParams||{}),type:getApiType(url),method,error:"",employee_id:emp};}
-async logError(err,req,employee_id=""){const base=this.buildBaseLog(req||{},employee_id);const d={...base,error:err&&err.message?err.message:String(err||"")};await this.logWriter.writeLog(d,"error");}
-async logRequest(req,employee_id=""){const d=this.buildBaseLog(req,employee_id);await this.logWriter.writeLog(d,"success");}
-async logExternalApi({url,method,data,params,error,employeeId}){const mb=this.mask(data||{});const mp=this.mask(params||{});const d={url:url||"",body:JSON.stringify(mb||{}),params:JSON.stringify(mp||{}),type:"external_api",method:(method||"").toUpperCase(),error:error||"",employee_id:employeeId||""};await this.logWriter.writeLog(d,"external");}
-expressMiddleware(){return(err,req,res,next)=>{try{this.logError(err,req).catch(e=>console.error("logger express error",e));}catch(e){console.error("logger express outer",e);}next(err);};}
-expressErrorMiddleware(){return this.expressMiddleware();}
-requestLoggerMiddleware(){return(req,res,next)=>{try{if(req.__nm_logger_logged)return next();req.__nm_logger_logged=true;this.logRequest(req).catch(e=>console.error("logger request error",e));}catch(e){console.error("logger request outer",e);}next();};}
-attachAxiosLogger(ax){if(!ax||!ax.interceptors)return;ax.interceptors.response.use(r=>{try{const c=r.config||{};this.logExternalApi({url:c.url,method:c.method,data:c.data,params:c.params,error:null,employeeId:c.employee_id}).catch(e=>console.error("logger axios ok",e));}catch(e){console.error("logger axios ok outer",e);}return r;},err=>{try{const c=err.config||{};this.logExternalApi({url:c&&c.url,method:c&&c.method,data:c&&c.data,params:c&&c.params,error:err&&err.message,employeeId:c&&c.employee_id}).catch(e=>console.error("logger axios err",e));}catch(e){console.error("logger axios err outer",e);}return Promise.reject(err);});}}
-module.exports=Logger;
+const LogWriter = require("./LogWriter");
+const Queue = require("./Queue");
+const S3Uploader = require("./S3Uploader");
+const DailyWatcher = require("./DailyWatcher");
+const {
+  getApiType,
+  maskSensitive,
+  generateCorrelationId
+} = require("./utils");
+
+const fs = require("fs-extra");
+const path = require("path");
+
+let dir = "logs";
+
+class Logger {
+  constructor(s3config = {}, options = {}) {
+   try {
+  if (opt.baseDir) {
+    const cleanPath = path.resolve(opt.baseDir); // absolute path
+
+    // Create folder safely if not exists
+    fs.ensureDirSync(cleanPath);
+
+    dir = cleanPath;
+  }
+} catch (e) {
+  console.error("[@nm-logger/logger] Invalid baseDir path, using default:", e.message);
+}
+
+this.baseDir = dir;
+
+    this.logWriter = new LogWriter(this.baseDir);
+    this.queue = new Queue();
+    this.s3Uploader = new S3Uploader(s3config);
+
+    this.extraMaskFields = (options.maskFields || []).map((f) =>
+      String(f).toLowerCase()
+    );
+
+    new DailyWatcher(this.baseDir, this.queue, this.s3Uploader, {
+      uploadIntervalMs: options.uploadIntervalMs
+    });
+  }
+
+  mask(value) {
+    return maskSensitive(value, this.extraMaskFields);
+  }
+
+  buildBaseLog(req, employee_id = "") {
+    const url = req?.originalUrl || "";
+    const bodySrc = req?.body || {};
+    const paramsObj = {
+      params: req?.params || {},
+      query: req?.query || {}
+    };
+
+    const maskedBody = this.mask(bodySrc);
+    const maskedParams = this.mask(paramsObj);
+
+    let correlationId =
+      req?.correlationId ||
+      (req?.headers &&
+        (req.headers["x-correlation-id"] || req.headers["X-Correlation-ID"])) ||
+      "";
+
+    const method = (req?.method || "").toUpperCase();
+
+    return {
+      url,
+      body: JSON.stringify(maskedBody || {}),
+      params: JSON.stringify(maskedParams || {}),
+      type: getApiType(url),
+      method,
+      error: "",
+      employee_id:
+        employee_id ||
+        (req &&
+          req.user &&
+          (req.user.employee_id || req.user.emp_code || req.user.id)) ||
+        "",
+      correlation_id: correlationId
+    };
+  }
+
+  async logError(err, req, employee_id = "") {
+    const base = this.buildBaseLog(req || {}, employee_id);
+    const logData = {
+      ...base,
+      error: err && err.message ? err.message : String(err || "")
+    };
+    await this.logWriter.writeLog(logData, "error");
+  }
+
+  async logRequest(req, employee_id = "") {
+    const logData = this.buildBaseLog(req, employee_id);
+    await this.logWriter.writeLog(logData, "success");
+  }
+
+  async logExternalApi({
+    url,
+    method,
+    data,
+    params,
+    error,
+    correlationId,
+    employeeId
+  }) {
+    const maskedBody = this.mask(data || {});
+    const maskedParams = this.mask(params || {});
+
+    const logData = {
+      url: url || "",
+      body: JSON.stringify(maskedBody || {}),
+      params: JSON.stringify(maskedParams || {}),
+      type: "external_api",
+      method: (method || "").toUpperCase(),
+      error: error || "",
+      employee_id: employeeId || "",
+      correlation_id: correlationId || "",
+      date: undefined
+    };
+
+    await this.logWriter.writeLog(logData, "external");
+  }
+
+  expressMiddleware() {
+    return (err, req, res, next) => {
+      try {
+        let correlationId =
+          req.correlationId ||
+          (req.headers &&
+            (req.headers["x-correlation-id"] ||
+              req.headers["X-Correlation-ID"])) ||
+          "";
+
+        
+
+        if (res && !res.headersSent) {
+          res.setHeader("X-Correlation-ID", correlationId);
+        }
+
+        this.logError(err, req).catch((e) =>
+          console.error("Logger expressMiddleware error:", e)
+        );
+      } catch (e) {
+        console.error("Logger expressMiddleware outer error:", e);
+      }
+
+      next(err);
+    };
+  }
+
+  expressErrorMiddleware() {
+    return this.expressMiddleware();
+  }
+
+requestLoggerMiddleware() {
+  return (req, res, next) => {
+    try {
+      console.log
+      if (req.__nm_logger_logged) return next();
+      req.__nm_logger_logged = true;
+
+      // correlation ID (no-crash)
+      const correlationId = 
+        req.headers["x-correlation-id"] ||
+        req.headers["X-Correlation-ID"] ||
+        req.correlationId ||
+        ''
+
+      req.correlationId = correlationId;
+      res.setHeader("X-Correlation-ID", correlationId);
+
+      // safe logging
+      try {
+        this.logRequest(req).catch(err => {
+          console.error("🔥 Error inside logRequest:", err);
+        });
+      } catch (inner) {
+        console.error("🔥 UNEXPECTED error inside requestLoggerMiddleware:", inner);
+      }
+
+    } catch (outer) {
+      console.error("🔥 requestLoggerMiddleware FATAL error:", outer);
+    }
+
+    next();
+  };
+}
+
+  attachAxiosLogger(axiosInstance) {
+    if (!axiosInstance || !axiosInstance.interceptors) {
+      console.warn(
+        "[@nm-logger/logger] attachAxiosLogger: provided axios instance is invalid"
+      );
+      return;
+    }
+
+    axiosInstance.interceptors.response.use(
+      (response) => {
+        try {
+          const cfg = response.config || {};
+          const headers = cfg.headers || {};
+
+          const correlationId =
+            headers["X-Correlation-ID"] ||
+            headers["x-correlation-id"] ||
+            "";
+
+          const employeeId =
+            headers["X-Employee-ID"] ||
+            headers["x-employee-id"] ||
+            "";
+
+          this.logExternalApi({
+            url: cfg.url,
+            method: cfg.method,
+            data: cfg.data,
+            params: cfg.params,
+            error: null,
+            correlationId,
+            employeeId
+          }).catch((e) =>
+            console.error("Logger axios success logExternalApi error:", e)
+          );
+        } catch (e) {
+          console.error("Logger axios response interceptor error:", e);
+        }
+        return response;
+      },
+      (error) => {
+        try {
+          const cfg = error.config || {};
+          const headers = cfg ? cfg.headers || {} : {};
+
+          const correlationId =
+            headers["X-Correlation-ID"] ||
+            headers["x-correlation-id"] ||
+            "";
+
+          const employeeId =
+            headers["X-Employee-ID"] ||
+            headers["x-employee-id"] ||
+            "";
+
+          this.logExternalApi({
+            url: cfg && cfg.url,
+            method: cfg && cfg.method,
+            data: cfg && cfg.data,
+            params: cfg && cfg.params,
+            error: error && error.message,
+            correlationId,
+            employeeId
+          }).catch((e) =>
+            console.error("Logger axios error logExternalApi error:", e)
+          );
+        } catch (e) {
+          console.error("Logger axios error interceptor outer error:", e);
+        }
+
+        return Promise.reject(error);
+      }
+    );
+  }
+}
+
+module.exports = Logger;