feat(headless): expose negotiated native log observation
This commit is contained in:
@@ -57,6 +57,21 @@ impl LogService {
|
||||
self.events.iter().filter(|e| e.seq > seq).cloned().collect()
|
||||
}
|
||||
|
||||
/// Non-destructive page in native sequence order. A null cursor includes zero.
|
||||
pub fn get_page(&self, after: Option<u64>, limit: usize) -> Vec<LogEvent> {
|
||||
self.events
|
||||
.iter()
|
||||
.filter(|event| after.is_none_or(|seq| event.seq > seq))
|
||||
.take(limit)
|
||||
.cloned()
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Retained bounds, independent of any reader's progress.
|
||||
pub fn sequence_bounds(&self) -> (Option<u64>, Option<u64>) {
|
||||
(self.events.front().map(|event| event.seq), self.last_seq())
|
||||
}
|
||||
|
||||
pub fn last_seq(&self) -> Option<u64> {
|
||||
self.events.back().map(|e| e.seq)
|
||||
}
|
||||
@@ -107,4 +122,35 @@ mod tests {
|
||||
assert_eq!(after[0].msg, "Log 3");
|
||||
assert_eq!(after[1].msg, "Log 4");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pages_preserve_zero_requery_and_retained_bounds() {
|
||||
let mut service = LogService::new(3);
|
||||
assert_eq!(service.sequence_bounds(), (None, None));
|
||||
assert!(service.get_page(None, 2).is_empty());
|
||||
for i in 0..3 {
|
||||
service.log(i, i, LogLevel::Info, LogSource::Pos, 7, format!("{i}"));
|
||||
}
|
||||
assert_eq!(service.sequence_bounds(), (Some(0), Some(2)));
|
||||
for _ in 0..2 {
|
||||
let page = service.get_page(None, 2);
|
||||
assert_eq!(page.iter().map(|event| event.seq).collect::<Vec<_>>(), vec![0, 1]);
|
||||
}
|
||||
assert_eq!(service.get_page(Some(1), 2)[0].seq, 2);
|
||||
assert!(service.get_page(Some(2), 2).is_empty());
|
||||
service.log(3, 3, LogLevel::Info, LogSource::Pos, 7, "next".into());
|
||||
assert_eq!(service.sequence_bounds(), (Some(1), Some(3)));
|
||||
assert_eq!(service.get_page(Some(2), 2)[0].seq, 3);
|
||||
assert_eq!(service.get_page(None, 10).len(), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn page_cursors_preserve_large_unsigned_sequences() {
|
||||
let mut service = LogService::new(3);
|
||||
service.next_seq = u64::MAX - 2;
|
||||
service.log(0, 0, LogLevel::Info, LogSource::Pos, 0, "first".into());
|
||||
service.log(0, 0, LogLevel::Info, LogSource::Pos, 0, "second".into());
|
||||
assert_eq!(service.get_page(Some(u64::MAX - 2), 1)[0].seq, u64::MAX - 1);
|
||||
assert!(service.get_page(Some(u64::MAX), 1).is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -170,6 +170,16 @@ impl SystemOS {
|
||||
self.log_service.get_after(seq)
|
||||
}
|
||||
|
||||
/// Coherent non-destructive page and retained bounds; does not execute the VM.
|
||||
pub fn log_snapshot(
|
||||
&self,
|
||||
after: Option<u64>,
|
||||
limit: usize,
|
||||
) -> (Vec<LogEvent>, Option<u64>, Option<u64>) {
|
||||
let (oldest, newest) = self.log_service.sequence_bounds();
|
||||
(self.log_service.get_page(after, limit), oldest, newest)
|
||||
}
|
||||
|
||||
pub fn frame_index(&mut self) -> u64 {
|
||||
self.vm().logical_frame_index()
|
||||
}
|
||||
|
||||
@@ -106,6 +106,7 @@ fn read_commands<R: BufRead, W: Write>(
|
||||
) -> io::Result<()> {
|
||||
let mut initialized = false;
|
||||
let mut memcard = false;
|
||||
let mut log_read = false;
|
||||
loop {
|
||||
let bytes = match read_line(&mut input, limits.max_command_bytes)? {
|
||||
Line::Eof => break,
|
||||
@@ -144,6 +145,16 @@ fn read_commands<R: BufRead, W: Write>(
|
||||
continue;
|
||||
}
|
||||
};
|
||||
if matches!(command, Command::GetLogs(_)) && !log_read {
|
||||
output.reply(
|
||||
Some(&id),
|
||||
Err(WireError::new(
|
||||
"unsupported_capability",
|
||||
"negotiate minor 1.2 and require log_read first",
|
||||
)),
|
||||
)?;
|
||||
continue;
|
||||
}
|
||||
if command.needs_memcard() && !memcard {
|
||||
output.reply(
|
||||
Some(&id),
|
||||
@@ -180,12 +191,18 @@ fn read_commands<R: BufRead, W: Write>(
|
||||
&& params.required_capabilities.iter().any(|c| c == "memcard")
|
||||
{
|
||||
Err(WireError::new("incompatible_version", "memcard requires protocol minor >= 1"))
|
||||
} else if params.protocol_version.minor < 2
|
||||
&& params.required_capabilities.iter().any(|c| c == "log_read")
|
||||
{
|
||||
Err(WireError::new("incompatible_version", "log_read requires protocol minor >= 2"))
|
||||
} else {
|
||||
initialized = true;
|
||||
memcard = params.protocol_version.minor >= 1
|
||||
&& params.required_capabilities.iter().any(|c| c == "memcard");
|
||||
log_read = params.protocol_version.minor >= 2
|
||||
&& params.required_capabilities.iter().any(|c| c == "log_read");
|
||||
Ok(
|
||||
json!({"protocolVersion":{"major":1,"minor":params.protocol_version.minor.min(1)},"capabilities":CAPABILITIES}),
|
||||
json!({"protocolVersion":{"major":1,"minor":params.protocol_version.minor.min(2)},"capabilities":CAPABILITIES}),
|
||||
)
|
||||
};
|
||||
output.reply(Some(&id), result)?;
|
||||
@@ -281,6 +298,7 @@ fn execute<W: Write>(
|
||||
}
|
||||
Command::GetState => Ok(wire::state(host.get_state())),
|
||||
Command::GetFault => Ok(host.get_fault().as_ref().map(wire::fault).unwrap_or(Value::Null)),
|
||||
Command::GetLogs(params) => wire::logs(host, params, &output.session),
|
||||
Command::Capture => host.capture_frame().map_err(wire::host_error).and_then(wire::capture),
|
||||
Command::Advance(p) => {
|
||||
let mut result = json!({"requested":p.frames,"completed":0,"stop":"completed"});
|
||||
@@ -339,7 +357,7 @@ pub fn serve<R: BufRead + Send + 'static, W: Write + Send + 'static>(
|
||||
let output =
|
||||
Arc::new(Output { writer: Mutex::new(writer), session, limit: limits.max_response_bytes });
|
||||
output.send(
|
||||
json!({"type":"hello","sessionId":output.session,"protocolVersion":{"major":1,"minor":1},
|
||||
json!({"type":"hello","sessionId":output.session,"protocolVersion":{"major":1,"minor":2},
|
||||
"runtimeVersion":runtime_version,"capabilities":CAPABILITIES,"limits":limits}),
|
||||
)?;
|
||||
let control = Arc::new(Mutex::new(Control::default()));
|
||||
@@ -476,7 +494,7 @@ mod tests {
|
||||
"../../../../../devtools/headless-protocol/requests.json"
|
||||
))
|
||||
.unwrap();
|
||||
assert_eq!(requests.len(), 21);
|
||||
assert!(!requests.is_empty());
|
||||
for request in requests {
|
||||
wire::parse(serde_json::from_value(request).unwrap()).unwrap();
|
||||
}
|
||||
|
||||
@@ -22,6 +22,7 @@ pub const CAPABILITIES: &[&str] = &[
|
||||
"capture",
|
||||
"get_state",
|
||||
"get_fault",
|
||||
"log_read",
|
||||
"cancel",
|
||||
"shutdown",
|
||||
"memcard",
|
||||
@@ -139,6 +140,19 @@ pub(super) struct Advance {
|
||||
pub frames: u64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
||||
pub(super) struct GetLogs {
|
||||
// Explicit deserializer makes the nullable field required, including on first read.
|
||||
#[serde(deserialize_with = "nullable_cursor")]
|
||||
pub after_sequence: Option<u64>,
|
||||
pub limit: u16,
|
||||
}
|
||||
|
||||
fn nullable_cursor<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Option<u64>, D::Error> {
|
||||
Option::<u64>::deserialize(d)
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
||||
pub(super) struct Cancel {
|
||||
@@ -203,6 +217,7 @@ pub(super) enum Command {
|
||||
Capture,
|
||||
GetState,
|
||||
GetFault,
|
||||
GetLogs(GetLogs),
|
||||
Cancel(Cancel),
|
||||
Shutdown(Teardown),
|
||||
}
|
||||
@@ -247,6 +262,13 @@ pub(super) fn parse(req: Request) -> Result<(String, Command), WireError> {
|
||||
Command::Boot(p)
|
||||
}
|
||||
"advance" => Command::Advance(params(req.params)?),
|
||||
"get_logs" => {
|
||||
let p: GetLogs = params(req.params)?;
|
||||
if !(1..=1024).contains(&p.limit) {
|
||||
return Err(WireError::new("invalid_params", "limit must be 1..1024"));
|
||||
}
|
||||
Command::GetLogs(p)
|
||||
}
|
||||
"reset" => Command::Reset(params(req.params)?),
|
||||
"shutdown" => Command::Shutdown(params(req.params)?),
|
||||
"memcard_mount" => {
|
||||
@@ -357,6 +379,48 @@ pub(super) fn state(s: HostState) -> Value {
|
||||
"status":status_name(s.status)})
|
||||
}
|
||||
|
||||
pub(super) fn logs(
|
||||
host: &crate::HeadlessHost,
|
||||
params: GetLogs,
|
||||
session: &str,
|
||||
) -> Result<Value, WireError> {
|
||||
let (events, oldest, newest) =
|
||||
host.log_snapshot(params.after_sequence, usize::from(params.limit));
|
||||
if params.after_sequence.is_some_and(|after| newest.is_none_or(|newest| after > newest)) {
|
||||
return Err(WireError::new("invalid_cursor", "afterSequence exceeds the log stream"));
|
||||
}
|
||||
let gap = oldest.is_some_and(|oldest| match params.after_sequence {
|
||||
None => oldest > 0,
|
||||
Some(after) => after.checked_add(1).is_some_and(|next| next < oldest),
|
||||
});
|
||||
let next = events.last().map(|event| event.seq).or(params.after_sequence);
|
||||
Ok(
|
||||
json!({"sessionId":session,"logEpoch":0,"events":events.iter().map(log_event).collect::<Vec<_>>(),
|
||||
"oldestSequence":oldest,"newestSequence":newest,"nextAfterSequence":next,
|
||||
"gap":gap,"overflow":oldest.is_some_and(|oldest| oldest > 0)}),
|
||||
)
|
||||
}
|
||||
|
||||
fn log_event(event: &prometeu_hal::log::LogEvent) -> Value {
|
||||
use prometeu_hal::log::{LogLevel, LogSource};
|
||||
let level = match event.level {
|
||||
LogLevel::Trace => "trace",
|
||||
LogLevel::Debug => "debug",
|
||||
LogLevel::Info => "info",
|
||||
LogLevel::Warn => "warn",
|
||||
LogLevel::Error => "error",
|
||||
};
|
||||
let (source, app_id) = match event.source {
|
||||
LogSource::Pos => ("pos", None),
|
||||
LogSource::Hub => ("hub", None),
|
||||
LogSource::Vm => ("vm", None),
|
||||
LogSource::Fs => ("fs", None),
|
||||
LogSource::App { app_id } => ("app", Some(app_id)),
|
||||
};
|
||||
json!({"sequence":event.seq,"frame":event.frame,"timestampMs":event.ts_ms,
|
||||
"level":level,"source":source,"appId":app_id,"tag":event.tag,"message":event.msg})
|
||||
}
|
||||
|
||||
pub(super) fn fault(report: &CrashReport) -> Value {
|
||||
let mut result = json!({"kind":report.kind(),"pc":report.pc(),"summary":report.summary()});
|
||||
match report {
|
||||
@@ -402,3 +466,105 @@ pub(super) fn capture(c: CapturedFrame) -> Result<Value, WireError> {
|
||||
"width":width,"height":height,"stridePixels":frame.stride_pixels,"pixelFormat":"RGBA8888",
|
||||
"logicalFrameIndex":c.logical_frame_index,"frameId":frame.frame_id.get()}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod log_tests {
|
||||
use super::*;
|
||||
use prometeu_hal::log::{LogEvent, LogLevel, LogSource};
|
||||
|
||||
#[test]
|
||||
fn oversized_native_event_is_an_error_without_partial_result() {
|
||||
let event = LogEvent {
|
||||
seq: 0,
|
||||
frame: 0,
|
||||
ts_ms: 0,
|
||||
level: LogLevel::Error,
|
||||
source: LogSource::Vm,
|
||||
tag: 0,
|
||||
msg: "x".repeat(8192),
|
||||
};
|
||||
let output = super::super::Output {
|
||||
writer: std::sync::Mutex::new(Vec::new()),
|
||||
session: "session".into(),
|
||||
limit: 4096,
|
||||
};
|
||||
output.reply(Some("logs"), Ok(json!({"events":[log_event(&event)]}))).unwrap();
|
||||
let bytes = output.writer.into_inner().unwrap();
|
||||
assert!(bytes.len() <= 4097);
|
||||
let response: Value = serde_json::from_slice(&bytes).unwrap();
|
||||
assert_eq!(response["error"]["code"], "response_too_large");
|
||||
assert_eq!(response["requestId"], "logs");
|
||||
assert!(response.get("result").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_records_preserve_unsigned_maxima_and_typed_sources() {
|
||||
for (source, name, app_id) in [
|
||||
(LogSource::Pos, "pos", None),
|
||||
(LogSource::Hub, "hub", None),
|
||||
(LogSource::Vm, "vm", None),
|
||||
(LogSource::Fs, "fs", None),
|
||||
(LogSource::App { app_id: u32::MAX }, "app", Some(u32::MAX)),
|
||||
] {
|
||||
for (level, level_name) in [
|
||||
(LogLevel::Trace, "trace"),
|
||||
(LogLevel::Debug, "debug"),
|
||||
(LogLevel::Info, "info"),
|
||||
(LogLevel::Warn, "warn"),
|
||||
(LogLevel::Error, "error"),
|
||||
] {
|
||||
let event = LogEvent {
|
||||
seq: u64::MAX,
|
||||
frame: u64::MAX,
|
||||
ts_ms: u64::MAX,
|
||||
level,
|
||||
source,
|
||||
tag: u16::MAX,
|
||||
msg: "complete native message".into(),
|
||||
};
|
||||
let encoded = log_event(&event);
|
||||
let decoded: Value =
|
||||
serde_json::from_slice(&serde_json::to_vec(&encoded).unwrap()).unwrap();
|
||||
for key in ["sequence", "frame", "timestampMs"] {
|
||||
assert_eq!(decoded[key].as_u64(), Some(u64::MAX));
|
||||
}
|
||||
assert_eq!(decoded["level"], level_name);
|
||||
assert_eq!(decoded["source"], name);
|
||||
assert_eq!(decoded["appId"], json!(app_id));
|
||||
assert_eq!(decoded["tag"], u16::MAX);
|
||||
assert_eq!(decoded["message"], event.msg);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn required_nullable_cursor_and_limit_reject_malformed_values() {
|
||||
for value in [
|
||||
json!({"limit":1}),
|
||||
json!({"afterSequence":null}),
|
||||
json!({"afterSequence":-1,"limit":1}),
|
||||
json!({"afterSequence":1.5,"limit":1}),
|
||||
json!({"afterSequence":"0","limit":1}),
|
||||
json!({"afterSequence":null,"limit":0}),
|
||||
json!({"afterSequence":null,"limit":1025}),
|
||||
json!({"afterSequence":null,"limit":1,"filter":"app"}),
|
||||
] {
|
||||
assert!(
|
||||
parse(Request {
|
||||
request_id: "logs".into(),
|
||||
command: "get_logs".into(),
|
||||
params: value
|
||||
})
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
assert!(
|
||||
parse(Request {
|
||||
request_id: "logs".into(),
|
||||
command: "get_logs".into(),
|
||||
params: json!({"afterSequence":u64::MAX,"limit":1024})
|
||||
})
|
||||
.is_ok()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -178,6 +178,15 @@ impl HeadlessHost {
|
||||
self.controlled_wall_clock.as_deref()
|
||||
}
|
||||
|
||||
/// Observe native log history without advancing, draining or changing lifecycle.
|
||||
pub fn log_snapshot(
|
||||
&self,
|
||||
after: Option<u64>,
|
||||
limit: usize,
|
||||
) -> (Vec<prometeu_hal::log::LogEvent>, Option<u64>, Option<u64>) {
|
||||
self.firmware.os.log_snapshot(after, limit)
|
||||
}
|
||||
|
||||
/// Load `path` and tick until the firmware is in `GameRunning`.
|
||||
///
|
||||
/// The transition into `GameRunning` is the last tick. The first game
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
use base64::{Engine as _, engine::general_purpose::STANDARD};
|
||||
use prometeu_bytecode::SourceSpan;
|
||||
use prometeu_bytecode::assembler::assemble;
|
||||
use prometeu_bytecode::model::{DebugInfo, Export, SyscallDecl};
|
||||
use prometeu_bytecode::model::{ConstantPoolEntry, DebugInfo, Export, SyscallDecl};
|
||||
use prometeu_bytecode::registry::FunctionDecl;
|
||||
use prometeu_host_headless::{AdvanceFramesStop, HeadlessHost};
|
||||
use prometeu_test_support::program::{TestProgram, int64_signature};
|
||||
@@ -223,6 +223,48 @@ fn cartridge_bytes(code: Vec<u8>, gfx: bool) -> TempDir {
|
||||
fn colored_cart() -> TempDir {
|
||||
cartridge("PUSH_I64 4278190335\nHOSTCALL 0\nRET\n", true)
|
||||
}
|
||||
|
||||
fn logging_cart(messages_per_frame: usize, message: &str) -> TempDir {
|
||||
let dir = TempDir::new();
|
||||
let code = assemble(&format!(
|
||||
"{}RET\n",
|
||||
"PUSH_I64 2\nPUSH_I64 41000\nPUSH_CONST 0\nHOSTCALL 0\n".repeat(messages_per_frame)
|
||||
))
|
||||
.unwrap();
|
||||
let mut module = TestProgram::single(code, int64_signature(0, 0), 0, 3);
|
||||
module.const_pool = vec![ConstantPoolEntry::String(message.into())];
|
||||
module.exports = vec![Export { symbol: "main".into(), func_idx: 0 }];
|
||||
module.syscalls = vec![SyscallDecl {
|
||||
module: "log".into(),
|
||||
name: "write_tag".into(),
|
||||
version: 1,
|
||||
arg_slots: 3,
|
||||
ret_slots: 0,
|
||||
}];
|
||||
fs::write(dir.0.join("program.pbx"), module.serialize()).unwrap();
|
||||
fs::write(
|
||||
dir.0.join("manifest.json"),
|
||||
serde_json::to_vec(&json!({
|
||||
"magic":"PMTU","cartridge_version":1,"app_id":41,"title":"Native log test",
|
||||
"app_version":"0.1.0","app_mode":"Game","capabilities":["log"]}))
|
||||
.unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
fn initialize_logs(client: &mut Client) {
|
||||
let result = client.ok(
|
||||
"initialize",
|
||||
json!({"protocolVersion":{"major":1,"minor":2},
|
||||
"requiredCapabilities":["log_read"]}),
|
||||
);
|
||||
assert_eq!(result["protocolVersion"]["minor"], 2);
|
||||
}
|
||||
|
||||
fn read_log_page(client: &mut Client, after: Value, limit: u16) -> Value {
|
||||
client.ok("get_logs", json!({"afterSequence":after,"limit":limit}))
|
||||
}
|
||||
fn boot(client: &mut Client, dir: &TempDir) {
|
||||
client.ok("boot", json!({"path":dir.0}));
|
||||
}
|
||||
@@ -243,7 +285,7 @@ fn png_bytes(capture: &Value) -> Vec<u8> {
|
||||
fn handshake_versions_capabilities_and_limits_are_explicit() {
|
||||
let mut c = Client::new(&["--stdio"]);
|
||||
assert_eq!(c.hello["runtimeVersion"], env!("CARGO_PKG_VERSION"));
|
||||
assert_eq!(c.hello["protocolVersion"], json!({"major":1,"minor":1}));
|
||||
assert_eq!(c.hello["protocolVersion"], json!({"major":1,"minor":2}));
|
||||
assert_eq!(
|
||||
c.hello["limits"],
|
||||
json!({"maxFrames":600,"maxCommandBytes":65536,"maxResponseBytes":33554432,
|
||||
@@ -269,7 +311,7 @@ fn handshake_versions_capabilities_and_limits_are_explicit() {
|
||||
"initialize",
|
||||
json!({"protocolVersion":{"major":1,"minor":42},"requiredCapabilities":[]})
|
||||
)["protocolVersion"]["minor"],
|
||||
1
|
||||
2
|
||||
);
|
||||
assert_eq!(
|
||||
c.call(
|
||||
@@ -432,11 +474,15 @@ fn faults_and_boot_failures_are_structured_not_log_parsing() {
|
||||
fn conflicting_work_is_rejected_and_cancellation_reports_partial_progress() {
|
||||
let dir = colored_cart();
|
||||
let mut c = Client::new(&["--stdio", "--max-frames", "100000"]);
|
||||
c.initialize();
|
||||
initialize_logs(&mut c);
|
||||
boot(&mut c, &dir);
|
||||
let advance = c.send("advance", json!({"frames":100000}));
|
||||
assert_eq!(c.event()["type"], "progress");
|
||||
assert_eq!(c.call("reset", json!({}))["error"]["code"], "busy");
|
||||
assert_eq!(
|
||||
c.call("get_logs", json!({"afterSequence":null,"limit":1}))["error"]["code"],
|
||||
"busy"
|
||||
);
|
||||
c.ok("cancel", json!({"targetRequestId":advance}));
|
||||
let response = c.response(&advance);
|
||||
let result = &response["result"];
|
||||
@@ -551,6 +597,187 @@ fn missing_binary_and_invalid_cli_limits_fail_explicitly() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn log_read_requires_explicit_capability_and_minor_two() {
|
||||
for minor in [0, 1, 2] {
|
||||
let mut c = Client::new(&["--stdio"]);
|
||||
assert!(c.hello["capabilities"].as_array().unwrap().contains(&json!("log_read")));
|
||||
if minor < 2 {
|
||||
assert_eq!(
|
||||
c.call(
|
||||
"initialize",
|
||||
json!({"protocolVersion":{"major":1,"minor":minor},
|
||||
"requiredCapabilities":["log_read"]})
|
||||
)["error"]["code"],
|
||||
"incompatible_version"
|
||||
);
|
||||
}
|
||||
let initialized = c.ok(
|
||||
"initialize",
|
||||
json!({"protocolVersion":{"major":1,"minor":minor},
|
||||
"requiredCapabilities":[]}),
|
||||
);
|
||||
assert_eq!(initialized["protocolVersion"]["minor"], minor);
|
||||
assert_eq!(
|
||||
c.call("get_logs", json!({"afterSequence":null,"limit":1}))["error"]["code"],
|
||||
"unsupported_capability"
|
||||
);
|
||||
assert_eq!(c.ok("get_state", json!({}))["logicalFrameIndex"], 0);
|
||||
c.close();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_log_pages_are_read_only_replayable_and_survive_reset() {
|
||||
let dir = logging_cart(2, "{\"native\":\"é\"}");
|
||||
let mut c = Client::new(&["--stdio"]);
|
||||
initialize_logs(&mut c);
|
||||
let initial = read_log_page(&mut c, Value::Null, 1);
|
||||
assert_eq!(initial["events"][0]["sequence"], 0);
|
||||
assert_eq!(initial["events"][0]["source"], "pos");
|
||||
assert_eq!(initial["events"][0]["appId"], Value::Null);
|
||||
assert_eq!(initial["sessionId"], c.hello["sessionId"]);
|
||||
assert_eq!(initial["logEpoch"], 0);
|
||||
assert_eq!(initial["gap"], false);
|
||||
assert_eq!(initial["overflow"], false);
|
||||
boot(&mut c, &dir);
|
||||
c.ok("advance", json!({"frames":2}));
|
||||
let state = c.ok("get_state", json!({}));
|
||||
let fault = c.ok("get_fault", json!({}));
|
||||
let all = read_log_page(&mut c, Value::Null, 1024);
|
||||
let native = all["events"].as_array().unwrap();
|
||||
let app: Vec<_> = native.iter().filter(|event| event["source"] == "app").collect();
|
||||
assert_eq!(app.len(), 4);
|
||||
assert!(app.iter().all(|event| event["tag"] == 41000
|
||||
&& event["appId"] == 41
|
||||
&& event["level"] == "info"
|
||||
&& event["message"] == "{\"native\":\"é\"}"));
|
||||
let mut cursor = Value::Null;
|
||||
let mut paged = Vec::new();
|
||||
loop {
|
||||
let page = read_log_page(&mut c, cursor.clone(), 2);
|
||||
assert_eq!(page, read_log_page(&mut c, cursor.clone(), 2));
|
||||
paged.extend(page["events"].as_array().unwrap().iter().cloned());
|
||||
cursor = page["nextAfterSequence"].clone();
|
||||
if cursor == page["newestSequence"] {
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert_eq!(&paged, native);
|
||||
let empty = read_log_page(&mut c, cursor.clone(), 1);
|
||||
assert!(empty["events"].as_array().unwrap().is_empty());
|
||||
assert_eq!(empty["nextAfterSequence"], cursor);
|
||||
assert_eq!(state, c.ok("get_state", json!({})));
|
||||
assert_eq!(fault, c.ok("get_fault", json!({})));
|
||||
assert_eq!(
|
||||
c.call("get_logs", json!({"afterSequence":u64::MAX,"limit":1}))["error"]["code"],
|
||||
"invalid_cursor"
|
||||
);
|
||||
c.ok("reset", json!({}));
|
||||
let reset = read_log_page(&mut c, Value::Null, 1024);
|
||||
assert_eq!(&reset["events"].as_array().unwrap()[..native.len()], native);
|
||||
let after_reset = read_log_page(&mut c, cursor, 1024);
|
||||
assert!(!after_reset["events"].as_array().unwrap().is_empty());
|
||||
assert_eq!(after_reset["gap"], false);
|
||||
assert_eq!(after_reset["logEpoch"], 0);
|
||||
assert_eq!(after_reset["sessionId"], all["sessionId"]);
|
||||
c.close();
|
||||
let mut other = Client::new(&["--stdio"]);
|
||||
initialize_logs(&mut other);
|
||||
let fresh = read_log_page(&mut other, Value::Null, 1);
|
||||
assert_ne!(fresh["sessionId"], all["sessionId"]);
|
||||
assert_eq!(fresh["events"][0]["sequence"], 0);
|
||||
assert_eq!(
|
||||
other.call("get_logs", json!({"afterSequence":all["newestSequence"],"limit":1}))["error"]["code"],
|
||||
"invalid_cursor"
|
||||
);
|
||||
other.close();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn timely_readers_outlive_ring_capacity_while_stale_cursors_report_gaps() {
|
||||
let dir = logging_cart(10, "retention");
|
||||
let mut c = Client::new(&["--stdio"]);
|
||||
initialize_logs(&mut c);
|
||||
boot(&mut c, &dir);
|
||||
let mut cursor = Value::Null;
|
||||
let mut count = 0;
|
||||
let mut saw_eviction = false;
|
||||
for _ in 0..5 {
|
||||
assert_eq!(c.ok("advance", json!({"frames":100}))["completed"], 100);
|
||||
loop {
|
||||
let page = read_log_page(&mut c, cursor.clone(), 128);
|
||||
assert_eq!(page["gap"], false);
|
||||
saw_eviction |= page["overflow"] == true;
|
||||
for event in page["events"].as_array().unwrap() {
|
||||
assert_eq!(event["sequence"].as_u64().unwrap(), count);
|
||||
count += 1;
|
||||
}
|
||||
cursor = page["nextAfterSequence"].clone();
|
||||
if cursor == page["newestSequence"] {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(count > 4096 && saw_eviction);
|
||||
for stale in [Value::Null, json!(0)] {
|
||||
let page = read_log_page(&mut c, stale, 1);
|
||||
assert_eq!(page["gap"], true);
|
||||
assert_eq!(page["overflow"], true);
|
||||
assert!(page["oldestSequence"].as_u64().unwrap() > 0);
|
||||
assert_eq!(page["events"][0]["sequence"], page["oldestSequence"]);
|
||||
}
|
||||
let empty = read_log_page(&mut c, cursor.clone(), 1);
|
||||
assert_eq!(empty["gap"], false);
|
||||
assert_eq!(empty["overflow"], true);
|
||||
assert_eq!(empty["nextAfterSequence"], cursor);
|
||||
c.close();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bounded_log_responses_can_be_retried_without_draining() {
|
||||
let dir = logging_cart(10, &"x".repeat(200));
|
||||
let mut c = Client::new(&["--stdio", "--max-response-bytes", "4096"]);
|
||||
initialize_logs(&mut c);
|
||||
boot(&mut c, &dir);
|
||||
c.ok("advance", json!({"frames":5}));
|
||||
let state = c.ok("get_state", json!({}));
|
||||
let response = c.call("get_logs", json!({"afterSequence":null,"limit":1024}));
|
||||
assert_eq!(response["error"]["code"], "response_too_large");
|
||||
assert!(response.get("result").is_none());
|
||||
let first = read_log_page(&mut c, Value::Null, 1);
|
||||
assert_eq!(first["events"][0]["sequence"], 0);
|
||||
assert_eq!(first, read_log_page(&mut c, Value::Null, 1));
|
||||
assert_eq!(state, c.ok("get_state", json!({})));
|
||||
c.close();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn log_observation_preserves_existing_guest_length_and_rate_limits() {
|
||||
let dir = logging_cart(12, &"x".repeat(300));
|
||||
let mut c = Client::new(&["--stdio"]);
|
||||
initialize_logs(&mut c);
|
||||
boot(&mut c, &dir);
|
||||
c.ok("advance", json!({"frames":1}));
|
||||
let page = read_log_page(&mut c, Value::Null, 1024);
|
||||
let app: Vec<_> = page["events"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.filter(|event| event["source"] == "app")
|
||||
.collect();
|
||||
let messages: Vec<_> = app.iter().filter(|event| event["tag"] == 41000).collect();
|
||||
assert_eq!(messages.len(), 10);
|
||||
assert!(messages.iter().all(|event| event["message"].as_str().unwrap().len() == 256));
|
||||
assert_eq!(app.len(), 11);
|
||||
assert!(app.iter().any(|event| event["tag"] == 0
|
||||
&& event["level"] == "warn"
|
||||
&& event["message"] == "App exceeded log limit per frame"));
|
||||
assert_eq!(page["gap"], false);
|
||||
assert_eq!(page["overflow"], false);
|
||||
c.close();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn schemas_and_distributed_request_fixtures_are_consistent() {
|
||||
let request: Value = serde_json::from_str(include_str!(
|
||||
@@ -616,3 +843,38 @@ fn packaged_installation_smoke() {
|
||||
c.input.take();
|
||||
c.wait_exit();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an isolated installation"]
|
||||
fn packaged_native_log_observation() {
|
||||
let installation = PathBuf::from(
|
||||
std::env::var_os("PROMETEU_PROTOCOL_TEST_INSTALL").expect("set isolated installation path"),
|
||||
);
|
||||
let cwd = TempDir::new();
|
||||
let dir = logging_cart(1, "installed native log");
|
||||
let mut c =
|
||||
Client::spawn(&installation.join("prometeu"), &["headless", "--stdio"], Some(&cwd.0));
|
||||
initialize_logs(&mut c);
|
||||
boot(&mut c, &dir);
|
||||
c.ok("advance", json!({"frames":1}));
|
||||
let page = read_log_page(&mut c, Value::Null, 1024);
|
||||
assert_eq!(page["gap"], false);
|
||||
assert!(
|
||||
page["events"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.any(|event| event["source"] == "app" && event["message"] == "installed native log")
|
||||
);
|
||||
let installed_schema: Value = serde_json::from_slice(
|
||||
&fs::read(installation.join("headless-protocol/response.schema.json")).unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
jsonschema::validator_for(&installed_schema)
|
||||
.unwrap()
|
||||
.validate(&json!({
|
||||
"type":"response","sessionId":c.hello["sessionId"],"requestId":"logs","result":page,
|
||||
}))
|
||||
.unwrap();
|
||||
c.close();
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user