@onlineapps/service-wrapper 2.1.3 → 2.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "description": "Thin orchestration layer for microservices - delegates all infrastructure concerns to specialized connectors",
   "main": "src/index.js",
   "scripts": {

package/src/HttpLoggingMiddleware.js

@@ -0,0 +1,295 @@
+'use strict';
+
+/**
+ * HTTP Logging Middleware
+ * 
+ * Configurable request/response logging for business services.
+ * Logs to both local files and central monitoring via wrapper.logger.
+ * 
+ * Configuration in conn-config/config.json:
+ * {
+ *   "wrapper": {
+ *     "logging": {
+ *       "enabled": true,           // Master switch
+ *       "level": "info",           // Log level: debug, info, warn, error
+ *       "requests": {
+ *         "enabled": true,         // Log incoming requests
+ *         "bodies": true,          // Include request bodies
+ *         "headers": false         // Include request headers (careful with auth tokens)
+ *       },
+ *       "responses": {
+ *         "enabled": true,         // Log outgoing responses
+ *         "bodies": true           // Include response bodies
+ *       },
+ *       "excludePaths": [          // Paths to exclude from logging
+ *         "/health",
+ *         "/status",
+ *         "/metrics"
+ *       ]
+ *     }
+ *   }
+ * }
+ */
+
+const DEFAULT_CONFIG = {
+  enabled: true,
+  level: 'info',
+  requests: {
+    enabled: true,
+    bodies: true,
+    headers: false
+  },
+  responses: {
+    enabled: true,
+    bodies: true
+  },
+  excludePaths: ['/health', '/status', '/metrics', '/specification']
+};
+
+/**
+ * Merge user config with defaults
+ */
+function mergeConfig(userConfig = {}) {
+  return {
+    enabled: userConfig.enabled ?? DEFAULT_CONFIG.enabled,
+    level: userConfig.level ?? DEFAULT_CONFIG.level,
+    requests: {
+      enabled: userConfig.requests?.enabled ?? DEFAULT_CONFIG.requests.enabled,
+      bodies: userConfig.requests?.bodies ?? DEFAULT_CONFIG.requests.bodies,
+      headers: userConfig.requests?.headers ?? DEFAULT_CONFIG.requests.headers
+    },
+    responses: {
+      enabled: userConfig.responses?.enabled ?? DEFAULT_CONFIG.responses.enabled,
+      bodies: userConfig.responses?.bodies ?? DEFAULT_CONFIG.responses.bodies
+    },
+    excludePaths: userConfig.excludePaths ?? DEFAULT_CONFIG.excludePaths
+  };
+}
+
+/**
+ * Check if path should be excluded from logging
+ */
+function shouldExclude(path, excludePaths) {
+  return excludePaths.some(excluded => {
+    // Exact match or prefix match
+    return path === excluded || path.startsWith(excluded + '/');
+  });
+}
+
+/**
+ * Safely stringify body for logging
+ */
+function safeStringify(body) {
+  if (body === undefined || body === null) {
+    return null;
+  }
+  
+  if (typeof body === 'string') {
+    // Already a string - could be JSON or plain text
+    try {
+      // Try to parse and re-stringify for consistent format
+      return JSON.parse(body);
+    } catch {
+      return body;
+    }
+  }
+  
+  if (Buffer.isBuffer(body)) {
+    return `[Buffer: ${body.length} bytes]`;
+  }
+  
+  // Object - return as is (will be serialized by logger)
+  return body;
+}
+
+/**
+ * Create request logging middleware
+ * @param {Function} getLogger - Function that returns logger instance
+ * @param {Object} config - Logging configuration
+ * @returns {Function} Express middleware
+ */
+function createRequestLogger(getLogger, config) {
+  const cfg = mergeConfig(config);
+  
+  return (req, res, next) => {
+    // Skip if disabled
+    if (!cfg.enabled || !cfg.requests.enabled) {
+      return next();
+    }
+    
+    // Skip excluded paths
+    if (shouldExclude(req.path, cfg.excludePaths)) {
+      return next();
+    }
+    
+    const logger = getLogger();
+    if (!logger) {
+      return next();
+    }
+    
+    // Build log data
+    const logData = {
+      type: 'request',
+      method: req.method,
+      path: req.path,
+      url: req.originalUrl,
+      ip: req.ip || req.connection?.remoteAddress,
+      userAgent: req.get('user-agent')
+    };
+    
+    // Add query params if present
+    if (req.query && Object.keys(req.query).length > 0) {
+      logData.query = req.query;
+    }
+    
+    // Add request body if enabled
+    if (cfg.requests.bodies && req.body && Object.keys(req.body).length > 0) {
+      logData.body = safeStringify(req.body);
+    }
+    
+    // Add headers if enabled
+    if (cfg.requests.headers) {
+      // Filter out sensitive headers
+      const headers = { ...req.headers };
+      delete headers.authorization;
+      delete headers.cookie;
+      logData.headers = headers;
+    }
+    
+    // Store start time for response duration
+    req._loggingStartTime = Date.now();
+    
+    logger.info('HTTP Request', logData);
+    next();
+  };
+}
+
+/**
+ * Create response logging middleware
+ * @param {Function} getLogger - Function that returns logger instance
+ * @param {Object} config - Logging configuration
+ * @returns {Function} Express middleware
+ */
+function createResponseLogger(getLogger, config) {
+  const cfg = mergeConfig(config);
+  
+  return (req, res, next) => {
+    // Skip if disabled
+    if (!cfg.enabled || !cfg.responses.enabled) {
+      return next();
+    }
+    
+    // Skip excluded paths
+    if (shouldExclude(req.path, cfg.excludePaths)) {
+      return next();
+    }
+    
+    const logger = getLogger();
+    if (!logger) {
+      return next();
+    }
+    
+    // Store original methods
+    const originalSend = res.send;
+    const originalJson = res.json;
+    
+    // Flag to prevent double logging
+    let logged = false;
+    
+    const logResponse = (body) => {
+      if (logged) return;
+      logged = true;
+      
+      const duration = req._loggingStartTime 
+        ? Date.now() - req._loggingStartTime 
+        : null;
+      
+      const logData = {
+        type: 'response',
+        method: req.method,
+        path: req.path,
+        statusCode: res.statusCode,
+        statusMessage: res.statusMessage
+      };
+      
+      if (duration !== null) {
+        logData.durationMs = duration;
+      }
+      
+      // Add response body if enabled
+      if (cfg.responses.bodies && body !== undefined) {
+        logData.body = safeStringify(body);
+      }
+      
+      // Choose log level based on status code
+      if (res.statusCode >= 500) {
+        logger.error('HTTP Response', logData);
+      } else if (res.statusCode >= 400) {
+        logger.warn('HTTP Response', logData);
+      } else {
+        logger.info('HTTP Response', logData);
+      }
+    };
+    
+    // Override res.send
+    res.send = function(body) {
+      logResponse(body);
+      return originalSend.call(this, body);
+    };
+    
+    // Override res.json
+    res.json = function(body) {
+      logResponse(body);
+      return originalJson.call(this, body);
+    };
+    
+    next();
+  };
+}
+
+/**
+ * Create combined HTTP logging middleware
+ * @param {Function} getLogger - Function that returns logger instance
+ * @param {Object} config - Logging configuration from wrapper.logging
+ * @returns {Object} Object with requestLogger and responseLogger middlewares
+ */
+function createHttpLogging(getLogger, config = {}) {
+  const cfg = mergeConfig(config);
+  
+  return {
+    config: cfg,
+    requestLogger: createRequestLogger(getLogger, config),
+    responseLogger: createResponseLogger(getLogger, config),
+    
+    /**
+     * Apply both middlewares to Express app
+     * @param {Object} app - Express application
+     */
+    applyTo(app) {
+      if (!cfg.enabled) {
+        console.log('[HttpLogging] Disabled by configuration');
+        return;
+      }
+      
+      if (cfg.requests.enabled) {
+        app.use(this.requestLogger);
+      }
+      
+      if (cfg.responses.enabled) {
+        app.use(this.responseLogger);
+      }
+      
+      console.log(`[HttpLogging] Enabled (requests: ${cfg.requests.enabled}, responses: ${cfg.responses.enabled}, bodies: ${cfg.requests.bodies})`);
+      console.log(`[HttpLogging] Excluded paths: ${cfg.excludePaths.join(', ')}`);
+    }
+  };
+}
+
+module.exports = {
+  createHttpLogging,
+  createRequestLogger,
+  createResponseLogger,
+  mergeConfig,
+  DEFAULT_CONFIG
+};
+

package/src/ServiceWrapper.js

@@ -22,6 +22,7 @@ const CookbookConnector = require('@onlineapps/conn-orch-cookbook');
 const CacheConnector = require('@onlineapps/conn-base-cache');
 const ErrorHandlerConnector = require('@onlineapps/conn-infra-error-handler');
 const { ValidationOrchestrator } = require('@onlineapps/conn-orch-validator');
+const { createHttpLogging } = require('./HttpLoggingMiddleware');
 
 const INFRA_QUEUE_OWNERS = {
   'workflow.init': 'Gateway (api_gateway)',
@@ -558,23 +559,16 @@ class ServiceWrapper {
     // Logger is now available, use it
     this.logger.info('Monitoring connector initialized', { logsDir });
 
-    // Add monitoring middleware to Express app
+    // Apply HTTP logging middleware (configurable via wrapper.logging)
     if (this.app) {
-      this.app.use((req, res, next) => {
-        const start = Date.now();
-
-        res.on('finish', () => {
-          const duration = Date.now() - start;
-          this.monitoring?.info && this.monitoring.info('Request processed', {
-            method: req.method,
-            path: req.path,
-            statusCode: res.statusCode,
-            duration
-          });
-        });
-
-        next();
-      });
+      const loggingConfig = this.config.wrapper?.logging || {};
+      const httpLogging = createHttpLogging(() => this.logger, loggingConfig);
+      
+      // Store for access from outside if needed
+      this.httpLogging = httpLogging;
+      
+      // Apply middlewares to Express app
+      httpLogging.applyTo(this.app);
     }
   }
 

package/src/index.js

@@ -13,6 +13,7 @@
 
 const ServiceWrapper = require('./ServiceWrapper');
 const { ConfigLoader } = require('./ConfigLoader');
+const HttpLoggingMiddleware = require('./HttpLoggingMiddleware');
 
 // Note: WorkflowProcessor and ApiCaller functionality has been moved to connectors:
 // - WorkflowProcessor -> @onlineapps/conn-orch-orchestrator
@@ -21,5 +22,6 @@ const { ConfigLoader } = require('./ConfigLoader');
 module.exports = ServiceWrapper;
 module.exports.ServiceWrapper = ServiceWrapper;
 module.exports.ConfigLoader = ConfigLoader;
+module.exports.HttpLoggingMiddleware = HttpLoggingMiddleware;
 module.exports.default = ServiceWrapper;
-module.exports.VERSION = '2.1.2';
+module.exports.VERSION = '2.1.4';