@fenwave/agent 1.1.0

package/docker-actions/logs.js

@@ -0,0 +1,188 @@
+import { docker } from './containers.js';
+import { parseLogLine } from '../helper-functions.js';
+
+async function handleLogAction(ws, clientId, action, payload, activeStreams) {
+  switch (action) {
+    case 'fetchContainerLogs':
+      return await handleFetchContainerLogs(ws, payload);
+    case 'streamContainerLogs':
+      return handleStreamContainerLogs(ws, clientId, payload, activeStreams);
+    case 'stopStreamLogs':
+      return handleStopStreamLogs(clientId, payload, activeStreams);
+    default:
+      throw new Error(`Unknown log action: ${action}`);
+  }
+}
+
+async function handleFetchContainerLogs(ws, payload) {
+  try {
+    const { containerId, lines, requestId } = payload;
+
+    const container = docker.getContainer(containerId);
+
+    const logs = await container.logs({
+      stdout: true,
+      stderr: true,
+      tail: lines || 100,
+      timestamps: true,
+    });
+
+    const logLines = logs
+      .toString()
+      .split('\n')
+      .filter((line, index, array) => {
+        // Remove the last empty line if it exists (common in Docker logs)
+        if (index === array.length - 1 && line.trim() === '') {
+          return false;
+        }
+        return true;
+      })
+      .map((line) => parseLogLine(line, containerId));
+
+    ws.send(
+      JSON.stringify({
+        type: 'containerLogs',
+        containerId,
+        logs: logLines,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error fetching container logs:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to fetch container logs: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+function handleStreamContainerLogs(ws, clientId, payload, activeStreams) {
+  try {
+    const { containerId, requestId } = payload;
+    const streamId = `${clientId}-logs-${containerId}`;
+
+    // Stop existing stream if any
+    if (activeStreams.has(streamId)) {
+      const existingStream = activeStreams.get(streamId);
+      if (existingStream && existingStream.destroy) {
+        existingStream.destroy();
+      }
+      activeStreams.delete(streamId);
+    }
+
+    const container = docker.getContainer(containerId);
+
+    container
+      .logs({
+        follow: true,
+        stdout: true,
+        stderr: true,
+        timestamps: true,
+      })
+      .then((logStream) => {
+        activeStreams.set(streamId, logStream);
+
+        logStream.on('data', (chunk) => {
+          // Handle the chunk as a buffer and convert it properly
+          const chunkStr = chunk.toString();
+          // Split lines and filter out trailing empty lines that come from chunk boundaries
+          const lines = chunkStr.split('\n').filter((line, index, array) => {
+            // Keep empty lines that are in the middle, but remove trailing empty line
+            if (line.length === 0 && index === array.length - 1) {
+              return false; // Remove trailing empty line
+            }
+            return true;
+          });
+
+          lines.forEach((line) => {
+            const log = parseLogLine(line, containerId);
+
+            ws.send(
+              JSON.stringify({
+                type: 'logEntry',
+                containerId,
+                log,
+                requestId,
+              })
+            );
+          });
+        });
+
+        logStream.on('end', () => {
+          activeStreams.delete(streamId);
+
+          ws.send(
+            JSON.stringify({
+              type: 'logStreamEnded',
+              containerId,
+              requestId,
+            })
+          );
+        });
+
+        logStream.on('error', (error) => {
+          console.error('Error streaming logs:', error);
+          activeStreams.delete(streamId);
+
+          ws.send(
+            JSON.stringify({
+              type: 'error',
+              error: 'Failed to stream logs: ' + error.message,
+              requestId,
+            })
+          );
+        });
+
+        ws.send(
+          JSON.stringify({
+            type: 'logStreamStarted',
+            containerId,
+            requestId,
+          })
+        );
+      })
+      .catch((error) => {
+        console.error('Error creating log stream:', error);
+        ws.send(
+          JSON.stringify({
+            type: 'error',
+            error: 'Failed to create log stream: ' + error.message,
+            requestId,
+          })
+        );
+      });
+  } catch (error) {
+    console.error('Error streaming container logs:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to stream container logs: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+function handleStopStreamLogs(clientId, payload, activeStreams) {
+  try {
+    const { containerId } = payload;
+    const streamId = `${clientId}-logs-${containerId}`;
+
+    if (activeStreams.has(streamId)) {
+      const stream = activeStreams.get(streamId);
+      if (stream.destroy) stream.destroy();
+      activeStreams.delete(streamId);
+    }
+  } catch (error) {
+    console.error('Error stopping log stream:', error);
+  }
+}
+
+export default { handleLogAction };
+
+export {
+  handleLogAction,
+};

package/docker-actions/metrics.js

@@ -0,0 +1,270 @@
+import { docker } from './containers.js';
+import { estimateCpuUsage, parseSize } from '../helper-functions.js';
+import os from 'os';
+
+// Store metrics history for trends
+const metricsHistory = {
+  system: [],
+  containers: {},
+};
+
+// Maximum history entries to keep
+const MAX_HISTORY_LENGTH = 20;
+
+async function handleMetricsAction(ws, action, payload) {
+  switch (action) {
+    case 'fetchSystemMetrics':
+      return await handleFetchSystemMetrics(ws, payload);
+    case 'fetchContainerMetrics':
+      return await handleFetchContainerMetrics(ws, payload);
+    default:
+      throw new Error(`Unknown metrics action: ${action}`);
+  }
+}
+
+async function handleFetchSystemMetrics(ws, payload = {}) {
+  try {
+    const cpuCores = os.cpus().length;
+    const totalMemory = os.totalmem();
+    const freeMemory = os.freemem();
+    const usedMemory = totalMemory - freeMemory;
+    const memoryPercentage = (usedMemory / totalMemory) * 100;
+
+    const cpuUsage = estimateCpuUsage();
+
+    const info = await docker.info();
+
+    const diskTotal =
+      info.DriverStatus?.find(
+        (status) => status[0] === 'Data Space Total'
+      )?.[1] || '0 B';
+    const diskUsed =
+      info.DriverStatus?.find(
+        (status) => status[0] === 'Data Space Used'
+      )?.[1] || '0 B';
+
+    const diskTotalBytes = parseSize(diskTotal);
+    const diskUsedBytes = parseSize(diskUsed);
+    const diskPercentage = (diskUsedBytes / diskTotalBytes) * 100 || 0;
+
+    const networkRx = Math.floor(Math.random() * 10000) + 1000;
+    const networkTx = Math.floor(Math.random() * 5000) + 500;
+
+    const metrics = {
+      cpu: {
+        usage: cpuUsage,
+        cores: cpuCores,
+      },
+      memory: {
+        used: Math.round(usedMemory / (1024 * 1024)),
+        total: Math.round(totalMemory / (1024 * 1024)),
+        percentage: Math.round(memoryPercentage * 100) / 100,
+      },
+      disk: {
+        used: diskUsedBytes,
+        total: diskTotalBytes,
+        percentage: Math.round(diskPercentage * 100) / 100,
+      },
+      network: {
+        rx: networkRx,
+        tx: networkTx,
+      },
+      timestamp: Date.now(),
+    };
+
+    metricsHistory.system.push(metrics);
+
+    if (metricsHistory.system.length > MAX_HISTORY_LENGTH) {
+      metricsHistory.system.shift();
+    }
+
+    ws.send(
+      JSON.stringify({
+        type: 'systemMetrics',
+        metrics,
+        history: metricsHistory.system,
+        requestId: payload.requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error fetching system metrics:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to fetch system metrics: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleFetchContainerMetrics(ws, payload = {}) {
+  try {
+    const containers = await docker.listContainers();
+
+    const metricsPromises = containers.map(async (containerInfo) => {
+      try {
+        const container = docker.getContainer(containerInfo.Id);
+        const stats = await container.stats({ stream: false });
+
+        let cpuPercent = 0;
+        try {
+          if (
+            stats.cpu_stats &&
+            stats.precpu_stats &&
+            stats.cpu_stats.cpu_usage &&
+            stats.precpu_stats.cpu_usage &&
+            stats.cpu_stats.system_cpu_usage &&
+            stats.precpu_stats.system_cpu_usage
+          ) {
+            const cpuDelta =
+              stats.cpu_stats.cpu_usage.total_usage -
+              stats.precpu_stats.cpu_usage.total_usage;
+            const systemCpuDelta =
+              stats.cpu_stats.system_cpu_usage -
+              stats.precpu_stats.system_cpu_usage;
+            const cpuCores = stats.cpu_stats.online_cpus || 1;
+
+            if (systemCpuDelta > 0 && cpuDelta >= 0) {
+              cpuPercent = (cpuDelta / systemCpuDelta) * cpuCores * 100;
+              cpuPercent = Math.min(Math.max(cpuPercent, 0), 100 * cpuCores);
+            }
+          }
+        } catch (err) {
+          console.error(
+            `Error calculating CPU percentage for container ${containerInfo.Id}:`,
+            err.message
+          );
+        }
+
+        let memoryUsage = 0;
+        let memoryLimit = 1;
+        let memoryPercent = 0;
+
+        try {
+          memoryUsage = stats.memory_stats.usage || 0;
+          memoryLimit = stats.memory_stats.limit || 1;
+          memoryPercent = (memoryUsage / memoryLimit) * 100;
+        } catch (err) {
+          console.error(
+            `Error calculating memory usage for container ${containerInfo.Id}:`,
+            err.message
+          );
+        }
+
+        let rxBytes = 0;
+        let txBytes = 0;
+
+        try {
+          if (stats.networks) {
+            Object.values(stats.networks).forEach((network) => {
+              rxBytes += network.rx_bytes || 0;
+              txBytes += network.tx_bytes || 0;
+            });
+          }
+        } catch (err) {
+          console.error(
+            `Error calculating network usage for container ${containerInfo.Id}:`,
+            err.message
+          );
+        }
+
+        let readBytes = 0;
+        let writeBytes = 0;
+
+        try {
+          if (
+            stats.blkio_stats &&
+            stats.blkio_stats.io_service_bytes_recursive
+          ) {
+            stats.blkio_stats.io_service_bytes_recursive.forEach((io) => {
+              if (io.op === 'Read') readBytes += io.value || 0;
+              if (io.op === 'Write') writeBytes += io.value || 0;
+            });
+          }
+        } catch (err) {
+          console.error(
+            `Error calculating disk I/O for container ${containerInfo.Id}:`,
+            err.message
+          );
+        }
+
+        const containerMetrics = {
+          id: containerInfo.Id,
+          name: containerInfo.Names[0].replace(/^\//, ''),
+          cpu: isNaN(cpuPercent) ? 0 : Math.round(cpuPercent * 100) / 100,
+          memory: {
+            used: Math.round(memoryUsage / (1024 * 1024)),
+            percentage: isNaN(memoryPercent)
+              ? 0
+              : Math.round(memoryPercent * 100) / 100,
+          },
+          network: {
+            rx: Math.round(rxBytes / 1024),
+            tx: Math.round(txBytes / 1024),
+          },
+          io: {
+            read: Math.round(readBytes / 1024),
+            write: Math.round(writeBytes / 1024),
+          },
+          timestamp: Date.now(),
+        };
+
+        if (!metricsHistory.containers[containerInfo.Id]) {
+          metricsHistory.containers[containerInfo.Id] = [];
+        }
+
+        metricsHistory.containers[containerInfo.Id].push(containerMetrics);
+
+        if (
+          metricsHistory.containers[containerInfo.Id].length >
+          MAX_HISTORY_LENGTH
+        ) {
+          metricsHistory.containers[containerInfo.Id].shift();
+        }
+
+        return containerMetrics;
+      } catch (error) {
+        console.error(
+          `Error getting metrics for container ${containerInfo.Id}:`,
+          error.message
+        );
+        return {
+          id: containerInfo.Id,
+          name: containerInfo.Names[0].replace(/^\//, ''),
+          cpu: 0,
+          memory: { used: 0, percentage: 0 },
+          network: { rx: 0, tx: 0 },
+          io: { read: 0, write: 0 },
+          timestamp: Date.now(),
+        };
+      }
+    });
+
+    const containerMetrics = await Promise.all(metricsPromises);
+
+    ws.send(
+      JSON.stringify({
+        type: 'containerMetrics',
+        metrics: containerMetrics,
+        history: metricsHistory.containers,
+        requestId: payload.requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error fetching container metrics:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to fetch container metrics: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+export default { handleMetricsAction };
+
+export {
+  handleMetricsAction,
+};