feat(logs): capture request/response payloads and redesign log viewer

Backend:
- Extend request_logs schema with method, path, request_headers,
  request_body, response_headers, response_body (SQLite + Postgres
  migrations via ensure_request_log_column / ALTER TABLE IF NOT EXISTS)
- Capture ingress method/path/headers/body across universal, gemini and
  embeddings proxy entrypoints; aggregate final JSON for streaming
  responses and persist as response_body
- Emit logs on all early-exit error paths (decode failure, no route,
  auth failure, upstream error, cache miss fallbacks) with full context
- Cache-hit paths now include complete request/response bodies
- Embeddings proxy: log every success/error branch and parse
  usage.prompt_tokens into input_tokens
- Split API: query_logs list strips heavy fields (NULL bodies/headers);
  new get_log(id) endpoint fetches full payload on demand
- Settings: DEFAULT_RETENTION_DAYS 30 -> 7, batch size 64 -> 32,
  cleanup interval 60s -> 600s; new log_record_payloads toggle
  (default true) to disable payload persistence

Frontend:
- Compact 7-column log list (Time / Status / Model / Protocol /
  Latency / Token / Type), left-aligned, row click opens detail
- New LogDetailDialog with meta header and four copy-enabled payload
  blocks (request headers/body, response headers/body) using lazy
  get_log fetch and pretty-printed JSON
- Token display with IN/OUT labels and K/M formatting
  (<1000 raw, <1M 1-decimal K, >=1M 2-decimal M)
- Type badge: green SSE / sky JSON replaces boolean stream column
- Settings: split Log Configuration into its own half-width card next
  to Proxy Configuration; rename to "Retention Period" + "Record
  Payloads" with HelpCircle tooltips; tighten Config Backup layout

Author: shuaijinchao

crates/nyro-core/src/admin/mod.rs

@@ -751,6 +751,10 @@ impl AdminService {
         self.gw.storage.logs().query(q).await
     }
 
+    pub async fn get_log(&self, id: &str) -> anyhow::Result<Option<RequestLog>> {
+        self.gw.storage.logs().find_by_id(id).await
+    }
+
     // ── Stats ──
 
     fn normalize_hours(hours: Option<i32>) -> Option<i32> {

crates/nyro-core/src/db/mod.rs

@@ -58,6 +58,12 @@ pub async fn migrate(pool: &SqlitePool, vector_dimensions: usize) -> anyhow::Res
     ensure_route_column(pool, "cache_semantic_ttl", "INTEGER").await?;
     ensure_route_column(pool, "cache_semantic_threshold", "REAL").await?;
     ensure_request_log_column(pool, "api_key_id", "TEXT").await?;
+    ensure_request_log_column(pool, "method", "TEXT").await?;
+    ensure_request_log_column(pool, "path", "TEXT").await?;
+    ensure_request_log_column(pool, "request_headers", "TEXT").await?;
+    ensure_request_log_column(pool, "request_body", "TEXT").await?;
+    ensure_request_log_column(pool, "response_headers", "TEXT").await?;
+    ensure_request_log_column(pool, "response_body", "TEXT").await?;
     ensure_api_key_tables(pool).await?;
     ensure_api_key_column(pool, "rpd", "INTEGER").await?;
     // Migrate: providers/routes is_active -> is_enabled
@@ -478,7 +484,13 @@ CREATE TABLE IF NOT EXISTS request_logs (
     is_stream         INTEGER DEFAULT 0,
     is_tool_call      INTEGER DEFAULT 0,
     error_message     TEXT,
-    response_preview  TEXT
+    response_preview  TEXT,
+    method            TEXT,
+    path              TEXT,
+    request_headers   TEXT,
+    request_body      TEXT,
+    response_headers  TEXT,
+    response_body     TEXT
 );
 
 CREATE INDEX IF NOT EXISTS idx_logs_created_at ON request_logs(created_at);

crates/nyro-core/src/db/models.rs

@@ -160,6 +160,16 @@ pub struct RequestLog {
     pub is_tool_call: bool,
     pub error_message: Option<String>,
     pub response_preview: Option<String>,
+    pub method: Option<String>,
+    pub path: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub request_headers: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_headers: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_body: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

crates/nyro-core/src/logging/mod.rs

@@ -3,7 +3,10 @@ use tokio::sync::mpsc;
 use crate::protocol::types::TokenUsage;
 use crate::storage::DynStorage;
 
-const DEFAULT_RETENTION_DAYS: i64 = 30;
+const DEFAULT_RETENTION_DAYS: i64 = 7;
+const DEFAULT_RECORD_PAYLOADS: bool = true;
+pub const LOG_RECORD_PAYLOADS_KEY: &str = "log_record_payloads";
+pub const LOG_RETENTION_DAYS_KEY: &str = "log_retention_days";
 
 #[derive(Debug, Clone)]
 pub struct LogEntry {
@@ -20,18 +23,24 @@ pub struct LogEntry {
     pub is_tool_call: bool,
     pub error_message: Option<String>,
     pub response_preview: Option<String>,
+    pub method: Option<String>,
+    pub path: Option<String>,
+    pub request_headers: Option<String>,
+    pub request_body: Option<String>,
+    pub response_headers: Option<String>,
+    pub response_body: Option<String>,
 }
 
 pub async fn run_collector(mut rx: mpsc::Receiver<LogEntry>, storage: DynStorage) {
-    let mut buffer: Vec<LogEntry> = Vec::with_capacity(64);
+    let mut buffer: Vec<LogEntry> = Vec::with_capacity(32);
     let mut flush_interval = tokio::time::interval(std::time::Duration::from_secs(2));
-    let mut cleanup_interval = tokio::time::interval(std::time::Duration::from_secs(3600));
+    let mut cleanup_interval = tokio::time::interval(std::time::Duration::from_secs(600));
 
     loop {
         tokio::select! {
             Some(entry) = rx.recv() => {
                 buffer.push(entry);
-                if buffer.len() >= 64 {
+                if buffer.len() >= 32 {
                     flush(storage.clone(), &mut buffer).await;
                 }
             }
@@ -50,7 +59,7 @@ pub async fn run_collector(mut rx: mpsc::Receiver<LogEntry>, storage: DynStorage
 async fn cleanup_old_logs(storage: DynStorage) {
     let days = storage
         .settings()
-        .get("log_retention_days")
+        .get(LOG_RETENTION_DAYS_KEY)
         .await
         .ok()
         .flatten()
@@ -65,7 +74,27 @@ async fn cleanup_old_logs(storage: DynStorage) {
     }
 }
 
+async fn read_record_payloads(storage: &DynStorage) -> bool {
+    storage
+        .settings()
+        .get(LOG_RECORD_PAYLOADS_KEY)
+        .await
+        .ok()
+        .flatten()
+        .map(|v| !matches!(v.to_ascii_lowercase().as_str(), "false" | "0" | "off" | "no"))
+        .unwrap_or(DEFAULT_RECORD_PAYLOADS)
+}
+
 async fn flush(storage: DynStorage, buffer: &mut Vec<LogEntry>) {
-    let entries = std::mem::take(buffer);
-    let _ = storage.logs().append_batch(entries).await;
+    let mut entries = std::mem::take(buffer);
+    let record_payloads = read_record_payloads(&storage).await;
+    if !record_payloads {
+        for entry in entries.iter_mut() {
+            entry.request_headers = None;
+            entry.request_body = None;
+            entry.response_headers = None;
+            entry.response_body = None;
+        }
     }
+    let _ = storage.logs().append_batch(entries).await;
+}