@onlineapps/mq-client-core 1.0.43 → 1.0.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/mq-client-core",
-  "version": "1.0.43",
+  "version": "1.0.46",
   "description": "Core MQ client library for RabbitMQ - shared by infrastructure services and connectors",
   "main": "src/index.js",
   "scripts": {

package/src/config/queueConfig.js

@@ -207,14 +207,20 @@ module.exports = {
 
   /**
    * Monitoring infrastructure queue configurations
-   * These are dedicated queues for Monitoring service (separate from delivery queues)
+   * These are dedicated queues for Monitoring service (infrastructure service)
+   * 
+   * CRITICAL: Monitoring is an infrastructure service, monitoring queues are infrastructure queues!
+   * All services (both infrastructure and business) publish monitoring events here.
    */
   monitoring: {
     /**
-     * monitoring.workflow.completed - Completed workflows for monitoring
-     * Business services publish here for observability (separate from workflow.completed for delivery)
+     * monitoring.workflow - Unified workflow lifecycle monitoring
+     * Delivery Dispatcher publishes 'completed'/'failed' events after processing workflow.completed/workflow.failed
+     * Business services publish 'progress' events during workflow step processing
+     * Message format includes event_type: 'completed' | 'failed' | 'progress'
+     * Includes full cookbook and context snapshots for trace storage
      */
-    'workflow.completed': {
+    'workflow': {
       durable: true,
       arguments: {
         'x-message-ttl': 300000,      // 5 minutes TTL
@@ -223,36 +229,19 @@ module.exports = {
     },
 
     /**
-     * monitoring.workflow.failed - Failed workflows for monitoring
-     * Business services publish here for observability (separate from workflow.failed for delivery)
+     * monitoring.services - Service lifecycle events monitoring
+     * Registry publishes service lifecycle events (registered, validation.completed, version.changed, status.changed)
+     * InfrastructureHealthTracker publishes service status changes
+     * Message format includes event_type: 'service.registered' | 'service.validation.completed' | 
+     *   'service.version.changed' | 'service.deregistered' | 'service.status.changed'
+     * NOTE: Heartbeats are NOT published here (too frequent, every 10s)
+     * NOTE: Healthcheck messages go to infrastructure.health.events exchange
      */
-    'workflow.failed': {
+    'services': {
       durable: true,
       arguments: {
-        'x-message-ttl': 300000,      // 5 minutes TTL
-        'x-max-length': 10000
-      }
-    },
-
-    /**
-     * monitoring.registry.events - Registry events for monitoring
-     */
-    'registry.events': {
-      durable: true,
-      arguments: {
-        'x-message-ttl': 60000,       // 1 minute TTL
-        'x-max-length': 5000
-      }
-    },
-
-    /**
-     * monitoring.service.heartbeats - Service heartbeats for monitoring
-     */
-    'service.heartbeats': {
-      durable: true,
-      arguments: {
-        'x-message-ttl': 120000,      // 2 minutes TTL
-        'x-max-length': 10000
+        'x-message-ttl': 600000,      // 10 minutes TTL (longer for service tracking)
+        'x-max-length': 20000
       }
     }
   },
@@ -262,27 +251,28 @@ module.exports = {
    */
   registry: {
     /**
-     * registry.register - Registration requests
+     * registry.register - Main queue for ALL service communication with Registry
+     * 
+     * CRITICAL: This is the ONLY queue used for service-to-Registry communication.
+     * Registry listener processes different message types based on msg.type:
+     * - type: 'register' - Service registration requests
+     * - type: 'heartbeat' - Periodic health check messages (sent every 10s)
+     * - type: 'apiDescription' - API specification responses
+     * 
+     * Architecture rationale:
+     * - Single consumer on registry.register handles all message types
+     * - Simplifies queue management (one queue instead of multiple)
+     * - Registry can process messages in order and maintain state consistency
+     * - All business services send both registration AND heartbeats to this queue
      */
     register: {
       durable: true,
       arguments: {
-        'x-message-ttl': 60000,       // 1 minute TTL
+        'x-message-ttl': 60000,       // 1 minute TTL (for registration requests)
         'x-max-length': 1000
       }
     },
 
-    /**
-     * registry.heartbeats - Service heartbeats
-     */
-    heartbeats: {
-      durable: true,
-      arguments: {
-        'x-message-ttl': 120000,       // 2 minutes TTL
-        'x-max-length': 5000
-      }
-    },
-
     /**
      * registry.changes - Registry event fanout exchange
      * (This is an exchange, not a queue, but included for reference)

package/src/index.js

@@ -25,6 +25,12 @@ const {
   QueueNotFoundError,
   classifyPublishError,
 } = require('./utils/publishErrors');
+const {
+  publishToMonitoringResilient,
+  publishToMonitoringWorkflow,
+  publishToMonitoringServices,
+  isQueueUnavailableError,
+} = require('./monitoring-publish');
 
 // Export BaseClient as default (constructor), with additional named exports
 // NOTE: When destructuring, use: const { BaseClient } = require('@onlineapps/mq-client-core');
@@ -46,4 +52,10 @@ module.exports.publishErrors = {
   QueueNotFoundError,
   classifyPublishError,
 };
+module.exports.monitoring = {
+  publishToMonitoringResilient,
+  publishToMonitoringWorkflow,
+  publishToMonitoringServices,
+  isQueueUnavailableError,
+};
 

package/src/monitoring-publish.js

@@ -0,0 +1,203 @@
+/**
+ * Unified Monitoring Publish Helper
+ * 
+ * Provides resilient, fail-safe publishing to monitoring queues (monitoring.workflow, monitoring.services).
+ * 
+ * Principles:
+ * - Fail-safe: Never throws errors, always logs failures
+ * - Resilient: Handles queue unavailability gracefully (queue doesn't exist yet, RabbitMQ down)
+ * - Unified: Single API for all monitoring publish operations across all services
+ * - Encapsulated: All monitoring publish logic in one place, no duplication
+ * 
+ * Usage:
+ *   const { publishToMonitoringWorkflow, publishToMonitoringServices } = require('@onlineapps/mq-client-core');
+ *   await publishToMonitoringWorkflow(mqClient, { event_type: 'completed', workflow_id: '...', ... }, logger);
+ */
+
+const { PublishError, ConnectionError } = require('./utils/errorHandler');
+const { QueueNotFoundError, classifyPublishError } = require('./utils/publishErrors');
+
+/**
+ * Check if error indicates queue doesn't exist or RabbitMQ is unavailable
+ * @private
+ */
+function isQueueUnavailableError(error) {
+  if (!error) return false;
+  
+  const errorMessage = error.message || String(error);
+  const errorCode = error.code || '';
+  const errorName = error.name || '';
+  
+  // Connection errors
+  if (error instanceof ConnectionError || 
+      errorCode === 'ECONNREFUSED' || 
+      errorCode === 'ENOTFOUND' || 
+      errorCode === 'ETIMEDOUT' ||
+      errorMessage.includes('not connected') ||
+      errorMessage.includes('Connection closed')) {
+    return true;
+  }
+  
+  // Queue doesn't exist errors
+  if (error instanceof QueueNotFoundError ||
+      errorName === 'QueueNotFoundError' ||
+      errorMessage.includes('NOT_FOUND') || 
+      errorMessage.includes('404') ||
+      errorMessage.includes('no queue') ||
+      errorMessage.includes('queue does not exist') ||
+      errorMessage.includes('Channel closed')) {
+    return true;
+  }
+  
+  // Classify publish errors
+  const classified = classifyPublishError(error);
+  if (classified instanceof QueueNotFoundError) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Unified resilient publish to monitoring queue
+ * 
+ * @param {Object} mqClient - BaseClient instance (must be connected)
+ * @param {string} queueName - Queue name ('monitoring.workflow' or 'monitoring.services')
+ * @param {Object} message - Message to publish (must include event_type)
+ * @param {Object} [logger] - Logger instance (optional, for logging)
+ * @param {Object} [context] - Additional context for logging (optional)
+ * @returns {Promise<boolean>} - true if published successfully, false otherwise (never throws)
+ */
+async function publishToMonitoringResilient(mqClient, queueName, message, logger = null, context = {}) {
+  // Validate inputs
+  if (!mqClient) {
+    if (logger) {
+      logger.warn('Monitoring publish skipped: mqClient not provided', context);
+    }
+    return false;
+  }
+
+  if (!mqClient.isConnected || typeof mqClient.isConnected !== 'function' || !mqClient.isConnected()) {
+    if (logger) {
+      logger.warn(`Monitoring publish skipped: mqClient not connected (queue: ${queueName})`, context);
+    }
+    return false;
+  }
+
+  if (!message || !message.event_type) {
+    if (logger) {
+      logger.warn(`Monitoring publish skipped: message missing event_type (queue: ${queueName})`, {
+        ...context,
+        hasMessage: !!message
+      });
+    }
+    return false;
+  }
+
+  // Validate queue name
+  if (queueName !== 'monitoring.workflow' && queueName !== 'monitoring.services') {
+    if (logger) {
+      logger.warn(`Monitoring publish skipped: invalid queue name (expected monitoring.workflow or monitoring.services, got: ${queueName})`, context);
+    }
+    return false;
+  }
+
+  try {
+    await mqClient.publish(queueName, message);
+    
+    if (logger && logger.debug) {
+      logger.debug(`Published to ${queueName}`, {
+        ...context,
+        event_type: message.event_type,
+        workflow_id: message.workflow_id,
+        service_name: message.service_name
+      });
+    }
+    
+    return true;
+  } catch (error) {
+    // Check if this is a queue unavailable error
+    if (isQueueUnavailableError(error)) {
+      // Queue doesn't exist yet or RabbitMQ is unavailable - log but don't fail
+      if (logger && logger.warn) {
+        logger.warn(`Monitoring queue ${queueName} not available (queue may not exist yet or RabbitMQ unavailable)`, {
+          ...context,
+          error: error.message,
+          errorCode: error.code,
+          event_type: message.event_type,
+          workflow_id: message.workflow_id,
+          service_name: message.service_name
+        });
+      }
+      return false;
+    }
+    
+    // Other errors - log as warning but don't fail
+    if (logger && logger.warn) {
+      logger.warn(`Failed to publish to monitoring queue ${queueName}`, {
+        ...context,
+        error: error.message,
+        errorCode: error.code,
+        errorName: error.name,
+        event_type: message.event_type,
+        workflow_id: message.workflow_id,
+        service_name: message.service_name
+      });
+    }
+    
+    return false;
+  }
+}
+
+/**
+ * Publish workflow event to monitoring.workflow queue
+ * 
+ * @param {Object} mqClient - BaseClient instance (must be connected)
+ * @param {Object} message - Message with event_type ('completed' | 'failed' | 'progress'), workflow_id, etc.
+ * @param {Object} [logger] - Logger instance (optional)
+ * @param {Object} [context] - Additional context for logging (optional)
+ * @returns {Promise<boolean>} - true if published successfully, false otherwise (never throws)
+ * 
+ * @example
+ * await publishToMonitoringWorkflow(mqClient, {
+ *   event_type: 'completed',
+ *   workflow_id: 'wf-123',
+ *   service_name: 'hello-service',
+ *   cookbook: { ... },
+ *   context: { ... },
+ *   timestamp: new Date().toISOString()
+ * }, logger);
+ */
+async function publishToMonitoringWorkflow(mqClient, message, logger = null, context = {}) {
+  return publishToMonitoringResilient(mqClient, 'monitoring.workflow', message, logger, context);
+}
+
+/**
+ * Publish service lifecycle event to monitoring.services queue
+ * 
+ * @param {Object} mqClient - BaseClient instance (must be connected)
+ * @param {Object} message - Message with event_type ('service.registered' | 'service.validation.completed' | etc.), service_name, etc.
+ * @param {Object} [logger] - Logger instance (optional)
+ * @param {Object} [context] - Additional context for logging (optional)
+ * @returns {Promise<boolean>} - true if published successfully, false otherwise (never throws)
+ * 
+ * @example
+ * await publishToMonitoringServices(mqClient, {
+ *   event_type: 'service.registered',
+ *   service_name: 'hello-service',
+ *   version: '1.0.0',
+ *   status: 'pending',
+ *   timestamp: new Date().toISOString()
+ * }, logger);
+ */
+async function publishToMonitoringServices(mqClient, message, logger = null, context = {}) {
+  return publishToMonitoringResilient(mqClient, 'monitoring.services', message, logger, context);
+}
+
+module.exports = {
+  publishToMonitoringResilient,
+  publishToMonitoringWorkflow,
+  publishToMonitoringServices,
+  isQueueUnavailableError
+};
+