Added metrics for tree_availability crate

crates/tree_availability/src/server.rs

@@ -11,6 +11,7 @@ use semaphore::Field;
 use serde::de::Error;
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::Value;
+use tokio::time::Instant;
 
 use crate::error::TreeError;
 use crate::world_tree::{Hash, WorldTree};
@@ -81,12 +82,21 @@ pub async fn inclusion_proof<M: Middleware>(
     State(world_tree): State<Arc<WorldTree<M>>>,
     Json(req): Json<InclusionProofRequest>,
 ) -> Result<(StatusCode, Json<Option<InclusionProof>>), TreeError> {
+    metrics::increment_counter!("tree_availability.server.inclusion_proof");
+
     if world_tree.tree_updater.synced.load(Ordering::Relaxed) {
+        let inclusion_proof_start_time = Instant::now();
+
         let inclusion_proof = world_tree
             .tree_data
             .get_inclusion_proof(req.identity_commitment, req.root)
             .await;
 
+        metrics::histogram!(
+            "tree_availability.server.inclusion_proof_duration_ms",
+            inclusion_proof_start_time.elapsed().as_millis() as f64
+        );
+
         Ok((StatusCode::OK, inclusion_proof.into()))
     } else {
         Err(TreeError::TreeNotSynced)

crates/tree_availability/src/world_tree/block_scanner.rs

@@ -34,6 +34,11 @@ where
     ) -> Result<Vec<Log>, M::Error> {
         let latest_block = self.middleware.get_block_number().await?.as_u64();
 
+        metrics::gauge!(
+            "tree_availability.block_scanner.latest_block",
+            latest_block as f64
+        );
+
         let current_block = self.current_block.load(Ordering::SeqCst);
 
         if current_block >= latest_block {

crates/tree_availability/src/world_tree/tree_updater.rs

@@ -113,6 +113,10 @@ impl<M: Middleware> TreeUpdater<M> {
                 .map(|u256: U256| Hash::from_limbs(u256.0))
                 .collect();
 
+            metrics::increment_counter!(
+                "tree_availability.tree_updater.insertion"
+            );
+
             tree_data
                 .insert_many_at(start_index as usize, &identities)
                 .await;
@@ -126,6 +130,10 @@ impl<M: Middleware> TreeUpdater<M> {
             let indices: Vec<_> =
                 indices.into_iter().map(|x| x as usize).collect();
 
+            metrics::increment_counter!(
+                "tree_availability.tree_updater.deletion"
+            );
+
             tree_data.delete_many(&indices).await;
         } else {
             return Err(TreeAvailabilityError::UnrecognizedFunctionSelector);