use serde_json::{json, Value};
use std::io::Write;
use std::path::Path;
use std::sync::atomic::{AtomicU64, Ordering};
pub const RECEIVED_LOG_FILE: &str = "received_log.jsonl";
pub const MAX_RECEIVED_LOG_BYTES: u64 = 4 * 1024 * 1024;
pub const MAX_REQUESTER_ID_CHARS: usize = 128;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Entry<'a> {
pub ts: &'a str,
pub path: &'a str,
pub requester_id: Option<&'a str>,
pub subject_kind: Option<&'a str>,
pub status: &'a str,
pub reason: Option<&'a str>,
pub request_digest: Option<&'a str>,
pub principal_key_id: Option<&'a str>,
pub principal_node_id: Option<&'a str>,
pub principal_binding: Option<&'a str>,
pub audience: Option<&'a str>,
pub replay: Option<&'a str>,
}
impl Entry<'_> {
pub fn to_json(&self) -> Value {
json!({
"ts": self.ts,
"path": self.path,
"requester_id": self.requester_id.map(|id| id.chars().take(MAX_REQUESTER_ID_CHARS).collect::<String>()),
"subject_kind": self.subject_kind,
"status": self.status,
"reason": self.reason,
"request_digest": self.request_digest,
"principal_key_id": self.principal_key_id,
"principal_node_id": self.principal_node_id,
"principal_binding": self.principal_binding,
"audience": self.audience,
"replay": self.replay,
})
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Appended {
Written,
Off,
Full { dropped: u64 },
}
#[derive(Debug)]
pub struct ReceivedLog {
max_bytes: u64,
dropped: AtomicU64,
}
impl ReceivedLog {
pub const fn new(max_bytes: u64) -> Self {
Self {
max_bytes,
dropped: AtomicU64::new(0),
}
}
pub fn dropped(&self) -> u64 {
self.dropped.load(Ordering::Relaxed)
}
pub fn append(&self, dir: Option<&Path>, entry: &Entry<'_>) -> std::io::Result<Appended> {
let Some(dir) = dir.filter(|d| d.is_dir()) else {
return Ok(Appended::Off);
};
let line = format!("{}\n", entry.to_json());
let mut file = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(dir.join(RECEIVED_LOG_FILE))?;
if file.metadata()?.len() + line.len() as u64 > self.max_bytes {
let dropped = self.dropped.fetch_add(1, Ordering::Relaxed) + 1;
return Ok(Appended::Full { dropped });
}
file.write_all(line.as_bytes())?;
Ok(Appended::Written)
}
}
impl Default for ReceivedLog {
fn default() -> Self {
Self::new(MAX_RECEIVED_LOG_BYTES)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn entry() -> Entry<'static> {
Entry {
ts: "2026-09-29T00:00:00Z",
path: "evidence-request",
requester_id: Some("node-a"),
subject_kind: Some("record"),
status: "refused",
reason: Some("no_such_subject"),
request_digest: Some("ab"),
principal_key_id: Some("cd"),
principal_node_id: Some("node-a"),
principal_binding: Some("bound"),
audience: Some("node-r"),
replay: Some("checked"),
}
}
#[test]
fn a_line_reads_back_as_written() {
let dir = tempfile::tempdir().unwrap();
let log = ReceivedLog::default();
assert_eq!(
log.append(Some(dir.path()), &entry()).unwrap(),
Appended::Written
);
let line = std::fs::read_to_string(dir.path().join(RECEIVED_LOG_FILE)).unwrap();
assert_eq!(
line,
"{\"ts\":\"2026-09-29T00:00:00Z\",\"path\":\"evidence-request\",\"requester_id\":\"node-a\",\"subject_kind\":\"record\",\"status\":\"refused\",\"reason\":\"no_such_subject\",\"request_digest\":\"ab\",\"principal_key_id\":\"cd\",\"principal_node_id\":\"node-a\",\"principal_binding\":\"bound\",\"audience\":\"node-r\",\"replay\":\"checked\"}\n",
"member order and names are the reference's"
);
}
#[test]
fn nothing_is_written_without_the_directory() {
let dir = tempfile::tempdir().unwrap();
let missing = dir.path().join("received-log");
let log = ReceivedLog::default();
assert_eq!(log.append(Some(&missing), &entry()).unwrap(), Appended::Off);
assert_eq!(log.append(None, &entry()).unwrap(), Appended::Off);
assert!(!missing.exists());
}
#[test]
fn the_log_stops_growing_at_its_cap_and_counts_what_it_drops() {
let dir = tempfile::tempdir().unwrap();
let line_len = entry().to_json().to_string().len() as u64 + 1;
let log = ReceivedLog::new(3 * line_len);
let outcomes: Vec<_> = (0..10)
.map(|_| log.append(Some(dir.path()), &entry()).unwrap())
.collect();
assert_eq!(outcomes[..3], [Appended::Written; 3]);
assert_eq!(outcomes[9], Appended::Full { dropped: 7 });
let len = std::fs::metadata(dir.path().join(RECEIVED_LOG_FILE))
.unwrap()
.len();
assert_eq!(len, 3 * line_len, "exactly the lines that fit");
assert_eq!(log.dropped(), 7);
}
#[test]
fn a_requester_id_is_cut_to_the_limit() {
let long = "x".repeat(10_000);
let e = Entry {
requester_id: Some(&long),
..entry()
};
assert_eq!(
e.to_json()["requester_id"].as_str().unwrap().len(),
MAX_REQUESTER_ID_CHARS
);
}
}