feat: ids_data_usage

Author: dpc

crates/rostra-client-db/src/lib.rs

@@ -500,6 +500,7 @@ impl Database {
         let mut content_rc_table = tx.open_table(&content_rc::TABLE)?;
         let mut events_content_missing_table =
             tx.open_table(&tables::events_content_missing::TABLE)?;
+        let mut ids_data_usage_table = tx.open_table(&ids_data_usage::TABLE)?;
 
         debug_assert!(Database::has_event_tx(
             event_content.event.event_id,
@@ -563,6 +564,13 @@ impl Database {
                 // Increment RC for this event claiming the content
                 Database::increment_content_rc_tx(content_hash, &mut content_rc_table)?;
 
+                // Track content size for the author
+                Database::increment_content_size_tx(
+                    event_content.author(),
+                    event_content.content_len(),
+                    &mut ids_data_usage_table,
+                )?;
+
                 // Mark per-event state as available (this event now holds an RC)
                 events_content_state_table.insert(
                     &event_content.event_id().to_short(),

crates/rostra-client-db/src/migration_ops.rs

@@ -7,13 +7,13 @@ use tracing::{debug, info};
 use crate::ids::IdsFolloweesRecordV0;
 use crate::{
     ContentStoreRecordOwned, Database, DbResult, DbVersionTooHighSnafu, EventContentStateNew,
-    IdSocialProfileRecord, IdsFolloweesRecord, LOG_TARGET, Latest, SocialPostRecord,
-    WriteTransactionCtx, content_rc, content_store, db_version, events, events_by_time,
-    events_content, events_content_missing, events_content_state, events_heads, events_missing,
-    events_self, events_singletons, events_singletons_new, ids_followees, ids_followees_v0,
-    ids_followers, ids_full, ids_personas, ids_self, ids_unfollowed, social_posts,
-    social_posts_by_time, social_posts_reactions, social_posts_replies, social_posts_v0,
-    social_profiles, social_profiles_v0,
+    IdSocialProfileRecord, IdsDataUsageRecord, IdsFolloweesRecord, LOG_TARGET, Latest,
+    SocialPostRecord, WriteTransactionCtx, content_rc, content_store, db_version, events,
+    events_by_time, events_content, events_content_missing, events_content_state, events_heads,
+    events_missing, events_self, events_singletons, events_singletons_new, ids_data_usage,
+    ids_followees, ids_followees_v0, ids_followers, ids_full, ids_personas, ids_self,
+    ids_unfollowed, social_posts, social_posts_by_time, social_posts_reactions,
+    social_posts_replies, social_posts_v0, social_profiles, social_profiles_v0,
 };
 
 impl Database {
@@ -26,6 +26,7 @@ impl Database {
         tx.open_table(&ids_followees::TABLE)?;
         tx.open_table(&ids_unfollowed::TABLE)?;
         tx.open_table(&ids_personas::TABLE)?;
+        tx.open_table(&ids_data_usage::TABLE)?;
 
         tx.open_table(&events::TABLE)?;
         tx.open_table(&events_singletons::TABLE)?;
@@ -50,7 +51,7 @@ impl Database {
     }
 
     pub(crate) fn handle_db_ver_migrations(dbtx: &WriteTransactionCtx) -> DbResult<()> {
-        const DB_VER: u64 = 4;
+        const DB_VER: u64 = 5;
 
         let mut table_db_ver = dbtx.open_table(&db_version::TABLE)?;
 
@@ -76,6 +77,7 @@ impl Database {
                 1 => Self::migrate_v1(dbtx)?,
                 2 => Self::migrate_v2(dbtx)?,
                 3 => Self::migrate_v3(dbtx)?,
+                4 => Self::migrate_v4(dbtx)?,
                 DB_VER => { /* ensures we didn't forget to increment DB_VER */ }
                 x => panic!("Unexpected db ver: {x}"),
             }
@@ -316,4 +318,60 @@ impl Database {
 
         Ok(())
     }
+
+    /// Migration v4: Calculate initial data usage per identity.
+    ///
+    /// Iterates all events to calculate:
+    /// 1. metadata_size: count of events × EVENT_METADATA_SIZE (192 bytes)
+    /// 2. content_size: sum of content_len for events in Available state
+    pub(crate) fn migrate_v4(dbtx: &WriteTransactionCtx) -> DbResult<()> {
+        use std::collections::HashMap;
+
+        use rostra_core::event::EventExt as _;
+
+        /// Size of event metadata in bytes (Event struct + signature).
+        /// See rostra_core::event::Event documentation.
+        const EVENT_METADATA_SIZE: u64 = 192;
+
+        let events_table = dbtx.open_table(&events::TABLE)?;
+        let state_table = dbtx.open_table(&events_content_state::TABLE)?;
+        let mut usage_table = dbtx.open_table(&ids_data_usage::TABLE)?;
+
+        // Collect usage per author
+        let mut usage_map: HashMap<rostra_core::id::RostraId, IdsDataUsageRecord> = HashMap::new();
+
+        for entry in events_table.range(..)? {
+            let (event_id, record) = entry?;
+            let event_id = event_id.value();
+            let record = record.value();
+            let author = record.author();
+
+            let usage = usage_map.entry(author).or_default();
+
+            // Every event contributes to metadata size
+            usage.metadata_size += EVENT_METADATA_SIZE;
+
+            // Content only counts if state is Available
+            if let Some(state) = state_table.get(&event_id)?.map(|g| g.value()) {
+                if matches!(state, EventContentStateNew::Available) {
+                    usage.content_size += u64::from(record.content_len());
+                }
+            }
+        }
+
+        // Write aggregated usage to table
+        let mut count = 0u64;
+        for (author, usage) in usage_map {
+            usage_table.insert(&author, &usage)?;
+            count += 1;
+        }
+
+        info!(
+            target: LOG_TARGET,
+            "Calculated data usage for {} identities",
+            count
+        );
+
+        Ok(())
+    }
 }

crates/rostra-client-db/src/process_event_ops.rs

@@ -8,7 +8,7 @@ use crate::process_event_content_ops::ProcessEventError;
 use crate::{
     Database, DbResult, InsertEventOutcome, LOG_TARGET, ProcessEventState, WriteTransactionCtx,
     content_rc, content_store, events, events_by_time, events_content_missing,
-    events_content_state, events_heads, events_missing, ids_full,
+    events_content_state, events_heads, events_missing, ids_data_usage, ids_full,
 };
 
 impl Database {
@@ -26,6 +26,7 @@ impl Database {
         let mut events_heads_tbl = tx.open_table(&events_heads::TABLE)?;
         let mut events_by_time_tbl = tx.open_table(&events_by_time::TABLE)?;
         let mut ids_full_tbl = tx.open_table(&ids_full::TABLE)?;
+        let mut ids_data_usage_tbl = tx.open_table(&ids_data_usage::TABLE)?;
 
         let insert_event_outcome = Database::insert_event_tx(
             *event,
@@ -38,6 +39,7 @@ impl Database {
             &content_store_tbl,
             &mut content_rc_tbl,
             &mut events_content_missing_tbl,
+            Some(&mut ids_data_usage_tbl),
         )?;
 
         if let InsertEventOutcome::Inserted {
@@ -124,6 +126,7 @@ impl Database {
                 &mut events_content_state_tbl,
                 &mut content_rc_tbl,
                 &mut events_content_missing_tbl,
+                Some((event.author(), event.content_len(), &mut ids_data_usage_tbl)),
             )? {
                 ProcessEventState::Pruned
             } else {

crates/rostra-client-db/src/tables.rs

@@ -148,6 +148,33 @@ def_table! {
     ids_personas: (RostraId, PersonaId) => IdsPersonaRecord
 }
 
+def_table! {
+    /// Aggregate data usage per identity.
+    ///
+    /// Tracks the total storage used by each identity's events and content.
+    /// Updated incrementally as events are added and content state changes.
+    ids_data_usage: RostraId => IdsDataUsageRecord
+}
+
+/// Aggregate data usage record for an identity.
+///
+/// Tracks both event metadata size (fixed per event) and content size
+/// (variable, based on actual content stored).
+#[derive(Debug, Encode, Decode, Clone, Copy, Default, Serialize)]
+pub struct IdsDataUsageRecord {
+    /// Total size of event metadata (envelopes) in bytes.
+    ///
+    /// Each event contributes a fixed size (Event struct + signature = 192
+    /// bytes).
+    pub metadata_size: u64,
+
+    /// Total size of content (payloads) in bytes.
+    ///
+    /// Only content in the `Available` state is counted. Pruned/Deleted content
+    /// is not included (as it doesn't consume storage).
+    pub content_size: u64,
+}
+
 // ============================================================================
 // EVENT TABLES
 // ============================================================================