@onlineapps/conn-infra-mq 1.1.52 → 1.1.54

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@onlineapps/conn-infra-mq",
-    "version": "1.1.52",
+    "version": "1.1.54",
     "description": "A promise-based, broker-agnostic client for sending and receiving messages via RabbitMQ",
     "main": "src/index.js",
     "repository": {

package/src/ConnectorMQClient.js

@@ -46,11 +46,43 @@ class ConnectorMQClient extends BaseClient {
    * });
    */
   constructor(config = {}) {
-    super(config);
+    // Setup queue creation callback for RecoveryWorker (delegates to QueueManager)
+    // This ensures RecoveryWorker uses QueueManager for queue creation instead of direct creation
+    // Note: We create a closure that will access this.queues after it's initialized
+    let queueManagerRef = null;
+    const queueCreationCallback = async (queueName, options = {}) => {
+      if (!queueManagerRef) {
+        throw new Error('QueueManager not initialized - cannot create queue via RecoveryWorker');
+      }
+      // Use ensureQueue for individual queues (RecoveryWorker handles single queue creation)
+      // Note: setupServiceQueues creates multiple queues, but RecoveryWorker only needs one
+      // However, ensureQueue throws for business queues, so we need to handle that
+      try {
+        await queueManagerRef.ensureQueue(queueName, options);
+      } catch (err) {
+        // If ensureQueue fails because it's a business queue, we can't create it via RecoveryWorker
+        // RecoveryWorker should only handle transient errors, not business queue creation
+        // Business queues must be created via setupServiceQueues() after registration
+        throw new Error(`Cannot create business queue '${queueName}' via RecoveryWorker. Business queues must be created via setupServiceQueues() after registration.`);
+      }
+    };
+
+    // Pass queueCreationCallback to config for RecoveryWorker
+    const enhancedConfig = {
+      ...config,
+      queueCreationCallback,
+      recoveryScope: config.recoveryScope || 'business', // Business services can create queues
+    };
+
+    super(enhancedConfig);
 
     // Initialize layers
     this.workflow = new WorkflowRouter(this, config);
     this.queues = new QueueManager(this, config);
+    
+    // Set reference for queueCreationCallback closure
+    queueManagerRef = this.queues;
+    
     this.retry = new RetryHandler(this, config);
     this.forkJoin = new ForkJoinHandler(this, this.queues, config);
 

package/src/layers/RetryHandler.js

@@ -13,6 +13,7 @@ class RetryHandler {
       maxDelay: config.maxDelay || 30000,
       backoffMultiplier: config.backoffMultiplier || 2,
       dlqSuffix: config.dlqSuffix || '.dlq',
+      emitMonitoringEvents: config.emitMonitoringEvents !== false, // Enable by default
       ...config
     };
     this.retryStats = {
@@ -22,6 +23,36 @@ class RetryHandler {
       dlqMessages: 0
     };
   }
+  
+  /**
+   * Emit retry event to monitoring (non-blocking)
+   * @private
+   */
+  async _emitRetryEvent(eventType, data) {
+    if (!this.config.emitMonitoringEvents) return;
+    
+    try {
+      const { publishToMonitoringWorkflow } = require('@onlineapps/mq-client-core').monitoring;
+      
+      await publishToMonitoringWorkflow(this.client, {
+        event_type: eventType,
+        workflow_id: data.workflow_id || data.message?.workflow_id || 'unknown',
+        timestamp: new Date().toISOString(),
+        retry_info: {
+          queue: data.queue,
+          retry_count: data.retryCount,
+          max_retries: data.maxRetries || this.config.maxRetries,
+          delay_ms: data.delay,
+          error_message: data.error?.message,
+          error_code: data.error?.code
+        }
+      }, null, { source: 'RetryHandler' });
+      
+    } catch (e) {
+      // Silent fail - don't break retry logic due to monitoring
+      console.warn('[RetryHandler] Failed to emit monitoring event:', e.message);
+    }
+  }
 
   /**
    * Process message with retry logic
@@ -75,12 +106,23 @@ class RetryHandler {
 
     if (retryCount < maxRetries) {
       // Retry the message
+      const delay = this.calculateDelay(retryCount + 1);
       await this.retryMessage(enrichedMessage, queueName, retryCount + 1, options);
 
       // Acknowledge original to remove from queue
       await this.client.ack(rawMsg);
 
       this.retryStats.totalRetries++;
+      
+      // Emit retry event to monitoring
+      this._emitRetryEvent('message_retry', {
+        workflow_id: message.workflow_id,
+        queue: queueName,
+        retryCount: retryCount + 1,
+        maxRetries,
+        delay,
+        error
+      });
 
       return { success: false, retried: true, retryCount: retryCount + 1 };
     } else {
@@ -92,6 +134,15 @@ class RetryHandler {
 
       this.retryStats.failedRetries++;
       this.retryStats.dlqMessages++;
+      
+      // Emit DLQ event to monitoring
+      this._emitRetryEvent('message_dlq', {
+        workflow_id: message.workflow_id,
+        queue: queueName,
+        retryCount,
+        maxRetries,
+        error
+      });
 
       return { success: false, retried: false, dlq: true, retryCount };
     }

package/src/transports/rabbitmqClient.js

@@ -197,6 +197,36 @@ class RabbitMQClient extends EventEmitter {
     }
   }
 
+  /**
+   * Emits structured PRECONDITION_FAILED events and invokes optional hooks.
+   * @param {Object} context - Details about the failing operation
+   * @param {Error} error - Original amqplib error
+   * @private
+   */
+  _handlePreconditionFailed(context, error) {
+    const event = {
+      timestamp: new Date().toISOString(),
+      serviceName: this._config.serviceName || this._config.clientId || 'unknown',
+      host: this._config.host,
+      ...context,
+      error: {
+        message: error?.message,
+        code: error?.code,
+        stack: error?.stack
+      }
+    };
+
+    this.emit('preconditionFailed', event);
+
+    if (typeof this._config.onPreconditionFailed === 'function') {
+      try {
+        this._config.onPreconditionFailed(event);
+      } catch (hookError) {
+        console.warn('[RabbitMQClient] onPreconditionFailed hook threw error:', hookError.message);
+      }
+    }
+  }
+
   /**
    * Publishes a message buffer to the specified queue (or default queue) or exchange.
    * @param {string} queue           - Target queue name.
@@ -265,6 +295,19 @@ class RabbitMQClient extends EventEmitter {
       // Wait for confirmation
       await this._channel.waitForConfirms();
     } catch (err) {
+      if (err?.code === 406) {
+        this._handlePreconditionFailed(
+          {
+            operation: 'publish',
+            queueName: queue,
+            routingKey,
+            payloadSample: buffer?.toString?.().slice(0, 512) || null,
+            persistent,
+            headers
+          },
+          err
+        );
+      }
       this.emit('error', err);
       throw err;
     }
@@ -357,8 +400,24 @@ class RabbitMQClient extends EventEmitter {
         // Use queueChannel for assertQueue to avoid RPC reply queue issues
         const channelForAssert = this._queueChannel;
         this._queueChannel._lastOperation = `About to assertQueue ${queue} with options: ${JSON.stringify(queueOptions)}`;
-        await channelForAssert.assertQueue(queue, queueOptions);
-        this._queueChannel._lastOperation = `assertQueue ${queue} succeeded`;
+        try {
+          await channelForAssert.assertQueue(queue, queueOptions);
+          this._queueChannel._lastOperation = `assertQueue ${queue} succeeded`;
+        } catch (assertErr) {
+          this._queueChannel._closeReason = `assertQueue failed: ${assertErr.message}`;
+          if (assertErr?.code === 406) {
+            this._handlePreconditionFailed(
+              {
+                operation: 'assertQueue',
+                phase: 'consume.setup',
+                queueName: queue,
+                queueOptions
+              },
+              assertErr
+            );
+          }
+          throw assertErr;
+        }
         
         const assertEndTime = Date.now();
         console.log(`[RabbitMQClient] [CONSUMER] ✓ Queue ${queue} asserted (took ${assertEndTime - assertStartTime}ms)`);

package/src/utils/initInfrastructureQueues.js

@@ -1,92 +0,0 @@
-'use strict';
-
-/**
- * initInfrastructureQueues.js
- * 
- * Unified tool for creating all infrastructure queues.
- * Used by ALL relevant services (infrastructure AND business) during startup.
- * 
- * Ensures consistent queue parameters across all services.
- */
-
-const queueConfig = require('../config/queueConfig');
-
-/**
- * Initialize all infrastructure queues
- * @param {Object} channel - RabbitMQ channel
- * @param {Object} options - Options
- * @param {Array<string>} [options.queues] - Specific queues to create (default: all infrastructure queues)
- * @param {Object} [options.logger] - Logger instance (default: console)
- * @returns {Promise<void>}
- */
-async function initInfrastructureQueues(channel, options = {}) {
-  const logger = options.logger || console;
-  const queuesToCreate = options.queues || [
-    // Workflow infrastructure queues
-    'workflow.init',
-    'workflow.completed',
-    'workflow.failed',
-    'workflow.dlq',
-    // Registry infrastructure queues
-    'registry.register',
-    'registry.heartbeats'
-  ];
-
-  logger.log(`[QueueInit] Initializing ${queuesToCreate.length} infrastructure queues...`);
-
-  for (const queueName of queuesToCreate) {
-    try {
-      // Verify it's an infrastructure queue
-      if (!queueConfig.isInfrastructureQueue(queueName)) {
-        logger.warn(`[QueueInit] Skipping ${queueName} - not an infrastructure queue`);
-        continue;
-      }
-
-      // Get unified configuration
-      const config = queueConfig.getInfrastructureQueueConfig(queueName);
-      
-      // CRITICAL: Check if queue exists with different arguments (406 error)
-      // If so, delete it and recreate with correct parameters
-      try {
-        await channel.assertQueue(queueName, {
-          durable: config.durable !== false,
-          arguments: { ...config.arguments }
-        });
-        logger.log(`[QueueInit] ✓ Created/verified infrastructure queue: ${queueName}`);
-      } catch (assertError) {
-        if (assertError.code === 406) {
-          // Queue exists with different arguments - delete and recreate
-          logger.warn(`[QueueInit] ⚠ Queue ${queueName} exists with different arguments - deleting and recreating...`);
-          try {
-            await channel.deleteQueue(queueName);
-            logger.log(`[QueueInit] ✓ Deleted queue ${queueName} with incorrect parameters`);
-          } catch (deleteError) {
-            logger.error(`[QueueInit] ✗ Failed to delete queue ${queueName}:`, deleteError.message);
-            throw new Error(`Cannot delete queue ${queueName} with incorrect parameters: ${deleteError.message}`);
-          }
-          
-          // Recreate with correct parameters
-          await channel.assertQueue(queueName, {
-            durable: config.durable !== false,
-            arguments: { ...config.arguments }
-          });
-          logger.log(`[QueueInit] ✓ Recreated infrastructure queue: ${queueName} with correct parameters`);
-        } else {
-          // Other error - rethrow
-          logger.error(`[QueueInit] ✗ Failed to create ${queueName}:`, assertError.message);
-          throw assertError;
-        }
-      }
-    } catch (error) {
-      logger.error(`[QueueInit] ✗ Failed to initialize queue ${queueName}:`, error.message);
-      throw error;
-    }
-  }
-
-  logger.log(`[QueueInit] Infrastructure queues initialization complete`);
-}
-
-module.exports = {
-  initInfrastructureQueues
-};
-