Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

logging: restore debug capture parity

Raine Virtaf73599981469
diff --git a/README.md b/README.md
index f1b557c..3045353 100644
--- a/README.md
+++ b/README.md
@@ -630,9 +630,9 @@ Windows, and at
| `PORT` | `port` | `18765` | Proxy listen port |
| `CCP_CONFIG_DIR` | unset | platform config dir | Per-process config directory; Cursor auth uses it for file storage |
| `XDG_STATE_HOME` | — | `~/.local/state` | Linux/macOS base dir for `proxy.log` |
-| `CCP_LOG_STDERR` | `log.stderr` | unset | Also mirror log lines to stderr |
-| `CCP_LOG_VERBOSE` | `log.verbose` | unset | Log full request/response bodies + every SSE event |
-| `CCP_TRAFFIC_LOG` | — | unset | Write per-request traffic captures under `traffic/` for session debugging |
+| `CCP_LOG_STDERR` | `log.stderr` | unset | Also mirror log lines to stderr; any env value enables it |
+| `CCP_LOG_VERBOSE` | `log.verbose` | unset | Preserve full string fields in `proxy.log`; any env value enables it |
+| `CCP_TRAFFIC_LOG` | — | unset | Write full per-request traffic captures under `traffic/` for session debugging (`1`, `true`, or `yes`) |
| `CCP_ALIAS_PROVIDER` | `aliasProvider` | `codex` | Route Anthropic-style aliases (`haiku`, `sonnet`, `opus`, `claude-*`) through `codex` or `kimi` |
| `CCP_KIMI_OAUTH_HOST` | `kimi.oauthHost` | `https://auth.kimi.com` | Override Kimi's OAuth host (debugging only) |
| `CCP_KIMI_BASE_URL` | `kimi.baseUrl` | `https://api.kimi.com/coding/v1` | Override Kimi's API base URL |
@@ -686,6 +686,8 @@ sticky sessions or shared state before enabling continuation.
sequence numbers so sorted filenames preserve emission order. Token and
account headers are redacted, but prompt and tool content are intentionally
preserved for debugging.
+ For the most complete debugging run, use `CCP_LOG_STDERR=1 CCP_LOG_VERBOSE=1
+ CCP_TRAFFIC_LOG=1`.
- `config.json` — optional configuration file (see table above). It lives at
`~/.config/claude-code-proxy/config.json` on macOS,
`${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/config.json` on Linux,
diff --git a/src/config.rs b/src/config.rs
index f06df4e..376b073 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -93,14 +93,6 @@ fn parse_alias(raw: &str) -> Option<AliasProvider> {
}
}
-fn parse_bool_raw(raw: &str) -> Option<bool> {
- match raw.to_ascii_lowercase().as_str() {
- "1" | "true" | "yes" => Some(true),
- "0" | "false" | "no" => Some(false),
- _ => None,
- }
-}
-
fn read_file_config(config_dir: &Path) -> Option<FileConfig> {
let path = config_dir.join("config.json");
let raw = fs::read_to_string(path).ok()?;
@@ -140,10 +132,8 @@ pub fn load_config() -> LoadedConfig {
out.port = port;
}
- if let Some(raw) = env.get("CCP_LOG_VERBOSE") {
- if let Some(value) = parse_bool_raw(raw) {
- out.log_verbose = value;
- }
+ if env.contains_key("CCP_LOG_VERBOSE") {
+ out.log_verbose = true;
} else if let Some(value) = file
.as_ref()
.and_then(|f| f.log.as_ref().and_then(|v| v.verbose))
@@ -151,10 +141,8 @@ pub fn load_config() -> LoadedConfig {
out.log_verbose = value;
}
- if let Some(raw) = env.get("CCP_LOG_STDERR") {
- if let Some(value) = parse_bool_raw(raw) {
- out.log_stderr = value;
- }
+ if env.contains_key("CCP_LOG_STDERR") {
+ out.log_stderr = true;
} else if let Some(value) = file
.as_ref()
.and_then(|f| f.log.as_ref().and_then(|v| v.stderr))
@@ -506,6 +494,35 @@ mod tests {
fn clear_env() {
unsafe {
std::env::remove_var("CCP_CODEX_TRANSPORT");
+ std::env::remove_var("CCP_CONFIG_DIR");
+ std::env::remove_var("CCP_LOG_VERBOSE");
+ std::env::remove_var("CCP_LOG_STDERR");
+ }
+ }
+
+ struct EnvGuard {
+ key: &'static str,
+ previous: Option<std::ffi::OsString>,
+ }
+
+ impl EnvGuard {
+ fn set(key: &'static str, value: impl AsRef<std::ffi::OsStr>) -> Self {
+ let previous = std::env::var_os(key);
+ unsafe {
+ std::env::set_var(key, value);
+ }
+ Self { key, previous }
+ }
+ }
+
+ impl Drop for EnvGuard {
+ fn drop(&mut self) {
+ unsafe {
+ match self.previous.take() {
+ Some(value) => std::env::set_var(self.key, value),
+ None => std::env::remove_var(self.key),
+ }
+ }
}
}
@@ -576,4 +593,35 @@ mod tests {
assert_eq!(CodexTransport::WebSocket.as_str(), "websocket");
assert_eq!(CodexTransport::Auto.as_str(), "auto");
}
+
+ #[test]
+ fn log_env_presence_enables_legacy_verbose_and_stderr() {
+ let _guard = ENV_LOCK.lock().unwrap();
+ clear_env();
+ let config = tempfile::TempDir::new().unwrap();
+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
+ let _verbose_env = EnvGuard::set("CCP_LOG_VERBOSE", "0");
+ let _stderr_env = EnvGuard::set("CCP_LOG_STDERR", "");
+
+ let loaded = load_config();
+ assert!(loaded.log_verbose);
+ assert!(loaded.log_stderr);
+ }
+
+ #[test]
+ fn log_config_values_apply_without_env() {
+ let _guard = ENV_LOCK.lock().unwrap();
+ clear_env();
+ let config = tempfile::TempDir::new().unwrap();
+ std::fs::write(
+ config.path().join("config.json"),
+ r#"{"log":{"verbose":true,"stderr":true}}"#,
+ )
+ .unwrap();
+ let _config_env = EnvGuard::set("CCP_CONFIG_DIR", config.path());
+
+ let loaded = load_config();
+ assert!(loaded.log_verbose);
+ assert!(loaded.log_stderr);
+ }
}
diff --git a/src/logging.rs b/src/logging.rs
index fa69891..e8ea24b 100644
--- a/src/logging.rs
+++ b/src/logging.rs
@@ -162,8 +162,8 @@ fn redact_with_depth(value: Value, depth: u8) -> Value {
Value::String(s) => {
if config::log_verbose() {
Value::String(s)
- } else if s.len() > 1000 {
- Value::String(format!("{}…[{} more]", &s[..1000], s.len() - 1000))
+ } else if s.len() > 4000 {
+ Value::String(format!("{}…[{} more]", &s[..4000], s.len() - 4000))
} else {
Value::String(s)
}
diff --git a/src/server.rs b/src/server.rs
index 8bf57c1..aba25f5 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,5 +1,6 @@
use crate::{
anthropic::json_error,
+ logging::{Logger, REDACT_KEYS, create_logger},
provider::RequestContext,
registry::{Registry, normalize_incoming_model},
session::{self, SessionState},
@@ -14,8 +15,9 @@ use axum::{
routing::{get, post},
};
use serde::de::DeserializeOwned;
-use serde_json::json;
+use serde_json::{Map, Value, json};
use std::sync::Arc;
+use std::time::Instant;
use tokio::net::TcpListener;
use uuid::Uuid;
@@ -25,6 +27,20 @@ pub struct ServerConfig {
pub async fn serve(config: ServerConfig) -> anyhow::Result<()> {
let listener = TcpListener::bind(("127.0.0.1", config.port)).await?;
+ create_logger("server").info(
+ "server listening",
+ Some(serde_json::Map::from_iter([
+ ("port".to_string(), json!(config.port)),
+ (
+ "logDir".to_string(),
+ json!(
+ crate::paths::log_file()
+ .parent()
+ .map(|path| path.display().to_string())
+ ),
+ ),
+ ])),
+ );
let app = app(Arc::new(Registry::with_default_alias()));
axum::serve(listener, app).await?;
Ok(())
@@ -59,33 +75,74 @@ async fn dispatch_request(
req: Request<Body>,
count_tokens: bool,
) -> Response {
+ let started_at = Instant::now();
+ let log = create_logger("server");
+ let req_id = Uuid::new_v4().to_string();
+ let method = req.method().clone();
+ let uri = req.uri().clone();
+ let headers = req.headers().clone();
+ let path = uri.path().to_string();
+ let query = redacted_query(&uri);
+ log.info(
+ "request",
+ Some(serde_json::Map::from_iter([
+ ("reqId".to_string(), json!(&req_id)),
+ ("method".to_string(), json!(method.as_str())),
+ ("path".to_string(), json!(&path)),
+ ("query".to_string(), json!(&query)),
+ ])),
+ );
let session_id = req
.headers()
.get("x-claude-code-session-id")
.and_then(|value| value.to_str().ok())
.map(std::string::ToString::to_string);
- let req_id = Uuid::new_v4().to_string();
let now = current_millis();
let body_bytes = match axum::body::to_bytes(req.into_body(), usize::MAX).await {
Ok(bytes) => bytes,
Err(err) => {
- return json_error(
+ let response = json_error(
StatusCode::BAD_REQUEST,
"invalid_request_error",
format!("Invalid JSON: {err}"),
);
+ log_request_completed(
+ &log,
+ RequestLogContext {
+ req_id: &req_id,
+ provider: None,
+ model: None,
+ count_tokens,
+ status: response.status(),
+ started_at,
+ },
+ );
+ return response;
}
};
let body: crate::anthropic::schema::MessagesRequest = match parse_json_body(&body_bytes) {
Ok(body) => body,
- Err(response) => return *response,
+ Err(response) => {
+ log_request_completed(
+ &log,
+ RequestLogContext {
+ req_id: &req_id,
+ provider: None,
+ model: None,
+ count_tokens,
+ status: response.status(),
+ started_at,
+ },
+ );
+ return *response;
+ }
};
let model = match body.model.as_deref() {
Some(model) => model,
None => {
- return json_error(
+ let response = json_error(
StatusCode::BAD_REQUEST,
"invalid_request_error",
format!(
@@ -93,6 +150,18 @@ async fn dispatch_request(
registry.unknown_model_message()
),
);
+ log_request_completed(
+ &log,
+ RequestLogContext {
+ req_id: &req_id,
+ provider: None,
+ model: None,
+ count_tokens,
+ status: response.status(),
+ started_at,
+ },
+ );
+ return response;
}
};
@@ -113,7 +182,14 @@ async fn dispatch_request(
let provider = match provider {
Some(provider) => provider,
None => {
- return json_error(
+ log.warn(
+ "unknown model",
+ Some(serde_json::Map::from_iter([
+ ("reqId".to_string(), json!(&req_id)),
+ ("model".to_string(), json!(&normalized_model)),
+ ])),
+ );
+ let response = json_error(
StatusCode::BAD_REQUEST,
"invalid_request_error",
format!(
@@ -121,6 +197,18 @@ async fn dispatch_request(
registry.unknown_model_message()
),
);
+ log_request_completed(
+ &log,
+ RequestLogContext {
+ req_id: &req_id,
+ provider: None,
+ model: Some(&normalized_model),
+ count_tokens,
+ status: response.status(),
+ started_at,
+ },
+ );
+ return response;
}
};
@@ -145,11 +233,16 @@ async fn dispatch_request(
capture.write_json(
"000-metadata",
&json!({
- "reqId": req_id,
- "sessionId": session_id,
+ "reqId": &req_id,
+ "sessionId": &session_id,
"sessionSeq": current.as_ref().map(|s| s.seq),
+ "kind": if count_tokens { "count_tokens" } else { "messages" },
"provider": provider.name(),
- "model": normalized_model,
+ "model": &normalized_model,
+ "method": method.as_str(),
+ "path": &path,
+ "query": &query,
+ "headers": headers_to_record(&headers),
}),
);
capture.write_json(
@@ -159,18 +252,84 @@ async fn dispatch_request(
}
let context = RequestContext {
- req_id,
+ req_id: req_id.clone(),
session_id,
session_seq: current.map(|s| s.seq),
provider: provider.name().to_string(),
traffic,
};
- if count_tokens {
+ let response = if count_tokens {
provider.handle_count_tokens(body, context).await
} else {
provider.handle_messages(body, context).await
+ };
+ log_request_completed(
+ &log,
+ RequestLogContext {
+ req_id: &req_id,
+ provider: Some(provider.name()),
+ model: Some(&normalized_model),
+ count_tokens,
+ status: response.status(),
+ started_at,
+ },
+ );
+ response
+}
+
+struct RequestLogContext<'a> {
+ req_id: &'a str,
+ provider: Option<&'a str>,
+ model: Option<&'a str>,
+ count_tokens: bool,
+ status: StatusCode,
+ started_at: Instant,
+}
+
+fn log_request_completed(log: &Logger, ctx: RequestLogContext<'_>) {
+ log.info(
+ "request_completed",
+ Some(serde_json::Map::from_iter([
+ ("reqId".to_string(), json!(ctx.req_id)),
+ ("provider".to_string(), json!(ctx.provider)),
+ ("model".to_string(), json!(ctx.model)),
+ ("countTokens".to_string(), json!(ctx.count_tokens)),
+ ("status".to_string(), json!(ctx.status.as_u16())),
+ (
+ "ms".to_string(),
+ json!(ctx.started_at.elapsed().as_millis()),
+ ),
+ ])),
+ );
+}
+
+fn headers_to_record(headers: &http::HeaderMap) -> Value {
+ let mut out = Map::new();
+ for (key, value) in headers {
+ if let Ok(raw) = value.to_str() {
+ out.insert(key.as_str().to_string(), Value::String(raw.to_string()));
+ }
+ }
+ Value::Object(out)
+}
+
+fn redacted_query(uri: &http::Uri) -> Value {
+ let mut out = Map::new();
+ let Some(query) = uri.query() else {
+ return Value::Object(out);
+ };
+ for (key, value) in url::form_urlencoded::parse(query.as_bytes()) {
+ let key = key.into_owned();
+ let lower = key.to_lowercase();
+ let value = if REDACT_KEYS.contains(&lower.as_str()) {
+ Value::String(format!("[redacted len={}]", value.len()))
+ } else {
+ Value::String(value.into_owned())
+ };
+ out.insert(key, value);
}
+ Value::Object(out)
}
fn parse_json_body<T>(body: &[u8]) -> Result<T, Box<Response>>
diff --git a/src/traffic.rs b/src/traffic.rs
index 7b875cd..132325b 100644
--- a/src/traffic.rs
+++ b/src/traffic.rs
@@ -71,7 +71,12 @@ impl TrafficCapture {
}
pub fn write_text(&self, name: &str, text: &str) {
- let path = self.next_artifact_path(name, false);
+ let file = if name.ends_with(".txt") {
+ name.to_string()
+ } else {
+ format!("{name}.txt")
+ };
+ let path = self.next_artifact_path(&file, false);
let _ = write_bytes(path, text.as_bytes());
}
diff --git a/tests/foundation.rs b/tests/foundation.rs
index 7d028a1..dd044fc 100644
--- a/tests/foundation.rs
+++ b/tests/foundation.rs
@@ -111,7 +111,7 @@ fn logging_redaction_and_truncation() {
let long = "a".repeat(5000);
let long_payload = redact_value(json!({"text": long}));
let text = long_payload["text"].as_str().unwrap();
- assert!(text.contains("[4000 more]"));
+ assert!(text.contains("[1000 more]"));
}
#[test]