dashcam 1.4.5-beta.0 → 1.4.9-beta

package/LINUX_PERF_FIX.md

@@ -0,0 +1,184 @@
+# Linux Performance Tracking Fixes
+
+## Problem
+Performance data from dashcam-cli-minimal was not working on Ubuntu Linux.
+
+## Root Causes Identified
+
+### 1. **ps command compatibility**
+- Some Linux distributions (especially minimal/container images) use BusyBox `ps` which doesn't support the `--sort` option
+- The code was failing when trying to use `ps --sort=-pcpu`
+
+### 2. **Missing error handling**
+- Insufficient logging made it hard to diagnose where the performance tracking was failing
+- No fallback mechanisms when certain system calls failed
+
+### 3. **Network metrics parsing**
+- The macOS netstat parsing had an off-by-one error in the parts length check
+- Could cause network metrics to fail silently
+
+### 4. **Import optimization**
+- The Linux network code was using `await import('fs')` dynamically when `fs` was already imported at the top
+
+## Fixes Applied
+
+### topProcesses.js
+1. **Added fallback for ps --sort**:
+   ```javascript
+   try {
+     // Try with --sort first
+     const result = await execFileAsync('ps', ['-eo', 'pid,pcpu,pmem,comm', '--sort=-pcpu'], ...);
+   } catch (sortError) {
+     // Fallback to unsorted and sort in JavaScript
+     const result = await execFileAsync('ps', ['-eo', 'pid,pcpu,pmem,comm'], ...);
+   }
+   ```
+
+2. **Improved parsing with filtering**:
+   - Now filters out invalid entries (pid <= 0)
+   - Handles missing/undefined CPU and memory values
+   - Always sorts by CPU in JavaScript as a backup
+
+3. **Added timeouts**:
+   - All process listings now have 5-10 second timeouts to prevent hanging
+
+### performanceTracker.js
+1. **Fixed network metrics**:
+   - Corrected macOS netstat parsing (parts.length >= 10 instead of >= 7)
+   - Removed redundant `await import('fs')` on Linux
+   - Already using `fs` from the top-level import
+
+2. **Enhanced error handling**:
+   - All metric collection methods now have comprehensive try/catch blocks
+   - Graceful degradation - if one metric fails, others continue
+   - Better logging with platform and error context
+
+3. **Improved logging**:
+   - Added debug logs for successful operations
+   - More detailed error messages including platform info
+   - Stack traces for debugging
+
+## Testing
+
+### Quick Test (10 seconds)
+```bash
+cd dashcam-cli-minimal
+node test-perf-linux.js
+```
+
+This will:
+- Test `pidusage` library
+- Test `getTopProcesses` function
+- Test network metrics reading
+- Test system metrics
+- Run full performance tracker for 10 seconds
+- Show detailed results and identify any failures
+
+### Full Recording Test
+```bash
+# Start a recording with performance tracking
+dashcam start
+
+# Do some work for 10-15 seconds
+# ...
+
+# Stop recording  
+dashcam stop
+
+# Check the output for performance data
+```
+
+### Expected Output
+The test should show:
+```
+✓ pidusage: PASS
+✓ topProcesses: PASS  
+✓ networkMetrics: PASS
+✓ systemMetrics: PASS
+✓ performanceTracker: PASS
+
+Overall: ✓ ALL TESTS PASSED
+```
+
+## Platform-Specific Notes
+
+### Ubuntu/Debian
+- Should work on all versions
+- Uses `/proc/net/dev` for network stats
+- Falls back if `ps --sort` not available
+
+### Alpine Linux / Docker
+- BusyBox `ps` detected automatically
+- Sorts processes in JavaScript instead
+- May have limited network stats in containers
+
+### CentOS/RHEL
+- Full GNU ps support
+- Should use `--sort` option
+- Full network stats available
+
+## Troubleshooting
+
+### If performance data is still empty:
+
+1. **Check pidusage works**:
+   ```bash
+   node -e "import('pidusage').then(m => m.default(process.pid).then(console.log))"
+   ```
+
+2. **Check ps command**:
+   ```bash
+   ps -eo pid,pcpu,pmem,comm --sort=-pcpu | head -5
+   # If this fails, try:
+   ps -eo pid,pcpu,pmem,comm | head -5
+   ```
+
+3. **Check /proc/net/dev exists**:
+   ```bash
+   cat /proc/net/dev
+   ```
+
+4. **Run with verbose logging**:
+   ```bash
+   dashcam start --verbose
+   # ... do work ...
+   dashcam stop --verbose
+   ```
+
+5. **Check the performance file directly**:
+   ```bash
+   # Look for performance.jsonl in the output directory
+   cat ~/.dashcam/recordings/*/performance.jsonl | head -1 | jq
+   ```
+
+## What Gets Tracked
+
+Even with the fixes, the following is tracked every 5 seconds:
+
+- ✅ Process CPU usage (dashcam process)
+- ✅ Process memory usage (dashcam process)
+- ✅ System-wide memory usage
+- ✅ System CPU core count
+- ✅ Top 10 processes by CPU
+- ✅ Network I/O (where available)
+
+## API Upload
+
+The performance data is uploaded to the API with the recording:
+
+```javascript
+{
+  performance: {
+    samples: [...], // Array of samples taken during recording
+    summary: {      // Aggregated statistics
+      avgProcessCPU: 12.3,
+      maxProcessCPU: 18.7,
+      avgProcessMemoryMB: 128.0,
+      maxProcessMemoryMB: 192.0,
+      // ...
+    }
+  }
+}
+```
+
+This data is then displayed in the web UI under the "Performance" tab.

package/lib/performanceTracker.js

@@ -1,7 +1,7 @@
 import os from 'os';
 import { logger } from './logger.js';
 import pidusage from 'pidusage';
-import { getTopProcesses } from './topProcesses.js';
+import { getTopProcesses, cleanupPowerShell } from './topProcesses.js';
 import fs from 'fs';
 import path from 'path';
 
@@ -40,7 +40,7 @@ class PerformanceTracker {
           
           for (const line of lines) {
             const parts = line.trim().split(/\s+/);
-            if (parts.length >= 7 && parts[0] !== 'Name') {
+            if (parts.length >= 10 && parts[0] !== 'Name') {
               const ibytes = parseInt(parts[6]) || 0;
               const obytes = parseInt(parts[9]) || 0;
               totalBytesReceived += ibytes;
@@ -52,7 +52,6 @@ class PerformanceTracker {
         }
       } else if (process.platform === 'linux') {
         // Linux - read from /proc/net/dev
-        const fs = await import('fs');
         try {
           const netDev = fs.readFileSync('/proc/net/dev', 'utf8');
           const lines = netDev.split('\n');
@@ -157,6 +156,13 @@ class PerformanceTracker {
   async getProcessMetrics() {
     try {
       const stats = await pidusage(this.pid);
+      
+      logger.debug('Process metrics collected', {
+        cpu: stats.cpu?.toFixed(2),
+        memoryMB: (stats.memory / (1024 * 1024)).toFixed(1),
+        pid: stats.pid
+      });
+      
       return {
         process: {
           cpu: stats.cpu, // CPU usage percentage
@@ -169,7 +175,11 @@ class PerformanceTracker {
         }
       };
     } catch (error) {
-      logger.warn('Failed to get process metrics', { error: error.message });
+      logger.warn('Failed to get process metrics', { 
+        error: error.message,
+        pid: this.pid,
+        platform: process.platform
+      });
       return {
         process: {
           cpu: 0,
@@ -189,12 +199,21 @@ class PerformanceTracker {
       const topProcs = await getTopProcesses(10);
       
       if (!topProcs || topProcs.length === 0) {
+        logger.debug('No top processes returned', { 
+          platform: process.platform 
+        });
         return {
           topProcesses: [],
           totalProcesses: 0
         };
       }
       
+      logger.debug('Top processes fetched', { 
+        count: topProcs.length,
+        platform: process.platform,
+        firstProcess: topProcs[0]?.name
+      });
+      
       // Get detailed stats using pidusage for each process
       const detailedStats = [];
       for (const proc of topProcs) {
@@ -213,6 +232,7 @@ class PerformanceTracker {
           // Process might have exited, use basic data from ps/PowerShell
           logger.debug('Failed to get detailed stats for process, using basic data', { 
             pid: proc.pid, 
+            name: proc.name,
             error: error.message 
           });
           detailedStats.push({
@@ -233,7 +253,11 @@ class PerformanceTracker {
         totalProcesses: topProcs.length
       };
     } catch (error) {
-      logger.warn('Failed to get top processes', { error: error.message });
+      logger.warn('Failed to get top processes', { 
+        error: error.message,
+        platform: process.platform,
+        stack: error.stack
+      });
       return {
         topProcesses: [],
         totalProcesses: 0
@@ -478,6 +502,11 @@ class PerformanceTracker {
       }
     }
     this.performanceFile = null;
+    
+    // Cleanup PowerShell instance on Windows
+    if (process.platform === 'win32') {
+      cleanupPowerShell();
+    }
   }
 }
 

package/lib/topProcesses.js

@@ -1,25 +1,186 @@
-import { execFile } from 'child_process';
+import { execFile, spawn } from 'child_process';
 import { promisify } from 'util';
 import os from 'os';
 import { logger } from './logger.js';
 
 const execFileAsync = promisify(execFile);
 
+// Persistent PowerShell instance for Windows
+let persistentPowerShell = null;
+let psCommandQueue = [];
+let psProcessing = false;
+
+/**
+ * Initialize a persistent PowerShell instance for Windows
+ */
+function initPersistentPowerShell() {
+  if (persistentPowerShell) {
+    return persistentPowerShell;
+  }
+
+  logger.debug('Initializing persistent PowerShell instance');
+
+  const ps = spawn('powershell.exe', [
+    '-NoLogo',
+    '-NoProfile',
+    '-NonInteractive',
+    '-WindowStyle', 'Hidden',
+    '-Command', '-'
+  ], {
+    windowsHide: true,
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+
+  let outputBuffer = '';
+  const DELIMITER = '---END-OF-COMMAND---';
+
+  ps.stdout.on('data', (data) => {
+    outputBuffer += data.toString();
+    
+    // Check if we have a complete response
+    const delimiterIndex = outputBuffer.indexOf(DELIMITER);
+    if (delimiterIndex !== -1) {
+      const output = outputBuffer.substring(0, delimiterIndex);
+      outputBuffer = outputBuffer.substring(delimiterIndex + DELIMITER.length);
+      
+      // Resolve the pending command
+      if (psCommandQueue.length > 0) {
+        const { resolve } = psCommandQueue.shift();
+        resolve(output);
+        psProcessing = false;
+        processNextCommand();
+      }
+    }
+  });
+
+  ps.stderr.on('data', (data) => {
+    logger.debug('PowerShell stderr:', data.toString());
+  });
+
+  ps.on('close', (code) => {
+    logger.debug('PowerShell process closed', { code });
+    persistentPowerShell = null;
+    // Reject all pending commands
+    while (psCommandQueue.length > 0) {
+      const { reject } = psCommandQueue.shift();
+      reject(new Error('PowerShell process closed'));
+    }
+  });
+
+  ps.on('error', (error) => {
+    logger.warn('PowerShell process error', { error: error.message });
+    persistentPowerShell = null;
+  });
+
+  persistentPowerShell = ps;
+  persistentPowerShell.delimiter = DELIMITER;
+  
+  return ps;
+}
+
+/**
+ * Process the next command in the queue
+ */
+function processNextCommand() {
+  if (psProcessing || psCommandQueue.length === 0) {
+    return;
+  }
+
+  psProcessing = true;
+  const { command } = psCommandQueue[0];
+  
+  try {
+    persistentPowerShell.stdin.write(command + '\n');
+    persistentPowerShell.stdin.write(`Write-Host '${persistentPowerShell.delimiter}'\n`);
+  } catch (error) {
+    logger.warn('Failed to write to PowerShell stdin', { error: error.message });
+    const { reject } = psCommandQueue.shift();
+    reject(error);
+    psProcessing = false;
+    processNextCommand();
+  }
+}
+
+/**
+ * Execute a command in the persistent PowerShell instance
+ */
+function execPowerShellCommand(command, timeout = 10000) {
+  return new Promise((resolve, reject) => {
+    const ps = initPersistentPowerShell();
+    
+    const timeoutId = setTimeout(() => {
+      reject(new Error('PowerShell command timeout'));
+    }, timeout);
+
+    psCommandQueue.push({
+      command,
+      resolve: (output) => {
+        clearTimeout(timeoutId);
+        resolve(output);
+      },
+      reject: (error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      }
+    });
+
+    processNextCommand();
+  });
+}
+
+/**
+ * Cleanup the persistent PowerShell instance
+ */
+export function cleanupPowerShell() {
+  if (persistentPowerShell) {
+    logger.debug('Cleaning up persistent PowerShell instance');
+    try {
+      persistentPowerShell.stdin.end();
+      persistentPowerShell.kill();
+    } catch (error) {
+      logger.debug('Error cleaning up PowerShell', { error: error.message });
+    }
+    persistentPowerShell = null;
+  }
+}
+
 /**
  * Parse ps output format: "  PID %CPU %MEM COMMAND"
  */
 function parsePsOutput(stdout, limit) {
+  logger.debug('Parsing ps output', { 
+    outputLength: stdout.length,
+    firstLine: stdout.split('\n')[0],
+    lineCount: stdout.split('\n').length
+  });
+  
   const lines = stdout.trim().split('\n');
+  
+  if (lines.length === 0) {
+    logger.warn('ps output is empty');
+    return [];
+  }
+  
   // Skip header line
-  return lines.slice(1, 1 + limit).map(line => {
+  const processes = lines.slice(1).map(line => {
     const parts = line.trim().split(/\s+/, 4);
     return {
       pid: Number(parts[0]),
-      cpu: Number(parts[1]),
-      mem: Number(parts[2]),
+      cpu: Number(parts[1]) || 0,
+      mem: Number(parts[2]) || 0,
       name: parts[3] || ''
     };
+  }).filter(proc => proc.pid > 0); // Filter out invalid entries
+  
+  logger.debug('Parsed processes', { 
+    count: processes.length,
+    sample: processes.slice(0, 3)
   });
+  
+  // Sort by CPU descending (in case ps doesn't support --sort)
+  processes.sort((a, b) => b.cpu - a.cpu);
+  
+  return processes.slice(0, limit);
 }
 
 /**
@@ -32,24 +193,67 @@ async function getTopProcessesUnix(limit = 10) {
     if (os.platform() === 'darwin') {
       // macOS uses BSD ps - different syntax, no --sort option
       // Use -r flag to sort by CPU usage
+      console.log('[topProcesses] Running macOS ps command');
       const result = await execFileAsync('ps', [
         '-Arco',
         'pid,pcpu,pmem,comm'
-      ], { encoding: 'utf8' });
+      ], { encoding: 'utf8', timeout: 5000 });
       stdout = result.stdout;
+      console.log('[topProcesses] macOS ps succeeded, output length:', stdout.length);
     } else {
-      // Linux uses GNU ps - supports --sort
-      const result = await execFileAsync('ps', [
-        '-eo',
-        'pid,pcpu,pmem,comm',
-        '--sort=-pcpu'
-      ], { encoding: 'utf8' });
-      stdout = result.stdout;
+      // Linux - try different variations in order of preference
+      const psVariations = [
+        // Standard GNU ps with --sort
+        { args: ['-eo', 'pid,pcpu,pmem,comm', '--sort=-pcpu'], name: 'GNU ps with --sort' },
+        // GNU ps without --sort (we'll sort in JS)
+        { args: ['-eo', 'pid,pcpu,pmem,comm'], name: 'GNU ps without --sort' },
+        // BusyBox ps (minimal options)
+        { args: ['-o', 'pid,pcpu,pmem,comm'], name: 'BusyBox ps' },
+        // Most basic ps command
+        { args: ['aux'], name: 'basic ps aux' }
+      ];
+      
+      let psSuccess = false;
+      for (const variation of psVariations) {
+        try {
+          console.log(`[topProcesses] Trying: ${variation.name}`);
+          const result = await execFileAsync('ps', variation.args, { 
+            encoding: 'utf8', 
+            timeout: 5000 
+          });
+          stdout = result.stdout;
+          console.log(`[topProcesses] ${variation.name} succeeded, output length:`, stdout.length);
+          logger.debug(`ps command succeeded: ${variation.name}`, { outputLength: stdout.length });
+          psSuccess = true;
+          break;
+        } catch (err) {
+          console.log(`[topProcesses] ${variation.name} failed:`, err.message);
+          // Try next variation
+        }
+      }
+      
+      if (!psSuccess) {
+        throw new Error('All ps command variations failed');
+      }
     }
     
-    return parsePsOutput(stdout, limit);
+    console.log('[topProcesses] Parsing ps output...');
+    const processes = parsePsOutput(stdout, limit);
+    console.log('[topProcesses] Parsed', processes.length, 'processes');
+    logger.debug('Parsed processes from ps output', { 
+      processCount: processes.length,
+      firstProcess: processes[0]
+    });
+    
+    return processes;
   } catch (error) {
-    logger.warn('Failed to get top processes on Unix', { error: error.message });
+    console.error('[topProcesses] FATAL ERROR getting top processes:', error.message);
+    console.error('[topProcesses] Error stack:', error.stack);
+    logger.warn('Failed to get top processes on Unix', { 
+      error: error.message,
+      stack: error.stack,
+      platform: os.platform()
+    });
     return [];
   }
 }
@@ -86,22 +290,10 @@ function parsePsWinJson(stdout, limit) {
  */
 async function getTopProcessesWindows(limit = 10) {
   try {
-    // Use PowerShell to get process info and convert to JSON
-    // NOTE: PowerShell startup is slower but more reliable than WMI
-    const psCmd = [
-      'Get-Process | ',
-      'Select-Object Id,CPU,WS,ProcessName | ',
-      'ConvertTo-Json'
-    ].join('');
-
-    const { stdout } = await execFileAsync('powershell.exe', [
-      '-NoLogo',
-      '-NoProfile',
-      '-NonInteractive',
-      '-Command',
-      psCmd
-    ], { encoding: 'utf8' });
-
+    // Use persistent PowerShell instance
+    const psCmd = "Get-Process | Select-Object Id,CPU,WS,ProcessName | ConvertTo-Json";
+    
+    const stdout = await execPowerShellCommand(psCmd, 10000);
     return parsePsWinJson(stdout, limit);
   } catch (error) {
     logger.warn('Failed to get top processes on Windows', { error: error.message });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dashcam",
-  "version": "1.4.5-beta.0",
+  "version": "1.4.9-beta",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/dashcam.js",
   "bin": {

package/test-perf-linux.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+/**
+ * Linux-specific performance tracking test
+ * Tests each component individually to identify issues
+ */
+
+import { performanceTracker } from './lib/performanceTracker.js';
+import { getTopProcesses } from './lib/topProcesses.js';
+import { logger, setVerbose } from './lib/logger.js';
+import pidusage from 'pidusage';
+import os from 'os';
+import fs from 'fs';
+
+// Enable verbose logging
+setVerbose(true);
+
+async function testPidUsage() {
+  logger.info('=== Testing pidusage ===');
+  try {
+    const stats = await pidusage(process.pid);
+    logger.info('pidusage SUCCESS', {
+      cpu: stats.cpu?.toFixed(2),
+      memory: (stats.memory / (1024 * 1024)).toFixed(1) + ' MB',
+      pid: stats.pid,
+      ppid: stats.ppid
+    });
+    return true;
+  } catch (error) {
+    logger.error('pidusage FAILED', { error: error.message, stack: error.stack });
+    return false;
+  }
+}
+
+async function testTopProcesses() {
+  logger.info('=== Testing getTopProcesses ===');
+  try {
+    const topProcs = await getTopProcesses(5);
+    logger.info('getTopProcesses SUCCESS', {
+      count: topProcs.length,
+      processes: topProcs.map(p => `${p.name} (PID: ${p.pid}, CPU: ${p.cpu}%)`)
+    });
+    return topProcs.length > 0;
+  } catch (error) {
+    logger.error('getTopProcesses FAILED', { error: error.message, stack: error.stack });
+    return false;
+  }
+}
+
+async function testNetworkMetrics() {
+  logger.info('=== Testing Network Metrics ===');
+  try {
+    if (process.platform === 'linux') {
+      // Test /proc/net/dev reading
+      if (fs.existsSync('/proc/net/dev')) {
+        const content = fs.readFileSync('/proc/net/dev', 'utf8');
+        const lines = content.split('\n');
+        let totalRx = 0;
+        let totalTx = 0;
+        
+        logger.info('/proc/net/dev file found');
+        logger.debug('First few lines:', lines.slice(0, 5));
+        
+        for (const line of lines) {
+          if (line.includes(':')) {
+            const parts = line.split(':')[1].trim().split(/\s+/);
+            if (parts.length >= 9) {
+              const rx = parseInt(parts[0]) || 0;
+              const tx = parseInt(parts[8]) || 0;
+              totalRx += rx;
+              totalTx += tx;
+            }
+          }
+        }
+        
+        logger.info('Network stats parsed', {
+          totalRx: (totalRx / (1024 * 1024)).toFixed(2) + ' MB',
+          totalTx: (totalTx / (1024 * 1024)).toFixed(2) + ' MB'
+        });
+        return true;
+      } else {
+        logger.warn('/proc/net/dev not found - running in container?');
+        return false;
+      }
+    } else {
+      logger.info('Skipping network test (not Linux)');
+      return true;
+    }
+  } catch (error) {
+    logger.error('Network metrics FAILED', { error: error.message, stack: error.stack });
+    return false;
+  }
+}
+
+async function testSystemMetrics() {
+  logger.info('=== Testing System Metrics ===');
+  try {
+    const totalMem = os.totalmem();
+    const freeMem = os.freemem();
+    const usedMem = totalMem - freeMem;
+    const cpus = os.cpus();
+    
+    logger.info('System metrics SUCCESS', {
+      totalMemory: (totalMem / (1024 * 1024 * 1024)).toFixed(2) + ' GB',
+      freeMemory: (freeMem / (1024 * 1024 * 1024)).toFixed(2) + ' GB',
+      usedMemory: (usedMem / (1024 * 1024 * 1024)).toFixed(2) + ' GB',
+      memoryUsagePercent: ((usedMem / totalMem) * 100).toFixed(1) + '%',
+      cpuCount: cpus.length,
+      platform: os.platform(),
+      arch: os.arch()
+    });
+    return true;
+  } catch (error) {
+    logger.error('System metrics FAILED', { error: error.message });
+    return false;
+  }
+}
+
+async function testPerformanceTracker() {
+  logger.info('=== Testing PerformanceTracker ===');
+  try {
+    logger.info('Starting performance tracker for 10 seconds...');
+    
+    // Use temp directory for performance file
+    const tmpDir = os.tmpdir();
+    performanceTracker.start(tmpDir);
+    
+    // Wait 10 seconds
+    await new Promise(resolve => setTimeout(resolve, 10000));
+    
+    // Stop tracking
+    const result = performanceTracker.stop();
+    
+    logger.info('PerformanceTracker stopped', {
+      sampleCount: result.samples?.length || 0,
+      hasSummary: !!result.summary
+    });
+    
+    if (result.summary) {
+      logger.info('Performance Summary', {
+        duration: (result.summary.durationMs / 1000).toFixed(1) + 's',
+        avgCPU: result.summary.avgProcessCPU?.toFixed(1) + '%',
+        maxCPU: result.summary.maxProcessCPU?.toFixed(1) + '%',
+        avgMemory: result.summary.avgProcessMemoryMB?.toFixed(1) + ' MB',
+        maxMemory: result.summary.maxProcessMemoryMB?.toFixed(1) + ' MB'
+      });
+    }
+    
+    if (result.samples && result.samples.length > 0) {
+      const lastSample = result.samples[result.samples.length - 1];
+      logger.info('Last sample data', {
+        hasSystem: !!lastSample.system,
+        hasProcess: !!lastSample.process,
+        hasNetwork: !!lastSample.network,
+        hasTopProcesses: !!lastSample.topProcesses,
+        topProcessesCount: lastSample.topProcesses?.length || 0
+      });
+      
+      if (lastSample.topProcesses && lastSample.topProcesses.length > 0) {
+        logger.info('Top 3 processes from last sample:');
+        lastSample.topProcesses.slice(0, 3).forEach((proc, i) => {
+          logger.info(`  ${i + 1}. ${proc.name} - CPU: ${proc.cpu?.toFixed(1)}%, Mem: ${(proc.memory / (1024 * 1024)).toFixed(1)} MB`);
+        });
+      }
+    }
+    
+    // Clean up
+    performanceTracker.cleanup();
+    
+    return result.samples && result.samples.length > 0;
+  } catch (error) {
+    logger.error('PerformanceTracker FAILED', { error: error.message, stack: error.stack });
+    return false;
+  }
+}
+
+async function runAllTests() {
+  logger.info('Starting Linux Performance Tracking Tests');
+  logger.info('Platform:', os.platform());
+  logger.info('Architecture:', os.arch());
+  logger.info('Node version:', process.version);
+  logger.info('');
+  
+  const results = {
+    pidusage: await testPidUsage(),
+    topProcesses: await testTopProcesses(),
+    networkMetrics: await testNetworkMetrics(),
+    systemMetrics: await testSystemMetrics(),
+    performanceTracker: await testPerformanceTracker()
+  };
+  
+  logger.info('');
+  logger.info('=== Test Results Summary ===');
+  Object.entries(results).forEach(([test, passed]) => {
+    logger.info(`${test}: ${passed ? '✓ PASS' : '✗ FAIL'}`);
+  });
+  
+  const allPassed = Object.values(results).every(r => r);
+  logger.info('');
+  logger.info(`Overall: ${allPassed ? '✓ ALL TESTS PASSED' : '✗ SOME TESTS FAILED'}`);
+  
+  process.exit(allPassed ? 0 : 1);
+}
+
+runAllTests().catch(error => {
+  logger.error('Test suite failed', { error: error.message, stack: error.stack });
+  process.exit(1);
+});