Merge branch 'small-logging-improvements' into 'next'

Slight logging improvements

See merge request famedly/conduit!517

src/api/client_server/room.rs

@@ -425,11 +425,10 @@ pub async fn get_room_event_route(
 ) -> Result<get_room_event::v3::Response> {
     let sender_user = body.sender_user.as_ref().expect("user is authenticated");
 
-    let event = services()
+    let event = services().rooms.timeline.get_pdu(&body.event_id)?.ok_or({
-        .rooms
+        warn!("Event not found, event ID: {:?}", &body.event_id);
-        .timeline
+        Error::BadRequest(ErrorKind::NotFound, "Event not found.")
-        .get_pdu(&body.event_id)?
+    })?;
-        .ok_or(Error::BadRequest(ErrorKind::NotFound, "Event not found."))?;
 
     if !services().rooms.state_accessor.user_can_see_event(
         sender_user,

src/api/client_server/session.rs

@@ -9,7 +9,7 @@ use ruma::{
     UserId,
 };
 use serde::Deserialize;
-use tracing::info;
+use tracing::{info, warn};
 
 #[derive(Debug, Deserialize)]
 struct Claims {
@@ -52,6 +52,7 @@ pub async fn login_route(body: Ruma<login::v3::Request>) -> Result<login::v3::Re
             let username = if let UserIdentifier::UserIdOrLocalpart(user_id) = identifier {
                 user_id.to_lowercase()
             } else {
+                warn!("Bad login type: {:?}", &body.login_info);
                 return Err(Error::BadRequest(ErrorKind::Forbidden, "Bad login type."));
             };
             let user_id =
@@ -124,6 +125,7 @@ pub async fn login_route(body: Ruma<login::v3::Request>) -> Result<login::v3::Re
             user_id
         }
         _ => {
+            warn!("Unsupported or unknown login type: {:?}", &body.login_info);
             return Err(Error::BadRequest(
                 ErrorKind::Unknown,
                 "Unsupported login type.",

src/api/client_server/state.rs

@@ -12,6 +12,7 @@ use ruma::{
     serde::Raw,
     EventId, RoomId, UserId,
 };
+use tracing::log::warn;
 
 /// # `PUT /_matrix/client/r0/rooms/{roomId}/state/{eventType}/{stateKey}`
 ///
@@ -129,10 +130,13 @@ pub async fn get_state_events_for_key_route(
         .rooms
         .state_accessor
         .room_state_get(&body.room_id, &body.event_type, &body.state_key)?
-        .ok_or(Error::BadRequest(
+        .ok_or({
-            ErrorKind::NotFound,
+            warn!(
-            "State event not found.",
+                "State event {:?} not found in room {:?}",
-        ))?;
+                &body.event_type, &body.room_id
+            );
+            Error::BadRequest(ErrorKind::NotFound, "State event not found.")
+        })?;
 
     Ok(get_state_events_for_key::v3::Response {
         content: serde_json::from_str(event.content.get())
@@ -165,10 +169,13 @@ pub async fn get_state_events_for_empty_key_route(
         .rooms
         .state_accessor
         .room_state_get(&body.room_id, &body.event_type, "")?
-        .ok_or(Error::BadRequest(
+        .ok_or({
-            ErrorKind::NotFound,
+            warn!(
-            "State event not found.",
+                "State event {:?} not found in room {:?}",
-        ))?;
+                &body.event_type, &body.room_id
+            );
+            Error::BadRequest(ErrorKind::NotFound, "State event not found.")
+        })?;
 
     Ok(get_state_events_for_key::v3::Response {
         content: serde_json::from_str(event.content.get())

src/api/ruma_wrapper/axum.rs

@@ -292,10 +292,8 @@ where
         debug!("{:?}", http_request);
 
         let body = T::try_from_http_request(http_request, &path_params).map_err(|e| {
-            warn!(
+            warn!("try_from_http_request failed: {:?}", e);
-                "try_from_http_request failed: {:?}\nJSON body: {:?}",
+            debug!("JSON body: {:?}", json_body);
-                e, json_body
-            );
             Error::BadRequest(ErrorKind::BadJson, "Failed to deserialize request.")
         })?;
 

src/api/server_server.rs

@@ -711,7 +711,8 @@ pub async fn send_transaction_message_route(
         let (event_id, value, room_id) = match r {
             Ok(t) => t,
             Err(e) => {
-                warn!("Could not parse pdu: {e}");
+                warn!("Could not parse PDU: {e}");
+                warn!("Full PDU: {:?}", &pdu);
                 continue;
             }
         };
@@ -952,7 +953,10 @@ pub async fn get_event_route(
         .rooms
         .timeline
         .get_pdu_json(&body.event_id)?
-        .ok_or(Error::BadRequest(ErrorKind::NotFound, "Event not found."))?;
+        .ok_or({
+            warn!("Event not found, event ID: {:?}", &body.event_id);
+            Error::BadRequest(ErrorKind::NotFound, "Event not found.")
+        })?;
 
     let room_id_str = event
         .get("room_id")
@@ -1192,7 +1196,10 @@ pub async fn get_event_authorization_route(
         .rooms
         .timeline
         .get_pdu_json(&body.event_id)?
-        .ok_or(Error::BadRequest(ErrorKind::NotFound, "Event not found."))?;
+        .ok_or({
+            warn!("Event not found, event ID: {:?}", &body.event_id);
+            Error::BadRequest(ErrorKind::NotFound, "Event not found.")
+        })?;
 
     let room_id_str = event
         .get("room_id")

src/main.rs

@@ -433,6 +433,7 @@ fn routes() -> Router {
             "/_matrix/client/v3/rooms/:room_id/initialSync",
             get(initial_sync),
         )
+        .route("/", get(it_works))
         .fallback(not_found)
 }
 
@@ -482,6 +483,10 @@ async fn initial_sync(_uri: Uri) -> impl IntoResponse {
     )
 }
 
+async fn it_works() -> &'static str {
+    "Hello from Conduit!"
+}
+
 trait RouterExt {
     fn ruma_route<H, T>(self, handler: H) -> Self
     where

src/service/globals/mod.rs

@@ -1,8 +1,8 @@
 mod data;
 pub use data::Data;
-use ruma::serde::Base64;
 use ruma::{
-    OwnedDeviceId, OwnedEventId, OwnedRoomId, OwnedServerName, OwnedServerSigningKeyId, OwnedUserId,
+    serde::Base64, OwnedDeviceId, OwnedEventId, OwnedRoomId, OwnedServerName,
+    OwnedServerSigningKeyId, OwnedUserId,
 };
 
 use crate::api::server_server::FedDest;
@@ -15,14 +15,16 @@ use ruma::{
     },
     DeviceId, RoomVersionId, ServerName, UserId,
 };
-use std::sync::atomic::{self, AtomicBool};
 use std::{
     collections::{BTreeMap, HashMap},
     fs,
     future::Future,
     net::{IpAddr, SocketAddr},
     path::PathBuf,
-    sync::{Arc, Mutex, RwLock},
+    sync::{
+        atomic::{self, AtomicBool},
+        Arc, Mutex, RwLock,
+    },
     time::{Duration, Instant},
 };
 use tokio::sync::{broadcast, watch::Receiver, Mutex as TokioMutex, Semaphore};

src/service/rooms/event_handler/mod.rs

@@ -1526,9 +1526,13 @@ impl Service {
         if acl_event_content.is_allowed(server_name) {
             Ok(())
         } else {
+            info!(
+                "Server {} was denied by room ACL in {}",
+                server_name, room_id
+            );
             Err(Error::BadRequest(
                 ErrorKind::Forbidden,
-                "Server was denied by ACL",
+                "Server was denied by room ACL",
             ))
         }
     }

src/service/rooms/state/mod.rs

@@ -342,7 +342,10 @@ impl Service {
             .transpose()?;
         let room_version = create_event_content
             .map(|create_event| create_event.room_version)
-            .ok_or(Error::BadDatabase("Invalid room version"))?;
+            .ok_or({
+                warn!("Invalid room version for room {room_id}");
+                Error::BadDatabase("Invalid room version")
+            })?;
         Ok(room_version)
     }
 

src/service/users/mod.rs

@@ -62,7 +62,9 @@ impl Service {
         device_id: OwnedDeviceId,
         request: &mut sync_events::v4::Request,
     ) -> BTreeMap<String, BTreeMap<OwnedRoomId, bool>> {
-        let Some(conn_id) = request.conn_id.clone() else { return BTreeMap::new(); };
+        let Some(conn_id) = request.conn_id.clone() else {
+            return BTreeMap::new();
+        };
 
         let cache = &mut self.connections.lock().unwrap();
         let cached = Arc::clone(