playbooks

home / skills / jeremylongshore / claude-code-plugins-plus-skills / flame-graph-generator

flame-graph-generator skill

/skills/10-performance-testing/flame-graph-generator

This skill helps you automate flame graph generation for performance testing, providing step-by-step guidance, production-ready configs, and validation.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill flame-graph-generator

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.2 KB
---
name: "flame-graph-generator"
description: |
  Generate flame graph generator operations. Auto-activating skill for Performance Testing.
  Triggers on: flame graph generator, flame graph generator
  Part of the Performance Testing skill category. Use when working with flame graph generator functionality. Trigger with phrases like "flame graph generator", "flame generator", "flame".
allowed-tools: "Read, Write, Edit, Bash(cmd:*)"
version: 1.0.0
license: MIT
author: "Jeremy Longshore <[email protected]>"
---

# Flame Graph Generator

## Overview

This skill provides automated assistance for flame graph generator tasks within the Performance Testing domain.

## When to Use

This skill activates automatically when you:
- Mention "flame graph generator" in your request
- Ask about flame graph generator patterns or best practices
- Need help with performance testing skills covering load testing, stress testing, benchmarking, and performance monitoring.

## Instructions

1. Provides step-by-step guidance for flame graph generator
2. Follows industry best practices and patterns
3. Generates production-ready code and configurations
4. Validates outputs against common standards

## Examples

**Example: Basic Usage**
Request: "Help me with flame graph generator"
Result: Provides step-by-step guidance and generates appropriate configurations


## Prerequisites

- Relevant development environment configured
- Access to necessary tools and services
- Basic understanding of performance testing concepts


## Output

- Generated configurations and code
- Best practice recommendations
- Validation results


## Error Handling

| Error | Cause | Solution |
|-------|-------|----------|
| Configuration invalid | Missing required fields | Check documentation for required parameters |
| Tool not found | Dependency not installed | Install required tools per prerequisites |
| Permission denied | Insufficient access | Verify credentials and permissions |


## Resources

- Official documentation for related tools
- Best practices guides
- Community examples and tutorials

## Related Skills

Part of the **Performance Testing** skill category.
Tags: performance, load-testing, k6, jmeter, benchmarking

Overview

This skill automates flame graph generator tasks for performance testing. It provides step‑by‑step guidance, generates production‑ready code and configurations, and validates outputs against common standards. Use it to accelerate profiling, visualization, and interpretation of application CPU and sampling data.

How this skill works

The skill inspects profiler output (sampling stacks, pprof, perf.data, or trace files) and maps stack samples to call paths to produce a flame graph-compatible format. It can output folded stack text, generate SVG flame graphs, and produce configuration snippets to integrate with CI or load test runs. It validates input formats and reports common issues like missing symbols or sampling gaps.

When to use it

  • When you need a visual breakdown of CPU or function-level hotspots from profiler output
  • While converting profiler outputs (pprof, perf, async-profiler) into flame graph format
  • During performance test analysis to prioritize optimization work
  • When automating profiling in CI pipelines or load testing jobs
  • When creating reproducible profiling artifacts for team reviews

Best practices

  • Collect representative samples under realistic load to avoid misleading hotspots
  • Use symbol-enabled builds or provide debug symbols for accurate function names
  • Keep sample duration long enough to capture rare but important paths
  • Integrate generation into CI with versioned artifacts and retention policies
  • Annotate flame graphs with context (test scenario, input size, environment)

Example use cases

  • Convert perf.data from a Linux perf recording into a flame graph SVG for a high-CPU incident
  • Automate async-profiler runs at the end of load tests and upload generated graphs to an artifact store
  • Generate folded stack files for comparison across two runs to show regressions
  • Embed flame graph generation in CI to fail builds when new hotspots exceed thresholds
  • Produce human-readable reports that include flame graph images and short remediation steps

FAQ

What input formats are supported?

Common profiler outputs such as perf.data, pprof, async-profiler traces, and folded stack text are supported. If symbols are missing, the output will include raw addresses and a note to supply debug symbols.

Can this run automatically in CI?

Yes. The skill can produce scripts and configs to run profiling under load, generate flame graphs, validate results, and archive artifacts as part of CI pipelines.