improved logging

src/routes/rooms.rs

@@ -296,8 +296,6 @@ async fn send_invite(
             )
         })?;
 
-    tracing::info!("bro");
-
     let room_name = room_name_from_uuid(&db, payload.room_uuid).await?;
 
     Ok((

src/routes/users.rs

@@ -279,7 +279,7 @@ async fn upload_avatar(
     let claims = verify_jwt(headers)?;
 
     let user_id = user_id_from_uuid(&db, claims.sub).await?;
-    tracing::info!("User ID {} is uploading {} bytes)", user_id, body.len());
+    tracing::debug!("User ID {} is uploading {} bytes)", user_id, body.len());
 
     let base_dir = &config.avatar_dir;
     let file_extension = "png"; // TODO: detect MIME type

src/routes/ws.rs

@@ -1,6 +1,6 @@
 use axum::Json;
-use axum::extract::Query;
 use axum::extract::ws::{Message as WsMessage, WebSocket};
+use axum::extract::{ConnectInfo, Query};
 use axum::http::HeaderMap;
 use axum::routing::get;
 use axum::{
@@ -9,7 +9,9 @@ use axum::{
     http::StatusCode,
     response::IntoResponse,
 };
+use axum_extra::{TypedHeader, headers};
 use serde::Deserialize;
+use std::net::SocketAddr;
 use std::time::Duration;
 use tokio::select;
 use uuid::Uuid;
@@ -77,8 +79,10 @@ pub async fn issue_ws_token(
 
 async fn ws_handler(
     ws: WebSocketUpgrade,
+    user_agent: Option<TypedHeader<headers::UserAgent>>,
     Path(room_uuid): Path<Uuid>,
     Query(query): Query<WsAuthQuery>,
+    ConnectInfo(addr): ConnectInfo<SocketAddr>,
     Extension(realtime): Extension<Realtime>,
     Extension(db): Extension<sqlx::PgPool>,
 ) -> Result<impl IntoResponse, axum::http::StatusCode> {
@@ -110,11 +114,19 @@ async fn ws_handler(
     let sender = realtime.sender_for(room_id);
     let receiver = sender.subscribe();
 
-    Ok(ws.on_upgrade(move |socket| handle_socket(socket, receiver)))
+    let user_agent = if let Some(TypedHeader(user_agent)) = user_agent {
+        user_agent.to_string()
+    } else {
+        String::from("Unknown browser")
+    };
+    tracing::debug!("`{user_agent}` at {addr} connected.");
+
+    Ok(ws.on_upgrade(move |socket| handle_socket(socket, addr, receiver)))
 }
 
 async fn handle_socket(
     mut socket: WebSocket,
+    who: SocketAddr,
     mut receiver: tokio::sync::broadcast::Receiver<crate::routes::messages::Message>,
 ) {
     let mut ping_interval = tokio::time::interval(Duration::from_secs(30));
@@ -126,7 +138,7 @@ async fn handle_socket(
                 if let Ok(msg) = msg {
                     if let Ok(json) = serde_json::to_string(&msg) {
                         if socket.send(WsMessage::Text(json.into())).await.is_err() {
-                            tracing::warn!("WebSocket send failed, closing socket");
+                            tracing::error!("Failed to send message to {who}, closing connection");
                             break;
                         }
                     }
@@ -138,33 +150,33 @@ async fn handle_socket(
             // Send Ping
             _ = ping_interval.tick() => {
                 if socket.send(WsMessage::Ping(vec![].into())).await.is_err() {
-                    tracing::error!("Failed to send ping, closing connection");
+                    tracing::error!("Failed to send ping to {who}, closing connection");
                     break;
                 }
 
-                tracing::info!("Ping sent successfully");
+                // tracing::debug!("Ping sent to {who}");
             }
 
             // Get incoming messages from client
             client_msg = socket.recv() => {
-                match client_msg {
-                    Some(Ok(msg)) => {
-                        match msg {
-                            WsMessage::Pong(_) => {
-                                tracing::info!("Received Pong");
-                            }
-                            WsMessage::Ping(_) => {
-                                tracing::info!("Received Ping from client");
-                            }
-                            // WsMessage::Text(_) => {}
-                            WsMessage::Close(_) => {
-                                tracing::info!("Client disconnected");
-                                break;
-                            }
-                            _ => {}
+                if let Some(Ok(msg)) = client_msg {
+                    match msg {
+                        // WsMessage::Pong(_) => {
+                        //     tracing::debug!("Received Pong from {who}");
+                        // }
+                        // WsMessage::Ping(_) => {
+                        //     tracing::info!("Received Ping from client");
+                        // }
+                        // WsMessage::Text(_) => {}
+                        WsMessage::Close(_) => {
+                            tracing::debug!("Client disconnected");
+                            break;
                         }
-                    },
-                    _ => break,
+                        _ => {}
+                    }
+                } else {
+                    tracing::debug!("Client {who} abruptly disconnected");
+                    break;
                 }
             }
         }