apollo_infra: replace error JSON field with message in trace logs

Author: victorkstarkware

crates/apollo_infra/src/trace_util.rs

@@ -1,3 +1,4 @@
+use std::io::{Result as IoResult, Write};
 use std::str::FromStr;
 
 use time::macros::format_description;
@@ -9,6 +10,37 @@ use tracing_subscriber::fmt::time::UtcTime;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, reload, EnvFilter};
 
+// Renames the "error" key to "message" in a JSON object, if present.
+// If "message" already exists, leaves the object unchanged.
+pub(crate) fn rename_error_to_message(buf: &[u8]) -> Option<Vec<u8>> {
+    let mut obj: serde_json::Map<String, serde_json::Value> = serde_json::from_slice(buf).ok()?;
+    if !obj.contains_key("message") {
+        if let Some(v) = obj.remove("error") {
+            obj.insert("message".into(), v);
+        }
+    }
+    let mut out = serde_json::to_vec(&obj).ok()?;
+    out.push(b'\n');
+    Some(out)
+}
+
+// Wraps any writer to rename the "error" JSON key to "message" in log output.
+// This is used because #[instrument(...,err)] emits errors in the "error" field.
+struct ErrorToMessageWriter<W>(W);
+
+impl<W: Write> Write for ErrorToMessageWriter<W> {
+    fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
+        let len = buf.len();
+        let output = rename_error_to_message(buf).unwrap_or_else(|| buf.to_vec());
+        self.0.write_all(&output)?;
+        Ok(len)
+    }
+
+    fn flush(&mut self) -> IoResult<()> {
+        self.0.flush()
+    }
+}
+
 // Crates we always keep at INFO regardless of operator-supplied spec.
 const QUIET_LIBS: &[&str] = &[
     "alloy_provider",
@@ -47,6 +79,7 @@ pub async fn configure_tracing() -> ReloadHandle {
 
             let fmt_layer = fmt::layer()
                 .json()
+                .map_writer(|w| move || ErrorToMessageWriter(w()))
                 .with_timer(timer)
                 .with_target(false) // No module name.
                 // Instead, file name and line number.

crates/apollo_infra/src/trace_util_tests.rs

@@ -1,7 +1,7 @@
 use tracing::metadata::LevelFilter;
 use tracing_subscriber::{reload, EnvFilter};
 
-use crate::trace_util::{get_log_directives, set_log_level, ReloadHandle};
+use crate::trace_util::{get_log_directives, rename_error_to_message, set_log_level, ReloadHandle};
 
 #[test]
 fn log_level_directive_updates() {
@@ -16,3 +16,57 @@ fn log_level_directive_updates() {
     let directives = get_log_directives(&reload_handle).unwrap();
     assert_eq!(directives, "b=debug,a=info,info");
 }
+
+#[test]
+fn rename_error_to_message_renames_error_key() {
+    let input = br#"{"level":"ERROR","error":"something failed","file":"test.rs"}"#;
+    let output = rename_error_to_message(input).unwrap();
+    let output_str = String::from_utf8(output).unwrap();
+
+    assert!(output_str.contains(r#""message":"something failed""#), "got: {output_str}");
+    assert!(!output_str.contains(r#""error""#), "got: {output_str}");
+}
+
+#[test]
+fn rename_error_to_message_preserves_other_fields() {
+    let input = br#"{"level":"INFO","status":"ok","count":42}"#;
+    let output = rename_error_to_message(input).unwrap();
+    let output_str = String::from_utf8(output).unwrap();
+
+    assert!(output_str.contains(r#""level":"INFO""#), "got: {output_str}");
+    assert!(output_str.contains(r#""status":"ok""#), "got: {output_str}");
+    assert!(output_str.contains(r#""count":42"#), "got: {output_str}");
+}
+
+#[test]
+fn rename_error_to_message_returns_none_for_invalid_json() {
+    let input = b"not valid json";
+    assert!(rename_error_to_message(input).is_none());
+}
+
+#[test]
+fn rename_error_to_message_only_renames_root_level_error() {
+    // Nested "error" fields should NOT be renamed - only root level
+    let input = br#"{"error":"root error","nested":{"error":"nested error"}}"#;
+    let output = rename_error_to_message(input).unwrap();
+    let parsed: serde_json::Value = serde_json::from_slice(&output).unwrap();
+
+    // Root "error" should be renamed to "message"
+    assert_eq!(parsed["message"], "root error");
+    assert!(parsed.get("error").is_none(), "root 'error' should be removed");
+
+    // Nested "error" should remain unchanged
+    assert_eq!(parsed["nested"]["error"], "nested error");
+}
+
+#[test]
+fn rename_error_to_message_preserves_existing_message_field() {
+    // If both "error" and "message" exist, leave the object unchanged
+    let input = br#"{"error":"the error","message":"original message"}"#;
+    let output = rename_error_to_message(input).unwrap();
+    let parsed: serde_json::Value = serde_json::from_slice(&output).unwrap();
+
+    // Both fields should remain unchanged
+    assert_eq!(parsed["message"], "original message");
+    assert_eq!(parsed["error"], "the error");
+}