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};
 
@@ -338,7 +341,14 @@ impl TransactionConverter {
         };
         let internal_tx = self.convert_rpc_tx_to_internal_rpc_tx(tx).await?;
         if let Some((proof_facts, proof)) = proof_data {
+            let proof_manager_store_start = Instant::now();
             self.proof_manager_client.set_proof(proof_facts, proof).await?;
+            let proof_manager_store_duration = proof_manager_store_start.elapsed();
+            let tx_hash = internal_tx.tx_hash;
+            info!(
+                "Proof manager store in the consensus took: {proof_manager_store_duration:?} for \
+                 tx hash: {tx_hash:?}"
+            );
         }
         Ok(internal_tx)
     }
@@ -362,7 +372,14 @@ impl TransactionConverter {
             return Ok(());
         }
 
+        let verify_start = Instant::now();
         self.verify_proof(proof_facts.clone(), proof.clone())?;
+        let verify_duration = verify_start.elapsed();
+        let proof_facts_hash = proof_facts.hash();
+        info!(
+            "Proof verification took: {verify_duration:?} for proof facts hash: \
+             {proof_facts_hash:?}"
+        );
         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,
@@ -169,16 +170,29 @@ impl Gateway {
             .inspect_err(|e| metric_counters.record_add_tx_failure(e))?;
 
         if let Some((proof_facts, proof)) = proof_data {
+            let tx_hash = internal_tx.tx_hash;
             let proof_manager_client = self.transaction_converter.get_proof_manager_client();
+            let proof_manager_store_start = Instant::now();
             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:?} for tx hash: \
+                 {tx_hash:?}"
+            );
+            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:?} for tx hash: \
+                     {tx_hash:?}"
+                );
             });
         }
         let gateway_output = create_gateway_output(&internal_tx);