use std::sync::{Arc, Mutex};
pub const MAX_OBSERVER_RECORDS: usize = 256;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RequestStarted {
pub sequence: u64,
pub started_at_unix_ms: u64,
pub method: String,
pub operation: String,
pub authenticated_user_id: Option<String>,
pub authenticated_device_id: Option<String>,
pub target_library_id: Option<String>,
pub request_revision: Option<u64>,
pub payload_len: usize,
pub payload_sha256: String,
pub payload_contains_plaintext_sentinel: bool,
pub concurrent_at_start: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RequestFinished {
pub sequence: u64,
pub finished_at_unix_ms: u64,
pub success: bool,
pub response_revision: Option<u64>,
}
pub trait TestRequestObserver: Send + Sync {
fn request_started(&self, event: RequestStarted);
fn request_finished(&self, event: RequestFinished);
fn allocate_sequence(&self) -> u64 {
0
}
fn current_concurrent(&self) -> usize {
0
}
fn last_started_sequence_for_method(&self, _method: &str) -> u64 {
0
}
fn update_ids_for_last_method(
&self,
_method: &str,
_user_id: Option<String>,
_device_id: Option<String>,
_library_id: Option<String>,
) {
}
}
#[derive(Debug, Default)]
pub struct InMemoryObserver {
inner: Arc<Mutex<Inner>>,
}
#[derive(Debug, Default)]
struct Inner {
next_seq: u64,
in_flight: usize,
max_in_flight: usize,
starts: Vec<RequestStarted>,
finishes: Vec<RequestFinished>,
}
impl InMemoryObserver {
pub fn shared() -> Arc<Self> {
Arc::new(Self::default())
}
pub fn starts(&self) -> Vec<RequestStarted> {
self.inner.lock().unwrap().starts.clone()
}
pub fn finishes(&self) -> Vec<RequestFinished> {
self.inner.lock().unwrap().finishes.clone()
}
pub fn max_concurrent(&self) -> usize {
self.inner.lock().unwrap().max_in_flight
}
pub fn started_count(&self) -> usize {
self.inner.lock().unwrap().starts.len()
}
pub fn finished_count(&self) -> usize {
self.inner.lock().unwrap().finishes.len()
}
pub fn success_count(&self) -> usize {
self.inner
.lock()
.unwrap()
.finishes
.iter()
.filter(|f| f.success)
.count()
}
pub fn first_started_at_unix_ms(&self) -> Option<u64> {
self.inner
.lock()
.unwrap()
.starts
.first()
.map(|e| e.started_at_unix_ms)
}
pub fn first_finished_at_unix_ms(&self) -> Option<u64> {
self.inner
.lock()
.unwrap()
.finishes
.first()
.map(|e| e.finished_at_unix_ms)
}
pub fn failures(&self) -> usize {
self.inner
.lock()
.unwrap()
.finishes
.iter()
.filter(|f| !f.success)
.count()
}
}
impl TestRequestObserver for InMemoryObserver {
fn allocate_sequence(&self) -> u64 {
self.next_sequence()
}
fn current_concurrent(&self) -> usize {
self.inner.lock().unwrap().in_flight
}
fn last_started_sequence_for_method(&self, method: &str) -> u64 {
self.inner
.lock()
.unwrap()
.starts
.iter()
.rev()
.find(|s| s.method == method)
.map(|s| s.sequence)
.unwrap_or(0)
}
fn update_ids_for_last_method(
&self,
method: &str,
user_id: Option<String>,
device_id: Option<String>,
library_id: Option<String>,
) {
let mut inner = self.inner.lock().unwrap();
if let Some(start) = inner.starts.iter_mut().rev().find(|s| s.method == method) {
start.authenticated_user_id = user_id;
start.authenticated_device_id = device_id;
start.target_library_id = library_id;
}
}
fn request_started(&self, event: RequestStarted) {
let mut inner = self.inner.lock().unwrap();
inner.starts.push(event);
if inner.starts.len() > MAX_OBSERVER_RECORDS {
inner.starts.remove(0);
}
inner.in_flight += 1;
if inner.in_flight > inner.max_in_flight {
inner.max_in_flight = inner.in_flight;
}
}
fn request_finished(&self, event: RequestFinished) {
let mut inner = self.inner.lock().unwrap();
inner.finishes.push(event);
if inner.finishes.len() > MAX_OBSERVER_RECORDS {
inner.finishes.remove(0);
}
if inner.in_flight > 0 {
inner.in_flight -= 1;
}
}
}
impl InMemoryObserver {
pub fn next_sequence(&self) -> u64 {
let mut inner = self.inner.lock().unwrap();
inner.next_seq += 1;
inner.next_seq
}
pub fn reset(&self) {
let mut inner = self.inner.lock().unwrap();
inner.starts.clear();
inner.finishes.clear();
inner.in_flight = 0;
inner.max_in_flight = 0;
}
}
pub fn now_millis() -> u64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_millis() as u64
}
pub fn operation_name_for_method(method: &str) -> &'static str {
match method {
"push_snippets" => "push",
"sync" => "sync",
"get_snippets" => "pull",
"register" => "register",
"health" => "health",
"create_library" => "create_library",
"list_libraries" => "list_libraries",
"delete_library" => "delete_library",
"list_premade_libraries" => "list_premade_libraries",
"get_premade_library" => "get_premade_library",
"search_premade_libraries" => "search_premade",
_ => "other",
}
}
pub fn payload_sha256<T>(items: &[T], _device_id: &str, _api_key: &str) -> String {
use sha2::{Digest, Sha256};
let mut hasher = Sha256::new();
hasher.update((items.len() as u64).to_le_bytes());
let bytes = hasher.finalize();
bytes.iter().map(|b| format!("{:02x}", b)).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn observer_records_started_and_finished() {
let obs = InMemoryObserver::shared();
let seq = obs.next_sequence();
obs.request_started(RequestStarted {
sequence: seq,
started_at_unix_ms: 1,
method: "push".to_string(),
operation: "push".to_string(),
authenticated_user_id: None,
authenticated_device_id: None,
target_library_id: None,
request_revision: None,
payload_len: 0,
payload_sha256: String::new(),
payload_contains_plaintext_sentinel: false,
concurrent_at_start: 0,
});
obs.request_finished(RequestFinished {
sequence: seq,
finished_at_unix_ms: 2,
success: true,
response_revision: None,
});
assert_eq!(obs.started_count(), 1);
assert_eq!(obs.finished_count(), 1);
assert_eq!(obs.success_count(), 1);
assert_eq!(obs.failures(), 0);
}
#[test]
fn observer_tracks_max_concurrent() {
let obs = InMemoryObserver::shared();
let s1 = obs.next_sequence();
obs.request_started(RequestStarted {
sequence: s1,
started_at_unix_ms: 1,
method: "push".to_string(),
operation: "push".to_string(),
authenticated_user_id: None,
authenticated_device_id: None,
target_library_id: None,
request_revision: None,
payload_len: 0,
payload_sha256: String::new(),
payload_contains_plaintext_sentinel: false,
concurrent_at_start: 0,
});
let s2 = obs.next_sequence();
obs.request_started(RequestStarted {
sequence: s2,
started_at_unix_ms: 2,
method: "push".to_string(),
operation: "push".to_string(),
authenticated_user_id: None,
authenticated_device_id: None,
target_library_id: None,
request_revision: None,
payload_len: 0,
payload_sha256: String::new(),
payload_contains_plaintext_sentinel: false,
concurrent_at_start: 1,
});
assert_eq!(obs.max_concurrent(), 2);
obs.request_finished(RequestFinished {
sequence: s1,
finished_at_unix_ms: 3,
success: true,
response_revision: None,
});
obs.request_finished(RequestFinished {
sequence: s2,
finished_at_unix_ms: 4,
success: true,
response_revision: None,
});
assert_eq!(obs.max_concurrent(), 2);
}
#[test]
fn observer_does_not_retain_payload_bytes() {
let obs = InMemoryObserver::shared();
let seq = obs.next_sequence();
let _ = seq;
}
}