495 lines
14 KiB
JavaScript
495 lines
14 KiB
JavaScript
/**
|
|
* Container Resource Monitoring Module
|
|
* Tracks CPU, memory, disk, and network usage for Docker containers
|
|
* Provides alerts and historical data
|
|
*/
|
|
|
|
const Docker = require('dockerode');
|
|
const EventEmitter = require('events');
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
|
|
const docker = new Docker();
|
|
|
|
// Configuration
|
|
const STATS_FILE = process.env.STATS_FILE || path.join(__dirname, 'container-stats.json');
|
|
const ALERT_CONFIG_FILE = process.env.ALERT_CONFIG_FILE || path.join(__dirname, 'alert-config.json');
|
|
const STATS_RETENTION_HOURS = parseInt(process.env.STATS_RETENTION_HOURS || '168', 10); // 7 days default
|
|
const MONITORING_INTERVAL = parseInt(process.env.MONITORING_INTERVAL || '10000', 10); // 10 seconds
|
|
|
|
class ResourceMonitor extends EventEmitter {
|
|
constructor() {
|
|
super();
|
|
this.monitoring = false;
|
|
this.monitoringInterval = null;
|
|
this.stats = new Map(); // containerId -> array of stats
|
|
this.alerts = new Map(); // containerId -> alert config
|
|
this.lastAlerts = new Map(); // containerId -> last alert timestamp
|
|
|
|
this.loadStats();
|
|
this.loadAlertConfig();
|
|
}
|
|
|
|
/**
|
|
* Start monitoring all containers
|
|
*/
|
|
start() {
|
|
if (this.monitoring) {
|
|
console.log('[ResourceMonitor] Already monitoring');
|
|
return;
|
|
}
|
|
|
|
console.log('[ResourceMonitor] Starting container monitoring');
|
|
this.monitoring = true;
|
|
this.monitoringInterval = setInterval(() => this.collectStats(), MONITORING_INTERVAL);
|
|
|
|
// Initial collection
|
|
this.collectStats();
|
|
}
|
|
|
|
/**
|
|
* Stop monitoring
|
|
*/
|
|
stop() {
|
|
if (!this.monitoring) return;
|
|
|
|
console.log('[ResourceMonitor] Stopping container monitoring');
|
|
this.monitoring = false;
|
|
|
|
if (this.monitoringInterval) {
|
|
clearInterval(this.monitoringInterval);
|
|
this.monitoringInterval = null;
|
|
}
|
|
|
|
this.saveStats();
|
|
}
|
|
|
|
/**
|
|
* Collect stats from all running containers
|
|
*/
|
|
async collectStats() {
|
|
try {
|
|
const containers = await docker.listContainers({ all: false });
|
|
|
|
for (const containerInfo of containers) {
|
|
try {
|
|
const container = docker.getContainer(containerInfo.Id);
|
|
const stats = await this.getContainerStats(container);
|
|
|
|
if (stats) {
|
|
this.recordStats(containerInfo.Id, containerInfo.Names[0], stats);
|
|
this.checkAlerts(containerInfo.Id, containerInfo.Names[0], stats);
|
|
}
|
|
} catch (error) {
|
|
console.error(`[ResourceMonitor] Error collecting stats for ${containerInfo.Names[0]}:`, error.message);
|
|
}
|
|
}
|
|
|
|
// Cleanup old stats
|
|
this.cleanupOldStats();
|
|
|
|
// Persist stats periodically
|
|
if (Math.random() < 0.1) { // 10% chance to save (every ~100 seconds)
|
|
this.saveStats();
|
|
}
|
|
} catch (error) {
|
|
console.error('[ResourceMonitor] Error collecting container stats:', error.message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get stats for a single container
|
|
*/
|
|
async getContainerStats(container) {
|
|
return new Promise((resolve, reject) => {
|
|
container.stats({ stream: false }, (err, stats) => {
|
|
if (err) {
|
|
reject(err);
|
|
return;
|
|
}
|
|
|
|
// Calculate CPU percentage
|
|
const cpuDelta = stats.cpu_stats.cpu_usage.total_usage -
|
|
(stats.precpu_stats.cpu_usage?.total_usage || 0);
|
|
const systemDelta = stats.cpu_stats.system_cpu_usage -
|
|
(stats.precpu_stats.system_cpu_usage || 0);
|
|
const cpuPercent = systemDelta > 0 ? (cpuDelta / systemDelta) * 100 : 0;
|
|
|
|
// Calculate memory usage
|
|
const memoryUsage = stats.memory_stats.usage || 0;
|
|
const memoryLimit = stats.memory_stats.limit || 0;
|
|
const memoryPercent = memoryLimit > 0 ? (memoryUsage / memoryLimit) * 100 : 0;
|
|
|
|
// Calculate network I/O
|
|
let networkRx = 0;
|
|
let networkTx = 0;
|
|
if (stats.networks) {
|
|
Object.values(stats.networks).forEach(net => {
|
|
networkRx += net.rx_bytes || 0;
|
|
networkTx += net.tx_bytes || 0;
|
|
});
|
|
}
|
|
|
|
// Calculate block I/O
|
|
let blockRead = 0;
|
|
let blockWrite = 0;
|
|
if (stats.blkio_stats?.io_service_bytes_recursive) {
|
|
stats.blkio_stats.io_service_bytes_recursive.forEach(io => {
|
|
if (io.op === 'Read') blockRead += io.value;
|
|
if (io.op === 'Write') blockWrite += io.value;
|
|
});
|
|
}
|
|
|
|
resolve({
|
|
timestamp: new Date().toISOString(),
|
|
cpu: {
|
|
percent: Math.round(cpuPercent * 100) / 100,
|
|
usage: stats.cpu_stats.cpu_usage.total_usage
|
|
},
|
|
memory: {
|
|
usage: memoryUsage,
|
|
limit: memoryLimit,
|
|
percent: Math.round(memoryPercent * 100) / 100,
|
|
usageMB: Math.round(memoryUsage / 1024 / 1024),
|
|
limitMB: Math.round(memoryLimit / 1024 / 1024)
|
|
},
|
|
network: {
|
|
rxBytes: networkRx,
|
|
txBytes: networkTx,
|
|
rxMB: Math.round(networkRx / 1024 / 1024 * 100) / 100,
|
|
txMB: Math.round(networkTx / 1024 / 1024 * 100) / 100
|
|
},
|
|
disk: {
|
|
readBytes: blockRead,
|
|
writeBytes: blockWrite,
|
|
readMB: Math.round(blockRead / 1024 / 1024 * 100) / 100,
|
|
writeMB: Math.round(blockWrite / 1024 / 1024 * 100) / 100
|
|
},
|
|
pids: stats.pids_stats?.current || 0
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Record stats for a container
|
|
*/
|
|
recordStats(containerId, containerName, stats) {
|
|
if (!this.stats.has(containerId)) {
|
|
this.stats.set(containerId, {
|
|
name: containerName,
|
|
history: []
|
|
});
|
|
}
|
|
|
|
const containerStats = this.stats.get(containerId);
|
|
containerStats.name = containerName; // Update name in case it changed
|
|
containerStats.history.push(stats);
|
|
|
|
// Keep only recent stats (based on retention policy)
|
|
const cutoffTime = Date.now() - (STATS_RETENTION_HOURS * 60 * 60 * 1000);
|
|
containerStats.history = containerStats.history.filter(s =>
|
|
new Date(s.timestamp).getTime() > cutoffTime
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Check if any alerts should be triggered
|
|
*/
|
|
checkAlerts(containerId, containerName, stats) {
|
|
const alertConfig = this.alerts.get(containerId);
|
|
if (!alertConfig || !alertConfig.enabled) return;
|
|
|
|
const now = Date.now();
|
|
const lastAlert = this.lastAlerts.get(containerId) || 0;
|
|
const cooldown = (alertConfig.cooldownMinutes || 15) * 60 * 1000;
|
|
|
|
// Don't spam alerts - respect cooldown period
|
|
if (now - lastAlert < cooldown) return;
|
|
|
|
const alerts = [];
|
|
|
|
// Check CPU threshold
|
|
if (alertConfig.cpuThreshold && stats.cpu.percent > alertConfig.cpuThreshold) {
|
|
alerts.push({
|
|
type: 'cpu',
|
|
severity: 'warning',
|
|
message: `CPU usage ${stats.cpu.percent.toFixed(1)}% exceeds threshold ${alertConfig.cpuThreshold}%`,
|
|
value: stats.cpu.percent,
|
|
threshold: alertConfig.cpuThreshold
|
|
});
|
|
}
|
|
|
|
// Check memory threshold
|
|
if (alertConfig.memoryThreshold && stats.memory.percent > alertConfig.memoryThreshold) {
|
|
alerts.push({
|
|
type: 'memory',
|
|
severity: 'warning',
|
|
message: `Memory usage ${stats.memory.percent.toFixed(1)}% exceeds threshold ${alertConfig.memoryThreshold}%`,
|
|
value: stats.memory.percent,
|
|
threshold: alertConfig.memoryThreshold
|
|
});
|
|
}
|
|
|
|
// Check disk I/O threshold (MB/s)
|
|
if (alertConfig.diskIOThreshold) {
|
|
const diskIO = stats.disk.readMB + stats.disk.writeMB;
|
|
if (diskIO > alertConfig.diskIOThreshold) {
|
|
alerts.push({
|
|
type: 'disk',
|
|
severity: 'warning',
|
|
message: `Disk I/O ${diskIO.toFixed(1)} MB/s exceeds threshold ${alertConfig.diskIOThreshold} MB/s`,
|
|
value: diskIO,
|
|
threshold: alertConfig.diskIOThreshold
|
|
});
|
|
}
|
|
}
|
|
|
|
if (alerts.length > 0) {
|
|
this.lastAlerts.set(containerId, now);
|
|
|
|
this.emit('alert', {
|
|
containerId,
|
|
containerName,
|
|
timestamp: new Date().toISOString(),
|
|
alerts,
|
|
stats,
|
|
config: alertConfig
|
|
});
|
|
|
|
// Auto-restart if configured
|
|
if (alertConfig.autoRestart) {
|
|
this.restartContainer(containerId, containerName, alerts);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Restart a container due to resource alerts
|
|
*/
|
|
async restartContainer(containerId, containerName, alerts) {
|
|
try {
|
|
console.log(`[ResourceMonitor] Auto-restarting ${containerName} due to alerts:`, alerts.map(a => a.type).join(', '));
|
|
|
|
const container = docker.getContainer(containerId);
|
|
await container.restart();
|
|
|
|
this.emit('auto-restart', {
|
|
containerId,
|
|
containerName,
|
|
timestamp: new Date().toISOString(),
|
|
reason: alerts
|
|
});
|
|
} catch (error) {
|
|
console.error(`[ResourceMonitor] Failed to restart ${containerName}:`, error.message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get current stats for a container
|
|
*/
|
|
getCurrentStats(containerId) {
|
|
const containerStats = this.stats.get(containerId);
|
|
if (!containerStats || containerStats.history.length === 0) {
|
|
return null;
|
|
}
|
|
|
|
return containerStats.history[containerStats.history.length - 1];
|
|
}
|
|
|
|
/**
|
|
* Get historical stats for a container
|
|
*/
|
|
getHistoricalStats(containerId, hours = 24) {
|
|
const containerStats = this.stats.get(containerId);
|
|
if (!containerStats) return [];
|
|
|
|
const cutoffTime = Date.now() - (hours * 60 * 60 * 1000);
|
|
return containerStats.history.filter(s =>
|
|
new Date(s.timestamp).getTime() > cutoffTime
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get aggregated stats for a container
|
|
*/
|
|
getAggregatedStats(containerId, hours = 24) {
|
|
const history = this.getHistoricalStats(containerId, hours);
|
|
if (history.length === 0) return null;
|
|
|
|
const cpuValues = history.map(s => s.cpu.percent);
|
|
const memoryValues = history.map(s => s.memory.percent);
|
|
|
|
return {
|
|
cpu: {
|
|
current: cpuValues[cpuValues.length - 1],
|
|
avg: cpuValues.reduce((a, b) => a + b, 0) / cpuValues.length,
|
|
max: Math.max(...cpuValues),
|
|
min: Math.min(...cpuValues)
|
|
},
|
|
memory: {
|
|
current: memoryValues[memoryValues.length - 1],
|
|
avg: memoryValues.reduce((a, b) => a + b, 0) / memoryValues.length,
|
|
max: Math.max(...memoryValues),
|
|
min: Math.min(...memoryValues)
|
|
},
|
|
dataPoints: history.length,
|
|
timeRange: hours
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get stats for all containers
|
|
*/
|
|
getAllStats() {
|
|
const result = {};
|
|
|
|
for (const [containerId, data] of this.stats.entries()) {
|
|
const current = this.getCurrentStats(containerId);
|
|
const aggregated = this.getAggregatedStats(containerId, 24);
|
|
|
|
result[containerId] = {
|
|
name: data.name,
|
|
current,
|
|
aggregated,
|
|
alertConfig: this.alerts.get(containerId)
|
|
};
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Configure alerts for a container
|
|
*/
|
|
setAlertConfig(containerId, config) {
|
|
this.alerts.set(containerId, {
|
|
enabled: config.enabled !== false,
|
|
cpuThreshold: config.cpuThreshold || null,
|
|
memoryThreshold: config.memoryThreshold || null,
|
|
diskIOThreshold: config.diskIOThreshold || null,
|
|
cooldownMinutes: config.cooldownMinutes || 15,
|
|
autoRestart: config.autoRestart || false,
|
|
notificationChannels: config.notificationChannels || []
|
|
});
|
|
|
|
this.saveAlertConfig();
|
|
}
|
|
|
|
/**
|
|
* Get alert configuration for a container
|
|
*/
|
|
getAlertConfig(containerId) {
|
|
return this.alerts.get(containerId) || null;
|
|
}
|
|
|
|
/**
|
|
* Remove alert configuration
|
|
*/
|
|
removeAlertConfig(containerId) {
|
|
this.alerts.delete(containerId);
|
|
this.lastAlerts.delete(containerId);
|
|
this.saveAlertConfig();
|
|
}
|
|
|
|
/**
|
|
* Cleanup old stats beyond retention period
|
|
*/
|
|
cleanupOldStats() {
|
|
const cutoffTime = Date.now() - (STATS_RETENTION_HOURS * 60 * 60 * 1000);
|
|
|
|
for (const [containerId, data] of this.stats.entries()) {
|
|
data.history = data.history.filter(s =>
|
|
new Date(s.timestamp).getTime() > cutoffTime
|
|
);
|
|
|
|
// Remove container stats if no recent data
|
|
if (data.history.length === 0) {
|
|
this.stats.delete(containerId);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load stats from disk
|
|
*/
|
|
loadStats() {
|
|
try {
|
|
if (fs.existsSync(STATS_FILE)) {
|
|
const data = JSON.parse(fs.readFileSync(STATS_FILE, 'utf8'));
|
|
this.stats = new Map(Object.entries(data));
|
|
console.log(`[ResourceMonitor] Loaded stats for ${this.stats.size} containers`);
|
|
}
|
|
} catch (error) {
|
|
console.error('[ResourceMonitor] Error loading stats:', error.message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save stats to disk
|
|
*/
|
|
saveStats() {
|
|
try {
|
|
const data = Object.fromEntries(this.stats);
|
|
fs.writeFileSync(STATS_FILE, JSON.stringify(data, null, 2));
|
|
} catch (error) {
|
|
console.error('[ResourceMonitor] Error saving stats:', error.message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Load alert configuration from disk
|
|
*/
|
|
loadAlertConfig() {
|
|
try {
|
|
if (fs.existsSync(ALERT_CONFIG_FILE)) {
|
|
const data = JSON.parse(fs.readFileSync(ALERT_CONFIG_FILE, 'utf8'));
|
|
this.alerts = new Map(Object.entries(data));
|
|
console.log(`[ResourceMonitor] Loaded alert config for ${this.alerts.size} containers`);
|
|
}
|
|
} catch (error) {
|
|
console.error('[ResourceMonitor] Error loading alert config:', error.message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save alert configuration to disk
|
|
*/
|
|
saveAlertConfig() {
|
|
try {
|
|
const data = Object.fromEntries(this.alerts);
|
|
fs.writeFileSync(ALERT_CONFIG_FILE, JSON.stringify(data, null, 2));
|
|
} catch (error) {
|
|
console.error('[ResourceMonitor] Error saving alert config:', error.message);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Export stats for backup
|
|
*/
|
|
exportStats() {
|
|
return {
|
|
stats: Object.fromEntries(this.stats),
|
|
alerts: Object.fromEntries(this.alerts),
|
|
exportedAt: new Date().toISOString()
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Import stats from backup
|
|
*/
|
|
importStats(data) {
|
|
if (data.stats) {
|
|
this.stats = new Map(Object.entries(data.stats));
|
|
}
|
|
if (data.alerts) {
|
|
this.alerts = new Map(Object.entries(data.alerts));
|
|
}
|
|
this.saveStats();
|
|
this.saveAlertConfig();
|
|
}
|
|
}
|
|
|
|
// Export singleton instance
|
|
module.exports = new ResourceMonitor();
|