# hotpath-rs

> A simple Rust performance profiler for CPU, memory, async, Tokio, SQL, HTTP, I/O, locks and channels, with Prometheus and Grafana integration.

## Docs

- [Home](https://hotpath.rs/): A simple Rust performance profiler for CPU, memory, async, Tokio, SQL, HTTP, I/O, locks and channels, with Prometheus and Grafana integration.
- [Profiling Modes](https://hotpath.rs/profiling_modes): Two ways to profile Rust performance: static reports for one-off analysis and a live monitoring dashboard for real-time runtime metrics. Track timing, memory, and data flow with hotpath-rs.
- [Functions](https://hotpath.rs/functions): Profile Rust function performance with precise timing metrics, memory allocation tracking, and percentile statistics. Measure sync and async functions to find and optimize runtime bottlenecks.
- [CPU Profiling](https://hotpath.rs/cpu_profiling): Profile CPU usage in Rust applications with hotpath-rs and samply. Combine sampling-based CPU profiling with instrumentation-based timing and allocation tracking to diagnose CPU, I/O, and memory bottlenecks.
- [Rust Channels Performance](https://hotpath.rs/data_flow): Profile async data flow in Rust. Measure channels performance, latency, queue, depth and messages ratio. Monitor streams and futures to discover async bottlenecks.
- [Locks](https://hotpath.rs/locks): Profile lock contention in Rust with hotpath-rs. Track wait time and hold time for std, parking_lot, Tokio, and async-lock RwLocks and Mutexes to find concurrency bottlenecks.
- [SQL Queries](https://hotpath.rs/sql_tracing): Profile database query execution time in Rust with hotpath-rs. Surface slow statements and repetitive query patterns across sqlx, SeaORM, Diesel and Toasty, with queries bucketed by normalized statement text.
- [HTTP requests](https://hotpath.rs/http_tracing): Profile outgoing HTTP requests in Rust with hotpath-rs. Wrap your reqwest client once to track per-endpoint call counts, error counts, average latency and percentiles, with requests grouped by normalized endpoint.
- [HTTP server (axum)](https://hotpath.rs/axum_tracing): Profile axum HTTP servers in Rust with hotpath-rs. Wrap your router once to track per-route request counts, 4xx/5xx errors, average latency and percentiles, with SQL queries and outbound HTTP calls attributed to the route that triggered them.
- [I/O tracing](https://hotpath.rs/io_tracing): Monitor byte-level I/O in Rust with hotpath-rs. Track operation counts, bytes processed, throughput, durations and errors for files, sockets, TLS and compression streams - sync std::io and async tokio::io.
- [Debug & Metrics](https://hotpath.rs/debug): Track values and log debug info during Rust profiling with hotpath::dbg!, hotpath::val!, and hotpath::gauge! macros. View real-time metrics in the TUI Data Flow tab or query via HTTP API and MCP.
- [Threads](https://hotpath.rs/threads): Monitor per-thread CPU usage and memory allocation metrics in Rust applications. Track thread states, allocation counts, and system time in the hotpath-rs monitoring dashboard.
- [Tokio Runtime](https://hotpath.rs/tokio_runtime): Monitor Tokio runtime metrics with hotpath-rs. Track tokio-runtime-worker thread utilization, work stealing, global and local queue depth, and task scheduling via Handle::metrics() for real-time Rust async monitoring.
- [Profiling Overhead](https://hotpath.rs/profiling_overhead): How much overhead does hotpath-rs add? Per-operation benchmark results for function timing, locks, channels, futures and streams instrumentation, plus time sampling to reduce the cost further.
- [Configuration](https://hotpath.rs/configuration): Configure hotpath-rs profiling with environment variables. Control output format, metrics server ports, MCP integration, Prometheus exporter, TUI refresh intervals, function filtering, memory tracking mode, and monitoring intervals.
- [MCP Integration](https://hotpath.rs/mcp): Connect LLM agents like Claude Code to live Rust performance metrics via MCP. Query runtime profiling data, memory usage, and async operations in natural language.
- [Cloud](https://hotpath.rs/cloud): Performance regression testing for Rust in CI: hotpath Cloud compares the report a pull request produced with its base branch, judges the change under a per-repository policy and posts the verdict as a PR comment. Work in progress.
- [CI integration](https://hotpath.rs/ci_integration): Set up hotpath Cloud in GitHub Actions: upload a benchmark report from CI, compare every pull request with its base branch and get the verdict as a PR comment.
- [Regression policy](https://hotpath.rs/regression_policy): Decide what counts as a performance regression in hotpath Cloud: a TOML policy per repository or benchmark with judged metric families, thresholds, call floors and ignore patterns.
- [Performance budgets](https://hotpath.rs/performance_budgets): Set hard limits on allocations, timing and call counts of Rust functions, SQL queries, HTTP calls and routes. hotpath Cloud checks performance budgets on every report, without a baseline.
- [Agents & CLI](https://hotpath.rs/agents_cli): Read hotpath Cloud reports, diffs and policies from the command line. The hotpath cloud CLI prints the pull request verdict as JSON, with exit codes coding agents and scripts can branch on.
- [Cloud FAQ](https://hotpath.rs/cloud_faq): Frequently asked questions about hotpath Cloud.
- [Prometheus & Grafana](https://hotpath.rs/prometheus_grafana): Export Rust profiling data to Prometheus with hotpath-rs. Scrape function timings, allocations, SQL and HTTP latencies, locks, channels, I/O, threads and Tokio runtime metrics as native histograms and build Grafana dashboards on top.
- [FAQ](https://hotpath.rs/faq): Frequently asked questions about hotpath-rs, the lightweight Rust profiler for timing, memory allocations, async code, SQL, HTTP, I/O and threads.

## Blog

- [How to Profile Rust Performance using Grafana and Prometheus](https://hotpath.rs/blog/rust-performance-grafana): Monitor Rust app performance in production with Grafana and Prometheus. Copy-paste PromQL queries for hotpath-rs metrics: SQL time and N+1 detection per Axum route, HTTP call overhead, memory allocations per request, channel and lock contention, Tokio workers and per-thread CPU, plus a way to verify that profiling overhead stays negligible.
- [Profiling Rust: The Complete Guide - From SQL Queries to CPU Sampling](https://hotpath.rs/blog/profiling-rust-guide): A complete guide to profiling Rust applications, layer by layer: N+1 SQL query detection, parallelizing HTTP calls, I/O throughput, Mutex and RwLock contention, channel queue depth, memory allocations, and CPU sampling. Each layer comes with a real bottleneck, the hotpath-rs report that exposes it, and a measurable fix.
- [Profiling Async and Concurrent Rust: Channels and Lock Contention](https://hotpath.rs/blog/profiling-async-rust): New hotpath-rs instrumentation APIs expose async, channel, and lock contention bottlenecks that traditional Rust profilers miss, including the new wrap channel pattern from hotpath 0.18.0.
- [Lessons Learned Building High-Performance Rust Profiler](https://hotpath.rs/blog/rust-performance-profiling): The Rust performance book features over a dozen different profiling tools. So I'm not sure if the world needed a new Rust profiler. Still, I spent the last 6+ months building hotpath-rs. In this post, I'll describe the design decisions behind the library and share a few performance challenges I encountered while working on it. We'll go deep into the low-level details like cache-line contention, async futures instrumentation, and decoding raw CPU traces back into Rust symbols.
- [Cargo Flamegraph Alternatives for Rust Performance Profiling](https://hotpath.rs/blog/sampling_comparison): Cargo flamegraph alternatives for Rust performance profiling. See how hotpath-rs instrumentation differs from sampling profilers like perf, cargo flamegraph, and samply for CPU-bound, blocking I/O, and async workloads.

## Optional

- [Used by](https://hotpath.rs/adoption): Public GitHub repositories that depend on hotpath for Rust performance profiling. The list is refreshed regularly from a GitHub code search.
- [Sponsorship](https://hotpath.rs/sponsorship): Sponsor hotpath-rs and reach Rust developers through logo placement in the README and documentation site. Limited sponsorship slots support continued work on the open-source Rust profiler.
- [Terms](https://hotpath.rs/terms): hotpath-rs terms of service and privacy policy.