4 files changed, 47 insertions, 0 deletions
diff --git a/src/api/stats.rs b/src/api/stats.rs
index 558507a..9ac2c94 100644
--- a/src/api/stats.rs
+++ b/src/api/stats.rs
@@ -140,6 +140,11 @@ struct RelayStats {
     pulls: u64,
     /// Announcements of heads we lacked that waited for the pull in progress.
     pulls_queued: u64,
+    /// Links made eager, and lazy again (`swarm::relay`).
+    grafts: u64,
+    prunes: u64,
+    /// Changes forwarded over eager links, per neighbour.
+    eager_forwards: u64,
     /// Blob requests not answered: too many were being answered.
     blob_requests_dropped: u64,
 }
@@ -340,6 +345,9 @@ pub(crate) async fn collect(state: &AppState, list: &PeerListResponse) -> StatsR
             announce_rounds: node.relay.announce_rounds,
             pulls: node.relay.pulls,
             pulls_queued: node.relay.pulls_queued,
+            grafts: node.relay.grafts,
+            prunes: node.relay.prunes,
+            eager_forwards: node.relay.eager_forwards,
             blob_requests_dropped: node.blob_requests_dropped,
         },
         topology: TopologyStats {
diff --git a/src/api/stats/prometheus.rs b/src/api/stats/prometheus.rs
index 0a1d75d..3d4bcc6 100644
--- a/src/api/stats/prometheus.rs
+++ b/src/api/stats/prometheus.rs
@@ -651,6 +651,24 @@ pub(super) fn render(stats: &StatsResponse, list: &PeerListResponse) -> String {
         relay.pulls_queued as f64,
     );
     out.single(
+        "grafts_total",
+        "counter",
+        "Links made eager: a pull brought changes over them.",
+        relay.grafts as f64,
+    );
+    out.single(
+        "prunes_total",
+        "counter",
+        "Links made lazy again: changes came over them that another path brought first.",
+        relay.prunes as f64,
+    );
+    out.single(
+        "eager_forwards_total",
+        "counter",
+        "Changes forwarded over eager links, per neighbour.",
+        relay.eager_forwards as f64,
+    );
+    out.single(
         "blob_requests_dropped_total",
         "counter",
         "Blob requests not answered: too many were being answered.",
diff --git a/src/swarm/relay.rs b/src/swarm/relay.rs
index fcca9c7..e11bd69 100644
--- a/src/swarm/relay.rs
+++ b/src/swarm/relay.rs
@@ -106,6 +106,7 @@ async fn forward_eagerly(state: &AppState, from: &str) {
             continue;
         }
         if peer_state.lock().await.eager_to {
+            state.stats.eager_forward();
             state.request_sync(&peer);
         }
     }
@@ -265,6 +266,7 @@ async fn graft(state: &AppState, peer: &str) {
     if !set_eager_from(state, peer, true).await {
         return;
     }
+    state.stats.link_grafted();
     debug!(peer = %peer, "Link eager: we want its changes as it applies them");
     if let Err(error) = announce_heads(state, peer).await {
         debug!(peer = %peer, error = %format!("{error:#}"), "Telling a neighbour the link is eager failed");
@@ -277,6 +279,7 @@ pub(crate) async fn prune(state: &AppState, peer: &str) {
     if !set_eager_from(state, peer, false).await {
         return;
     }
+    state.stats.link_pruned();
     debug!(peer = %peer, "Link lazy: its changes reach us first another way");
     if let Err(error) = announce_heads(state, peer).await {
         debug!(peer = %peer, error = %format!("{error:#}"), "Telling a neighbour the link is lazy failed");
diff --git a/src/swarm/stats.rs b/src/swarm/stats.rs
index 04f41b2..dd56bb0 100644
--- a/src/swarm/stats.rs
+++ b/src/swarm/stats.rs
@@ -102,6 +102,12 @@ pub(crate) struct Relay {
     pub(crate) pulls: u64,
     /// Announcements of heads we lacked that had to wait for the pull in progress.
     pub(crate) pulls_queued: u64,
+    /// Links made eager (a pull brought changes over them) and lazy again (changes came
+    /// over them that another path brought first).
+    pub(crate) grafts: u64,
+    pub(crate) prunes: u64,
+    /// Changes forwarded over eager links: a sync message asked for per neighbour.
+    pub(crate) eager_forwards: u64,
 }
 
 /// When the initial sync finished, and what it took.
@@ -184,6 +190,18 @@ impl NodeStats {
         self.lock().relay.pulls_queued += 1;
     }
 
+    pub(crate) fn link_grafted(&self) {
+        self.lock().relay.grafts += 1;
+    }
+
+    pub(crate) fn link_pruned(&self) {
+        self.lock().relay.prunes += 1;
+    }
+
+    pub(crate) fn eager_forward(&self) {
+        self.lock().relay.eager_forwards += 1;
+    }
+
     /// A sync message of `bytes` arrived.
     pub(crate) fn sync_received(&self, bytes: usize) {
         let mut inner = self.lock();