@onlineapps/service-common 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-common",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Common utilities for both infrastructure services and business services",
   "main": "src/index.js",
   "scripts": {

package/src/index.js

@@ -32,6 +32,12 @@ const {
   getServiceConfig,
   getInfrastructureHealthConfig
 } = require('./runtime-config');
+const {
+  publishToMonitoringResilient,
+  publishToMonitoringWorkflow,
+  publishToMonitoringServices,
+  isQueueUnavailableError
+} = require('./monitoring-publish');
 
 module.exports = {
   // Infrastructure readiness utilities (used by both infrastructure and business services)
@@ -59,7 +65,13 @@ module.exports = {
   getInfrastructureHealthConfig,
 
   // Reporting utilities
-  sendMonitoringFailFallbackEmail
+  sendMonitoringFailFallbackEmail,
+
+  // Resilient monitoring publish utilities
+  publishToMonitoringResilient,
+  publishToMonitoringWorkflow,
+  publishToMonitoringServices,
+  isQueueUnavailableError
 };
 
 

package/src/monitoring-publish.js

@@ -0,0 +1,133 @@
+/**
+ * Resilient monitoring publish helper
+ * 
+ * Publishes to monitoring queues (monitoring.workflow, monitoring.services) with fail-safe behavior.
+ * If the queue doesn't exist or RabbitMQ is unavailable, logs the error and continues without failing.
+ * 
+ * This ensures services can start and operate even if monitoring queues aren't ready yet.
+ * Monitoring queues are created when health:all is true, so this is a temporary state during startup.
+ */
+
+/**
+ * Check if error indicates queue doesn't exist or RabbitMQ is unavailable
+ */
+function isQueueUnavailableError(error) {
+  if (!error) return false;
+  
+  const errorMessage = error.message || String(error);
+  const errorCode = error.code || '';
+  
+  // RabbitMQ connection errors
+  if (errorCode === 'ECONNREFUSED' || errorCode === 'ENOTFOUND' || errorCode === 'ETIMEDOUT') {
+    return true;
+  }
+  
+  // Queue doesn't exist errors (from RabbitMQ)
+  if (errorMessage.includes('NOT_FOUND') || 
+      errorMessage.includes('404') ||
+      errorMessage.includes('no queue') ||
+      errorMessage.includes('queue does not exist') ||
+      errorMessage.includes('Channel closed') ||
+      errorMessage.includes('Connection closed')) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Resilient publish to monitoring queue
+ * 
+ * @param {Object} mqClient - MQ client instance (must have publish method)
+ * @param {string} queueName - Queue name (e.g., 'monitoring.workflow', 'monitoring.services')
+ * @param {Object} message - Message to publish
+ * @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
+ */
+async function publishToMonitoringResilient(mqClient, queueName, message, logger = null, context = {}) {
+  if (!mqClient || typeof mqClient.publish !== 'function') {
+    if (logger) {
+      logger.warn('Monitoring publish skipped: mqClient not available', context);
+    }
+    return false;
+  }
+
+  try {
+    await mqClient.publish(queueName, message);
+    
+    if (logger) {
+      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(`Monitoring queue ${queueName} not available (queue may not exist yet or RabbitMQ unavailable)`, {
+          ...context,
+          error: error.message,
+          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(`Failed to publish to monitoring queue ${queueName}`, {
+        ...context,
+        error: error.message,
+        errorCode: error.code,
+        event_type: message.event_type,
+        workflow_id: message.workflow_id,
+        service_name: message.service_name
+      });
+    }
+    
+    return false;
+  }
+}
+
+/**
+ * Resilient publish to monitoring.workflow queue
+ * 
+ * @param {Object} mqClient - MQ client instance
+ * @param {Object} message - Message with event_type, workflow_id, etc.
+ * @param {Object} logger - Logger instance (optional)
+ * @param {Object} context - Additional context for logging (optional)
+ * @returns {Promise<boolean>}
+ */
+async function publishToMonitoringWorkflow(mqClient, message, logger = null, context = {}) {
+  return publishToMonitoringResilient(mqClient, 'monitoring.workflow', message, logger, context);
+}
+
+/**
+ * Resilient publish to monitoring.services queue
+ * 
+ * @param {Object} mqClient - MQ client instance
+ * @param {Object} message - Message with event_type, service_name, etc.
+ * @param {Object} logger - Logger instance (optional)
+ * @param {Object} context - Additional context for logging (optional)
+ * @returns {Promise<boolean>}
+ */
+async function publishToMonitoringServices(mqClient, message, logger = null, context = {}) {
+  return publishToMonitoringResilient(mqClient, 'monitoring.services', message, logger, context);
+}
+
+module.exports = {
+  publishToMonitoringResilient,
+  publishToMonitoringWorkflow,
+  publishToMonitoringServices,
+  isQueueUnavailableError
+};
+