dashcam 1.4.3-beta → 1.4.5-beta

package/PERFORMANCE_TRACKING.md

@@ -0,0 +1,139 @@
+# Performance Tracking
+
+The Dashcam CLI now includes comprehensive performance tracking during recordings. This feature monitors CPU and memory usage throughout the recording session and includes the data in the log files.
+
+## What's Tracked
+
+### 1. Dashcam Process Metrics
+- **CPU Usage**: Percentage of CPU used by the Dashcam process
+- **Memory Usage**: Memory consumed by the Dashcam process in bytes and MB
+- **Process Info**: PID, parent PID, CPU time, elapsed time
+
+### 2. System-Wide Metrics
+- **Total Memory**: System total and free memory
+- **Memory Usage Percentage**: Overall system memory utilization
+- **CPU Count**: Number of CPU cores available
+
+### 3. Top Processes
+- **Top 10 by CPU**: The most CPU-intensive processes running on the system
+- **Top 10 by Memory**: The most memory-intensive processes running on the system
+- **Process Details**: For each top process, tracks:
+  - Process name
+  - PID
+  - CPU usage percentage
+  - Memory usage in bytes
+  - Parent process ID
+  - CPU time and elapsed time
+
+## Sampling Frequency
+
+Performance metrics are sampled every **1 second** (1000ms) during the recording session.
+
+## Output Format
+
+Performance data is included in the recording result with the following structure:
+
+```javascript
+{
+  performance: {
+    samples: [
+      {
+        timestamp: 1700000000000,
+        elapsedMs: 1000,
+        system: {
+          totalMemory: 17179869184,
+          freeMemory: 8589934592,
+          usedMemory: 8589934592,
+          memoryUsagePercent: 50.0,
+          cpuCount: 8
+        },
+        process: {
+          cpu: 15.5,
+          memory: 134217728,
+          pid: 12345,
+          ppid: 1,
+          ctime: 5000,
+          elapsed: 10000
+        },
+        topProcesses: [
+          {
+            pid: 54321,
+            name: "ffmpeg",
+            cpu: 85.2,
+            memory: 268435456,
+            ppid: 12345,
+            ctime: 8500,
+            elapsed: 10000
+          },
+          // ... up to 10 processes
+        ],
+        totalProcesses: 342
+      }
+      // ... one sample per second
+    ],
+    summary: {
+      durationMs: 10000,
+      sampleCount: 10,
+      monitorInterval: 1000,
+      avgProcessCPU: 12.3,
+      maxProcessCPU: 18.7,
+      avgProcessMemoryBytes: 134217728,
+      avgProcessMemoryMB: 128.0,
+      maxProcessMemoryBytes: 201326592,
+      maxProcessMemoryMB: 192.0,
+      avgSystemMemoryUsagePercent: 52.5,
+      maxSystemMemoryUsagePercent: 55.3,
+      totalSystemMemoryBytes: 17179869184,
+      totalSystemMemoryGB: 16.0
+    }
+  }
+}
+```
+
+## Summary Statistics
+
+The performance tracker calculates summary statistics including:
+- **Average and Max Process CPU**: How much CPU the Dashcam process used
+- **Average and Max Process Memory**: Memory consumed by the Dashcam process
+- **Average and Max System Memory Usage**: Overall system memory pressure
+- **Total Duration**: How long the tracking ran
+- **Sample Count**: Number of samples collected
+
+## Logging
+
+Performance data is logged to the standard Dashcam log files:
+- `~/.dashcam/logs/combined.log` - All log levels including performance samples
+- `~/.dashcam/logs/debug.log` - Debug-level information
+- Console output when running with `--verbose` flag
+
+## Testing
+
+Run the performance tracking test:
+
+```bash
+node test-performance-tracking.js
+```
+
+This will:
+1. Start a 10-second recording
+2. Collect performance samples every second
+3. Display detailed performance statistics
+4. Show the top 10 processes at the end of the recording
+
+## Use Cases
+
+Performance tracking helps with:
+- **Debugging Performance Issues**: Identify when recordings are resource-intensive
+- **Optimization**: Track the impact of code changes on resource usage
+- **System Monitoring**: Understand what other processes are running during recordings
+- **Troubleshooting**: Correlate performance issues with specific applications or system states
+- **Capacity Planning**: Understand resource requirements for different recording scenarios
+
+## Implementation Details
+
+The performance tracker uses:
+- `pidusage` - For detailed per-process CPU and memory statistics
+- `ps-list` - For listing all system processes
+- `os` module - For system-wide memory and CPU information
+
+The tracker runs in parallel with the recording and has minimal overhead (~1% CPU on average).

package/bin/dashcam-background.js

@@ -161,37 +161,64 @@ async function runBackgroundRecording() {
       }
       isShuttingDown = true;
       
-      logger.info(`Received ${signal}, cleaning up child processes`);
-      console.log('[Background] Received stop signal, cleaning up...');
+      logger.info(`Received ${signal}, stopping recording and collecting data`);
+      console.log('[Background] Received stop signal, stopping recording...');
       
-      // Kill any child processes (ffmpeg, etc.)
       try {
-        // Get all child processes and kill them
-        const { exec } = await import('child_process');
-        const platform = process.platform;
+        // Stop the recording properly to collect all tracking data
+        const { stopRecording } = await import('../lib/recorder.js');
+        const result = await stopRecording();
         
-        if (platform === 'darwin' || platform === 'linux') {
-          // On Unix, kill the entire process group
-          exec(`pkill -P ${process.pid}`, (error) => {
-            if (error && error.code !== 1) { // code 1 means no processes found
-              logger.warn('Failed to kill child processes', { error: error.message });
-            }
-            logger.info('Child processes killed');
-          });
-        } else if (platform === 'win32') {
-          // On Windows, use taskkill
-          exec(`taskkill /F /T /PID ${process.pid}`, (error) => {
-            if (error) {
-              logger.warn('Failed to kill child processes on Windows', { error: error.message });
-            }
-            logger.info('Child processes killed');
-          });
-        }
+        logger.info('Recording stopped successfully', {
+          outputPath: result.outputPath,
+          duration: result.duration,
+          performanceSamples: result.performance?.summary?.sampleCount || 0
+        });
+        
+        // Write the complete result to file for the stop command to read
+        const RECORDING_RESULT_FILE = path.join(PROCESS_DIR, 'recording-result.json');
+        fs.writeFileSync(RECORDING_RESULT_FILE, JSON.stringify({
+          ...result,
+          timestamp: Date.now()
+        }, null, 2));
+        
+        logger.info('Saved recording result to file', { 
+          path: RECORDING_RESULT_FILE,
+          performanceSamples: result.performance?.summary?.sampleCount || 0 
+        });
+        
+        // Update status to indicate recording is complete
+        writeStatus({
+          isRecording: false,
+          completedAt: Date.now(),
+          outputPath: result.outputPath,
+          duration: result.duration
+        });
         
-        // Give it a moment to clean up
-        await new Promise(resolve => setTimeout(resolve, 500));
       } catch (error) {
-        logger.error('Error during cleanup', { error: error.message });
+        logger.error('Error stopping recording during shutdown', { error: error.message });
+        
+        // Still try to kill child processes
+        try {
+          const { exec } = await import('child_process');
+          const platform = process.platform;
+          
+          if (platform === 'darwin' || platform === 'linux') {
+            exec(`pkill -P ${process.pid}`, (error) => {
+              if (error && error.code !== 1) {
+                logger.warn('Failed to kill child processes', { error: error.message });
+              }
+            });
+          } else if (platform === 'win32') {
+            exec(`taskkill /F /T /PID ${process.pid}`, (error) => {
+              if (error) {
+                logger.warn('Failed to kill child processes on Windows', { error: error.message });
+              }
+            });
+          }
+        } catch (cleanupError) {
+          logger.error('Error during cleanup', { error: cleanupError.message });
+        }
       }
       
       logger.info('Background process exiting');

package/bin/dashcam.js

@@ -25,6 +25,57 @@ if (!fs.existsSync(APP.recordingsDir)) {
   fs.mkdirSync(APP.recordingsDir, { recursive: true });
 }
 
+// Handle graceful shutdown on terminal close or process termination
+// This prevents orphaned FFmpeg processes and ensures clean exit
+let isShuttingDown = false;
+
+async function gracefulShutdown(signal) {
+  if (isShuttingDown) {
+    logger.debug('Shutdown already in progress, ignoring additional signal', { signal });
+    return;
+  }
+  
+  isShuttingDown = true;
+  logger.info('Received shutdown signal, cleaning up...', { signal });
+  
+  try {
+    // Check if there's an active recording and stop it
+    if (processManager.isRecordingActive()) {
+      logger.info('Stopping active recording before exit...');
+      await processManager.stopActiveRecording().catch(err => {
+        logger.warn('Failed to stop recording during shutdown', { error: err.message });
+      });
+    }
+    
+    logger.info('Cleanup complete, exiting gracefully');
+    process.exit(0);
+  } catch (error) {
+    logger.error('Error during graceful shutdown', { error: error.message });
+    process.exit(1);
+  }
+}
+
+// Register signal handlers for graceful shutdown
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+process.on('SIGHUP', () => gracefulShutdown('SIGHUP'));
+
+// Handle uncaught errors to prevent crashes
+process.on('uncaughtException', (error) => {
+  logger.error('Uncaught exception', { 
+    error: error.message, 
+    stack: error.stack 
+  });
+  gracefulShutdown('uncaughtException');
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  logger.error('Unhandled promise rejection', { 
+    reason: reason instanceof Error ? reason.message : reason,
+    stack: reason instanceof Error ? reason.stack : undefined
+  });
+});
+
 program
   .name('dashcam')
   .description('Capture the steps to reproduce every bug.')
@@ -469,6 +520,24 @@ program
         console.log('Recording stopped successfully');
         logger.debug('Stop result:', result);
         
+        // Try to read the recording result saved by the background process
+        // This includes performance data and other tracking information
+        const RECORDING_RESULT_FILE = path.join(os.homedir(), '.dashcam-cli', 'recording-result.json');
+        let backgroundResult = null;
+        if (fs.existsSync(RECORDING_RESULT_FILE)) {
+          try {
+            const resultData = fs.readFileSync(RECORDING_RESULT_FILE, 'utf8');
+            backgroundResult = JSON.parse(resultData);
+            logger.info('Loaded recording result from background process', {
+              outputPath: backgroundResult.outputPath,
+              duration: backgroundResult.duration,
+              performanceSamples: backgroundResult.performance?.summary?.sampleCount || 0
+            });
+          } catch (error) {
+            logger.warn('Failed to read background recording result', { error: error.message });
+          }
+        }
+        
         // Reconstruct recording data from status and fix video with FFmpeg
         console.log('Processing recording...');
         logger.debug('Reconstructing recording data from status file');
@@ -660,6 +729,87 @@ program
           logger.warn('Failed to collect log tracking results', { error: error.message });
         }
         
+        // Read performance data from file if available
+        let performanceData = null;
+        try {
+          const performanceFile = path.join(recordingDir, 'performance.jsonl');
+          if (fs.existsSync(performanceFile)) {
+            logger.info('Found performance file, reading data', { file: performanceFile });
+            
+            // Read the file directly and parse samples
+            const fileContent = fs.readFileSync(performanceFile, 'utf8');
+            const lines = fileContent.trim().split('\n').filter(line => line.length > 0);
+            const samples = lines.map(line => JSON.parse(line));
+            
+            logger.info('Parsed performance samples from file', { sampleCount: samples.length });
+            
+            // Calculate summary statistics
+            if (samples.length > 0) {
+              const firstSample = samples[0];
+              const lastSample = samples[samples.length - 1];
+              
+              let totalProcessCPU = 0;
+              let totalProcessMemory = 0;
+              let totalSystemMemoryUsage = 0;
+              let maxProcessCPU = 0;
+              let maxProcessMemory = 0;
+              let maxSystemMemoryUsage = 0;
+              
+              samples.forEach(sample => {
+                const processCPU = sample.process?.cpu || 0;
+                const processMemory = sample.process?.memory || 0;
+                const systemMemoryUsage = sample.system?.memoryUsagePercent || 0;
+                
+                totalProcessCPU += processCPU;
+                totalProcessMemory += processMemory;
+                totalSystemMemoryUsage += systemMemoryUsage;
+                
+                maxProcessCPU = Math.max(maxProcessCPU, processCPU);
+                maxProcessMemory = Math.max(maxProcessMemory, processMemory);
+                maxSystemMemoryUsage = Math.max(maxSystemMemoryUsage, systemMemoryUsage);
+              });
+              
+              const count = samples.length;
+              const finalSample = samples[samples.length - 1];
+              const totalBytesReceived = finalSample.network?.bytesReceived || 0;
+              const totalBytesSent = finalSample.network?.bytesSent || 0;
+              
+              const summary = {
+                durationMs: lastSample.timestamp - firstSample.timestamp,
+                sampleCount: count,
+                monitorInterval: 5000,
+                avgProcessCPU: totalProcessCPU / count,
+                maxProcessCPU,
+                avgProcessMemoryBytes: totalProcessMemory / count,
+                avgProcessMemoryMB: (totalProcessMemory / count) / (1024 * 1024),
+                maxProcessMemoryBytes: maxProcessMemory,
+                maxProcessMemoryMB: maxProcessMemory / (1024 * 1024),
+                avgSystemMemoryUsagePercent: totalSystemMemoryUsage / count,
+                maxSystemMemoryUsagePercent: maxSystemMemoryUsage,
+                totalSystemMemoryBytes: firstSample.system?.totalMemory || 0,
+                totalSystemMemoryGB: (firstSample.system?.totalMemory || 0) / (1024 * 1024 * 1024),
+                totalBytesReceived,
+                totalBytesSent,
+                totalMBReceived: totalBytesReceived / (1024 * 1024),
+                totalMBSent: totalBytesSent / (1024 * 1024)
+              };
+              
+              performanceData = { samples, summary };
+              
+              logger.info('Calculated performance summary', {
+                sampleCount: summary.sampleCount,
+                avgCPU: summary.avgProcessCPU.toFixed(1),
+                maxCPU: summary.maxProcessCPU.toFixed(1),
+                avgMemoryMB: summary.avgProcessMemoryMB.toFixed(1)
+              });
+            }
+          } else {
+            logger.debug('No performance file found', { expectedPath: performanceFile });
+          }
+        } catch (error) {
+          logger.warn('Failed to load performance data', { error: error.message, stack: error.stack });
+        }
+        
         // The recording is on disk and can be uploaded with full metadata
         const recordingResult = {
           outputPath,
@@ -668,14 +818,22 @@ program
           duration: result.duration,
           fileSize: fs.statSync(outputPath).size,
           clientStartDate: activeStatus.startTime,
-          apps: appTrackingResults.apps,
-          icons: appTrackingResults.icons,
-          logs: logTrackingResults,
+          apps: backgroundResult?.apps || appTrackingResults.apps,
+          icons: backgroundResult?.icons || appTrackingResults.icons,
+          logs: backgroundResult?.logs || logTrackingResults,
+          performance: performanceData || backgroundResult?.performance || null, // Prefer file data, fallback to background result
           title: activeStatus?.options?.title,
           description: activeStatus?.options?.description,
           project: activeStatus?.options?.project
         };
         
+        logger.info('Recording result prepared for upload', {
+          hasPerformanceData: !!recordingResult.performance,
+          performanceSamples: recordingResult.performance?.summary?.sampleCount || 0,
+          avgCPU: recordingResult.performance?.summary?.avgProcessCPU?.toFixed(1) || 'N/A',
+          maxCPU: recordingResult.performance?.summary?.maxProcessCPU?.toFixed(1) || 'N/A'
+        });
+        
         if (!recordingResult || !recordingResult.outputPath) {
           console.error('Failed to process recording');
           logger.error('No recording result', { recordingResult });
@@ -695,6 +853,7 @@ program
             apps: recordingResult.apps,
             icons: recordingResult.icons,
             logs: recordingResult.logs,
+            performance: recordingResult.performance, // Include performance data
             gifPath: recordingResult.gifPath,
             snapshotPath: recordingResult.snapshotPath
           });
@@ -702,8 +861,19 @@ program
           console.log('Watch your recording:', uploadResult.shareLink);
           logger.info('Upload succeeded');
           
-          // Clean up the result file
+          // Clean up the result file and recording result file
           processManager.cleanup();
+          
+          // Also clean up recording result file from background process
+          const RECORDING_RESULT_FILE = path.join(os.homedir(), '.dashcam-cli', 'recording-result.json');
+          if (fs.existsSync(RECORDING_RESULT_FILE)) {
+            try {
+              fs.unlinkSync(RECORDING_RESULT_FILE);
+              logger.debug('Cleaned up recording result file');
+            } catch (error) {
+              logger.warn('Failed to clean up recording result file', { error: error.message });
+            }
+          }
         } catch (uploadError) {
           console.error('Upload failed:', uploadError.message);
           logger.error('Upload error details:', {

package/lib/auth.js

@@ -1,5 +1,5 @@
 import got from 'got';
-import { auth0Config } from './config.js';
+import { auth0Config, API_ENDPOINT } from './config.js';
 import { logger, logFunctionCall } from './logger.js';
 import { Store } from './store.js';
 
@@ -14,11 +14,12 @@ const auth = {
       logger.info('Authenticating with API key');
       logger.verbose('Starting API key exchange', {
         apiKeyLength: apiKey?.length,
-        hasApiKey: !!apiKey
+        hasApiKey: !!apiKey,
+        apiEndpoint: API_ENDPOINT
       });
       
       // Exchange API key for token
-      const { token } = await got.post('https://testdriver-api.onrender.com/auth/exchange-api-key', {
+      const { token } = await got.post(`${API_ENDPOINT}/auth/exchange-api-key`, {
         json: { apiKey },
         timeout: 30000 // 30 second timeout
       }).json();
@@ -34,7 +35,7 @@ const auth = {
 
       // Get user info to verify the token works
       logger.debug('Fetching user information to validate token...');
-      const user = await got.get('https://testdriver-api.onrender.com/api/v1/whoami', {
+      const user = await got.get(`${API_ENDPOINT}/api/v1/whoami`, {
         headers: {
           Authorization: `Bearer ${token}`
         },
@@ -105,7 +106,7 @@ const auth = {
     const token = await this.getToken();
     
     try {
-      const response = await got.get('https://testdriver-api.onrender.com/api/v1/projects', {
+      const response = await got.get(`${API_ENDPOINT}/api/v1/projects`, {
         headers: {
           Authorization: `Bearer ${token}`
         },
@@ -160,7 +161,7 @@ const auth = {
       requestBody.project = replayData.project;
     }
     
-    const response = await got.post('https://testdriver-api.onrender.com/api/v1/replay/upload', {
+    const response = await got.post(`${API_ENDPOINT}/api/v1/replay/upload`, {
       headers: {
         Authorization: `Bearer ${token}`
       },
@@ -188,7 +189,7 @@ const auth = {
     const token = await this.getToken();
     
     try {
-      const response = await got.post('https://testdriver-api.onrender.com/api/v1/logs', {
+      const response = await got.post(`${API_ENDPOINT}/api/v1/logs`, {
         headers: {
           Authorization: `Bearer ${token}`
         },

package/lib/config.js

@@ -26,7 +26,8 @@ export const apiEndpoints = {
   production: 'https://testdriver-api.onrender.com'
 };
 
-export const API_ENDPOINT = apiEndpoints[ENV];
+// Allow TD_API_ROOT to override the endpoint
+export const API_ENDPOINT = process.env.TD_API_ROOT || apiEndpoints[ENV];
 
 // App configuration
 export const APP = {