feat: add system info to upload metadata runner property

Cargo.toml

@@ -38,6 +38,7 @@ git2 = "0.18.3"
 nestify = "0.3.3"
 gql_client = { git = "https://github.com/adriencaccia/gql-client-rs" }
 serde_yaml = "0.9.34"
+sysinfo = { version = "0.30.12", features = ["serde"] }
 
 [dev-dependencies]
 temp-env = { version = "0.3.6", features = ["async_closure"] }

src/run/check_system.rs

@@ -0,0 +1,77 @@
+use std::process::Command;
+
+use serde::{Deserialize, Serialize};
+use sysinfo::System;
+
+use crate::prelude::*;
+
+fn get_user() -> Result<String> {
+    let user_output = Command::new("whoami")
+        .output()
+        .map_err(|_| anyhow!("Failed to get user info"))?;
+    if !user_output.status.success() {
+        bail!("Failed to get user info");
+    }
+    let output_str =
+        String::from_utf8(user_output.stdout).map_err(|_| anyhow!("Failed to parse user info"))?;
+    Ok(output_str.trim().to_string())
+}
+
+#[derive(Eq, PartialEq, Hash, Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SystemInfo {
+    pub os: String,
+    pub os_version: String,
+    pub arch: String,
+    pub host: String,
+    pub user: String,
+}
+
+#[cfg(test)]
+impl SystemInfo {
+    pub fn test() -> Self {
+        SystemInfo {
+            os: "Ubuntu".to_string(),
+            os_version: "20.04".to_string(),
+            arch: "x86_64".to_string(),
+            host: "host".to_string(),
+            user: "user".to_string(),
+        }
+    }
+}
+
+/// Checks if the system is supported and returns the system info
+///
+/// Supported systems:
+/// - Ubuntu 20.04 on x86_64
+/// - Ubuntu 22.04 on x86_64
+/// - Debian 11 on x86_64
+/// - Debian 12 on x86_64
+pub fn check_system() -> Result<SystemInfo> {
+    let os = System::name().ok_or(anyhow!("Failed to get OS name"))?;
+    let os_version = System::os_version().ok_or(anyhow!("Failed to get OS version"))?;
+    debug!("OS: {}, Version: {}", os, os_version);
+    match (os.as_str(), os_version.as_str()) {
+        ("Ubuntu", "20.04") | ("Ubuntu", "22.04") | ("Debian", "11") | ("Debian", "12") => (),
+        ("Ubuntu", _) => bail!("Only Ubuntu 20.04 and 22.04 are supported at the moment"),
+        ("Debian", _) => bail!("Only Debian 11 and 12 are supported at the moment"),
+        _ => bail!("Only Ubuntu and Debian are supported at the moment"),
+    }
+    let arch = System::cpu_arch().ok_or(anyhow!("Failed to get CPU architecture"))?;
+    debug!("Arch: {}", arch);
+    if arch != "x86_64" && arch != "arm64" {
+        bail!("Only x86_64 and arm64 are supported at the moment");
+    }
+    let user = get_user()?;
+    debug!("User: {}", user);
+    let host = System::host_name().ok_or(anyhow!("Failed to get host name"))?;
+    debug!("Host: {}", host);
+
+    Ok(SystemInfo {
+        os,
+        os_version,
+        arch,
+        host,
+        user,
+    })
+}

src/run/ci_provider/provider.rs

@@ -2,6 +2,7 @@ use git2::Repository;
 use simplelog::SharedLogger;
 
 use crate::prelude::*;
+use crate::run::check_system::SystemInfo;
 use crate::run::config::Config;
 use crate::run::uploader::{Runner, UploadMetadata};
 
@@ -71,13 +72,18 @@ pub trait CIProvider {
     /// let instruments = Instruments::new();
     /// let metadata = provider.get_upload_metadata(&config, "abc123").unwrap();
     /// ```
-    fn get_upload_metadata(&self, config: &Config, archive_hash: &str) -> Result<UploadMetadata> {
+    fn get_upload_metadata(
+        &self,
+        config: &Config,
+        system_info: &SystemInfo,
+        archive_hash: &str,
+    ) -> Result<UploadMetadata> {
         let provider_metadata = self.get_provider_metadata()?;
 
         let commit_hash = get_commit_hash(&provider_metadata.repository_root_path)?;
 
         Ok(UploadMetadata {
-            version: Some(2),
+            version: Some(3),
             tokenless: config.token.is_none(),
             provider_metadata,
             profile_md5: archive_hash.into(),
@@ -86,6 +92,7 @@ pub trait CIProvider {
                 name: "codspeed-runner".into(),
                 version: crate::VERSION.into(),
                 instruments: config.instruments.get_active_instrument_names(),
+                system_info: system_info.clone(),
             },
             platform: self.get_provider_slug().into(),
         })

src/run/mod.rs

@@ -5,6 +5,7 @@ use crate::run::{config::Config, logger::Logger};
 use crate::VERSION;
 use clap::Args;
 
+mod check_system;
 pub mod ci_provider;
 mod helpers;
 mod instruments;
@@ -118,12 +119,13 @@ pub async fn run(args: RunArgs, api_client: &CodSpeedAPIClient) -> Result<()> {
         config.set_token(codspeed_config.auth.token.clone());
     }
 
-    let run_data = runner::run(&config).await?;
+    let system_info = check_system::check_system()?;
+    let run_data = runner::run(&config, &system_info).await?;
 
     if !config.skip_upload {
         start_group!("Upload the results");
         logger.persist_log_to_profile_folder(&run_data)?;
-        let upload_result = uploader::upload(&config, &provider, &run_data).await?;
+        let upload_result = uploader::upload(&config, &system_info, &provider, &run_data).await?;
         end_group!();
 
         if provider.get_provider_slug() == "local" {

src/run/runner/mod.rs

@@ -1,4 +1,3 @@
-mod check_system;
 mod helpers;
 mod run;
 mod setup;