lib

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

work.rs (3178B)


      1 //! Private test observations of actual provider work; no production metric API.
      2 use sqlx::{Row, sqlite::SqliteRow};
      3 use std::sync::Mutex;
      4 
      5 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq, serde::Serialize)]
      6 pub(super) struct Counts {
      7     pub bounded_requests: u64,
      8     pub key_requests: u64,
      9     pub key_rows_returned: u64,
     10     pub materialization_requests: u64,
     11     pub aggregate_requests: u64,
     12     pub successful_fetches: u64,
     13     pub event_rows_returned: u64,
     14     pub event_bytes_returned: u64,
     15     pub aggregate_rows_returned: u64,
     16     pub codec_inputs: u64,
     17     pub codec_input_bytes: u64,
     18     pub codec_successes: u64,
     19     pub visibility_inputs: u64,
     20 }
     21 
     22 #[derive(Clone, Copy)]
     23 pub(super) enum Read {
     24     Bounded,
     25     Materialize,
     26     Aggregate,
     27     Keys,
     28 }
     29 
     30 #[derive(Default)]
     31 pub(super) struct Observer {
     32     counts: Mutex<Counts>,
     33     // Placeholder-only shapes; bind values and payloads are never retained.
     34     templates: Mutex<[Option<String>; 4]>,
     35 }
     36 
     37 impl Observer {
     38     pub(super) fn request(&self, kind: Read, sql: &str) {
     39         let mut counts = self.counts.lock().expect("test observer");
     40         match kind {
     41             Read::Bounded => counts.bounded_requests += 1,
     42             Read::Materialize => counts.materialization_requests += 1,
     43             Read::Aggregate => counts.aggregate_requests += 1,
     44             Read::Keys => counts.key_requests += 1,
     45         }
     46         self.templates.lock().expect("test query templates")[kind as usize] = Some(sql.to_owned());
     47     }
     48 
     49     pub(super) fn keys_returned(&self, rows: usize) {
     50         let mut counts = self.counts.lock().expect("test observer");
     51         counts.successful_fetches += 1;
     52         counts.key_rows_returned += rows as u64;
     53     }
     54 
     55     pub(super) fn returned(&self, rows: &[SqliteRow]) {
     56         let bytes = rows
     57             .iter()
     58             .filter_map(|row| row.try_get::<&[u8], _>("signed_event").ok())
     59             .map(|value| value.len() as u64)
     60             .sum::<u64>();
     61         let mut counts = self.counts.lock().expect("test observer");
     62         counts.successful_fetches += 1;
     63         counts.event_rows_returned += rows.len() as u64;
     64         counts.event_bytes_returned += bytes;
     65     }
     66 
     67     pub(super) fn aggregate_returned(&self) {
     68         let mut counts = self.counts.lock().expect("test observer");
     69         counts.successful_fetches += 1;
     70         counts.aggregate_rows_returned += 1;
     71     }
     72 
     73     pub(super) fn decode(&self, bytes: usize) {
     74         let mut counts = self.counts.lock().expect("test observer");
     75         counts.codec_inputs += 1;
     76         counts.codec_input_bytes += bytes as u64;
     77     }
     78 
     79     pub(super) fn decoded(&self) {
     80         self.counts.lock().expect("test observer").codec_successes += 1;
     81     }
     82 
     83     pub(super) fn visibility(&self, rows: usize) {
     84         self.counts.lock().expect("test observer").visibility_inputs += rows as u64;
     85     }
     86 
     87     pub(super) fn take(&self) -> Counts {
     88         std::mem::take(&mut *self.counts.lock().expect("test observer"))
     89     }
     90 
     91     pub(super) fn template(&self, kind: Read) -> String {
     92         self.templates.lock().expect("test query templates")[kind as usize]
     93             .clone()
     94             .expect("observed request")
     95     }
     96 }