feat: remove projects query from the exec polling

Author: GuillaumeLagrange

src/api_client.rs

@@ -86,12 +86,6 @@ pub struct FetchLocalRunReportVars {
     pub run_id: String,
 }
 
-#[derive(Serialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct FetchLocalExecReportVars {
-    pub name: String,
-    pub run_id: String,
-}
 #[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
 pub enum ReportConclusion {
     AcknowledgedFailure,
@@ -181,10 +175,6 @@ pub struct FetchLocalRunReportResponse {
     pub run: FetchLocalRunReportRun,
 }
 
-pub struct FetchLocalExecReportResponse {
-    pub run: FetchLocalRunReportRun,
-}
-
 #[derive(Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct GetOrCreateProjectRepositoryVars {
@@ -257,28 +247,6 @@ impl CodSpeedAPIClient {
         }
     }
 
-    pub async fn fetch_local_exec_report(
-        &self,
-        vars: FetchLocalExecReportVars,
-    ) -> Result<FetchLocalExecReportResponse> {
-        let response = self
-            .gql_client
-            .query_with_vars_unwrap::<FetchLocalExecReportData, FetchLocalExecReportVars>(
-                include_str!("queries/FetchLocalExecReport.gql"),
-                vars.clone(),
-            )
-            .await;
-        match response {
-            Ok(response) => Ok(FetchLocalExecReportResponse {
-                run: response.project.run,
-            }),
-            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}"),
-        }
-    }
-
     pub async fn get_or_create_project_repository(
         &self,
         vars: GetOrCreateProjectRepositoryVars,

src/exec/mod.rs

@@ -2,6 +2,7 @@ use crate::api_client::CodSpeedAPIClient;
 use crate::config::CodSpeedConfig;
 use crate::executor;
 use crate::prelude::*;
+use crate::run::uploader::UploadResult;
 use clap::Args;
 use std::path::Path;
 
@@ -36,7 +37,10 @@ pub async fn run(
         executor::ExecutorCommand::Exec,
     );
 
-    let poll_results_fn = |run_id: String| poll_results::poll_results(api_client, run_id);
+    let poll_results_fn = |upload_result: &UploadResult| {
+        let upload_result = upload_result.clone();
+        async move { poll_results::poll_results(api_client, &upload_result).await }
+    };
 
     executor::execute_benchmarks(
         executor.as_ref(),

src/exec/poll_results.rs

@@ -2,21 +2,24 @@ use console::style;
 use tokio::time::{Instant, sleep};
 
 use crate::api_client::{
-    CodSpeedAPIClient, FetchLocalExecReportResponse, FetchLocalExecReportVars, RunStatus,
+    CodSpeedAPIClient, FetchLocalRunReportResponse, FetchLocalRunReportVars, RunStatus,
 };
-use crate::exec::DEFAULT_REPOSITORY_NAME;
+use crate::run::uploader::UploadResult;
 use crate::prelude::*;
 use crate::run::helpers::poll_results::{
     POLLING_INTERVAL, RUN_PROCESSING_MAX_DURATION, build_benchmark_table,
 };
 
 #[allow(clippy::borrowed_box)]
-pub async fn poll_results(api_client: &CodSpeedAPIClient, run_id: String) -> Result<()> {
+pub async fn poll_results(
+    api_client: &CodSpeedAPIClient,
+    upload_result: &UploadResult,
+) -> Result<()> {
     let start = Instant::now();
-    let fetch_local_exec_report_vars = FetchLocalExecReportVars {
-        // TODO: Set this dynamically based on the upload endpoint return value
-        name: DEFAULT_REPOSITORY_NAME.to_owned(),
-        run_id: run_id.clone(),
+    let fetch_local_run_report_vars = FetchLocalRunReportVars {
+        owner: upload_result.owner.clone(),
+        name: upload_result.repository.clone(),
+        run_id: upload_result.run_id.clone(),
     };
 
     start_group!("Fetching the results");
@@ -27,11 +30,11 @@ pub async fn poll_results(api_client: &CodSpeedAPIClient, run_id: String) -> Res
         }
 
         let fetch_result = api_client
-            .fetch_local_exec_report(fetch_local_exec_report_vars.clone())
+            .fetch_local_run_report(fetch_local_run_report_vars.clone())
             .await?;
 
         match fetch_result {
-            FetchLocalExecReportResponse { run, .. }
+            FetchLocalRunReportResponse { run, .. }
                 if run.status == RunStatus::Pending || run.status == RunStatus::Processing =>
             {
                 sleep(POLLING_INTERVAL).await;

src/executor/mod.rs

@@ -14,6 +14,7 @@ mod wall_time;
 use crate::instruments::mongo_tracer::{MongoTracer, install_mongodb_tracer};
 use crate::prelude::*;
 use crate::run::check_system::SystemInfo;
+use crate::run::uploader::UploadResult;
 use crate::runner_mode::RunnerMode;
 use async_trait::async_trait;
 pub use config::Config;
@@ -102,7 +103,7 @@ pub async fn execute_benchmarks<F>(
     api_client: &crate::api_client::CodSpeedAPIClient,
 ) -> Result<()>
 where
-    F: AsyncFn(String) -> Result<()>,
+    F: AsyncFn(&UploadResult) -> Result<()>,
 {
     if !execution_context.config.skip_setup {
         start_group!("Preparing the environment");
@@ -165,7 +166,7 @@ where
         end_group!();
 
         if execution_context.is_local() {
-            poll_results(upload_result.run_id).await?;
+            poll_results(&upload_result).await?;
         }
     } else {
         debug!("Skipping upload of performance data");

src/queries/FetchLocalExecReport.gql

@@ -4,6 +4,7 @@ use crate::config::CodSpeedConfig;
 use crate::executor;
 use crate::executor::Config;
 use crate::prelude::*;
+use crate::run::uploader::UploadResult;
 use crate::run_environment::interfaces::RepositoryProvider;
 use crate::runner_mode::RunnerMode;
 use clap::{Args, ValueEnum};
@@ -201,9 +202,9 @@ pub async fn run(
         executor::ExecutorCommand::Run,
     );
 
-    let run_environment_metadata = execution_context.provider.get_run_environment_metadata()?;
-    let poll_results_fn = |run_id: String| {
-        poll_results::poll_results(api_client, &run_environment_metadata, run_id, output_json)
+    let poll_results_fn = |upload_result: &UploadResult| {
+        let upload_result = upload_result.clone();
+        async move { poll_results::poll_results(api_client, &upload_result, output_json).await }
     };
     executor::execute_benchmarks(
         executor.as_ref(),

src/run/mod.rs

@@ -8,22 +8,19 @@ use crate::prelude::*;
 use crate::run::helpers::poll_results::{
     POLLING_INTERVAL, RUN_PROCESSING_MAX_DURATION, build_benchmark_table,
 };
-use crate::run_environment::RunEnvironmentMetadata;
+use crate::run::uploader::UploadResult;
 
 #[allow(clippy::borrowed_box)]
 pub async fn poll_results(
     api_client: &CodSpeedAPIClient,
-    run_environment_metadata: &RunEnvironmentMetadata,
-    run_id: String,
+    upload_result: &UploadResult,
     output_json: bool,
 ) -> Result<()> {
     let start = Instant::now();
-    let owner = run_environment_metadata.owner.as_str();
-    let name = run_environment_metadata.repository.as_str();
     let fetch_local_run_report_vars = FetchLocalRunReportVars {
-        owner: owner.to_owned(),
-        name: name.to_owned(),
-        run_id: run_id.to_owned(),
+        owner: upload_result.owner.clone(),
+        name: upload_result.repository.clone(),
+        run_id: upload_result.run_id.clone(),
     };
 
     start_group!("Fetching the results");
@@ -88,7 +85,7 @@ pub async fn poll_results(
         // We could make use of structured logging for this https://docs.rs/log/latest/log/#structured-logging
         log_json!(format!(
             "{{\"event\": \"run_finished\", \"run_id\": \"{}\"}}",
-            run_id
+            upload_result.run_id
         ));
     }
 

src/run/poll_results.rs

@@ -5,4 +5,4 @@ mod upload_metadata;
 
 pub use interfaces::*;
 pub use profile_archive::ProfileArchive;
-pub use upload::upload;
+pub use upload::{UploadResult, upload};

src/run/uploader/mod.rs

@@ -235,8 +235,11 @@ async fn upload_profile_archive(
     Ok(())
 }
 
+#[derive(Clone)]
 pub struct UploadResult {
     pub run_id: String,
+    pub owner: String,
+    pub repository: String,
 }
 
 pub async fn upload(
@@ -299,6 +302,8 @@ pub async fn upload(
 
     Ok(UploadResult {
         run_id: upload_data.run_id,
+        owner: upload_metadata.run_environment_metadata.owner.clone(),
+        repository: upload_metadata.run_environment_metadata.repository.clone(),
     })
 }