blockifier: set state reader and contract manager metrics as optional (#10469)

Author: ArniStarkware

Cargo.lock

@@ -728,7 +728,7 @@ impl BlockBuilderFactory {
         let state_reader = StateReaderAndContractManager::new(
             apollo_reader,
             self.contract_class_manager.clone(),
-            BATCHER_CLASS_CACHE_METRICS,
+            Some(BATCHER_CLASS_CACHE_METRICS),
         );
 
         let executor = ConcurrentTransactionExecutor::start_block(

crates/apollo_batcher/src/block_builder.rs

@@ -85,7 +85,7 @@ impl StatefulTransactionValidatorFactoryTrait for StatefulTransactionValidatorFa
         let state_reader_and_contract_manager = StateReaderAndContractManager::new(
             state_reader,
             self.contract_class_manager.clone(),
-            GATEWAY_CLASS_CACHE_METRICS,
+            Some(GATEWAY_CLASS_CACHE_METRICS),
         );
 
         let state = CachedState::new(state_reader_and_contract_manager);

crates/apollo_gateway/src/stateful_transaction_validator.rs

@@ -22,14 +22,14 @@ pub trait FetchCompiledClasses: StateReader {
 pub struct StateReaderAndContractManager<S: FetchCompiledClasses> {
     pub state_reader: S,
     contract_class_manager: ContractClassManager,
-    class_cache_metrics: CacheMetrics,
+    class_cache_metrics: Option<CacheMetrics>,
 }
 
 impl<S: FetchCompiledClasses> StateReaderAndContractManager<S> {
     pub fn new(
         state_reader: S,
         contract_class_manager: ContractClassManager,
-        class_cache_metrics: CacheMetrics,
+        class_cache_metrics: Option<CacheMetrics>,
     ) -> Self {
         Self { state_reader, contract_class_manager, class_cache_metrics }
     }
@@ -52,11 +52,11 @@ impl<S: FetchCompiledClasses> StateReaderAndContractManager<S> {
                     }
                 }
             }
-            self.class_cache_metrics.increment_hit();
+            self.increment_cache_hit_metric();
             self.update_native_metrics(&runnable_class);
             return Ok(runnable_class);
         }
-        self.class_cache_metrics.increment_miss();
+        self.increment_cache_miss_metric();
 
         let compiled_class = self.state_reader.get_compiled_classes(class_hash)?;
         self.contract_class_manager.set_and_compile(class_hash, compiled_class.clone());
@@ -72,6 +72,18 @@ impl<S: FetchCompiledClasses> StateReaderAndContractManager<S> {
         Ok(runnable_class)
     }
 
+    fn increment_cache_hit_metric(&self) {
+        if let Some(ref class_cache_metrics) = self.class_cache_metrics {
+            class_cache_metrics.increment_hit();
+        }
+    }
+
+    fn increment_cache_miss_metric(&self) {
+        if let Some(ref class_cache_metrics) = self.class_cache_metrics {
+            class_cache_metrics.increment_miss();
+        }
+    }
+
     fn update_native_metrics(&self, _runnable_class: &RunnableCompiledClass) {
         #[cfg(feature = "cairo_native")]
         {

crates/blockifier/src/state/state_reader_and_contract_manager.rs

@@ -1,4 +1,3 @@
-use apollo_metrics::metrics::{MetricCounter, MetricScope};
 use blockifier_test_utils::cairo_versions::CairoVersion;
 use blockifier_test_utils::contracts::FeatureContract;
 use starknet_api::abi::abi_utils::get_fee_token_var_address;
@@ -11,7 +10,6 @@ use strum::IntoEnumIterator;
 
 use crate::blockifier::config::ContractClassManagerConfig;
 use crate::context::ChainInfo;
-use crate::metrics::CacheMetrics;
 use crate::state::cached_state::CachedState;
 use crate::state::contract_class_manager::ContractClassManager;
 use crate::state::state_reader_and_contract_manager::{
@@ -21,22 +19,6 @@ use crate::state::state_reader_and_contract_manager::{
 use crate::test_utils::contracts::FeatureContractData;
 use crate::test_utils::dict_state_reader::DictStateReader;
 
-/// Placeholder class cache metrics. The metrics are not tested in the blockifier's context.
-const BLOCKIFIER_CLASS_CACHE_METRICS: CacheMetrics = CacheMetrics::new(
-    MetricCounter::new(
-        MetricScope::Blockifier,
-        "Class Cache Misses in Blockifier",
-        "Counter of the number of times that the class cache was missed",
-        0,
-    ),
-    MetricCounter::new(
-        MetricScope::Blockifier,
-        "Class Cache Misses in Blockifier",
-        "Counter of the number of times that the class cache was hit",
-        0,
-    ),
-);
-
 /// Utility to fund an account.
 pub fn fund_account(
     chain_info: &ChainInfo,
@@ -203,9 +185,5 @@ pub fn state_reader_and_contract_manager_for_testing<Reader: FetchCompiledClasse
     state_reader: Reader,
     contract_class_manager: ContractClassManager,
 ) -> StateReaderAndContractManager<Reader> {
-    StateReaderAndContractManager::new(
-        state_reader,
-        contract_class_manager,
-        BLOCKIFIER_CLASS_CACHE_METRICS,
-    )
+    StateReaderAndContractManager::new(state_reader, contract_class_manager, None)
 }

crates/blockifier/src/test_utils/initial_test_state.rs

@@ -28,7 +28,6 @@ crate-type = ["cdylib"]
 
 [dependencies]
 apollo_compile_to_native_types.workspace = true
-apollo_metrics.workspace = true
 apollo_state_reader.workspace = true
 apollo_storage.workspace = true
 blockifier = { workspace = true, features = ["native_blockifier"] }

crates/native_blockifier/Cargo.toml

@@ -2,7 +2,6 @@
 
 use std::str::FromStr;
 
-use apollo_metrics::metrics::{MetricCounter, MetricScope};
 use apollo_state_reader::apollo_state::ApolloReader;
 use blockifier::blockifier::config::{ContractClassManagerConfig, TransactionExecutorConfig};
 use blockifier::blockifier::transaction_executor::{
@@ -13,7 +12,6 @@ use blockifier::blockifier::transaction_executor::{
 use blockifier::blockifier_versioned_constants::VersionedConstants;
 use blockifier::bouncer::BouncerConfig;
 use blockifier::context::{BlockContext, ChainInfo, FeeTokenAddresses};
-use blockifier::metrics::CacheMetrics;
 use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier::state::state_reader_and_contract_manager::StateReaderAndContractManager;
 use blockifier::transaction::account_transaction::AccountTransaction;
@@ -55,22 +53,6 @@ pub(crate) type RawTransactionExecutionResult = Vec<u8>;
 pub type ApolloStateReaderAndContractManager = StateReaderAndContractManager<ApolloReader>;
 const RESULT_SERIALIZE_ERR: &str = "Failed serializing execution info.";
 
-/// Placeholder class cache metrics. There are not metrics on the native blockifier.
-const NATIVE_BLOCKIFIER_CLASS_CACHE_METRICS: CacheMetrics = CacheMetrics::new(
-    MetricCounter::new(
-        MetricScope::Blockifier,
-        "Class Cache Misses in Native Blockifier",
-        "Counter of the number of times that the class cache was missed",
-        0,
-    ),
-    MetricCounter::new(
-        MetricScope::Blockifier,
-        "Class Cache Misses in Native Blockifier",
-        "Counter of the number of times that the class cache was hit",
-        0,
-    ),
-);
-
 /// Return type for the finalize method containing state diffs, bouncer weights, and CASM hash
 /// computation data.
 type FinalizeResult = (
@@ -429,11 +411,7 @@ impl PyBlockExecutor {
         self.storage.validate_aligned(next_block_number.0);
         let apollo_reader = ApolloReader::new(self.storage.reader().clone(), next_block_number);
 
-        StateReaderAndContractManager::new(
-            apollo_reader,
-            self.contract_class_manager.clone(),
-            NATIVE_BLOCKIFIER_CLASS_CACHE_METRICS,
-        )
+        StateReaderAndContractManager::new(apollo_reader, self.contract_class_manager.clone(), None)
     }
 
     pub fn create_for_testing_with_storage(storage: impl Storage + Send + 'static) -> Self {