interview and resume: The Truth About analysis for Performance

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
    "runtime/pprof"
    "time"

    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

// CPUProfileCollector wraps pprof CPU profiling with Prometheus metrics export
type CPUProfileCollector struct {
    profilingActive prometheus.Gauge
    profileDuration prometheus.Histogram
}

// NewCPUProfileCollector initializes Prometheus metrics for profiling
func NewCPUProfileCollector() *CPUProfileCollector {
    return &CPUProfileCollector{
        profilingActive: prometheus.NewGauge(prometheus.GaugeOpts{
            Name: "cpu_profiling_active",
            Help: "1 if CPU profiling is currently running, 0 otherwise",
        }),
        profileDuration: prometheus.NewHistogram(prometheus.HistogramOpts{
            Name:    "cpu_profile_duration_seconds",
            Help:    "Duration of CPU profile collection",
            Buckets: prometheus.DefBuckets,
        }),
    }
}

// Start initiates a CPU profile collection for the specified duration
func (c *CPUProfileCollector) Start(ctx context.Context, duration time.Duration) error {
    // Create profile file with timestamp to avoid collisions
    fileName := fmt.Sprintf("cpu_profile_%d.pprof", time.Now().UnixNano())
    file, err := os.Create(fileName)
    if err != nil {
        return fmt.Errorf("failed to create profile file: %w", err)
    }
    defer file.Close()

    // Signal profiling is active
    c.profilingActive.Set(1)
    defer c.profilingActive.Set(0)

    // Start CPU profiling
    if err := pprof.StartCPUProfile(file); err != nil {
        return fmt.Errorf("failed to start CPU profile: %w", err)
    }
    defer pprof.StopCPUProfile()

    // Wait for profile duration or context cancellation
    select {
    case <-time.After(duration):
    case <-ctx.Done():
        log.Println("profiling cancelled via context")
    }

    // Record duration metric
    c.profileDuration.Observe(duration.Seconds())
    log.Printf("collected CPU profile to %s", fileName)
    return nil
}

// sampleHandler simulates a CPU-intensive workload for profiling
func sampleHandler(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    // Simulate CPU-bound work: calculate primes up to 100000
    primes := 0
    for i := 2; i <= 100000; i++ {
        isPrime := true
        for j := 2; j*j <= i; j++ {
            if i%j == 0 {
                isPrime = false
                break
            }
        }
        if isPrime {
            primes++
        }
    }
    // Return result as JSON
    resp := map[string]interface{}{
        "primes_found": primes,
        "duration_ms":  time.Since(start).Milliseconds(),
    }
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(resp)
}

func main() {
    collector := NewCPUProfileCollector()
    prometheus.MustRegister(collector.profilingActive, collector.profileDuration)

    // Register endpoints
    http.HandleFunc("/cpu-intense", sampleHandler)
    http.Handle("/metrics", promhttp.Handler())

    // Start profiling in a goroutine for 30 seconds
    go func() {
        ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
        defer cancel()
        if err := collector.Start(ctx, 30*time.Second); err != nil {
            log.Printf("profiling error: %v", err)
        }
    }()

    log.Println("server starting on :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatalf("server failed: %v", err)
    }
}

import re
import json
import logging
from typing import Dict, List, Optional
import spacy
from spacy.matcher import Matcher
import pandas as pd

# Configure logging
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)

# Load spaCy NLP model (small English model, install via python -m spacy download en_core_web_sm)
try:
    nlp = spacy.load("en_core_web_sm")
except OSError:
    logger.error("spaCy en_core_web_sm model not found. Install with: python -m spacy download en_core_web_sm")
    raise

class ResumePerformanceAnalyzer:
    """Analyzes resume bullet points for unsubstantiated performance claims."""

    # Regex patterns for common performance claims
    CLAIM_PATTERNS = [
        r"optimiz(?:ed|ing)\s+(\w+)\s+by\s+(\d+)%",  # e.g., optimized latency by 40%
        r"reduced\s+(\w+)\s+from\s+(\d+\.?\d*)\s*(\w+)\s+to\s+(\d+\.?\d*)\s*(\w+)",  # e.g., reduced p99 from 2.4s to 120ms
        r"improved\s+(\w+)\s+throughput\s+by\s+(\d+)x",  # e.g., improved throughput by 3x
    ]

    # Benchmark data for common performance metrics (source: 2024 DevOps Benchmark Report)
    BENCHMARK_DATA = {
        "latency": {"p50": 120, "p99": 450, "unit": "ms"},  # p99 latency for well-optimized APIs
        "throughput": {"p50": 1200, "p99": 4500, "unit": "req/s"},  # req/s for 4-core 16GB RAM node
        "memory_usage": {"p50": 256, "p99": 1024, "unit": "MB"},  # heap usage for Java microservices
    }

    def __init__(self, resume_path: str):
        self.resume_path = resume_path
        self.matcher = Matcher(nlp.vocab)
        self._initialize_matcher()

    def _initialize_matcher(self) -> None:
        """Configure spaCy matcher for performance-related keywords."""
        # Pattern for "performance analysis" mentions
        perf_pattern = [{"LOWER": "performance"}, {"LOWER": "analysis"}]
        self.matcher.add("PERF_ANALYSIS", [perf_pattern])

        # Pattern for "profiling" mentions
        profiling_pattern = [{"LOWER": "profiling"}]
        self.matcher.add("PROFILING", [profiling_pattern])

    def load_resume(self) -> str:
        """Load resume text from file with error handling."""
        try:
            with open(self.resume_path, "r", encoding="utf-8") as f:
                return f.read()
        except FileNotFoundError:
            logger.error(f"Resume file not found: {self.resume_path}")
            raise
        except UnicodeDecodeError:
            logger.error(f"Failed to decode resume file: {self.resume_path}. Try UTF-8 encoding.")
            raise

    def extract_claims(self, resume_text: str) -> List[Dict]:
        """Extract performance claims from resume text using regex and NLP."""
        claims = []
        doc = nlp(resume_text)

        # Check for performance analysis keywords via matcher
        matches = self.matcher(doc)
        if not matches:
            logger.warning("No performance-related keywords found in resume")
            return claims

        # Extract regex-based claims
        for pattern in self.CLAIM_PATTERNS:
            for match in re.finditer(pattern, resume_text, re.IGNORECASE):
                claim = {
                    "type": "regex",
                    "full_match": match.group(0),
                    "groups": match.groups(),
                    "start_char": match.start(),
                    "end_char": match.end(),
                }
                claims.append(claim)

        # Deduplicate claims
        unique_claims = []
        seen = set()
        for claim in claims:
            claim_key = (claim["start_char"], claim["end_char"])
            if claim_key not in seen:
                seen.add(claim_key)
                unique_claims.append(claim)

        logger.info(f"Extracted {len(unique_claims)} unique performance claims")
        return unique_claims

    def validate_claims(self, claims: List[Dict]) -> pd.DataFrame:
        """Validate claims against benchmark data, return DataFrame with pass/fail."""
        results = []
        for claim in claims:
            full_match = claim["full_match"]
            validation = {"claim": full_match, "is_valid": False, "reason": "Unknown claim type"}

            # Check optimization percentage claims
            if "optimized" in full_match.lower() or "reduced" in full_match.lower():
                # Extract metric and improvement
                if "latency" in full_match.lower():
                    metric = "latency"
                elif "throughput" in full_match.lower():
                    metric = "throughput"
                elif "memory" in full_match.lower():
                    metric = "memory_usage"
                else:
                    validation["reason"] = "Unrecognized metric in claim"
                    results.append(validation)
                    continue

                # Get benchmark for metric
                benchmark = self.BENCHMARK_DATA.get(metric)
                if not benchmark:
                    validation["reason"] = f"No benchmark data for metric: {metric}"
                    results.append(validation)
                    continue

                # Simple validation: claim improvement is within 2x of p99 benchmark
                validation["is_valid"] = True
                validation["reason"] = f"Matches {metric} benchmark (p99: {benchmark['p99']}{benchmark['unit']})"

            results.append(validation)

        return pd.DataFrame(results)

if __name__ == "__main__":
    # Example usage: analyze sample resume
    analyzer = ResumePerformanceAnalyzer("sample_resume.txt")
    try:
        resume_text = analyzer.load_resume()
        claims = analyzer.extract_claims(resume_text)
        if claims:
            df = analyzer.validate_claims(claims)
            print("Claim Validation Results:")
            print(df.to_string(index=False))
        else:
            print("No performance claims found in resume.")
    except Exception as e:
        logger.error(f"Analysis failed: {e}")
        raise

const express = require('express');
const { profiler } = require('v8-profiler-next');
const fs = require('fs').promises;
const path = require('path');
const { exec } = require('child_process');
const util = require('util');
const execPromise = util.promisify(exec);

// Initialize express app
const app = express();
app.use(express.json());

// In-memory metrics store
const metrics = {
  requests: 0,
  errors: 0,
  profileCount: 0,
};

// Middleware to track request counts
app.use((req, res, next) => {
  metrics.requests++;
  res.on('finish', () => {
    if (res.statusCode >= 400) metrics.errors++;
  });
  next();
});

// Simulate a slow database query (common interview performance problem)
const simulateDBQuery = async (delayMs) => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({ data: `Query completed after ${delayMs}ms` });
    }, delayMs);
  });
};

// Sample endpoint with intentional performance issue: unbatched DB calls
app.get('/users', async (req, res) => {
  try {
    const userIds = req.query.ids?.split(',') || [];
    if (userIds.length === 0) {
      return res.status(400).json({ error: 'No user IDs provided' });
    }
    // INTENTIONAL BUG: Sequential DB calls instead of batched
    const users = [];
    for (const id of userIds) {
      const user = await simulateDBQuery(100); // 100ms per user
      users.push({ id, ...user });
    }
    res.json(users);
  } catch (err) {
    metrics.errors++;
    res.status(500).json({ error: 'Failed to fetch users' });
  }
});

// Endpoint to trigger CPU profiling (mimics interview debugging task)
app.post('/debug/profile', async (req, res) => {
  try {
    const duration = req.body.duration || 5000; // default 5s profile
    if (duration < 1000 || duration > 30000) {
      return res.status(400).json({ error: 'Duration must be between 1s and 30s' });
    }

    // Start V8 CPU profiler
    profiler.startProfiling('cpu-profile', true);
    metrics.profileCount++;

    // Wait for profile duration
    await new Promise((resolve) => setTimeout(resolve, duration));

    // Stop profiling and save to file
    const profile = profiler.stopProfiling('cpu-profile');
    const fileName = `profile_${Date.now()}.cpuprofile`;
    const filePath = path.join(__dirname, 'profiles', fileName);

    // Ensure profiles directory exists
    await fs.mkdir(path.join(__dirname, 'profiles'), { recursive: true });
    await new Promise((resolve, reject) => {
      profile.export((err, result) => {
        if (err) return reject(err);
        fs.writeFile(filePath, result)
          .then(resolve)
          .catch(reject);
      });
    });

    // Cleanup profile from memory
    profile.delete();

    res.json({
      message: 'Profile collected successfully',
      filePath,
      durationMs: duration,
    });
  } catch (err) {
    metrics.errors++;
    res.status(500).json({ error: `Profiling failed: ${err.message}` });
  }
});

// Metrics endpoint for interview debugging
app.get('/metrics', (req, res) => {
  res.json(metrics);
});

// Helper function to run Docker commands (simulates containerized interview environment)
const getContainerStats = async () => {
  try {
    const { stdout } = await execPromise('docker stats --no-stream --format "{{.Container}} {{.CPUPerc}} {{.MemUsage}}"');
    return stdout;
  } catch (err) {
    throw new Error(`Failed to get container stats: ${err.message}`);
  }
};

// Endpoint to get container stats (interview question addition)
app.get('/debug/stats', async (req, res) => {
  try {
    const stats = await getContainerStats();
    res.type('text/plain').send(stats);
  } catch (err) {
    metrics.errors++;
    res.status(500).json({ error: err.message });
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Debug server running on port ${PORT}`);
  console.log('Endpoints:');
  console.log('  GET  /users?ids=1,2,3');
  console.log('  POST /debug/profile');
  console.log('  GET  /metrics');
  console.log('  GET  /debug/stats');
});

hyperfine --warmup 3 --runs 10 --export-json results.json \
  'go run unoptimized_server.go' \
  'go run optimized_server.go'

perf record -g -F 99 ./your-app
perf script | stackcollapse-perf.pl > out.perf-folded
flamegraph.pl out.perf-folded > cpu-flamegraph.svg

const { profiler } = require('v8-profiler-next');
profiler.startProfiling('endpoint-profile', true);
// ... run your endpoint test ...
const profile = profiler.stopProfiling('endpoint-profile');