chore: introduce tuple type for pruned info

crates/prune/prune/src/event.rs

@@ -1,5 +1,5 @@
 use alloy_primitives::BlockNumber;
-use reth_prune_types::{PruneProgress, PruneSegment};
+use reth_prune_types::PrunedSegmentInfo;
 use std::time::Duration;
 
 /// An event emitted by a [Pruner][crate::Pruner].
@@ -8,9 +8,5 @@ pub enum PrunerEvent {
     /// Emitted when pruner started running.
     Started { tip_block_number: BlockNumber },
     /// Emitted when pruner finished running.
-    Finished {
-        tip_block_number: BlockNumber,
-        elapsed: Duration,
-        stats: Vec<(PruneSegment, usize, PruneProgress)>,
-    },
+    Finished { tip_block_number: BlockNumber, elapsed: Duration, stats: Vec<PrunedSegmentInfo> },
 }

crates/prune/prune/src/pruner.rs

@@ -9,7 +9,7 @@ use reth_exex_types::FinishedExExHeight;
 use reth_provider::{
     DBProvider, DatabaseProviderFactory, PruneCheckpointReader, PruneCheckpointWriter,
 };
-use reth_prune_types::{PruneLimiter, PruneProgress, PruneSegment, PrunerOutput};
+use reth_prune_types::{PruneLimiter, PruneProgress, PrunedSegmentInfo, PrunerOutput};
 use reth_tokio_util::{EventSender, EventStream};
 use std::time::{Duration, Instant};
 use tokio::sync::watch;
@@ -21,8 +21,6 @@ pub type PrunerResult = Result<PrunerOutput, PrunerError>;
 /// The pruner type itself with the result of [`Pruner::run`]
 pub type PrunerWithResult<S, DB> = (Pruner<S, DB>, PrunerResult);
 
-type PrunerStats = Vec<(PruneSegment, usize, PruneProgress)>;
-
 /// Pruner with preset provider factory.
 pub type PrunerWithFactory<PF> = Pruner<<PF as DatabaseProviderFactory>::ProviderRW, PF>;
 
@@ -174,14 +172,15 @@ where
     /// be pruned according to the highest `static_files`. Segments are parts of the database that
     /// represent one or more tables.
     ///
-    /// Returns [`PrunerStats`], total number of entries pruned, and [`PruneProgress`].
+    /// Returns a list of stats per pruned segment, total number of entries pruned, and
+    /// [`PruneProgress`].
     fn prune_segments(
         &mut self,
         provider: &Provider,
         tip_block_number: BlockNumber,
         limiter: &mut PruneLimiter,
-    ) -> Result<(PrunerStats, usize, PrunerOutput), PrunerError> {
-        let mut stats = PrunerStats::new();
+    ) -> Result<(Vec<PrunedSegmentInfo>, usize, PrunerOutput), PrunerError> {
+        let mut stats = Vec::with_capacity(self.segments.len());
         let mut pruned = 0;
         let mut output = PrunerOutput {
             progress: PruneProgress::Finished,
@@ -249,7 +248,12 @@ where
                 if segment_output.pruned > 0 {
                     limiter.increment_deleted_entries_count_by(segment_output.pruned);
                     pruned += segment_output.pruned;
-                    stats.push((segment.segment(), segment_output.pruned, segment_output.progress));
+                    let info = PrunedSegmentInfo {
+                        segment: segment.segment(),
+                        pruned: segment_output.pruned,
+                        progress: segment_output.progress,
+                    };
+                    stats.push(info);
                 }
             } else {
                 debug!(target: "pruner", segment = ?segment.segment(), purpose = ?segment.purpose(), "Nothing to prune for the segment");

crates/prune/types/src/lib.rs

@@ -19,7 +19,8 @@ pub use checkpoint::PruneCheckpoint;
 pub use limiter::PruneLimiter;
 pub use mode::PruneMode;
 pub use pruner::{
-    PruneInterruptReason, PruneProgress, PrunerOutput, SegmentOutput, SegmentOutputCheckpoint,
+    PruneInterruptReason, PruneProgress, PrunedSegmentInfo, PrunerOutput, SegmentOutput,
+    SegmentOutputCheckpoint,
 };
 pub use segment::{PrunePurpose, PruneSegment, PruneSegmentError};
 use serde::{Deserialize, Serialize};

crates/prune/types/src/pruner.rs

@@ -1,6 +1,5 @@
-use alloy_primitives::{BlockNumber, TxNumber};
-
 use crate::{PruneCheckpoint, PruneLimiter, PruneMode, PruneSegment};
+use alloy_primitives::{BlockNumber, TxNumber};
 
 /// Pruner run output.
 #[derive(Debug)]
@@ -17,6 +16,17 @@ impl From<PruneProgress> for PrunerOutput {
     }
 }
 
+/// Represents information of a pruner run for a segment.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PrunedSegmentInfo {
+    /// The pruned segment
+    pub segment: PruneSegment,
+    /// Number of pruned entries
+    pub pruned: usize,
+    /// Prune progress
+    pub progress: PruneProgress,
+}
+
 /// Segment pruning output.
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct SegmentOutput {