@nm-logger/logger 1.2.2 → 1.2.4

package/README.md

@@ -1,4 +1,4 @@
-# @nm-logger/logger v1.2.2
+# @nm-logger/logger v1.2.3
 
 Minimal JSON logger for Express:
 
@@ -12,7 +12,8 @@ Minimal JSON logger for Express:
 - S3: one JSON file per day per category, append (read+merge+put)
 - Previous day's local folder is removed when the date changes
 - `employee_id` taken from `req.user.employee_id || req.user.emp_code || req.user.id`
-- `baseDir` can be absolute (e.g. `/home/VE/hiveLogs`)
+- `baseDir` can be absolute (e.g. `/home/logs`)
+
 
 Basic usage:
 
@@ -25,17 +26,23 @@ const nm_logger = new Logger(
     accessKeyId: process.env.AWS_ACCESS_KEY_ID,
     secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
     region: "us-east-1",
-    bucket: "nmhive"
+    bucket: "bucket-name"
   },
   {
-    baseDir: "/home/logger/logs",
+    baseDir: "/home/logs",
     uploadIntervalMs: 60_000,
     maskFields: ["aadhaar", "pan"]
   }
 );
 
+Folder permission
+
+- mkdir -p /home/logs
+- chmod -R 777 /home/logs
+
 app.use(nm_logger.requestLoggerMiddleware());
 app.use("/api", routes);
 app.use(nm_logger.expressMiddleware());
 nm_logger.attachAxiosLogger(axios);
-```
+
+```

package/package.json

@@ -1 +1 @@
-{"name":"@nm-logger/logger","version":"1.2.2","description":"Express JSON logger with daily success/error/external logs, S3 append uploads, and configurable baseDir.","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.4","description":"Express JSON logger with daily success/error/external logs, S3 append uploads, and configurable baseDir.","main":"index.js","types":"index.d.ts","license":"MIT","dependencies":{"@aws-sdk/client-s3":"^3.600.0","fs-extra":"^11.1.1"}}

package/src/LogWriter.js

@@ -1,2 +1,57 @@
-const fs=require("fs-extra");const path=require("path");const{getDatePath,formatDate}=require("./utils");const MAP={success:"daily_logs_success.json",error:"daily_logs_error.json",external:"daily_logs_external.json"};
-class LogWriter{constructor(baseDir){this.baseDir=baseDir;}getFilePath(cat="success"){const{Y,M,D}=getDatePath();const fn=MAP[cat]||MAP.success;return path.join(this.baseDir,`${Y}/${M}/${D}/${fn}`);}async writeLog(log,cat="success"){const fp=this.getFilePath(cat);await fs.ensureDir(path.dirname(fp));let w={logs:[]};if(await fs.pathExists(fp)){try{const t=await fs.readFile(fp,"utf8");if(t.trim()){const p=JSON.parse(t);if(Array.isArray(p.logs))w.logs=p.logs;}}catch(_){}}w.logs.push({url:log.url||"",body:log.body||"",params:log.params||"",type:log.type||"",method:log.method||"",error:log.error||"",employee_id:log.employee_id||"",date:log.date||formatDate(new Date())});await fs.writeFile(fp,JSON.stringify(w,null,2),"utf8");return fp;}}module.exports=LogWriter;
+const fs = require("fs-extra");
+const path = require("path");
+const { getDatePath, formatDate } = require("./utils");
+
+const MAP = {
+  success: "daily_logs_success.json",
+  error: "daily_logs_error.json",
+  external: "daily_logs_external.json",
+};
+
+class LogWriter {
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+
+  getFilePath(category = "success") {
+    const { Y, M, D } = getDatePath();
+    const fileName = MAP[category] || MAP.success;
+    return path.join(this.baseDir, `${Y}/${M}/${D}/${fileName}`);
+  }
+
+  async writeLog(log, category = "success") {
+    const filePath = this.getFilePath(category);
+    await fs.ensureDir(path.dirname(filePath));
+
+    let wrapper = { logs: [] };
+
+    if (await fs.pathExists(filePath)) {
+      try {
+        const txt = await fs.readFile(filePath, "utf8");
+        if (txt.trim()) {
+          const parsed = JSON.parse(txt);
+          if (Array.isArray(parsed.logs)) {
+            wrapper.logs = parsed.logs;
+          }
+        }
+      } catch (_) {}
+    }
+
+    wrapper.logs.push({
+      url: log.url || "",
+      body: log.body || "",
+      params: log.params || "",
+      response: log.response || "", // 👈 NEW: store external response if present
+      type: log.type || "",
+      method: log.method || "",
+      error: log.error || "",
+      employee_id: log.employee_id || "",
+      date: log.date || formatDate(new Date()),
+    });
+
+    await fs.writeFile(filePath, JSON.stringify(wrapper, null, 2), "utf8");
+    return filePath;
+  }
+}
+
+module.exports = LogWriter;

package/src/Logger.js

@@ -1,11 +1,200 @@
-const LogWriter=require("./LogWriter");const Queue=require("./Queue");const S3Uploader=require("./S3Uploader");const DailyWatcher=require("./DailyWatcher");const{getApiType,maskSensitive}=require("./utils");const fs=require("fs-extra");const path=require("path");
-class Logger{constructor(s3cfg={},opt={}){let dir="logs";try{if(opt.baseDir){const r=path.resolve(opt.baseDir);fs.ensureDirSync(r);dir=r;}}catch(e){console.error("[@nm-logger] Invalid baseDir, fallback to ./logs",e.message);}this.baseDir=dir;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||60000});}
-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(()=>{});}catch(_){ }next(err);};}
-requestLoggerMiddleware(){return(req,res,next)=>{try{if(!req.__nm_logger_logged){req.__nm_logger_logged=true;this.logRequest(req).catch(()=>{});}}catch(_){ }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(()=>{});}catch(_){ }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(()=>{});}catch(_){ }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 } = require("./utils");
+const fs = require("fs-extra");
+const path = require("path");
+
+class Logger {
+  constructor(s3cfg = {}, opt = {}) {
+    let dir = null;
+
+    try {
+      if (opt.baseDir) {
+        const resolved = path.resolve(opt.baseDir);
+        const parent = path.dirname(resolved);
+
+        // ensure parent + dir exist
+        fs.ensureDirSync(parent);
+        fs.ensureDirSync(resolved);
+
+        dir = resolved;
+        console.log("[nm-logger] ✔ Using baseDir:", dir);
+      }
+    } catch (e) {
+      console.error("[nm-logger] ❌ baseDir INVALID:", e.message);
+    }
+
+    if (!dir) {
+      dir = path.resolve("logs");
+      fs.ensureDirSync(dir);
+      console.error("[nm-logger] ⚠ Falling back to:", dir);
+    }
+
+    this.baseDir = dir;
+    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 || 60_000,
+    });
+  }
+
+  // Mask helper
+  mask(v) {
+    return maskSensitive(v, this.maskFields);
+  }
+
+  // Build base log object for success/error logs
+  buildBaseLog(req, employee_id = "") {
+    const url = req && req.originalUrl ? req.originalUrl : "";
+    const body = (req && req.body) || {};
+    const params = {
+      params: (req && req.params) || {},
+      query: (req && req.query) || {},
+    };
+
+    const maskedBody = this.mask(body);
+    const maskedParams = this.mask(params);
+    const method = (req && req.method ? req.method : "").toUpperCase();
+
+    const emp =
+      employee_id ||
+      req?.employee_id ||
+      (req &&
+        req.user &&
+        (req.user.employee_id || req.user.emp_code || req.user.id)) ||
+      "";
+
+    return {
+      url,
+      body: JSON.stringify(maskedBody || {}),
+      params: JSON.stringify(maskedParams || {}),
+      type: getApiType(url),
+      method,
+      error: "",
+      employee_id: emp,
+    };
+  }
+
+  // ---- Error logging (Express errors) ----
+  async logError(err, req, employee_id = "") {
+    const base = this.buildBaseLog(req || {}, employee_id);
+
+    const log = {
+      ...base,
+      error: err && err.message ? err.message : String(err || ""),
+    };
+
+    await this.logWriter.writeLog(log, "error");
+  }
+
+  // ---- Success logging (normal requests) ----
+  async logRequest(req, employee_id = "") {
+    const log = this.buildBaseLog(req, employee_id);
+    await this.logWriter.writeLog(log, "success");
+  }
+
+  // ---- External API logging (Axios) ----
+  async logExternalApi({
+    url,
+    method,
+    data,
+    params,
+    error,
+    employeeId,
+    response, // 👈 NEW: store external API response
+  }) {
+    const maskedBody = this.mask(data || {});
+    const maskedParams = this.mask(params || {});
+    const maskedResponse = this.mask(response || {});
+
+    const log = {
+      url: url || "",
+      body: JSON.stringify(maskedBody || {}),
+      params: JSON.stringify(maskedParams || {}),
+      response: JSON.stringify(maskedResponse || {}), // 👈 NEW FIELD
+      type: "external_api",
+      method: (method || "").toUpperCase(),
+      error: error || "",
+      employee_id: employeeId || "",
+    };
+
+    await this.logWriter.writeLog(log, "external");
+  }
+
+  // ---- Express error middleware ----
+  expressMiddleware() {
+    return (err, req, res, next) => {
+      try {
+        this.logError(err, req).catch(() => {});
+      } catch (_) {}
+      next(err);
+    };
+  }
+
+  // ---- Request logger middleware (once per request) ----
+  requestLoggerMiddleware() {
+    return (req, res, next) => {
+      try {
+        if (!req.__nm_logger_logged) {
+          req.__nm_logger_logged = true;
+          this.logRequest(req).catch(() => {});
+        }
+      } catch (_) {}
+      next();
+    };
+  }
+
+  // ---- Axios interceptor ----
+  attachAxiosLogger(axiosInstance) {
+    if (!axiosInstance || !axiosInstance.interceptors) return;
+
+    // Success response
+    axiosInstance.interceptors.response.use(
+      (response) => {
+        try {
+          const cfg = response.config || {};
+          this.logExternalApi({
+            url: cfg.url,
+            method: cfg.method,
+            data: cfg.data,
+            params: cfg.params,
+            response: response.data, // 👈 log external API response body
+            error: null,
+            employeeId: cfg.employee_id,
+          }).catch(() => {});
+        } catch (_) {}
+
+        return response;
+      },
+
+      // Error response
+      (error) => {
+        try {
+          const cfg = (error && error.config) || {};
+          const res = error && error.response;
+
+          this.logExternalApi({
+            url: cfg && cfg.url,
+            method: cfg && cfg.method,
+            data: cfg && cfg.data,
+            params: cfg && cfg.params,
+            response: res && res.data, // 👈 log response even on error
+            error: error && error.message,
+            employeeId: cfg && cfg.employee_id,
+          }).catch(() => {});
+        } catch (_) {}
+
+        return Promise.reject(error);
+      }
+    );
+  }
+}
+
+module.exports = Logger;