perf-profiler

Profile application performance to identify CPU, memory, and latency bottlenecks.

2|1|Updated Mar 2, 2026
One-click install
npx skills add https://github.com/albertdobmeyer/opentrapp --skill perf-profiler-albertdobmeyer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: perf-profiler
Source: https://github.com/albertdobmeyer/opentrapp/tree/main/workloads/skills/skills/perf-profiler
Command: npx skills add https://github.com/albertdobmeyer/opentrapp --skill perf-profiler-albertdobmeyer

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps diagnose why software feels slow by revealing where CPU time, memory growth, latency, and database work are being spent.

Core Features & Use Cases

  • CPU Profiling: Capture hot paths and flame graphs to see which functions dominate runtime.
  • Memory Analysis: Inspect heap growth, snapshots, and leak patterns to catch runaway allocations.
  • Benchmarking and Load Testing: Compare implementations, measure regressions, and validate service performance under realistic traffic.
  • Use Case: A developer can use this Skill to investigate a slow API, confirm whether the bottleneck is application code or a database query, and then verify the improvement after a fix.

Quick Start

Use the perf-profiler skill to profile the slow workflow, identify the main bottleneck, and recommend the most effective optimization steps.

Frequently Asked Questions about perf-profiler

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I identify CPU and memory bottlenecks in Node.js, Python, or Go applications?

To identify CPU and memory bottlenecks, you profile application performance by capturing hot paths, flame graphs, and heap snapshots. This reveals exactly which functions dominate runtime and where runaway allocations occur across Node.js, Python, and Go workloads.

What's the best way to detect memory leaks using heap snapshots?

The best way to detect memory leaks is by analyzing heap growth and snapshot patterns. By inspecting these leak patterns, you can catch runaway allocations and pinpoint exactly where memory growth is occurring before shipping your code.

How do I profile a slow API to determine if the bottleneck is application code or a database query?

To profile a slow API, you apply timing tools and profiler outputs to compare hotspots. This process isolates whether the latency bottleneck originates from application code execution or underlying database query tuning issues.

Can I use load testing to measure performance regressions and validate service improvements?

Yes, load testing measures performance regressions and validates service improvements. By running benchmark implementations under realistic traffic, you can compare implementations, observe hotspots, and confirm that optimizations actually resolve the bottlenecks.

When do I need pprof-style diagnostics for benchmarking and flame graph analysis?

You need pprof-style diagnostics when you must compare hotspots and validate improvements across complex workloads. These diagnostics capture detailed flame graphs and timing tool outputs required to accurately benchmark and profile CPU latency or memory issues.

Does this profiling approach work across Node.js, Python, and Go workloads simultaneously?

Yes, this profiling approach works across Node.js, Python, and Go workloads. It applies standard timing tools, profiler outputs, benchmark runners, and pprof-style diagnostics to consistently compare hotspots and validate improvements regardless of the runtime environment.