@nm-logger/logger 1.1.9 → 1.2.0

package/LICENSE

@@ -1,21 +1,3 @@
 MIT License
 
 Copyright (c) 2025
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights  
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell     
-copies of the Software, and to permit persons to whom the Software is        
-furnished to do so, subject to the following conditions:                     
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.                              
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR    
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,      
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE   
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER       
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,241 +1,39 @@
-# @nm-logger/logger
+# @nm-logger/logger v1.2.0
 
-Daily JSON logger for Node.js / Express APIs with:
-- Per-request logging (success, error, external API)
-- Separate daily files:
-  - `daily_logs_success.json`
-  - `daily_logs_error.json`
-  - `daily_logs_external.json`
-- S3 upload + queue + daily rotation  
-- Correlation IDs (with `X-Correlation-ID` header)  
-- External API logging (Axios)  
-- Sensitive field masking (password, token, otp, etc.)  
+Minimal JSON logger for Express:
 
----
+- Logs every handled request as **success**
+- Logs errors from Express error middleware as **error**
+- Logs Axios requests as **external**
+- Local daily files (under `baseDir`):
+  - `YYYY/MM/DD/daily_logs_success.json`
+  - `YYYY/MM/DD/daily_logs_error.json`
+  - `YYYY/MM/DD/daily_logs_external.json`
+- S3: one JSON file per day per category, always appended (read + merge + put)
+- Local previous-day folder is removed when date changes
+- `employee_id` is taken from `req.user.employee_id` (if available)
 
-## Installation
-
-After you publish the package to npm:
-
-```bash
-npm install @nm-logger/logger
-```
-
----
-
-## Log Format
-
-Each log line in `daily_logs.json` is a JSON object:
-
-```json
-{
-  "url": "/api/v1/attendance/get",
-  "body": "{\"month\":\"2025-12\"}",
-  "params": "{\"params\":{},\"query\":{}}",
-  "type": "get",
-  "error": "",
-  "date": "2025-12-05 12:24:00",
-  "employee_id": "TAKK122",
-  "correlation_id": "cid-abcd1234-17f5d3c9a"
-}
-```
-
-Fields:
-
-- `url` – `req.originalUrl`
-- `body` – stringified (and masked) `req.body`
-- `params` – stringified (and masked) object `{ params: req.params, query: req.query }`
-- `type` – last segment of the URL (e.g. `/api/v1/attendance/get` → `"get"`)
-- `error` – error message if any
-- `date` – `YYYY-MM-DD HH:mm:ss`
-- `employee_id` – from argument or `req.user.employee_id / emp_code / id`
-- `correlation_id` – unique per request chain (also added as `X-Correlation-ID` header)
-
----
-
-## Basic Usage
-
-### 1. Create the logger
+## Basic usage
 
 ```js
 const Logger = require("@nm-logger/logger");
+const axios = require("axios");
 
 const logger = new Logger(
   {
-    accessKeyId: process.env.AWS_KEY,
-    secretAccessKey: process.env.AWS_SECRET,
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
     region: "ap-south-1",
-    bucket: "your-log-bucket-name"
+    bucket: "nmhive"
   },
   {
-    baseDir: "logs",        // optional, default "logs"
-    watchIntervalMs: 60000, // optional, default 60s
-    maskFields: ["aadhaar", "panNumber"] // extra fields to mask
+    baseDir: "hiveLogs",
+    uploadIntervalMs: 60_000
   }
 );
-```
-
-### 2. Log every request + set correlation ID header
 
-```js
 app.use(logger.requestLoggerMiddleware());
-```
-
-### 3. Log errors via Express error middleware
-
-```js
-// your routes above...
-
-app.use(logger.expressMiddleware()); // or logger.expressErrorMiddleware()
-```
-
-### 4. Manual logging in routes
-
-```js
-app.post("/api/v1/attendance/get", async (req, res) => {
-  try {
-    // ... your logic, external APIs etc ...
-
-    await logger.logRequest(req, req.user?.employee_id);
-    res.json({ success: true });
-  } catch (err) {
-    await logger.logError(err, req, req.user?.employee_id);
-    res.status(500).json({ error: err.message });
-  }
-});
-```
-
----
-
-## External API logging with Axios
-
-```js
-const axios = require("axios");
-
-// Attach once at startup
+app.use("/api", routes);
+app.use(logger.expressMiddleware());
 logger.attachAxiosLogger(axios);
-
-app.get("/api/v1/some-data", async (req, res) => {
-  try {
-    const response = await axios.get("https://api.example.com/data", {
-      headers: {
-        "X-Correlation-ID": req.correlationId,          // propagated
-        "X-Employee-ID": req.user?.employee_id || ""    // optional
-      },
-      params: {
-        id: 123
-      }
-    });
-
-    res.json(response.data);
-  } catch (err) {
-    await logger.logError(err, req, req.user?.employee_id);
-    res.status(500).json({ error: err.message });
-  }
-});
-```
-
-This will produce external log lines like:
-
-```json
-{
-  "url": "https://api.example.com/data",
-  "body": "{}",
-  "params": "{\"id\":123}",
-  "type": "external_api",
-  "error": "",
-  "date": "2025-12-05 12:24:00",
-  "employee_id": "TAKK122",
-  "correlation_id": "cid-abcd1234-17f5d3c9a"
-}
-```
-
----
-
-## Sensitive Data Masking
-
-Built-in masked keys (case-insensitive, partial match):
-
-- password, pass  
-- token, secret  
-- otp  
-- auth, authorization  
-- apiKey, api_key  
-- session  
-- ssn  
-
-Plus anything you pass in `maskFields` option.
-
-Any object like:
-
-```json
-{
-  "password": "MyPass123",
-  "otp": "111222",
-  "aadhaar": "9999-8888-7777",
-  "email": "user@example.com"
-}
-```
-
-will be logged as:
-
-```json
-{
-  "password": "*****",
-  "otp": "*****",
-  "aadhaar": "*****",
-  "email": "user@example.com"
-}
-```
-
----
-
-## S3 Upload Behavior
-
-- Logs are stored locally under:
-  - `logs/YYYY/MM/DD/daily_logs.json`
-- A watcher runs every `watchIntervalMs` (default 60 seconds)
-  - When the date changes (e.g., from `2025-12-05` to `2025-12-06`),
-  - The logger uploads the **previous day's** log file to S3:
-
-Example S3 key:
-
-```txt
-2025/12/05/daily_logs.json
-```
-
-So final S3 path:
-
-```txt
-s3://<bucket>/<year>/<month>/<day>/daily_logs.json
-```
-
----
-
-## TypeScript Usage
-
-```ts
-import Logger, { S3Config, LoggerOptions } from "@ve/logger";
-
-const s3config: S3Config = {
-  accessKeyId: process.env.AWS_KEY!,
-  secretAccessKey: process.env.AWS_SECRET!,
-  region: "ap-south-1",
-  bucket: "your-log-bucket"
-};
-
-const options: LoggerOptions = {
-  baseDir: "logs",
-  watchIntervalMs: 60000,
-  maskFields: ["aadhaar", "pan"]
-};
-
-const logger = new Logger(s3config, options);
 ```
-
----
-
-## License
-
-MIT
-

package/index.d.ts

@@ -1,69 +1,17 @@
 import * as express from "express";
 
-export interface S3Config {
-  accessKeyId: string;
-  secretAccessKey: string;
-  region: string;
-  bucket: string;
+export interface S3Config{accessKeyId:string;secretAccessKey:string;region:string;bucket:string;}
+export interface LoggerOptions{baseDir?:string;maskFields?:string[];uploadIntervalMs?:number;}
+export interface ExternalApiLogOptions{url?:string;method?:string;data?:any;params?:any;error?:string|null;employeeId?:string;}
+
+declare class Logger{
+  constructor(s3config?:S3Config,options?:LoggerOptions);
+  logError(err:any,req?:express.Request,employee_id?:string):Promise<void>;
+  logRequest(req:express.Request,employee_id?:string):Promise<void>;
+  logExternalApi(options:ExternalApiLogOptions):Promise<void>;
+  expressMiddleware(): (err:any,req:express.Request,res:express.Response,next:express.NextFunction)=>void;
+  expressErrorMiddleware(): (err:any,req:express.Request,res:express.Response,next:express.NextFunction)=>void;
+  requestLoggerMiddleware(): (req:express.Request,res:express.Response,next:express.NextFunction)=>void;
+  attachAxiosLogger(axiosInstance:any):void;
 }
-
-export interface LoggerOptions {
-  baseDir?: string;
-  maskFields?: string[];
-  uploadIntervalMs?: number;
-}
-
-export interface LogEntryShape {
-  url: string;
-  body: string;
-  params: string;
-  type: string;
-  method: string;
-  error: string;
-  employee_id: string;
-  correlation_id: string;
-  date: string;
-  category: string;
-}
-
-export interface ExternalApiLogOptions {
-  url?: string;
-  method?: string;
-  data?: any;
-  params?: any;
-  error?: string | null;
-  correlationId?: string;
-  employeeId?: string;
-}
-
-declare class Logger {
-  constructor(s3config?: S3Config, options?: LoggerOptions);
-
-  logError(err: any, req?: express.Request, employee_id?: string): Promise<void>;
-  logRequest(req: express.Request, employee_id?: string): Promise<void>;
-  logExternalApi(options: ExternalApiLogOptions): Promise<void>;
-
-  expressMiddleware(): (
-    err: any,
-    req: express.Request,
-    res: express.Response,
-    next: express.NextFunction
-  ) => void;
-
-  expressErrorMiddleware(): (
-    err: any,
-    req: express.Request,
-    res: express.Response,
-    next: express.NextFunction
-  ) => void;
-
-  requestLoggerMiddleware(): (
-    req: express.Request,
-    res: express.Response,
-    next: express.NextFunction
-  ) => void;
-
-  attachAxiosLogger(axiosInstance: any): void;
-}
-
 export = Logger;

package/index.js

@@ -1,3 +1 @@
-const Logger = require("./src/Logger");
-module.exports = Logger;
-module.exports.Logger = Logger;
+module.exports=require('./src/Logger');

package/package.json

@@ -1,36 +1 @@
-{
-  "name": "@nm-logger/logger",
-  "version": "1.1.9",
-  "description": "Express JSON logger with S3 upload, correlation IDs, and separate success/error/external daily logs.",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "scripts": {
-    "test": "node -e \"console.log('no tests yet')\""
-  },
-  "keywords": [
-    "logger",
-    "logging",
-    "express",
-    "s3",
-    "aws",
-    "json-logger",
-    "daily-logs",
-    "correlation-id",
-    "axios"
-  ],
-  "author": "nm-logger",
-  "license": "MIT",
-  "dependencies": {
-    "@aws-sdk/client-s3": "^3.600.0",
-    "fs-extra": "^11.1.1",
-     "@nm-logger/logger": "^1.1.9"
-  },
-  "peerDependencies": {
-    "express": ">=4.0.0"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.21",
-    "@types/node": "^22.0.0",
-    "typescript": "^5.6.0"
-  }
-}
+{"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"}}

package/src/DailyWatcher.js

@@ -1,84 +1,3 @@
-const fs = require("fs-extra");
-const path = require("path");
-const { getDatePath } = require("./utils");
-
-const CATEGORY_FILE_MAP = {
-  success: "daily_logs_success.json",
-  error: "daily_logs_error.json",
-  external: "daily_logs_external.json"
-};
-
-class DailyWatcher {
-  constructor(baseDir, queue, s3Uploader, options = {}) {
-    this.baseDir = baseDir;
-    this.queue = queue;
-    this.s3Uploader = s3Uploader;
-    this.intervalMs = options.uploadIntervalMs || 60_000; // default 1 minute
-
-    console.log(
-      "⏱ [@nm-logger/logger] periodic S3 upload every",
-      this.intervalMs,
-      "ms"
-    );
-
-    this.start();
-  }
-
-  start() {
-    setInterval(() => {
-      const { Y, M, D } = getDatePath();
-
-      Object.entries(CATEGORY_FILE_MAP).forEach(([category, fileName]) => {
-        const file = path.join(
-          this.baseDir,
-          `${Y}/${M}/${D}`,
-          fileName
-        );
-        const key = `${Y}/${M}/${D}/${fileName}`;
-
-        if (!fs.existsSync(file)) {
-          return;
-        }
-
-       this.queue.add(async () => {
-  try {
-    const now = new Date();
-    const key = `${Y}/${M}/${D}/${fileName}`;
-
-    console.log(`📤 Uploading [${category}] logs to S3: ${key}`);
-
-    // Step 1 — Read local file
-    const localContent = JSON.parse(await fs.readFile(file, "utf8"));
-
-    // Step 2 — Try loading existing file from S3
-    let existing = { logs: [] };
-    try {
-      const s3Content = await this.s3Uploader.getObject(key);
-      if (s3Content) {
-        existing = JSON.parse(s3Content);
-      }
-    } catch (err) {
-      // File may not exist on first upload — ignore
-    }
-
-    // Step 3 — Append logs
-    const merged = {
-      logs: [...existing.logs, ...localContent.logs]
-    };
-
-    // Step 4 — Upload merged logs
-    await this.s3Uploader.putObject(key, JSON.stringify(merged, null, 2));
-
-    console.log("✅ Logs appended to S3 successfully");
-
-  } catch (err) {
-    console.error(`❌ Error uploading logs to S3:`, err);
-  }
-});
-
-      });
-    }, this.intervalMs);
-  }
-}
-
-module.exports = DailyWatcher;
+const fs=require("fs-extra");const path=require("path");const{getDatePath}=require("./utils");
+const MAP={success:"daily_logs_success.json",error:"daily_logs_error.json",external:"daily_logs_external.json"};
+class DailyWatcher{constructor(baseDir,q,s3,opt={}){this.baseDir=baseDir;this.q=q;this.s3=s3;this.ms=opt.uploadIntervalMs||60000;this.currentDate=getDatePath();this.start();}async cleanup(){const{Y,M,D}=getDatePath();const p=this.currentDate;if(p.Y===Y&&p.M===M&&p.D===D)return;const dir=path.join(this.baseDir,`${p.Y}/${p.M}/${p.D}`);try{if(await fs.pathExists(dir))await fs.remove(dir);}catch(e){console.error("daily cleanup error",e);}this.currentDate={Y,M,D};}start(){setInterval(()=>{this.tick().catch(e=>console.error("daily tick error",e));},this.ms);}async tick(){await this.cleanup();const{Y,M,D}=getDatePath();for(const[cat,fn]of Object.entries(MAP)){const file=path.join(this.baseDir,`${Y}/${M}/${D}`,fn);const key=`${Y}/${M}/${D}/${fn}`;if(!(await fs.pathExists(file)))continue;this.q.add(async()=>{try{const txt=await fs.readFile(file,"utf8");let nw={logs:[]};if(txt.trim()){try{const p=JSON.parse(txt);if(Array.isArray(p.logs))nw.logs=p.logs;}catch(_){}}let ex={logs:[]};try{const s=await this.s3.getObject(key);if(s&&s.trim()){const p=JSON.parse(s);if(Array.isArray(p.logs))ex.logs=p.logs;}}catch(_){ }const merged={logs:[...ex.logs,...nw.logs]};await this.s3.putObject(key,JSON.stringify(merged,null,2));}catch(e){console.error("s3 upload error",e);}});}}}module.exports=DailyWatcher;

package/src/LogWriter.js

@@ -1,63 +1,3 @@
-const fs = require("fs-extra");
-const path = require("path");
-const { getDatePath, formatDate } = require("./utils");
-
-const CATEGORY_FILE_MAP = {
-  success: "daily_logs_success.json",
-  error: "daily_logs_error.json",
-  external: "daily_logs_external.json"
-};
-
-class LogWriter {
-  constructor(baseDir = "logs") {
-    this.baseDir = baseDir;
-  }
-
-  async writeLog(log, category = "success") {
-    const filePath = this.getFilePath(category);
-
-    await fs.ensureDir(path.dirname(filePath));
-
-    let logsWrapper = { logs: [] };
-
-    if (await fs.pathExists(filePath)) {
-      try {
-        const content = await fs.readFile(filePath, "utf8");
-        if (content.trim()) {
-          const parsed = JSON.parse(content);
-          if (Array.isArray(parsed.logs)) {
-            logsWrapper.logs = parsed.logs;
-          }
-        }
-      } catch (e) {
-        logsWrapper = { logs: [] };
-      }
-    }
-
-    const enriched = {
-      url: log.url || "",
-      body: log.body || "",
-      params: log.params || "",
-      type: log.type || "",
-      method: log.method || "",
-      error: log.error || "",
-      employee_id: log.employee_id || "",
-      correlation_id: log.correlation_id || "",
-      date: log.date || formatDate(new Date()),
-      category: category || ""
-    };
-
-    logsWrapper.logs.push(enriched);
-
-    await fs.writeFile(filePath, JSON.stringify(logsWrapper, null, 2), "utf8");
-    return filePath;
-  }
-
-  getFilePath(category = "success") {
-    const { Y, M, D } = getDatePath();
-    const fileName = CATEGORY_FILE_MAP[category] || CATEGORY_FILE_MAP.success;
-    return path.join(this.baseDir, `${Y}/${M}/${D}/${fileName}`);
-  }
-}
-
-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="logs"){this.baseDir=baseDir;}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:[]};}}const e={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())};w.logs.push(e);await fs.writeFile(fp,JSON.stringify(w,null,2),"utf8");return fp;}getFilePath(cat="success"){const{Y,M,D}=getDatePath();const fn=MAP[cat]||MAP.success;return path.join(this.baseDir,`${Y}/${M}/${D}/${fn}`);}}module.exports=LogWriter;

package/src/Logger.js

@@ -1,252 +1,12 @@
-const LogWriter = require("./LogWriter");
-const Queue = require("./Queue");
-const S3Uploader = require("./S3Uploader");
-const DailyWatcher = require("./DailyWatcher");
-const {
-  getApiType,
-  maskSensitive,
-  generateCorrelationId
-} = require("./utils");
-
-class Logger {
-  constructor(s3config = {}, options = {}) {
-    this.baseDir = options.baseDir || "logs";
-
-    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 (!correlationId) {
-          correlationId = generateCorrelationId();
-          req.correlationId = correlationId;
-        }
-
-        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 {
-      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 ||
-        generateCorrelationId();
-
-      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;
+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;

package/src/Queue.js

@@ -1,29 +1 @@
-class Queue {
-  constructor() {
-    this.jobs = [];
-    this.processing = false;
-  }
-
-  add(job) {
-    this.jobs.push(job);
-    this.run();
-  }
-
-  async run() {
-    if (this.processing) return;
-    this.processing = true;
-
-    while (this.jobs.length) {
-      const job = this.jobs.shift();
-      try {
-        await job();
-      } catch (err) {
-        console.error("[@nm-logger/logger] Queue job failed:", err);
-      }
-    }
-
-    this.processing = false;
-  }
-}
-
-module.exports = Queue;
+class Queue{constructor(){this.jobs=[];this.processing=false;}add(j){this.jobs.push(j);this.run();}async run(){if(this.processing)return;this.processing=true;while(this.jobs.length){const j=this.jobs.shift();try{await j();}catch(e){console.error("[@nm-logger/logger] queue job failed",e);}}this.processing=false;}}module.exports=Queue;

package/src/S3Uploader.js

@@ -1,47 +1,2 @@
-const fs = require("fs");
-const {
-  S3Client,
-  PutObjectCommand,
-  GetObjectCommand
-} = require("@aws-sdk/client-s3");
-const { streamToString } = require("./utils");
-
-class S3Uploader {
-  constructor(config) {
-    this.client = new S3Client({
-      region: config.region,
-      credentials: {
-        accessKeyId: config.accessKeyId,
-        secretAccessKey: config.secretAccessKey
-      }
-    });
-
-    this.bucket = config.bucket;
-  }
-
-  async getObject(key) {
-    try {
-      const result = await this.client.send(
-        new GetObjectCommand({
-          Bucket: this.bucket,
-          Key: key
-        })
-      );
-      return await streamToString(result.Body);
-    } catch (err) {
-      return null; // file not found
-    }
-  }
-
-  async putObject(key, body) {
-    await this.client.send(
-      new PutObjectCommand({
-        Bucket: this.bucket,
-        Key: key,
-        Body: body
-      })
-    );
-  }
-}
-
-module.exports = S3Uploader;
+const{S3Client,PutObjectCommand,GetObjectCommand}=require("@aws-sdk/client-s3");const{streamToString}=require("./utils");
+class S3Uploader{constructor(cfg){this.client=new S3Client({region:cfg.region,credentials:{accessKeyId:cfg.accessKeyId,secretAccessKey:cfg.secretAccessKey}});this.bucket=cfg.bucket;}async getObject(key){try{const r=await this.client.send(new GetObjectCommand({Bucket:this.bucket,Key:key}));return await streamToString(r.Body);}catch(e){if(e&&((e.name==="NoSuchKey")||(e.$metadata&&e.$metadata.httpStatusCode===404)))return null;throw e;}}async putObject(key,body){await this.client.send(new PutObjectCommand({Bucket:this.bucket,Key:key,Body:body}));}}module.exports=S3Uploader;

package/src/utils.js

@@ -1,100 +1,6 @@
-exports.getDatePath = () => {
-  const now = new Date();
-  const Y = now.getFullYear();
-  const M = String(now.getMonth() + 1).padStart(2, "0");
-  const D = String(now.getDate()).padStart(2, "0");
-  return { Y, M, D };
-};
-
-exports.formatDate = (d) => {
-  const pad = (n) => String(n).padStart(2, "0");
-  return (
-    d.getFullYear() +
-    "-" +
-    pad(d.getMonth() + 1) +
-    "-" +
-    pad(d.getDate()) +
-    " " +
-    pad(d.getHours()) +
-    ":" +
-    pad(d.getMinutes()) +
-    ":" +
-    pad(d.getSeconds())
-  );
-};
-
-exports.getApiType = (url) => {
-  if (!url) return "";
-  const segments = url.split("/").filter(Boolean);
-  return segments[segments.length - 1] || "";
-};
-
-const DEFAULT_MASK_KEYS = [
-  "password",
-  "pass",
-  "token",
-  "secret",
-  "otp",
-  "auth",
-  "authorization",
-  "apikey",
-  "api_key",
-  "session",
-  "ssn"
-];
-
-exports.maskSensitive = (value, extraFields = []) => {
-  const allKeys = [
-    ...DEFAULT_MASK_KEYS,
-    ...(extraFields || [])
-  ].map((k) => String(k).toLowerCase());
-
-  const shouldMaskKey = (key) => {
-    const lower = String(key).toLowerCase();
-    return allKeys.some((mk) => lower.includes(mk));
-  };
-
-  const maskAny = (val) => {
-    if (val && typeof val === "object") {
-      if (Array.isArray(val)) {
-        return val.map(maskAny);
-      }
-      const out = {};
-      for (const [k, v] of Object.entries(val)) {
-        if (shouldMaskKey(k)) {
-          out[k] = "*****";
-        } else {
-          out[k] = maskAny(v);
-        }
-      }
-      return out;
-    }
-    return val;
-  };
-
-  if (typeof value === "string") {
-    try {
-      const parsed = JSON.parse(value);
-      return maskAny(parsed);
-    } catch (_) {
-      return value;
-    }
-  }
-
-  return maskAny(value);
-};
-
-exports.generateCorrelationId = () => {
-  const rand = Math.random().toString(16).slice(2, 10);
-  const ts = Date.now().toString(16);
-  return `cid-${rand}-${ts}`;
-};
-
-exports.streamToString = async (stream) => {
-  return await new Promise((resolve, reject) => {
-    const chunks = [];
-    stream.on("data", (chunk) => chunks.push(chunk));
-    stream.on("error", reject);
-    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
-  });
-};
+exports.getDatePath=function(){const d=new Date();return{Y:d.getFullYear(),M:String(d.getMonth()+1).padStart(2,"0"),D:String(d.getDate()).padStart(2,"0")};};
+exports.formatDate=function(d){const p=n=>String(n).padStart(2,"0");return d.getFullYear()+"-"+p(d.getMonth()+1)+"-"+p(d.getDate())+" "+p(d.getHours())+":"+p(d.getMinutes())+":"+p(d.getSeconds());};
+exports.getApiType=function(url){if(!url)return"";const s=url.split("/").filter(Boolean);return s[s.length-1]||"";};
+const MASK_KEYS=["password","pass","token","secret","otp","auth","authorization","apikey","api_key","session","ssn"];
+exports.maskSensitive=function(v,extra){const keys=[...MASK_KEYS,...(extra||[])].map(k=>String(k).toLowerCase());const isMask=k=>keys.some(m=>String(k).toLowerCase().includes(m));const maskAny=val=>{if(val&&typeof val==="object"){if(Array.isArray(val))return val.map(maskAny);const o={};for(const[k,x]of Object.entries(val))o[k]=isMask(k)?"*****":maskAny(x);return o;}return val;};if(typeof v==="string"){try{return maskAny(JSON.parse(v));}catch(_){return v;}}return maskAny(v);};
+exports.streamToString=async s=>await new Promise((res,rej)=>{const c=[];s.on("data",x=>c.push(x));s.on("error",rej);s.on("end",()=>res(Buffer.concat(c).toString("utf8")));});