@onlineapps/infrastructure-tools 1.0.3 → 1.0.5

package/README.md

@@ -55,6 +55,8 @@ await waitForInfrastructureReady({
 });
 ```
 
+**Note:** `waitForInfrastructureReady` is re-exported from `@onlineapps/service-common` to avoid duplication. Both infrastructure and business services can use it.
+
 ### Initialize Infrastructure Queues
 
 Initialize infrastructure queues with correct parameters:
@@ -120,7 +122,7 @@ Creates health publisher adapter for amqplib (direct connection + channel).
 ## Dependencies
 
 - `@onlineapps/mq-client-core` - For queue configuration
-- `redis` - For health status checking
+- `@onlineapps/service-common` - For `waitForInfrastructureReady` (shared utility)
 
 ## Related Libraries
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/infrastructure-tools",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Infrastructure orchestration utilities for OA Drive infrastructure services (health tracking, queue initialization, service discovery)",
   "main": "src/index.js",
   "scripts": {
@@ -18,8 +18,8 @@
   "author": "OnlineApps",
   "license": "MIT",
   "dependencies": {
-    "@onlineapps/mq-client-core": "^1.0.24",
-    "redis": "^4.6.0"
+    "@onlineapps/mq-client-core": "^1.0.25",
+    "@onlineapps/service-common": "^1.0.0"
   },
   "devDependencies": {
     "jest": "^29.7.0"
@@ -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,22 +10,30 @@
  * Business services should NOT use this library.
  */
 
-const { waitForInfrastructureReady } = require('./orchestration/waitForInfrastructureReady');
+// Re-export infrastructure readiness utilities from service-common (no duplication)
+const { waitForInfrastructureReady, waitForHealthCheckQueueReady } = require('@onlineapps/service-common');
+
 const { initInfrastructureQueues } = require('./orchestration/initInfrastructureQueues');
 const {
   createHealthPublisher,
   createBaseClientAdapter,
   createAmqplibAdapter
 } = require('./health/healthPublisher');
+const { createLogger } = require('./utils/logger');
 
 module.exports = {
   // Orchestration utilities
+  // 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,
+};
+

package/src/orchestration/waitForInfrastructureReady.js

@@ -1,149 +0,0 @@
-'use strict';
-
-/**
- * waitForInfrastructureReady.js
- * 
- * Waits for all infrastructure services to be verified as running and healthy.
- * Used by infrastructure services before creating queues to ensure system consistency.
- * 
- * This prevents race conditions where queues are created before all services are ready.
- * 
- * **How it works:**
- * 1. Connects to Redis (where Registry stores infrastructure health status)
- * 2. Checks `infrastructure:health:all` key every 5 seconds
- * 3. If key is `"true"` → all infrastructure services are UP → return success
- * 4. If key is `"false"` or missing → wait and retry
- * 5. If timeout reached → throw error
- * 
- * **Why Redis (not HTTP):**
- * - Fast: In-memory lookup, no network overhead
- * - Reliable: Redis is already required infrastructure
- * - Low latency: Direct key lookup, no HTTP parsing
- * - Consistent: Same data source as Registry uses
- * - No single point of failure: Redis can be clustered
- */
-
-/**
- * Wait for all infrastructure services to be ready
- * @param {Object} options - Options
- * @param {string} [options.redisUrl] - Redis URL (default: REDIS_URL env or redis://api_node_cache:6379)
- * @param {number} [options.maxWait] - Maximum wait time in ms (default: INFRASTRUCTURE_HEALTH_WAIT_MAX_TIME env or 300000 = 5 minutes)
- * @param {number} [options.checkInterval] - Check interval in ms (default: INFRASTRUCTURE_HEALTH_WAIT_CHECK_INTERVAL env or 5000 = 5 seconds)
- * @param {Object} [options.logger] - Logger instance (default: console)
- * @returns {Promise<boolean>} - True if all infrastructure services are ready
- * @throws {Error} - If timeout is reached
- * 
- * Note: Default values can be overridden via ENV variables or options parameter.
- * Registry config (config.infrastructureHealth) is the source of truth for these defaults.
- */
-async function waitForInfrastructureReady(options = {}) {
-  const redisUrl = options.redisUrl || process.env.REDIS_URL || 'redis://api_node_cache:6379';
-  const maxWait = options.maxWait || parseInt(process.env.INFRASTRUCTURE_HEALTH_WAIT_MAX_TIME) || 300000; // 5 minutes
-  const checkInterval = options.checkInterval || parseInt(process.env.INFRASTRUCTURE_HEALTH_WAIT_CHECK_INTERVAL) || 5000; // 5 seconds
-  const logger = options.logger || console;
-
-  // Universal logger adapter (supports both console and winston)
-  // Winston logger can accept string, but to be safe, we'll always use object format for winston
-  const log = (message) => {
-    const messageStr = String(message);
-    
-    // Check if logger is winston (has child method or format property)
-    const isWinston = typeof logger.child === 'function' || logger.format !== undefined;
-    
-    if (typeof logger.info === 'function') {
-      if (isWinston) {
-        // Winston logger - always use object format to avoid property conflicts
-        logger.info({ message: messageStr });
-      } else {
-        // Other logger with info method - use string
-        logger.info(messageStr);
-      }
-    } else if (typeof logger.log === 'function') {
-      // console.log or similar
-      logger.log(messageStr);
-    } else {
-      console.log(messageStr);
-    }
-  };
-
-  const startTime = Date.now();
-  let attemptCount = 0;
-  let redis = null;
-
-  log('[InfrastructureReady] Waiting for all infrastructure services to be ready...');
-  log(`[InfrastructureReady] Redis URL: ${redisUrl}`);
-  log(`[InfrastructureReady] Max wait: ${maxWait}ms, Check interval: ${checkInterval}ms`);
-
-  try {
-    // Connect to Redis
-    const { createClient } = require('redis');
-    redis = createClient({ url: redisUrl });
-    
-    redis.on('error', (err) => {
-      log(`[InfrastructureReady] Redis error: ${err.message}`);
-    });
-    
-    await redis.connect();
-    log('[InfrastructureReady] Connected to Redis');
-
-    while (Date.now() - startTime < maxWait) {
-      attemptCount++;
-      
-      try {
-        // Check Redis key: infrastructure:health:all
-        const allHealthy = await redis.get('infrastructure:health:all');
-        
-        if (allHealthy === 'true') {
-          // All services are UP, we can proceed
-          const elapsed = Date.now() - startTime;
-          log(`[InfrastructureReady] ✓ All infrastructure services are ready (took ${elapsed}ms, ${attemptCount} attempts)`);
-          
-          // Optionally log individual service status
-          // Note: Service names should match config.infrastructureServices in Registry
-          const serviceKeys = ['gateway', 'registry', 'validator', 'delivery', 'monitoring'];
-          const statuses = {};
-          for (const serviceName of serviceKeys) {
-            const status = await redis.get(`infrastructure:health:${serviceName}`);
-            if (status) {
-              statuses[serviceName] = JSON.parse(status);
-            }
-          }
-          log(`[InfrastructureReady] Infrastructure status: ${JSON.stringify(statuses, null, 2)}`);
-          
-          return true;
-        }
-
-        // Not all services ready yet
-        log(`[InfrastructureReady] Attempt ${attemptCount}: Not all services ready (allHealthy: ${allHealthy || 'null'})`);
-        log(`[InfrastructureReady] Waiting ${checkInterval}ms before next check...`);
-
-      } catch (error) {
-        // Redis might not be ready yet, or connection issue
-        log(`[InfrastructureReady] Attempt ${attemptCount}: Redis check failed (${error.message})`);
-        log(`[InfrastructureReady] Waiting ${checkInterval}ms before retry...`);
-      }
-
-      // Wait before next check
-      await new Promise(resolve => setTimeout(resolve, checkInterval));
-    }
-
-    // Timeout reached
-    const elapsed = Date.now() - startTime;
-    throw new Error(
-      `Infrastructure services not ready within ${maxWait}ms (${elapsed}ms elapsed, ${attemptCount} attempts). ` +
-      `Check Redis keys: infrastructure:health:*`
-    );
-
-  } finally {
-    // Clean up Redis connection
-    if (redis && redis.isReady) {
-      await redis.quit();
-      log('[InfrastructureReady] Redis connection closed');
-    }
-  }
-}
-
-module.exports = {
-  waitForInfrastructureReady
-};
-