feat(logging): add sensitive diagnostic log preference

Author: limityan

src/apps/desktop/src/logging.rs

@@ -5,12 +5,12 @@ use chrono::Local;
 use serde::Serialize;
 use std::path::PathBuf;
 use std::sync::{
-    atomic::{AtomicU8, Ordering},
     OnceLock,
+    atomic::{AtomicU8, Ordering},
 };
 use std::thread;
-use tauri::{plugin::TauriPlugin, Runtime};
-use tauri_plugin_log::{fern, RotationStrategy, Target, TargetKind, TimezoneStrategy};
+use tauri::{Runtime, plugin::TauriPlugin};
+use tauri_plugin_log::{RotationStrategy, Target, TargetKind, TimezoneStrategy, fern};
 
 const SESSION_DIR_PATTERN: &str = r"^\d{8}T\d{6}$";
 const MAX_LOG_SESSIONS: usize = 10;
@@ -309,6 +309,17 @@ pub fn build_log_plugin<R: Runtime>(log_targets: Vec<Target>) -> TauriPlugin<R>
         .level_for("opentelemetry_sdk", log::LevelFilter::Off)
         .level_for("opentelemetry-otlp", log::LevelFilter::Off)
         .level_for("notify", log::LevelFilter::Off)
+        // These targets can emit hot-path trace diagnostics during event
+        // routing. Keep debug diagnostics, warnings, and errors, but avoid
+        // drowning useful app traces in mechanical noise.
+        .level_for(
+            "bitfun_core::agentic::events::queue",
+            log::LevelFilter::Debug,
+        )
+        .level_for(
+            "bitfun_core::agentic::events::router",
+            log::LevelFilter::Debug,
+        )
         .level_for("hyper_util", log::LevelFilter::Info)
         .level_for("h2", log::LevelFilter::Info)
         .level_for("portable_pty", log::LevelFilter::Info)

src/crates/ai-adapters/src/diagnostics.rs

@@ -0,0 +1,27 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+
+static INCLUDE_SENSITIVE_DIAGNOSTICS: AtomicBool = AtomicBool::new(true);
+
+pub fn set_include_sensitive_diagnostics(enabled: bool) {
+    INCLUDE_SENSITIVE_DIAGNOSTICS.store(enabled, Ordering::Relaxed);
+}
+
+pub fn include_sensitive_diagnostics() -> bool {
+    INCLUDE_SENSITIVE_DIAGNOSTICS.load(Ordering::Relaxed)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{include_sensitive_diagnostics, set_include_sensitive_diagnostics};
+
+    #[test]
+    fn sensitive_diagnostics_can_be_toggled() {
+        set_include_sensitive_diagnostics(true);
+        assert!(include_sensitive_diagnostics());
+
+        set_include_sensitive_diagnostics(false);
+        assert!(!include_sensitive_diagnostics());
+
+        set_include_sensitive_diagnostics(true);
+    }
+}

src/crates/ai-adapters/src/lib.rs

@@ -1,6 +1,7 @@
 #![doc = include_str!("../README.md")]
 
 pub mod client;
+pub mod diagnostics;
 pub mod providers;
 pub mod stream;
 pub mod tool_call_accumulator;
@@ -9,7 +10,7 @@ pub mod types;
 pub use client::{AIClient, StreamOptions, StreamResponse};
 pub use stream::{UnifiedResponse, UnifiedTokenUsage, UnifiedToolCall};
 pub use types::{
-    resolve_request_url, AIConfig, ConnectionTestMessageCode, ConnectionTestResult, GeminiResponse,
-    GeminiUsage, Message, ProxyConfig, ReasoningMode, RemoteModelInfo, ToolCall, ToolDefinition,
-    ToolImageAttachment,
+    AIConfig, ConnectionTestMessageCode, ConnectionTestResult, GeminiResponse, GeminiUsage,
+    Message, ProxyConfig, ReasoningMode, RemoteModelInfo, ToolCall, ToolDefinition,
+    ToolImageAttachment, resolve_request_url,
 };

src/crates/ai-adapters/src/providers/shared.rs

@@ -1,7 +1,7 @@
+use crate::client::AIClient;
 use crate::client::utils::{
     build_request_body_subset, is_trim_custom_request_body_mode, merge_json_value,
 };
-use crate::client::AIClient;
 use reqwest::RequestBuilder;
 
 pub(crate) fn apply_header_policy<F>(
@@ -104,12 +104,175 @@ pub(crate) fn log_extra_body_keys(
     );
 }
 
+pub(crate) fn summarize_request_body_for_log(
+    request_body: &serde_json::Value,
+) -> serde_json::Value {
+    let mut summary = serde_json::Map::new();
+
+    if let Some(model) = request_body
+        .get("model")
+        .and_then(serde_json::Value::as_str)
+    {
+        summary.insert(
+            "model".to_string(),
+            serde_json::Value::String(model.to_string()),
+        );
+    }
+    if let Some(stream) = request_body
+        .get("stream")
+        .and_then(serde_json::Value::as_bool)
+    {
+        summary.insert("stream".to_string(), serde_json::Value::Bool(stream));
+    }
+    if let Some(max_tokens) = request_body
+        .get("max_tokens")
+        .and_then(|value| value.as_u64())
+    {
+        summary.insert(
+            "max_tokens".to_string(),
+            serde_json::Value::Number(max_tokens.into()),
+        );
+    }
+    if let Some(tool_stream) = request_body
+        .get("tool_stream")
+        .and_then(serde_json::Value::as_bool)
+    {
+        summary.insert(
+            "tool_stream".to_string(),
+            serde_json::Value::Bool(tool_stream),
+        );
+    }
+    if let Some(system) = request_body
+        .get("system")
+        .and_then(serde_json::Value::as_str)
+    {
+        summary.insert(
+            "system_chars".to_string(),
+            serde_json::Value::Number((system.chars().count() as u64).into()),
+        );
+    }
+    if let Some(messages) = request_body
+        .get("messages")
+        .and_then(serde_json::Value::as_array)
+    {
+        summary.insert(
+            "message_count".to_string(),
+            serde_json::Value::Number((messages.len() as u64).into()),
+        );
+        summary.insert(
+            "messages".to_string(),
+            serde_json::Value::Array(messages.iter().map(summarize_message_for_log).collect()),
+        );
+    }
+    if let Some(tools) = request_body
+        .get("tools")
+        .and_then(serde_json::Value::as_array)
+    {
+        summary.insert(
+            "tool_count".to_string(),
+            serde_json::Value::Number((tools.len() as u64).into()),
+        );
+    }
+    if let Some(object) = request_body.as_object() {
+        let mut top_level_keys = object.keys().cloned().collect::<Vec<_>>();
+        top_level_keys.sort();
+        summary.insert(
+            "top_level_keys".to_string(),
+            serde_json::Value::Array(
+                top_level_keys
+                    .into_iter()
+                    .map(serde_json::Value::String)
+                    .collect(),
+            ),
+        );
+    }
+
+    serde_json::Value::Object(summary)
+}
+
+fn summarize_message_for_log(message: &serde_json::Value) -> serde_json::Value {
+    let mut summary = serde_json::Map::new();
+    let content = message.get("content");
+
+    if let Some(role) = message.get("role").and_then(serde_json::Value::as_str) {
+        summary.insert(
+            "role".to_string(),
+            serde_json::Value::String(role.to_string()),
+        );
+    }
+    if let Some(content) = content {
+        summary.insert(
+            "content_chars".to_string(),
+            serde_json::Value::Number((content_text_chars(content) as u64).into()),
+        );
+        if let Some(items) = content.as_array() {
+            summary.insert(
+                "content_items".to_string(),
+                serde_json::Value::Number((items.len() as u64).into()),
+            );
+            let mut content_types = items
+                .iter()
+                .filter_map(|item| item.get("type").and_then(serde_json::Value::as_str))
+                .map(str::to_string)
+                .collect::<Vec<_>>();
+            content_types.sort();
+            content_types.dedup();
+            if !content_types.is_empty() {
+                summary.insert(
+                    "content_types".to_string(),
+                    serde_json::Value::Array(
+                        content_types
+                            .into_iter()
+                            .map(serde_json::Value::String)
+                            .collect(),
+                    ),
+                );
+            }
+        }
+    }
+
+    serde_json::Value::Object(summary)
+}
+
+fn content_text_chars(content: &serde_json::Value) -> usize {
+    if let Some(text) = content.as_str() {
+        return text.chars().count();
+    }
+
+    content
+        .as_array()
+        .map(|items| {
+            items
+                .iter()
+                .filter_map(|item| item.get("text").and_then(serde_json::Value::as_str))
+                .map(|text| text.chars().count())
+                .sum()
+        })
+        .unwrap_or(0)
+}
+
+fn should_log_full_request_body(include_sensitive_diagnostics: bool) -> bool {
+    include_sensitive_diagnostics
+}
+
 pub(crate) fn log_request_body(target: &str, label: &str, request_body: &serde_json::Value) {
+    if should_log_full_request_body(crate::diagnostics::include_sensitive_diagnostics()) {
+        log::debug!(
+            target: target,
+            "{}\n{}",
+            label,
+            serde_json::to_string_pretty(request_body)
+                .unwrap_or_else(|_| "serialization failed".to_string())
+        );
+        return;
+    }
+
+    let summary_label = label.trim_end_matches(':');
     log::debug!(
         target: target,
-        "{}\n{}",
-        label,
-        serde_json::to_string_pretty(request_body)
+        "{} summary:\n{}",
+        summary_label,
+        serde_json::to_string_pretty(&summarize_request_body_for_log(request_body))
             .unwrap_or_else(|_| "serialization failed".to_string())
     );
 }
@@ -146,3 +309,50 @@ pub(crate) fn collect_function_declaration_names_or_object_keys(
             .collect()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::should_log_full_request_body;
+    use super::summarize_request_body_for_log;
+
+    #[test]
+    fn request_body_log_summary_keeps_shape_without_message_contents() {
+        let request_body = serde_json::json!({
+            "model": "kimi-k2.6",
+            "stream": true,
+            "max_tokens": 32000,
+            "system": "secret system context",
+            "messages": [
+                { "role": "user", "content": "secret user message" },
+                {
+                    "role": "assistant",
+                    "content": [
+                        { "type": "text", "text": "secret assistant message" },
+                        { "type": "tool_use", "id": "tool-1", "name": "Read" }
+                    ]
+                }
+            ]
+        });
+
+        let summary = summarize_request_body_for_log(&request_body);
+        let summary_text = serde_json::to_string(&summary).unwrap();
+
+        assert!(!summary_text.contains("secret system context"));
+        assert!(!summary_text.contains("secret user message"));
+        assert!(!summary_text.contains("secret assistant message"));
+        assert_eq!(summary["model"], "kimi-k2.6");
+        assert_eq!(summary["stream"], true);
+        assert_eq!(summary["max_tokens"], 32000);
+        assert_eq!(summary["system_chars"], 21);
+        assert_eq!(summary["message_count"], 2);
+        assert_eq!(summary["messages"][0]["role"], "user");
+        assert_eq!(summary["messages"][0]["content_chars"], 19);
+        assert_eq!(summary["messages"][1]["content_items"], 2);
+    }
+
+    #[test]
+    fn request_body_logging_keeps_full_payload_when_sensitive_diagnostics_are_enabled() {
+        assert!(should_log_full_request_body(true));
+        assert!(!should_log_full_request_body(false));
+    }
+}