[Metrics] Use helper traits and functions when possible

Simplify the code and prepare for further changes.

Author: wqfish

aptos-move/aptos-vm/src/aptos_vm.rs

@@ -44,6 +44,7 @@ use aptos_gas_schedule::{
     AptosGasParameters, VMGasParameters,
 };
 use aptos_logger::{enabled, prelude::*, Level};
+use aptos_metrics_core::IntCounterVecHelper;
 #[cfg(any(test, feature = "testing"))]
 use aptos_types::state_store::StateViewId;
 use aptos_types::{
@@ -2855,7 +2856,7 @@ impl AptosVM {
                     TransactionStatus::Retry => None,
                 };
                 if let Some(label) = counter_label {
-                    USER_TRANSACTIONS_EXECUTED.with_label_values(&[label]).inc();
+                    USER_TRANSACTIONS_EXECUTED.inc_with(&[label]);
                 }
                 (vm_status, output)
             },
@@ -3126,9 +3127,7 @@ impl VMValidator for AptosVM {
             ),
         };
 
-        TRANSACTIONS_VALIDATED
-            .with_label_values(&[counter_label])
-            .inc();
+        TRANSACTIONS_VALIDATED.inc_with(&[counter_label]);
 
         result
     }

aptos-move/aptos-vm/src/sharded_block_executor/sharded_executor_service.rs

@@ -20,6 +20,7 @@ use aptos_block_executor::{
     code_cache_global_manager::AptosModuleCacheManager, txn_provider::default::DefaultTxnProvider,
 };
 use aptos_logger::{info, trace};
+use aptos_metrics_core::TimerHelper;
 use aptos_types::{
     block_executor::{
         config::{BlockExecutorConfig, BlockExecutorLocalConfig},
@@ -190,11 +191,11 @@ impl<S: StateView + Sync + Send + 'static> ShardedExecutorService<S> {
         let mut result = vec![];
         for (round, sub_block) in transactions.into_sub_blocks().into_iter().enumerate() {
             let _timer = SHARDED_BLOCK_EXECUTION_BY_ROUNDS_SECONDS
-                .with_label_values(&[&self.shard_id.to_string(), &round.to_string()])
-                .start_timer();
-            SHARDED_BLOCK_EXECUTOR_TXN_COUNT
-                .with_label_values(&[&self.shard_id.to_string(), &round.to_string()])
-                .observe(sub_block.transactions.len() as f64);
+                .timer_with(&[&self.shard_id.to_string(), &round.to_string()]);
+            SHARDED_BLOCK_EXECUTOR_TXN_COUNT.observe_with(
+                &[&self.shard_id.to_string(), &round.to_string()],
+                sub_block.transactions.len() as f64,
+            );
             info!(
                 "executing sub block for shard {} and round {}, number of txns {}",
                 self.shard_id,
@@ -234,8 +235,7 @@ impl<S: StateView + Sync + Send + 'static> ShardedExecutorService<S> {
                         num_txns
                     );
                     let exe_timer = SHARDED_EXECUTOR_SERVICE_SECONDS
-                        .with_label_values(&[&self.shard_id.to_string(), "execute_block"])
-                        .start_timer();
+                        .timer_with(&[&self.shard_id.to_string(), "execute_block"]);
                     let ret = self.execute_block(
                         transactions,
                         state_view.as_ref(),
@@ -250,8 +250,7 @@ impl<S: StateView + Sync + Send + 'static> ShardedExecutorService<S> {
                     drop(exe_timer);
 
                     let _result_tx_timer = SHARDED_EXECUTOR_SERVICE_SECONDS
-                        .with_label_values(&[&self.shard_id.to_string(), "result_tx"])
-                        .start_timer();
+                        .timer_with(&[&self.shard_id.to_string(), "result_tx"]);
                     self.coordinator_client.send_execution_result(ret);
                 },
                 ExecutorShardCommand::Stop => {

aptos-move/block-executor/src/counters.rs

@@ -4,7 +4,7 @@
 use aptos_metrics_core::{
     exponential_buckets, register_avg_counter_vec, register_histogram, register_histogram_vec,
     register_int_counter, register_int_counter_vec, register_int_gauge, Histogram, HistogramVec,
-    IntCounter, IntCounterVec, IntGauge,
+    IntCounter, IntCounterVec, IntGauge, TimerHelper,
 };
 use aptos_mvhashmap::BlockStateStats;
 use aptos_types::fee_statement::FeeStatement;
@@ -242,29 +242,35 @@ pub static BLOCK_VIEW_BASE_VALUES_MEMORY_USAGE: Lazy<HistogramVec> = Lazy::new(|
 });
 
 fn observe_gas(counter: &Lazy<HistogramVec>, mode_str: &str, fee_statement: &FeeStatement) {
-    counter
-        .with_label_values(&[mode_str, GasType::TOTAL_GAS])
-        .observe(fee_statement.gas_used() as f64);
-
-    counter
-        .with_label_values(&[mode_str, GasType::EXECUTION_GAS])
-        .observe(fee_statement.execution_gas_used() as f64);
-
-    counter
-        .with_label_values(&[mode_str, GasType::IO_GAS])
-        .observe(fee_statement.io_gas_used() as f64);
-
-    counter
-        .with_label_values(&[mode_str, GasType::NON_STORAGE_GAS])
-        .observe((fee_statement.execution_gas_used() + fee_statement.io_gas_used()) as f64);
-
-    counter
-        .with_label_values(&[mode_str, GasType::STORAGE_FEE])
-        .observe(fee_statement.storage_fee_used() as f64);
-
-    counter
-        .with_label_values(&[mode_str, GasType::STORAGE_FEE_REFUND])
-        .observe(fee_statement.storage_fee_refund() as f64);
+    counter.observe_with(
+        &[mode_str, GasType::TOTAL_GAS],
+        fee_statement.gas_used() as f64,
+    );
+
+    counter.observe_with(
+        &[mode_str, GasType::EXECUTION_GAS],
+        fee_statement.execution_gas_used() as f64,
+    );
+
+    counter.observe_with(
+        &[mode_str, GasType::IO_GAS],
+        fee_statement.io_gas_used() as f64,
+    );
+
+    counter.observe_with(
+        &[mode_str, GasType::NON_STORAGE_GAS],
+        (fee_statement.execution_gas_used() + fee_statement.io_gas_used()) as f64,
+    );
+
+    counter.observe_with(
+        &[mode_str, GasType::STORAGE_FEE],
+        fee_statement.storage_fee_used() as f64,
+    );
+
+    counter.observe_with(
+        &[mode_str, GasType::STORAGE_FEE_REFUND],
+        fee_statement.storage_fee_refund() as f64,
+    );
 }
 
 pub(crate) fn update_block_gas_counters(
@@ -281,17 +287,11 @@ pub(crate) fn update_block_gas_counters(
     };
 
     observe_gas(&BLOCK_GAS, mode_str, accumulated_fee_statement);
-    BLOCK_COMMITTED_TXNS
-        .with_label_values(&[mode_str])
-        .observe(num_committed as f64);
+    BLOCK_COMMITTED_TXNS.observe_with(&[mode_str], num_committed as f64);
 
-    EFFECTIVE_BLOCK_GAS
-        .with_label_values(&[mode_str])
-        .observe(accumulated_effective_gas as f64);
+    EFFECTIVE_BLOCK_GAS.observe_with(&[mode_str], accumulated_effective_gas as f64);
 
-    APPROX_BLOCK_OUTPUT_SIZE
-        .with_label_values(&[mode_str])
-        .observe(accumulated_approx_output_size as f64);
+    APPROX_BLOCK_OUTPUT_SIZE.observe_with(&[mode_str], accumulated_approx_output_size as f64);
 }
 
 pub(crate) fn update_txn_gas_counters(txn_fee_statements: &Vec<FeeStatement>, is_parallel: bool) {
@@ -313,25 +313,29 @@ pub(crate) fn update_state_counters(block_state_stats: BlockStateStats, is_paral
         Mode::SEQUENTIAL
     };
 
+    BLOCK_VIEW_DISTINCT_KEYS.observe_with(
+        &[mode_str, "resource"],
+        block_state_stats.num_resources as f64,
+    );
+    BLOCK_VIEW_DISTINCT_KEYS.observe_with(
+        &[mode_str, "resource_group"],
+        block_state_stats.num_resource_groups as f64,
+    );
+    BLOCK_VIEW_DISTINCT_KEYS.observe_with(
+        &[mode_str, "delayed_field"],
+        block_state_stats.num_delayed_fields as f64,
+    );
     BLOCK_VIEW_DISTINCT_KEYS
-        .with_label_values(&[mode_str, "resource"])
-        .observe(block_state_stats.num_resources as f64);
-    BLOCK_VIEW_DISTINCT_KEYS
-        .with_label_values(&[mode_str, "resource_group"])
-        .observe(block_state_stats.num_resource_groups as f64);
-    BLOCK_VIEW_DISTINCT_KEYS
-        .with_label_values(&[mode_str, "delayed_field"])
-        .observe(block_state_stats.num_delayed_fields as f64);
-    BLOCK_VIEW_DISTINCT_KEYS
-        .with_label_values(&[mode_str, "module"])
-        .observe(block_state_stats.num_modules as f64);
-
-    BLOCK_VIEW_BASE_VALUES_MEMORY_USAGE
-        .with_label_values(&[mode_str, "resource"])
-        .observe(block_state_stats.base_resources_size as f64);
-    BLOCK_VIEW_BASE_VALUES_MEMORY_USAGE
-        .with_label_values(&[mode_str, "delayed_field"])
-        .observe(block_state_stats.base_delayed_fields_size as f64);
+        .observe_with(&[mode_str, "module"], block_state_stats.num_modules as f64);
+
+    BLOCK_VIEW_BASE_VALUES_MEMORY_USAGE.observe_with(
+        &[mode_str, "resource"],
+        block_state_stats.base_resources_size as f64,
+    );
+    BLOCK_VIEW_BASE_VALUES_MEMORY_USAGE.observe_with(
+        &[mode_str, "delayed_field"],
+        block_state_stats.base_delayed_fields_size as f64,
+    );
 }
 
 pub static GLOBAL_MODULE_CACHE_SIZE_IN_BYTES: Lazy<IntGauge> = Lazy::new(|| {

aptos-move/block-executor/src/limit_processor.rs

@@ -5,6 +5,7 @@ use crate::{
     counters, hot_state_op_accumulator::BlockHotStateOpAccumulator, types::ReadWriteSummary,
 };
 use aptos_logger::{info, warn};
+use aptos_metrics_core::IntCounterVecHelper;
 use aptos_types::{
     fee_statement::FeeStatement,
     on_chain_config::BlockGasLimitType,
@@ -131,9 +132,7 @@ impl<'s, T: Transaction, S: TStateView<Key = T::Key>> BlockGasLimitProcessor<'s,
             // PER_BLOCK_GAS_LIMIT, early halt BlockSTM.
             let accumulated_block_gas = self.get_effective_accumulated_block_gas();
             if accumulated_block_gas >= per_block_gas_limit {
-                counters::EXCEED_PER_BLOCK_GAS_LIMIT_COUNT
-                    .with_label_values(&[mode])
-                    .inc();
+                counters::EXCEED_PER_BLOCK_GAS_LIMIT_COUNT.inc_with(&[mode]);
                 info!(
                     "[BlockSTM]: execution ({}) early halted due to \
                     accumulated_block_gas {} >= PER_BLOCK_GAS_LIMIT {}",
@@ -146,9 +145,7 @@ impl<'s, T: Transaction, S: TStateView<Key = T::Key>> BlockGasLimitProcessor<'s,
         if let Some(per_block_output_limit) = self.block_gas_limit_type.block_output_limit() {
             let accumulated_output = self.get_accumulated_approx_output_size();
             if accumulated_output >= per_block_output_limit {
-                counters::EXCEED_PER_BLOCK_OUTPUT_LIMIT_COUNT
-                    .with_label_values(&[mode])
-                    .inc();
+                counters::EXCEED_PER_BLOCK_OUTPUT_LIMIT_COUNT.inc_with(&[mode]);
                 info!(
                     "[BlockSTM]: execution ({}) early halted due to \
                     accumulated_output {} >= PER_BLOCK_OUTPUT_LIMIT {}",

execution/block-partitioner/src/v2/build_edge.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::v2::{counters::MISC_TIMERS_SECONDS, state::PartitionState, PartitionerV2};
+use aptos_metrics_core::TimerHelper;
 use aptos_types::{
     block_executor::partitioner::{
         PartitionedTransactions, SubBlock, SubBlocksForShard, TransactionWithDependencies,
@@ -16,9 +17,7 @@ use std::sync::Mutex;
 
 impl PartitionerV2 {
     pub(crate) fn add_edges(state: &mut PartitionState) -> PartitionedTransactions {
-        let _timer = MISC_TIMERS_SECONDS
-            .with_label_values(&["add_edges"])
-            .start_timer();
+        let _timer = MISC_TIMERS_SECONDS.timer_with(&["add_edges"]);
 
         state.sub_block_matrix = state.thread_pool.install(|| {
             (0..state.num_rounds())

execution/block-partitioner/src/v2/init.rs

@@ -8,14 +8,13 @@ use crate::{
         state::PartitionState, types::OriginalTxnIdx, PartitionerV2,
     },
 };
+use aptos_metrics_core::TimerHelper;
 use rayon::{iter::ParallelIterator, prelude::IntoParallelIterator};
 use std::sync::RwLock;
 
 impl PartitionerV2 {
     pub(crate) fn init(state: &mut PartitionState) {
-        let _timer = MISC_TIMERS_SECONDS
-            .with_label_values(&["init"])
-            .start_timer();
+        let _timer = MISC_TIMERS_SECONDS.timer_with(&["init"]);
 
         state.thread_pool.install(|| {
             (0..state.num_txns())

execution/block-partitioner/src/v2/partition_to_matrix.rs

@@ -9,6 +9,7 @@ use crate::v2::{
     PartitionerV2,
 };
 use aptos_logger::trace;
+use aptos_metrics_core::TimerHelper;
 use aptos_types::block_executor::partitioner::{RoundId, TxnIndex};
 use dashmap::DashMap;
 use rayon::{
@@ -27,9 +28,7 @@ impl PartitionerV2 {
     /// Populate `state.finalized_txn_matrix` with txns flattened into a matrix (num_rounds by num_shards),
     /// in a way that avoid in-round cross-shard conflicts.
     pub(crate) fn remove_cross_shard_dependencies(state: &mut PartitionState) {
-        let _timer = MISC_TIMERS_SECONDS
-            .with_label_values(&["remove_cross_shard_dependencies"])
-            .start_timer();
+        let _timer = MISC_TIMERS_SECONDS.timer_with(&["remove_cross_shard_dependencies"]);
 
         let mut remaining_txns = mem::take(&mut state.pre_partitioned);
         assert_eq!(state.num_executor_shards, remaining_txns.len());
@@ -48,9 +47,7 @@ impl PartitionerV2 {
             }
         }
 
-        let _timer = MISC_TIMERS_SECONDS
-            .with_label_values(&["last_round"])
-            .start_timer();
+        let _timer = MISC_TIMERS_SECONDS.timer_with(&["last_round"]);
 
         if !state.partition_last_round {
             trace!("Merging txns after discarding stopped.");
@@ -83,9 +80,7 @@ impl PartitionerV2 {
         Vec<Vec<PrePartitionedTxnIdx>>,
         Vec<Vec<PrePartitionedTxnIdx>>,
     ) {
-        let _timer = MISC_TIMERS_SECONDS
-            .with_label_values(&[format!("round_{round_id}").as_str()])
-            .start_timer();
+        let _timer = MISC_TIMERS_SECONDS.timer_with(&[format!("round_{round_id}").as_str()]);
 
         let num_shards = remaining_txns.len();
 
@@ -182,9 +177,7 @@ impl PartitionerV2 {
     }
 
     pub(crate) fn build_index_from_txn_matrix(state: &mut PartitionState) {
-        let _timer = MISC_TIMERS_SECONDS
-            .with_label_values(&["build_index_from_txn_matrix"])
-            .start_timer();
+        let _timer = MISC_TIMERS_SECONDS.timer_with(&["build_index_from_txn_matrix"]);
 
         let num_rounds = state.finalized_txn_matrix.len();
         state.start_index_matrix = vec![vec![0; state.num_executor_shards]; num_rounds];

execution/block-partitioner/src/v2/state.rs

@@ -14,6 +14,7 @@ use crate::{
     },
     Sender,
 };
+use aptos_metrics_core::TimerHelper;
 use aptos_types::{
     block_executor::partitioner::{
         CrossShardDependencies, RoundId, ShardId, ShardedTxnIndex, SubBlock,
@@ -116,9 +117,7 @@ impl PartitionState {
         cross_shard_dep_avoid_threshold: f32,
         partition_last_round: bool,
     ) -> Self {
-        let _timer = MISC_TIMERS_SECONDS
-            .with_label_values(&["new"])
-            .start_timer();
+        let _timer = MISC_TIMERS_SECONDS.timer_with(&["new"]);
         let num_txns = txns.len();
         let sender_counter = AtomicUsize::new(0);
         let key_counter = AtomicUsize::new(0);

execution/executor-benchmark/src/block_preparation.rs

@@ -9,6 +9,7 @@ use aptos_block_partitioner::{BlockPartitioner, PartitionerConfig};
 use aptos_crypto::HashValue;
 use aptos_experimental_runtimes::thread_manager::optimal_min_len;
 use aptos_logger::info;
+use aptos_metrics_core::{IntCounterVecHelper, TimerHelper};
 use aptos_types::{
     block_executor::partitioner::{ExecutableBlock, ExecutableTransactions},
     transaction::{signature_verified_transaction::SignatureVerifiedTransaction, Transaction},
@@ -70,12 +71,10 @@ impl BlockPreparationStage {
         let block_id = HashValue::random();
         let sig_verified_txns: Vec<SignatureVerifiedTransaction> =
             self.sig_verify_pool.install(|| {
-                let _timer = TIMER.with_label_values(&["sig_verify"]).start_timer();
+                let _timer = TIMER.timer_with(&["sig_verify"]);
 
                 let num_txns = txns.len();
-                NUM_TXNS
-                    .with_label_values(&["sig_verify"])
-                    .inc_by(num_txns as u64);
+                NUM_TXNS.inc_with_by(&["sig_verify"], num_txns as u64);
 
                 txns.into_par_iter()
                     .with_min_len(optimal_min_len(num_txns, SIG_VERIFY_RAYON_MIN_THRESHOLD))
@@ -85,12 +84,10 @@ impl BlockPreparationStage {
         let block: ExecutableBlock = match &self.maybe_partitioner {
             None => (block_id, sig_verified_txns).into(),
             Some(partitioner) => {
-                NUM_TXNS
-                    .with_label_values(&["partition"])
-                    .inc_by(sig_verified_txns.len() as u64);
+                NUM_TXNS.inc_with_by(&["partition"], sig_verified_txns.len() as u64);
                 let analyzed_transactions =
                     sig_verified_txns.into_iter().map(|t| t.into()).collect();
-                let timer = TIMER.with_label_values(&["partition"]).start_timer();
+                let timer = TIMER.timer_with(&["partition"]);
                 let partitioned_txns =
                     partitioner.partition(analyzed_transactions, self.num_executor_shards);
                 timer.stop_and_record();