hotpath 0.15.0

Simple async Rust profiler with memory and data-flow insights - quickly find and debug performance bottlenecks.
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use eyre::Result;
use hotpath::ProfilingMode;
use serde::Deserialize;
use serde_json::json;

#[derive(Debug, Deserialize)]
struct GitHubUser {
    login: String,
    #[serde(rename = "type")]
    user_type: String,
}

#[derive(Debug, Deserialize)]
struct GitHubComment {
    id: u64,
    body: String,
    user: GitHubUser,
}

fn find_existing_comment(
    repo: &str,
    pr_number: &str,
    token: &str,
    profiling_mode: &ProfilingMode,
    benchmark_id: Option<&str>,
) -> Result<Option<u64>> {
    let url = format!(
        "https://api.github.com/repos/{}/issues/{}/comments",
        repo, pr_number
    );

    let response = ureq::get(&url)
        .header("Authorization", &format!("token {}", token))
        .header("Accept", "application/vnd.github.v3+json")
        .header("User-Agent", "hotpath-utils-action")
        .call();

    match response {
        Ok(mut resp) => {
            let comments: Vec<GitHubComment> = resp.body_mut().read_json()?;

            let search_marker = match benchmark_id {
                Some(id) => format!("**Benchmark ID:** {}", id),
                None => format!("**Profiling Mode:** {}", profiling_mode),
            };

            for comment in comments {
                if comment.user.user_type == "Bot"
                    && comment.user.login == "github-actions[bot]"
                    && comment.body.contains(&search_marker)
                {
                    return Ok(Some(comment.id));
                }
            }

            Ok(None)
        }
        Err(e) => {
            println!("Warning: Failed to fetch existing comments: {}", e);
            Ok(None)
        }
    }
}

fn create_comment(repo: &str, pr_number: &str, token: &str, body: &str) -> Result<()> {
    let url = format!(
        "https://api.github.com/repos/{}/issues/{}/comments",
        repo, pr_number
    );

    let comment_body = json!({
        "body": body,
    });

    let response = ureq::post(&url)
        .header("Authorization", &format!("token {}", token))
        .header("Accept", "application/vnd.github.v3+json")
        .header("User-Agent", "hotpath-utils-action")
        .send_json(&comment_body)?;

    let status = response.status();
    if status.is_success() {
        println!("Successfully created new comment");
        Ok(())
    } else {
        let error_text = response.into_body().read_to_string()?;
        println!("Failed to create comment: {}", status);
        println!("Error details: {}", error_text);
        if status.as_u16() == 403 {
            println!("This is likely a permissions issue. Make sure the workflow has:");
            println!("permissions:");
            println!("  pull-requests: write");
            println!("  contents: read");
        }
        Err(eyre::eyre!("Failed to create comment"))
    }
}

fn update_comment(repo: &str, comment_id: u64, token: &str, body: &str) -> Result<()> {
    let url = format!(
        "https://api.github.com/repos/{}/issues/comments/{}",
        repo, comment_id
    );

    let comment_body = json!({
        "body": body,
    });

    let response = ureq::patch(&url)
        .header("Authorization", &format!("token {}", token))
        .header("Accept", "application/vnd.github.v3+json")
        .header("User-Agent", "hotpath-utils-action")
        .send_json(&comment_body)?;

    let status = response.status();
    if status.is_success() {
        println!("Successfully updated existing comment");
        Ok(())
    } else {
        let error_text = response.into_body().read_to_string()?;
        println!("Failed to update comment: {}", status);
        println!("Error details: {}", error_text);
        Err(eyre::eyre!("Failed to update comment"))
    }
}

pub fn upsert_pr_comment(
    repo: &str,
    pr_number: &str,
    token: &str,
    body: &str,
    profiling_mode: &ProfilingMode,
    benchmark_id: Option<&str>,
) -> Result<()> {
    match find_existing_comment(repo, pr_number, token, profiling_mode, benchmark_id) {
        Ok(Some(comment_id)) => {
            println!(
                "Found existing comment (id: {}) for profiling mode: {}",
                comment_id, profiling_mode
            );
            update_comment(repo, comment_id, token, body)
        }
        Ok(None) => {
            println!("No existing comment found, creating new comment");
            create_comment(repo, pr_number, token, body)
        }
        Err(e) => {
            println!("Error searching for existing comment: {}", e);
            println!("Falling back to creating new comment");
            create_comment(repo, pr_number, token, body)
        }
    }
}