feat(headless): expose negotiated native log observation

This commit is contained in:
2026-11-10 21:57:34 +00:00
parent 09d8778f04
commit c649e02816
17 changed files with 1830 additions and 11 deletions
@@ -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();
}