apollo_proof_manager: log verify and store times

Author: einat-starkware

Cargo.lock

@@ -26,6 +26,7 @@ strum = { workspace = true, features = ["derive"] }
 strum_macros.workspace = true
 thiserror.workspace = true
 tokio.workspace = true
+tracing.workspace = true
 
 [dev-dependencies]
 apollo_proof_manager_types = { workspace = true, features = ["testing"] }

crates/apollo_class_manager_types/Cargo.toml

@@ -1,3 +1,5 @@
+use std::time::Instant;
+
 use apollo_proof_manager_types::{ProofManagerClientError, SharedProofManagerClient};
 use async_trait::async_trait;
 #[cfg(any(feature = "testing", test))]
@@ -27,6 +29,7 @@ use starknet_api::transaction::fields::{Fee, Proof, ProofFacts};
 use starknet_api::transaction::CalculateContractAddress;
 use starknet_api::{executable_transaction, transaction, StarknetApiError};
 use thiserror::Error;
+use tracing::info;
 
 use crate::{ClassHashes, ClassManagerClientError, SharedClassManagerClient};
 
@@ -353,7 +356,10 @@ impl TransactionConverter {
             return Ok(());
         }
 
+        let verify_start = Instant::now();
         self.verify_proof(proof_facts.clone(), proof.clone())?;
+        let verify_duration = verify_start.elapsed();
+        info!("Proof verification took: {verify_duration:?}");
         Ok(())
     }
 

crates/apollo_class_manager_types/src/transaction_converter.rs

@@ -1,5 +1,6 @@
 use std::clone::Clone;
 use std::sync::Arc;
+use std::time::Instant;
 
 use apollo_class_manager_types::transaction_converter::{
     TransactionConverter,
@@ -36,7 +37,7 @@ use starknet_api::rpc_transaction::{
     RpcTransaction,
 };
 use starknet_api::transaction::fields::TransactionSignature;
-use tracing::{debug, error, warn};
+use tracing::{debug, error, info, warn};
 
 use crate::errors::{
     mempool_client_result_to_deprecated_gw_result,
@@ -172,17 +173,23 @@ impl Gateway {
             .inspect_err(|e| metric_counters.record_add_tx_failure(e))?;
 
         if let Some((proof_facts, proof)) = proof_data {
+            let proof_manager_store_start = Instant::now();
             let proof_manager_client = self.proof_manager_client.clone();
             if let Err(e) = proof_manager_client.set_proof(proof_facts.clone(), proof.clone()).await
             {
                 error!("Failed to set proof in proof manager: {}", e);
             }
+            let proof_manager_store_duration = proof_manager_store_start.elapsed();
+            info!("Proof manager store took: {proof_manager_store_duration:?}");
+            let proof_archive_writer_start = Instant::now();
             let proof_archive_writer = self.proof_archive_writer.clone();
             tokio::spawn(async move {
                 if let Err(e) = proof_archive_writer.set_proof(proof_facts, proof).await {
                     error!("Failed to archive proof to GCS: {}", e);
                 }
             });
+            let proof_archive_writer_duration = proof_archive_writer_start.elapsed();
+            info!("Proof archive writer took: {proof_archive_writer_duration:?}");
         }
         let gateway_output = create_gateway_output(&internal_tx);