Add more metrics, tidy existing metrics

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -827,8 +827,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             return Ok(BlockProcessingOutcome::GenesisBlock);
         }
 
+        let block_root_timer = metrics::start_timer(&metrics::BLOCK_PROCESSING_BLOCK_ROOT);
+
         let block_root = block.canonical_root();
 
+        metrics::stop_timer(block_root_timer);
+
         if block_root == self.genesis_block_root {
             return Ok(BlockProcessingOutcome::GenesisBlock);
         }

beacon_node/beacon_chain/src/metrics.rs

@@ -16,6 +16,10 @@ lazy_static! {
     );
     pub static ref BLOCK_PROCESSING_TIMES: Result<Histogram> =
         try_create_histogram("beacon_block_processing_seconds", "Full runtime of block processing");
+    pub static ref BLOCK_PROCESSING_BLOCK_ROOT: Result<Histogram> = try_create_histogram(
+        "beacon_block_processing_block_root_seconds",
+        "Time spent calculating the block root when processing a block."
+    );
     pub static ref BLOCK_PROCESSING_DB_READ: Result<Histogram> = try_create_histogram(
         "beacon_block_processing_db_read_seconds",
         "Time spent loading block and state from DB for block processing"

beacon_node/eth2-libp2p/src/discovery.rs

@@ -159,13 +159,17 @@ where
     }
 
     fn inject_connected(&mut self, peer_id: PeerId, _endpoint: ConnectedPoint) {
-        metrics::inc_counter(&metrics::PEER_CONNECT_COUNT);
         self.connected_peers.insert(peer_id);
+
+        metrics::inc_counter(&metrics::PEER_CONNECT_EVENT_COUNT);
+        metrics::set_gauge(&metrics::PEERS_CONNECTED, self.connected_peers() as i64);
     }
 
     fn inject_disconnected(&mut self, peer_id: &PeerId, _endpoint: ConnectedPoint) {
-        metrics::inc_counter(&metrics::PEER_DISCONNECT_COUNT);
         self.connected_peers.remove(peer_id);
+
+        metrics::inc_counter(&metrics::PEER_DISCONNECT_EVENT_COUNT);
+        metrics::set_gauge(&metrics::PEERS_CONNECTED, self.connected_peers() as i64);
     }
 
     fn inject_replaced(

beacon_node/eth2-libp2p/src/metrics.rs

@@ -2,15 +2,19 @@ pub use lighthouse_metrics::*;
 
 lazy_static! {
     pub static ref ADDRESS_UPDATE_COUNT: Result<IntCounter> = try_create_int_counter(
-        "libp2p_address_update_count",
+        "libp2p_address_update_total",
         "Count of libp2p socked updated events (when our view of our IP address has changed)"
     );
-    pub static ref PEER_CONNECT_COUNT: Result<IntCounter> = try_create_int_counter(
-        "libp2p_peer_connect_count",
+    pub static ref PEERS_CONNECTED: Result<IntGauge> = try_create_int_gauge(
+        "libp2p_peer_connected_peers_total",
+        "Count of libp2p peers currently connected"
+    );
+    pub static ref PEER_CONNECT_EVENT_COUNT: Result<IntCounter> = try_create_int_counter(
+        "libp2p_peer_connect_event_total",
         "Count of libp2p peer connect events (not the current number of connected peers)"
     );
-    pub static ref PEER_DISCONNECT_COUNT: Result<IntCounter> = try_create_int_counter(
-        "libp2p_peer_disconnect_count",
+    pub static ref PEER_DISCONNECT_EVENT_COUNT: Result<IntCounter> = try_create_int_counter(
+        "libp2p_peer_disconnect_event_total",
         "Count of libp2p peer disconnect events"
     );
 }

beacon_node/store/src/impls.rs

@@ -9,10 +9,26 @@ impl<T: EthSpec> StoreItem for BeaconBlock<T> {
     }
 
     fn as_store_bytes(&self) -> Vec<u8> {
-        self.as_ssz_bytes()
+        let timer = metrics::start_timer(&metrics::BEACON_STATE_WRITE_TIMES);
+        let bytes = self.as_ssz_bytes();
+
+        metrics::stop_timer(timer);
+        metrics::inc_counter(&metrics::BEACON_STATE_WRITE_COUNT);
+        metrics::inc_counter_by(&metrics::BEACON_STATE_WRITE_BYTES, bytes.len() as i64);
+
+        bytes
     }
 
     fn from_store_bytes(bytes: &mut [u8]) -> Result<Self, Error> {
-        Self::from_ssz_bytes(bytes).map_err(Into::into)
+        let timer = metrics::start_timer(&metrics::BEACON_STATE_READ_TIMES);
+
+        let len = bytes.len();
+        let result = Self::from_ssz_bytes(bytes).map_err(Into::into);
+
+        metrics::stop_timer(timer);
+        metrics::inc_counter(&metrics::BEACON_STATE_READ_COUNT);
+        metrics::inc_counter_by(&metrics::BEACON_STATE_READ_BYTES, len as i64);
+
+        result
     }
 }

beacon_node/store/src/impls/beacon_state.rs

@@ -53,12 +53,29 @@ impl<T: EthSpec> StoreItem for BeaconState<T> {
     }
 
     fn as_store_bytes(&self) -> Vec<u8> {
+        let timer = metrics::start_timer(&metrics::BEACON_STATE_WRITE_TIMES);
+
         let container = StorageContainer::new(self);
-        container.as_ssz_bytes()
+        let bytes = container.as_ssz_bytes();
+
+        metrics::stop_timer(timer);
+        metrics::inc_counter(&metrics::BEACON_STATE_WRITE_COUNT);
+        metrics::inc_counter_by(&metrics::BEACON_STATE_WRITE_BYTES, bytes.len() as i64);
+
+        bytes
     }
 
     fn from_store_bytes(bytes: &mut [u8]) -> Result<Self, Error> {
+        let timer = metrics::start_timer(&metrics::BEACON_STATE_READ_TIMES);
+
+        let len = bytes.len();
         let container = StorageContainer::from_ssz_bytes(bytes)?;
-        container.try_into()
+        let result = container.try_into();
+
+        metrics::stop_timer(timer);
+        metrics::inc_counter(&metrics::BEACON_STATE_READ_COUNT);
+        metrics::inc_counter_by(&metrics::BEACON_STATE_READ_BYTES, len as i64);
+
+        result
     }
 }

beacon_node/store/src/metrics.rs

@@ -4,6 +4,9 @@ use std::fs;
 use std::path::PathBuf;
 
 lazy_static! {
+    /*
+     * General
+     */
     pub static ref DISK_DB_SIZE: Result<IntGauge> =
         try_create_int_gauge("store_disk_db_size", "Size of the on-disk database (bytes)");
     pub static ref DISK_DB_WRITE_BYTES: Result<IntCounter> = try_create_int_counter(
@@ -30,6 +33,60 @@ lazy_static! {
         "store_disk_db_delete_count_total",
         "Total number of deletions from the on-disk DB"
     );
+    /*
+     * Beacon State
+     */
+    pub static ref BEACON_STATE_READ_TIMES: Result<Histogram> = try_create_histogram(
+        "store_beacon_state_read_overhead_seconds",
+        "Overhead on reading a beacon state from the DB (e.g., decoding)"
+    );
+    pub static ref BEACON_STATE_READ_COUNT: Result<IntCounter> = try_create_int_counter(
+        "store_beacon_state_read_total",
+        "Total number of beacon state reads from the DB"
+    );
+    pub static ref BEACON_STATE_READ_BYTES: Result<IntCounter> = try_create_int_counter(
+        "store_beacon_state_read_bytes_total",
+        "Total number of beacon state bytes read from the DB"
+    );
+    pub static ref BEACON_STATE_WRITE_TIMES: Result<Histogram> = try_create_histogram(
+        "store_beacon_state_write_overhead_seconds",
+        "Overhead on writing a beacon state to the DB (e.g., encoding)"
+    );
+    pub static ref BEACON_STATE_WRITE_COUNT: Result<IntCounter> = try_create_int_counter(
+        "store_beacon_state_write_total",
+        "Total number of beacon state writes the DB"
+    );
+    pub static ref BEACON_STATE_WRITE_BYTES: Result<IntCounter> = try_create_int_counter(
+        "store_beacon_state_write_bytes_total",
+        "Total number of beacon state bytes written to the DB"
+    );
+    /*
+     * Beacon Block
+     */
+    pub static ref BEACON_BLOCK_READ_TIMES: Result<Histogram> = try_create_histogram(
+        "store_beacon_block_read_overhead_seconds",
+        "Overhead on reading a beacon block from the DB (e.g., decoding)"
+    );
+    pub static ref BEACON_BLOCK_READ_COUNT: Result<IntCounter> = try_create_int_counter(
+        "store_beacon_block_read_total",
+        "Total number of beacon block reads from the DB"
+    );
+    pub static ref BEACON_BLOCK_READ_BYTES: Result<IntCounter> = try_create_int_counter(
+        "store_beacon_block_read_bytes_total",
+        "Total number of beacon block bytes read from the DB"
+    );
+    pub static ref BEACON_BLOCK_WRITE_TIMES: Result<Histogram> = try_create_histogram(
+        "store_beacon_block_write_overhead_seconds",
+        "Overhead on writing a beacon block to the DB (e.g., encoding)"
+    );
+    pub static ref BEACON_BLOCK_WRITE_COUNT: Result<IntCounter> = try_create_int_counter(
+        "store_beacon_block_write_total",
+        "Total number of beacon block writes the DB"
+    );
+    pub static ref BEACON_BLOCK_WRITE_BYTES: Result<IntCounter> = try_create_int_counter(
+        "store_beacon_block_write_bytes_total",
+        "Total number of beacon block bytes written to the DB"
+    );
 }
 
 /// Updates the global metrics registry with store-related information.

eth2/utils/slot_clock/src/metrics.rs

@@ -7,6 +7,8 @@ lazy_static! {
         try_create_int_gauge("slotclock_present_slot", "The present wall-clock slot");
     pub static ref PRESENT_EPOCH: Result<IntGauge> =
         try_create_int_gauge("slotclock_present_epoch", "The present wall-clock epoch");
+    pub static ref SLOTS_PER_EPOCH: Result<IntGauge> =
+        try_create_int_gauge("slotclock_slots_per_epoch", "Slots per epoch (constant)");
     pub static ref MILLISECONDS_PER_SLOT: Result<IntGauge> = try_create_int_gauge(
         "slotclock_slot_time_milliseconds",
         "The duration in milliseconds between each slot"
@@ -25,5 +27,6 @@ pub fn scrape_for_metrics<T: EthSpec, U: SlotClock>(clock: &U) {
         &PRESENT_EPOCH,
         present_slot.epoch(T::slots_per_epoch()).as_u64() as i64,
     );
+    set_gauge(&SLOTS_PER_EPOCH, T::slots_per_epoch() as i64);
     set_gauge(&MILLISECONDS_PER_SLOT, clock.slot_duration_millis() as i64);
 }