learning_ai_common_plat/services/monitoring/health-check.ts

/**
 * Monitoring & Health Check — aggregates health from all services.
 *
 * Standalone script that polls each service's /health endpoint and
 * reports combined status. Can be run as a cron job, GitHub Action,
 * or standalone HTTP endpoint.
 *
 * Usage:
 *   npx tsx services/monitoring/health-check.ts          # one-shot check
 *   npx tsx services/monitoring/health-check.ts --serve   # HTTP server on :4004
 *
 * Environment:
 *   BACKEND_URL          (default: http://localhost:8000)
 *   GROWTH_SERVICE_URL   (default: http://localhost:4001)
 *   BILLING_SERVICE_URL  (default: http://localhost:4002)
 *   PLATFORM_SERVICE_URL (default: http://localhost:4003)
 *   ADMIN_DASHBOARD_URL  (default: http://localhost:3001)
 *   USER_DASHBOARD_URL   (default: http://localhost:3002)
 */

export {};

interface ServiceCheck {
  name: string;
  url: string;
  status: 'healthy' | 'unhealthy' | 'unreachable';
  responseTimeMs: number;
  details?: Record<string, unknown>;
  error?: string;
}

interface HealthReport {
  overall: 'healthy' | 'degraded' | 'down';
  timestamp: string;
  services: ServiceCheck[];
  summary: { healthy: number; unhealthy: number; unreachable: number; total: number };
}

const SERVICES = [
  { name: 'Backend API', url: process.env.BACKEND_URL || 'http://localhost:8000', path: '/health' },
  {
    name: 'Growth Service',
    url: process.env.GROWTH_SERVICE_URL || 'http://localhost:4001',
    path: '/health',
  },
  {
    name: 'Billing Service',
    url: process.env.BILLING_SERVICE_URL || 'http://localhost:4002',
    path: '/health',
  },
  {
    name: 'Platform Service',
    url: process.env.PLATFORM_SERVICE_URL || 'http://localhost:4003',
    path: '/health',
  },
  {
    name: 'Admin Dashboard',
    url: process.env.ADMIN_DASHBOARD_URL || 'http://localhost:3001',
    path: '/api/health',
  },
  {
    name: 'User Dashboard',
    url: process.env.USER_DASHBOARD_URL || 'http://localhost:3002',
    path: '/api/health',
  },
];

async function checkService(svc: {
  name: string;
  url: string;
  path: string;
}): Promise<ServiceCheck> {
  const fullUrl = `${svc.url}${svc.path}`;
  const start = performance.now();

  try {
    const res = await fetch(fullUrl, { signal: AbortSignal.timeout(5_000) });
    const elapsed = Math.round(performance.now() - start);

    if (res.ok) {
      let details: Record<string, unknown> | undefined;
      try {
        details = (await res.json()) as Record<string, unknown>;
      } catch {
        /* ignore */
      }
      return { name: svc.name, url: svc.url, status: 'healthy', responseTimeMs: elapsed, details };
    }
    return {
      name: svc.name,
      url: svc.url,
      status: 'unhealthy',
      responseTimeMs: elapsed,
      error: `HTTP ${res.status}`,
    };
  } catch (err) {
    const elapsed = Math.round(performance.now() - start);
    return {
      name: svc.name,
      url: svc.url,
      status: 'unreachable',
      responseTimeMs: elapsed,
      error: String(err),
    };
  }
}

async function generateReport(): Promise<HealthReport> {
  const checks = await Promise.all(SERVICES.map(checkService));

  const healthy = checks.filter(c => c.status === 'healthy').length;
  const unhealthy = checks.filter(c => c.status === 'unhealthy').length;
  const unreachable = checks.filter(c => c.status === 'unreachable').length;

  let overall: HealthReport['overall'] = 'healthy';
  if (unreachable === checks.length) overall = 'down';
  else if (unhealthy > 0 || unreachable > 0) overall = 'degraded';

  return {
    overall,
    timestamp: new Date().toISOString(),
    services: checks,
    summary: { healthy, unhealthy, unreachable, total: checks.length },
  };
}

// ── CLI / HTTP server mode ──

const args = process.argv.slice(2);

if (args.includes('--serve')) {
  // Run as HTTP server for continuous monitoring
  const { createServer } = await import('http');
  const PORT = Number(process.env.MONITOR_PORT || 4004);

  const server = createServer(async (_req, res) => {
    const report = await generateReport();
    res.writeHead(report.overall === 'healthy' ? 200 : 503, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(report, null, 2));
  });

  server.listen(PORT, () => {
    console.log(`🩺 Monitoring dashboard running on http://localhost:${PORT}`);
    console.log(`   Checking ${SERVICES.length} services every request`);
  });
} else {
  // One-shot check
  const report = await generateReport();
  const icon = { healthy: '✅', degraded: '⚠️', down: '❌' };
  console.log(`\n${icon[report.overall]} Overall: ${report.overall.toUpperCase()}\n`);

  for (const svc of report.services) {
    const sIcon = { healthy: '✅', unhealthy: '⚠️', unreachable: '❌' };
    console.log(
      `  ${sIcon[svc.status]} ${svc.name.padEnd(20)} ${svc.responseTimeMs}ms${svc.error ? ` — ${svc.error}` : ''}`
    );
  }

  console.log(`\nHealthy: ${report.summary.healthy}/${report.summary.total}`);
  process.exit(report.overall === 'healthy' ? 0 : 1);
}