[api] return keyspace disk sizes in stats

src/api/stats.rs

···
 #[derive(Serialize)]
 pub struct StatsResponse {
     pub counts: BTreeMap<&'static str, u64>,
+    pub size: BTreeMap<&'static str, u64>,
 }
 
 pub async fn get_stats(State(state): State<Arc<AppState>>) -> Result<Json<StatsResponse>> {
-    let db = &state.db;
+    let db = state.db.clone();
 
     let mut counts: BTreeMap<&'static str, u64> = futures::future::join_all(
         [
···
             "error_generic",
         ]
         .into_iter()
-        .map(|name| async move { (name, db.get_count(name).await) }),
+        .map(|name| {
+            let db = db.clone();
+            async move { (name, db.get_count(name).await) }
+        }),
     )
     .await
     .into_iter()
     .collect();
     // this should be accurate since we dont remove events
+    // todo: ...unless in ephemeral mode
     counts.insert("events", db.events.approximate_len() as u64);
 
-    Ok(Json(StatsResponse { counts }))
+    let size = tokio::task::spawn_blocking(move || {
+        let mut size = BTreeMap::new();
+        size.insert("repos", db.repos.disk_space());
+        size.insert("records", db.records.disk_space());
+        size.insert("blocks", db.blocks.disk_space());
+        size.insert("cursors", db.cursors.disk_space());
+        size.insert("pending", db.pending.disk_space());
+        size.insert("resync", db.resync.disk_space());
+        size.insert("resync_buffer", db.resync_buffer.disk_space());
+        size.insert("events", db.events.disk_space());
+        size.insert("counts", db.counts.disk_space());
+        size.insert("filter", db.filter.disk_space());
+        size.insert("crawler", db.crawler.disk_space());
+        size
+    })
+    .await
+    .map_err(|_| axum::http::StatusCode::INTERNAL_SERVER_ERROR)?;
+
+    Ok(Json(StatsResponse { counts, size }))
 }

src/db/mod.rs

···
     KeyspaceCreateOptions::default()
 }
 
+#[derive(Clone)]
 pub struct Db {
     pub inner: Arc<Database>,
     pub repos: Keyspace,
···
                 .max_memtable_size(mb(16))
                 .data_block_size_policy(BlockSizePolicy::all(kb(1))),
         )?;
+
+        // when adding new keyspaces, make sure to add them to the /stats endpoint
+        // and also update any relevant /debug/* endpoints
 
         let mut last_id = 0;
         if let Some(guard) = events.iter().next_back() {

tests/debug_endpoints.nu

···
                  print "PASSED: /debug/iter on events returns JSON objects"
             }
 
+            # 4. Test size in /stats
+            print "testing size in /stats"
+            let stats = http get $"($url)/stats"
+            if ($stats.size | is-empty) {
+                print "FAILED: /stats returned empty size"
+                exit 1
+            }
+            if not ("repos" in ($stats.size | columns)) {
+                print "FAILED: /stats missing 'repos' in size"
+                exit 1
+            }
+            print "PASSED: /stats returns keyspace sizes"
+
         } else {
             print "backfill failed"
             exit 1