From c18a7ccee5d96d5faf10f757e9d0d2527ec90ec3 Mon Sep 17 00:00:00 2001 From: OverloadedTech Date: Tue, 17 Nov 2026 16:51:44 +0100 Subject: [PATCH] fix: send server logs as JSONRPC log notifications (Fixes #571) Since #314, `pet server` wrote tracing output to stderr with ANSI colors instead of sending `log` notifications, so the Python Environments extension showed every warning as an [error] line full of escape codes. The CLI also kept the colors when stderr was redirected to a file. --- crates/pet/src/jsonrpc.rs | 52 ++++++++++++++++++++++--- crates/pet/src/lib.rs | 3 +- crates/pet/tests/cli_test.rs | 23 +++++++++++ crates/pet/tests/jsonrpc_server_test.rs | 32 +++++++++++++++ 4 files changed, 104 insertions(+), 6 deletions(-) diff --git a/crates/pet/src/jsonrpc.rs b/crates/pet/src/jsonrpc.rs index 6dc5f2bd..7daadd8f 100644 --- a/crates/pet/src/jsonrpc.rs +++ b/crates/pet/src/jsonrpc.rs @@ -6,7 +6,6 @@ use pet::find::find_and_report_envs; use pet::find::find_python_environments_in_workspace_folder_recursive; use pet::find::identify_python_executables_using_locators; use pet::find::SearchScope; -use pet::initialize_tracing; use pet::locators::create_locators; use pet::resolve::resolve_environment; use pet_conda::Conda; @@ -27,7 +26,7 @@ use pet_fs::glob::{ }; use pet_fs::path::norm_case; use pet_jsonrpc::{ - send_error, send_reply, + send_error, send_message, send_reply, server::{start_server, HandlersKeyedByMethodName}, RequestId, }; @@ -52,7 +51,9 @@ use std::{ thread, time::{Instant, SystemTime}, }; +use tracing::field::{Field, Visit}; use tracing::info_span; +use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter, Layer}; #[derive(Debug, Clone, Default)] struct ConfigurationState { @@ -559,10 +560,51 @@ const MISSING_ENVS_COMPLETED: u64 = u64::MAX - 1; static MISSING_ENVS_REPORTING_STATE: AtomicU64 = AtomicU64::new(MISSING_ENVS_AVAILABLE); static NEXT_REFRESH_ID: AtomicU64 = AtomicU64::new(1); +/// Sends tracing events (including `log` records) to the client as `log` notifications, +/// so they keep their level instead of being written to stderr. +struct LogNotificationLayer; + +impl Layer for LogNotificationLayer { + fn on_event( + &self, + event: &tracing::Event<'_>, + _ctx: tracing_subscriber::layer::Context<'_, S>, + ) { + let level = match *event.metadata().level() { + tracing::Level::ERROR => jsonrpc::LogLevel::Error, + tracing::Level::WARN => jsonrpc::LogLevel::Warning, + tracing::Level::INFO => jsonrpc::LogLevel::Info, + _ => jsonrpc::LogLevel::Debug, + }; + let mut visitor = LogMessageVisitor::default(); + event.record(&mut visitor); + let payload = jsonrpc::Log { + message: visitor.message, + level, + }; + send_message("log", payload.into()); + } +} + +#[derive(Default)] +struct LogMessageVisitor { + message: String, +} + +impl Visit for LogMessageVisitor { + fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) { + if field.name() == "message" { + self.message = format!("{value:?}"); + } + } +} + pub fn start_jsonrpc_server() -> std::io::Result<()> { - // Initialize tracing for performance profiling (controlled by RUST_LOG env var) - // Note: This includes log compatibility, so we don't call jsonrpc::initialize_logger - initialize_tracing(false); + // Log level is controlled by the RUST_LOG env var (warn by default). + tracing_subscriber::registry() + .with(EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("warn"))) + .with(LogNotificationLayer) + .init(); // These are globals for the the lifetime of the server. // Hence passed around as Arcs via the context. diff --git a/crates/pet/src/lib.rs b/crates/pet/src/lib.rs index 532de84f..02ac0c92 100644 --- a/crates/pet/src/lib.rs +++ b/crates/pet/src/lib.rs @@ -18,7 +18,7 @@ use pet_reporter::{self, cache::CacheReporter, collect, stdio}; use resolve::resolve_environment; use serde::Serialize; use std::path::PathBuf; -use std::{collections::BTreeMap, env, sync::Arc, time::SystemTime}; +use std::{collections::BTreeMap, env, io::IsTerminal, sync::Arc, time::SystemTime}; use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter}; pub mod find; @@ -58,6 +58,7 @@ pub fn initialize_tracing(verbose: bool) { fmt::layer() .with_target(true) .with_timer(fmt::time::uptime()) + .with_ansi(std::io::stderr().is_terminal()) .with_writer(std::io::stderr), ) .init(); diff --git a/crates/pet/tests/cli_test.rs b/crates/pet/tests/cli_test.rs index fd7e0cda..25277ebb 100644 --- a/crates/pet/tests/cli_test.rs +++ b/crates/pet/tests/cli_test.rs @@ -360,3 +360,26 @@ fn find_environment_directories_via_env_var() { let json: Value = serde_json::from_slice(&output.stdout).expect("output is not valid JSON"); assert!(json["environments"].is_array()); } + +/// Test 9: log output written to a non-terminal stderr has no ANSI escape codes. +#[cfg_attr(feature = "ci", test)] +#[allow(dead_code)] +fn stderr_logs_have_no_ansi_codes_when_redirected() { + let temp_dir = tempfile::tempdir().expect("failed to create temp dir"); + let missing = temp_dir.path().join("missing-python"); + + let output = Command::new(env!("CARGO_BIN_EXE_pet")) + .args(["resolve", missing.to_string_lossy().as_ref()]) + .output() + .expect("failed to run pet resolve"); + + let stderr = String::from_utf8_lossy(&output.stderr); + assert!( + stderr.contains("Unknown Python Env"), + "expected a warning on stderr, got: {stderr}" + ); + assert!( + !stderr.contains('\u{1b}'), + "stderr contains ANSI escape codes: {stderr:?}" + ); +} diff --git a/crates/pet/tests/jsonrpc_server_test.rs b/crates/pet/tests/jsonrpc_server_test.rs index 054d29b4..2e632283 100644 --- a/crates/pet/tests/jsonrpc_server_test.rs +++ b/crates/pet/tests/jsonrpc_server_test.rs @@ -101,6 +101,15 @@ impl RawRpcClient { } fn receive(&self) -> Value { + loop { + let message = self.receive_message(); + if message["method"] != "log" { + return message; + } + } + } + + fn receive_message(&self) -> Value { self.responses .recv_timeout(Duration::from_secs(10)) .expect("PET must respond within ten seconds") @@ -363,6 +372,29 @@ fn missing_and_invalid_request_ids_have_distinct_wire_behavior() { assert_eq!(client.receive()["id"], "after-invalid"); } +#[test] +fn server_logs_are_sent_as_log_notifications() { + let mut client = RawRpcClient::spawn(); + client.send(json!({ + "jsonrpc": "2.0", + "id": "invalid-resolve", + "method": "resolve", + "params": {"executable": 42} + })); + + let log = client.receive_message(); + assert_eq!( + log["method"], "log", + "expected a log notification, got {log}" + ); + assert_eq!(log["params"]["level"], "error"); + assert!(log["params"]["message"] + .as_str() + .unwrap() + .starts_with("Failed to parse resolve")); + assert_rpc_error(&client.receive(), &json!("invalid-resolve"), -4); +} + fn create_fake_workspace(prompt: &str) -> (TempDir, PathBuf, PathBuf) { let temp_dir = tempfile::tempdir().expect("failed to create temp directory"); let workspace = temp_dir.path().join("workspace");