performance-profiler

Performance Profiler

Systematic performance profiling for Node.js, Python, and Go applications. Identifies CPU bottlenecks with flamegraphs, detects memory leaks with heap snapshots, analyzes bundle sizes, optimizes database queries, detects N+1 patterns, and runs load tests with k6 and Artillery. Enforces a measure-first methodology: establish baseline, identify bottleneck, fix, and verify improvement.

Golden Rule — Measure First: Profile → Confirm bottleneck → Fix → Measure again → Verify improvement. Every optimization needs baseline metrics, profiler evidence, the fix, post-fix metrics, and a delta. Full rule in references/cpu-and-memory-profiling.md.

Core Capabilities

• CPU profiling — Clinic.js/V8 flamegraphs (Node), py-spy/cProfile/scalene (Python), pprof (Go), Chrome DevTools (browser).
• Memory profiling — heap snapshots and before/after comparison, GC pressure analysis, leak detection, retained object graphs.
• Database optimization — EXPLAIN ANALYZE plan reading, N+1 detection and batching, slow query logs, missing-index identification, connection pool sizing.
• Bundle analysis — webpack/Next.js analyzers, tree-shaking, dynamic imports, heavy dependency identification.
• Load testing — k6 ramp-up scripts, SLA threshold enforcement in CI, P50/P95/P99 latency tracking, concurrent user simulation.

When to Use

• App is slow and you do not know where the bottleneck is.
• P99 latency exceeds SLA before a release.
• Memory usage grows over time (suspected leak).
• Bundle size increased after adding dependencies.
• Preparing for a traffic spike (load test before launch).
• Database queries taking >100ms, or verifying no regressions after a dependency upgrade.

Clarify First

Before profiling, settle the inputs below. When one is missing or vague and would change the result, ask about it; when it wouldn't, use a sensible default and say which one you used.

• Runtime & symptom: Node / Python / Go and CPU / memory / bundle / query / load-spike (selects the profiler and toolchain).
• Baseline + SLA target: current numbers and the P95/P99 (or size) threshold to beat (measure-first needs both to verify a delta).
• Environment: local / staging / prod determines the safe profiling method and whether load testing is allowed.

Ask about the two or three inputs that matter most for this request, not the whole list. If the user wants a result straight away, produce it and state your assumptions at the top.

Tools

Tool	Purpose	Command
benchmark_reporter.py	Parse benchmark results and report regressions/improvements vs thresholds	python scripts/benchmark_reporter.py results.json --fail-on-regression
bottleneck_detector.py	Analyze logs/traces to flag slow latency, queries, and spans	python scripts/bottleneck_detector.py trace.json --latency-threshold 200
resource_analyzer.py	Analyze CPU/memory/disk usage data and flag anomalies and trends	python scripts/resource_analyzer.py metrics.json --cpu-threshold 80

All three accept a file path or - for stdin and support --json.

References

Load the reference that matches the task — keep this file lean and pull detail on demand:

• references/cpu-and-memory-profiling.md — the full Measure-First rule, Node.js CPU profiling (Clinic.js flamegraphs, V8 CPU profiles), and memory leak detection (Node heap snapshots, Python memray/tracemalloc). Read when chasing CPU or memory issues.
• references/database-and-bundle.md — EXPLAIN ANALYZE workflow, N+1 detection patterns and middleware script, Next.js bundle analyzer setup, quick size checks, and the common-bundle-wins table. Read when optimizing queries or bundle size.
• references/load-testing-and-methodology.md — full k6 load-test script, the before/after measurement template, quick-win optimization checklist, common pitfalls, best practices, troubleshooting table, and success criteria. Read when load testing or documenting a win.

Scope & Limitations

This skill covers:

• CPU and memory profiling for Node.js, Python, and Go applications using flamegraphs and heap snapshots
• Database query optimization including EXPLAIN ANALYZE interpretation, N+1 detection, and index recommendations
• Frontend bundle analysis and size reduction strategies for webpack and Next.js projects
• Load testing methodology with k6 including ramp-up patterns, threshold enforcement, and CI integration

This skill does NOT cover:

• Application Performance Monitoring (APM) platform setup and configuration (Datadog, New Relic, Grafana) — see engineering/observability-designer
• Infrastructure-level performance tuning (kernel parameters, network stack, container resource limits) — see engineering/senior-devops
• Security-focused performance concerns such as DDoS mitigation or rate limiting — see engineering/senior-security
• Mobile application profiling (iOS Instruments, Android Profiler) — see engineering/senior-mobile

Integration Points

Skill	Integration	Data Flow
engineering/observability-designer	Performance profiling findings feed into observability dashboard design; alerting thresholds derived from profiling baselines	Profiler baselines and SLA thresholds → Prometheus/Grafana alert rules and dashboard panels
engineering/ci-cd-pipeline-builder	k6 load tests and bundle size checks integrate as CI pipeline gates	k6 threshold configs and bundle budget scripts → CI pipeline stage definitions
engineering/database-designer	Query optimization recommendations inform schema design decisions; index suggestions feed back to schema migrations	EXPLAIN ANALYZE findings and index recommendations → schema migration files and index definitions
engineering/senior-backend	Backend architecture decisions incorporate profiling data; connection pool sizing and caching strategies validated by load tests	Profiling reports and load test results → architecture decision records and implementation guidance
engineering/tech-debt-tracker	Performance regressions and unresolved bottlenecks are tracked as technical debt items with measured impact	Before/after measurement reports and unresolved findings → tech debt backlog with quantified cost
engineering/senior-frontend	Bundle analysis results drive frontend optimization work; code-splitting and lazy-loading decisions backed by profiler data	Bundle analyzer output and Lighthouse scores → frontend optimization tasks and component refactoring plans