Added functionlaity for logging information

examples/simple-chat-client/Cargo.toml

@@ -13,10 +13,10 @@ thiserror = "2.0"
 async-trait = "0.1"
 futures = "0.3"
 toml = "0.8"
-rmcp = { workspace = true, features = [
+rmcp = { path = "../../rmcp", features = [
     "client",
     "transport-child-process",
     "transport-sse-client",
     "reqwest"
-], no-default-features = true }
+], default-features = false }
 clap = { version = "4.0", features = ["derive"] }

examples/transport/src/http_upgrade.rs

@@ -16,17 +16,22 @@ async fn main() -> anyhow::Result<()> {
     start_server().await?;
     let client = http_client("127.0.0.1:8001").await?;
     let tools = client.list_all_tools().await?;
+    tracing::info!("Available tools: {:#?}", tools);
     client.cancel().await?;
-    tracing::info!("{:#?}", tools);
+    tracing::info!("Client terminated");
     Ok(())
 }
 
 async fn http_server(req: Request<Incoming>) -> Result<hyper::Response<String>, hyper::Error> {
     tokio::spawn(async move {
-        let upgraded = hyper::upgrade::on(req).await?;
-        let service = Calculator.serve(TokioIo::new(upgraded)).await?;
-        service.waiting().await?;
-        anyhow::Result::<()>::Ok(())
+        if let Err(e) = async {
+            let upgraded = hyper::upgrade::on(req).await?;
+            let service = Calculator.serve(TokioIo::new(upgraded)).await?;
+            service.waiting().await?;
+            Ok::<(), anyhow::Error>(())
+        }.await {
+            tracing::error!("Service error: {:?}", e);
+        }
     });
     let mut response = hyper::Response::new(String::new());
     *response.status_mut() = StatusCode::SWITCHING_PROTOCOLS;
@@ -36,6 +41,7 @@ async fn http_server(req: Request<Incoming>) -> Result<hyper::Response<String>,
     Ok(response)
 }
 
+
 async fn http_client(uri: &str) -> anyhow::Result<RunningService<RoleClient, ()>> {
     let tcp_stream = tokio::net::TcpStream::connect(uri).await?;
     let (mut s, c) =
@@ -52,12 +58,13 @@ async fn http_client(uri: &str) -> anyhow::Result<RunningService<RoleClient, ()>
 
 async fn start_server() -> anyhow::Result<()> {
     let tcp_listener = tokio::net::TcpListener::bind("127.0.0.1:8001").await?;
+    tracing::info!("Server listening on {}", tcp_listener.local_addr()?);
     let service = hyper::service::service_fn(http_server);
     tokio::spawn(async move {
         while let Ok((stream, addr)) = tcp_listener.accept().await {
-            tracing::info!("accepted connection from: {}", addr);
+            tracing::info!("Accepted connection from: {}", addr);
             let conn = hyper::server::conn::http1::Builder::new()
-                .serve_connection(TokioIo::new(stream), service)
+                .serve_connection(TokioIo::new(stream), service.clone())
                 .with_upgrades();
             tokio::spawn(conn);
         }

examples/transport/src/tcp.rs

@@ -1,31 +1,63 @@
 use common::calculator::Calculator;
 use rmcp::{serve_client, serve_server};
+use tracing::info;
+use tracing_subscriber::EnvFilter;
 
 mod common;
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    tokio::spawn(server());
+    tracing_subscriber::fmt()
+        .with_env_filter(EnvFilter::from_default_env().add_directive("info".parse()?))
+        .init();
+
+
+    let (tx, rx) = tokio::sync::oneshot::channel();
+    tokio::spawn(server(tx));
+    rx.await??;
     client().await?;
     Ok(())
 }
 
-async fn server() -> anyhow::Result<()> {
-    let tcp_listener = tokio::net::TcpListener::bind("127.0.0.1:8001").await?;
-    while let Ok((stream, _)) = tcp_listener.accept().await {
+async fn server(ready_tx: tokio::sync::oneshot::Sender<anyhow::Result<()>>) {
+
+    let bind_result = tokio::net::TcpListener::bind("127.0.0.1:8001").await;
+    let listener = match bind_result {
+        Ok(l) => l,
+        Err(e) => {
+            let _ = ready_tx.send(Err(e.into()));
+            return;
+        }
+    };
+
+    info!("Server listening on {}", listener.local_addr().unwrap());
+    let _ = ready_tx.send(Ok(()));
+
+
+    while let Ok((stream, addr)) = listener.accept().await {
+        info!("Accepted connection from: {}", addr);
+
         tokio::spawn(async move {
-            let server = serve_server(Calculator, stream).await?;
-            server.waiting().await?;
-            anyhow::Ok(())
+            match serve_server(Calculator, stream).await {
+                Ok(server) => {
+                    if let Err(e) = server.waiting().await {
+                        info!("Connection closed with error: {}", e);
+                    }
+                }
+                Err(e) => {
+                    info!("Failed to serve connection: {}", e);
+                }
+            };
         });
     }
-    Ok(())
 }
 
 async fn client() -> anyhow::Result<()> {
+    info!("Client connecting to server...");
     let stream = tokio::net::TcpSocket::new_v4()?
         .connect("127.0.0.1:8001".parse()?)
         .await?;
     let client = serve_client((), stream).await?;
+    info!("Client connected successfully");
     let tools = client.peer().list_tools(Default::default()).await?;
     println!("{:?}", tools);
     Ok(())