Log Count metrics

anchor/Cargo.toml

@@ -15,6 +15,7 @@ futures = { workspace = true }
 keygen = { workspace = true }
 keysplit = { workspace = true }
 logging = { workspace = true }
+metrics = { workspace = true }
 serde = { workspace = true }
 strum = { workspace = true }
 task_executor = { workspace = true }

anchor/logging/Cargo.toml

@@ -11,10 +11,12 @@ chrono = { version = "0.4", default-features = false, features = [
 ] }
 clap = { workspace = true }
 logroller = "0.1.8"
+metrics = { workspace = true }
 serde = { workspace = true }
 strum = { workspace = true }
 tracing = { workspace = true }
 tracing-appender = "0.2"
 tracing-core = "0.1"
+tracing-log = "0.2.0"
 tracing-subscriber = { workspace = true }
 workspace_members = { workspace = true }

anchor/logging/src/count_layer.rs

@@ -0,0 +1,93 @@
+use std::sync::LazyLock;
+
+use tracing_log::NormalizeEvent;
+
+// Global metrics counters
+pub static INFOS_TOTAL: LazyLock<metrics::Result<metrics::IntCounter>> = LazyLock::new(|| {
+    metrics::try_create_int_counter(
+        "info_total",
+        "Total count of info logs across all dependencies",
+    )
+});
+
+pub static WARNS_TOTAL: LazyLock<metrics::Result<metrics::IntCounter>> = LazyLock::new(|| {
+    metrics::try_create_int_counter(
+        "warn_total",
+        "Total count of warn logs across all dependencies",
+    )
+});
+
+pub static ERRORS_TOTAL: LazyLock<metrics::Result<metrics::IntCounter>> = LazyLock::new(|| {
+    metrics::try_create_int_counter(
+        "error_total",
+        "Total count of error logs across all dependencies",
+    )
+});
+
+// Dependency-specific metrics
+pub static DEP_INFOS_TOTAL: LazyLock<metrics::Result<metrics::IntCounterVec>> =
+    LazyLock::new(|| {
+        metrics::try_create_int_counter_vec(
+            "dep_info_total",
+            "Count of infos logged per enabled dependency",
+            &["target"],
+        )
+    });
+
+pub static DEP_WARNS_TOTAL: LazyLock<metrics::Result<metrics::IntCounterVec>> =
+    LazyLock::new(|| {
+        metrics::try_create_int_counter_vec(
+            "dep_warn_total",
+            "Count of warns logged per enabled dependency",
+            &["target"],
+        )
+    });
+
+pub static DEP_ERRORS_TOTAL: LazyLock<metrics::Result<metrics::IntCounterVec>> =
+    LazyLock::new(|| {
+        metrics::try_create_int_counter_vec(
+            "dep_error_total",
+            "Count of errors logged per enabled dependency",
+            &["target"],
+        )
+    });
+
+// Count layer implementation
+pub struct CountLayer;
+impl<S: tracing_core::Subscriber> tracing_subscriber::layer::Layer<S> for CountLayer {
+    fn on_event(
+        &self,
+        event: &tracing_core::Event<'_>,
+        _ctx: tracing_subscriber::layer::Context<'_, S>,
+    ) {
+        // get the event's normalized metadata
+        let normalized_meta = event.normalized_metadata();
+        let meta = normalized_meta.as_ref().unwrap_or_else(|| event.metadata());
+        if !meta.is_event() {
+            // ignore tracing span events
+            return;
+        }
+
+        // First, increment global counters regardless of target
+        match *meta.level() {
+            tracing_core::Level::INFO => metrics::inc_counter(&INFOS_TOTAL),
+            tracing_core::Level::WARN => metrics::inc_counter(&WARNS_TOTAL),
+            tracing_core::Level::ERROR => metrics::inc_counter(&ERRORS_TOTAL),
+            _ => {}
+        }
+
+        // Then handle dependency-specific counters
+        let full_target = meta.module_path().unwrap_or_else(|| meta.target());
+        let target = full_target
+            .split_once("::")
+            .map(|(name, _rest)| name)
+            .unwrap_or(full_target);
+        let target = &[target];
+        match *meta.level() {
+            tracing_core::Level::INFO => metrics::inc_counter_vec(&DEP_INFOS_TOTAL, target),
+            tracing_core::Level::WARN => metrics::inc_counter_vec(&DEP_WARNS_TOTAL, target),
+            tracing_core::Level::ERROR => metrics::inc_counter_vec(&DEP_ERRORS_TOTAL, target),
+            _ => {}
+        }
+    }
+}

anchor/logging/src/lib.rs

@@ -1,4 +1,6 @@
+mod count_layer;
 mod logging;
 mod tracing_libp2p_discv5_layer;
 pub mod utils;
+pub use count_layer::CountLayer;
 pub use logging::*;

anchor/message_validator/src/consensus_message.rs

@@ -927,7 +927,11 @@ mod tests {
             signed_ssv_message: &signed_msg,
             committee_info: &committee_info,
             role: Role::Proposer, // Proposer role has TTL = 1 + LATE_SLOT_ALLOWANCE + LATE_MESSAGE_MARGIN. To be late for slot 1, we need to add more 2 seconds (2 * slot duration).
-            received_at: now.checked_add(Duration::from_secs(1 + LATE_SLOT_ALLOWANCE + 2)).unwrap().checked_add(LATE_MESSAGE_MARGIN).unwrap(),
+            received_at: now
+                .checked_add(Duration::from_secs(1 + LATE_SLOT_ALLOWANCE + 2))
+                .unwrap()
+                .checked_add(LATE_MESSAGE_MARGIN)
+                .unwrap(),
             operators_pk: &[],
             slots_per_epoch: 32,
             epochs_per_sync_committee_period: 256,

anchor/src/main.rs

@@ -13,7 +13,7 @@ use keygen::Keygen;
 use keysplit::Keysplit;
 use logging::{
     create_libp2p_discv5_tracing_layer, init_file_logging, utils::build_workspace_filter,
-    Libp2pDiscv5TracingLayer, LoggerConfig, LoggingLayer,
+    CountLayer, Libp2pDiscv5TracingLayer, LoggerConfig, LoggingLayer,
 };
 use task_executor::ShutdownReason;
 use tracing::Level;
@@ -244,6 +244,9 @@ fn enable_logging(anchor_config: &Node) -> (Option<WorkerGuard>, Option<Libp2pDi
         );
     }
 
+    // Add the CountLayer
+    logging_layers.push(CountLayer.boxed());
+
     let logging_result = tracing_subscriber::registry()
         .with(logging_layers)
         .try_init();