COD-1345: Do not gzip walltime reports

.gitignore

@@ -1,2 +1,3 @@
 /target
 .DS_Store
+samples

Cargo.toml

@@ -31,6 +31,7 @@ url = "2.4.1"
 sha256 = "1.4.0"
 tokio = { version = "1", features = ["macros", "rt"] }
 tokio-tar = "0.3.1"
+tokio-util = "0.7.16"
 md5 = "0.7.0"
 base64 = "0.21.0"
 async-compression = { version = "0.4.5", features = ["tokio", "gzip"] }

src/request_client.rs

@@ -16,4 +16,10 @@ lazy_static! {
         ExponentialBackoff::builder().build_with_max_retries(UPLOAD_RETRY_COUNT)
     ))
     .build();
+
+    // Client without retry middleware for streaming uploads (can't be cloned)
+    pub static ref STREAMING_CLIENT: reqwest::Client = ClientBuilder::new()
+        .user_agent("codspeed-runner")
+        .build()
+        .unwrap();
 }

src/run/run_environment/local/provider.rs

@@ -8,7 +8,9 @@ use crate::run::config::RepositoryOverride;
 use crate::run::helpers::{GitRemote, parse_git_remote};
 use crate::run::run_environment::{RunEnvironment, RunPart};
 use crate::run::runner::ExecutorName;
-use crate::run::uploader::{Runner, UploadMetadata};
+use crate::run::uploader::{
+    LATEST_UPLOAD_METADATA_VERSION, ProfileArchive, Runner, UploadMetadata,
+};
 use crate::run::{
     config::Config,
     helpers::find_repository_root,
@@ -147,18 +149,19 @@ impl RunEnvironmentProvider for LocalProvider {
         &self,
         config: &Config,
         system_info: &SystemInfo,
-        archive_hash: &str,
+        profile_archive: &ProfileArchive,
         executor_name: ExecutorName,
     ) -> Result<UploadMetadata> {
         let run_environment_metadata = self.get_run_environment_metadata()?;
 
         Ok(UploadMetadata {
-            version: Some(6),
+            version: Some(LATEST_UPLOAD_METADATA_VERSION),
             tokenless: config.token.is_none(),
             repository_provider: self.get_repository_provider(),
             commit_hash: run_environment_metadata.ref_.clone(),
             run_environment_metadata,
-            profile_md5: archive_hash.into(),
+            profile_md5: profile_archive.hash.clone(),
+            profile_encoding: profile_archive.content.encoding(),
             runner: Runner {
                 name: "codspeed-runner".into(),
                 version: crate::VERSION.into(),

src/run/run_environment/provider.rs

@@ -5,7 +5,9 @@ use crate::prelude::*;
 use crate::run::check_system::SystemInfo;
 use crate::run::config::Config;
 use crate::run::runner::ExecutorName;
-use crate::run::uploader::{Runner, UploadMetadata};
+use crate::run::uploader::{
+    LATEST_UPLOAD_METADATA_VERSION, ProfileArchive, Runner, UploadMetadata,
+};
 
 use super::interfaces::{RepositoryProvider, RunEnvironment, RunEnvironmentMetadata, RunPart};
 
@@ -66,19 +68,20 @@ pub trait RunEnvironmentProvider {
         &self,
         config: &Config,
         system_info: &SystemInfo,
-        archive_hash: &str,
+        profile_archive: &ProfileArchive,
         executor_name: ExecutorName,
     ) -> Result<UploadMetadata> {
         let run_environment_metadata = self.get_run_environment_metadata()?;
 
         let commit_hash = get_commit_hash(&run_environment_metadata.repository_root_path)?;
 
         Ok(UploadMetadata {
-            version: Some(6),
+            version: Some(LATEST_UPLOAD_METADATA_VERSION),
             tokenless: config.token.is_none(),
             repository_provider: self.get_repository_provider(),
             run_environment_metadata,
-            profile_md5: archive_hash.into(),
+            profile_md5: profile_archive.hash.clone(),
+            profile_encoding: profile_archive.content.encoding(),
             commit_hash,
             runner: Runner {
                 name: "codspeed-runner".into(),

src/run/uploader/interfaces.rs

@@ -7,13 +7,16 @@ use crate::run::{
     runner::ExecutorName,
 };
 
+pub const LATEST_UPLOAD_METADATA_VERSION: u32 = 7;
+
 #[derive(Deserialize, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct UploadMetadata {
     pub repository_provider: RepositoryProvider,
     pub version: Option<u32>,
     pub tokenless: bool,
     pub profile_md5: String,
+    pub profile_encoding: Option<String>,
     pub runner: Runner,
     pub run_environment: RunEnvironment,
     pub run_part: Option<RunPart>,

src/run/uploader/mod.rs

@@ -1,6 +1,8 @@
 mod interfaces;
+mod profile_archive;
 mod upload;
 mod upload_metadata;
 
 pub use interfaces::*;
+pub use profile_archive::ProfileArchive;
 pub use upload::upload;

src/run/uploader/profile_archive.rs

@@ -0,0 +1,71 @@
+use base64::{Engine, engine::general_purpose};
+
+use crate::prelude::*;
+use std::path::PathBuf;
+
+#[derive(Debug)]
+pub struct ProfileArchive {
+    pub hash: String,
+    pub content: ProfileArchiveContent,
+}
+
+#[derive(Debug)]
+pub enum ProfileArchiveContent {
+    CompressedInMemory { data: Vec<u8> },
+    UncompressedOnDisk { path: PathBuf },
+}
+
+impl ProfileArchive {
+    pub fn new_compressed_in_memory(data: Vec<u8>) -> Self {
+        let hash = general_purpose::STANDARD.encode(md5::compute(&data).0);
+        ProfileArchive {
+            hash,
+            content: ProfileArchiveContent::CompressedInMemory { data },
+        }
+    }
+
+    pub fn new_uncompressed_on_disk(path: PathBuf) -> Result<Self> {
+        let metadata = std::fs::metadata(&path)?;
+        if !metadata.is_file() {
+            return Err(anyhow!("The provided path is not a file"));
+        }
+        let mut file = std::fs::File::open(&path)?;
+        let mut buffer = Vec::new();
+        use std::io::Read;
+        file.read_to_end(&mut buffer)?;
+        let hash = general_purpose::STANDARD.encode(md5::compute(&buffer).0);
+        Ok(ProfileArchive {
+            hash,
+            content: ProfileArchiveContent::UncompressedOnDisk { path },
+        })
+    }
+}
+
+impl ProfileArchiveContent {
+    pub async fn size(&self) -> Result<u64> {
+        match &self {
+            ProfileArchiveContent::CompressedInMemory { data } => Ok(data.len() as u64),
+            ProfileArchiveContent::UncompressedOnDisk { path } => {
+                let metadata = tokio::fs::metadata(path).await?;
+                Ok(metadata.len())
+            }
+        }
+    }
+
+    pub fn encoding(&self) -> Option<String> {
+        match self {
+            ProfileArchiveContent::CompressedInMemory { .. } => Some("gzip".to_string()),
+            _ => None,
+        }
+    }
+}
+
+impl Drop for ProfileArchiveContent {
+    fn drop(&mut self) {
+        if let ProfileArchiveContent::UncompressedOnDisk { path } = self {
+            if path.exists() {
+                let _ = std::fs::remove_file(path);
+            }
+        }
+    }
+}

src/run/uploader/snapshots/codspeed__run__uploader__upload_metadata__tests__get_metadata_hash-2.snap

@@ -4,9 +4,10 @@ expression: upload_metadata
 ---
 {
   "repositoryProvider": "GITHUB",
-  "version": 6,
+  "version": 7,
   "tokenless": true,
   "profileMd5": "jp/k05RKuqP3ERQuIIvx4Q==",
+  "profileEncoding": "gzip",
   "runner": {
     "name": "codspeed-runner",
     "version": "2.1.0",