@onlineapps/service-wrapper 2.1.5 → 2.1.7

package/package.json

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

package/src/ServiceWrapper.js

@@ -22,7 +22,6 @@ 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)',
@@ -559,17 +558,9 @@ class ServiceWrapper {
     // Logger is now available, use it
     this.logger.info('Monitoring connector initialized', { logsDir });
 
-    // Apply HTTP logging middleware (configurable via wrapper.logging)
-    if (this.app) {
-      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);
-    }
+    // NOTE: HTTP logging middleware is applied directly in service's app.js
+    // using middlewares/httpLogging.js with lazy logger access via lib/logger.js
+    // Configuration is in conn-config/config.json -> wrapper.logging (for reference)
   }
 
   /**

package/src/index.js

@@ -13,15 +13,16 @@
 
 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
 // - ApiCaller -> @onlineapps/conn-orch-api-mapper
 
+// Note: HTTP logging middleware is now in each service's middlewares/httpLogging.js
+// It uses lazy logger access via lib/logger.js (set after wrapper.initialize())
+
 module.exports = ServiceWrapper;
 module.exports.ServiceWrapper = ServiceWrapper;
 module.exports.ConfigLoader = ConfigLoader;
-module.exports.HttpLoggingMiddleware = HttpLoggingMiddleware;
 module.exports.default = ServiceWrapper;
-module.exports.VERSION = '2.1.4';
+module.exports.VERSION = '2.1.6';

package/src/HttpLoggingMiddleware.js

@@ -1,295 +0,0 @@
-'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
-};
-