dashcaddy/dashcaddy-api/routes/monitoring.js

/**
 * Monitoring and stats routes
 * Refactored to use explicit dependencies
 */

const express = require('express');
const asyncHandler = require('../src/utils/async-handler');

module.exports = function({ docker, resourceMonitor }) {
  const router = express.Router();

  // ===== RESOURCE MONITORING ENDPOINTS =====

  router.get('/monitoring/stats', asyncHandler(async (req, res) => {
    const stats = resourceMonitor.getAllStats();
    res.json({ success: true, stats });
  }, 'monitoring-stats'));

  router.get('/monitoring/stats/:containerId', asyncHandler(async (req, res) => {
    const stats = resourceMonitor.getCurrentStats(req.params.containerId);
    if (!stats) {
      const { NotFoundError } = require('../errors');
      throw new NotFoundError('Container');
    }
    res.json({ success: true, stats });
  }, 'monitoring-stats-container'));

  router.get('/monitoring/history/:containerId', asyncHandler(async (req, res) => {
    const hours = parseInt(req.query.hours) || 24;
    const history = resourceMonitor.getHistoricalStats(req.params.containerId, hours);
    res.json({ success: true, history, hours });
  }, 'monitoring-history'));

  router.get('/monitoring/aggregated/:containerId', asyncHandler(async (req, res) => {
    const hours = parseInt(req.query.hours) || 24;
    const aggregated = resourceMonitor.getAggregatedStats(req.params.containerId, hours);
    if (!aggregated) {
      const { NotFoundError } = require('../errors');
      throw new NotFoundError('Monitoring data');
    }
    res.json({ success: true, aggregated, hours });
  }, 'monitoring-aggregated'));

  router.post('/monitoring/alerts/:containerId', asyncHandler(async (req, res) => {
    resourceMonitor.setAlertConfig(req.params.containerId, req.body);
    res.json({ success: true, message: 'Alert configuration saved' });
  }, 'monitoring-alerts-set'));

  router.get('/monitoring/alerts/:containerId', asyncHandler(async (req, res) => {
    const config = resourceMonitor.getAlertConfig(req.params.containerId);
    res.json({ success: true, config: config || {} });
  }, 'monitoring-alerts-get'));

  router.delete('/monitoring/alerts/:containerId', asyncHandler(async (req, res) => {
    resourceMonitor.removeAlertConfig(req.params.containerId);
    res.json({ success: true, message: 'Alert configuration removed' });
  }, 'monitoring-alerts-delete'));

  // ===== CONTAINER STATS ENDPOINTS (legacy /stats/) =====

  router.get('/stats/containers', asyncHandler(async (req, res) => {
    const containers = await docker.client.listContainers({ all: false });
    const stats = [];

    for (const containerInfo of containers) {
      try {
        const container = docker.client.getContainer(containerInfo.Id);
        const containerStats = await container.stats({ stream: false });

        const cpuDelta = containerStats.cpu_stats.cpu_usage.total_usage -
                        (containerStats.precpu_stats.cpu_usage?.total_usage || 0);
        const systemDelta = containerStats.cpu_stats.system_cpu_usage -
                           (containerStats.precpu_stats.system_cpu_usage || 0);
        const cpuPercent = systemDelta > 0 ? (cpuDelta / systemDelta) * 100 * (containerStats.cpu_stats.online_cpus || 1) : 0;

        const memUsage = containerStats.memory_stats.usage || 0;
        const memLimit = containerStats.memory_stats.limit || 1;
        const memPercent = (memUsage / memLimit) * 100;

        let netRx = 0, netTx = 0;
        if (containerStats.networks) {
          for (const net of Object.values(containerStats.networks)) {
            netRx += net.rx_bytes || 0;
            netTx += net.tx_bytes || 0;
          }
        }

        stats.push({
          id: containerInfo.Id.slice(0, 12),
          name: containerInfo.Names[0]?.replace(/^\//, '') || 'unknown',
          image: containerInfo.Image,
          status: containerInfo.State,
          cpu: { percent: Math.round(cpuPercent * 100) / 100 },
          memory: {
            used: memUsage,
            limit: memLimit,
            percent: Math.round(memPercent * 100) / 100,
          },
          network: { rx: netRx, tx: netTx },
        });
      } catch (e) {
        console.log(`Could not get stats for ${containerInfo.Names[0]}:`, e.message);
      }
    }

    res.json({ success: true, stats, timestamp: new Date().toISOString() });
  }, 'stats-containers'));

  router.get('/stats/container/:id', asyncHandler(async (req, res) => {
    const container = docker.client.getContainer(req.params.id);
    const containerStats = await container.stats({ stream: false });
    const info = await container.inspect();

    const cpuDelta = containerStats.cpu_stats.cpu_usage.total_usage -
                    (containerStats.precpu_stats.cpu_usage?.total_usage || 0);
    const systemDelta = containerStats.cpu_stats.system_cpu_usage -
                       (containerStats.precpu_stats.system_cpu_usage || 0);
    const cpuPercent = systemDelta > 0 ? (cpuDelta / systemDelta) * 100 * (containerStats.cpu_stats.online_cpus || 1) : 0;

    const memUsage = containerStats.memory_stats.usage || 0;
    const memLimit = containerStats.memory_stats.limit || 1;

    let netRx = 0, netTx = 0;
    if (containerStats.networks) {
      for (const net of Object.values(containerStats.networks)) {
        netRx += net.rx_bytes || 0;
        netTx += net.tx_bytes || 0;
      }
    }

    res.json({
      success: true,
      stats: {
        name: info.Name.replace(/^\//, ''),
        image: info.Config.Image,
        status: info.State.Status,
        started: info.State.StartedAt,
        cpu: { percent: Math.round(cpuPercent * 100) / 100 },
        memory: {
          used: memUsage,
          limit: memLimit,
          percent: Math.round((memUsage / memLimit) * 100 * 100) / 100,
        },
        network: { rx: netRx, tx: netTx },
      },
    });
  }, 'stats-container'));

  return router;
};