Lightweight coding agent that runs in your terminal
Rust
Propagate request trace context through exec-server relays (#38690)
Ben Romano4861236f06d0
diff --git a/codex-rs/exec-server/README.md b/codex-rs/exec-server/README.mdindex b560f568bf..c3d5bc0c42 100644--- a/codex-rs/exec-server/README.md+++ b/codex-rs/exec-server/README.md@@ -59,6 +59,8 @@ identity plus endpoint-owned reliability metadata:```textversionstream_id+traceparent // optional W3C parent on the first frame of a traced request+tracestate // optional W3C vendor state paired with traceparentbody // handshake | data | ack_frame | resume | reset | heartbeatack // highest contiguous peer segment seq receivedack_bits // bitset for peer segment seqs after ackdiff --git a/codex-rs/exec-server/src/noise_relay/executor_stream.rs b/codex-rs/exec-server/src/noise_relay/executor_stream.rsindex 89f33d938a..37a026931a 100644--- a/codex-rs/exec-server/src/noise_relay/executor_stream.rs+++ b/codex-rs/exec-server/src/noise_relay/executor_stream.rs@@ -7,6 +7,7 @@use std::sync::Arc;use std::sync::Mutex;+use codex_exec_server_protocol::JSONRPCMessage;use tokio::sync::mpsc;use tokio::sync::watch;use tracing::warn;@@ -119,6 +120,12 @@ pub(crate) fn spawn_noise_virtual_stream(break;}};+ let mut trace = match message {+ JSONRPCMessage::Request(request) => request.trace,+ JSONRPCMessage::Notification(_)+ | JSONRPCMessage::Response(_)+ | JSONRPCMessage::Error(_) => None,+ };for plaintext_record in framed.chunks(NOISE_RECORD_PLAINTEXT_LEN) {let seq = match take_next_sequence(&mut next_seq) {Ok(seq) => seq,@@ -140,7 +147,12 @@ pub(crate) fn spawn_noise_virtual_stream(break 'writer;}};- let frame = RelayMessageFrame::data(writer_stream_id.clone(), seq, ciphertext);+ let frame = RelayMessageFrame::data(+ writer_stream_id.clone(),+ seq,+ ciphertext,+ trace.take(),+ );if physical_outgoing_tx.send(encode_relay_message_frame(&frame)).awaitdiff --git a/codex-rs/exec-server/src/noise_relay/executor_stream_tests.rs b/codex-rs/exec-server/src/noise_relay/executor_stream_tests.rsindex 232dfa479e..986fd650fe 100644--- a/codex-rs/exec-server/src/noise_relay/executor_stream_tests.rs+++ b/codex-rs/exec-server/src/noise_relay/executor_stream_tests.rs@@ -2,8 +2,10 @@ use std::time::Duration;use anyhow::Result;use codex_exec_server_protocol::JSONRPCMessage;+use codex_exec_server_protocol::JSONRPCRequest;use codex_exec_server_protocol::JSONRPCResponse;use codex_exec_server_protocol::RequestId;+use codex_protocol::protocol::W3cTraceContext;use tokio::sync::mpsc;use tokio::time::timeout;@@ -16,8 +18,60 @@ use crate::noise_channel::NoiseChannelIdentity;use crate::noise_channel::PendingResponderHandshake;use crate::noise_relay::message_framing::frame_jsonrpc_message;use crate::relay_proto::RelayData;+use crate::relay_proto::RelayMessageFrame;use crate::server::ConnectionProcessor;+#[test]+fn executor_requests_attach_trace_context_only_to_the_first_noise_record() {+ let traceparent = "00-00000000000000000000000000000001-0000000000000002-01";+ let tracestate = "dd=s:1";+ let owned_traceparent = traceparent.to_string();+ let owned_tracestate = tracestate.to_string();+ let traceparent_ptr = owned_traceparent.as_ptr();+ let tracestate_ptr = owned_tracestate.as_ptr();+ let mut request = JSONRPCRequest {+ id: RequestId::Integer(1),+ method: "approval/request".to_string(),+ params: None,+ trace: Some(W3cTraceContext {+ traceparent: Some(owned_traceparent),+ tracestate: Some(owned_tracestate),+ }),+ };++ let first = RelayMessageFrame::data(+ "stream-1".to_string(),+ /*seq*/ 0,+ vec![1],+ request.trace.take(),+ );+ assert_eq!(first.traceparent.as_deref(), Some(traceparent));+ assert_eq!(first.tracestate.as_deref(), Some(tracestate));+ assert_eq!(+ first.traceparent.as_ref().unwrap().as_ptr(),+ traceparent_ptr+ );+ assert_eq!(first.tracestate.as_ref().unwrap().as_ptr(), tracestate_ptr);++ let second = RelayMessageFrame::data(+ "stream-1".to_string(),+ /*seq*/ 1,+ vec![2],+ request.trace.take(),+ );+ assert!(second.traceparent.is_none());+ assert!(second.tracestate.is_none());++ let response = RelayMessageFrame::data(+ "stream-1".to_string(),+ /*seq*/ 2,+ vec![3],+ /*trace*/ None,+ );+ assert!(response.traceparent.is_none());+ assert!(response.tracestate.is_none());+}+#[tokio::test]async fn processor_exit_reports_closed_virtual_stream() -> Result<()> {let executor_identity = NoiseChannelIdentity::generate()?;diff --git a/codex-rs/exec-server/src/noise_relay/harness.rs b/codex-rs/exec-server/src/noise_relay/harness.rsindex 9969a3e130..ad2163c903 100644--- a/codex-rs/exec-server/src/noise_relay/harness.rs+++ b/codex-rs/exec-server/src/noise_relay/harness.rs@@ -275,7 +275,7 @@ where// Keep one framed message as a cursor. Sending one Noise record per loop// creates a scheduling point for keepalive and inbound control frames// without splitting the WebSocket reader and writer.- let mut pending_outbound: Option<(Vec<u8>, usize)> = None;+ let mut pending_outbound = None;let mut force_incoming = false;let mut frames_drained_after_pong_deadline = 0usize;'relay: loop {@@ -344,13 +344,20 @@ wherelet Some(message) = maybe_message else {break;};- pending_outbound = Some(match frame_jsonrpc_message(&message) {- Ok(framed) => (framed, 0),+ let framed = match frame_jsonrpc_message(&message) {+ Ok(framed) => framed,Err(error) => {warn!("failed to frame JSON-RPC payload for Noise relay: {error}");break;}- });+ };+ let request_trace = match message {+ codex_exec_server_protocol::JSONRPCMessage::Request(request) => request.trace,+ codex_exec_server_protocol::JSONRPCMessage::Notification(_)+ | codex_exec_server_protocol::JSONRPCMessage::Response(_)+ | codex_exec_server_protocol::JSONRPCMessage::Error(_) => None,+ };+ pending_outbound = Some((framed, 0, request_trace));}_ = std::future::ready(()), if pending_outbound.is_some() && !force_incoming && !pong_deadline_expired => {let seq = match take_next_sequence(&mut next_outbound_seq) {@@ -360,8 +367,8 @@ wherebreak 'relay;}};- let (ciphertext, next_offset, message_complete) = {- let Some((framed, offset)) = pending_outbound.as_ref() else {+ let (ciphertext, next_offset, message_complete, request_trace) = {+ let Some((framed, offset, request_trace)) = pending_outbound.as_mut() else {continue;};let next_offset = (*offset + NOISE_RECORD_PLAINTEXT_LEN).min(framed.len());@@ -372,9 +379,15 @@ wherebreak 'relay;}};- (ciphertext, next_offset, next_offset == framed.len())+ (+ ciphertext,+ next_offset,+ next_offset == framed.len(),+ request_trace.take(),+ )};- let frame = RelayMessageFrame::data(stream_id.clone(), seq, ciphertext);+ let frame =+ RelayMessageFrame::data(stream_id.clone(), seq, ciphertext, request_trace);// A Pong can arrive after the readiness check while this write owns the// combined sink and stream. A single bounded record can therefore hit the// deadline and disconnect with that Pong queued. Treat that as write@@ -391,7 +404,7 @@ where}if message_complete {pending_outbound = None;- } else if let Some((_framed, offset)) = pending_outbound.as_mut() {+ } else if let Some((_framed, offset, _request_trace)) = pending_outbound.as_mut() {*offset = next_offset;}}diff --git a/codex-rs/exec-server/src/noise_relay/harness_tests.rs b/codex-rs/exec-server/src/noise_relay/harness_tests.rsindex 348351e61c..16df1cbf0f 100644--- a/codex-rs/exec-server/src/noise_relay/harness_tests.rs+++ b/codex-rs/exec-server/src/noise_relay/harness_tests.rs@@ -11,6 +11,7 @@ use anyhow::Result;use codex_exec_server_protocol::JSONRPCMessage;use codex_exec_server_protocol::JSONRPCRequest;use codex_exec_server_protocol::RequestId;+use codex_protocol::protocol::W3cTraceContext;use futures::Sink;use futures::SinkExt;use futures::StreamExt;@@ -31,6 +32,52 @@ use crate::noise_channel::PendingResponderHandshake;const ENVIRONMENT_ID: &str = "environment-1";const EXECUTOR_REGISTRATION_ID: &str = "registration-1";+#[tokio::test(start_paused = true)]+async fn first_encrypted_request_frame_exposes_only_its_trace_context() -> Result<()> {+ let (connection, mut control, mut outbound_rx) = connected_controlled_harness().await?;+ let traceparent = "00-00000000000000000000000000000001-0000000000000002-01";+ let tracestate = "dd=s:1";++ connection+ .outgoing_tx+ .send(JSONRPCMessage::Request(JSONRPCRequest {+ id: RequestId::Integer(1),+ method: "fs/getMetadata".to_string(),+ params: Some(serde_json::json!({+ "payload": "x".repeat(NOISE_RECORD_PLAINTEXT_LEN * 2),+ })),+ trace: Some(W3cTraceContext {+ traceparent: Some(traceparent.to_string()),+ tracestate: Some(tracestate.to_string()),+ }),+ }))+ .await?;++ control.wait_for_blocked_write(/*expected*/ 1).await?;+ control.grant_writes(/*count*/ 1);+ let first = read_outbound_frame(&mut outbound_rx).await?;+ assert_eq!(+ (first.traceparent.as_deref(), first.tracestate.as_deref()),+ (Some(traceparent), Some(tracestate))+ );+ let first_payload = first.into_data()?.payload;+ assert!(+ !first_payload+ .windows("fs/getMetadata".len())+ .any(|window| window == b"fs/getMetadata")+ );++ control.wait_for_blocked_write(/*expected*/ 2).await?;+ control.grant_writes(/*count*/ 1);+ let second = read_outbound_frame(&mut outbound_rx).await?;+ assert_eq!((second.traceparent, second.tracestate), (None, None));++ for task in &connection.task_handles {+ task.abort();+ }+ Ok(())+}+#[tokio::test(start_paused = true)]async fn fragmented_writes_yield_to_keepalive_and_queued_pong() -> Result<()> {let (connection, mut control, mut outbound_rx) = connected_controlled_harness().await?;@@ -240,6 +287,15 @@ async fn application_event_delivery_is_bounded() -> Result<()> {async fn read_outbound_data(outbound_rx: &mut futures_mpsc::UnboundedReceiver<Message>,) -> Result<RelayData> {+ read_outbound_frame(outbound_rx)+ .await?+ .into_data()+ .map_err(anyhow::Error::from)+}++async fn read_outbound_frame(+ outbound_rx: &mut futures_mpsc::UnboundedReceiver<Message>,+) -> Result<RelayMessageFrame> {let Message::Binary(payload) = timeout(Duration::from_secs(1), outbound_rx.next()).await?.context("harness closed before sending data")?@@ -248,7 +304,7 @@ async fn read_outbound_data(};let frame = decode_relay_message_frame(payload.as_ref())?;assert_eq!(frame.validate()?, RelayFrameBodyKind::Data);- frame.into_data().map_err(anyhow::Error::from)+ Ok(frame)}async fn connected_controlled_harness() -> Result<(diff --git a/codex-rs/exec-server/src/proto/codex.exec_server.relay.v1.proto b/codex-rs/exec-server/src/proto/codex.exec_server.relay.v1.protoindex 3de1bfbe99..a9d2100137 100644--- a/codex-rs/exec-server/src/proto/codex.exec_server.relay.v1.proto+++ b/codex-rs/exec-server/src/proto/codex.exec_server.relay.v1.proto@@ -16,6 +16,9 @@ message RelayMessageFrame {RelayHeartbeat heartbeat = 9;RelayHandshake handshake = 10;}++ optional string traceparent = 11;+ optional string tracestate = 12;}message RelayData {diff --git a/codex-rs/exec-server/src/proto/codex.exec_server.relay.v1.rs b/codex-rs/exec-server/src/proto/codex.exec_server.relay.v1.rsindex f65e1329f5..4694ed4024 100644--- a/codex-rs/exec-server/src/proto/codex.exec_server.relay.v1.rs+++ b/codex-rs/exec-server/src/proto/codex.exec_server.relay.v1.rs@@ -11,6 +11,10 @@ pub struct RelayMessageFrame {pub ack_bits: u32,#[prost(oneof = "relay_message_frame::Body", tags = "5, 6, 7, 8, 9, 10")]pub body: ::core::option::Option<relay_message_frame::Body>,+ #[prost(string, optional, tag = "11")]+ pub traceparent: ::core::option::Option<::prost::alloc::string::String>,+ #[prost(string, optional, tag = "12")]+ pub tracestate: ::core::option::Option<::prost::alloc::string::String>,}pub mod relay_message_frame {#[derive(Clone, PartialEq, ::prost::Oneof)]diff --git a/codex-rs/exec-server/src/relay.rs b/codex-rs/exec-server/src/relay.rsindex 3d0be695b4..82ef338c5f 100644--- a/codex-rs/exec-server/src/relay.rs+++ b/codex-rs/exec-server/src/relay.rs@@ -2,6 +2,7 @@ use std::collections::HashMap;use std::time::Duration;use codex_exec_server_protocol::JSONRPCMessage;+use codex_protocol::protocol::W3cTraceContext;use futures::Sink;use futures::SinkExt;use futures::Stream;@@ -81,18 +82,27 @@ pub(crate) enum RelayFrameBodyKind {}impl RelayMessageFrame {- pub(crate) fn data(stream_id: String, seq: u32, payload: Vec<u8>) -> Self {+ pub(crate) fn data(+ stream_id: String,+ seq: u32,+ payload: Vec<u8>,+ trace: Option<W3cTraceContext>,+ ) -> Self {+ let (traceparent, tracestate) = trace+ .map(|trace| (trace.traceparent, trace.tracestate))+ .unwrap_or_default();Self {version: RELAY_MESSAGE_FRAME_VERSION,stream_id,- ack: 0,- ack_bits: 0,+ traceparent,+ tracestate,body: Some(relay_message_frame::Body::Data(RelayData {seq,segment_index: 0,segment_count: 1,payload,})),+ ..Self::default()}}@@ -100,11 +110,10 @@ impl RelayMessageFrame {Self {version: RELAY_MESSAGE_FRAME_VERSION,stream_id,- ack: 0,- ack_bits: 0,body: Some(relay_message_frame::Body::Resume(RelayResume {next_seq: 0,})),+ ..Self::default()}}@@ -112,11 +121,10 @@ impl RelayMessageFrame {Self {version: RELAY_MESSAGE_FRAME_VERSION,stream_id,- ack: 0,- ack_bits: 0,body: Some(relay_message_frame::Body::Handshake(RelayHandshake {payload,})),+ ..Self::default()}}@@ -124,9 +132,8 @@ impl RelayMessageFrame {Self {version: RELAY_MESSAGE_FRAME_VERSION,stream_id,- ack: 0,- ack_bits: 0,body: Some(relay_message_frame::Body::Reset(RelayReset { reason })),+ ..Self::default()}}@@ -313,7 +320,13 @@ wherebreak;}};- let frame = RelayMessageFrame::data(stream_id.clone(), next_seq, payload);+ let trace = match message {+ JSONRPCMessage::Request(request) => request.trace,+ JSONRPCMessage::Notification(_)+ | JSONRPCMessage::Response(_)+ | JSONRPCMessage::Error(_) => None,+ };+ let frame = RelayMessageFrame::data(stream_id.clone(), next_seq, payload, trace);next_seq = next_seq.wrapping_add(1);if websocket.send(Message::Binary(encode_relay_message_frame(&frame).into()))@@ -961,6 +974,7 @@ mod tests {stream_id,/*seq*/ 0,jsonrpc_payload(&message)?,+ /*trace*/ None,)).into(),))diff --git a/codex-rs/exec-server/src/relay_noise_tests.rs b/codex-rs/exec-server/src/relay_noise_tests.rsindex 704c48d9a1..754c6e498c 100644--- a/codex-rs/exec-server/src/relay_noise_tests.rs+++ b/codex-rs/exec-server/src/relay_noise_tests.rs@@ -426,7 +426,7 @@ async fn repeated_early_data_during_validation_closes_the_physical_relay() -> Re)?;for frame in [RelayMessageFrame::handshake(stream_id.clone(), request),- RelayMessageFrame::data(stream_id, /*seq*/ 0, vec![0]),+ RelayMessageFrame::data(stream_id, /*seq*/ 0, vec![0], /*trace*/ None),] {harness_websocket.send(Message::Binary(encode_relay_message_frame(&frame).into()))