feat(l1): rpc instrumentation and panels

Cargo.toml

@@ -60,6 +60,7 @@ ethrex-levm = { path = "./crates/vm/levm" }
 ethrex-trie = { path = "./crates/common/trie" }
 ethrex-rlp = { path = "./crates/common/rlp" }
 ethrex-crypto = { path = "./crates/common/crypto" }
+ethrex-metrics = { path = "./crates/blockchain/metrics" }
 ethrex-l2 = { path = "./crates/l2" }
 ethrex-l2-common = { path = "./crates/l2/common" }
 ethrex-sdk = { path = "./crates/l2/sdk" }

crates/blockchain/blockchain.rs

@@ -180,7 +180,12 @@ impl Blockchain {
     }
 
     /// Executes a block withing a new vm instance and state
-    #[instrument(level = "trace", name = "Execute Block", skip_all)]
+    #[instrument(
+        level = "trace",
+        name = "Execute Block",
+        skip_all,
+        fields(namespace = "block_execution")
+    )]
     fn execute_block_pipeline(
         &self,
         block: &Block,
@@ -280,7 +285,12 @@ impl Blockchain {
         ))
     }
 
-    #[instrument(level = "trace", name = "Trie update", skip_all)]
+    #[instrument(
+        level = "trace",
+        name = "Trie update",
+        skip_all,
+        fields(namespace = "block_execution")
+    )]
     fn handle_merkleization(
         &self,
         rx: Receiver<Vec<AccountUpdate>>,
@@ -772,7 +782,12 @@ impl Blockchain {
         })
     }
 
-    #[instrument(level = "trace", name = "Block DB update", skip_all)]
+    #[instrument(
+        level = "trace",
+        name = "Block DB update",
+        skip_all,
+        fields(namespace = "block_execution")
+    )]
     pub fn store_block(
         &self,
         block: Block,

crates/blockchain/metrics/profiling.rs

@@ -1,6 +1,10 @@
 use prometheus::{Encoder, HistogramTimer, HistogramVec, TextEncoder, register_histogram_vec};
-use std::sync::LazyLock;
-use tracing::{Subscriber, span::Id};
+use std::{future::Future, sync::LazyLock};
+use tracing::{
+    Subscriber,
+    field::{Field, Visit},
+    span::{Attributes, Id},
+};
 use tracing_subscriber::{Layer, layer::Context, registry::LookupSpan};
 
 use crate::MetricsError;
@@ -11,8 +15,8 @@ pub static METRICS_BLOCK_PROCESSING_PROFILE: LazyLock<HistogramVec> =
 fn initialize_histogram_vec() -> HistogramVec {
     register_histogram_vec!(
         "function_duration_seconds",
-        "Histogram of the run time of the functions in block processing",
-        &["function_name"]
+        "Histogram of the run time of the functions in block processing and RPC handling",
+        &["namespace", "function_name"]
     )
     .unwrap()
 }
@@ -25,19 +29,72 @@ pub struct FunctionProfilingLayer;
 /// Wrapper around [`HistogramTimer`] to avoid conflicts with other layers
 struct ProfileTimer(HistogramTimer);
 
+/// Span extension storing the profiling namespace selected by instrumentation. This needs to
+/// be a String instead of a &'static str because using the span macros we could recieve dynamically
+/// generated names and can't rely on only string literals.
+struct Namespace(String);
+
+#[derive(Default)]
+struct NamespaceVisitor {
+    namespace: Option<String>,
+}
+
+impl Visit for NamespaceVisitor {
+    fn record_str(&mut self, field: &Field, value: &str) {
+        if field.name() == "namespace" {
+            self.namespace = Some(value.to_owned());
+        }
+    }
+
+    fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
+        if field.name() == "namespace" {
+            let rendered = format!("{value:?}");
+            let cleaned = rendered
+                .strip_prefix('"')
+                .and_then(|s| s.strip_suffix('"'))
+                .unwrap_or(&rendered);
+            self.namespace = Some(cleaned.to_owned());
+        }
+    }
+}
+
 impl<S> Layer<S> for FunctionProfilingLayer
 where
     S: Subscriber + for<'a> LookupSpan<'a>,
 {
+    fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>) {
+        let mut visitor = NamespaceVisitor::default();
+        attrs.record(&mut visitor);
+
+        if let (Some(span), Some(namespace)) = (ctx.span(id), visitor.namespace) {
+            span.extensions_mut().insert(Namespace(namespace));
+        }
+    }
+
     fn on_enter(&self, id: &Id, ctx: Context<'_, S>) {
         if let Some(span) = ctx.span(id)
             && span.metadata().target().starts_with("ethrex")
         {
-            let name = span.metadata().name();
+            let target = span.metadata().target();
+
+            // Skip RPC modules; RPC timing is recorded explicitly at the call sites.
+            if target.contains("::rpc") {
+                return;
+            }
+            let timer = {
+                let extensions = span.extensions();
+                let namespace = extensions
+                    .get::<Namespace>()
+                    .map(|ns| ns.0.as_str())
+                    .unwrap_or("default");
+
+                let function_name = span.metadata().name();
+
+                METRICS_BLOCK_PROCESSING_PROFILE
+                    .with_label_values(&[namespace, function_name])
+                    .start_timer()
+            };
 
-            let timer = METRICS_BLOCK_PROCESSING_PROFILE
-                .with_label_values(&[name])
-                .start_timer();
             // PERF: `extensions_mut` uses a Mutex internally (per span)
             span.extensions_mut().insert(ProfileTimer(timer));
         }
@@ -54,6 +111,31 @@ where
     }
 }
 
+/// Records the duration of an async operation in the function profiling histogram.
+///
+/// This provides a lightweight alternative to the `#[instrument]` attribute when you need
+/// manual control over timing instrumentation, such as in RPC handlers.
+///
+/// # Parameters
+/// * `namespace` - Category for the metric (e.g., "rpc", "engine", "block_execution")
+/// * `function_name` - Name identifier for the operation being timed
+/// * `future` - The async operation to time
+///
+/// Use this function when you need to instrument an async operation for duration metrics,
+/// but cannot or do not want to use the `#[instrument]` attribute (for example, in RPC handlers).
+pub async fn record_async_duration<Fut, T>(namespace: &str, function_name: &str, future: Fut) -> T
+where
+    Fut: Future<Output = T>,
+{
+    let timer = METRICS_BLOCK_PROCESSING_PROFILE
+        .with_label_values(&[namespace, function_name])
+        .start_timer();
+
+    let output = future.await;
+    timer.observe_duration();
+    output
+}
+
 pub fn gather_profiling_metrics() -> Result<String, MetricsError> {
     let encoder = TextEncoder::new();
     let metric_families = prometheus::gather();

crates/blockchain/vm.rs

@@ -44,21 +44,36 @@ impl StoreVmDatabase {
 }
 
 impl VmDatabase for StoreVmDatabase {
-    #[instrument(level = "trace", name = "Account read", skip_all)]
+    #[instrument(
+        level = "trace",
+        name = "Account read",
+        skip_all,
+        fields(namespace = "block_execution")
+    )]
     fn get_account_state(&self, address: Address) -> Result<Option<AccountState>, EvmError> {
         self.store
             .get_account_state_by_root(self.state_root, address)
             .map_err(|e| EvmError::DB(e.to_string()))
     }
 
-    #[instrument(level = "trace", name = "Storage read", skip_all)]
+    #[instrument(
+        level = "trace",
+        name = "Storage read",
+        skip_all,
+        fields(namespace = "block_execution")
+    )]
     fn get_storage_slot(&self, address: Address, key: H256) -> Result<Option<U256>, EvmError> {
         self.store
             .get_storage_at_root(self.state_root, address, key)
             .map_err(|e| EvmError::DB(e.to_string()))
     }
 
-    #[instrument(level = "trace", name = "Block hash read", skip_all)]
+    #[instrument(
+        level = "trace",
+        name = "Block hash read",
+        skip_all,
+        fields(namespace = "block_execution")
+    )]
     fn get_block_hash(&self, block_number: u64) -> Result<H256, EvmError> {
         // Check if we have it cached
         if let Some(block_hash) = self.block_hash_cache.get(&block_number) {
@@ -103,7 +118,12 @@ impl VmDatabase for StoreVmDatabase {
         Ok(self.store.get_chain_config())
     }
 
-    #[instrument(level = "trace", name = "Account code read", skip_all)]
+    #[instrument(
+        level = "trace",
+        name = "Account code read",
+        skip_all,
+        fields(namespace = "block_execution")
+    )]
     fn get_account_code(&self, code_hash: H256) -> Result<Code, EvmError> {
         if code_hash == *EMPTY_KECCACK_HASH {
             return Ok(Code::default());

crates/networking/rpc/Cargo.toml

@@ -20,6 +20,7 @@ ethrex-common.workspace = true
 ethrex-storage.workspace = true
 ethrex-vm.workspace = true
 ethrex-blockchain.workspace = true
+ethrex-metrics.workspace = true
 ethrex-crypto.workspace = true
 ethrex-p2p = { workspace = true, features = ["test-utils"] }
 ethrex-rlp.workspace = true

crates/networking/rpc/rpc.rs

@@ -55,6 +55,7 @@ use bytes::Bytes;
 use ethrex_blockchain::Blockchain;
 use ethrex_blockchain::error::ChainError;
 use ethrex_common::types::Block;
+use ethrex_metrics::profiling::record_async_duration;
 use ethrex_p2p::peer_handler::PeerHandler;
 use ethrex_p2p::sync_manager::SyncManager;
 use ethrex_p2p::types::Node;
@@ -191,7 +192,15 @@ pub trait RpcHandler: Sized {
 
     async fn call(req: &RpcRequest, context: RpcApiContext) -> Result<Value, RpcErr> {
         let request = Self::parse(&req.params)?;
-        request.handle(context).await
+        let namespace = match req.namespace() {
+            Ok(RpcNamespace::Engine) => "engine",
+            _ => "rpc",
+        };
+
+        record_async_duration(namespace, req.method.as_str(), async move {
+            request.handle(context).await
+        })
+        .await
     }
 
     async fn handle(&self, context: RpcApiContext) -> Result<Value, RpcErr>;

crates/vm/backends/mod.rs

@@ -77,7 +77,12 @@ impl Evm {
         LEVM::execute_block(block, &mut self.db, self.vm_type)
     }
 
-    #[instrument(level = "trace", name = "Block execution", skip_all)]
+    #[instrument(
+        level = "trace",
+        name = "Block execution",
+        skip_all,
+        fields(namespace = "block_execution")
+    )]
     pub fn execute_block_pipeline(
         &mut self,
         block: &Block,