initial check for process summary screen

This check in offers alpha support for per process metrics, you can view threads, process CPU usage over time, IO, memory, CPU time, parent process, command, uptime and journal entries. This is unfinished but all major functionality is available and I wanted to make it available to feedback and testing.

socktop_connector/src/connector.rs

@@ -66,7 +66,7 @@ use tokio_tungstenite::{Connector, connect_async_tls_with_config};
 use crate::error::{ConnectorError, Result};
 use crate::types::{AgentRequest, AgentResponse};
 #[cfg(any(feature = "networking", feature = "wasm"))]
-use crate::types::{DiskInfo, Metrics, ProcessInfo, ProcessesPayload};
+use crate::types::{DiskInfo, Metrics, ProcessInfo, ProcessesPayload, ProcessMetricsResponse, JournalResponse};
 #[cfg(feature = "tls")]
 fn ensure_crypto_provider() {
     use std::sync::Once;
@@ -186,6 +186,18 @@ impl SocktopConnector {
                     .ok_or_else(|| ConnectorError::invalid_response("Failed to get processes"))?;
                 Ok(AgentResponse::Processes(processes))
             }
+            AgentRequest::ProcessMetrics { pid } => {
+                let process_metrics = request_process_metrics(stream, pid)
+                    .await
+                    .ok_or_else(|| ConnectorError::invalid_response("Failed to get process metrics"))?;
+                Ok(AgentResponse::ProcessMetrics(process_metrics))
+            }
+            AgentRequest::JournalEntries { pid } => {
+                let journal_entries = request_journal_entries(stream, pid)
+                    .await
+                    .ok_or_else(|| ConnectorError::invalid_response("Failed to get journal entries"))?;
+                Ok(AgentResponse::JournalEntries(journal_entries))
+            }
         }
     }
 
@@ -437,6 +449,38 @@ async fn request_processes(ws: &mut WsStream) -> Option<ProcessesPayload> {
     }
 }
 
+// Send a "get_process_metrics:{pid}" request and await a JSON ProcessMetricsResponse
+#[cfg(feature = "networking")]
+async fn request_process_metrics(ws: &mut WsStream, pid: u32) -> Option<ProcessMetricsResponse> {
+    let request = format!("get_process_metrics:{}", pid);
+    if ws.send(Message::Text(request)).await.is_err() {
+        return None;
+    }
+    match ws.next().await {
+        Some(Ok(Message::Binary(b))) => {
+            gunzip_to_string(&b).ok().and_then(|s| serde_json::from_str::<ProcessMetricsResponse>(&s).ok())
+        }
+        Some(Ok(Message::Text(json))) => serde_json::from_str::<ProcessMetricsResponse>(&json).ok(),
+        _ => None,
+    }
+}
+
+// Send a "get_journal_entries:{pid}" request and await a JSON JournalResponse
+#[cfg(feature = "networking")]
+async fn request_journal_entries(ws: &mut WsStream, pid: u32) -> Option<JournalResponse> {
+    let request = format!("get_journal_entries:{}", pid);
+    if ws.send(Message::Text(request)).await.is_err() {
+        return None;
+    }
+    match ws.next().await {
+        Some(Ok(Message::Binary(b))) => {
+            gunzip_to_string(&b).ok().and_then(|s| serde_json::from_str::<JournalResponse>(&s).ok())
+        }
+        Some(Ok(Message::Text(json))) => serde_json::from_str::<JournalResponse>(&json).ok(),
+        _ => None,
+    }
+}
+
 // Decompress a gzip-compressed binary frame into a String.
 /// Unified gzip decompression to string for both networking and WASM
 #[cfg(any(feature = "networking", feature = "wasm"))]
@@ -805,6 +849,20 @@ impl SocktopConnector {
                     Ok(AgentResponse::Processes(processes))
                 }
             }
+            AgentRequest::ProcessMetrics { pid: _ } => {
+                // Parse JSON response for process metrics
+                let process_metrics: ProcessMetricsResponse = serde_json::from_str(&response).map_err(|e| {
+                    ConnectorError::serialization_error(format!("Failed to parse process metrics: {e}"))
+                })?;
+                Ok(AgentResponse::ProcessMetrics(process_metrics))
+            }
+            AgentRequest::JournalEntries { pid: _ } => {
+                // Parse JSON response for journal entries
+                let journal_entries: JournalResponse = serde_json::from_str(&response).map_err(|e| {
+                    ConnectorError::serialization_error(format!("Failed to parse journal entries: {e}"))
+                })?;
+                Ok(AgentResponse::JournalEntries(journal_entries))
+            }
         }
     }
 

socktop_connector/src/connector_impl.rs

@@ -6,7 +6,8 @@ use crate::{AgentRequest, AgentResponse};
 
 #[cfg(feature = "networking")]
 use crate::networking::{
-    WsStream, connect_to_agent, request_disks, request_metrics, request_processes,
+    WsStream, connect_to_agent, request_disks, request_journal_entries, request_metrics,
+    request_process_metrics, request_processes,
 };
 
 #[cfg(all(feature = "wasm", not(feature = "networking")))]
@@ -72,6 +73,20 @@ impl SocktopConnector {
                     .ok_or_else(|| ConnectorError::invalid_response("Failed to get processes"))?;
                 Ok(AgentResponse::Processes(processes))
             }
+            AgentRequest::ProcessMetrics { pid } => {
+                let process_metrics =
+                    request_process_metrics(stream, pid).await.ok_or_else(|| {
+                        ConnectorError::invalid_response("Failed to get process metrics")
+                    })?;
+                Ok(AgentResponse::ProcessMetrics(process_metrics))
+            }
+            AgentRequest::JournalEntries { pid } => {
+                let journal_entries =
+                    request_journal_entries(stream, pid).await.ok_or_else(|| {
+                        ConnectorError::invalid_response("Failed to get journal entries")
+                    })?;
+                Ok(AgentResponse::JournalEntries(journal_entries))
+            }
         }
     }
 

socktop_connector/src/lib.rs

@@ -161,7 +161,8 @@ pub use config::ConnectorConfig;
 pub use connector_impl::SocktopConnector;
 pub use error::{ConnectorError, Result};
 pub use types::{
-    AgentRequest, AgentResponse, DiskInfo, GpuInfo, Metrics, NetworkInfo, ProcessInfo,
+    AgentRequest, AgentResponse, DetailedProcessInfo, DiskInfo, GpuInfo, JournalEntry,
+    JournalResponse, LogLevel, Metrics, NetworkInfo, ProcessInfo, ProcessMetricsResponse,
     ProcessesPayload,
 };
 

socktop_connector/src/networking/requests.rs

@@ -1,6 +1,7 @@
 //! WebSocket request handlers for native (non-WASM) environments.
 
 use crate::networking::WsStream;
+use crate::types::{JournalResponse, ProcessMetricsResponse};
 use crate::utils::{gunzip_to_string, gunzip_to_vec, is_gzip};
 use crate::{DiskInfo, Metrics, ProcessInfo, ProcessesPayload, pb};
 
@@ -82,3 +83,36 @@ pub async fn request_processes(ws: &mut WsStream) -> Option<ProcessesPayload> {
         _ => None,
     }
 }
+
+/// Send a "get_process_metrics:{pid}" request and await a JSON ProcessMetricsResponse
+pub async fn request_process_metrics(
+    ws: &mut WsStream,
+    pid: u32,
+) -> Option<ProcessMetricsResponse> {
+    let request = format!("get_process_metrics:{pid}");
+    if ws.send(Message::Text(request)).await.is_err() {
+        return None;
+    }
+    match ws.next().await {
+        Some(Ok(Message::Binary(b))) => gunzip_to_string(&b)
+            .ok()
+            .and_then(|s| serde_json::from_str::<ProcessMetricsResponse>(&s).ok()),
+        Some(Ok(Message::Text(json))) => serde_json::from_str::<ProcessMetricsResponse>(&json).ok(),
+        _ => None,
+    }
+}
+
+/// Send a "get_journal_entries:{pid}" request and await a JSON JournalResponse
+pub async fn request_journal_entries(ws: &mut WsStream, pid: u32) -> Option<JournalResponse> {
+    let request = format!("get_journal_entries:{pid}");
+    if ws.send(Message::Text(request)).await.is_err() {
+        return None;
+    }
+    match ws.next().await {
+        Some(Ok(Message::Binary(b))) => gunzip_to_string(&b)
+            .ok()
+            .and_then(|s| serde_json::from_str::<JournalResponse>(&s).ok()),
+        Some(Ok(Message::Text(json))) => serde_json::from_str::<JournalResponse>(&json).ok(),
+        _ => None,
+    }
+}

socktop_connector/src/types.rs

@@ -73,6 +73,79 @@ pub struct ProcessesPayload {
     pub top_processes: Vec<ProcessInfo>,
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ThreadInfo {
+    pub tid: u32,             // Thread ID
+    pub name: String,         // Thread name (from /proc/{pid}/task/{tid}/comm)
+    pub cpu_time_user: u64,   // User CPU time in microseconds
+    pub cpu_time_system: u64, // System CPU time in microseconds
+    pub status: String,       // Thread status (Running, Sleeping, etc.)
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct DetailedProcessInfo {
+    pub pid: u32,
+    pub name: String,
+    pub command: String,
+    pub cpu_usage: f32,
+    pub mem_bytes: u64,
+    pub virtual_mem_bytes: u64,
+    pub shared_mem_bytes: Option<u64>,
+    pub thread_count: u32,
+    pub fd_count: Option<u32>,
+    pub status: String,
+    pub parent_pid: Option<u32>,
+    pub user_id: u32,
+    pub group_id: u32,
+    pub start_time: u64,      // Unix timestamp
+    pub cpu_time_user: u64,   // Microseconds
+    pub cpu_time_system: u64, // Microseconds
+    pub read_bytes: Option<u64>,
+    pub write_bytes: Option<u64>,
+    pub working_directory: Option<String>,
+    pub executable_path: Option<String>,
+    pub child_processes: Vec<DetailedProcessInfo>,
+    pub threads: Vec<ThreadInfo>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ProcessMetricsResponse {
+    pub process: DetailedProcessInfo,
+    pub cached_at: u64, // Unix timestamp when this data was cached
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct JournalEntry {
+    pub timestamp: String, // ISO 8601 formatted timestamp
+    pub priority: LogLevel,
+    pub message: String,
+    pub unit: Option<String>, // systemd unit name
+    pub pid: Option<u32>,
+    pub comm: Option<String>, // process command name
+    pub uid: Option<u32>,
+    pub gid: Option<u32>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub enum LogLevel {
+    Emergency = 0,
+    Alert = 1,
+    Critical = 2,
+    Error = 3,
+    Warning = 4,
+    Notice = 5,
+    Info = 6,
+    Debug = 7,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct JournalResponse {
+    pub entries: Vec<JournalEntry>,
+    pub total_count: u32,
+    pub truncated: bool,
+    pub cached_at: u64, // Unix timestamp when this data was cached
+}
+
 /// Request types that can be sent to the agent
 #[derive(Debug, Clone, Serialize)]
 #[serde(tag = "type")]
@@ -83,6 +156,10 @@ pub enum AgentRequest {
     Disks,
     #[serde(rename = "processes")]
     Processes,
+    #[serde(rename = "process_metrics")]
+    ProcessMetrics { pid: u32 },
+    #[serde(rename = "journal_entries")]
+    JournalEntries { pid: u32 },
 }
 
 impl AgentRequest {
@@ -92,6 +169,8 @@ impl AgentRequest {
             AgentRequest::Metrics => "get_metrics".to_string(),
             AgentRequest::Disks => "get_disks".to_string(),
             AgentRequest::Processes => "get_processes".to_string(),
+            AgentRequest::ProcessMetrics { pid } => format!("get_process_metrics:{pid}"),
+            AgentRequest::JournalEntries { pid } => format!("get_journal_entries:{pid}"),
         }
     }
 }
@@ -106,4 +185,8 @@ pub enum AgentResponse {
     Disks(Vec<DiskInfo>),
     #[serde(rename = "processes")]
     Processes(ProcessesPayload),
+    #[serde(rename = "process_metrics")]
+    ProcessMetrics(ProcessMetricsResponse),
+    #[serde(rename = "journal_entries")]
+    JournalEntries(JournalResponse),
 }

socktop_connector/src/wasm/requests.rs

@@ -3,7 +3,10 @@
 use crate::error::{ConnectorError, Result};
 use crate::pb::Processes;
 use crate::utils::{gunzip_to_string, gunzip_to_vec, is_gzip, log_debug};
-use crate::{AgentRequest, AgentResponse, DiskInfo, Metrics, ProcessInfo, ProcessesPayload};
+use crate::{
+    AgentRequest, AgentResponse, DiskInfo, JournalResponse, Metrics, ProcessInfo,
+    ProcessMetricsResponse, ProcessesPayload,
+};
 
 use prost::Message as ProstMessage;
 use std::cell::RefCell;
@@ -206,6 +209,26 @@ pub async fn send_request_and_wait(
                 Ok(AgentResponse::Processes(processes))
             }
         }
+        AgentRequest::ProcessMetrics { pid: _ } => {
+            // Parse JSON response for process metrics
+            let process_metrics: ProcessMetricsResponse =
+                serde_json::from_str(&response).map_err(|e| {
+                    ConnectorError::serialization_error(format!(
+                        "Failed to parse process metrics: {e}"
+                    ))
+                })?;
+            Ok(AgentResponse::ProcessMetrics(process_metrics))
+        }
+        AgentRequest::JournalEntries { pid: _ } => {
+            // Parse JSON response for journal entries
+            let journal_entries: JournalResponse =
+                serde_json::from_str(&response).map_err(|e| {
+                    ConnectorError::serialization_error(format!(
+                        "Failed to parse journal entries: {e}"
+                    ))
+                })?;
+            Ok(AgentResponse::JournalEntries(journal_entries))
+        }
     }
 }