@onlineapps/infrastructure-tools 1.0.4 → 1.0.6

package/README.md

@@ -67,6 +67,7 @@ const { initInfrastructureQueues } = require('@onlineapps/infrastructure-tools')
 await initInfrastructureQueues(channel, {
   queues: ['workflow.init'], // Only create specific queues
   connection: connection,
+  serviceName: 'api-gateway',
   logger: logger
 });
 ```
@@ -94,6 +95,8 @@ Initializes infrastructure queues with correct parameters from `queueConfig`.
 - `connection` (Object): RabbitMQ connection (for channel recreation)
 - `logger` (Object): Logger instance (default: console)
 - `queueConfig` (Object): Queue config instance (default: from mq-client-core)
+- `serviceName` (string): Used in queue mismatch alerts (default: `unknown-service`)
+- `alertOnMismatch` (boolean): Disable automatic 406 alerts (default: `true`)
 
 **Returns:** `Promise<void>`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/infrastructure-tools",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Infrastructure orchestration utilities for OA Drive infrastructure services (health tracking, queue initialization, service discovery)",
   "main": "src/index.js",
   "scripts": {
@@ -19,7 +19,7 @@
   "license": "MIT",
   "dependencies": {
     "@onlineapps/mq-client-core": "^1.0.25",
-    "@onlineapps/service-common": "^1.0.0"
+    "@onlineapps/service-common": "^1.0.1"
   },
   "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,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,25 @@ const {
   createBaseClientAdapter,
   createAmqplibAdapter
 } = require('./health/healthPublisher');
+const { createLogger } = require('./utils/logger');
+const { sendQueueMismatchAlert } = require('./monitoring/queueMismatchReporter');
 
 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,
+
+  // Monitoring utilities
+  sendQueueMismatchAlert
 };
 

package/src/monitoring/queueMismatchReporter.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const { sendMonitoringFailFallbackEmail } = require('@onlineapps/service-common');
+
+const DEFAULT_COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes
+const lastAlertMap = new Map();
+
+function shouldThrottle(key, cooldownMs) {
+  const now = Date.now();
+  const last = lastAlertMap.get(key) || 0;
+  if (now - last < cooldownMs) {
+    return true;
+  }
+  lastAlertMap.set(key, now);
+  return false;
+}
+
+/**
+ * Send structured alert when queue precondition fails (406 mismatch).
+ * Falls back to email via service-common if Slack/webhook unavailable.
+ * @param {Object} options
+ * @param {string} options.serviceName
+ * @param {string} options.queueName
+ * @param {Object} [options.expectedArguments]
+ * @param {string} [options.action]
+ * @param {Error} [options.error]
+ * @param {Object} [options.logger]
+ * @param {number} [options.cooldownMs]
+ */
+async function sendQueueMismatchAlert(options = {}) {
+  const {
+    serviceName = 'unknown-service',
+    queueName = 'unknown-queue',
+    expectedArguments = {},
+    action = 'assertQueue',
+    error,
+    logger = console,
+    cooldownMs = DEFAULT_COOLDOWN_MS,
+    extra = {}
+  } = options;
+
+  const key = `${serviceName}:${queueName}`;
+  if (shouldThrottle(key, cooldownMs)) {
+    logger.warn('[QueueMismatchAlert] Throttling duplicate alert', { serviceName, queueName });
+    return false;
+  }
+
+  const event = {
+    serviceName,
+    queueName,
+    action,
+    expectedArguments,
+    errorMessage: error?.message,
+    errorCode: error?.code,
+    timestamp: new Date().toISOString(),
+    ...extra
+  };
+
+  logger.error('[QueueMismatchAlert] 406 PRECONDITION_FAILED detected', event);
+
+  const subject = `[Infra][QueueMismatch] ${serviceName} → ${queueName}`;
+  const textLines = [
+    `Service: ${serviceName}`,
+    `Queue: ${queueName}`,
+    `Action: ${action}`,
+    `Error: ${error?.message || 'Unknown'}`,
+    `Code: ${error?.code || 'N/A'}`,
+    `Expected arguments: ${JSON.stringify(expectedArguments, null, 2)}`,
+    `Timestamp: ${event.timestamp}`
+  ];
+  const text = textLines.join('\n');
+  const html = `<p><strong>Infrastructure Queue Mismatch</strong></p><pre>${text}</pre>`;
+
+  try {
+    const sent = await sendMonitoringFailFallbackEmail(subject, text, html);
+    if (!sent) {
+      logger.warn('[QueueMismatchAlert] Fallback email skipped (missing config)');
+    }
+    return sent;
+  } catch (emailError) {
+    logger.error('[QueueMismatchAlert] Failed to send fallback email', { error: emailError.message });
+    return false;
+  }
+}
+
+module.exports = {
+  sendQueueMismatchAlert,
+  _internal: {
+    shouldThrottle,
+    lastAlertMap
+  }
+};
+
+

package/src/orchestration/initInfrastructureQueues.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { sendQueueMismatchAlert } = require('../monitoring/queueMismatchReporter');
+
 /**
  * initInfrastructureQueues.js
  * 
@@ -18,6 +20,8 @@
  * @param {Object} [options.logger] - Logger instance (default: console)
  * @param {Object} [options.connection] - RabbitMQ connection (for channel recreation)
  * @param {Object} [options.queueConfig] - Queue config instance (default: from mq-client-core)
+ * @param {string} [options.serviceName] - Name of service initializing queues (for alerting context)
+ * @param {boolean} [options.alertOnMismatch=true] - Whether to send queue mismatch alerts
  * @returns {Promise<void>}
  */
 async function initInfrastructureQueues(channel, options = {}) {
@@ -27,6 +31,8 @@ async function initInfrastructureQueues(channel, options = {}) {
 
   const logger = options.logger || console;
   const connection = options.connection || channel.connection;
+  const serviceName = options.serviceName || process.env.SERVICE_NAME || 'unknown-service';
+  const alertOnMismatch = options.alertOnMismatch !== false;
   
   // Load queueConfig from mq-client-core
   // NOTE: queueConfig is part of mq-client-core because it's used by both:
@@ -102,6 +108,20 @@ async function initInfrastructureQueues(channel, options = {}) {
         logger.log(`[QueueInit] ✓ Created/verified infrastructure queue: ${queueName}`);
       } catch (assertError) {
         if (assertError.code === 406) {
+          if (alertOnMismatch) {
+            try {
+              await sendQueueMismatchAlert({
+                serviceName,
+                queueName,
+                expectedArguments: config.arguments || {},
+                action: 'initInfrastructureQueues.assertQueue',
+                error: assertError,
+                logger
+              });
+            } catch (alertError) {
+              logger.warn('[QueueInit] Failed to send queue mismatch alert', alertError.message);
+            }
+          }
           logger.warn(
             `[QueueInit] ⚠ Queue ${queueName} exists with different arguments - deleting and recreating...`
           );

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/tests/queueMismatchReporter.test.js

@@ -0,0 +1,49 @@
+'use strict';
+
+jest.mock('@onlineapps/service-common', () => ({
+  sendMonitoringFailFallbackEmail: jest.fn().mockResolvedValue(true)
+}));
+
+const {
+  sendQueueMismatchAlert,
+  _internal
+} = require('../src/monitoring/queueMismatchReporter');
+const { sendMonitoringFailFallbackEmail } = require('@onlineapps/service-common');
+
+describe('queueMismatchReporter', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    _internal.lastAlertMap.clear();
+  });
+
+  it('sends fallback email for queue mismatch', async () => {
+    await sendQueueMismatchAlert({
+      serviceName: 'test-service',
+      queueName: 'workflow.init',
+      expectedArguments: { 'x-message-ttl': 60000 },
+      error: new Error('PRECONDITION_FAILED')
+    });
+
+    expect(sendMonitoringFailFallbackEmail).toHaveBeenCalledTimes(1);
+    const [subject, text] = sendMonitoringFailFallbackEmail.mock.calls[0];
+    expect(subject).toContain('test-service');
+    expect(text).toContain('workflow.init');
+  });
+
+  it('throttles duplicate alerts within cooldown', async () => {
+    await sendQueueMismatchAlert({
+      serviceName: 'test-service',
+      queueName: 'workflow.init',
+      cooldownMs: 60000
+    });
+    await sendQueueMismatchAlert({
+      serviceName: 'test-service',
+      queueName: 'workflow.init',
+      cooldownMs: 60000
+    });
+
+    expect(sendMonitoringFailFallbackEmail).toHaveBeenCalledTimes(1);
+  });
+});
+
+