@onlineapps/mq-client-core 1.0.45 → 1.0.46

package/package.json

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

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
+};
+