hotpath 0.1.0

Minmal performance profiler for Rust applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

# HotPath

A lightweight Rust performance measurement library with async background processing.

## Features

- **Zero-overhead** function measurement with `#[measure]` attribute
- **Async background processing** via MPSC channels
- **Full module path tracking** (e.g., `my_app::services::db::connect`)
- **High-performance** with RwLock for concurrent access
- **Graceful shutdown** with proper resource cleanup

## Quick Start

Add to your `Cargo.toml`:

```toml
[dependencies]
hotpath = "0.1"
tokio = { version = "1.0", features = ["full"] }
```

## Usage

```rust
use hotpath::{measure, HotPath};
use std::time::Duration;

#[measure]
fn sync_function() {
    std::thread::sleep(Duration::from_millis(100));
}

#[measure]
async fn async_function() {
    tokio::time::sleep(Duration::from_millis(150)).await;
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize the background measurement processor
    HotPath::init().await?;

    // Your measured functions will automatically send metrics
    sync_function();
    async_function().await;

    // Graceful shutdown - processes remaining measurements
    HotPath::finalize().await?;

    Ok(())
}
```

Output:
```
[HotPath] my_app::sync_function took 105.0ms
[HotPath] my_app::async_function took 152.1ms
[HotPath] Background task shutting down
```

## How It Works

1. **`#[measure]`** - Proc-macro that wraps functions with timing code
2. **Background MPSC** - Measurements are sent to a background task via unbounded channel
3. **Non-blocking** - Function execution continues immediately after sending measurement
4. **Async processing** - Background task prints measurements without blocking your code

## API

### `HotPath::init()`
Starts the background measurement processing task. Call once at application startup.

### `HotPath::finalize()`
Gracefully shuts down the background task, processing any remaining measurements. Call before application exit.

### `#[measure]`
Attribute macro that instruments functions to send timing measurements to the background processor.