feat(headless): expose negotiated native log observation
This commit is contained in:
@@ -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