feat/add codspeed cli

Cargo.toml

@@ -5,10 +5,14 @@ edition = "2021"
 repository = "https://github.com/CodSpeedHQ/runner"
 publish = false
 
+[[bin]]
+name = "codspeed"
+path = "src/main.rs"
+
 
 [dependencies]
 anyhow = "1.0.75"
-clap = { version = "4.4.8", features = ["derive", "env"] }
+clap = { version = "4.4.8", features = ["derive", "env", "color"] }
 itertools = "0.11.0"
 lazy_static = "1.4.0"
 log = "0.4.20"
@@ -30,9 +34,17 @@ tokio-tar = "0.3.1"
 md5 = "0.7.0"
 base64 = "0.21.0"
 async-compression = { version = "0.4.5", features = ["tokio", "gzip"] }
-simplelog = { version = "0.12.1", default-features = false }
+simplelog = { version = "0.12.1", default-features = false, features = [
+    "termcolor",
+] }
 tempfile = "3.10.0"
 git2 = "0.18.3"
+nestify = "0.3.3"
+gql_client = { git = "https://github.com/CodSpeedHQ/gql-client-rs" }
+serde_yaml = "0.9.34"
+sysinfo = { version = "0.30.12", features = ["serde"] }
+indicatif = "0.17.8"
+console = "0.15.8"
 
 [dev-dependencies]
 temp-env = { version = "0.3.6", features = ["async_closure"] }

README.md

@@ -1,17 +1,17 @@
 <div align="center">
-<h1><code>codspeed-runner</code></h1>
+<h1>CodSpeed CLI</h1>
 
-CLI to gather performance data from CI environments and upload performance reports to [CodSpeed](https://codspeed.io)
+CLI to gather performance data and upload performance reports to [CodSpeed](https://codspeed.io)
 
 [![CI](https://github.com/CodSpeedHQ/runner/actions/workflows/ci.yml/badge.svg)](https://github.com/CodSpeedHQ/runner/actions/workflows/ci.yml)
 [![Discord](https://img.shields.io/badge/chat%20on-discord-7289da.svg)](https://discord.com/invite/MxpaCfKSqF)
 [![CodSpeed Badge](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/)
 
 </div>
 
-The `codspeed-runner` CLI is designed to be used in CI environments.
+The `codspeed` CLI is designed to be used both in **local** in **CI environments**.
 
-The following providers are supported:
+The following CI providers are supported:
 
 - [GitHub Actions](https://docs.codspeed.io/ci/github-actions): Usage with [`@CodSpeedHQ/action`](https://github.com/CodSpeedHQ/action) is recommended.
 - [Buildkite](https://docs.codspeed.io/ci/buildkite)
@@ -20,7 +20,7 @@ The following providers are supported:
 
 If you want to use the CLI with another provider, you can open an issue or chat with us on [Discord](https://discord.com/invite/MxpaCfKSqF) 🚀
 
-You can check out the implementation of the [supported providers](https://github.com/CodSpeedHQ/runner/tree/main/src/ci_provider) for reference.
+You can check out the implementation of the [supported providers](https://github.com/CodSpeedHQ/runner/tree/main/src/run/ci_provider) for reference.
 
 ## Installation
 
@@ -35,16 +35,31 @@ Refer to the [releases page](https://github.com/CodSpeedHQ/runner/releases) to s
 ## Usage
 
 > [!NOTE]
-> For now, the CLI only supports Ubuntu 20.04 and 22.04.
+> For now, the CLI only supports Ubuntu 20.04, 22.04, and Debian 11, 12.
 
-Example of a command to run benchmarks with [Vitest](https://docs.codspeed.io/benchmarks/nodejs/vitest):
+First, authenticate with your CodSpeed account:
 
 ```bash
-codspeed-runner --token=$CODSPEED_TOKEN -- pnpm vitest bench
+codspeed auth login
+```
+
+Then, run benchmarks with the following command:
+
+```bash
+codspeed run <my-benchmark-command>
+
+# Example, using https://github.com/CodSpeedHQ/codspeed-rust
+codspeed run cargo codspeed run
+
+# Example, using https://github.com/CodSpeedHQ/pytest-codspeed
+codspeed run pytest ./tests --codspeed
+
+# Example, using https://github.com/CodSpeedHQ/codspeed-node/tree/main/packages/vitest-plugin
+codspeed run pnpm vitest bench
 ```
 
 ```
-Usage: codspeed-runner [OPTIONS] [COMMAND]...
+Usage: codspeed run [OPTIONS] [COMMAND]...
 
 Arguments:
   [COMMAND]...  The bench command to run
@@ -65,5 +80,5 @@ Options:
 Use the `CODSPEED_LOG` environment variable to set the logging level:
 
 ```bash
-CODSPEED_LOG=debug codspeed-runner ...
+CODSPEED_LOG=debug codspeed run ...
 ```

src/api_client.rs

@@ -0,0 +1,216 @@
+use std::fmt::Display;
+
+use crate::prelude::*;
+use crate::{app::Cli, config::CodSpeedConfig};
+use console::style;
+use gql_client::{Client as GQLClient, ClientConfig};
+use nestify::nest;
+use serde::{Deserialize, Serialize};
+
+pub struct CodSpeedAPIClient {
+    gql_client: GQLClient,
+    unauthenticated_gql_client: GQLClient,
+}
+
+impl TryFrom<&Cli> for CodSpeedAPIClient {
+    type Error = Error;
+    fn try_from(args: &Cli) -> Result<Self> {
+        let codspeed_config = CodSpeedConfig::load()?;
+
+        Ok(Self {
+            gql_client: build_gql_api_client(&codspeed_config, args.api_url.clone(), true),
+            unauthenticated_gql_client: build_gql_api_client(
+                &codspeed_config,
+                args.api_url.clone(),
+                false,
+            ),
+        })
+    }
+}
+
+fn build_gql_api_client(
+    codspeed_config: &CodSpeedConfig,
+    api_url: String,
+    with_auth: bool,
+) -> GQLClient {
+    let headers = if with_auth && codspeed_config.auth.token.is_some() {
+        let mut headers = std::collections::HashMap::new();
+        headers.insert(
+            "Authorization".to_string(),
+            codspeed_config.auth.token.clone().unwrap(),
+        );
+        headers
+    } else {
+        Default::default()
+    };
+
+    GQLClient::new_with_config(ClientConfig {
+        endpoint: api_url,
+        timeout: Some(10),
+        headers: Some(headers),
+        proxy: None,
+    })
+}
+
+nest! {
+    #[derive(Debug, Deserialize, Serialize)]*
+    #[serde(rename_all = "camelCase")]*
+    struct CreateLoginSessionData {
+        create_login_session: pub struct CreateLoginSessionPayload {
+            pub callback_url: String,
+            pub session_id: String,
+        }
+    }
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct ConsumeLoginSessionVars {
+    session_id: String,
+}
+nest! {
+    #[derive(Debug, Deserialize, Serialize)]*
+    #[serde(rename_all = "camelCase")]*
+    struct ConsumeLoginSessionData {
+        consume_login_session: pub struct ConsumeLoginSessionPayload {
+            pub token: Option<String>
+        }
+    }
+}
+
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct FetchLocalRunReportVars {
+    pub owner: String,
+    pub name: String,
+    pub run_id: String,
+}
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
+pub enum ReportConclusion {
+    AcknowledgedFailure,
+    Failure,
+    MissingBaseRun,
+    Success,
+}
+
+impl Display for ReportConclusion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ReportConclusion::AcknowledgedFailure => {
+                write!(f, "{}", style("Acknowledged Failure").yellow().bold())
+            }
+            ReportConclusion::Failure => write!(f, "{}", style("Failure").red().bold()),
+            ReportConclusion::MissingBaseRun => {
+                write!(f, "{}", style("Missing Base Run").yellow().bold())
+            }
+            ReportConclusion::Success => write!(f, "{}", style("Success").green().bold()),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FetchLocalRunReportHeadReport {
+    pub id: String,
+    pub impact: Option<f64>,
+    pub conclusion: ReportConclusion,
+}
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum RunStatus {
+    Pending,
+    Processing,
+    Completed,
+}
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FetchLocalRunReportRun {
+    pub id: String,
+    pub status: RunStatus,
+    pub url: String,
+    pub head_reports: Vec<FetchLocalRunReportHeadReport>,
+}
+nest! {
+    #[derive(Debug, Deserialize, Serialize)]*
+    #[serde(rename_all = "camelCase")]*
+    struct FetchLocalRunReportData {
+        repository: pub struct FetchLocalRunReportRepository {
+            settings: struct FetchLocalRunReportSettings {
+                allowed_regression: f64,
+            },
+            runs: Vec<FetchLocalRunReportRun>,
+        }
+    }
+}
+
+pub struct FetchLocalRunReportResponse {
+    pub allowed_regression: f64,
+    pub run: FetchLocalRunReportRun,
+}
+
+impl CodSpeedAPIClient {
+    pub async fn create_login_session(&self) -> Result<CreateLoginSessionPayload> {
+        let response = self
+            .unauthenticated_gql_client
+            .query_unwrap::<CreateLoginSessionData>(include_str!("queries/CreateLoginSession.gql"))
+            .await;
+        match response {
+            Ok(response) => Ok(response.create_login_session),
+            Err(err) => bail!("Failed to create login session: {}", err),
+        }
+    }
+
+    pub async fn consume_login_session(
+        &self,
+        session_id: &str,
+    ) -> Result<ConsumeLoginSessionPayload> {
+        let response = self
+            .unauthenticated_gql_client
+            .query_with_vars_unwrap::<ConsumeLoginSessionData, ConsumeLoginSessionVars>(
+                include_str!("queries/ConsumeLoginSession.gql"),
+                ConsumeLoginSessionVars {
+                    session_id: session_id.to_string(),
+                },
+            )
+            .await;
+        match response {
+            Ok(response) => Ok(response.consume_login_session),
+            Err(err) => bail!("Failed to use login session: {}", err),
+        }
+    }
+
+    pub async fn fetch_local_run_report(
+        &self,
+        vars: FetchLocalRunReportVars,
+    ) -> Result<FetchLocalRunReportResponse> {
+        let response = self
+            .gql_client
+            .query_with_vars_unwrap::<FetchLocalRunReportData, FetchLocalRunReportVars>(
+                include_str!("queries/FetchLocalRunReport.gql"),
+                vars.clone(),
+            )
+            .await;
+        match response {
+            Ok(response) => {
+                let allowed_regression = response.repository.settings.allowed_regression;
+
+                match response.repository.runs.into_iter().next() {
+                    Some(run) => Ok(FetchLocalRunReportResponse {
+                        allowed_regression,
+                        run,
+                    }),
+                    None => bail!(
+                        "No runs found for owner: {}, name: {}, run_id: {}",
+                        vars.owner,
+                        vars.name,
+                        vars.run_id
+                    ),
+                }
+            }
+            Err(err) if err.contains_error_code("UNAUTHENTICATED") => {
+                bail!("Your session has expired, please login again using `codspeed auth login`")
+            }
+            Err(err) => bail!("Failed to fetch local run report: {}", err),
+        }
+    }
+}