claude-flow-novice 2.2.3 → 2.2.4

package/dist/scripts/monitoring/resource-monitor.sh

@@ -0,0 +1,126 @@
+#!/bin/bash
+# Resource monitoring script for 100-agent coordination test
+# Tracks memory, CPU, file descriptors, processes, and disk I/O
+
+set -euo pipefail
+
+# Configuration
+SAMPLE_INTERVAL=1
+OUTPUT_DIR="${1:-./monitoring-results}"
+TIMESTAMP=$(date +%Y%m%d_%H%M%S)
+CSV_FILE="${OUTPUT_DIR}/resource-usage-${TIMESTAMP}.csv"
+LOG_FILE="${OUTPUT_DIR}/monitor-${TIMESTAMP}.log"
+PID_FILE="${OUTPUT_DIR}/monitor.pid"
+
+# Create output directory
+mkdir -p "${OUTPUT_DIR}"
+
+# Store monitor PID for cleanup
+echo $$ > "${PID_FILE}"
+
+# Cleanup function
+cleanup() {
+    echo "[$(date +%H:%M:%S)] Monitoring stopped. Results: ${CSV_FILE}" | tee -a "${LOG_FILE}"
+    rm -f "${PID_FILE}"
+    exit 0
+}
+
+trap cleanup SIGINT SIGTERM
+
+# Initialize CSV with headers
+echo "timestamp,elapsed_sec,memory_rss_mb,memory_vsz_mb,memory_shm_mb,cpu_percent,fd_count,process_count,node_processes,io_read_mb,io_write_mb" > "${CSV_FILE}"
+
+echo "[$(date +%H:%M:%S)] Resource monitoring started" | tee -a "${LOG_FILE}"
+echo "[$(date +%H:%M:%S)] Output: ${CSV_FILE}" | tee -a "${LOG_FILE}"
+echo "[$(date +%H:%M:%S)] Sampling every ${SAMPLE_INTERVAL}s" | tee -a "${LOG_FILE}"
+
+# Baseline metrics
+START_TIME=$(date +%s)
+BASELINE_IO_READ=0
+BASELINE_IO_WRITE=0
+
+# Get baseline I/O if available
+if [ -f /proc/diskstats ]; then
+    BASELINE_IO_READ=$(awk '/sda/ {sum+=$6} END {print sum}' /proc/diskstats 2>/dev/null || echo 0)
+    BASELINE_IO_WRITE=$(awk '/sda/ {sum+=$10} END {print sum}' /proc/diskstats 2>/dev/null || echo 0)
+fi
+
+# Monitoring loop
+while true; do
+    CURRENT_TIME=$(date +%s)
+    ELAPSED=$((CURRENT_TIME - START_TIME))
+    TIMESTAMP=$(date +%Y-%m-%d_%H:%M:%S)
+
+    # Memory metrics (RSS and VSZ for all node processes)
+    MEMORY_RSS=0
+    MEMORY_VSZ=0
+    if pgrep -f "node|npm" > /dev/null 2>&1; then
+        MEMORY_RSS=$(ps aux | grep -E "node|npm" | grep -v grep | awk '{sum+=$6} END {print sum/1024}' || echo 0)
+        MEMORY_VSZ=$(ps aux | grep -E "node|npm" | grep -v grep | awk '{sum+=$5} END {print sum/1024}' || echo 0)
+    fi
+
+    # Shared memory (tmpfs /dev/shm)
+    MEMORY_SHM=0
+    if [ -d /dev/shm ]; then
+        MEMORY_SHM=$(du -sm /dev/shm 2>/dev/null | cut -f1 || echo 0)
+    fi
+
+    # CPU usage (average across all node processes)
+    CPU_PERCENT=0
+    if pgrep -f "node|npm" > /dev/null 2>&1; then
+        CPU_PERCENT=$(ps aux | grep -E "node|npm" | grep -v grep | awk '{sum+=$3} END {print sum}' || echo 0)
+    fi
+
+    # File descriptor count (sample from first node process for speed)
+    FD_COUNT=0
+    FIRST_NODE_PID=$(pgrep -f "node|npm" 2>/dev/null | head -1 | tr -d '\n' || echo "")
+    if [ -n "${FIRST_NODE_PID}" ] && [ -d "/proc/${FIRST_NODE_PID}/fd" ]; then
+        FD_COUNT=$(ls "/proc/${FIRST_NODE_PID}/fd" 2>/dev/null | wc -l | tr -d '\n' || echo 0)
+    fi
+
+    # Process count (all node/npm processes) - ensure single line
+    PROCESS_COUNT=$(pgrep -f "node|npm" 2>/dev/null | wc -l | tr -d '\n' || echo 0)
+    NODE_PROCESSES=$(pgrep -f "node" 2>/dev/null | wc -l | tr -d '\n' || echo 0)
+
+    # Disk I/O (if available via /proc/diskstats)
+    IO_READ_MB=0
+    IO_WRITE_MB=0
+    if [ -f /proc/diskstats ]; then
+        CURRENT_IO_READ=$(awk '/sda/ {sum+=$6} END {print sum}' /proc/diskstats 2>/dev/null || echo 0)
+        CURRENT_IO_WRITE=$(awk '/sda/ {sum+=$10} END {print sum}' /proc/diskstats 2>/dev/null || echo 0)
+        IO_READ_MB=$(echo "scale=2; ($CURRENT_IO_READ - $BASELINE_IO_READ) * 512 / 1024 / 1024" | bc 2>/dev/null || echo 0)
+        IO_WRITE_MB=$(echo "scale=2; ($CURRENT_IO_WRITE - $BASELINE_IO_WRITE) * 512 / 1024 / 1024" | bc 2>/dev/null || echo 0)
+    fi
+
+    # Round floating point values
+    MEMORY_RSS=$(printf "%.2f" "${MEMORY_RSS}")
+    MEMORY_VSZ=$(printf "%.2f" "${MEMORY_VSZ}")
+    CPU_PERCENT=$(printf "%.2f" "${CPU_PERCENT}")
+
+    # Write CSV row
+    echo "${TIMESTAMP},${ELAPSED},${MEMORY_RSS},${MEMORY_VSZ},${MEMORY_SHM},${CPU_PERCENT},${FD_COUNT},${PROCESS_COUNT},${NODE_PROCESSES},${IO_READ_MB},${IO_WRITE_MB}" >> "${CSV_FILE}"
+
+    # Log significant events
+    if (( $(echo "${MEMORY_RSS} > 5000" | bc -l 2>/dev/null || echo 0) )); then
+        echo "[$(date +%H:%M:%S)] WARNING: High memory usage: ${MEMORY_RSS}MB RSS" | tee -a "${LOG_FILE}"
+    fi
+
+    if (( $(echo "${CPU_PERCENT} > 80" | bc -l 2>/dev/null || echo 0) )); then
+        echo "[$(date +%H:%M:%S)] WARNING: High CPU usage: ${CPU_PERCENT}%" | tee -a "${LOG_FILE}"
+    fi
+
+    if [ "${FD_COUNT}" -gt 10000 ]; then
+        echo "[$(date +%H:%M:%S)] WARNING: High FD count: ${FD_COUNT}" | tee -a "${LOG_FILE}"
+    fi
+
+    if [ "${PROCESS_COUNT}" -gt 500 ]; then
+        echo "[$(date +%H:%M:%S)] WARNING: High process count: ${PROCESS_COUNT}" | tee -a "${LOG_FILE}"
+    fi
+
+    # Progress indicator every 10 seconds
+    if [ $((ELAPSED % 10)) -eq 0 ] && [ "${ELAPSED}" -gt 0 ]; then
+        echo "[$(date +%H:%M:%S)] ${ELAPSED}s | MEM: ${MEMORY_RSS}MB | CPU: ${CPU_PERCENT}% | FD: ${FD_COUNT} | PROC: ${PROCESS_COUNT}" | tee -a "${LOG_FILE}"
+    fi
+
+    sleep "${SAMPLE_INTERVAL}"
+done

package/dist/scripts/monitoring/stability-monitor.js

@@ -0,0 +1,429 @@
+#!/usr/bin/env node
+/**
+ * 50-Agent Stability Test Memory Monitor
+ * WSL2-optimized, 8-hour duration, <1% overhead
+ */
+
+import fs from 'fs/promises';
+import { createWriteStream } from 'fs';
+import v8 from 'v8';
+import { spawn, execSync } from 'child_process';
+import os from 'os';
+
+class StabilityMonitor {
+  constructor(config = {}) {
+    this.config = {
+      outputPath: config.outputPath || './stability-results',
+      samplingInterval: config.samplingInterval || 1000, // 1s
+      baselineDelay: config.baselineDelay || 120000,     // 2 min
+      leakThreshold: config.leakThreshold || 0.10,       // 10%
+      fdThreshold: config.fdThreshold || 10000,
+      maxSamples: config.maxSamples || 28800,            // 8 hours at 1s
+      ...config
+    };
+
+    this.baseline = null;
+    this.measurements = [];
+    this.alerts = [];
+    this.jsonlStream = null;
+    this.startTime = Date.now();
+    this.running = false;
+  }
+
+  async start() {
+    console.log('🚀 Starting 8-hour stability test monitor...');
+    console.log(`   Sampling interval: ${this.config.samplingInterval}ms`);
+    console.log(`   Leak threshold: ${(this.config.leakThreshold * 100).toFixed(1)}%`);
+    console.log(`   Output: ${this.config.outputPath}`);
+
+    // Ensure output directory exists
+    await fs.mkdir(this.config.outputPath, { recursive: true });
+
+    // Initialize JSONL stream
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const filename = `metrics-${timestamp}.jsonl`;
+    this.jsonlStream = createWriteStream(`${this.config.outputPath}/${filename}`);
+    console.log(`   Log file: ${filename}`);
+
+    // Establish baseline after delay
+    setTimeout(() => this.establishBaseline(), this.config.baselineDelay);
+
+    // Start collection loop
+    this.running = true;
+    this.collectionInterval = setInterval(() => this.collect(), this.config.samplingInterval);
+
+    // Summary reports every 10 minutes
+    this.reportInterval = setInterval(() => this.printSummary(), 600000);
+
+    // Graceful shutdown handlers
+    process.on('SIGINT', () => this.shutdown('SIGINT'));
+    process.on('SIGTERM', () => this.shutdown('SIGTERM'));
+
+    console.log('✅ Monitor started. Establishing baseline in 2 minutes...\n');
+  }
+
+  async collect() {
+    if (!this.running) return;
+
+    const timestamp = Date.now();
+    const mem = process.memoryUsage();
+    const heap = v8.getHeapStatistics();
+    const resources = process.resourceUsage();
+
+    // Collect metrics
+    const metrics = {
+      timestamp,
+      elapsed: timestamp - this.startTime,
+      memory: {
+        rss: mem.rss,
+        heapUsed: mem.heapUsed,
+        heapTotal: mem.heapTotal,
+        external: mem.external,
+        arrayBuffers: mem.arrayBuffers
+      },
+      heap: {
+        totalSize: heap.total_heap_size,
+        usedSize: heap.used_heap_size,
+        limit: heap.heap_size_limit,
+        mallocedMemory: heap.malloced_memory,
+        peakMalloced: heap.peak_malloced_memory
+      },
+      resources: {
+        userCPU: resources.userCPUTime,
+        systemCPU: resources.systemCPUTime,
+        maxRSS: resources.maxRSS
+      },
+      fds: await this.getFileDescriptorCount(),
+      proc: await this.getProcMemory(),
+      system: await this.getSystemMetrics()
+    };
+
+    // Store and analyze
+    this.measurements.push(metrics);
+
+    // Keep memory bounded
+    if (this.measurements.length > this.config.maxSamples) {
+      this.measurements.shift();
+    }
+
+    // Write to JSONL
+    this.jsonlStream.write(JSON.stringify(metrics) + '\n');
+
+    // Leak detection every 5 minutes
+    if (this.baseline && this.measurements.length % 300 === 0) {
+      const leak = this.detectLeak();
+      if (leak.detected) {
+        this.alerts.push({ timestamp, type: 'memory_leak', data: leak });
+        console.warn(`\n⚠️  [${new Date(timestamp).toISOString()}] MEMORY LEAK DETECTED`);
+        console.warn(`    Growth: ${leak.growthPercent}% (${leak.growthMB} MB)`);
+        console.warn(`    Severity: ${leak.severity}`);
+        console.warn(`    Projected 8h: ${leak.projectedGrowth8h.toFixed(2)} MB\n`);
+      }
+    }
+
+    // FD leak detection
+    if (metrics.fds > this.config.fdThreshold) {
+      const fdLeak = {
+        timestamp,
+        count: metrics.fds,
+        growth: this.baseline ? metrics.fds - this.baseline.fds : 0
+      };
+      this.alerts.push({ timestamp, type: 'fd_leak', data: fdLeak });
+      console.warn(`\n⚠️  [${new Date(timestamp).toISOString()}] FD LEAK DETECTED`);
+      console.warn(`    Open FDs: ${metrics.fds} (threshold: ${this.config.fdThreshold})\n`);
+    }
+  }
+
+  async getFileDescriptorCount() {
+    try {
+      const fdPath = `/proc/${process.pid}/fd`;
+      const files = await fs.readdir(fdPath);
+      return files.length;
+    } catch {
+      return 0;
+    }
+  }
+
+  async getProcMemory() {
+    try {
+      const statusPath = `/proc/${process.pid}/status`;
+      const status = await fs.readFile(statusPath, 'utf8');
+
+      const extract = (key) => {
+        const match = status.match(new RegExp(`${key}:\\s+(\\d+)`));
+        return match ? parseInt(match[1]) * 1024 : 0; // Convert kB to bytes
+      };
+
+      return {
+        vmRSS: extract('VmRSS'),
+        vmSize: extract('VmSize'),
+        rssAnon: extract('RssAnon'),
+        rssFile: extract('RssFile')
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  async getSystemMetrics() {
+    try {
+      // Memory usage from /proc/meminfo
+      const meminfo = await fs.readFile('/proc/meminfo', 'utf8');
+      const memTotal = parseInt(meminfo.match(/MemTotal:\s+(\d+)/)[1]) * 1024;
+      const memAvailable = parseInt(meminfo.match(/MemAvailable:\s+(\d+)/)[1]) * 1024;
+      const memUsed = memTotal - memAvailable;
+
+      // tmpfs usage
+      const tmpfsOutput = execSync('df -B1 /dev/shm', { encoding: 'utf8' });
+      const tmpfsLines = tmpfsOutput.trim().split('\n');
+      const tmpfsParts = tmpfsLines[1].split(/\s+/);
+      const tmpfsTotal = parseInt(tmpfsParts[1]);
+      const tmpfsUsed = parseInt(tmpfsParts[2]);
+
+      // Load average
+      const loadavg = os.loadavg();
+
+      return {
+        memory: {
+          total: memTotal,
+          used: memUsed,
+          available: memAvailable,
+          utilizationPct: (memUsed / memTotal * 100).toFixed(1)
+        },
+        tmpfs: {
+          total: tmpfsTotal,
+          used: tmpfsUsed,
+          available: tmpfsTotal - tmpfsUsed,
+          utilizationPct: (tmpfsUsed / tmpfsTotal * 100).toFixed(1)
+        },
+        loadavg: {
+          '1min': loadavg[0],
+          '5min': loadavg[1],
+          '15min': loadavg[2]
+        }
+      };
+    } catch (error) {
+      console.error('Failed to get system metrics:', error.message);
+      return null;
+    }
+  }
+
+  establishBaseline() {
+    if (this.measurements.length === 0) return;
+
+    this.baseline = this.measurements[this.measurements.length - 1];
+    console.log('📊 Baseline established:');
+    console.log(`   RSS: ${(this.baseline.memory.rss / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`   Heap: ${(this.baseline.memory.heapUsed / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`   FDs: ${this.baseline.fds}`);
+    if (this.baseline.system) {
+      console.log(`   System memory: ${this.baseline.system.memory.utilizationPct}%`);
+      console.log(`   tmpfs: ${this.baseline.system.tmpfs.utilizationPct}%`);
+    }
+    console.log('');
+  }
+
+  detectLeak() {
+    if (!this.baseline || this.measurements.length < 300) {
+      return { detected: false };
+    }
+
+    const current = this.measurements[this.measurements.length - 1];
+    const growth = (current.memory.rss - this.baseline.memory.rss) / this.baseline.memory.rss;
+
+    // Calculate trend (linear regression on last 5 minutes)
+    const recentWindow = this.measurements.slice(-300);
+    const slope = this.calculateSlope(recentWindow.map(m => m.memory.rss));
+
+    const projectedGrowth8h = (slope * 28800) / 1024 / 1024;
+
+    return {
+      detected: growth > this.config.leakThreshold || slope > 0.001,
+      growthPercent: (growth * 100).toFixed(2),
+      growthMB: ((current.memory.rss - this.baseline.memory.rss) / 1024 / 1024).toFixed(2),
+      slopePerSecond: slope,
+      projectedGrowth8h,
+      severity: this.assessSeverity(growth, slope)
+    };
+  }
+
+  calculateSlope(values) {
+    const n = values.length;
+    if (n < 2) return 0;
+
+    const sumX = (n * (n - 1)) / 2;
+    const sumY = values.reduce((a, b) => a + b, 0);
+    const sumXY = values.reduce((sum, y, x) => sum + x * y, 0);
+    const sumX2 = (n * (n - 1) * (2 * n - 1)) / 6;
+
+    return (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
+  }
+
+  assessSeverity(growth, slope) {
+    if (growth > 0.15 || slope > 0.002) return 'CRITICAL';
+    if (growth > 0.10 || slope > 0.001) return 'HIGH';
+    if (growth > 0.05 || slope > 0.0005) return 'MEDIUM';
+    return 'LOW';
+  }
+
+  printSummary() {
+    if (this.measurements.length === 0) return;
+
+    const current = this.measurements[this.measurements.length - 1];
+    const elapsed = (current.timestamp - this.startTime) / 1000 / 3600; // hours
+
+    console.log(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    console.log(`📈 STABILITY TEST SUMMARY (${elapsed.toFixed(2)}h elapsed)`);
+    console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    console.log(`Memory RSS:  ${(current.memory.rss / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`Heap Used:   ${(current.memory.heapUsed / 1024 / 1024).toFixed(2)} MB`);
+    console.log(`Open FDs:    ${current.fds}`);
+    console.log(`Samples:     ${this.measurements.length}`);
+    console.log(`Alerts:      ${this.alerts.length}`);
+
+    if (this.baseline) {
+      const growth = ((current.memory.rss - this.baseline.memory.rss) / this.baseline.memory.rss * 100).toFixed(2);
+      console.log(`Growth:      ${growth}% (threshold: ${(this.config.leakThreshold * 100).toFixed(1)}%)`);
+    }
+
+    if (current.system) {
+      console.log(`System RAM:  ${current.system.memory.utilizationPct}%`);
+      console.log(`tmpfs:       ${current.system.tmpfs.utilizationPct}%`);
+      console.log(`Load (1m):   ${current.system.loadavg['1min'].toFixed(2)}`);
+    }
+
+    console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
+  }
+
+  async shutdown(signal) {
+    console.log(`\n\n🛑 Received ${signal}, shutting down gracefully...`);
+    this.running = false;
+
+    clearInterval(this.collectionInterval);
+    clearInterval(this.reportInterval);
+
+    if (this.jsonlStream) {
+      this.jsonlStream.end();
+    }
+
+    // Generate final report
+    await this.generateReport();
+
+    console.log('✅ Monitor stopped. Report generated.');
+    process.exit(0);
+  }
+
+  async generateReport() {
+    if (this.measurements.length === 0) return;
+
+    const first = this.measurements[0];
+    const last = this.measurements[this.measurements.length - 1];
+    const maxRss = this.measurements.reduce((max, m) => Math.max(max, m.memory.rss), 0);
+    const avgRss = this.measurements.reduce((sum, m) => sum + m.memory.rss, 0) / this.measurements.length;
+    const maxFds = this.measurements.reduce((max, m) => Math.max(max, m.fds), 0);
+
+    const report = {
+      test: {
+        duration: (last.timestamp - first.timestamp) / 1000,
+        samples: this.measurements.length,
+        startTime: new Date(first.timestamp).toISOString(),
+        endTime: new Date(last.timestamp).toISOString(),
+        samplingInterval: this.config.samplingInterval
+      },
+      memory: {
+        initial: first.memory.rss,
+        final: last.memory.rss,
+        max: maxRss,
+        avg: avgRss,
+        growth: ((last.memory.rss - first.memory.rss) / first.memory.rss * 100).toFixed(2) + '%',
+        growthMB: ((last.memory.rss - first.memory.rss) / 1024 / 1024).toFixed(2)
+      },
+      heap: {
+        initial: first.memory.heapUsed,
+        final: last.memory.heapUsed,
+        growth: ((last.memory.heapUsed - first.memory.heapUsed) / first.memory.heapUsed * 100).toFixed(2) + '%'
+      },
+      fds: {
+        initial: first.fds,
+        final: last.fds,
+        max: maxFds,
+        growth: last.fds - first.fds
+      },
+      system: last.system,
+      alerts: this.alerts,
+      result: this.determineResult()
+    };
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const reportFile = `${this.config.outputPath}/report-${timestamp}.json`;
+    await fs.writeFile(reportFile, JSON.stringify(report, null, 2));
+
+    console.log('\n' + JSON.stringify(report, null, 2));
+    console.log(`\n📄 Report saved to: ${reportFile}`);
+  }
+
+  determineResult() {
+    if (!this.baseline || this.measurements.length < 10) {
+      return { status: 'INSUFFICIENT_DATA', message: 'Test ran for less than 10 seconds' };
+    }
+
+    const last = this.measurements[this.measurements.length - 1];
+    const growth = (last.memory.rss - this.baseline.memory.rss) / this.baseline.memory.rss;
+    const fdGrowth = last.fds - this.baseline.fds;
+
+    const memoryLeak = growth >= this.config.leakThreshold;
+    const fdLeak = last.fds >= this.config.fdThreshold;
+    const hasAlerts = this.alerts.length > 0;
+
+    const passed = !memoryLeak && !fdLeak && !hasAlerts;
+
+    return {
+      status: passed ? 'PASS' : 'FAIL',
+      memoryLeakDetected: memoryLeak,
+      fdLeakDetected: fdLeak,
+      alertCount: this.alerts.length,
+      memoryGrowthPercent: (growth * 100).toFixed(2),
+      fdGrowth: fdGrowth,
+      message: passed ? 'All stability criteria met' : 'Stability issues detected'
+    };
+  }
+}
+
+// CLI interface
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  const config = {};
+
+  // Parse command line arguments
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--output' && args[i + 1]) {
+      config.outputPath = args[++i];
+    } else if (args[i] === '--interval' && args[i + 1]) {
+      config.samplingInterval = parseInt(args[++i]);
+    } else if (args[i] === '--threshold' && args[i + 1]) {
+      config.leakThreshold = parseFloat(args[++i]);
+    } else if (args[i] === '--fd-threshold' && args[i + 1]) {
+      config.fdThreshold = parseInt(args[++i]);
+    } else if (args[i] === '--help') {
+      console.log(`
+Usage: node stability-monitor.js [options]
+
+Options:
+  --output <path>         Output directory for results (default: ./stability-results)
+  --interval <ms>         Sampling interval in milliseconds (default: 1000)
+  --threshold <percent>   Memory leak threshold (default: 0.10 = 10%)
+  --fd-threshold <count>  File descriptor leak threshold (default: 10000)
+  --help                  Show this help
+
+Example:
+  node stability-monitor.js --output ./test-results --interval 5000 --threshold 0.05
+      `);
+      process.exit(0);
+    }
+  }
+
+  const monitor = new StabilityMonitor(config);
+  monitor.start();
+}
+
+export default StabilityMonitor;

package/dist/scripts/monitoring/test-monitor-quick.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+# Quick test to verify monitoring scripts work correctly
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TEST_DIR="${SCRIPT_DIR}/../../reports/monitoring/test-quick"
+
+echo "Quick Monitoring Test"
+echo "====================="
+echo ""
+
+# Cleanup old test data
+rm -rf "${TEST_DIR}"
+mkdir -p "${TEST_DIR}"
+
+# Start monitor
+echo "Starting monitor for 10 seconds..."
+"${SCRIPT_DIR}/resource-monitor.sh" "${TEST_DIR}" &
+MONITOR_PID=$!
+
+# Wait for monitor to initialize
+sleep 2
+
+# Let it collect some samples
+sleep 8
+
+# Stop monitor
+echo "Stopping monitor..."
+kill -TERM "${MONITOR_PID}" 2>/dev/null || true
+wait "${MONITOR_PID}" 2>/dev/null || true
+
+# Find CSV file
+CSV_FILE=$(find "${TEST_DIR}" -name "resource-usage-*.csv" -type f | head -1)
+
+if [ ! -f "${CSV_FILE}" ]; then
+    echo "ERROR: CSV file not created"
+    exit 1
+fi
+
+echo ""
+echo "CSV created: ${CSV_FILE}"
+echo "Sample count: $(tail -n +2 "${CSV_FILE}" | wc -l)"
+echo ""
+
+# Analyze
+echo "Running analysis..."
+"${SCRIPT_DIR}/analyze-resources.sh" "${CSV_FILE}"
+
+echo ""
+echo "✅ Monitoring test complete"
+echo ""
+echo "Files created:"
+ls -lh "${TEST_DIR}"