sasai-common-utils 1.0.51 → 1.0.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sasai-common-utils",
-  "version": "1.0.51",
+  "version": "1.0.53",
   "description": "Reusable utility library for common logging and other shared features.",
   "main": "src/index.js",
   "scripts": {

package/src/features/axios-logger/axiosLogger.js

@@ -6,11 +6,20 @@ const { LOG_LEVELS } = require("../logger/constants");
  * @param {Object} logger - Logger instance.
  */
 const logRequest = (request, logger) => {
-    const { method, url, headers, data, params, query } = request;
-    const api = "REQUEST"
-    const logObject = { method, url, headers, requestBody: data, parameters: query, api };
-    logger.logInfo("Axios Request", logObject);
-    return request;
+  const { method, url, headers, data, params } = request;
+  const api = "REQUEST";
+
+  const logObject = {
+    method,
+    url,
+    headers,
+    requestBody: data,
+    parameters: params,
+    api,
+  };
+
+  logger.logInfo("Axios Request", logObject);
+  return request;
 };
 
 /**
@@ -19,12 +28,24 @@ const logRequest = (request, logger) => {
  * @param {Object} logger - Logger instance.
  */
 const logResponse = (response, logger) => {
-    const { status, config, data } = response;
-    const { method, url, headers, data: requestBody } = config;
-    const api = "RESPONSE"
-    const logObject = { statusCode: status, method, url, responseHeaders:headers, headers, requestBody, responseBody: data, api };
-    logger.logInfo( "Axios Response", logObject);
-    return response;
+  const { status, config, data, headers: responseHeaders } = response;
+  const { method, url, headers, data: requestBody, params } = config || {};
+  const api = "RESPONSE";
+
+  const logObject = {
+    statusCode: status,
+    method,
+    url,
+    headers, // request headers
+    responseHeaders, // actual response headers
+    requestBody,
+    responseBody: data,
+    parameters: params,
+    api,
+  };
+
+  logger.logInfo("Axios Response", logObject);
+  return response;
 };
 
 /**
@@ -33,53 +54,55 @@ const logResponse = (response, logger) => {
  * @param {Object} logger - Logger instance.
  */
 const logError = (error, logger) => {
-    const { response, config } = error;
-    const { method, url } = config || {};
-    const logObject = {
-        method,
-        url,
-        status: response?.status,
-        message: error.message,
-        stack: error.stack,
-    };
-    logger.logError({error}, "Axios Error", logObject);
-    return Promise.reject(error);
+  const { response, config } = error || {};
+  const { method, url, headers, data: requestBody, params } = config || {};
+
+  const logObject = {
+    step: "Axios Error",
+    error,
+    method,
+    url,
+    headers,
+    requestBody,
+    parameters: params,
+    responseBody: response?.data || {},
+    statusCode: response?.status || "",
+    responseHeaders: response?.headers || {},
+    api: "ERROR",
+  };
+
+  logger.logError(logObject);
+  return Promise.reject(error);
 };
 
 /**
  * Attaches logging interceptors to an Axios instance.
  * @param {Object} axiosInstance - Axios instance.
  * @param {Object} logger - Logger instance.
+ * @param {Object} traceContext - Trace context provider.
  */
 const attachAxiosLogger = (axiosInstance, logger, traceContext) => {
-    axiosInstance.interceptors.request.use(
-        (request) =>{
-            const currentTraceContext = traceContext.getCurrentTraceContext();
-            request.headers = {
-                ...request.headers,
-                "x-b3-traceid": currentTraceContext?.trace_id ?? "",
-                "x-b3-spanid": currentTraceContext?.span_id ?? "",
-                "x-b3-parentspanid": currentTraceContext?.parent_span_id ?? ""
-            };
-           return  logRequest(request, logger)
-        } ,
-        (error) => logError(error, logger)
-    );
+  axiosInstance.interceptors.request.use(
+    (request) => {
+      const currentTraceContext =
+        traceContext?.getCurrentTraceContext?.() || {};
+
+      request.headers = {
+        ...request.headers,
+        "x-b3-traceid": currentTraceContext?.trace_id ?? "",
+        "x-b3-spanid": currentTraceContext?.span_id ?? "",
+        "x-b3-parentspanid": currentTraceContext?.parent_span_id ?? "",
+      };
 
-    axiosInstance.interceptors.response.use(
-        (response) => {
-            const currentTraceContext = traceContext.getCurrentTraceContext();
-            response.headers = {
-                ...response.headers,
-                "x-b3-traceid": currentTraceContext?.trace_id ?? "",
-                "x-b3-spanid": currentTraceContext?.span_id ?? "",
-                "x-b3-parentspanid": currentTraceContext?.parent_span_id ?? ""
+      return logRequest(request, logger);
+    },
+    (error) => logError(error, logger),
+  );
 
-            };
-            return logResponse(response, logger);
-        } ,
-        (error) => logError(error, logger)
-    );
+  axiosInstance.interceptors.response.use(
+    (response) => logResponse(response, logger),
+    (error) => logError(error, logger),
+  );
 };
 
 module.exports = { attachAxiosLogger };

package/src/features/logger/index.js

@@ -41,6 +41,11 @@ function safeJsonStringify(value) {
   }
 }
 
+function normalizePayload(value) {
+  if (typeof value === "string") return cleanString(value);
+  return value;
+}
+
 function decodeTokenDetails(headers = {}) {
   try {
     const authHeader = headers?.authorization || headers?.Authorization;
@@ -155,11 +160,17 @@ function emitLog(level, data) {
 
   const { trace, span, parentSpan, message, ...rest } = data;
 
+  const finalMessage =
+    typeof message === "string" && message.trim()
+      ? cleanString(message)
+      : "Application log";
+
   pinoLogger[level]({
     trace_id: trace || undefined,
     span_id: span || undefined,
     parent_span_id: parentSpan || undefined,
-    message: cleanString(message),
+    body: finalMessage,
+    message: finalMessage,
     ...rest,
   });
 }
@@ -181,20 +192,18 @@ function createLogger(config) {
         parentSpan: traceContext.parent_span_id,
         thread: "",
         class: "",
-        body: safeJsonStringify({
-          step: data?.step || "",
-          message,
-          method: data?.method?.toUpperCase() || "",
-          parameters: data?.parameters || "",
-          path: data?.url || "",
-          headers: data?.headers || {},
-          responseHeaders: data?.responseHeaders || {},
-          api: data?.api || "",
-          tokenDetails,
-          responseStatus: data?.statusCode || "",
-          requestBody: data?.requestBody || {},
-          responseBody: data?.responseBody || {},
-        }),
+        message,
+        step: data?.step || "",
+        method: data?.method?.toUpperCase() || "",
+        parameters: normalizePayload(data?.parameters || ""),
+        path: data?.url || "",
+        headers: normalizePayload(data?.headers || {}),
+        responseHeaders: normalizePayload(data?.responseHeaders || {}),
+        api: data?.api || "",
+        tokenDetails,
+        responseStatus: data?.statusCode || "",
+        requestBody: normalizePayload(data?.requestBody || {}),
+        responseBody: normalizePayload(data?.responseBody || {}),
       };
 
       const redactedData = redactInformation(logData, {
@@ -208,10 +217,7 @@ function createLogger(config) {
       const traceContext = getTraceContext();
       const errorResponse = data?.error?.response;
       const tokenDetails = decodeTokenDetails(
-        data?.headers ||
-          errorResponse?.config?.headers ||
-          req?.headers ||
-          {}
+        data?.headers || errorResponse?.config?.headers || req?.headers || {},
       );
 
       const logData = {
@@ -220,24 +226,24 @@ function createLogger(config) {
         parentSpan: traceContext.parent_span_id,
         thread: "",
         class: "",
-        body: safeJsonStringify({
-          step: data?.step || "",
-          message: data?.error?.message || "",
-          method: errorResponse?.config?.method?.toUpperCase() || "",
-          parameters: data?.parameters || "",
-          path: errorResponse?.config?.url || req?.originalUrl || "",
-          responseStatus:
-            errorResponse?.status || HTTP_STATUS_CODES.BAD_REQUEST,
-          headers: errorResponse?.config?.headers || req?.headers || {},
-          requestBody:
-            errorResponse?.config?.data ||
+        message: data?.error?.message || "",
+        step: data?.step || "",
+        method: errorResponse?.config?.method?.toUpperCase() || "",
+        parameters: normalizePayload(data?.parameters || ""),
+        path: errorResponse?.config?.url || req?.originalUrl || "",
+        responseStatus: errorResponse?.status || HTTP_STATUS_CODES.BAD_REQUEST,
+        headers: normalizePayload(
+          errorResponse?.config?.headers || req?.headers || {},
+        ),
+        requestBody: normalizePayload(
+          errorResponse?.config?.data ||
             errorResponse?.config?.body ||
             req?.body ||
             {},
-          responseBody: errorResponse?.data || {},
-          stack: data?.error?.stack || "",
-          tokenDetails,
-        }),
+        ),
+        responseBody: normalizePayload(errorResponse?.data || {}),
+        stack: data?.error?.stack || "",
+        tokenDetails,
       };
 
       const redactedData = redactInformation(logData, {
@@ -250,14 +256,20 @@ function createLogger(config) {
     logDebug: (message, data = {}) => {
       const traceContext = getTraceContext();
 
-      emitLog("debug", {
+      const logData = {
         trace: traceContext.trace_id,
         span: traceContext.span_id,
         parentSpan: traceContext.parent_span_id,
-        body:
+        message:
           typeof message === "string" ? message : safeJsonStringify(message),
         ...data,
+      };
+
+      const redactedData = redactInformation(logData, {
+        sensitiveKeys: globalConfig?.SENSITIVE_KEYS,
       });
+
+      emitLog("debug", redactedData);
     },
 
     flush: async () => {
@@ -278,4 +290,4 @@ module.exports = {
   createLogger,
   setContextProvider,
   logger: loggerInstance,
-};
+};

package/src/features/logger/redact.js

@@ -1,61 +1,102 @@
 /** This file will be used to redact the sensitive informations to be logged */
 
-const traverse =  require("traverse");
-const { klona }  = require("klona/full");
-
-const defautSensitiveKeys = [/cookie/i, /passw(or)?d/i, /^pw$/, /^pass$/i, /secret/i, /api[-._]?key/i, /token/i, /authorization/i, /otp/i,  /^pin$/i ];
-let SENSITIVE_KEYS;
-function isSensitiveKey(keyStr) {
-    if (!keyStr) return false;
-    // Exception for "tokenDetails"
-    if (/^tokenDetails$/i.test(keyStr)) {
-        return false; // Do not redact this key
+const traverse = require("traverse");
+const { klona } = require("klona/full");
+
+const defaultSensitiveKeys = [
+  /cookie/i,
+  /passw(or)?d/i,
+  /^pw$/i,
+  /^pass$/i,
+  /secret/i,
+  /api[-._]?key/i,
+  /token/i,
+  /authorization/i,
+  /otp/i,
+  /^pin$/i,
+];
+
+function buildSensitiveRegexList(sensitiveKeys) {
+  try {
+    if (!sensitiveKeys) return defaultSensitiveKeys;
+
+    const parsed =
+      typeof sensitiveKeys === "string" ? JSON.parse(sensitiveKeys) : sensitiveKeys;
+
+    if (!Array.isArray(parsed) || !parsed.length) {
+      return defaultSensitiveKeys;
     }
-    return SENSITIVE_KEYS.some(regex => regex.test(keyStr));
-}
 
-function redactNestedFields(obj) {
-    Object.entries(obj).forEach(([key, value]) => {
-        if (isSensitiveKey(key)) {
-            obj[key] = "[REDACTED]";
-        } else if (typeof value === "object" && value !== null) {
-            redactNestedFields(value); // Recursively process nested objects
-        }
+    return parsed.map(key => {
+      if (key instanceof RegExp) return key;
+
+      const parts =
+        typeof key === "string" && key.match(/^\/(.*?)\/([gimsuy]*)$/);
+
+      return parts ? new RegExp(parts[1], parts[2]) : new RegExp(key, "i");
     });
+  } catch (error) {
+    return defaultSensitiveKeys;
+  }
 }
 
-function redactObject(obj) {
-	traverse(obj).forEach(function redactor() {
-		if (isSensitiveKey(this.key )) {
-			this.update("[REDACTED]");
-		}
-		if (this.key === "message" && typeof this.node === "string") {
-			let parsedMessage
-			try {
-				parsedMessage = JSON.parse(this?.node);
-				redactNestedFields(parsedMessage);
-			} catch (error) {
-				parsedMessage = {}; 
-			}
-
-                this.update(JSON.stringify(parsedMessage)); // Update with the redacted string
-        }
-	});
+function isSensitiveKey(keyStr, sensitiveRegexList) {
+  if (!keyStr) return false;
+
+  if (/^tokenDetails$/i.test(keyStr)) {
+    return false;
+  }
+
+  return sensitiveRegexList.some(regex => regex.test(String(keyStr)));
 }
 
-const redactInformation=(obj, {sensitiveKeys})=> {
-	const regexArray = JSON.parse(sensitiveKeys).map((key) => {
-		const parts = key.match(/^\/(.*?)\/([gimsuy]*)$/);
-		return parts ? new RegExp(parts[1], parts[2]) : new RegExp(key); // Handle conversion
-	});
-SENSITIVE_KEYS = regexArray || defautSensitiveKeys;
-	const copy = klona(obj); // Making a deep copy to prevent side effects
-	redactObject(copy);
+function redactNestedFields(obj, sensitiveRegexList) {
+  if (!obj || typeof obj !== "object") return;
 
-	const splat = copy[Symbol.for("splat")];
-	redactObject(splat); // Specifically redact splat Symbol
+  Object.entries(obj).forEach(([key, value]) => {
+    if (isSensitiveKey(key, sensitiveRegexList)) {
+      obj[key] = "[REDACTED]";
+    } else if (value && typeof value === "object") {
+      redactNestedFields(value, sensitiveRegexList);
+    }
+  });
+}
+
+function redactObject(obj, sensitiveRegexList) {
+  if (!obj || typeof obj !== "object") return;
 
-	return copy;
+  traverse(obj).forEach(function redactor() {
+    if (isSensitiveKey(this.key, sensitiveRegexList)) {
+      this.update("[REDACTED]");
+      return;
+    }
+
+    if (this.key === "message" && typeof this.node === "string") {
+      try {
+        const parsedMessage = JSON.parse(this.node);
+        if (parsedMessage && typeof parsedMessage === "object") {
+          redactNestedFields(parsedMessage, sensitiveRegexList);
+          this.update(JSON.stringify(parsedMessage));
+        }
+      } catch (error) {
+        // keep original plain-text message unchanged
+      }
+    }
+  });
 }
 
-module.exports = { redactInformation }
+const redactInformation = (obj, { sensitiveKeys } = {}) => {
+  const sensitiveRegexList = buildSensitiveRegexList(sensitiveKeys);
+  const copy = klona(obj);
+
+  redactObject(copy, sensitiveRegexList);
+
+  const splat = copy?.[Symbol.for("splat")];
+  if (splat) {
+    redactObject(splat, sensitiveRegexList);
+  }
+
+  return copy;
+};
+
+module.exports = { redactInformation };