hotpath-rs README

The project's README from github.com/pawurb/hotpath-rs. As one markdown file: README.md.

hotpath-rs logo hotpath - Rust Performance, CPU & Memory Profiler

GH Actions Latest Version Downloads Sponsor

A simple Rust profiler that shows exactly why your code is slow.

Performance feedback for developers and coding agents. Profile CPU, memory, async execution, SQL and HTTP calls, I/O streams, lock contention and channels. Built-in support for Prometheus metrics and Grafana dashboards.

Try the TUI demo via SSH - no installation required:

ssh demo.hotpath.rs

Or let your own AI agent configure profiling in a repo:

cargo install hotpath
hotpath init --agent claude # or --agent codex / --agent opencode

hotpath-rs is an easy-to-configure Rust performance profiling toolkit that shows exactly where your code spends time, burns CPU, and allocates memory.

It helps you distinguish between functions that are slow because they wait on I/O and those that are CPU-intensive. Instrument functions, channels, futures, streams, SQL queries, HTTP calls, and byte-level I/O to find bottlenecks and focus optimizations where they matter most. Get actionable insights into time, memory, and async data flow with minimal setup.

Explore the full documentation at hotpath.rs. See CONTRIBUTING.md for development setup and guidelines.

You can use it to produce one-off performance (timing, memory or CPU) reports:

hotpath alloc report

correlate all performance signals in Grafana with minimal profiling overhead:

Grafana dashboard built on hotpath-rs Prometheus metrics showing slowest SQL queries, per-function allocations and requests by route

inspect throughput and latency of network, file or compression I/O streams:

hotpath-rs I/O profiling report showing per-stream read counts, bytes, transfer rate, average and P95 latency

analyze SQL/HTTP calls performance with automatic source function attribution:

hotpath-rs SQL query profiling report showing per-query call counts, source function attribution, average and P95 execution time

monitor throughput, performance and max queue depth of instrumented channels:

hotpath-rs channel profiling report showing throughput, send-to-receive latency and max queue depth per channel

or use the live TUI dashboard to monitor real-time performance and async data flow metrics with debug info:

https://github.com/user-attachments/assets/2e890417-2b43-4b1b-8657-a5ef3b458153

Features

Getting Started

The quickest way to set up hotpath is to let your own AI coding agent do it. Install the hotpath CLI and run init inside your project repo:

cargo install hotpath --version '^0.28'
hotpath init --agent claude # or --agent codex / --agent opencode

hotpath init downloads the hotpath_init agent skill from GitHub and starts an interactive Claude Code, Codex or OpenCode session with it as setup instructions. The agent inspects your project, adds the feature-gated dependency, instruments main and a starting set of functions, channels and locks, then verifies that everything compiles with profiling enabled and disabled. You review and approve each edit through the agent's regular permission prompts. Requires curl and the claude, codex or opencode CLI on PATH.

You can also use the skill directly, without the hotpath CLI: copy it to ~/.claude/skills/hotpath_init/SKILL.md and run /hotpath_init in a Claude Code session.

Manual installation

Add to your Cargo.toml:

[dependencies]
hotpath = "0.28"

[features]
hotpath = ["hotpath/hotpath"]
hotpath-cpu = ["hotpath/hotpath-cpu"]
hotpath-alloc = ["hotpath/hotpath-alloc"]
hotpath-prometheus = ["hotpath/hotpath-prometheus"]

This config ensures that the lib has no compile time or runtime overhead unless explicitly enabled via a hotpath feature. All the lib dependencies are optional (i.e. not compiled) and all macros are noop unless profiling is enabled.

Basic setup

You'll need only #[hotpath::main] and #[hotpath::measure] macros to get started:

#[hotpath::measure]
fn sync_function(sleep: u64) {
    std::thread::sleep(Duration::from_nanos(sleep));
    let vec1 = vec![1, 2, 3];
    std::hint::black_box(&vec1); // force mem allocation
}

#[hotpath::measure]
async fn async_function(sleep: u64) {
    tokio::time::sleep(Duration::from_nanos(sleep)).await;
}

// When using with tokio, place the #[tokio::main] first
#[tokio::main]
#[hotpath::main]
async fn main() {
    for i in 0..10000 {
        sync_function(i);
        async_function(i * 2).await;

        hotpath::measure_block!("custom_block", {
            std::thread::sleep(Duration::from_nanos(i * 3))
        });
    }
}

Now, run your program with hotpath (and optionally hotpath-alloc features):

cargo run --features='hotpath,hotpath-alloc'

On exit it will print a report with timings, memory allocations and thread usage metrics:

[hotpath] 1.20s | timing, alloc, threads

timing - Function execution time metrics.
+------------------------------+-------+----------+----------+----------+---------+
| Function                     | Calls | Avg      | P95      | Total    | % Total |
+------------------------------+-------+----------+----------+----------+---------+
| docs_example::main           | 1     | 1.20 s   | 1.20 s   | 1.20 s   | 100.00% |
+------------------------------+-------+----------+----------+----------+---------+
| docs_example::async_function | 1000  | 1.15 ms  | 1.20 ms  | 1.15 s   | 96.10%  |
+------------------------------+-------+----------+----------+----------+---------+
| custom_block                 | 1000  | 18.13 µs | 31.71 µs | 18.13 ms | 1.51%   |
+------------------------------+-------+----------+----------+----------+---------+
| docs_example::sync_function  | 1000  | 16.58 µs | 27.63 µs | 16.58 ms | 1.38%   |
+------------------------------+-------+----------+----------+----------+---------+

alloc - Cumulative allocations during each function call (including nested calls).
+------------------------------+-------+---------+---------+---------+---------+
| Function                     | Calls | Avg     | P95     | Total   | % Total |
+------------------------------+-------+---------+---------+---------+---------+
| docs_example::main           | 1     | 63.0 KB | 63.1 KB | 63.0 KB | 100.00% |
+------------------------------+-------+---------+---------+---------+---------+
| docs_example::sync_function  | 1000  | 12 B    | 12 B    | 11.7 KB | 18.58%  |
+------------------------------+-------+---------+---------+---------+---------+
| custom_block                 | 1000  | 0 B     | 0 B     | 0 B     | 0.00%   |
+------------------------------+-------+---------+---------+---------+---------+
| docs_example::async_function | 1000  | 0 B     | 0 B     | 0 B     | 0.00%   |
+------------------------------+-------+---------+---------+---------+---------+

threads - Thread CPU and memory statistics. (RSS: 7.8 MB, Alloc: 2.1 MB, Dealloc: 304.3 KB, Diff: 1.8 MB, 5/10)
+--------------+------+------+----------+----------+----------+
| Thread       | Max% | Avg% | Alloc    | Dealloc  | Diff     |
+--------------+------+------+----------+----------+----------+
| hp-functions | 1.8% | 1.2% | 1.8 MB   | 291.3 KB | 1.5 MB   |
+--------------+------+------+----------+----------+----------+
| main         | 6.3% | 5.1% | 367.8 KB | 9.9 KB   | 357.9 KB |
+--------------+------+------+----------+----------+----------+
| hp-threads   | 0.0% | 0.0% | 10.3 KB  | 3.0 KB   | 7.3 KB   |
+--------------+------+------+----------+----------+----------+
| hp-server    | 0.0% | 0.0% | 1.8 KB   | 56 B     | 1.7 KB   |
+--------------+------+------+----------+----------+----------+
| thread_5     | -    | -    | 640 B    | 24 B     | 616 B    |
+--------------+------+------+----------+----------+----------+

Full documentation

See the full docs and advanced config tutorials at hotpath.rs.

Read the complete guide to profiling Rust applications - a comprehensive overview of debugging performance issues in Rust.

hotpath Cloud

My long-term goal for hotpath-rs is to become the single place to understand all performance signals in a Rust application. From CPU and memory usage to locks, channels, and async execution, all the way up to SQL queries and HTTP/RPC calls.

I'm also building a hosted version that makes profiling reports easier to share, compare, and analyze across pull requests, deployments, and teams. Read more: https://hotpath.rs/cloud

Status

This project is under active development. Core public APIs are stable, but implementation details (JSON report formats, TUI/MCP internals, and advanced config options) may change between releases as the project evolves.

hotpath-rs (pawurb/hotpath-rs)

Searching Database…

1.9K ·GitHub
Hotpath-rs
Что это?hotpath-rs — это профилировщик производительности для Rust, который показывает, где именно ваш код тратит время, грузит CPU и выделяет память, охватывая асинхронное выполнение, вызовы SQL/HTTP, потоки ввода-вывода и конкуренцию за блокировки.
Это Rust-библиотека для моего проекта или отдельный инструмент?Это прежде всего библиотека: вы добавляете её как Cargo-зависимость с feature-флагом и помечаете функции макросами #[hotpath::main] и #[hotpath::measure]. В комплекте также идут сопутствующий hotpath CLI для настройки и живая TUI-панель, плюс MCP-сервер для AI-агентов.
Как запустить его в своём проекте?Рекомендуемый способ — установить hotpath CLI и выполнить 'hotpath init' в своём репозитории: это запустит вашего AI-агента для кодинга (Claude Code, Codex или OpenCode), который сам добавит зависимость и инструментирует код. Как вариант, добавьте крейт hotpath в Cargo.toml вручную и сами примените макросы #[hotpath::main]/#[hotpath::measure].
Нужен ли AI-агент для кодинга, чтобы воспользоваться автоматической настройкой?Только для рекомендуемой настройки с помощью AI, которая требует curl и один из CLI — claude, codex или opencode — в PATH. Ручная установка требует лишь правки Cargo.toml и макросов профилирования, агент не нужен.
Добавляет ли профилирование накладные расходы, если оставить его в сборке?Нет — все зависимости опциональны, а макросы превращаются в no-op, пока фича-флаг hotpath явно не включён, так что при отключении нет никаких затрат ни на этапе компиляции, ни во время выполнения. Учтите, что проект ещё в активной разработке, поэтому внутренности вроде форматов JSON-отчётов и деталей TUI/MCP могут меняться между релизами.
Для кого это создано?Он нацелен на Rust-разработчиков (и их агентов для кодинга), которым нужно диагностировать медленные функции, утечки памяти, асинхронные узкие места или медленные вызовы SQL/HTTP, а не на обычных пользователей приложений.
Можно попробовать hotpath, ничего не устанавливая?Да, в README предлагается TUI-демо, доступное по SSH и не требующее установки.
Что делает встроенный MCP-сервер?Он поднимает MCP-сервер (Model Context Protocol), чтобы AI-агенты могли напрямую запрашивать живые данные профилирования: тайминги, использование памяти и асинхронные метрики.
Какие SQL- и HTTP-библиотеки он умеет профилировать?Он профилирует SQL-запросы для sqlx и Diesel, вызовы HTTP-клиентов reqwest и ureq, а также маршруты HTTP-сервера axum, с метриками задержек и ошибок по каждому эндпоинту.
Может ли он интегрироваться с моей существующей системой мониторинга?Да, hotpath экспортирует метрики профилирования в Prometheus и позволяет строить дашборды Grafana, чтобы собрать все сигналы производительности в одном месте.
What are similar projects?openobserve, pgbot, scalene, claude-code, bifrost, grafana, memray, 3d-asset-server
Which topics is it in?profiler, grafana, cpu, metrics, prometheus, concurrency, async, debugging, agent-skill, high-performance, memory, redis
Creator
pawurb
Size
46.9 MB
Stars
1.9K
Updated
CommitOct 17Releasev0.28.6Oct 08
Age
1y
Commits · 90 Days