@onlineapps/infrastructure-tools 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/infrastructure-tools",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Infrastructure orchestration utilities for OA Drive infrastructure services (health tracking, queue initialization, service discovery)",
   "main": "src/index.js",
   "scripts": {
@@ -28,4 +28,3 @@
     "access": "public"
   }
 }
-

package/src/health/healthPublisher.js

@@ -12,6 +12,8 @@
  * - Custom publish function
  */
 
+const { createLogger } = require('../utils/logger');
+
 /**
  * Create infrastructure health publisher
  * @param {Object} options - Configuration options
@@ -32,9 +34,12 @@ function createHealthPublisher(options) {
     publishFunction,
     getHealthData,
     config = {},
-    logger = console
+    logger: customLogger
   } = options;
 
+  // Use shared logger utility for consistent logging
+  const logger = createLogger(customLogger);
+
   if (!serviceName) {
     throw new Error('serviceName is required');
   }
@@ -71,11 +76,19 @@ function createHealthPublisher(options) {
         components: getHealthData()
       };
       
+      logger.info(`[InfrastructureHealth:${serviceName}] Publishing health check...`, {
+        queue: queueName,
+        serviceName,
+        status: healthData.status,
+        timestamp: healthData.timestamp
+      });
+      
       await publishFunction(queueName, healthData);
       
-      logger.debug(`[InfrastructureHealth:${serviceName}] Published health check`, {
+      logger.info(`[InfrastructureHealth:${serviceName}] ✓ Published health check`, {
         queue: queueName,
-        status: healthData.status
+        status: healthData.status,
+        timestamp: healthData.timestamp
       });
     } catch (error) {
       logger.error(`[InfrastructureHealth:${serviceName}] Failed to publish health check`, {
@@ -151,12 +164,44 @@ function createHealthPublisher(options) {
  * @param {Object} logger - Logger instance
  * @returns {Object} Health publisher instance
  */
-function createBaseClientAdapter(baseClient, serviceName, getHealthData, config, logger) {
+function createBaseClientAdapter(baseClient, serviceName, getHealthData, config, customLogger) {
+  // Use shared logger utility for consistent logging
+  const logger = createLogger(customLogger);
   const publishFunction = async (queueName, data) => {
+    logger.info(`[InfrastructureHealth:${serviceName}] [PUBLISH] Starting publish to queue '${queueName}'...`, {
+      queueName,
+      serviceName,
+      status: data.status,
+      timestamp: data.timestamp
+    });
+    
     if (!baseClient || typeof baseClient.publish !== 'function') {
-      throw new Error('BaseClient instance must have publish() method');
+      const error = new Error('BaseClient instance must have publish() method');
+      logger.error(`[InfrastructureHealth:${serviceName}] [PUBLISH] ✗ BaseClient invalid`, {
+        queueName,
+        error: error.message,
+        hasBaseClient: !!baseClient,
+        hasPublish: baseClient && typeof baseClient.publish === 'function'
+      });
+      throw error;
+    }
+    
+    try {
+      await baseClient.publish(queueName, data);
+      logger.info(`[InfrastructureHealth:${serviceName}] [PUBLISH] ✓ Message sent to queue '${queueName}'`, {
+        queueName,
+        serviceName,
+        status: data.status
+      });
+    } catch (error) {
+      logger.error(`[InfrastructureHealth:${serviceName}] [PUBLISH] ✗ Failed to publish health check`, {
+        queueName,
+        error: error.message,
+        stack: error.stack,
+        code: error.code
+      });
+      throw error;
     }
-    await baseClient.publish(queueName, data);
   };
 
   return createHealthPublisher({
@@ -178,18 +223,105 @@ function createBaseClientAdapter(baseClient, serviceName, getHealthData, config,
  * @param {Object} logger - Logger instance
  * @returns {Object} Health publisher instance
  */
-function createAmqplibAdapter(connection, channel, serviceName, getHealthData, config, logger) {
+function createAmqplibAdapter(connection, channel, serviceName, getHealthData, config, customLogger) {
+  // Use shared logger utility for consistent logging
+  const logger = createLogger(customLogger);
+  
+  // Create a dedicated channel for health checks to avoid conflicts with consumer channels
+  let healthCheckChannel = null;
+  
   const publishFunction = async (queueName, data) => {
-    if (!channel || channel.closed) {
-      throw new Error('AMQP channel is not available or closed');
-    }
-    // Ensure queue exists (it should be created by Registry, but assert just in case)
-    await channel.assertQueue(queueName, { durable: true });
-    await channel.sendToQueue(
+    logger.info(`[InfrastructureHealth:${serviceName}] [PUBLISH] Starting publish to queue '${queueName}'...`, {
       queueName,
-      Buffer.from(JSON.stringify(data)),
-      { persistent: true }
-    );
+      serviceName,
+      status: data.status,
+      timestamp: data.timestamp
+    });
+    
+    // Check connection first
+    if (!connection || connection.closed) {
+      const error = new Error('AMQP connection is not available or closed');
+      logger.error(`[InfrastructureHealth:${serviceName}] [PUBLISH] ✗ Connection not available`, {
+        queueName,
+        error: error.message
+      });
+      throw error;
+    }
+    
+    // Always use dedicated channel for health checks to avoid conflicts with consumer channels
+    // Check if we need to create or recreate the channel
+    if (!healthCheckChannel || healthCheckChannel.closed) {
+      if (healthCheckChannel && healthCheckChannel.closed) {
+        logger.warn(`[InfrastructureHealth:${serviceName}] [PUBLISH] Health check channel closed, recreating...`);
+      }
+      
+      try {
+        healthCheckChannel = await connection.createChannel();
+        logger.info(`[InfrastructureHealth:${serviceName}] [PUBLISH] Created dedicated health check channel`);
+      } catch (createErr) {
+        logger.error(`[InfrastructureHealth:${serviceName}] [PUBLISH] ✗ Failed to create health check channel`, {
+          error: createErr.message
+        });
+        throw createErr;
+      }
+    }
+    
+    const activeChannel = healthCheckChannel;
+    
+    try {
+      // Queue should already exist (created by Registry), so we don't assert it
+      // This avoids 406 PRECONDITION-FAILED errors if queue exists with different parameters
+      // Just send the message directly
+      logger.debug(`[InfrastructureHealth:${serviceName}] [PUBLISH] Sending message to queue '${queueName}' (queue should already exist)...`);
+      
+      await activeChannel.sendToQueue(
+        queueName,
+        Buffer.from(JSON.stringify(data)),
+        { persistent: true }
+      );
+      
+      logger.info(`[InfrastructureHealth:${serviceName}] [PUBLISH] ✓ Message sent to queue '${queueName}'`, {
+        queueName,
+        serviceName,
+        status: data.status
+      });
+    } catch (error) {
+      // If channel was closed during operation, mark it for recreation
+      if (error.message && (error.message.includes('Channel closed') || error.message.includes('channel is closed'))) {
+        logger.warn(`[InfrastructureHealth:${serviceName}] [PUBLISH] Channel closed during publish, will recreate on next attempt`);
+        if (healthCheckChannel) {
+          try {
+            await healthCheckChannel.close().catch(() => {});
+          } catch (closeErr) {
+            // Ignore close errors
+          }
+          healthCheckChannel = null;
+        }
+      }
+      
+      logger.error(`[InfrastructureHealth:${serviceName}] [PUBLISH] ✗ Failed to publish health check`, {
+        queueName,
+        error: error.message,
+        stack: error.stack,
+        code: error.code
+      });
+      throw error;
+    }
+  };
+  
+  // Cleanup function to close health check channel
+  const cleanup = async () => {
+    if (healthCheckChannel && !healthCheckChannel.closed) {
+      try {
+        await healthCheckChannel.close();
+        logger.info(`[InfrastructureHealth:${serviceName}] Closed dedicated health check channel`);
+      } catch (closeErr) {
+        logger.warn(`[InfrastructureHealth:${serviceName}] Failed to close health check channel`, {
+          error: closeErr.message
+        });
+      }
+      healthCheckChannel = null;
+    }
   };
 
   return createHealthPublisher({

package/src/index.js

@@ -10,8 +10,8 @@
  * Business services should NOT use this library.
  */
 
-// Re-export waitForInfrastructureReady from service-common (no duplication)
-const { waitForInfrastructureReady } = require('@onlineapps/service-common');
+// Re-export infrastructure readiness utilities from service-common (no duplication)
+const { waitForInfrastructureReady, waitForHealthCheckQueueReady } = require('@onlineapps/service-common');
 
 const { initInfrastructureQueues } = require('./orchestration/initInfrastructureQueues');
 const {
@@ -19,16 +19,21 @@ const {
   createBaseClientAdapter,
   createAmqplibAdapter
 } = require('./health/healthPublisher');
+const { createLogger } = require('./utils/logger');
 
 module.exports = {
   // Orchestration utilities
-  // waitForInfrastructureReady is re-exported from @onlineapps/service-common
+  // waitForInfrastructureReady and waitForHealthCheckQueueReady are re-exported from @onlineapps/service-common
   waitForInfrastructureReady,
+  waitForHealthCheckQueueReady,
   initInfrastructureQueues,
   
   // Health tracking utilities
   createHealthPublisher,
   createBaseClientAdapter,
-  createAmqplibAdapter
+  createAmqplibAdapter,
+  
+  // Logger utility (consistent with conn-infra-mq pattern)
+  createLogger
 };
 

package/src/utils/logger.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * logger.js
+ *
+ * Provides a simple abstraction over console or a custom logger.
+ * If the user passes a custom logger object with methods { info, warn, error, debug },
+ * these are used; otherwise console.* is used as fallback.
+ * 
+ * Similar to conn-infra-mq logger utility for consistency across infrastructure libraries.
+ */
+
+function createLogger(customLogger) {
+  const methods = ['info', 'warn', 'error', 'debug'];
+  if (
+    customLogger &&
+    typeof customLogger === 'object' &&
+    methods.every((fn) => typeof customLogger[fn] === 'function')
+  ) {
+    // Wrap custom logger to ensure consistent signature
+    return {
+      info: (...args) => customLogger.info(...args),
+      warn: (...args) => customLogger.warn(...args),
+      error: (...args) => customLogger.error(...args),
+      debug: (...args) => customLogger.debug(...args),
+    };
+  }
+
+  // Fallback to console
+  return {
+    info: (...args) => console.log('[INFO]', ...args),
+    warn: (...args) => console.warn('[WARN]', ...args),
+    error: (...args) => console.error('[ERROR]', ...args),
+    debug: (...args) => console.debug('[DEBUG]', ...args),
+  };
+}
+
+module.exports = {
+  createLogger,
+};
+