lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

commit babe4622ec60f85167845bba8d58d3da58b03227
parent 189c49b74b4bafc142b00b76b296477931139e72
Author: triesap <tyson@radroots.org>
Date:   Fri,  9 Oct 2026 19:14:49 +0000

test: measure sqlite event query work (C187)

- Add private test-only observations of SQL fetches and event decoding.
- Measure bounded raw pages and full visibility scans with real SQLite fixtures.
- Cover pending pool cancellation and per-instance observer isolation.
- Preserve production behavior and the existing security audit coverage.

Diffstat:
Mcrates/storage_sqlite/src/event/mod.rs | 72+++++++++++++++++++++++++++++++++++++++++++++++++++---------------------
Acrates/storage_sqlite/src/event/work.rs | 86+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/storage_sqlite/src/event/work_tests.rs | 180+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 317 insertions(+), 21 deletions(-)

diff --git a/crates/storage_sqlite/src/event/mod.rs b/crates/storage_sqlite/src/event/mod.rs @@ -31,6 +31,8 @@ pub struct SqliteStorage { pub(crate) backup_root: Option<Arc<PathBuf>>, pub(crate) paths: Option<Arc<crate::Paths>>, pub(crate) reliability: Arc<Mutex<crate::backup::ReliabilityState>>, + #[cfg(test)] + work: Arc<work::Observer>, } struct StoredEventRow { @@ -56,6 +58,8 @@ impl SqliteStorage { backup_root: None, paths: None, reliability: Arc::new(Mutex::new(crate::backup::ReliabilityState::default())), + #[cfg(test)] + work: Arc::default(), } } @@ -75,6 +79,8 @@ impl SqliteStorage { backup_root: None, paths: None, reliability: Arc::new(Mutex::new(crate::backup::ReliabilityState::default())), + #[cfg(test)] + work: Arc::default(), } } @@ -105,6 +111,8 @@ impl SqliteStorage { .map(|path| Arc::new(path.to_path_buf())), paths: Some(Arc::new(options.paths().clone())), reliability: Arc::new(Mutex::new(crate::backup::ReliabilityState::default())), + #[cfg(test)] + work: Arc::default(), } } @@ -155,11 +163,16 @@ impl SqliteStorage { builder.push(" ORDER BY source_sequence LIMIT "); builder.push_bind(i64_from_u64(fetch_limit)?); + #[cfg(test)] + self.work + .request(work::Read::Bounded, builder.sql().as_str()); let rows = builder .build() .fetch_all(&self.pool) .await .map_err(map_backend)?; + #[cfg(test)] + self.work.returned(&rows); let mut decoded = rows .iter() .map(|row| self.decode_event_row(row)) @@ -174,21 +187,26 @@ impl SqliteStorage { } async fn current_event_rows(&self) -> Result<Vec<StoredEventRow>, Error> { - let rows = sqlx::query( - "SELECT source_generation, source_sequence, signed_event, admission_stage, + let sql = "SELECT source_generation, source_sequence, signed_event, admission_stage, admitted_contract_id, admitted_registry_version FROM radroots_runtime_events WHERE source_generation = ? - ORDER BY source_sequence", - ) - .bind(self.generation.as_bytes().as_slice()) - .fetch_all(&self.pool) - .await - .map_err(map_backend)?; + ORDER BY source_sequence"; + #[cfg(test)] + self.work.request(work::Read::Materialize, sql); + let rows = sqlx::query(sql) + .bind(self.generation.as_bytes().as_slice()) + .fetch_all(&self.pool) + .await + .map_err(map_backend)?; + #[cfg(test)] + self.work.returned(&rows); rows.iter().map(|row| self.decode_event_row(row)).collect() } fn visibility_for_rows(&self, rows: &[StoredEventRow]) -> Result<VisibilityEvaluation, Error> { + #[cfg(test)] + self.work.visibility(rows.len()); evaluate_visibility( self.generation, rows.iter() @@ -215,8 +233,12 @@ impl SqliteStorage { let sequence = event_sequence(row.try_get("source_sequence").map_err(map_corrupt)?)?; let raw_json = String::from_utf8(row.try_get("signed_event").map_err(map_corrupt)?) .map_err(|_| Error::CorruptStoredEvent)?; + #[cfg(test)] + self.work.decode(raw_json.len()); let event = Codec::decode_signed_event(raw_json.as_str()).map_err(|_| Error::CorruptStoredEvent)?; + #[cfg(test)] + self.work.decoded(); let stage = admission_stage(row.try_get("admission_stage").map_err(map_corrupt)?)?; let contract_id = row .try_get::<Option<String>, _>("admitted_contract_id") @@ -377,17 +399,20 @@ fn admission_contract_metadata(admission: &EventAdmission) -> Option<(&'static s impl EventStore for SqliteStorage { fn status(&self) -> BoxFuture<'_, Result<EventStoreStatus, Error>> { Box::pin(async move { - let row = sqlx::query( - "SELECT + let sql = "SELECT COUNT(*) AS raw_events, COALESCE(SUM(CASE WHEN admission_stage IN ('verified', 'visible') THEN 1 ELSE 0 END), 0) AS verified_events - FROM radroots_runtime_events WHERE source_generation = ?", - ) - .bind(self.generation.as_bytes().as_slice()) - .fetch_one(&self.pool) - .await - .map_err(map_backend)?; + FROM radroots_runtime_events WHERE source_generation = ?"; + #[cfg(test)] + self.work.request(work::Read::Aggregate, sql); + let row = sqlx::query(sql) + .bind(self.generation.as_bytes().as_slice()) + .fetch_one(&self.pool) + .await + .map_err(map_backend)?; + #[cfg(test)] + self.work.aggregate_returned(); let visibility_rows = self.current_event_rows().await?; let visible_events = u64::try_from( self.visibility_for_rows(&visibility_rows)? @@ -603,6 +628,11 @@ fn map_corrupt(_: sqlx::Error) -> Error { } #[cfg(test)] +mod work; +#[cfg(test)] +mod work_tests; + +#[cfg(test)] #[cfg_attr(coverage_nightly, coverage(off))] mod tests { use super::*; @@ -660,7 +690,7 @@ mod tests { } } - async fn store(generation: SourceGeneration) -> SqliteStorage { + pub(super) async fn store(generation: SourceGeneration) -> SqliteStorage { let pool = SqlitePoolOptions::new() .max_connections(1) .connect("sqlite::memory:") @@ -692,7 +722,7 @@ mod tests { signed_event_with(content, pretty, 1_800_000_100, 0, vec![]) } - fn signed_event_with( + pub(super) fn signed_event_with( content: &str, pretty: bool, created_at: u64, @@ -730,7 +760,7 @@ mod tests { SignedEvent::from_wire_verified_id(wire, raw_json).expect("signed event") } - fn observed(event: SignedEvent, at: u64, cursor: Option<&str>) -> ObservedEvent { + pub(super) fn observed(event: SignedEvent, at: u64, cursor: Option<&str>) -> ObservedEvent { let target = Target::new(TransportId::NOSTR, "wss://relay.example").expect("target"); let mut provenance = EventProvenance::new(TransportId::NOSTR, target.fingerprint().clone(), at) @@ -741,7 +771,7 @@ mod tests { ObservedEvent::new(event, provenance) } - fn verified(event: &SignedEvent) -> radroots_event::VerifiedEvent { + pub(super) fn verified(event: &SignedEvent) -> radroots_event::VerifiedEvent { RawEvent::new(event.envelope().clone()) .verify_id() .expect("event id") @@ -749,7 +779,7 @@ mod tests { .expect("signature") } - fn visible(event: &SignedEvent) -> VisibleEvent { + pub(super) fn visible(event: &SignedEvent) -> VisibleEvent { let verified = verified(event); let validated = if event.envelope().kind_u32() == 5 { verified diff --git a/crates/storage_sqlite/src/event/work.rs b/crates/storage_sqlite/src/event/work.rs @@ -0,0 +1,86 @@ +//! Private test observations of actual provider work; no production metric API. +use sqlx::{Row, sqlite::SqliteRow}; +use std::sync::Mutex; + +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, serde::Serialize)] +pub(super) struct Counts { + pub bounded_requests: u64, + pub materialization_requests: u64, + pub aggregate_requests: u64, + pub successful_fetches: u64, + pub event_rows_returned: u64, + pub event_bytes_returned: u64, + pub aggregate_rows_returned: u64, + pub codec_inputs: u64, + pub codec_input_bytes: u64, + pub codec_successes: u64, + pub visibility_inputs: u64, +} + +#[derive(Clone, Copy)] +pub(super) enum Read { + Bounded, + Materialize, + Aggregate, +} + +#[derive(Default)] +pub(super) struct Observer { + counts: Mutex<Counts>, + // Three placeholder-only shapes; bind values and payloads are never retained. + templates: Mutex<[Option<String>; 3]>, +} + +impl Observer { + pub(super) fn request(&self, kind: Read, sql: &str) { + let mut counts = self.counts.lock().expect("test observer"); + match kind { + Read::Bounded => counts.bounded_requests += 1, + Read::Materialize => counts.materialization_requests += 1, + Read::Aggregate => counts.aggregate_requests += 1, + } + self.templates.lock().expect("test query templates")[kind as usize] = Some(sql.to_owned()); + } + + pub(super) fn returned(&self, rows: &[SqliteRow]) { + let bytes = rows + .iter() + .filter_map(|row| row.try_get::<&[u8], _>("signed_event").ok()) + .map(|value| value.len() as u64) + .sum::<u64>(); + let mut counts = self.counts.lock().expect("test observer"); + counts.successful_fetches += 1; + counts.event_rows_returned += rows.len() as u64; + counts.event_bytes_returned += bytes; + } + + pub(super) fn aggregate_returned(&self) { + let mut counts = self.counts.lock().expect("test observer"); + counts.successful_fetches += 1; + counts.aggregate_rows_returned += 1; + } + + pub(super) fn decode(&self, bytes: usize) { + let mut counts = self.counts.lock().expect("test observer"); + counts.codec_inputs += 1; + counts.codec_input_bytes += bytes as u64; + } + + pub(super) fn decoded(&self) { + self.counts.lock().expect("test observer").codec_successes += 1; + } + + pub(super) fn visibility(&self, rows: usize) { + self.counts.lock().expect("test observer").visibility_inputs += rows as u64; + } + + pub(super) fn take(&self) -> Counts { + std::mem::take(&mut *self.counts.lock().expect("test observer")) + } + + pub(super) fn template(&self, kind: Read) -> String { + self.templates.lock().expect("test query templates")[kind as usize] + .clone() + .expect("observed request") + } +} diff --git a/crates/storage_sqlite/src/event/work_tests.rs b/crates/storage_sqlite/src/event/work_tests.rs @@ -0,0 +1,180 @@ +use super::tests::{observed, signed_event_with, store, verified, visible}; +use super::work::{Counts, Read}; +use super::*; +use std::task::{Context, Poll, Waker}; + +async fn retained_source(size: u64) -> (SqliteStorage, u64) { + let generation = SourceGeneration::new([71; 32]).unwrap(); + let storage = store(generation).await; + let mut bytes = 0; + for index in 0..size { + let content = if index % 4 == 0 { + format!(r#"{{"display_name":"Farm {index}","bot":false}}"#) + } else { + format!("retained note {index}") + }; + let event = signed_event_with( + &content, + false, + 1_800_000_100 + index, + if index % 4 == 0 { 0 } else { 1 }, + vec![], + ); + bytes += event.raw_json().len() as u64; + let provenance = observed(event.clone(), 10 + index, None); + let admission = match index % 4 { + 2 => EventAdmission::raw(provenance), + 3 => EventAdmission::verified(provenance, verified(&event)).unwrap(), + _ => EventAdmission::visible(provenance, visible(&event)).unwrap(), + }; + storage.admit(admission).await.unwrap(); + } + storage.work.take(); + (storage, bytes) +} + +fn first() -> EventQuery { + EventQuery::all(EventQueryBounds::first(5).unwrap()) +} + +fn assert_materialized(counts: Counts, rows: u64, bytes: u64) { + assert_eq!(counts.materialization_requests, 1); + assert_eq!(counts.event_rows_returned, rows); + assert_eq!(counts.event_bytes_returned, bytes); + assert_eq!(counts.codec_inputs, rows); + assert_eq!(counts.codec_input_bytes, bytes); + assert_eq!(counts.codec_successes, rows); + assert_eq!(counts.visibility_inputs, rows); +} + +async fn plan(storage: &SqliteStorage, kind: Read) -> Vec<String> { + let template = storage.work.template(kind); + let mut builder = QueryBuilder::<Sqlite>::new("EXPLAIN QUERY PLAN "); + builder.push(template); + let mut query = builder + .build() + .bind(storage.generation.as_bytes().as_slice()); + if matches!(kind, Read::Bounded) { + query = query.bind(0_i64).bind(6_i64); + } + query + .fetch_all(&storage.pool) + .await + .unwrap() + .into_iter() + .map(|row| row.get::<String, _>("detail")) + .collect() +} + +#[cfg(test)] +#[tokio::test] +async fn actual_returned_and_decoded_work_distinguishes_bounded_and_full_reads() { + for retained in [32, 96] { + let (storage, bytes) = retained_source(retained).await; + let raw = storage.query_raw(first()).await.unwrap(); + assert_eq!(raw.items().len(), 5); + let bounded = storage.work.take(); + assert_eq!(bounded.bounded_requests, 1); + assert_eq!(bounded.successful_fetches, 1); + assert_eq!(bounded.event_rows_returned, 6); + assert_eq!(bounded.codec_inputs, 6); + assert_eq!(bounded.codec_successes, 6); + assert_eq!(bounded.event_bytes_returned, bounded.codec_input_bytes); + assert!(bounded.event_bytes_returned > 0 && bounded.event_bytes_returned < bytes); + assert_eq!(bounded.visibility_inputs, 0); + let bounded_plan = plan(&storage, Read::Bounded).await; + let page = storage.query_visible(first()).await.unwrap(); + assert_eq!(page.items().len(), 5); + let full = storage.work.take(); + assert_materialized(full, retained, bytes); + assert_eq!(full.successful_fetches, 1); + let full_plan = plan(&storage, Read::Materialize).await; + assert!(!bounded_plan.is_empty() && !full_plan.is_empty()); + println!( + "{}", + serde_json::json!({"scenario":"bounded_vs_materialized", "retained_events":retained, + "returned_page_items":5, "bounded":bounded, "full_visibility":full, + "bounded_query_plan":bounded_plan, "full_query_plan":full_plan, + "sqlite_vm_row_visits_measured":false, "wall_time_qualification":false}) + ); + storage.close().await.unwrap(); + } +} + +#[cfg(test)] +#[tokio::test] +async fn status_and_rebuild_measure_actual_full_source_materialization() { + let (storage, bytes) = retained_source(32).await; + let status = storage.status().await.unwrap(); + assert_eq!(status.raw_events(), 32); + assert_eq!(status.verified_events(), 24); + let counts = storage.work.take(); + assert_materialized(counts, 32, bytes); + assert_eq!(counts.aggregate_requests, 1); + assert_eq!(counts.aggregate_rows_returned, 1); + assert_eq!(counts.successful_fetches, 2); + let aggregate_plan = plan(&storage, Read::Aggregate).await; + let visibility = storage.rebuild_visibility().await.unwrap(); + let rebuilt = storage.work.take(); + assert_materialized(rebuilt, 32, bytes); + assert_eq!(rebuilt.aggregate_requests, 0); + assert_eq!(rebuilt.successful_fetches, 1); + assert_eq!( + status.visible_events(), + visibility.visible_event_ids().len() as u64 + ); + println!( + "{}", + serde_json::json!({"scenario":"status_and_rebuild", "status":counts, + "rebuild":rebuilt, "aggregate_query_plan":aggregate_plan, "sqlite_vm_row_visits_measured":false}) + ); + storage.close().await.unwrap(); +} + +#[cfg(test)] +#[tokio::test] +async fn cancelled_pool_wait_materializes_nothing_and_retry_executes_real_read() { + let (storage, _) = retained_source(32).await; + let held = storage.pool.acquire().await.unwrap(); + let mut future = storage.query_raw(first()); + assert!(matches!( + future + .as_mut() + .poll(&mut Context::from_waker(Waker::noop())), + Poll::Pending + )); + drop(future); + let cancelled = storage.work.take(); + assert_eq!(cancelled.bounded_requests, 1); + assert_eq!(cancelled.successful_fetches, 0); + assert_eq!(cancelled.event_rows_returned, 0); + assert_eq!(cancelled.codec_inputs, 0); + assert_eq!(cancelled.codec_input_bytes, 0); + drop(held); + assert_eq!(storage.query_raw(first()).await.unwrap().items().len(), 5); + let retry = storage.work.take(); + assert_eq!(retry.bounded_requests, 1); + assert_eq!(retry.successful_fetches, 1); + assert_eq!(retry.event_rows_returned, 6); + assert_eq!(retry.codec_successes, 6); + println!( + "{}", + serde_json::json!({"scenario":"cancelled_pool_wait", "cancelled":cancelled, "retry":retry, + "cancellation_boundary":"pending pool acquisition", "running_sqlite_worker_cancellation_qualified":false}) + ); + storage.close().await.unwrap(); +} + +#[cfg(test)] +#[tokio::test] +async fn observations_are_instance_scoped_and_shared_only_by_clones() { + let (storage, _) = retained_source(32).await; + let (other, _) = retained_source(32).await; + let cloned = storage.clone(); + cloned.query_raw(first()).await.unwrap(); + assert_eq!(storage.work.take().event_rows_returned, 6); + assert_eq!(cloned.work.take(), Counts::default()); + assert_eq!(other.work.take(), Counts::default()); + storage.close().await.unwrap(); + other.close().await.unwrap(); +}