Lightweight coding agent that runs in your terminal
Rust
Harden diagnostic report uploads (#41569)
chessaaa7ed042eaa
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex 38a1b295a9..ba42adc6c2 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -3206,9 +3206,13 @@ name = "codex-feedback"version = "0.0.0"dependencies = ["anyhow",+ "bytes","codex-http-client","codex-login","codex-protocol",+ "flate2",+ "http 1.4.0",+ "httpdate","log","mime_guess","pretty_assertions",diff --git a/codex-rs/app-server/src/request_processors/feedback_processor.rs b/codex-rs/app-server/src/request_processors/feedback_processor.rsindex e6b8eef3a2..d2948c4ade 100644--- a/codex-rs/app-server/src/request_processors/feedback_processor.rs+++ b/codex-rs/app-server/src/request_processors/feedback_processor.rs@@ -185,6 +185,9 @@ impl FeedbackRequestProcessor {let mut attachment_paths = Vec::new();let mut seen_attachment_paths = HashSet::new();+ // File priority after logs and generated diagnostics: reported thread, subagent+ // descendants (oldest to newest within the retained recent set), guardian rollout,+ // sandbox log, tool caches, then caller files. Keep this order for size budgeting.if include_logs {for feedback_thread_id in &feedback_thread_ids {let Some(rollout_path) = selfdiff --git a/codex-rs/feedback/Cargo.toml b/codex-rs/feedback/Cargo.tomlindex 8a01696952..303cde11fe 100644--- a/codex-rs/feedback/Cargo.toml+++ b/codex-rs/feedback/Cargo.toml@@ -9,11 +9,16 @@ workspace = true[dependencies]anyhow = { workspace = true }+bytes = { workspace = true }codex-http-client = { workspace = true }codex-login = { workspace = true }codex-protocol = { workspace = true }+flate2 = { workspace = true }+http = { workspace = true }+httpdate = { workspace = true }mime_guess = { workspace = true }sentry = { version = "0.46" }+tokio = { workspace = true, features = ["time"] }tracing = { workspace = true }tracing-subscriber = { workspace = true }diff --git a/codex-rs/feedback/src/attachment_truncation.rs b/codex-rs/feedback/src/attachment_truncation.rsnew file mode 100644index 0000000000..ef8fc3dd7c--- /dev/null+++ b/codex-rs/feedback/src/attachment_truncation.rs@@ -0,0 +1,41 @@+use std::path::Path;++use anyhow::Context;+use anyhow::Result;++/// Shorten and label an attachment copy, leaving files within the target untouched.+/// JSONL keeps at least one complete record when a smaller record prefix is possible,+/// even if it exceeds the target. Callers must check the resulting upload size.+/// Other formats use a byte prefix.+pub(super) fn truncate_attachment(+ filename: &mut String,+ buffer: &mut Vec<u8>,+ target_bytes: usize,+) -> Result<()> {+ if buffer.len() <= target_bytes {+ return Ok(());+ }++ let end = match Path::new(filename)+ .extension()+ .and_then(|extension| extension.to_str())+ {+ Some(extension) if extension.eq_ignore_ascii_case("jsonl") => buffer[..target_bytes]+ .iter()+ .rposition(|byte| *byte == b'\n')+ .or_else(|| {+ buffer+ .iter()+ .position(|byte| *byte == b'\n')+ .filter(|end| *end + 1 < buffer.len())+ })+ .map(|end| end + 1)+ .context("feedback attachment cannot be shortened to a complete JSONL record")?,+ _ => target_bytes,+ };+ buffer.truncate(end);+ if !filename.starts_with("truncated-") {+ filename.insert_str(0, "truncated-");+ }+ Ok(())+}diff --git a/codex-rs/feedback/src/lib.rs b/codex-rs/feedback/src/lib.rsindex dad90f56a6..34f7b01b1a 100644--- a/codex-rs/feedback/src/lib.rs+++ b/codex-rs/feedback/src/lib.rs@@ -2,6 +2,7 @@ use std::collections::BTreeMap;use std::collections::VecDeque;use std::collections::btree_map::Entry;use std::fs;+use std::io::Read;use std::io::Write;use std::io::{self};use std::path::Path;@@ -29,10 +30,16 @@ use tracing_subscriber::filter::Targets;use tracing_subscriber::fmt::writer::MakeWriter;use tracing_subscriber::registry::LookupSpan;+mod attachment_truncation;pub(crate) mod feedback_diagnostics;+mod report_upload;+mod upload;pub use feedback_diagnostics::FEEDBACK_DIAGNOSTICS_ATTACHMENT_FILENAME;pub use feedback_diagnostics::FeedbackDiagnostic;pub use feedback_diagnostics::FeedbackDiagnostics;+pub use report_upload::FeedbackDelivery;+pub use report_upload::FeedbackTransport;+pub use report_upload::prepare_report_attachment;/// Filename used for the redacted `codex doctor --json` feedback attachment.pub const DOCTOR_REPORT_ATTACHMENT_FILENAME: &str = "codex-doctor-report.json";@@ -46,6 +53,15 @@ const DEFAULT_MAX_BYTES: usize = 4 * 1024 * 1024; // 4 MiBconst SENTRY_DSN: &str ="https://[email protected]/4510195390611458";const UPLOAD_TIMEOUT_SECS: u64 = 10;+// Raw collection budgets used by the report API, not the interactive upload.+pub const MAX_ATTACHMENT_BYTES: usize = 64 * 1024 * 1024;+pub const MAX_ATTACHMENTS_BYTES: usize = 126 * 1024 * 1024;+// Check complete envelopes against Sentry's published limits, including framing:+// https://develop.sentry.dev/sdk/foundations/envelopes/#size-limits+// https://docs.sentry.io/platforms/javascript/enriching-events/attachments/+const MAX_DECODED_UPLOAD_BYTES: usize = 200 * 1024 * 1024;+const MAX_EVENT_BYTES: usize = 1024 * 1024;+const MAX_UPLOAD_BYTES: usize = 40_000_000;const FEEDBACK_TAGS_TARGET: &str = "feedback_tags";const MAX_FEEDBACK_TAGS: usize = 64;@@ -370,6 +386,64 @@ pub struct FeedbackAttachmentPath {pub attachment_filename_override: Option<String>,}+enum AttachmentReadMode {+ Whole,+ Prefix,+}++impl FeedbackAttachmentPath {+ /// Read a whole regular file within the caller's size limit.+ pub fn read_attachment(&self, max_bytes: usize) -> io::Result<Option<FeedbackAttachment>> {+ self.read_attachment_with_mode(max_bytes, AttachmentReadMode::Whole)+ }++ fn read_attachment_with_mode(+ &self,+ max_bytes: usize,+ mode: AttachmentReadMode,+ ) -> io::Result<Option<FeedbackAttachment>> {+ let metadata = fs::metadata(&self.path)?;+ if !metadata.is_file()+ || (metadata.len() > max_bytes as u64 && matches!(mode, AttachmentReadMode::Whole))+ {+ return Ok(None);+ }+ let mut buffer = Vec::new();+ // Keep one extra byte so the encoder can detect and label a truncated prefix,+ // including when the file grows after the metadata check.+ fs::File::open(&self.path)?+ .take(max_bytes as u64 + 1)+ .read_to_end(&mut buffer)?;+ if buffer.len() > max_bytes && matches!(mode, AttachmentReadMode::Whole) {+ return Ok(None);+ }+ let filename = self+ .attachment_filename_override+ .clone()+ .unwrap_or_else(|| {+ self.path+ .file_name()+ .map(|name| name.to_string_lossy().to_string())+ .unwrap_or_else(|| "extra-log.log".to_string())+ });+ let content_type = match Path::new(&filename)+ .extension()+ .and_then(|extension| extension.to_str())+ {+ Some(extension) if extension.eq_ignore_ascii_case("jsonl") => "text/plain".to_string(),+ _ => mime_guess::from_path(&filename)+ .first_or_octet_stream()+ .essence_str()+ .to_string(),+ };+ Ok(Some(FeedbackAttachment {+ filename,+ content_type: Some(content_type),+ buffer,+ }))+ }+}+/// In-memory attachment to include in a feedback upload.////// Use this for generated diagnostics that should not be materialized on disk,@@ -407,6 +481,51 @@ pub struct FeedbackUploadOptions<'a> {}impl FeedbackSnapshot {+ fn feedback_event(+ &self,+ classification: &str,+ reason: Option<&str>,+ tags: Option<&BTreeMap<String, String>>,+ session_source: Option<&SessionSource>,+ ) -> sentry::protocol::Event<'static> {+ use sentry::protocol::Event;+ use sentry::protocol::Exception;+ use sentry::protocol::Level;+ use sentry::protocol::Values;++ let level = match classification {+ "bug" | "bad_result" | "safety_check" => Level::Error,+ _ => Level::Info,+ };+ let title = format!(+ "[{}]: Codex session {}",+ display_classification(classification),+ self.thread_id+ );+ let mut event = Event {+ level,+ message: Some(title.clone()),+ tags: self.upload_tags(classification, reason, tags, session_source),+ ..Default::default()+ };+ if let Some(reason) = reason {+ event.exception = Values::from(vec![Exception {+ ty: title,+ value: Some(reason.to_string()),+ ..Default::default()+ }]);+ }+ event+ }++ pub fn log_attachment(&self, logs_override: Option<Vec<u8>>) -> FeedbackAttachment {+ FeedbackAttachment {+ filename: "codex-logs.log".to_string(),+ content_type: Some("text/plain".to_string()),+ buffer: logs_override.unwrap_or_else(|| self.bytes.clone()),+ }+ }+pub fn feedback_diagnostics(&self) -> &FeedbackDiagnostics {&self.feedback_diagnostics}@@ -442,55 +561,48 @@ impl FeedbackSnapshot {) -> Result<()> {use std::str::FromStr;- use sentry::ClientOptions;use sentry::protocol::Envelope;use sentry::protocol::EnvelopeItem;- use sentry::protocol::Event;- use sentry::protocol::Level;use sentry::types::Dsn;let started_at = Instant::now();let dsn = Dsn::from_str(dsn).map_err(|error| anyhow!("invalid DSN: {error}"))?;- let upload_url = dsn.envelope_api_url();- let sentry_options = ClientOptions::default();- let sentry_auth = dsn.to_auth(Some(sentry_options.user_agent.as_ref()));- let tags = self.upload_tags(+ let event = self.feedback_event(options.classification,options.reason,options.tags,options.session_source.as_ref(),);-- let level = match options.classification {- "bug" | "bad_result" | "safety_check" => Level::Error,- _ => Level::Info,- };-let mut envelope = Envelope::new();- let title = format!(- "[{}]: Codex session {}",- display_classification(options.classification),- self.thread_id- );-- let mut event = Event {- level,- message: Some(title.clone()),- tags,- ..Default::default()- };- if let Some(r) = options.reason {- use sentry::protocol::Exception;- use sentry::protocol::Values;-- event.exception = Values::from(vec![Exception {- ty: title,- value: Some(r.to_string()),- ..Default::default()- }]);- }envelope.add_item(EnvelopeItem::Event(event));+ let (event_body, event_bytes) =+ upload::gzip_envelope(&envelope).context("failed to serialize feedback event")?;+ anyhow::ensure!(+ event_bytes <= MAX_EVENT_BYTES,+ "feedback event exceeds the size limit"+ );+ let headers = envelope.headers().clone();+ drop(envelope);+ let client_pool = RouteAwareClientPool::new_without_redirects_or_request_logging(+ http_client_factory.clone(),+ ClientRouteClass::Other,+ );+ // Acknowledge the report before reading diagnostic files. Keep one network wait+ // budget for the whole submission; file reads and compression do not consume it.+ let mut remaining_upload_time = Duration::from_secs(UPLOAD_TIMEOUT_SECS);+ let status = upload::send_gzip_envelope(+ &client_pool,+ &dsn,+ event_body,+ upload::EnvelopeKind::Event,+ &mut remaining_upload_time,+ )+ .await?;+ anyhow::ensure!(+ status.is_success(),+ "Sentry rejected feedback upload with HTTP status {status}"+ );let attachments = self.feedback_attachments(options.include_logs,@@ -498,74 +610,50 @@ impl FeedbackSnapshot {options.extra_attachment_paths,options.logs_override,);- let attachment_count = attachments.len();+ let mut uploaded_attachments = 0;+ let mut attachments_failed = false;+ // Keep attachments linked to the accepted event, without replaying its contents.for attachment in attachments {- envelope.add_item(EnvelopeItem::Attachment(attachment));+ if remaining_upload_time.is_zero() {+ attachments_failed = true;+ break;+ }+ let mut status = None;+ let result: Result<()> = async {+ let body = upload::gzip_attachment_envelope(&headers, attachment)?;+ let response_status = upload::send_gzip_envelope(+ &client_pool,+ &dsn,+ body,+ upload::EnvelopeKind::Attachment,+ &mut remaining_upload_time,+ )+ .await?;+ status = Some(response_status.as_u16());+ anyhow::ensure!(response_status.is_success(), "Sentry rejected attachment");+ Ok(())+ }+ .await;+ if result.is_ok() {+ uploaded_attachments += 1;+ } else {+ attachments_failed = true;+ // Keep trying other diagnostics before reporting the partial failure.+ tracing::warn!(status, "feedback attachment upload failed; continuing");+ }}-- let mut body = Vec::new();- envelope- .to_writer(&mut body)- .context("failed to serialize feedback upload")?;-tracing::info!(thread_id = %self.thread_id,- classification = options.classification,- include_logs = options.include_logs,- attachment_count,- payload_bytes = body.len(),- "uploading feedback to Sentry"+ uploaded_attachments,+ attachments_failed,+ elapsed_ms = started_at.elapsed().as_millis(),+ "feedback event uploaded to Sentry");-- let mut status = None;- let result: Result<()> = async {- let client_pool = RouteAwareClientPool::new_without_redirects(- http_client_factory.clone(),- ClientRouteClass::Other,- );- let response = client_pool- .post(upload_url.as_str())- .header("X-Sentry-Auth", sentry_auth.to_string())- .body(body)- .timeout(Duration::from_secs(UPLOAD_TIMEOUT_SECS))- .send()- .await- .context("failed to upload feedback to Sentry")?;- let response_status = response.status();- status = Some(response_status.as_u16());- response- .error_for_status()- .context("failed to upload feedback to Sentry")?;- anyhow::ensure!(- response_status.is_success(),- "Sentry rejected feedback upload with HTTP status {response_status}"- );- Ok(())- }- .await;-- match &result {- Ok(()) => tracing::info!(- thread_id = %self.thread_id,- classification = options.classification,- include_logs = options.include_logs,- status,- elapsed_ms = started_at.elapsed().as_millis(),- "feedback uploaded to Sentry"- ),- Err(error) => {- tracing::warn!(- thread_id = %self.thread_id,- classification = options.classification,- include_logs = options.include_logs,- status,- elapsed_ms = started_at.elapsed().as_millis(),- error = %format!("{error:#}"),- "feedback upload failed"- )- }- }- result+ anyhow::ensure!(+ !attachments_failed,+ "feedback report was accepted, but some attachments failed to upload"+ );+ Ok(())}fn upload_tags(@@ -617,85 +705,63 @@ impl FeedbackSnapshot {tags}- fn feedback_attachments(- &self,+ fn feedback_attachments<'a>(+ &'a self,include_logs: bool,- extra_attachments: &[FeedbackAttachment],- extra_attachment_paths: &[FeedbackAttachmentPath],+ extra_attachments: &'a [FeedbackAttachment],+ extra_attachment_paths: &'a [FeedbackAttachmentPath],logs_override: Option<Vec<u8>>,- ) -> Vec<sentry::protocol::Attachment> {+ ) -> impl Iterator<Item = sentry::protocol::Attachment> + 'a {use sentry::protocol::Attachment;- let mut attachments = Vec::new();-- if include_logs {- attachments.push(Attachment {- buffer: logs_override.unwrap_or_else(|| self.bytes.clone()),- filename: String::from("codex-logs.log"),- content_type: Some("text/plain".to_string()),- ty: None,- });- }-- attachments.extend(extra_attachments.iter().map(|attachment| Attachment {- buffer: attachment.buffer.clone(),- filename: attachment.filename.clone(),- content_type: attachment.content_type.clone(),- ty: None,- }));-- if let Some(text) = self.feedback_diagnostics_attachment_text(include_logs) {- attachments.push(Attachment {+ // Priority: logs, generated attachments (doctor report), connectivity diagnostics,+ // then files in caller order. Read and compress each file independently;+ // raw sizes across separate requests do not determine whether their gzip bodies fit.+ let logs = include_logs.then(|| self.log_attachment(logs_override));+ let diagnostics = self+ .feedback_diagnostics_attachment_text(include_logs)+ .map(|text| FeedbackAttachment {buffer: text.into_bytes(),filename: FEEDBACK_DIAGNOSTICS_ATTACHMENT_FILENAME.to_string(),content_type: Some("text/plain".to_string()),- ty: None,});- }- for attachment_path in extra_attachment_paths {- let data = match fs::read(&attachment_path.path) {- Ok(data) => data,- Err(err) => {- tracing::warn!(- path = %attachment_path.path.display(),- error = %err,- "failed to read log attachment; skipping"- );- continue;- }- };- let filename = attachment_path- .attachment_filename_override- .clone()- .unwrap_or_else(|| {- attachment_path- .path- .file_name()- .map(|s| s.to_string_lossy().to_string())- .unwrap_or_else(|| "extra-log.log".to_string())- });- let content_type = match Path::new(&filename)- .extension()- .and_then(|extension| extension.to_str())- {- Some(extension) if extension.eq_ignore_ascii_case("jsonl") => {- "text/plain".to_string()+ logs.into_iter()+ .chain(+ extra_attachments+ .iter()+ .map(|attachment| FeedbackAttachment {+ buffer: attachment.buffer.clone(),+ filename: attachment.filename.clone(),+ content_type: attachment.content_type.clone(),+ }),+ )+ .chain(diagnostics)+ .chain(extra_attachment_paths.iter().filter_map(|attachment_path| {+ match attachment_path+ .read_attachment_with_mode(MAX_DECODED_UPLOAD_BYTES, AttachmentReadMode::Prefix)+ {+ Ok(Some(attachment)) => Some(attachment),+ Ok(None) => {+ tracing::warn!("feedback attachment is not a regular file; skipping");+ None+ }+ Err(err) => {+ tracing::warn!(+ path = %attachment_path.path.display(),+ error = %err,+ "failed to read log attachment; skipping"+ );+ None+ }}- _ => mime_guess::from_path(&filename)- .first_or_octet_stream()- .essence_str()- .to_string(),- };- attachments.push(Attachment {- buffer: data,- filename,- content_type: Some(content_type),+ }))+ .map(|attachment| Attachment {+ buffer: attachment.buffer,+ filename: attachment.filename,+ content_type: attachment.content_type,ty: None,- });- }-- attachments+ })}}@@ -783,16 +849,21 @@ impl Visit for FeedbackTagsVisitor {mod tests {use std::ffi::OsStr;use std::fs;+ use std::sync::atomic::AtomicUsize;+ use std::sync::atomic::Ordering;use super::*;use crate::FeedbackDiagnostic;use codex_http_client::OutboundProxyPolicy;+ use flate2::read::GzDecoder;+ use http::StatusCode;use pretty_assertions::assert_eq;use tracing_subscriber::layer::SubscriberExt;use tracing_subscriber::util::SubscriberInitExt;use wiremock::Mock;use wiremock::MockServer;use wiremock::ResponseTemplate;+ use wiremock::matchers::header;use wiremock::matchers::header_exists;use wiremock::matchers::method;use wiremock::matchers::path;@@ -871,16 +942,21 @@ mod tests {pretty_assertions::assert_eq!(snap.tags.get("cached").map(String::as_str), Some("true"));}- async fn upload_test_feedback(feedback: &CodexFeedback, dsn: &str) -> Result<()> {+ async fn upload_test_feedback(+ feedback: &CodexFeedback,+ dsn: &str,+ extra_attachments: &[FeedbackAttachment],+ ) -> Result<()> {feedback.snapshot(/*session_id*/ None)+ .with_feedback_diagnostics(FeedbackDiagnostics::default()).upload_feedback_with_dsn(FeedbackUploadOptions {classification: "bug",reason: Some("private feedback"),tags: None,include_logs: true,- extra_attachments: &[],+ extra_attachments,extra_attachment_paths: &[],session_source: Some(SessionSource::Cli),logs_override: Some(b"private log contents".to_vec()),@@ -892,20 +968,258 @@ mod tests {}#[tokio::test]- async fn feedback_upload_waits_for_successful_sentry_response() {+ async fn feedback_upload_retries_diagnostics_without_replaying_core() {let server = MockServer::start().await;+ let attempt = AtomicUsize::default();Mock::given(method("POST")).and(path("/api/42/envelope/")).and(header_exists("X-Sentry-Auth"))- .respond_with(ResponseTemplate::new(200))- .expect(1)+ .and(header("Content-Encoding", "gzip"))+ .respond_with(move |_: &wiremock::Request| {+ match attempt.fetch_add(/*val*/ 1, Ordering::SeqCst) {+ // Accept the core once; accept logs only on their second attempt.+ 0 => ResponseTemplate::new(StatusCode::OK).insert_header(+ "X-Sentry-Rate-Limits",+ "0:attachment:project,60:transaction:project",+ ),+ 2 => ResponseTemplate::new(StatusCode::OK).insert_header("Retry-After", "0"),+ 6 => ResponseTemplate::new(StatusCode::OK)+ .insert_header("X-Sentry-Rate-Limits", "60:transaction:project"),+ 1 => ResponseTemplate::new(StatusCode::SERVICE_UNAVAILABLE)+ .insert_header("Retry-After", "2"),+ 5 => ResponseTemplate::new(StatusCode::SERVICE_UNAVAILABLE)+ .insert_header("Retry-After", "8"),+ _ => ResponseTemplate::new(StatusCode::SERVICE_UNAVAILABLE)+ .insert_header("Retry-After", "0"),+ }+ })+ .expect(/*r*/ 7).mount(&server).await;let dsn = format!("http://public@{}/42", server.address());- upload_test_feedback(&CodexFeedback::new(), &dsn)+ let attachments = ["retry-exhausted.txt", "later.txt"].map(|filename| FeedbackAttachment {+ filename: filename.to_string(),+ content_type: Some("text/plain".to_string()),+ buffer: filename.as_bytes().to_vec(),+ });+ let started = Instant::now();+ upload_test_feedback(&CodexFeedback::new(), &dsn, &attachments)+ .await+ .expect_err("legacy uploads report incomplete diagnostics");+ assert!(started.elapsed() >= Duration::from_secs(2));+ let requests = server.received_requests().await.unwrap();+ assert_eq!(requests[1].body, requests[2].body, "retry exact gzip bytes");+ // Exhausting one diagnostic must not delay later.txt or replay earlier files.+ assert!(+ requests[3..6]+ .iter()+ .all(|request| request.body == requests[3].body)+ );+ let mut decoded = String::new();+ GzDecoder::new(requests[1].body.as_slice())+ .read_to_string(&mut decoded)+ .unwrap();+ assert!(decoded.ends_with("private log contents\n"));+ }++ #[tokio::test]+ async fn feedback_upload_delivers_whole_files_or_marked_prefixes() {+ let suffix = ThreadId::new();+ let first_path = std::env::temp_dir().join(format!("feedback-first-{suffix}.jsonl"));+ let second_path = std::env::temp_dir().join(format!("feedback-second-{suffix}.jsonl"));+ let binary_path = std::env::temp_dir().join(format!("feedback-binary-{suffix}.bin"));+ let pending_path = second_path.with_extension("pending");+ let block = "{\"type\":\"event_msg\",\"payload\":{\"type\":\"agent_message\",\"message\":\"diagnostic fixture 🍵\"}}\n"+ .repeat(1024);+ let block_counts = [65, 205].map(|mib| mib * 1024 * 1024 / block.len() + 1);+ for (path, blocks) in [&first_path, &pending_path].into_iter().zip(block_counts) {+ let mut file = fs::File::create(path).unwrap();+ for _ in 0..blocks {+ file.write_all(block.as_bytes()).unwrap();+ }+ }+ // Repeats beyond gzip's 32 KiB window keep this fixture above the wire limit.+ let record_block = (0..4096)+ .flat_map(|_| sentry::types::Uuid::new_v4().into_bytes())+ .map(|byte| {+ b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"+ [usize::from(byte % 64)]+ })+ .collect::<Vec<_>>();+ let mut file = fs::File::create(&binary_path).unwrap();+ // The first record fits compressed, but exceeds the encoder's initial+ // half-file target. It must survive when this same file is sent as JSONL.+ for mib in [32, 30] {+ file.write_all(b"{\"message\":\"").unwrap();+ for _ in 0..mib * 1024 * 1024 / record_block.len() {+ file.write_all(&record_block).unwrap();+ }+ file.write_all(b"\"}\n").unwrap();+ }+ drop(file);++ let server = MockServer::start().await;+ let attempt = AtomicUsize::default();+ let ready_path = second_path.clone();+ Mock::given(method("POST"))+ .and(path("/api/42/envelope/"))+ .and(header("Content-Encoding", "gzip"))+ .respond_with(move |_: &wiremock::Request| {+ if attempt.fetch_add(/*val*/ 1, Ordering::SeqCst) == 1 {+ // The next file becomes readable only after the first file arrives.+ fs::rename(&pending_path, &ready_path).unwrap();+ }+ ResponseTemplate::new(StatusCode::OK)+ })+ .expect(/*r*/ 5)+ .mount(&server)+ .await;++ CodexFeedback::new()+ .snapshot(/*session_id*/ None)+ .upload_feedback_with_dsn(+ FeedbackUploadOptions {+ classification: "bug",+ reason: Some("large diagnostic upload"),+ tags: None,+ include_logs: false,+ extra_attachments: &[],+ extra_attachment_paths: &[+ FeedbackAttachmentPath {+ path: first_path.clone(),+ attachment_filename_override: None,+ },+ FeedbackAttachmentPath {+ path: second_path.clone(),+ attachment_filename_override: None,+ },+ FeedbackAttachmentPath {+ path: binary_path.clone(),+ attachment_filename_override: None,+ },+ FeedbackAttachmentPath {+ path: binary_path.clone(),+ attachment_filename_override: Some(format!(+ "feedback-records-{suffix}.jsonl"+ )),+ },+ ],+ session_source: Some(SessionSource::Cli),+ logs_override: None,+ },+ &HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault),+ &format!("http://public@{}/42", server.address()),+ ).await- .expect("successful Sentry response should complete feedback upload");+ .unwrap();+ let requests = server.received_requests().await.unwrap();+ assert_eq!(requests.len(), 5);+ let mut event = String::new();+ GzDecoder::new(requests[0].body.as_slice())+ .read_to_string(&mut event)+ .unwrap();+ for (request, (filename, source_path)) in requests[1..].iter().zip([+ (format!("feedback-first-{suffix}.jsonl"), &first_path),+ (+ format!("truncated-feedback-second-{suffix}.jsonl"),+ &second_path,+ ),+ (+ format!("truncated-feedback-binary-{suffix}.bin"),+ &binary_path,+ ),+ (+ format!("truncated-feedback-records-{suffix}.jsonl"),+ &binary_path,+ ),+ ]) {+ assert!(request.body.len() <= MAX_UPLOAD_BYTES);+ let mut decoded = Vec::new();+ GzDecoder::new(request.body.as_slice())+ .read_to_end(&mut decoded)+ .unwrap();+ assert!(decoded.len() <= MAX_DECODED_UPLOAD_BYTES);+ let mut parts = decoded.splitn(3, |byte| *byte == b'\n');+ assert_eq!(+ parts.next().unwrap(),+ event.lines().next().unwrap().as_bytes()+ );+ let header = std::str::from_utf8(parts.next().unwrap()).unwrap();+ assert!(header.contains(&format!("\"filename\":\"{filename}\"")));+ let payload = parts.next().unwrap().strip_suffix(b"\n").unwrap();+ let mut source = fs::File::open(source_path).unwrap();+ let original_bytes = source.metadata().unwrap().len() as usize;+ if filename.starts_with("truncated-") {+ assert!(!payload.is_empty() && payload.len() < original_bytes);+ } else {+ assert_eq!(payload.len(), original_bytes);+ }+ if filename.ends_with(".jsonl") {+ let text = std::str::from_utf8(payload).unwrap();+ assert!(text.ends_with('\n'));+ }+ let mut expected = [0; 64 * 1024];+ for chunk in payload.chunks(expected.len()) {+ source.read_exact(&mut expected[..chunk.len()]).unwrap();+ assert_eq!(chunk, &expected[..chunk.len()]);+ }+ }+ fs::remove_file(first_path).unwrap();+ fs::remove_file(second_path).unwrap();+ fs::remove_file(binary_path).unwrap();+ }++ #[tokio::test]+ async fn feedback_upload_stops_diagnostics_for_sentry_rate_limits() {+ for (accepted_before_limit, rate_limit) in [+ (1, ResponseTemplate::new(StatusCode::TOO_MANY_REQUESTS)),+ (+ 1,+ ResponseTemplate::new(StatusCode::TOO_MANY_REQUESTS)+ .insert_header("X-Sentry-Rate-Limits", "60:attachment:project")+ .insert_header("Retry-After", "0"),+ ),+ (+ 0,+ ResponseTemplate::new(StatusCode::OK)+ .insert_header("X-Sentry-Rate-Limits", "60:attachment:project"),+ ),+ (+ 1,+ ResponseTemplate::new(StatusCode::OK)+ .insert_header("X-Sentry-Rate-Limits", "60::project"),+ ),+ (+ 0,+ ResponseTemplate::new(StatusCode::OK).insert_header("Retry-After", "60"),+ ),+ ] {+ let server = MockServer::start().await;+ let attempt = AtomicUsize::default();+ Mock::given(method("POST"))+ .and(path("/api/42/envelope/"))+ .respond_with(move |_: &wiremock::Request| {+ if attempt.fetch_add(/*val*/ 1, Ordering::SeqCst) < accepted_before_limit {+ ResponseTemplate::new(StatusCode::OK)+ } else {+ rate_limit.clone()+ }+ })+ .expect((accepted_before_limit + 1) as u64)+ .mount(&server)+ .await;++ let dsn = format!("http://public@{}/42", server.address());+ let later = FeedbackAttachment {+ filename: "later.txt".to_string(),+ content_type: None,+ buffer: b"later diagnostic".to_vec(),+ };+ upload_test_feedback(&CodexFeedback::new(), &dsn, &[later])+ .await+ .expect_err("legacy uploads report rate-limited diagnostics");+ }}#[tokio::test]@@ -921,7 +1235,7 @@ mod tests {let feedback = CodexFeedback::new();let dsn = format!("http://public@{}/42", server.address());- let error = upload_test_feedback(&feedback, &dsn)+ let error = upload_test_feedback(&feedback, &dsn, &[]).await.expect_err("rejected Sentry responses must fail feedback uploads");@@ -944,7 +1258,7 @@ mod tests {.mount(&sentry_server).await;let dsn = format!("http://public@{}/42", sentry_server.address());- let error = upload_test_feedback(&CodexFeedback::new(), &dsn)+ let error = upload_test_feedback(&CodexFeedback::new(), &dsn, &[]).await.expect_err("redirected feedback uploads must be rejected");@@ -968,7 +1282,7 @@ mod tests {drop(listener);let dsn = format!("http://public@{address}/42");- let error = upload_test_feedback(&CodexFeedback::new(), &dsn)+ let error = upload_test_feedback(&CodexFeedback::new(), &dsn, &[]).await.expect_err("transport failures must fail feedback uploads");@@ -997,16 +1311,18 @@ mod tests {details: vec!["HTTPS_PROXY = https://example.com:443".to_string()],}]));- let attachments_with_diagnostics = snapshot_with_diagnostics.feedback_attachments(- /*include_logs*/ true,- &[FeedbackAttachment {- filename: DOCTOR_REPORT_ATTACHMENT_FILENAME.to_string(),- content_type: Some("application/json".to_string()),- buffer: b"{\"overallStatus\":\"ok\"}".to_vec(),- }],- std::slice::from_ref(&extra_attachment_path),- Some(vec![1]),- );+ let attachments_with_diagnostics = snapshot_with_diagnostics+ .feedback_attachments(+ /*include_logs*/ true,+ &[FeedbackAttachment {+ filename: DOCTOR_REPORT_ATTACHMENT_FILENAME.to_string(),+ content_type: Some("application/json".to_string()),+ buffer: b"{\"overallStatus\":\"ok\"}".to_vec(),+ }],+ &[extra_attachment_path],+ Some(vec![1]),+ )+ .collect::<Vec<_>>();assert_eq!(attachments_with_diagnostics@@ -1041,7 +1357,8 @@ mod tests {let attachments_without_diagnostics = CodexFeedback::new().snapshot(/*session_id*/ None).with_feedback_diagnostics(FeedbackDiagnostics::default())- .feedback_attachments(/*include_logs*/ true, &[], &[], Some(vec![1]));+ .feedback_attachments(/*include_logs*/ true, &[], &[], Some(vec![1]))+ .collect::<Vec<_>>();assert_eq!(attachments_without_diagnostics@@ -1082,7 +1399,8 @@ mod tests {},],/*logs_override*/ None,- );+ )+ .collect::<Vec<_>>();fs::remove_file(gzip_path).expect("gzip attachment should be removed");fs::remove_file(unknown_path).expect("unknown attachment should be removed");diff --git a/codex-rs/feedback/src/report_upload.rs b/codex-rs/feedback/src/report_upload.rsnew file mode 100644index 0000000000..1410832c7e--- /dev/null+++ b/codex-rs/feedback/src/report_upload.rs@@ -0,0 +1,155 @@+use std::collections::BTreeMap;+use std::time::Duration;++use anyhow::Context;+use anyhow::Result;+use anyhow::anyhow;+use codex_http_client::ClientRouteClass;+use codex_http_client::HttpClientFactory;+use codex_http_client::RouteAwareClientPool;+use codex_protocol::protocol::SessionSource;+use http::StatusCode;+use sentry::protocol::Attachment;+use sentry::protocol::Envelope;+use sentry::protocol::EnvelopeHeaders;+use sentry::protocol::EnvelopeItem;+use sentry::types::Dsn;+use sentry::types::Uuid;++use crate::FeedbackAttachment;+use crate::FeedbackSnapshot;+use crate::MAX_DECODED_UPLOAD_BYTES;+use crate::MAX_EVENT_BYTES;+use crate::MAX_UPLOAD_BYTES;+use crate::SENTRY_DSN;+use crate::upload;++// Background parts must tolerate slow links without inheriting the interactive+// upload's ten-second budget. The report API can cancel the request at any time.+const REPORT_PART_UPLOAD_TIMEOUT: Duration = Duration::from_secs(/*secs*/ 300);++/// The upstream HTTP result, not proof of durable storage in Sentry.+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub enum FeedbackDelivery {+ Accepted {+ retry_after: Option<Duration>,+ },+ Rejected {+ status: u16,+ retry_after: Option<Duration>,+ },+ /// No response was received. The upstream may still have accepted the envelope.+ Unconfirmed,+}++/// Sends persisted report parts without retries or request diagnostics.+pub struct FeedbackTransport {+ client_pool: RouteAwareClientPool,+ dsn: Dsn,+}++impl FeedbackTransport {+ pub fn new(http_client_factory: HttpClientFactory) -> Result<Self> {+ Ok(Self {+ client_pool: RouteAwareClientPool::new_without_redirects_or_request_logging(+ http_client_factory,+ ClientRouteClass::Other,+ ),+ dsn: SENTRY_DSN+ .parse()+ .map_err(|_| anyhow!("invalid feedback DSN"))?,+ })+ }++ /// Make one attempt. Callers own retry decisions and must retain the same bytes.+ pub async fn send(&self, envelope: Vec<u8>) -> FeedbackDelivery {+ let response = upload::gzip_envelope_request(+ &self.client_pool,+ &self.dsn,+ envelope.into(),+ REPORT_PART_UPLOAD_TIMEOUT,+ )+ .send()+ .await;+ let Ok(response) = response else {+ return FeedbackDelivery::Unconfirmed;+ };+ let status = response.status();+ let headers = response.headers();+ let mut retry_after = headers+ .get_all("Retry-After")+ .iter()+ .map(|value| {+ upload::parse_retry_after(value.to_str().unwrap_or_default())+ .unwrap_or(upload::DEFAULT_RATE_LIMIT)+ })+ .max();+ // Report events and attachments share one conservative cooldown. Honor quotas on+ // successful responses too; ignore quotas for unrelated Sentry categories.+ // https://develop.sentry.dev/sdk/foundations/transport/rate-limiting/+ retry_after = retry_after.max(upload::sentry_rate_limit_delay(headers));+ if status == StatusCode::TOO_MANY_REQUESTS && retry_after.is_none() {+ retry_after = Some(upload::DEFAULT_RATE_LIMIT);+ }+ if status.is_success() {+ FeedbackDelivery::Accepted { retry_after }+ } else {+ FeedbackDelivery::Rejected {+ status: status.as_u16(),+ retry_after,+ }+ }+ }+}++impl FeedbackSnapshot {+ /// Prepare only the core report, using the caller's stable UUID as its Sentry event ID.+ pub fn prepare_report_event(+ &self,+ report_id: &str,+ classification: &str,+ reason: Option<&str>,+ tags: Option<&BTreeMap<String, String>>,+ session_source: Option<&SessionSource>,+ ) -> Result<Vec<u8>> {+ let mut event = self.feedback_event(classification, reason, tags, session_source);+ // Auth tags must come from this report's caller, not metadata retained+ // from an earlier account in the process-wide tracing layer.+ event.tags.retain(|key, _| {+ !matches!(key.as_str(), "account_id" | "chatgpt_user_id")+ || tags.is_some_and(|tags| tags.contains_key(key))+ });+ event.event_id =+ Uuid::parse_str(report_id).map_err(|_| anyhow!("invalid feedback report ID"))?;+ let mut envelope = Envelope::new();+ envelope.add_item(EnvelopeItem::Event(event));+ prepare_envelope(envelope, MAX_EVENT_BYTES)+ }+}++/// Prepare one whole attachment linked to an existing report, without replaying its event.+/// The caller must apply consent and the report's cumulative attachment budget first.+pub fn prepare_report_attachment(+ report_id: &str,+ attachment: FeedbackAttachment,+) -> Result<Vec<u8>> {+ let event_id = Uuid::parse_str(report_id).map_err(|_| anyhow!("invalid feedback report ID"))?;+ let mut envelope = Envelope::new().with_headers(EnvelopeHeaders::new().with_event_id(event_id));+ envelope.add_item(EnvelopeItem::Attachment(Attachment {+ buffer: attachment.buffer,+ filename: attachment.filename,+ content_type: attachment.content_type,+ ty: None,+ }));+ prepare_envelope(envelope, MAX_DECODED_UPLOAD_BYTES)+}++fn prepare_envelope(envelope: Envelope, max_decoded_bytes: usize) -> Result<Vec<u8>> {+ let (bytes, decoded_bytes) =+ upload::gzip_envelope(&envelope).context("failed to serialize feedback envelope")?;+ anyhow::ensure!(+ bytes.len() <= MAX_UPLOAD_BYTES && decoded_bytes <= max_decoded_bytes,+ "feedback envelope exceeds the size limit"+ );+ Ok(bytes)+}diff --git a/codex-rs/feedback/src/upload.rs b/codex-rs/feedback/src/upload.rsnew file mode 100644index 0000000000..c617e84a5b--- /dev/null+++ b/codex-rs/feedback/src/upload.rs@@ -0,0 +1,236 @@+use std::io;+use std::io::Write;+use std::time::Duration;+use std::time::Instant;+use std::time::SystemTime;++use anyhow::Context;+use anyhow::Result;+use bytes::Bytes;+use codex_http_client::RouteAwareClientPool;+use codex_http_client::RouteAwareRequestBuilder;+use flate2::Compression;+use flate2::write::GzEncoder;+use http::HeaderMap;+use http::StatusCode;+use sentry::ClientOptions;+use sentry::protocol::Attachment;+use sentry::protocol::Envelope;+use sentry::protocol::EnvelopeHeaders;+use sentry::types::Dsn;++use crate::MAX_DECODED_UPLOAD_BYTES;+use crate::MAX_UPLOAD_BYTES;+use crate::attachment_truncation::truncate_attachment;++pub(super) const DEFAULT_RATE_LIMIT: Duration = Duration::from_secs(/*secs*/ 60);++pub(super) enum EnvelopeKind {+ Event,+ Attachment,+}++pub(super) fn gzip_envelope_request(+ client_pool: &RouteAwareClientPool,+ dsn: &Dsn,+ body: Bytes,+ timeout: Duration,+) -> RouteAwareRequestBuilder {+ let sentry_options = ClientOptions::default();+ let sentry_auth = dsn.to_auth(Some(sentry_options.user_agent.as_ref()));+ client_pool+ .post(dsn.envelope_api_url().as_str())+ .header("X-Sentry-Auth", sentry_auth.to_string())+ .header("Content-Encoding", "gzip")+ .body(body)+ .timeout(timeout)+}++/// Send an already-serialized envelope, charging requests and backoff to the shared budget.+pub(super) async fn send_gzip_envelope(+ client_pool: &RouteAwareClientPool,+ dsn: &Dsn,+ body: Vec<u8>,+ kind: EnvelopeKind,+ remaining_upload_time: &mut Duration,+) -> Result<StatusCode> {+ let request_started_at = Instant::now();+ let body = Bytes::from(body);+ // Retain the exact gzip bytes for at most two diagnostic retries. Never replay the core.+ let mut retry_delays = [250, 500].map(Duration::from_millis).into_iter();+ let response = loop {+ let timeout = remaining_upload_time.saturating_sub(request_started_at.elapsed());+ if timeout.is_zero() {+ *remaining_upload_time = Duration::ZERO;+ anyhow::bail!("feedback upload network wait budget exhausted");+ }+ let response = gzip_envelope_request(client_pool, dsn, body.clone(), timeout)+ .send()+ .await;+ if response.as_ref().is_ok_and(|response| {+ sentry_rate_limit_delay(response.headers()).is_some_and(|delay| !delay.is_zero())+ || (response.status().is_success()+ && response.headers().get("Retry-After").is_some_and(|value| {+ parse_retry_after(value.to_str().unwrap_or_default())+ .is_none_or(|delay| !delay.is_zero())+ }))+ }) {+ // Even accepted requests can impose a quota on events or attachments.+ // https://develop.sentry.dev/sdk/foundations/transport/rate-limiting/+ *remaining_upload_time = Duration::ZERO;+ break response;+ }+ let retryable = match &response {+ Ok(response) => matches!(response.status().as_u16(), 408 | 429 | 500..=599),+ Err(error) => {+ error.is_timeout()+ || (error.failure_class().is_none()+ && (error.is_connect() || error.is_request() || error.is_body()))+ }+ };+ if matches!(kind, EnvelopeKind::Event) || !retryable {+ break response;+ }+ let retry_delay = retry_delays.next();+ if response.as_ref().is_ok_and(|response| {+ response.status() == StatusCode::TOO_MANY_REQUESTS+ && (retry_delay.is_none() || !response.headers().contains_key("Retry-After"))+ }) {+ // Bare 429s default to a cooldown longer than this upload budget.+ // Never let later files bypass an exhausted rate limit.+ *remaining_upload_time = Duration::ZERO;+ break response;+ }+ let Some(retry_delay) = retry_delay else {+ break response;+ };+ let retry_after = response+ .as_ref()+ .ok()+ .and_then(|response| response.headers().get("Retry-After"))+ .map(|value| {+ // An invalid cooldown is not permission to send immediately.+ parse_retry_after(value.to_str().unwrap_or_default())+ .unwrap_or(*remaining_upload_time)+ });+ let delay = retry_delay.max(retry_after.unwrap_or_default());+ if delay >= remaining_upload_time.saturating_sub(request_started_at.elapsed()) {+ // The cooldown applies to later files too, not just this retry.+ *remaining_upload_time = Duration::ZERO;+ break response;+ }+ tokio::time::sleep(delay).await;+ if request_started_at.elapsed() >= *remaining_upload_time {+ break response;+ }+ };+ *remaining_upload_time = remaining_upload_time.saturating_sub(request_started_at.elapsed());+ response+ .map(|response| response.status())+ .context("failed to upload feedback to Sentry")+}++pub(super) fn sentry_rate_limit_delay(headers: &HeaderMap) -> Option<Duration> {+ let mut retry_after = None;+ for value in headers.get_all("X-Sentry-Rate-Limits") {+ for quota in value.to_str().unwrap_or_default().split(',') {+ let mut fields = quota.trim().split(':');+ let seconds = fields.next().unwrap_or_default();+ let categories = fields.next().unwrap_or_default();+ if !categories.is_empty()+ && !categories+ .split(';')+ .any(|category| matches!(category, "error" | "attachment"))+ {+ continue;+ }+ let delay = seconds+ .parse::<f64>()+ .ok()+ .and_then(|seconds| Duration::try_from_secs_f64(seconds.ceil()).ok())+ .unwrap_or(DEFAULT_RATE_LIMIT);+ retry_after = retry_after.max(Some(delay));+ }+ }+ retry_after+}++pub(super) fn parse_retry_after(value: &str) -> Option<Duration> {+ value+ .parse::<u64>()+ .map(Duration::from_secs)+ .or_else(|_| {+ httpdate::parse_http_date(value)+ .map(|date| date.duration_since(SystemTime::now()).unwrap_or_default())+ })+ .ok()+}++pub(super) fn gzip_envelope(envelope: &Envelope) -> io::Result<(Vec<u8>, usize)> {+ let mut writer = CountingWriter {+ inner: GzEncoder::new(Vec::new(), Compression::fast()),+ bytes: 0,+ };+ envelope.to_writer(&mut writer)?;+ Ok((writer.inner.finish()?, writer.bytes))+}++pub(super) fn gzip_attachment_envelope(+ headers: &EnvelopeHeaders,+ mut attachment: Attachment,+) -> Result<Vec<u8>> {+ let envelope = Envelope::new().with_headers(headers.clone());+ // Apply the file reader's bound to in-memory attachments too. The extra byte+ // lets the format-aware truncation below detect and label a shortened copy.+ attachment.buffer.truncate(MAX_DECODED_UPLOAD_BYTES + 1);+ let mut target_bytes = MAX_DECODED_UPLOAD_BYTES;+ loop {+ truncate_attachment(+ &mut attachment.filename,+ &mut attachment.buffer,+ target_bytes,+ )?;+ let mut writer = CountingWriter {+ inner: GzEncoder::new(Vec::new(), Compression::fast()),+ bytes: 0,+ };+ // Use the SDK's framing while retaining the buffer for in-place truncation.+ // https://github.com/getsentry/sentry-rust/blob/0.46.1/sentry-types/src/protocol/envelope.rs#L453-L487+ envelope.to_writer(&mut writer)?;+ attachment.to_writer(&mut writer)?;+ writeln!(writer)?;+ let decoded_bytes = writer.bytes;+ let body = writer.inner.finish()?;+ if body.len() <= MAX_UPLOAD_BYTES && decoded_bytes <= MAX_DECODED_UPLOAD_BYTES {+ return Ok(body);+ }+ anyhow::ensure!(+ !attachment.buffer.is_empty(),+ "feedback attachment headers exceed the size limit"+ );+ target_bytes = attachment+ .buffer+ .len()+ .saturating_sub(decoded_bytes.saturating_sub(MAX_DECODED_UPLOAD_BYTES));+ if body.len() > MAX_UPLOAD_BYTES {+ target_bytes /= 2;+ }+ }+}++struct CountingWriter<W> {+ inner: W,+ bytes: usize,+}++impl<W: Write> Write for CountingWriter<W> {+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {+ let written = self.inner.write(buf)?;+ self.bytes += written;+ Ok(written)+ }++ fn flush(&mut self) -> io::Result<()> {+ self.inner.flush()+ }+}