dashcam 1.4.11-beta.0 → 1.4.12-beta

package/bin/dashcam.js

@@ -531,7 +531,7 @@ program
             logger.info('Loaded recording result from background process', {
               outputPath: backgroundResult.outputPath,
               duration: backgroundResult.duration,
-              performanceSamples: backgroundResult.performance?.summary?.sampleCount || 0
+              hasPerformanceFile: !!backgroundResult.performanceFile
             });
           } catch (error) {
             logger.warn('Failed to read background recording result', { error: error.message });
@@ -730,20 +730,23 @@ program
         }
         
         // Read performance data from file if available
-        let performanceData = null;
+        // Instead of embedding all samples, we'll just pass the file path for S3 upload
+        let performanceFile = null;
+        let performanceSummary = null;
         try {
-          const performanceFile = path.join(recordingDir, 'performance.jsonl');
-          if (fs.existsSync(performanceFile)) {
-            logger.info('Found performance file, reading data', { file: performanceFile });
+          const perfFile = path.join(recordingDir, 'performance.jsonl');
+          if (fs.existsSync(perfFile)) {
+            logger.info('Found performance file, will upload to S3', { file: perfFile });
+            performanceFile = perfFile;
             
-            // Read the file directly and parse samples
-            const fileContent = fs.readFileSync(performanceFile, 'utf8');
+            // Read samples just to calculate summary for logging (not for DB storage)
+            const fileContent = fs.readFileSync(perfFile, '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
+            // Calculate summary statistics just for logging
             if (samples.length > 0) {
               const firstSample = samples[0];
               const lastSample = samples[samples.length - 1];
@@ -770,44 +773,28 @@ program
               });
               
               const count = samples.length;
-              const finalSample = samples[samples.length - 1];
-              const totalBytesReceived = finalSample.network?.bytesReceived || 0;
-              const totalBytesSent = finalSample.network?.bytesSent || 0;
               
-              const summary = {
+              performanceSummary = {
                 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)
+                maxProcessMemoryMB: maxProcessMemory / (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)
+              logger.info('Calculated performance summary for logging', {
+                sampleCount: performanceSummary.sampleCount,
+                avgCPU: performanceSummary.avgProcessCPU.toFixed(1),
+                maxCPU: performanceSummary.maxProcessCPU.toFixed(1),
+                avgMemoryMB: performanceSummary.avgProcessMemoryMB.toFixed(1)
               });
             }
           } else {
-            logger.debug('No performance file found', { expectedPath: performanceFile });
+            logger.debug('No performance file found', { expectedPath: perfFile });
           }
         } catch (error) {
-          logger.warn('Failed to load performance data', { error: error.message, stack: error.stack });
+          logger.warn('Failed to process performance data', { error: error.message, stack: error.stack });
         }
         
         // The recording is on disk and can be uploaded with full metadata
@@ -821,17 +808,17 @@ program
           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
+          performanceFile: performanceFile || backgroundResult?.performanceFile || null, // Pass file path for S3 upload
           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'
+          hasPerformanceFile: !!recordingResult.performanceFile,
+          performanceSamples: performanceSummary?.sampleCount || 0,
+          avgCPU: performanceSummary?.avgProcessCPU?.toFixed(1) || 'N/A',
+          maxCPU: performanceSummary?.maxProcessCPU?.toFixed(1) || 'N/A'
         });
         
         if (!recordingResult || !recordingResult.outputPath) {
@@ -853,7 +840,7 @@ program
             apps: recordingResult.apps,
             icons: recordingResult.icons,
             logs: recordingResult.logs,
-            performance: recordingResult.performance, // Include performance data
+            performanceFile: recordingResult.performanceFile, // Path to JSONL file for S3 upload
             gifPath: recordingResult.gifPath,
             snapshotPath: recordingResult.snapshotPath
           });

package/lib/auth.js

@@ -217,6 +217,40 @@ const auth = {
       logExit();
       throw error;
     } // Return the full response with video, gif, image objects
+  },
+
+  async createPerformanceSts(replayId) {
+    const logExit = logFunctionCall('auth.createPerformanceSts');
+    
+    logger.debug('Creating performance STS credentials', { replayId });
+    const token = await this.getToken();
+    
+    try {
+      const response = await got.post(`${API_ENDPOINT}/api/v1/replay/performance`, {
+        headers: {
+          Authorization: `Bearer ${token}`
+        },
+        json: {
+          replayId
+        },
+        timeout: 30000
+      }).json();
+      
+      logger.verbose('Performance STS credentials created', {
+        hasCredentials: !!response.bucket,
+        file: response.file
+      });
+      
+      logExit();
+      return response;
+    } catch (error) {
+      logger.error('Failed to create performance STS credentials:', {
+        message: error.message,
+        statusCode: error.response?.statusCode
+      });
+      logExit();
+      throw error;
+    }
   }
 };
 

package/lib/performanceTracker.js

@@ -403,7 +403,8 @@ class PerformanceTracker {
     
     const result = {
       samples: this.samples,
-      summary
+      summary,
+      performanceFile: this.performanceFile // Return file path for S3 upload
     };
     
     // DON'T delete the performance file - keep it for the stop command to read

package/lib/recorder.js

@@ -857,13 +857,15 @@ export async function stopRecording() {
       apps: appTrackingResults.apps, // Include tracked applications
       icons: appTrackingResults.icons, // Include application icons metadata
       logs: logTrackingResults, // Include log tracking results
-      performance: performanceResults // Include performance tracking results
+      performanceFile: performanceResults.performanceFile, // Path to JSONL file for S3 upload
+      performanceSummary: performanceResults.summary // Just include summary for logging (not uploaded to DB)
     };
     
     logger.info('Recording stopped with performance data', {
       clientStartDate: recordingStartTime,
       clientStartDateReadable: new Date(recordingStartTime).toISOString(),
       duration: result.duration,
+      performanceFile: performanceResults.performanceFile,
       performanceSamples: performanceResults.summary?.sampleCount || 0,
       avgCPU: performanceResults.summary?.avgProcessCPU?.toFixed(1) || 0,
       maxCPU: performanceResults.summary?.maxProcessCPU?.toFixed(1) || 0,

package/lib/topProcesses.js

@@ -161,18 +161,40 @@ function parsePsOutput(stdout, limit) {
     return [];
   }
   
+  // Log first few lines to debug format
+  logger.info('ps output sample', { 
+    firstThreeLines: lines.slice(0, 3)
+  });
+  
   // Skip header line
-  const processes = lines.slice(1).map(line => {
+  const processes = lines.slice(1).map((line, index) => {
     const parts = line.trim().split(/\s+/, 4);
-    return {
+    const proc = {
       pid: Number(parts[0]),
       cpu: Number(parts[1]) || 0,
       mem: Number(parts[2]) || 0,
       name: parts[3] || ''
     };
-  }).filter(proc => proc.pid > 0); // Filter out invalid entries
+    
+    // Log first few parsed entries to debug
+    if (index < 3) {
+      logger.info(`Parsed process ${index}`, { 
+        line: line.trim(),
+        parts: parts,
+        parsed: proc
+      });
+    }
+    
+    return proc;
+  }).filter(proc => {
+    const isValid = proc.pid > 0;
+    if (!isValid) {
+      logger.warn('Filtered out invalid process', { proc });
+    }
+    return isValid;
+  });
   
-  logger.debug('Parsed processes', { 
+  logger.info('Parsed processes', { 
     count: processes.length,
     sample: processes.slice(0, 3)
   });

package/lib/uploader.js

@@ -246,13 +246,14 @@ export async function upload(filePath, metadata = {}) {
   }
 
   // First, create a replay in the cloud (like the desktop app does)
+  // Note: Performance data is uploaded separately to S3 as JSONL to reduce DB storage
   const replayConfig = {
     duration: metadata.duration || 0,
     apps: metadata.apps && metadata.apps.length > 0 ? metadata.apps : ['Screen Recording'], // Use tracked apps or fallback
     title: metadata.title || defaultTitle,
     system: systemInfo, // Include system information
-    clientStartDate: metadata.clientStartDate || Date.now(), // Use actual recording start time
-    performance: metadata.performance // Include performance tracking data
+    clientStartDate: metadata.clientStartDate || Date.now() // Use actual recording start time
+    // performance data is now uploaded to S3 separately
   };
 
   // Add project if we have one
@@ -266,8 +267,7 @@ export async function upload(filePath, metadata = {}) {
 
   logger.verbose('Creating replay with config', {
     ...replayConfig,
-    performanceSamples: replayConfig.performance?.samples?.length || 0,
-    performanceSummary: replayConfig.performance?.summary ? 'included' : 'none'
+    performanceDataWillBeUploaded: !!metadata.performanceFile
   });
 
   console.log('Creating replay on server...');
@@ -275,8 +275,7 @@ export async function upload(filePath, metadata = {}) {
     title: replayConfig.title,
     duration: replayConfig.duration,
     apps: replayConfig.apps,
-    hasPerformanceData: !!replayConfig.performance,
-    performanceSamples: replayConfig.performance?.samples?.length || 0
+    hasPerformanceFile: !!metadata.performanceFile
   });
 
   // Create the replay first
@@ -372,6 +371,14 @@ export async function upload(filePath, metadata = {}) {
 
   logger.info('Starting asset uploads', { totalUploads: promises.length });
   console.log(`Uploading ${promises.length} file(s)...`);
+
+  // Upload performance data to S3 if available (uses STS from replay-upload)
+  if (metadata.performanceFile && fs.existsSync(metadata.performanceFile) && sts.performance) {
+    logger.debug('Adding performance data upload to queue', { performanceFile: metadata.performanceFile });
+    promises.push(uploader.uploadFile(sts.performance, clip, metadata.performanceFile, 'application', 'jsonl'));
+    filesToCleanup.push(metadata.performanceFile);
+    logger.info('Performance data upload queued', { file: metadata.performanceFile });
+  }
   
   // Process and upload logs if available
   if (metadata.logs && metadata.logs.length > 0) {

package/package.json

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