fix(l1): headers snapsync logs (#5082)

**Motivation**

The logs for the headers in snapsync shows inaccurate numbers due to the
chunked header download. This pr aims to fix that and show the proper
percentage of headers to download.

**Description**

- Change `METRICS.headers_downloaded` to an `IntCounter` instead of
`AtomicU64`
- Removed `METRICS.headers_to_download` and replaced the calculation
with `METRICS.sync_head_block`
- Fixed `METRICS.sync_head_block` to include the proper 

Works to improve #4950

Author: fedacking

crates/networking/p2p/metrics.rs

@@ -61,8 +61,7 @@ pub struct Metrics {
     pub current_step: Arc<CurrentStep>,
 
     // Headers
-    pub headers_to_download: AtomicU64,
-    pub downloaded_headers: AtomicU64,
+    pub downloaded_headers: IntCounter,
     pub time_to_retrieve_sync_head_block: Arc<Mutex<Option<Duration>>>,
     pub headers_download_start_time: Arc<Mutex<Option<SystemTime>>>,
 
@@ -632,6 +631,16 @@ impl Default for Metrics {
             .register(Box::new(storage_leaves_inserted.clone()))
             .expect("Failed to register storage_leaves_inserted counter");
 
+        let downloaded_headers = IntCounter::new(
+            "downloaded_headers",
+            "Total number of headers already download",
+        )
+        .expect("Failed to create downloaded_headers counter");
+
+        registry
+            .register(Box::new(downloaded_headers.clone()))
+            .expect("Failed to register downloaded_headers counter");
+
         let storage_leaves_downloaded = IntCounter::new(
             "storage_leaves_downloaded",
             "Total number of storage leaves downloaded",
@@ -679,8 +688,7 @@ impl Default for Metrics {
             current_step: Arc::new(CurrentStep(AtomicU8::new(0))),
 
             // Headers
-            headers_to_download: AtomicU64::new(0),
-            downloaded_headers: AtomicU64::new(0),
+            downloaded_headers,
             time_to_retrieve_sync_head_block: Arc::new(Mutex::new(None)),
             headers_download_start_time: Arc::new(Mutex::new(None)),
 

crates/networking/p2p/network.rs

@@ -198,8 +198,11 @@ pub async fn periodically_show_peer_stats_during_syncing(
             let current_header_hash = *METRICS.sync_head_hash.lock().await;
 
             // Headers metrics
-            let headers_to_download = METRICS.headers_to_download.load(Ordering::Relaxed);
-            let headers_downloaded = METRICS.downloaded_headers.load(Ordering::Relaxed);
+            let headers_to_download = METRICS.sync_head_block.load(Ordering::Relaxed);
+            // We may download more than expected headers due to duplicates
+            // We just clamp it to the max to avoid showing the user confusing data
+            let headers_downloaded =
+                u64::min(METRICS.downloaded_headers.get(), headers_to_download);
             let headers_remaining = headers_to_download.saturating_sub(headers_downloaded);
             let headers_download_progress = if headers_to_download == 0 {
                 "0%".to_string()

crates/networking/p2p/peer_handler.rs

@@ -190,8 +190,6 @@ impl PeerHandler {
             .current_step
             .set(CurrentStepValue::DownloadingHeaders);
 
-        let initial_downloaded_headers = METRICS.downloaded_headers.load(Ordering::Relaxed);
-
         let mut ret = Vec::<BlockHeader>::new();
 
         let mut sync_head_number = 0_u64;
@@ -238,6 +236,9 @@ impl PeerHandler {
 
             retries += 1;
         }
+        METRICS
+            .sync_head_block
+            .store(sync_head_number, Ordering::Relaxed);
         sync_head_number = sync_head_number.min(start + MAX_HEADER_CHUNK);
 
         let sync_head_number_retrieval_elapsed = sync_head_number_retrieval_start
@@ -248,12 +249,6 @@ impl PeerHandler {
 
         *METRICS.time_to_retrieve_sync_head_block.lock().await =
             Some(sync_head_number_retrieval_elapsed);
-        METRICS
-            .sync_head_block
-            .store(sync_head_number, Ordering::Relaxed);
-        METRICS
-            .headers_to_download
-            .store(sync_head_number + 1, Ordering::Relaxed);
         *METRICS.sync_head_hash.lock().await = sync_head;
 
         let block_count = sync_head_number + 1 - start;
@@ -307,9 +302,7 @@ impl PeerHandler {
 
                 downloaded_count += headers.len() as u64;
 
-                METRICS
-                    .downloaded_headers
-                    .fetch_add(headers.len() as u64, Ordering::Relaxed);
+                METRICS.downloaded_headers.inc_by(headers.len() as u64);
 
                 let batch_show = downloaded_count / 10_000;
 
@@ -393,11 +386,6 @@ impl PeerHandler {
             });
         }
 
-        METRICS.downloaded_headers.store(
-            initial_downloaded_headers + downloaded_count,
-            Ordering::Relaxed,
-        );
-
         let elapsed = start_time.elapsed().unwrap_or_default();
 
         debug!(