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:
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();
+}