@onlineapps/service-common 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-common",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Common utilities for both infrastructure services and business services",
   "main": "src/index.js",
   "scripts": {
@@ -17,6 +17,7 @@
   "author": "OA Drive Team",
   "license": "MIT",
   "dependencies": {
+    "nodemailer": "^6.9.8",
     "redis": "^4.6.0"
   },
   "devDependencies": {

package/src/index.js

@@ -10,9 +10,14 @@
  */
 
 const { waitForInfrastructureReady } = require('./infrastructure/waitForInfrastructureReady');
+const { waitForHealthCheckQueueReady } = require('./infrastructure/waitForHealthCheckQueueReady');
+const { sendMonitoringFailFallbackEmail } = require('./reporting/monitoringFallbackEmail');
 
 module.exports = {
   // Infrastructure readiness utilities (used by both infrastructure and business services)
-  waitForInfrastructureReady
+  waitForInfrastructureReady,
+  waitForHealthCheckQueueReady,
+  // Reporting utilities
+  sendMonitoringFailFallbackEmail
 };
 

package/src/infrastructure/waitForHealthCheckQueueReady.js

@@ -0,0 +1,106 @@
+'use strict';
+
+/**
+ * waitForHealthCheckQueueReady.js
+ * 
+ * Waits for Registry to create the infrastructure.health.checks queue.
+ * Used by infrastructure services to know when they can start publishing health checks.
+ * 
+ * This is different from waitForInfrastructureReady - this only checks if the queue exists,
+ * not if all services are healthy.
+ * 
+ * **How it works:**
+ * 1. Connects to Redis
+ * 2. Checks `infrastructure:health:queue:ready` key every 2 seconds
+ * 3. If key is `"true"` → queue is ready → return success
+ * 4. If key is missing → wait and retry
+ * 5. If timeout reached → throw error
+ * 
+ * **Usage:**
+ * - Infrastructure services: Wait before starting health check publisher
+ */
+
+/**
+ * Wait for health check queue to be ready
+ * @param {Object} options - Options
+ * @param {string} [options.redisUrl] - Redis URL (default: REDIS_URL env or redis://api_node_cache:6379)
+ * @param {number} [options.maxWait] - Maximum wait time in ms (default: 60000 = 1 minute)
+ * @param {number} [options.checkInterval] - Check interval in ms (default: 2000 = 2 seconds)
+ * @param {Object} [options.logger] - Logger instance (default: console)
+ * @returns {Promise<boolean>} - True if queue is ready
+ * @throws {Error} - If timeout is reached
+ */
+async function waitForHealthCheckQueueReady(options = {}) {
+  const redisUrl = options.redisUrl || process.env.REDIS_URL || 'redis://api_node_cache:6379';
+  const maxWait = options.maxWait || parseInt(process.env.INFRASTRUCTURE_HEALTH_QUEUE_WAIT_MAX_TIME) || 60000; // 1 minute
+  const checkInterval = options.checkInterval || parseInt(process.env.INFRASTRUCTURE_HEALTH_QUEUE_WAIT_CHECK_INTERVAL) || 2000; // 2 seconds
+  const logger = options.logger || console;
+  
+  const log = (msg) => {
+    if (logger && typeof logger.info === 'function') {
+      logger.info(msg);
+    } else if (logger && typeof logger.log === 'function') {
+      logger.log(msg);
+    } else {
+      console.log(msg);
+    }
+  };
+
+  let redis = null;
+  const startTime = Date.now();
+  let attemptCount = 0;
+
+  log(`[HealthCheckQueueReady] Waiting for health check queue to be ready...`);
+  log(`[HealthCheckQueueReady] Redis URL: ${redisUrl}`);
+  log(`[HealthCheckQueueReady] Max wait: ${maxWait}ms, Check interval: ${checkInterval}ms`);
+
+  try {
+    // Connect to Redis
+    const { createClient } = require('redis');
+    redis = createClient({ url: redisUrl });
+    
+    redis.on('error', (err) => {
+      log(`[HealthCheckQueueReady] Redis error: ${err.message}`);
+    });
+    
+    await redis.connect();
+    log('[HealthCheckQueueReady] Connected to Redis');
+
+    while (Date.now() - startTime < maxWait) {
+      attemptCount++;
+      
+      try {
+        // Check Redis key: infrastructure:health:queue:ready
+        const queueReady = await redis.get('infrastructure:health:queue:ready');
+        
+        if (queueReady === 'true') {
+          // Queue is ready, we can proceed
+          const elapsed = Date.now() - startTime;
+          log(`[HealthCheckQueueReady] ✓ Health check queue is ready (took ${elapsed}ms, ${attemptCount} attempts)`);
+          return true;
+        }
+
+        log(`[HealthCheckQueueReady] Attempt ${attemptCount}: Queue not ready yet (current status: ${queueReady || 'unknown'}). Waiting ${checkInterval}ms...`);
+
+      } catch (error) {
+        log(`[HealthCheckQueueReady] Attempt ${attemptCount}: Failed to get queue ready status from Redis (${error.message}). Waiting ${checkInterval}ms...`);
+      }
+
+      await new Promise(resolve => setTimeout(resolve, checkInterval));
+    }
+
+    const elapsed = Date.now() - startTime;
+    throw new Error(
+      `Health check queue not ready within ${maxWait}ms (${elapsed}ms elapsed, ${attemptCount} attempts). ` +
+      `Check Redis key 'infrastructure:health:queue:ready' and ensure Registry has started.`
+    );
+  } finally {
+    if (redis && redis.isReady) {
+      await redis.quit();
+      log('[HealthCheckQueueReady] Disconnected from Redis.');
+    }
+  }
+}
+
+module.exports = { waitForHealthCheckQueueReady };
+

package/src/reporting/monitoringFallbackEmail.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const nodemailer = require('nodemailer');
+
+let transporter = null;
+let cachedConfigSignature = null;
+
+function loadConfig() {
+  return {
+    host: process.env.INFRA_REPORT_SMTP_HOST,
+    port: process.env.INFRA_REPORT_SMTP_PORT ? parseInt(process.env.INFRA_REPORT_SMTP_PORT, 10) : undefined,
+    secure: process.env.INFRA_REPORT_SMTP_SECURE === 'true',
+    user: process.env.INFRA_REPORT_SMTP_USER,
+    pass: process.env.INFRA_REPORT_SMTP_PASS,
+    from: process.env.INFRA_REPORT_FROM,
+    to: process.env.INFRA_REPORT_TO
+  };
+}
+
+function createTransportIfNeeded(config) {
+  const signature = JSON.stringify(config);
+  if (transporter && cachedConfigSignature === signature) {
+    return transporter;
+  }
+
+  if (!config.host || !config.port || !config.user || !config.pass || !config.from || !config.to) {
+    return null;
+  }
+
+  transporter = nodemailer.createTransport({
+    host: config.host,
+    port: config.port,
+    secure: config.secure,
+    auth: {
+      user: config.user,
+      pass: config.pass
+    }
+  });
+  cachedConfigSignature = signature;
+  return transporter;
+}
+
+async function sendMonitoringFailFallbackEmail(subject, text, html) {
+  const config = loadConfig();
+  const mailer = createTransportIfNeeded(config);
+
+  if (!mailer) {
+    console.warn('[MonitoringFallbackEmail] SMTP configuration missing, skipping email send');
+    return false;
+  }
+
+  const recipients = config.to.split(',').map(addr => addr.trim()).filter(Boolean);
+  if (recipients.length === 0) {
+    console.warn('[MonitoringFallbackEmail] No recipients configured in INFRA_REPORT_TO');
+    return false;
+  }
+
+  try {
+    const result = await mailer.sendMail({
+      from: config.from,
+      to: recipients,
+      subject,
+      text,
+      html
+    });
+    console.log('[MonitoringFallbackEmail] Email sent successfully', {
+      messageId: result.messageId,
+      response: result.response,
+      accepted: result.accepted,
+      rejected: result.rejected
+    });
+    return true;
+  } catch (error) {
+    console.error('[MonitoringFallbackEmail] Failed to send email:', {
+      message: error.message,
+      code: error.code,
+      command: error.command,
+      response: error.response,
+      responseCode: error.responseCode
+    });
+    return false;
+  }
+}
+
+module.exports = {
+  sendMonitoringFailFallbackEmail
+};
+
+

package/tests/unit/monitoringFallbackEmail.test.js

@@ -0,0 +1,57 @@
+'use strict';
+
+jest.mock('nodemailer', () => {
+  return {
+    createTransport: jest.fn(() => ({
+      sendMail: jest.fn().mockResolvedValue(true)
+    }))
+  };
+});
+
+describe('monitoringFallbackEmail', () => {
+  const ORIGINAL_ENV = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...ORIGINAL_ENV };
+  });
+
+  afterEach(() => {
+    process.env = ORIGINAL_ENV;
+  });
+
+  function loadReporter() {
+    return require('../../src/reporting/monitoringFallbackEmail');
+  }
+
+  test('returns false when SMTP config missing', async () => {
+    delete process.env.INFRA_REPORT_SMTP_HOST;
+    const { sendMonitoringFailFallbackEmail } = loadReporter();
+    const result = await sendMonitoringFailFallbackEmail('t', 't', '<p>t</p>');
+    expect(result).toBe(false);
+  });
+
+  test('sends email when SMTP config provided', async () => {
+    process.env.INFRA_REPORT_SMTP_HOST = 'smtp.example.com';
+    process.env.INFRA_REPORT_SMTP_PORT = '587';
+    process.env.INFRA_REPORT_SMTP_SECURE = 'false';
+    process.env.INFRA_REPORT_SMTP_USER = 'user@example.com';
+    process.env.INFRA_REPORT_SMTP_PASS = 'secret';
+    process.env.INFRA_REPORT_FROM = 'infra@example.com';
+    process.env.INFRA_REPORT_TO = 'ops@example.com';
+
+    const nodemailer = require('nodemailer');
+    const transportMock = {
+      sendMail: jest.fn().mockResolvedValue(true)
+    };
+    nodemailer.createTransport.mockReturnValue(transportMock);
+
+    const { sendMonitoringFailFallbackEmail } = loadReporter();
+    const result = await sendMonitoringFailFallbackEmail('Subject', 'Body', '<p>Body</p>');
+
+    expect(result).toBe(true);
+    expect(transportMock.sendMail).toHaveBeenCalledTimes(1);
+  });
+});
+
+