ctrlshiftleft/scripts/demo-performance.js

AI-powered toolkit for embedding QA and security testing into development workflows

#!/usr/bin/env node

/**
 * Performance Metrics Demo Script
 * 
 * This script demonstrates the performance tracking capabilities
 * added in v1.4.0 by performing some basic operations and generating
 * a performance report.
 */

const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const { PerformanceTracker } = require('./utils/performanceTracker');
const { PathUtils, FileUtils } = require('./utils/platformUtils');
const { errorHandler } = require('./utils/errorHandler');

// Create output directory for reports
const outputDir = path.join(process.cwd(), 'demo-performance-reports');
PathUtils.ensureDir(outputDir);

// Create performance tracker
const tracker = new PerformanceTracker({
  projectName: 'ctrl.shift.left-demo',
  version: require('../package.json').version,
  outputDir,
  enabled: true
});

// Simulate file operations with performance tracking
async function runPerformanceDemo() {
  console.log('📊 Running performance metrics demo...\n');
  
  try {
    // Demo file operations
    console.log('💾 Testing file operations...');
    const fileOpTimer = tracker.startTimer('file-operations', 'demo-files');
    
    // Create test files
    const testDir = path.join(outputDir, 'test-files');
    PathUtils.ensureDir(testDir);
    
    // Generate some test files with different content
    for (let i = 1; i <= 5; i++) {
      const filePath = path.join(testDir, `test-file-${i}.txt`);
      const content = `This is test file ${i}\nCreated at ${new Date().toISOString()}\n` +
                      `Random data: ${crypto.randomBytes(100).toString('hex')}`;
      
      FileUtils.writeFile(filePath, content, 'auto');
      console.log(`  ✓ Created file ${i}`);
    }
    
    const fileOpDuration = tracker.stopTimer(fileOpTimer);
    console.log(`  ✅ File operations completed in ${fileOpDuration}ms\n`);
    
    // Demo complex computation operations
    console.log('🧮 Testing compute operations...');
    const computeTimer = tracker.startTimer('computation', 'hash-generation');
    
    // Perform some computation (hash generation)
    const results = [];
    for (let i = 1; i <= 10; i++) {
      const startTime = Date.now();
      
      // Generate a complex hash
      const data = crypto.randomBytes(10000).toString('hex');
      const hash = crypto.createHash('sha512').update(data).digest('hex');
      results.push(hash);
      
      const opTime = Date.now() - startTime;
      tracker.recordOperation('hash-calculation', `round-${i}`, opTime, {
        inputSize: data.length,
        outputSize: hash.length,
        algorithm: 'sha512'
      });
      
      console.log(`  ✓ Computed hash ${i} in ${opTime}ms`);
    }
    
    const computeDuration = tracker.stopTimer(computeTimer);
    console.log(`  ✅ Computation operations completed in ${computeDuration}ms\n`);
    
    // Read files back with timing
    console.log('📖 Testing read operations...');
    const readTimer = tracker.startTimer('file-reads', 'demo-files');
    
    for (let i = 1; i <= 5; i++) {
      const startTime = Date.now();
      const filePath = path.join(testDir, `test-file-${i}.txt`);
      
      const content = FileUtils.readFile(filePath, 'auto');
      const contentSize = content ? content.length : 0;
      
      const readTime = Date.now() - startTime;
      console.log(`  ✓ Read file ${i} (${contentSize} bytes) in ${readTime}ms`);
      
      tracker.recordOperation('file-read', filePath, readTime, {
        fileSize: contentSize,
        success: !!content
      });
    }
    
    const readDuration = tracker.stopTimer(readTimer);
    console.log(`  ✅ Read operations completed in ${readDuration}ms\n`);
    
    // Generate and save reports
    console.log('📝 Generating performance reports...');
    
    // Generate JSON report
    const jsonReportPath = tracker.saveReport('json', 'demo-run');
    console.log(`  ✓ JSON report saved to: ${jsonReportPath}`);
    
    // Generate Markdown report
    const markdownReportPath = tracker.saveReport('markdown', 'demo-run');
    console.log(`  ✓ Markdown report saved to: ${markdownReportPath}`);
    
    // Display performance summary
    const report = tracker.generateReport('demo-run');
    console.log('\n📊 Performance Summary:');
    console.log(`Total operations: ${report.summary.operationCount}`);
    console.log(`Total duration: ${report.summary.totalDuration}ms`);
    console.log(`Average duration: ${report.summary.averageDuration.toFixed(2)}ms`);
    console.log(`Success rate: ${report.summary.successRate}%`);
    
    console.log('\nOperation types:');
    Object.keys(report.summary.byType).forEach(type => {
      const stats = report.summary.byType[type];
      console.log(`- ${type}: ${stats.count} operations, avg ${stats.averageDuration.toFixed(2)}ms`);
    });
    
    console.log(`\n✅ Performance demo completed successfully!`);
    console.log(`Reports saved to: ${outputDir}`);
    
    return { success: true };
  } catch (error) {
    // Use our enhanced error handler
    const enhancedError = errorHandler.handleError(error, 'performance-demo', {
      outputDir
    });
    
    errorHandler.displayError(enhancedError);
    errorHandler.logError(enhancedError);
    
    return { success: false, error: enhancedError };
  }
}

// Run the demo
runPerformanceDemo()
  .then(result => {
    if (!result.success) {
      process.exit(1);
    }
  })
  .catch(error => {
    console.error('Unhandled error:', error);
    process.exit(1);
  });