Added area for the client callstack to the UI

test/rust_grpc/Cargo.toml

@@ -25,6 +25,16 @@ tokio-shutdown = "0.1.4"
 clap = {  version= "4.4.11", features = ["derive"] }
 portpicker = "0.1.1"
 atomic-counter = "1.0.1"
+os-id = "3.0.1"
+crossbeam-skiplist = "0.1.1"
+
+[dependencies.windows]
+version = "0.52.0"
+features = [
+    "Win32_Foundation",
+    "Win32_System_Threading",
+]
+
 
 [build-dependencies]
 tonic-build = { version = "0.10.2", features = ["prost"] }

test/rust_grpc/proto/rust_grpc.proto

@@ -50,13 +50,26 @@ message SendMessageResponse {
 message DiagnosticsRequest {
 }
 
+
+message ClientProcess {
+
+  /// Identifies the process in the system.
+  uint32 id = 1;
+
+  /// Identifies the threads that have called the server from this process.
+  repeated uint64 threads = 2;
+}
+
 message DiagnosticsResponse {
 
   /// Uptime of the server.
   google.protobuf.Duration uptime = 1;
 
   /// Number of times SendMessage has been called since the server was started.
   uint64 send_message_calls = 2;
+
+  /// Information about the clients that have called the server.
+  repeated ClientProcess clients = 3;
 }
 
 message WaitForFirstMessageRequest {

test/rust_grpc/src/generator.rs

@@ -4,7 +4,10 @@ use rust_grpc_private::{SendMessageRequest, WaitForFirstMessageRequest};
 use std::{thread, time};
 use tokio::sync::mpsc::UnboundedSender;
 use tokio::task::JoinSet;
+use tonic::metadata::MetadataValue;
 use tonic::transport::Channel;
+#[cfg(target_os = "windows")]
+use windows;
 
 mod rust_grpc_private
 {
@@ -157,7 +160,15 @@ async fn generate_messages_task(
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 {
     loop {
-        let request = tonic::Request::new(SendMessageRequest {});
+        let mut request = tonic::Request::new(SendMessageRequest {});
+        request.metadata_mut().append(
+            "proxide-client-process-id",
+            MetadataValue::from(std::process::id()),
+        );
+        request.metadata_mut().append(
+            "proxide-client-thread-id",
+            MetadataValue::from(get_current_native_thread_id()),
+        );
         tokio::select! {
             chosen = client.send_message(request) => { chosen?; },
             _chosen = tokio::signal::ctrl_c() => { break; }
@@ -202,8 +213,29 @@ async fn report_statistics(args: Args) -> Result<(), Box<dyn std::error::Error +
         let diagnostics = response.get_ref();
         let server_uptime = time::Duration::try_from(diagnostics.uptime.clone().unwrap())?;
         let call_rate = diagnostics.send_message_calls as u128 / server_uptime.as_millis();
-        println!("Call rate: {} calls / ms", call_rate);
+        println!(
+            "Call rate: {} calls / ms, processes: {} with {} threads",
+            call_rate,
+            diagnostics.clients.len(),
+            diagnostics
+                .clients
+                .iter()
+                .map(|c| c.threads.len() as u64)
+                .sum::<u64>()
+        );
 
         tokio::time::sleep(time::Duration::from_secs(2)).await;
     }
 }
+
+/// Gets the current native thread id.
+pub fn get_current_native_thread_id() -> i64
+{
+    #[cfg(not(target_os = "windows"))]
+    return os_id::thread::get_raw_id() as i64;
+
+    #[cfg(target_os = "windows")]
+    unsafe {
+        return windows::Win32::System::Threading::GetCurrentThreadId() as i64;
+    }
+}