@nm-logger/logger 1.2.5 → 1.2.7

package/README.md

@@ -1,48 +1,317 @@
-# @nm-logger/logger v1.2.3
+# @nm-logger/logger
 
-Minimal JSON logger for Express:
+Minimal JSON logger for Express + Axios with optional S3 sync.
 
-- Logs handled requests as **success**
+## Features
+
+- Logs handled Express requests as **success**
 - Logs Express errors as **error**
 - Logs Axios calls as **external**
+- Optional **database error** logs as `db_error`
 - Local daily files under configurable `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, append (read+merge+put)
+  - `YYYY/MM/DD/daily_logs_db_error.json`
+- S3: one JSON file per day per category (append by 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/logs`)
+- `employee_id` taken from `req.user.employee_id || req.user.emp_code || req.user.id` (used internally only, **not** written to JSON)
+- Each log entry includes:
+  - `url`, `method`, `type` (internal/external/db_error)
+  - `status_code`
+  - `user_agent`
+  - `project_version` (from Logger options)
+  - `error`
+  - optional `response` (for external errors)
+  - `count` (when consecutive identical entries are compacted)
+- External API logging:
+  - Logs **response body only for error-like calls** (4xx/5xx or when a custom `externalErrorDetector` marks it as error)
+  - Long responses are truncated with `maxResponseLength`
+
+## Install
 
+```bash
+npm install @nm-logger/logger
+```
 
-Basic usage:
+## Basic usage (Express + Axios)
 
 ```js
-const Logger = require("@nm-logger/logger");
+const express = require("express");
 const axios = require("axios");
+const Logger = require("@nm-logger/logger");
+
+const app = express();
+
+const nm_logger = new Logger(
+  {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    region: "us-east-1",
+    bucket: "project",
+  },
+  {
+    baseDir: "/var/log/nm-logger",
+    maskFields: ["aadhaar", "pan"],
+
+    // Optional metadata for logs
+    projectVersion: "Project-1.0.0",
+
+    // Background S3 uploader (set to false if you prefer cron; see below)
+    enableDailyWatcher: true,
+
+    // Interval for background S3 uploads when enableDailyWatcher = true
+    uploadIntervalMs: 60 * 1000, // 1 minute
+
+    // How many characters of external response to keep (after masking)
+    maxResponseLength: 4000,
+
+    // If true (default), include external response body only for error-like calls
+    logExternalResponseOnError: true,
+
+    // Control logging of successful external calls
+    // - true  (default): log all external calls
+    // - false: log only error-like calls (4xx/5xx or externalErrorDetector = true)
+    logExternalSuccess: true,
+
+    // Optional semantic error detector for 2xx/3xx external responses
+    // Example below in "External error-only logging"
+    externalErrorDetector: null,
+  }
+);
+
+// Express middlewares
+app.use(express.json());
+app.use(nm_logger.requestLoggerMiddleware());
+app.use("/api", require("./routes"));
+app.use(nm_logger.expressMiddleware());
+
+// Attach Axios interceptor
+nm_logger.attachAxiosLogger(axios);
 
+app.listen(3000, () => {
+  console.log("Server listening on 3000");
+});
+```
+
+### Folder permissions
+
+Make sure the base directory exists and is writable by your Node process:
+
+```bash
+mkdir -p /var/log/nm-logger
+chmod -R 777 /var/log/nm-logger
+```
+
+## External error-only logging (recommended for high load)
+
+If your external API returns HTTP 200 but the **body** contains error info, you can:
+
+- Skip logging successful calls completely
+- Still log error-like responses with full (masked + truncated) body
+
+Example:
+
+```js
 const nm_logger = new Logger(
   {
     accessKeyId: process.env.AWS_ACCESS_KEY_ID,
     secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
     region: "us-east-1",
-    bucket: "bucket-name"
+    bucket: "project",
   },
   {
-    baseDir: "/home/logs",
-    uploadIntervalMs: 60_000,
-    maskFields: ["aadhaar", "pan"]
+    baseDir: "/var/log/nm-logger",
+    maskFields: ["aadhaar", "pan"],
+
+    enableDailyWatcher: false, // use cron for S3 (see next section)
+    logExternalSuccess: false, // do NOT log success responses
+
+    externalErrorDetector: ({ response }) => {
+      try {
+        // Adjust this according to your external API response format
+        if (response && response.success === false) return true;
+        if (response && typeof response.status === "string" &&
+            response.status.toLowerCase() === "error") return true;
+        if (response && (response.error || response.error_code)) return true;
+      } catch (e) {
+        return false;
+      }
+      return false;
+    },
   }
 );
+```
+
+With this config:
+
+- Only external calls that look like **errors** are logged (4xx/5xx or `externalErrorDetector` = true).
+- For these, the masked + truncated `response` body is stored in JSON.
+
+## S3 upload modes
 
-Folder permission
+There are two ways to sync daily logs to S3.
 
-- mkdir -p /home/logs
-- chmod -R 777 /home/logs
+### Mode 1: Background timer (default)
+
+If `enableDailyWatcher: true` (or omitted), the logger will:
+
+- Start an internal `setInterval` in the same Node process
+- Every `uploadIntervalMs`:
+  - Read local daily log JSONs
+  - Merge them with S3 files
+  - Upload merged logs back to S3
+  - Clean up previous day's local folder
+
+This is simple but adds some extra work inside your API process.
+
+### Mode 2: Cron-based upload (recommended for production)
+
+To keep your API process as light as possible, you can:
+
+1. **Disable the internal watcher in your API**
+2. **Use a separate cron script** to upload logs to S3
+
+#### 1. API server: disable watcher
+
+```js
+const nm_logger = new Logger(
+  {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    region: "us-east-1",
+    bucket: "project",
+  },
+  {
+    baseDir: "/var/log/nm-logger",
+    maskFields: ["aadhaar", "pan"],
+    enableDailyWatcher: false,  // 🔴 no setInterval in API process
+  }
+);
 
 app.use(nm_logger.requestLoggerMiddleware());
 app.use("/api", routes);
 app.use(nm_logger.expressMiddleware());
 nm_logger.attachAxiosLogger(axios);
+```
+
+This way, the API only writes local JSON files.
+
+### Mode 2b: node-cron inside Node (no system crontab)
+
+If you are already using [`node-cron`](https://www.npmjs.com/package/node-cron) in your Node project, you can avoid Linux `crontab` entirely and schedule uploads from your app code.
+
+1. Disable the internal watcher in your API (same as before):
+
+```js
+const nm_logger = new Logger(
+  {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    region: "us-east-1",
+    bucket: "project",
+  },
+  {
+    baseDir: "/var/log/nm-logger",
+    maskFields: ["aadhaar", "pan"],
+    enableDailyWatcher: false,  // no setInterval
+  }
+);
+```
+
+2. Use `node-cron` in your Node app to trigger uploads:
+
+```js
+const cron = require("node-cron");
+const Logger = require("@nm-logger/logger");
+
+const nm_logger = new Logger(
+  {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    region: "us-east-1",
+    bucket: "project",
+  },
+  {
+    baseDir: "/var/log/nm-logger",
+    maskFields: ["aadhaar", "pan"],
+    enableDailyWatcher: false,
+  }
+);
+
+// Every 5 minutes
+cron.schedule("*/5 * * * *", async () => {
+  try {
+    await nm_logger.uploadDailyLogsOnce();
+    console.log("[nm-logger] ✅ Daily logs uploaded to S3 (node-cron)");
+  } catch (err) {
+    console.error("[nm-logger] ❌ Upload failed (node-cron):", err);
+  }
+});
+```
+
+This way you:
+- Do **not** depend on OS-level `crontab`.
+- Still avoid `setInterval`-based uploads inside the main request flow.
+- Keep all scheduling logic inside Node where you are already comfortable.
+
+#### 3. System Crontab entry (optional, Linux)
+
+If you prefer OS-level cron instead of `node-cron`, you can still use a separate script as before.
+
+Create a separate script (for example in your backend root):
+
+```js
+// upload-logs.js
+require("dotenv").config();
+const Logger = require("@nm-logger/logger");
+
+async function main() {
+  const logger = new Logger(
+    {
+      accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+      region: "us-east-1",
+      bucket: "project",
+    },
+    {
+      baseDir: "/var/log/nm-logger",
+      maskFields: ["aadhaar", "pan"],
+      enableDailyWatcher: false, // no internal timers here either
+    }
+  );
+
+  try {
+    await logger.uploadDailyLogsOnce();
+    console.log("[nm-logger] ✅ Daily logs uploaded to S3");
+  } catch (err) {
+    console.error("[nm-logger] ❌ Failed to upload daily logs:", err);
+    process.exitCode = 1;
+  }
+}
+
+main();
+```
+
+On your server (Linux):
+
+```bash
+crontab -e
+```
+
+Add a line like:
+
+```cron
+*/5 * * * * /usr/bin/node /path/to/upload-logs.js >> /var/log/nm-logger-cron.log 2>&1
+```
+
+- This will **not** be created automatically by the package.
+- You must add it manually using `crontab -e`.
+- Make sure the `node` path (`/usr/bin/node`) and script path (`/path/to/upload-logs.js`) are correct for your server.
+
+## Notes
 
-```
+- The logger does **not** create or manage cron jobs automatically; you must configure `node-cron` or `crontab` yourself if you choose cron mode.
+- For lower CPU and disk usage on busy servers:
+  - Prefer `logExternalSuccess: false` + `externalErrorDetector` to log only problematic external calls.
+  - Use cron-based upload (Mode 2 / Mode 2b) so S3 sync runs in a separate short-lived context.

package/package.json

@@ -1 +1,12 @@
-{"name":"@nm-logger/logger","version":"1.2.5","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.7",
+  "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/DailyWatcher.js

@@ -1,2 +1,85 @@
-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(_){ }this.currentDate={Y,M,D};}start(){setInterval(()=>this.tick().catch(()=>{}),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 localTxt=await fs.readFile(file,"utf8");let local={logs:[]};if(localTxt.trim())local=JSON.parse(localTxt);let existing={logs:[]};const s3Txt=await this.s3.getObject(key).catch(()=>null);if(s3Txt&&s3Txt.trim())existing=JSON.parse(s3Txt);const merged={logs:[...existing.logs,...local.logs]};await this.s3.putObject(key,JSON.stringify(merged,null,2));}catch(_){}});}}}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",
+  db_error: "daily_logs_db_error.json",
+};
+
+class DailyWatcher {
+  constructor(baseDir, q, s3, opt = {}) {
+    this.baseDir = baseDir;
+    this.q = q;
+    this.s3 = s3;
+    this.uploadIntervalMs = opt.uploadIntervalMs || 60_000;
+    this.currentDate = getDatePath();
+    this.disableTimer = !!opt.disableTimer;
+
+    if (!this.disableTimer) {
+      this.start();
+    }
+  }
+
+  async cleanup() {
+    const { Y, M, D } = getDatePath();
+    const p = this.currentDate;
+
+    if (p && (p.Y !== Y || p.M !== M || p.D !== D)) {
+      const dir = path.join(this.baseDir, `${p.Y}/${p.M}/${p.D}`);
+      try {
+        if (await fs.pathExists(dir)) {
+          await fs.remove(dir);
+        }
+      } catch (_) {}
+      this.currentDate = { Y, M, D };
+    }
+  }
+
+  start() {
+    setInterval(() => {
+      this.tick().catch(() => {});
+    }, this.uploadIntervalMs);
+  }
+
+  async tick() {
+    await this.cleanup();
+
+    const { Y, M, D } = getDatePath();
+
+    for (const [cat, fileName] of Object.entries(MAP)) {
+      const file = path.join(this.baseDir, `${Y}/${M}/${D}`, fileName);
+      const key = `${Y}/${M}/${D}/${fileName}`;
+
+      if (!(await fs.pathExists(file))) continue;
+
+      this.q.add(async () => {
+        try {
+          const localTxt = await fs.readFile(file, "utf8");
+          let local = { logs: [] };
+          if (localTxt && localTxt.trim()) {
+            local = JSON.parse(localTxt);
+          }
+
+          let existing = { logs: [] };
+          try {
+            const s3Txt = await this.s3.getObject(key);
+            if (s3Txt && s3Txt.trim()) {
+              existing = JSON.parse(s3Txt);
+            }
+          } catch (_) {}
+
+          const merged = {
+            logs: [...(existing.logs || []), ...(local.logs || [])],
+          };
+
+          await this.s3.putObject(key, JSON.stringify(merged, null, 2));
+        } catch (_) {}
+      });
+    }
+  }
+}
+
+module.exports = DailyWatcher;

package/src/LogWriter.js

@@ -6,6 +6,7 @@ const MAP = {
   success: "daily_logs_success.json",
   error: "daily_logs_error.json",
   external: "daily_logs_external.json",
+  db_error: "daily_logs_db_error.json",
 };
 
 class LogWriter {
@@ -37,17 +38,44 @@ class LogWriter {
       } catch (_) {}
     }
 
-    wrapper.logs.push({
+    const entry = {
       url: log.url || "",
       body: log.body || "",
       params: log.params || "",
-      response: log.response || "", // 👈 NEW: store external response if present
+      response: log.response || "",
       type: log.type || "",
       method: log.method || "",
       error: log.error || "",
-      employee_id: log.employee_id || "",
+      status_code: log.status_code || "",
+      user_agent: log.user_agent || "",
+      project_version: log.project_version || "",
       date: log.date || formatDate(new Date()),
-    });
+    };
+
+    const logs = wrapper.logs;
+
+    if (logs.length > 0) {
+      const last = logs[logs.length - 1];
+
+      if (
+        last.url === entry.url &&
+        last.method === entry.method &&
+        last.type === entry.type &&
+        String(last.status_code || "") === String(entry.status_code || "") &&
+        String(last.user_agent || "") === String(entry.user_agent || "") &&
+        String(last.project_version || "") === String(entry.project_version || "")
+      ) {
+        // Same URL/method/type/status/user_agent/version → compact into one entry
+        last.count = (last.count || 1) + 1;
+        last.date = entry.date;
+      } else {
+        entry.count = entry.count || 1;
+        logs.push(entry);
+      }
+    } else {
+      entry.count = entry.count || 1;
+      logs.push(entry);
+    }
 
     await fs.writeFile(filePath, JSON.stringify(wrapper, null, 2), "utf8");
     return filePath;

package/src/Logger.js

@@ -40,9 +40,48 @@ class Logger {
       String(x).toLowerCase()
     );
 
-    new DailyWatcher(this.baseDir, this.queue, this.s3, {
-      uploadIntervalMs: opt.uploadIntervalMs || 60_000,
-    });
+    // Optional: application/version metadata
+    this.projectVersion = opt.projectVersion || opt.version || "";
+
+    // Limit size of stored external responses to avoid huge log files
+    this.maxResponseLength =
+      typeof opt.maxResponseLength === "number" ? opt.maxResponseLength : 4000;
+
+    // Only include external API responses for errors by default
+    this.logExternalResponseOnError =
+      opt.logExternalResponseOnError !== false; // default: true
+
+    // Control logging of successful external calls
+    this.logExternalSuccess =
+      opt.logExternalSuccess !== false; // default: true (for backward compatibility)
+
+    // Optional semantic error detector for 2xx/3xx responses
+    this.externalErrorDetector =
+      typeof opt.externalErrorDetector === "function"
+        ? opt.externalErrorDetector
+        : null;
+
+    // Control background S3 uploader (DailyWatcher)
+    this.enableDailyWatcher = opt.enableDailyWatcher !== false;
+
+    if (this.enableDailyWatcher) {
+      this.dailyWatcher = new DailyWatcher(this.baseDir, this.queue, this.s3, {
+        uploadIntervalMs: opt.uploadIntervalMs || 60_000,
+        disableTimer: false,
+      });
+    }
+  }
+
+  async uploadDailyLogsOnce() {
+    if (!this._manualDailyWatcher) {
+      this._manualDailyWatcher = new DailyWatcher(
+        this.baseDir,
+        this.queue,
+        this.s3,
+        { disableTimer: true }
+      );
+    }
+    await this._manualDailyWatcher.tick();
   }
 
   // Mask helper
@@ -51,7 +90,7 @@ class Logger {
   }
 
   // Build base log object for success/error logs
-  buildBaseLog(req, employee_id = "") {
+  buildBaseLog(req, employee_id = "", statusCode) {
     const url = req && req.originalUrl ? req.originalUrl : "";
     const body = (req && req.body) || {};
     const params = {
@@ -62,6 +101,11 @@ class Logger {
     const maskedBody = this.mask(body);
     const maskedParams = this.mask(params);
     const method = (req && req.method ? req.method : "").toUpperCase();
+    const userAgent =
+      (req &&
+        req.headers &&
+        (req.headers["user-agent"] || req.headers["User-Agent"])) ||
+      "";
 
     const emp =
       employee_id ||
@@ -79,12 +123,16 @@ class Logger {
       method,
       error: "",
       employee_id: emp,
+      status_code:
+        typeof statusCode === "number" ? statusCode : statusCode || "",
+      user_agent: userAgent,
+      project_version: this.projectVersion || "",
     };
   }
 
   // ---- Error logging (Express errors) ----
-  async logError(err, req, employee_id = "") {
-    const base = this.buildBaseLog(req || {}, employee_id);
+  async logError(err, req, employee_id = "", statusCode) {
+    const base = this.buildBaseLog(req || {}, employee_id, statusCode);
 
     const log = {
       ...base,
@@ -95,8 +143,8 @@ class Logger {
   }
 
   // ---- Success logging (normal requests) ----
-  async logRequest(req, employee_id = "") {
-    const log = this.buildBaseLog(req, employee_id);
+  async logRequest(req, employee_id = "", statusCode) {
+    const log = this.buildBaseLog(req, employee_id, statusCode);
     await this.logWriter.writeLog(log, "success");
   }
 
@@ -107,22 +155,70 @@ class Logger {
     data,
     params,
     error,
-    employeeId,
-    response, // 👈 NEW: store external API response
+    response,
+    statusCode,
+    userAgent,
   }) {
     const maskedBody = this.mask(data || {});
     const maskedParams = this.mask(params || {});
-    const maskedResponse = this.mask(response || {});
+
+    const codeStr = statusCode ? String(statusCode) : "";
+    const isErrorStatus =
+      codeStr.startsWith("4") || codeStr.startsWith("5");
+
+    let semanticError = false;
+    if (this.externalErrorDetector) {
+      try {
+        semanticError = !!this.externalErrorDetector({
+          url,
+          method,
+          statusCode,
+          response,
+          error,
+        });
+      } catch (_) {
+        semanticError = false;
+      }
+    }
+
+    const hasErrorFlag = !!(error || isErrorStatus || semanticError);
+
+    // If logExternalSuccess is false, skip non-error calls completely
+    if (!this.logExternalSuccess && !hasErrorFlag) {
+      return;
+    }
+
+    let respStr = "";
+    const includeResponse =
+      this.logExternalResponseOnError && hasErrorFlag;
+
+    if (includeResponse && typeof response !== "undefined") {
+      try {
+        const maskedResponse = this.mask(response || {});
+        respStr = JSON.stringify(maskedResponse || {});
+      } catch (_) {
+        respStr = "";
+      }
+
+      if (this.maxResponseLength && respStr.length > this.maxResponseLength) {
+        respStr =
+          respStr.slice(0, this.maxResponseLength) +
+          `... [truncated ${respStr.length - this.maxResponseLength} chars]`;
+      }
+    }
 
     const log = {
       url: url || "",
       body: JSON.stringify(maskedBody || {}),
       params: JSON.stringify(maskedParams || {}),
-      response: JSON.stringify(maskedResponse || {}), // 👈 NEW FIELD
+      response: respStr,
       type: "external_api",
       method: (method || "").toUpperCase(),
       error: error || "",
-      employee_id: employeeId || "",
+      status_code:
+        typeof statusCode === "number" ? statusCode : statusCode || "",
+      user_agent: userAgent || "",
+      project_version: this.projectVersion || "",
     };
 
     await this.logWriter.writeLog(log, "external");
@@ -132,7 +228,8 @@ class Logger {
   expressMiddleware() {
     return (err, req, res, next) => {
       try {
-        this.logError(err, req).catch(() => {});
+        const statusCode = res && res.statusCode;
+        this.logError(err, req, "", statusCode).catch(() => {});
       } catch (_) {}
       next(err);
     };
@@ -144,7 +241,12 @@ class Logger {
       try {
         if (!req.__nm_logger_logged) {
           req.__nm_logger_logged = true;
-          this.logRequest(req).catch(() => {});
+          res.on("finish", () => {
+            try {
+              const statusCode = res && res.statusCode;
+              this.logRequest(req, "", statusCode).catch(() => {});
+            } catch (_) {}
+          });
         }
       } catch (_) {}
       next();
@@ -160,14 +262,20 @@ class Logger {
       (response) => {
         try {
           const cfg = response.config || {};
+          const statusCode = response && response.status;
+          const headers = (cfg && cfg.headers) || {};
+          const userAgent =
+            headers["User-Agent"] || headers["user-agent"] || "";
+
           this.logExternalApi({
             url: cfg.url,
             method: cfg.method,
             data: cfg.data,
             params: cfg.params,
-            response: response.data, // 👈 log external API response body
+            response: response.data,
             error: null,
-            employeeId: cfg.employee_id,
+            statusCode,
+            userAgent,
           }).catch(() => {});
         } catch (_) {}
 
@@ -179,15 +287,20 @@ class Logger {
         try {
           const cfg = (error && error.config) || {};
           const res = error && error.response;
+          const statusCode = res && res.status;
+          const headers = (cfg && cfg.headers) || {};
+          const userAgent =
+            headers["User-Agent"] || headers["user-agent"] || "";
 
           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
+            response: res && res.data,
             error: error && error.message,
-            employeeId: cfg && cfg.employee_id,
+            statusCode,
+            userAgent,
           }).catch(() => {});
         } catch (_) {}