DashDescomplicar/api/services/monitoring-collector.ts

/**
 * Monitoring Data Collector
 * HTTP health checks for services + EasyPanel API metrics + staleness detection
 * Runs every 5 minutes via scheduler in server.ts
 * @author Descomplicar® | @link descomplicar.pt | @copyright 2026
 */
import db from '../db.js'

interface ServiceCheck {
  name: string
  url: string
  okStatuses?: number[] // Additional HTTP codes to treat as 'up' (e.g. 403 for gateway)
}

interface CheckResult {
  status: 'up' | 'down' | 'warning'
  http_code: number
  response_time: number
  error?: string
}

/**
 * Services to monitor via HTTP health check.
 * Each entry maps to a record in tbl_eal_monitoring (category='service').
 */
const SERVICES: ServiceCheck[] = [
  { name: 'Desk CRM', url: 'https://desk.descomplicar.pt' },
  { name: 'NextCloud', url: 'https://cloud.descomplicar.pt' },
  { name: 'Gitea', url: 'https://git.descomplicar.pt' },
  { name: 'Wiki.js', url: 'https://wiki.descomplicar.pt' },
  { name: 'Syncthing', url: 'https://sync.descomplicar.pt' },
  { name: 'Authentik', url: 'https://auth.descomplicar.pt' },
  { name: 'Metabase', url: 'https://bi.descomplicar.pt' },
  { name: 'N8N', url: 'https://automator.descomplicar.pt' },
  { name: 'Outline', url: 'https://hub.descomplicar.pt' },
  { name: 'WhatSMS', url: 'https://app.whatsms.pt' },
  { name: 'MCP Gateway', url: 'http://gateway.descomplicar.pt', okStatuses: [403] },
]

/**
 * Check a single URL and return health status.
 * Uses redirect: 'manual' so 302 (auth redirects) count as 'up'.
 */
async function checkUrl(url: string, timeoutMs = 10000): Promise<CheckResult> {
  const start = Date.now()
  try {
    const controller = new AbortController()
    const timeout = setTimeout(() => controller.abort(), timeoutMs)

    const response = await fetch(url, {
      method: 'GET',
      redirect: 'manual',
      signal: controller.signal,
    })

    clearTimeout(timeout)
    const response_time = Date.now() - start
    const http_code = response.status

    // 2xx or 3xx = service is responding
    if (http_code >= 200 && http_code < 400) {
      return { status: 'up', http_code, response_time }
    }
    // 4xx = service responds but with client error
    if (http_code >= 400 && http_code < 500) {
      return { status: 'warning', http_code, response_time }
    }
    // 5xx = server error
    return { status: 'down', http_code, response_time }
  } catch (error: unknown) {
    const response_time = Date.now() - start
    const message = error instanceof Error ? error.message : 'Unknown error'
    if (message.includes('abort')) {
      return { status: 'down', http_code: 0, response_time, error: 'Timeout' }
    }
    return { status: 'down', http_code: 0, response_time, error: message }
  }
}

/**
 * Update or insert a monitoring record.
 * Tries UPDATE first; if no row matches, does INSERT.
 */
async function upsertMonitoring(category: string, name: string, status: string, details: object): Promise<void> {
  const detailsJson = JSON.stringify(details)

  const [result] = await db.query(
    `UPDATE tbl_eal_monitoring SET status = ?, details = ?, last_check = NOW() WHERE category = ? AND name = ?`,
    [status, detailsJson, category, name]
  )

  if ((result as any).affectedRows === 0) {
    await db.query(
      `INSERT INTO tbl_eal_monitoring (category, name, status, details, last_check) VALUES (?, ?, ?, ?, NOW())`,
      [category, name, status, detailsJson]
    )
  }
}

/**
 * Check all services via HTTP and update DB.
 * Runs all checks in parallel for speed.
 */
export async function checkAllServices(): Promise<{ checked: number; up: number; down: number; warning: number }> {
  let up = 0, down = 0, warning = 0

  const results = await Promise.allSettled(
    SERVICES.map(async (service) => {
      const result = await checkUrl(service.url)

      // Override status if HTTP code is in the service's okStatuses list
      if (result.status === 'warning' && service.okStatuses?.includes(result.http_code)) {
        result.status = 'up'
      }

      await upsertMonitoring('service', service.name, result.status, {
        url: service.url,
        http_code: result.http_code,
        response_time: `${result.response_time}ms`,
        ...(result.error ? { error: result.error } : {})
      })

      return { name: service.name, ...result }
    })
  )

  for (const r of results) {
    if (r.status === 'fulfilled') {
      if (r.value.status === 'up') up++
      else if (r.value.status === 'warning') warning++
      else down++
    } else {
      down++
    }
  }

  return { checked: SERVICES.length, up, down, warning }
}

/**
 * Mark WP sites as warning if they haven't reported in >24h.
 * The WP plugin (descomplicar-monitor) POSTs data periodically.
 * If no data arrives, something is wrong.
 */
export async function checkStaleness(): Promise<number> {
  const [result] = await db.query(
    `UPDATE tbl_eal_monitoring
     SET status = 'warning',
         details = JSON_SET(COALESCE(details, '{}'), '$.stale', true, '$.stale_reason', 'No data received in 24h')
     WHERE category = 'wordpress'
       AND status IN ('ok', 'up')
       AND last_check < DATE_SUB(NOW(), INTERVAL 24 HOUR)`
  )
  return (result as any).affectedRows || 0
}

/**
 * Collect EasyPanel server metrics + container stats via SSH.
 * A API tRPC do EasyPanel não expõe endpoint monitor.* nesta versão.
 * SSH com password ao Easy server (5.9.90.70) funciona a partir do container.
 */
export async function collectEasyPanelMetrics(): Promise<boolean> {
  const { collectSSHMetrics } = await import('./server-metrics.js')
  const result = await collectSSHMetrics()
  return result.success > 0
}

/**
 * Collect Docker Swarm service status via SSH to EasyPanel server.
 * Usa `docker service ls` para obter replicas actual vs desired.
 */
export async function collectEasyPanelContainers(): Promise<boolean> {
  const easyHost = process.env.EASY_HOST || '5.9.90.70'
  const easyUser = process.env.EASY_USER || 'root'
  const easyPass = process.env.EASY_PASS || ''

  if (!easyPass) return false

  try {
    const { Client } = await import('ssh2')
    const output = await new Promise<string>((resolve, reject) => {
      const conn = new Client()
      let data = ''
      const timer = setTimeout(() => { conn.end(); reject(new Error('timeout')) }, 20000)

      conn.on('ready', () => {
        conn.exec("docker service ls --format '{{.Name}} {{.Replicas}}'", (err, stream) => {
          if (err) { clearTimeout(timer); conn.end(); reject(err); return }
          stream.on('data', (chunk: Buffer) => { data += chunk.toString() })
          stream.on('close', () => { clearTimeout(timer); conn.end(); resolve(data) })
          stream.stderr.on('data', () => {})
        })
      })
      conn.on('error', (err) => { clearTimeout(timer); reject(err) })
      conn.connect({ host: easyHost, port: 22, username: easyUser, password: easyPass, readyTimeout: 15000 })
    })

    let total = 0, up = 0, down = 0
    const unhealthy: string[] = []

    for (const line of output.trim().split('\n')) {
      if (!line.trim()) continue
      const parts = line.trim().split(/\s+/)
      const name = parts[0] || ''
      const replicas = parts[1] || '0/0'
      const [actual, desired] = replicas.split('/').map(Number)
      total++
      if (actual >= desired && desired > 0) {
        up++
      } else {
        down++
        unhealthy.push(name.replace('descomplicar_', ''))
      }
    }

    const status = down > 0 ? 'warning' : 'ok'
    await upsertMonitoring('container', 'EasyPanel Containers', status, {
      total, up, down, restarting: 0,
      ...(unhealthy.length > 0 ? { unhealthy } : {}),
    })

    console.log(`[EASYPANEL] Containers: ${up}/${total} running${down > 0 ? `, ${down} down: ${unhealthy.join(', ')}` : ''}`)
    return true
  } catch (err: unknown) {
    console.error('[EASYPANEL] Container collection failed:', err instanceof Error ? err.message : err)
    return false
  }
}

/**
 * Main collector entry point.
 * Called by scheduler in server.ts every 5 minutes.
 */
export async function collectMonitoringData(): Promise<void> {
  console.log('[COLLECTOR] Starting monitoring collection...')

  try {
    const services = await checkAllServices()
    console.log(`[COLLECTOR] Services: ${services.up} up, ${services.warning} warning, ${services.down} down`)
  } catch (err: unknown) {
    console.error('[COLLECTOR] Service checks failed:', err instanceof Error ? err.message : err)
  }

  // EasyPanel API metrics (replaces SSH for Easy server)
  try {
    const gotStats = await collectEasyPanelMetrics()
    const gotContainers = await collectEasyPanelContainers()
    if (!gotStats && !gotContainers) {
      console.warn('[COLLECTOR] EasyPanel metrics unavailable (check EASY_HOST/EASY_USER/EASY_PASS)')
    }
  } catch (err: unknown) {
    console.error('[COLLECTOR] EasyPanel collection failed:', err instanceof Error ? err.message : err)
  }

  try {
    const stale = await checkStaleness()
    if (stale > 0) {
      console.log(`[COLLECTOR] Marked ${stale} stale WP site(s) as warning`)
    }
  } catch (err: unknown) {
    console.error('[COLLECTOR] Staleness check failed:', err instanceof Error ? err.message : err)
  }

  console.log('[COLLECTOR] Done')
}