Add detailed index and database statistics reporting in FDB bridge

Author: Choochmeque

rust/crates/fdb-sys/cpp/fdb_bridge.cpp

@@ -20,6 +20,7 @@
 #include "metkit/mars/MarsRequest.h"
 
 #include <mutex>
+#include <sstream>
 #include <stdexcept>
 
 // Include the cxx-generated header for our bridge types
@@ -490,13 +491,25 @@ StatsElementData StatsIteratorHandle::next() {
 
     has_current_ = false;
 
+    // Mirror `fdb5::StatsElement { IndexStats; DbStats; }` directly.
+    // For `IndexStats` we can read every numeric accessor; for
+    // `DbStats` upstream only exposes `report(ostream&)`, so the
+    // captured text is the only thing we can surface.
     StatsElementData data;
-    // StatsElement is a DbStats - access via indexStatistics methods
-    data.location = rust::String("");
-    data.field_count = current_.indexStatistics.fieldsCount();
-    data.total_size = current_.indexStatistics.fieldsSize();
-    data.duplicate_count = current_.indexStatistics.duplicatesCount();
-    data.duplicate_size = current_.indexStatistics.duplicatesSize();
+    data.index_statistics.fields_count = current_.indexStatistics.fieldsCount();
+    data.index_statistics.fields_size = current_.indexStatistics.fieldsSize();
+    data.index_statistics.duplicates_count = current_.indexStatistics.duplicatesCount();
+    data.index_statistics.duplicates_size = current_.indexStatistics.duplicatesSize();
+    {
+        std::ostringstream os;
+        current_.indexStatistics.report(os);
+        data.index_statistics.report = os.str();
+    }
+    {
+        std::ostringstream os;
+        current_.dbStatistics.report(os);
+        data.db_statistics.report = os.str();
+    }
     return data;
 }
 

rust/crates/fdb-sys/cpp/fdb_bridge.h

@@ -84,6 +84,8 @@ struct DumpElementData;
 struct StatusElementData;
 struct WipeElementData;
 struct PurgeElementData;
+struct IndexStatsData;
+struct DbStatsData;
 struct StatsElementData;
 struct ControlElementData;
 struct MoveElementData;

rust/crates/fdb-sys/src/lib.rs

@@ -159,19 +159,34 @@ mod ffi {
         pub content: String,
     }
 
-    /// Result from stats iteration.
+    /// Index-level stats — mirrors `fdb5::IndexStats`. Bundles the four
+    /// numeric accessors (`fieldsCount` / `fieldsSize` /
+    /// `duplicatesCount` / `duplicatesSize`) plus the `report()` text.
+    #[derive(Debug, Clone, Default)]
+    pub struct IndexStatsData {
+        pub fields_count: u64,
+        pub fields_size: u64,
+        pub duplicates_count: u64,
+        pub duplicates_size: u64,
+        /// Captured `fdb5::IndexStats::report()` output.
+        pub report: String,
+    }
+
+    /// Database-level stats — mirrors `fdb5::DbStats`. Upstream exposes
+    /// `DbStats` as fully opaque content; the only public read accessor
+    /// is `report(std::ostream&)`, so the captured report text is the
+    /// only thing we can surface.
+    #[derive(Debug, Clone, Default)]
+    pub struct DbStatsData {
+        /// Captured `fdb5::DbStats::report()` output.
+        pub report: String,
+    }
+
+    /// Result from stats iteration — mirrors `fdb5::StatsElement`.
     #[derive(Debug, Clone, Default)]
     pub struct StatsElementData {
-        /// Location
-        pub location: String,
-        /// Number of fields
-        pub field_count: u64,
-        /// Total size in bytes
-        pub total_size: u64,
-        /// Duplicate count
-        pub duplicate_count: u64,
-        /// Duplicate size
-        pub duplicate_size: u64,
+        pub index_statistics: IndexStatsData,
+        pub db_statistics: DbStatsData,
     }
 
     /// Result from control iteration.

rust/crates/fdb/src/iterator.rs

@@ -429,11 +429,16 @@ impl Iterator for StatsIterator {
 
         match self.handle.pin_mut().next() {
             Ok(data) => Some(Ok(StatsElement {
-                location: data.location,
-                field_count: data.field_count,
-                total_size: data.total_size,
-                duplicate_count: data.duplicate_count,
-                duplicate_size: data.duplicate_size,
+                index_statistics: IndexStats {
+                    fields_count: data.index_statistics.fields_count,
+                    fields_size: data.index_statistics.fields_size,
+                    duplicates_count: data.index_statistics.duplicates_count,
+                    duplicates_size: data.index_statistics.duplicates_size,
+                    report: data.index_statistics.report,
+                },
+                db_statistics: DbStats {
+                    report: data.db_statistics.report,
+                },
             })),
             Err(e) => {
                 self.exhausted = true;
@@ -451,19 +456,46 @@ impl Iterator for StatsIterator {
 #[allow(clippy::non_send_fields_in_send_ty)]
 unsafe impl Send for StatsIterator {}
 
-/// A stats element containing database statistics.
+/// Index-level statistics — mirrors `fdb5::IndexStats`.
+///
+/// Bundles the four numeric accessors upstream exposes
+/// (`fieldsCount` / `fieldsSize` / `duplicatesCount` / `duplicatesSize`)
+/// plus the captured `report()` text.
+#[derive(Debug, Clone)]
+pub struct IndexStats {
+    /// Number of fields covered by this index.
+    pub fields_count: u64,
+    /// Total size in bytes of those fields.
+    pub fields_size: u64,
+    /// Number of duplicate (masked) entries.
+    pub duplicates_count: u64,
+    /// Total size in bytes of the duplicate entries.
+    pub duplicates_size: u64,
+    /// Captured `fdb5::IndexStats::report()` output — the same text
+    /// `fdb-stats --details` prints for the index portion.
+    pub report: String,
+}
+
+/// Database-level statistics — mirrors `fdb5::DbStats`.
+///
+/// Upstream's `DbStats` is fully content-opaque; the only public
+/// readable accessor is `report(std::ostream&)`. The captured report
+/// text is therefore the only thing this binding can surface — same
+/// rule the C++ tools play by.
+#[derive(Debug, Clone)]
+pub struct DbStats {
+    /// Captured `fdb5::DbStats::report()` output — the same text
+    /// `fdb-stats --details` prints for the database portion.
+    pub report: String,
+}
+
+/// A stats element — mirrors `fdb5::StatsElement`.
 #[derive(Debug, Clone)]
 pub struct StatsElement {
-    /// Location of the database.
-    pub location: String,
-    /// Number of fields.
-    pub field_count: u64,
-    /// Total size in bytes.
-    pub total_size: u64,
-    /// Number of duplicate entries.
-    pub duplicate_count: u64,
-    /// Size of duplicate data in bytes.
-    pub duplicate_size: u64,
+    /// Index-level statistics for this database.
+    pub index_statistics: IndexStats,
+    /// Database-level statistics for this database.
+    pub db_statistics: DbStats,
 }
 
 // =============================================================================

rust/crates/fdb/src/lib.rs

@@ -45,9 +45,9 @@ pub use datareader::DataReader;
 pub use error::{Error, Result};
 pub use handle::{ArchiveCallbackData, Fdb, FdbConfig, FdbStats};
 pub use iterator::{
-    ControlElement, ControlIterator, DumpElement, DumpIterator, ListElement, ListIterator,
-    MoveElement, MoveIterator, PurgeElement, PurgeIterator, StatsElement, StatsIterator,
-    StatusElement, StatusIterator, WipeElement, WipeIterator,
+    ControlElement, ControlIterator, DbStats, DumpElement, DumpIterator, IndexStats, ListElement,
+    ListIterator, MoveElement, MoveIterator, PurgeElement, PurgeIterator, StatsElement,
+    StatsIterator, StatusElement, StatusIterator, WipeElement, WipeIterator,
 };
 pub use key::Key;
 pub use options::{DumpOptions, ListOptions, PurgeOptions, WipeOptions};

rust/crates/fdb/tests/fdb_integration.rs

@@ -571,17 +571,52 @@ fn test_fdb_stats_iterator() {
     let stats_items: Vec<_> = fdb
         .stats_iter(&request)
         .expect("failed to get stats")
-        .collect();
+        .collect::<Result<Vec<_>, _>>()
+        .expect("stats iterator returned an error");
 
-    println!("Stats returned {} items", stats_items.len());
-    for item in &stats_items {
-        match item {
-            Ok(elem) => println!(
-                "  fields={}, size={}, duplicates={}",
-                elem.field_count, elem.total_size, elem.duplicate_count
-            ),
-            Err(e) => println!("  error: {e}"),
-        }
+    assert!(
+        !stats_items.is_empty(),
+        "expected at least one stats element after archiving one field"
+    );
+
+    // Sum the index-level numeric fields across all returned databases.
+    // We just archived one field, so the totals across the iterator must
+    // include it. (Some FDB layouts may report it as multiple index
+    // entries; what matters is that the totals are non-zero and
+    // consistent with what we wrote.)
+    let total_fields: u64 = stats_items
+        .iter()
+        .map(|s| s.index_statistics.fields_count)
+        .sum();
+    let total_bytes: u64 = stats_items
+        .iter()
+        .map(|s| s.index_statistics.fields_size)
+        .sum();
+
+    assert!(
+        total_fields >= 1,
+        "expected total fields_count >= 1, got {total_fields}"
+    );
+    assert!(
+        total_bytes >= grib_data.len() as u64,
+        "expected total fields_size >= {} bytes (the GRIB we archived), got {total_bytes}",
+        grib_data.len()
+    );
+
+    // The report text fields are captured straight from
+    // `IndexStats::report()` / `DbStats::report()` on the C++ side.
+    // They should be non-empty for a populated database — that proves
+    // the captured-report path is actually wired up, not just an empty
+    // sentinel like the bogus `location` field used to be.
+    for stats in &stats_items {
+        assert!(
+            !stats.index_statistics.report.is_empty(),
+            "index_statistics.report should not be empty after archiving data"
+        );
+        assert!(
+            !stats.db_statistics.report.is_empty(),
+            "db_statistics.report should not be empty after archiving data"
+        );
     }
 }