@onlineapps/infrastructure-tools 1.0.5 → 1.0.7

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.5",
+  "version": "1.0.7",
   "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"

package/src/index.js

@@ -11,7 +11,11 @@
  */
 
 // Re-export infrastructure readiness utilities from service-common (no duplication)
-const { waitForInfrastructureReady, waitForHealthCheckQueueReady } = require('@onlineapps/service-common');
+const { waitForInfrastructureReady, waitForHealthCheckQueueReady, sendMonitoringFailFallbackEmail } = require('@onlineapps/service-common');
+
+// Re-export MQ client core utilities
+const BaseClient = require('@onlineapps/mq-client-core');
+const queueConfig = require('@onlineapps/mq-client-core/src/config/queueConfig');
 
 const { initInfrastructureQueues } = require('./orchestration/initInfrastructureQueues');
 const {
@@ -20,12 +24,20 @@ const {
   createAmqplibAdapter
 } = require('./health/healthPublisher');
 const { createLogger } = require('./utils/logger');
+const { sendQueueMismatchAlert } = require('./monitoring/queueMismatchReporter');
 
 module.exports = {
-  // Orchestration utilities
-  // waitForInfrastructureReady and waitForHealthCheckQueueReady are re-exported from @onlineapps/service-common
+  // MQ Client Core (re-exported for convenience)
+  BaseClient,
+  MQClient: BaseClient, // Alias for compatibility
+  queueConfig,
+  
+  // Service Common utilities (re-exported for convenience)
   waitForInfrastructureReady,
   waitForHealthCheckQueueReady,
+  sendMonitoringFailFallbackEmail,
+  
+  // Orchestration utilities
   initInfrastructureQueues,
   
   // Health tracking utilities
@@ -34,6 +46,9 @@ module.exports = {
   createAmqplibAdapter,
   
   // Logger utility (consistent with conn-infra-mq pattern)
-  createLogger
+  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/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);
+  });
+});
+
+