ember/continuwuity
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

refactor: Clean up logging issues

Browse source 
Primary issues: Double escapes (debug fmt), spans without levels
This commit is contained in:
Jade Ellis 2026-01-04 03:04:37 +00:00
parent 27d6604d14
commit aed15f246a
No known key found for this signature in database
GPG key ID: 8705A2A3EBF77BD2
65 changed files with 197 additions and 193 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
Cargo.lock generated
View file

@ -1750,7 +1750,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
dependencies = [ dependencies = [
"libc", "libc",
"windows-sys 0.52.0", "windows-sys 0.61.2",
] ]
[[package]] [[package]]
@ -2405,7 +2405,7 @@ dependencies = [
"libc", "libc",
"percent-encoding", "percent-encoding",
"pin-project-lite", "pin-project-lite",
"socket2 0.5.10", "socket2 0.6.1",
"tokio", "tokio",
"tower-service", "tower-service",
"tracing", "tracing",
@ -3121,7 +3121,7 @@ version = "0.50.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
dependencies = [ dependencies = [
"windows-sys 0.60.2", "windows-sys 0.61.2",
] ]
[[package]] [[package]]
@ -3749,7 +3749,7 @@ dependencies = [
"quinn-udp", "quinn-udp",
"rustc-hash", "rustc-hash",
"rustls", "rustls",
"socket2 0.5.10", "socket2 0.6.1",
"thiserror 2.0.17", "thiserror 2.0.17",
"tokio", "tokio",
"tracing", "tracing",
@ -3786,9 +3786,9 @@ dependencies = [
"cfg_aliases", "cfg_aliases",
"libc", "libc",
"once_cell", "once_cell",
"socket2 0.5.10", "socket2 0.6.1",
"tracing", "tracing",
"windows-sys 0.52.0", "windows-sys 0.60.2",
] ]
[[package]] [[package]]
@ -4325,7 +4325,7 @@ dependencies = [
"errno", "errno",
"libc", "libc",
"linux-raw-sys", "linux-raw-sys",
"windows-sys 0.52.0", "windows-sys 0.61.2",
] ]
[[package]] [[package]]

4
docs/development/code_style.mdx
View file

@ -128,7 +128,7 @@ Keep in mind the frequency that the log will be reached, and the relevancy to a
```rs ```rs
// Good // Good
error!( error!(
error = %err, error = ?err,
room_id = %room_id, room_id = %room_id,
"Failed to send event to room" "Failed to send event to room"
); );
@ -264,7 +264,7 @@ pub async fn send_federation_request(
warn!( warn!(
destination = %destination, destination = %destination,
attempt = attempt, attempt = attempt,
error = %err, error = ?err,
retry_delay_ms = retry_delay.as_millis(), retry_delay_ms = retry_delay.as_millis(),
"Federation request failed, retrying" "Federation request failed, retrying"
); );

2
src/admin/admin.rs
View file

@ -48,7 +48,7 @@ pub enum AdminCommand {
Query(QueryCommand), Query(QueryCommand),
} }
#[tracing::instrument(skip_all, name = "command")] #[tracing::instrument(skip_all, name = "command", level = "info")]
pub(super) async fn process(command: AdminCommand, context: &Context<'_>) -> Result { pub(super) async fn process(command: AdminCommand, context: &Context<'_>) -> Result {
use AdminCommand::*; use AdminCommand::*;

6
src/admin/debug/commands.rs
View file

@ -456,7 +456,7 @@ pub(super) async fn verify_pdu(&self, event_id: OwnedEventId) -> Result {
} }
#[admin_command] #[admin_command]
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self), level = "info")]
pub(super) async fn first_pdu_in_room(&self, room_id: OwnedRoomId) -> Result { pub(super) async fn first_pdu_in_room(&self, room_id: OwnedRoomId) -> Result {
self.bail_restricted()?; self.bail_restricted()?;
@ -483,7 +483,7 @@ pub(super) async fn first_pdu_in_room(&self, room_id: OwnedRoomId) -> Result {
} }
#[admin_command] #[admin_command]
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self), level = "info")]
pub(super) async fn latest_pdu_in_room(&self, room_id: OwnedRoomId) -> Result { pub(super) async fn latest_pdu_in_room(&self, room_id: OwnedRoomId) -> Result {
self.bail_restricted()?; self.bail_restricted()?;
@ -510,7 +510,7 @@ pub(super) async fn latest_pdu_in_room(&self, room_id: OwnedRoomId) -> Result {
} }
#[admin_command] #[admin_command]
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self), level = "info")]
pub(super) async fn force_set_room_state_from_server( pub(super) async fn force_set_room_state_from_server(
&self, &self,
room_id: OwnedRoomId, room_id: OwnedRoomId,

2
src/admin/processor.rs
View file

@ -37,7 +37,7 @@ pub(super) fn dispatch(services: Arc<Services>, command: CommandInput) -> Proces
Box::pin(handle_command(services, command)) Box::pin(handle_command(services, command))
} }
#[tracing::instrument(skip_all, name = "admin")] #[tracing::instrument(skip_all, name = "admin", level = "info")]
async fn handle_command(services: Arc<Services>, command: CommandInput) -> ProcessorResult { async fn handle_command(services: Arc<Services>, command: CommandInput) -> ProcessorResult {
AssertUnwindSafe(Box::pin(process_command(services, &command))) AssertUnwindSafe(Box::pin(process_command(services, &command)))
.catch_unwind() .catch_unwind()

6
src/admin/room/moderation.rs
View file

@ -98,7 +98,7 @@ async fn ban_room(&self, room: OwnedRoomOrAliasId) -> Result {
{ {
| Ok((room_id, servers)) => { | Ok((room_id, servers)) => {
debug!( debug!(
?room_id, %room_id,
?servers, ?servers,
"Got federation response fetching room ID for room {room}" "Got federation response fetching room ID for room {room}"
); );
@ -240,7 +240,7 @@ async fn ban_list_of_rooms(&self) -> Result {
{ {
| Ok((room_id, servers)) => { | Ok((room_id, servers)) => {
debug!( debug!(
?room_id, %room_id,
?servers, ?servers,
"Got federation response fetching room ID for \ "Got federation response fetching room ID for \
{room}", {room}",
@ -397,7 +397,7 @@ async fn unban_room(&self, room: OwnedRoomOrAliasId) -> Result {
{ {
| Ok((room_id, servers)) => { | Ok((room_id, servers)) => {
debug!( debug!(
?room_id, %room_id,
?servers, ?servers,
"Got federation response fetching room ID for room {room}" "Got federation response fetching room ID for room {room}"
); );

8
src/api/client/account.rs
View file

@ -49,7 +49,7 @@ const RANDOM_USER_ID_LENGTH: usize = 10;
/// ///
/// Note: This will not reserve the username, so the username might become /// Note: This will not reserve the username, so the username might become
/// invalid when trying to register /// invalid when trying to register
#[tracing::instrument(skip_all, fields(%client), name = "register_available")] #[tracing::instrument(skip_all, fields(%client), name = "register_available", level = "info")]
pub(crate) async fn get_register_available_route( pub(crate) async fn get_register_available_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -138,7 +138,7 @@ pub(crate) async fn get_register_available_route(
/// - If `inhibit_login` is false: Creates a device and returns device id and /// - If `inhibit_login` is false: Creates a device and returns device id and
/// access_token /// access_token
#[allow(clippy::doc_markdown)] #[allow(clippy::doc_markdown)]
#[tracing::instrument(skip_all, fields(%client), name = "register")] #[tracing::instrument(skip_all, fields(%client), name = "register", level = "info")]
pub(crate) async fn register_route( pub(crate) async fn register_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -603,7 +603,7 @@ pub(crate) async fn register_route(
/// last seen ts) /// last seen ts)
/// - Forgets to-device events /// - Forgets to-device events
/// - Triggers device list updates /// - Triggers device list updates
#[tracing::instrument(skip_all, fields(%client), name = "change_password")] #[tracing::instrument(skip_all, fields(%client), name = "change_password", level = "info")]
pub(crate) async fn change_password_route( pub(crate) async fn change_password_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -727,7 +727,7 @@ pub(crate) async fn whoami_route(
/// - Forgets all to-device events /// - Forgets all to-device events
/// - Triggers device list updates /// - Triggers device list updates
/// - Removes ability to log in again /// - Removes ability to log in again
#[tracing::instrument(skip_all, fields(%client), name = "deactivate")] #[tracing::instrument(skip_all, fields(%client), name = "deactivate", level = "info")]
pub(crate) async fn deactivate_route( pub(crate) async fn deactivate_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,

2
src/api/client/alias.rs
View file

@ -102,7 +102,7 @@ pub(crate) async fn get_alias_route(
}; };
let servers = room_available_servers(&services, &room_id, &room_alias, servers).await; let servers = room_available_servers(&services, &room_id, &room_alias, servers).await;
debug!(?room_alias, ?room_id, "available servers: {servers:?}"); debug!(%room_alias, %room_id, "available servers: {servers:?}");
Ok(get_alias::v3::Response::new(room_id, servers)) Ok(get_alias::v3::Response::new(room_id, servers))
} }

2
src/api/client/context.rs
View file

@ -74,7 +74,7 @@ pub(crate) async fn get_context_route(
} }
if !visible { if !visible {
debug_warn!(req_evt = ?event_id, ?base_id, ?room_id, "Event requested by {sender_user} but is not allowed to see it, returning 404"); debug_warn!(req_evt = %event_id, ?base_id, %room_id, "Event requested by {sender_user} but is not allowed to see it, returning 404");
return Err!(Request(NotFound("Event not found."))); return Err!(Request(NotFound("Event not found.")));
} }

2
src/api/client/device.rs
View file

@ -49,7 +49,7 @@ pub(crate) async fn get_device_route(
/// # `PUT /_matrix/client/r0/devices/{deviceId}` /// # `PUT /_matrix/client/r0/devices/{deviceId}`
/// ///
/// Updates the metadata on a given device of the sender user. /// Updates the metadata on a given device of the sender user.
#[tracing::instrument(skip_all, fields(%client), name = "update_device")] #[tracing::instrument(skip_all, fields(%client), name = "update_device", level = "debug")]
pub(crate) async fn update_device_route( pub(crate) async fn update_device_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,

6
src/api/client/directory.rs
View file

@ -44,7 +44,7 @@ use crate::Ruma;
/// Lists the public rooms on this server. /// Lists the public rooms on this server.
/// ///
/// - Rooms are ordered by the number of joined members /// - Rooms are ordered by the number of joined members
#[tracing::instrument(skip_all, fields(%client), name = "publicrooms")] #[tracing::instrument(skip_all, fields(%client), name = "publicrooms", level = "info")]
pub(crate) async fn get_public_rooms_filtered_route( pub(crate) async fn get_public_rooms_filtered_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -80,7 +80,7 @@ pub(crate) async fn get_public_rooms_filtered_route(
/// Lists the public rooms on this server. /// Lists the public rooms on this server.
/// ///
/// - Rooms are ordered by the number of joined members /// - Rooms are ordered by the number of joined members
#[tracing::instrument(skip_all, fields(%client), name = "publicrooms")] #[tracing::instrument(skip_all, fields(%client), name = "publicrooms", level = "info")]
pub(crate) async fn get_public_rooms_route( pub(crate) async fn get_public_rooms_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -116,7 +116,7 @@ pub(crate) async fn get_public_rooms_route(
/// # `PUT /_matrix/client/r0/directory/list/room/{roomId}` /// # `PUT /_matrix/client/r0/directory/list/room/{roomId}`
/// ///
/// Sets the visibility of a given room in the room directory. /// Sets the visibility of a given room in the room directory.
#[tracing::instrument(skip_all, fields(%client), name = "room_directory")] #[tracing::instrument(skip_all, fields(%client), name = "room_directory", level = "info")]
pub(crate) async fn set_room_visibility_route( pub(crate) async fn set_room_visibility_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,

8
src/api/client/keys.rs
View file

@ -52,7 +52,7 @@ pub(crate) async fn upload_keys_route(
.deserialize() .deserialize()
.inspect_err(|e| { .inspect_err(|e| {
debug_warn!( debug_warn!(
?key_id, %key_id,
?one_time_key, ?one_time_key,
"Invalid one time key JSON submitted by client, skipping: {e}" "Invalid one time key JSON submitted by client, skipping: {e}"
); );
@ -94,8 +94,8 @@ pub(crate) async fn upload_keys_route(
{ {
if existing_keys.json().get() == device_keys.json().get() { if existing_keys.json().get() == device_keys.json().get() {
debug!( debug!(
?sender_user, %sender_user,
?sender_device, %sender_device,
?device_keys, ?device_keys,
"Ignoring user uploaded keys as they are an exact copy already in the \ "Ignoring user uploaded keys as they are an exact copy already in the \
database" database"
@ -338,7 +338,7 @@ pub(crate) async fn upload_signatures_route(
for (user_id, keys) in &body.signed_keys { for (user_id, keys) in &body.signed_keys {
for (key_id, key) in keys { for (key_id, key) in keys {
let Ok(key) = serde_json::to_value(key) let Ok(key) = serde_json::to_value(key)
.inspect_err(|e| debug_warn!(?key_id, "Invalid \"key\" JSON: {e}")) .inspect_err(|e| debug_warn!(%key_id, "Invalid \"key\" JSON: {e}"))
else { else {
continue; continue;
}; };

2
src/api/client/membership/invite.rs
View file

@ -21,7 +21,7 @@ use crate::Ruma;
/// # `POST /_matrix/client/r0/rooms/{roomId}/invite` /// # `POST /_matrix/client/r0/rooms/{roomId}/invite`
/// ///
/// Tries to send an invite event into the room. /// Tries to send an invite event into the room.
#[tracing::instrument(skip_all, fields(%client), name = "invite")] #[tracing::instrument(skip_all, fields(%client), name = "invite", level = "info")]
pub(crate) async fn invite_user_route( pub(crate) async fn invite_user_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,

8
src/api/client/membership/join.rs
View file

@ -59,7 +59,7 @@ use crate::Ruma;
/// rules locally /// rules locally
/// - If the server does not know about the room: asks other servers over /// - If the server does not know about the room: asks other servers over
/// federation /// federation
#[tracing::instrument(skip_all, fields(%client), name = "join")] #[tracing::instrument(skip_all, fields(%client), name = "join", level = "info")]
pub(crate) async fn join_room_by_id_route( pub(crate) async fn join_room_by_id_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -131,7 +131,7 @@ pub(crate) async fn join_room_by_id_route(
/// - If the server does not know about the room: use the server name query /// - If the server does not know about the room: use the server name query
/// param if specified. if not specified, asks other servers over federation /// param if specified. if not specified, asks other servers over federation
/// via room alias server name and room ID server name /// via room alias server name and room ID server name
#[tracing::instrument(skip_all, fields(%client), name = "join")] #[tracing::instrument(skip_all, fields(%client), name = "join", level = "info")]
pub(crate) async fn join_room_by_id_or_alias_route( pub(crate) async fn join_room_by_id_or_alias_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -351,7 +351,7 @@ pub async fn join_room_by_id_helper(
Ok(join_room_by_id::v3::Response::new(room_id.to_owned())) Ok(join_room_by_id::v3::Response::new(room_id.to_owned()))
} }
#[tracing::instrument(skip_all, fields(%sender_user, %room_id), name = "join_remote")] #[tracing::instrument(skip_all, fields(%sender_user, %room_id), name = "join_remote", level = "info")]
async fn join_room_by_id_helper_remote( async fn join_room_by_id_helper_remote(
services: &Services, services: &Services,
sender_user: &UserId, sender_user: &UserId,
@ -709,7 +709,7 @@ async fn join_room_by_id_helper_remote(
Ok(()) Ok(())
} }
#[tracing::instrument(skip_all, fields(%sender_user, %room_id), name = "join_local")] #[tracing::instrument(skip_all, fields(%sender_user, %room_id), name = "join_local", level = "info")]
async fn join_room_by_id_helper_local( async fn join_room_by_id_helper_local(
services: &Services, services: &Services,
sender_user: &UserId, sender_user: &UserId,

2
src/api/client/membership/knock.rs
View file

@ -44,7 +44,7 @@ use crate::Ruma;
/// # `POST /_matrix/client/*/knock/{roomIdOrAlias}` /// # `POST /_matrix/client/*/knock/{roomIdOrAlias}`
/// ///
/// Tries to knock the room to ask permission to join for the sender user. /// Tries to knock the room to ask permission to join for the sender user.
#[tracing::instrument(skip_all, fields(%client), name = "knock")] #[tracing::instrument(skip_all, fields(%client), name = "knock", level = "info")]
pub(crate) async fn knock_room_route( pub(crate) async fn knock_room_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,

2
src/api/client/membership/mod.rs
View file

@ -63,7 +63,7 @@ pub(crate) async fn joined_rooms_route(
/// ///
/// Performs automatic deactivation if `auto_deactivate_banned_room_attempts` is /// Performs automatic deactivation if `auto_deactivate_banned_room_attempts` is
/// enabled /// enabled
#[tracing::instrument(skip(services))] #[tracing::instrument(skip(services), level = "info")]
pub(crate) async fn banned_room_check( pub(crate) async fn banned_room_check(
services: &Services, services: &Services,
user_id: &UserId, user_id: &UserId,

2
src/api/client/relations.rs
View file

@ -115,7 +115,7 @@ async fn paginate_relations_with_filter(
.user_can_see_event(sender_user, room_id, target) .user_can_see_event(sender_user, room_id, target)
.await .await
{ {
debug_warn!(req_evt = ?target, ?room_id, "Event relations requested by {sender_user} but is not allowed to see it, returning 404"); debug_warn!(req_evt = %target, %room_id, "Event relations requested by {sender_user} but is not allowed to see it, returning 404");
return Err!(Request(NotFound("Event not found."))); return Err!(Request(NotFound("Event not found.")));
} }

6
src/api/client/report.rs
View file

@ -29,7 +29,7 @@ struct Report {
/// # `POST /_matrix/client/v3/rooms/{roomId}/report` /// # `POST /_matrix/client/v3/rooms/{roomId}/report`
/// ///
/// Reports an abusive room to homeserver admins /// Reports an abusive room to homeserver admins
#[tracing::instrument(skip_all, fields(%client), name = "report_room")] #[tracing::instrument(skip_all, fields(%client), name = "report_room", level = "info")]
pub(crate) async fn report_room_route( pub(crate) async fn report_room_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -85,7 +85,7 @@ pub(crate) async fn report_room_route(
/// # `POST /_matrix/client/v3/rooms/{roomId}/report/{eventId}` /// # `POST /_matrix/client/v3/rooms/{roomId}/report/{eventId}`
/// ///
/// Reports an inappropriate event to homeserver admins /// Reports an inappropriate event to homeserver admins
#[tracing::instrument(skip_all, fields(%client), name = "report_event")] #[tracing::instrument(skip_all, fields(%client), name = "report_event", level = "info")]
pub(crate) async fn report_event_route( pub(crate) async fn report_event_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -133,7 +133,7 @@ pub(crate) async fn report_event_route(
Ok(report_content::v3::Response {}) Ok(report_content::v3::Response {})
} }
#[tracing::instrument(skip_all, fields(%client), name = "report_user")] #[tracing::instrument(skip_all, fields(%client), name = "report_user", level = "info")]
pub(crate) async fn report_user_route( pub(crate) async fn report_user_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,

8
src/api/client/room/create.rs
View file

@ -492,7 +492,7 @@ pub(crate) async fn create_room_route(
.boxed() .boxed()
.await .await
{ {
warn!(%e, "Failed to send invite"); warn!(?e, "Failed to send invite");
} }
} }
@ -627,7 +627,7 @@ async fn room_alias_check(
.map_err(|e| { .map_err(|e| {
err!(Request(InvalidParam(debug_error!( err!(Request(InvalidParam(debug_error!(
?e, ?e,
?room_alias_name, %room_alias_name,
"Failed to parse room alias.", "Failed to parse room alias.",
)))) ))))
})?; })?;
@ -711,7 +711,7 @@ fn custom_room_id_check(services: &Services, custom_room_id: &str) -> Result<Own
} }
}) })
.inspect(|full_room_id| { .inspect(|full_room_id| {
debug_info!(?full_room_id, "Full custom room ID"); debug_info!(%full_room_id, "Full custom room ID");
}) })
.inspect_err(|e| warn!(?e, ?custom_room_id, "Failed to create room with custom room ID",)) .inspect_err(|e| warn!(?e, %custom_room_id, "Failed to create room with custom room ID",))
} }

9
src/api/client/room/summary.rs
View file

@ -46,7 +46,7 @@ pub(crate) async fn get_room_summary_legacy(
/// # `GET /_matrix/client/v1/room_summary/{roomIdOrAlias}` /// # `GET /_matrix/client/v1/room_summary/{roomIdOrAlias}`
/// ///
/// Returns a short description of the state of a room. /// Returns a short description of the state of a room.
#[tracing::instrument(skip_all, fields(%client), name = "room_summary")] #[tracing::instrument(skip_all, fields(%client), name = "room_summary", level = "info")]
pub(crate) async fn get_room_summary( pub(crate) async fn get_room_summary(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -116,7 +116,10 @@ async fn local_room_summary_response(
room_id: &RoomId, room_id: &RoomId,
sender_user: Option<&UserId>, sender_user: Option<&UserId>,
) -> Result<get_summary::msc3266::Response> { ) -> Result<get_summary::msc3266::Response> {
trace!(?sender_user, "Sending local room summary response for {room_id:?}"); trace!(
sender_user = sender_user.map(tracing::field::display),
"Sending local room summary response for {room_id:?}"
);
let (join_rule, world_readable, guest_can_join) = join3( let (join_rule, world_readable, guest_can_join) = join3(
services.rooms.state_accessor.get_join_rules(room_id), services.rooms.state_accessor.get_join_rules(room_id),
services.rooms.state_accessor.is_world_readable(room_id), services.rooms.state_accessor.is_world_readable(room_id),
@ -228,7 +231,7 @@ async fn remote_room_summary_hierarchy_response(
servers: &[OwnedServerName], servers: &[OwnedServerName],
sender_user: Option<&UserId>, sender_user: Option<&UserId>,
) -> Result<SpaceHierarchyParentSummary> { ) -> Result<SpaceHierarchyParentSummary> {
trace!(?sender_user, ?servers, "Sending remote room summary response for {room_id:?}"); trace!(sender_user = ?sender_user.map(tracing::field::display), ?servers, "Sending remote room summary response for {room_id:?}");
if !services.config.allow_federation { if !services.config.allow_federation {
return Err!(Request(Forbidden("Federation is disabled."))); return Err!(Request(Forbidden("Federation is disabled.")));
} }

14
src/api/client/session.rs
View file

@ -35,7 +35,7 @@ use crate::Ruma;
/// ///
/// Get the supported login types of this server. One of these should be used as /// Get the supported login types of this server. One of these should be used as
/// the `type` field when logging in. /// the `type` field when logging in.
#[tracing::instrument(skip_all, fields(%client), name = "login")] #[tracing::instrument(skip_all, fields(%client), name = "login", level = "info")]
pub(crate) async fn get_login_types_route( pub(crate) async fn get_login_types_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -53,7 +53,7 @@ pub(crate) async fn get_login_types_route(
/// Authenticates the given user by its ID and its password. /// Authenticates the given user by its ID and its password.
/// ///
/// Returns the user ID if successful, and an error otherwise. /// Returns the user ID if successful, and an error otherwise.
#[tracing::instrument(skip_all, fields(%user_id), name = "password")] #[tracing::instrument(skip_all, fields(%user_id), name = "password", level = "debug")]
pub(crate) async fn password_login( pub(crate) async fn password_login(
services: &Services, services: &Services,
user_id: &UserId, user_id: &UserId,
@ -96,7 +96,7 @@ pub(crate) async fn password_login(
/// ///
/// Creates the user if the user is found in the LDAP and do not already have an /// Creates the user if the user is found in the LDAP and do not already have an
/// account. /// account.
#[tracing::instrument(skip_all, fields(%user_id), name = "ldap")] #[tracing::instrument(skip_all, fields(%user_id), name = "ldap", level = "debug")]
pub(super) async fn ldap_login( pub(super) async fn ldap_login(
services: &Services, services: &Services,
user_id: &UserId, user_id: &UserId,
@ -212,7 +212,7 @@ pub(crate) async fn handle_login(
/// Note: You can use [`GET /// Note: You can use [`GET
/// /_matrix/client/r0/login`](fn.get_supported_versions_route.html) to see /// /_matrix/client/r0/login`](fn.get_supported_versions_route.html) to see
/// supported login types. /// supported login types.
#[tracing::instrument(skip_all, fields(%client), name = "login")] #[tracing::instrument(skip_all, fields(%client), name = "login", level = "info")]
pub(crate) async fn login_route( pub(crate) async fn login_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -345,7 +345,7 @@ pub(crate) async fn login_route(
/// to log in with the m.login.token flow. /// to log in with the m.login.token flow.
/// ///
/// <https://spec.matrix.org/v1.13/client-server-api/#post_matrixclientv1loginget_token> /// <https://spec.matrix.org/v1.13/client-server-api/#post_matrixclientv1loginget_token>
#[tracing::instrument(skip_all, fields(%client), name = "login_token")] #[tracing::instrument(skip_all, fields(%client), name = "login_token", level = "info")]
pub(crate) async fn login_token_route( pub(crate) async fn login_token_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -413,7 +413,7 @@ pub(crate) async fn login_token_route(
/// last seen ts) /// last seen ts)
/// - Forgets to-device events /// - Forgets to-device events
/// - Triggers device list updates /// - Triggers device list updates
#[tracing::instrument(skip_all, fields(%client), name = "logout")] #[tracing::instrument(skip_all, fields(%client), name = "logout", level = "info")]
pub(crate) async fn logout_route( pub(crate) async fn logout_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,
@ -440,7 +440,7 @@ pub(crate) async fn logout_route(
/// Note: This is equivalent to calling [`GET /// Note: This is equivalent to calling [`GET
/// /_matrix/client/r0/logout`](fn.logout_route.html) from each device of this /// /_matrix/client/r0/logout`](fn.logout_route.html) from each device of this
/// user. /// user.
#[tracing::instrument(skip_all, fields(%client), name = "logout")] #[tracing::instrument(skip_all, fields(%client), name = "logout", level = "info")]
pub(crate) async fn logout_all_route( pub(crate) async fn logout_all_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,

14
src/api/client/state.rs
View file

@ -140,8 +140,8 @@ pub(crate) async fn get_state_events_for_key_route(
.await .await
.map_err(|_| { .map_err(|_| {
err!(Request(NotFound(debug_warn!( err!(Request(NotFound(debug_warn!(
room_id = ?body.room_id, room_id = %body.room_id,
event_type = ?body.event_type, event_type = %body.event_type,
"State event not found in room.", "State event not found in room.",
)))) ))))
})?; })?;
@ -226,7 +226,7 @@ async fn allowed_to_send_state_event(
match event_type { match event_type {
| StateEventType::RoomCreate => { | StateEventType::RoomCreate => {
return Err!(Request(BadJson(debug_warn!( return Err!(Request(BadJson(debug_warn!(
?room_id, %room_id,
"You cannot update m.room.create after a room has been created." "You cannot update m.room.create after a room has been created."
)))); ))));
}, },
@ -237,7 +237,7 @@ async fn allowed_to_send_state_event(
| Ok(acl_content) => { | Ok(acl_content) => {
if acl_content.allow_is_empty() { if acl_content.allow_is_empty() {
return Err!(Request(BadJson(debug_warn!( return Err!(Request(BadJson(debug_warn!(
?room_id, %room_id,
"Sending an ACL event with an empty allow key will permanently \ "Sending an ACL event with an empty allow key will permanently \
brick the room for non-conduwuit's as this equates to no servers \ brick the room for non-conduwuit's as this equates to no servers \
being allowed to participate in this room." being allowed to participate in this room."
@ -246,7 +246,7 @@ async fn allowed_to_send_state_event(
if acl_content.deny_contains("*") && acl_content.allow_contains("*") { if acl_content.deny_contains("*") && acl_content.allow_contains("*") {
return Err!(Request(BadJson(debug_warn!( return Err!(Request(BadJson(debug_warn!(
?room_id, %room_id,
"Sending an ACL event with a deny and allow key value of \"*\" will \ "Sending an ACL event with a deny and allow key value of \"*\" will \
permanently brick the room for non-conduwuit's as this equates to \ permanently brick the room for non-conduwuit's as this equates to \
no servers being allowed to participate in this room." no servers being allowed to participate in this room."
@ -258,7 +258,7 @@ async fn allowed_to_send_state_event(
&& !acl_content.allow_contains(services.globals.server_name().as_str()) && !acl_content.allow_contains(services.globals.server_name().as_str())
{ {
return Err!(Request(BadJson(debug_warn!( return Err!(Request(BadJson(debug_warn!(
?room_id, %room_id,
"Sending an ACL event with a deny key value of \"*\" and without \ "Sending an ACL event with a deny key value of \"*\" and without \
your own server name in the allow key will result in you being \ your own server name in the allow key will result in you being \
unable to participate in this room." unable to participate in this room."
@ -270,7 +270,7 @@ async fn allowed_to_send_state_event(
&& !acl_content.allow_contains(services.globals.server_name().as_str()) && !acl_content.allow_contains(services.globals.server_name().as_str())
{ {
return Err!(Request(BadJson(debug_warn!( return Err!(Request(BadJson(debug_warn!(
?room_id, %room_id,
"Sending an ACL event for an allow key without \"*\" and without \ "Sending an ACL event for an allow key without \"*\" and without \
your own server name in the allow key will result in you being \ your own server name in the allow key will result in you being \
unable to participate in this room." unable to participate in this room."

10
src/api/client/sync/v3/joined.rs
View file

@ -50,8 +50,8 @@ use crate::client::{
level = "debug", level = "debug",
skip_all, skip_all,
fields( fields(
room_id = ?room_id, room_id = %room_id,
syncing_user = ?sync_context.syncing_user, syncing_user = %sync_context.syncing_user,
), ),
)] )]
pub(super) async fn load_joined_room( pub(super) async fn load_joined_room(
@ -578,7 +578,7 @@ async fn build_notification_counts(
) )
.await; .await;
trace!(?notification_count, ?highlight_count, "syncing new notification counts"); trace!(%notification_count, %highlight_count, "syncing new notification counts");
Ok(Some(UnreadNotificationsCount { Ok(Some(UnreadNotificationsCount {
notification_count: Some(notification_count), notification_count: Some(notification_count),
@ -692,8 +692,8 @@ async fn build_room_summary(
}; };
trace!( trace!(
?joined_member_count, %joined_member_count,
?invited_member_count, %invited_member_count,
heroes_length = heroes.as_ref().map(HashSet::len), heroes_length = heroes.as_ref().map(HashSet::len),
"syncing updated summary" "syncing updated summary"
); );

4
src/api/client/sync/v3/left.rs
View file

@ -307,8 +307,8 @@ async fn build_left_state_and_timeline(
} }
trace!( trace!(
?timeline_start_count, %timeline_start_count,
?timeline_end_count, %timeline_end_count,
"syncing {} timeline events (limited = {}) and {} state events", "syncing {} timeline events (limited = {}) and {} state events",
timeline.pdus.len(), timeline.pdus.len(),
timeline.limited, timeline.limited,

2
src/api/client/sync/v3/mod.rs
View file

@ -275,7 +275,7 @@ pub(crate) async fn build_sync_events(
match joined_room { match joined_room {
| Ok((room, updates)) => Some((room_id, room, updates)), | Ok((room, updates)) => Some((room_id, room, updates)),
| Err(err) => { | Err(err) => {
warn!(?err, ?room_id, "error loading joined room {}", room_id); warn!(?err, %room_id, "error loading joined room");
None None
}, },
} }

2
src/api/client/sync/v3/state.rs
View file

@ -217,7 +217,7 @@ pub(super) async fn build_state_incremental<'a>(
the performance penalty is acceptable. the performance penalty is acceptable.
*/ */
trace!(?timeline_is_linear, ?timeline.limited, "computing state for incremental sync"); trace!(%timeline_is_linear, %timeline.limited, "computing state for incremental sync");
// fetch the shorteventids of state events in the timeline // fetch the shorteventids of state events in the timeline
let state_events_in_timeline: BTreeSet<ShortEventId> = services let state_events_in_timeline: BTreeSet<ShortEventId> = services

2
src/api/client/unstable.rs
View file

@ -26,7 +26,7 @@ use crate::Ruma;
/// TODO: Implement pagination, currently this just returns everything /// TODO: Implement pagination, currently this just returns everything
/// ///
/// An implementation of [MSC2666](https://github.com/matrix-org/matrix-spec-proposals/pull/2666) /// An implementation of [MSC2666](https://github.com/matrix-org/matrix-spec-proposals/pull/2666)
#[tracing::instrument(skip_all, fields(%client), name = "mutual_rooms")] #[tracing::instrument(skip_all, fields(%client), name = "mutual_rooms", level = "info")]
pub(crate) async fn get_mutual_rooms_route( pub(crate) async fn get_mutual_rooms_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,

6
src/api/server/get_missing_events.rs
View file

@ -40,7 +40,7 @@ pub(crate) async fn get_missing_events_route(
while i < queued_events.len() && events.len() < limit { while i < queued_events.len() && events.len() < limit {
let Ok(pdu) = services.rooms.timeline.get_pdu(&queued_events[i]).await else { let Ok(pdu) = services.rooms.timeline.get_pdu(&queued_events[i]).await else {
debug!( debug!(
?body.origin, body.origin = body.origin.as_ref().map(tracing::field::display),
"Event {} does not exist locally, skipping", &queued_events[i] "Event {} does not exist locally, skipping", &queued_events[i]
); );
i = i.saturating_add(1); i = i.saturating_add(1);
@ -59,7 +59,7 @@ pub(crate) async fn get_missing_events_route(
.await .await
{ {
debug!( debug!(
?body.origin, body.origin = body.origin.as_ref().map(tracing::field::display),
"Server cannot see {:?} in {:?}, skipping", pdu.event_id, pdu.room_id "Server cannot see {:?} in {:?}, skipping", pdu.event_id, pdu.room_id
); );
i = i.saturating_add(1); i = i.saturating_add(1);
@ -68,7 +68,7 @@ pub(crate) async fn get_missing_events_route(
let Ok(event) = to_canonical_object(&pdu) else { let Ok(event) = to_canonical_object(&pdu) else {
debug_error!( debug_error!(
?body.origin, body.origin = body.origin.as_ref().map(tracing::field::display),
"Failed to convert PDU in database to canonical JSON: {pdu:?}" "Failed to convert PDU in database to canonical JSON: {pdu:?}"
); );
i = i.saturating_add(1); i = i.saturating_add(1);

2
src/api/server/invite.rs
View file

@ -19,7 +19,7 @@ use crate::Ruma;
/// # `PUT /_matrix/federation/v2/invite/{roomId}/{eventId}` /// # `PUT /_matrix/federation/v2/invite/{roomId}/{eventId}`
/// ///
/// Invites a remote user to a room. /// Invites a remote user to a room.
#[tracing::instrument(skip_all, fields(%client), name = "invite")] #[tracing::instrument(skip_all, fields(%client), name = "invite", level = "info")]
pub(crate) async fn create_invite_route( pub(crate) async fn create_invite_route(
State(services): State<crate::State>, State(services): State<crate::State>,
InsecureClientIp(client): InsecureClientIp, InsecureClientIp(client): InsecureClientIp,

2
src/api/server/make_join.rs
View file

@ -22,7 +22,7 @@ use crate::Ruma;
/// # `GET /_matrix/federation/v1/make_join/{roomId}/{userId}` /// # `GET /_matrix/federation/v1/make_join/{roomId}/{userId}`
/// ///
/// Creates a join template. /// Creates a join template.
#[tracing::instrument(skip_all, fields(room_id = %body.room_id, user_id = %body.user_id, origin = %body.origin()))] #[tracing::instrument(skip_all, fields(room_id = %body.room_id, user_id = %body.user_id, origin = %body.origin()), level = "info")]
pub(crate) async fn create_join_event_template_route( pub(crate) async fn create_join_event_template_route(
State(services): State<crate::State>, State(services): State<crate::State>,
body: Ruma<prepare_join_event::v1::Request>, body: Ruma<prepare_join_event::v1::Request>,

14
src/api/server/send.rs
View file

@ -3,9 +3,7 @@ use std::{collections::BTreeMap, net::IpAddr, time::Instant};
use axum::extract::State; use axum::extract::State;
use axum_client_ip::InsecureClientIp; use axum_client_ip::InsecureClientIp;
use conduwuit::{ use conduwuit::{
Err, Error, Result, debug, Err, Error, Result, debug, debug_warn, err, error,
debug::INFO_SPAN_LEVEL,
debug_warn, err, error,
result::LogErr, result::LogErr,
trace, trace,
utils::{ utils::{
@ -48,7 +46,7 @@ type Pdu = (OwnedRoomId, OwnedEventId, CanonicalJsonObject);
/// Push EDUs and PDUs to this server. /// Push EDUs and PDUs to this server.
#[tracing::instrument( #[tracing::instrument(
name = "txn", name = "txn",
level = INFO_SPAN_LEVEL, level = "debug",
skip_all, skip_all,
fields( fields(
%client, %client,
@ -83,8 +81,8 @@ pub(crate) async fn send_transaction_message_route(
pdus = body.pdus.len(), pdus = body.pdus.len(),
edus = body.edus.len(), edus = body.edus.len(),
elapsed = ?txn_start_time.elapsed(), elapsed = ?txn_start_time.elapsed(),
id = ?body.transaction_id, id = %body.transaction_id,
origin =?body.origin(), origin = %body.origin(),
"Starting txn", "Starting txn",
); );
@ -110,8 +108,8 @@ pub(crate) async fn send_transaction_message_route(
pdus = body.pdus.len(), pdus = body.pdus.len(),
edus = body.edus.len(), edus = body.edus.len(),
elapsed = ?txn_start_time.elapsed(), elapsed = ?txn_start_time.elapsed(),
id = ?body.transaction_id, id = %body.transaction_id,
origin =?body.origin(), origin = %body.origin(),
"Finished txn", "Finished txn",
); );
for (id, result) in &results { for (id, result) in &results {

2
src/api/server/send_join.rs
View file

@ -26,7 +26,7 @@ use serde_json::value::{RawValue as RawJsonValue, to_raw_value};
use crate::Ruma; use crate::Ruma;
/// helper method for /send_join v1 and v2 /// helper method for /send_join v1 and v2
#[tracing::instrument(skip(services, pdu, omit_members), fields(room_id = room_id.as_str(), origin = origin.as_str()))] #[tracing::instrument(skip(services, pdu, omit_members), fields(room_id = room_id.as_str(), origin = origin.as_str()), level = "info")]
async fn create_join_event( async fn create_join_event(
services: &Services, services: &Services,
origin: &ServerName, origin: &ServerName,

4
src/core/alloc/je.rs
View file

@ -340,7 +340,7 @@ where
#[tracing::instrument( #[tracing::instrument(
name = "get", name = "get",
level = "trace" level = "trace",
skip_all, skip_all,
fields(?key) fields(?key)
)] )]
@ -357,7 +357,7 @@ where
#[tracing::instrument( #[tracing::instrument(
name = "xchg", name = "xchg",
level = "trace" level = "trace",
skip_all, skip_all,
fields(?key, ?val) fields(?key, ?val)
)] )]

2
src/core/config/manager.rs
View file

@ -59,7 +59,7 @@ impl Deref for Manager {
/// Update the active configuration, returning prior configuration. /// Update the active configuration, returning prior configuration.
#[implement(Manager)] #[implement(Manager)]
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all, level = "info")]
pub fn update(&self, config: Config) -> Result<Arc<Config>> { pub fn update(&self, config: Config) -> Result<Arc<Config>> {
let config = Arc::new(config); let config = Arc::new(config);
let new = Arc::into_raw(config); let new = Arc::into_raw(config);

21
src/core/matrix/state_res/event_auth.rs
View file

@ -532,8 +532,8 @@ where
if sender_power_level < invite_level { if sender_power_level < invite_level {
warn!( warn!(
%sender, %sender,
has=?sender_power_level, has=%sender_power_level,
required=?invite_level, required=%invite_level,
"sender cannot send invites in this room" "sender cannot send invites in this room"
); );
return Ok(false); return Ok(false);
@ -605,8 +605,8 @@ where
if !check_redaction(room_version, incoming_event, sender_power_level, redact_level)? { if !check_redaction(room_version, incoming_event, sender_power_level, redact_level)? {
warn!( warn!(
%sender, %sender,
?sender_power_level, %sender_power_level,
?redact_level, %redact_level,
"redaction event was not allowed" "redaction event was not allowed"
); );
return Ok(false); return Ok(false);
@ -772,11 +772,12 @@ where
power_levels_event.as_ref().is_some(), power_levels_event.as_ref().is_some(),
) || auth_user_pl >= invite_level; ) || auth_user_pl >= invite_level;
trace!( trace!(
auth_user_pl=?auth_user_pl, %auth_user_pl,
invite_level=?invite_level, %auth_user_pl,
user_joined=?user_joined, %invite_level,
okay_power=?okay_power, %user_joined,
passing=?(user_joined && okay_power), %okay_power,
passing=%(user_joined && okay_power),
"user for join auth is valid check details" "user for join auth is valid check details"
); );
user_joined && okay_power user_joined && okay_power
@ -1211,7 +1212,7 @@ fn can_send_event(event: &impl Event, ple: Option<&impl Event>, user_level: Int)
{ {
warn!( warn!(
%user_level, %user_level,
required=?event_type_power_level, required=%event_type_power_level,
state_key=?event.state_key(), state_key=?event.state_key(),
sender=%event.sender(), sender=%event.sender(),
"state_key starts with @ but does not match sender", "state_key starts with @ but does not match sender",

2
src/database/engine/backup.rs
View file

@ -7,7 +7,7 @@ use super::Engine;
use crate::util::map_err; use crate::util::map_err;
#[implement(Engine)] #[implement(Engine)]
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self), level = "info")]
pub fn backup(&self) -> Result { pub fn backup(&self) -> Result {
let mut engine = self.backup_engine()?; let mut engine = self.backup_engine()?;
let config = &self.ctx.server.config; let config = &self.ctx.server.config;

2
src/database/engine/logger.rs
View file

@ -4,7 +4,7 @@ use rocksdb::LogLevel;
#[tracing::instrument( #[tracing::instrument(
parent = None, parent = None,
name = "rocksdb", name = "rocksdb",
level = "trace" level = "trace",
skip(msg), skip(msg),
)] )]
pub(crate) fn handle(level: LogLevel, msg: &str) { pub(crate) fn handle(level: LogLevel, msg: &str) {

6
src/database/engine/open.rs
View file

@ -17,7 +17,7 @@ use super::{
use crate::{Context, or_else}; use crate::{Context, or_else};
#[implement(Engine)] #[implement(Engine)]
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all, level = "info")]
pub(crate) async fn open(ctx: Arc<Context>, desc: &[Descriptor]) -> Result<Arc<Self>> { pub(crate) async fn open(ctx: Arc<Context>, desc: &[Descriptor]) -> Result<Arc<Self>> {
let server = &ctx.server; let server = &ctx.server;
let config = &server.config; let config = &server.config;
@ -63,7 +63,7 @@ pub(crate) async fn open(ctx: Arc<Context>, desc: &[Descriptor]) -> Result<Arc<S
} }
#[implement(Engine)] #[implement(Engine)]
#[tracing::instrument(name = "configure", skip_all)] #[tracing::instrument(name = "configure", skip_all, level = "debug")]
fn configure_cfds( fn configure_cfds(
ctx: &Arc<Context>, ctx: &Arc<Context>,
db_opts: &Options, db_opts: &Options,
@ -119,7 +119,7 @@ fn configure_cfds(
} }
#[implement(Engine)] #[implement(Engine)]
#[tracing::instrument(name = "discover", skip_all)] #[tracing::instrument(name = "discover", skip_all, level = "debug")]
fn discover_cfs(path: &Path, opts: &Options) -> BTreeSet<String> { fn discover_cfs(path: &Path, opts: &Options) -> BTreeSet<String> {
Db::list_cf(opts, path) Db::list_cf(opts, path)
.unwrap_or_default() .unwrap_or_default()

2
src/database/map/compact.rs
View file

@ -26,7 +26,7 @@ pub struct Options {
#[implement(super::Map)] #[implement(super::Map)]
#[tracing::instrument( #[tracing::instrument(
name = "compact", name = "compact",
level = "info" level = "info",
skip(self), skip(self),
fields(%self), fields(%self),
)] )]

8
src/database/pool.rs
View file

@ -113,7 +113,7 @@ impl Drop for Pool {
} }
#[implement(Pool)] #[implement(Pool)]
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all, level = "debug")]
pub(crate) fn close(&self) { pub(crate) fn close(&self) {
let workers = take(&mut *self.workers.lock()); let workers = take(&mut *self.workers.lock());
@ -147,8 +147,8 @@ pub(crate) fn close(&self) {
.map(|result| result.map_err(Error::from_panic)) .map(|result| result.map_err(Error::from_panic))
.enumerate() .enumerate()
.for_each(|(id, result)| match result { .for_each(|(id, result)| match result {
| Ok(()) => trace!(?id, "worker joined"), | Ok(()) => trace!(%id, "worker joined"),
| Err(error) => error!(?id, "worker joined with error: {error}"), | Err(error) => error!(%id, "worker joined with error: {error}"),
}); });
} }
@ -297,7 +297,7 @@ fn worker_init(&self, id: usize) {
} }
debug!( debug!(
?group, %group,
affinity = ?affinity.collect::<Vec<_>>(), affinity = ?affinity.collect::<Vec<_>>(),
"worker ready" "worker ready"
); );

18
src/database/pool/configure.rs
View file

@ -105,8 +105,8 @@ pub(super) fn configure(server: &Arc<Server>) -> (usize, Vec<usize>, Vec<usize>)
.unwrap_or("None"), .unwrap_or("None"),
?worker_counts, ?worker_counts,
?queue_sizes, ?queue_sizes,
?total_workers, %total_workers,
stream_width = ?stream::automatic_width(), stream_width = %stream::automatic_width(),
"Frontend topology", "Frontend topology",
); );
@ -139,13 +139,13 @@ fn update_stream_width(server: &Arc<Server>, num_queues: usize, total_workers: u
let (old_width, new_width) = stream::set_width(req_width); let (old_width, new_width) = stream::set_width(req_width);
let (old_amp, new_amp) = stream::set_amplification(req_amp); let (old_amp, new_amp) = stream::set_amplification(req_amp);
debug!( debug!(
scale = ?config.stream_width_scale, scale = %config.stream_width_scale,
?num_queues, %num_queues,
?req_width, %req_width,
?old_width, %old_width,
?new_width, %new_width,
?old_amp, %old_amp,
?new_amp, %new_amp,
"Updated global stream width" "Updated global stream width"
); );
} }

5
src/main/logging.rs
View file

@ -6,6 +6,7 @@ use conduwuit_core::{
debug_warn, err, debug_warn, err,
log::{ConsoleFormat, ConsoleWriter, LogLevelReloadHandles, capture, fmt_span}, log::{ConsoleFormat, ConsoleWriter, LogLevelReloadHandles, capture, fmt_span},
result::UnwrapOrErr, result::UnwrapOrErr,
warn,
}; };
#[cfg(feature = "otlp_telemetry")] #[cfg(feature = "otlp_telemetry")]
use opentelemetry::trace::TracerProvider; use opentelemetry::trace::TracerProvider;
@ -85,7 +86,7 @@ pub(crate) fn init(
let exporter = match config.otlp_protocol.as_str() { let exporter = match config.otlp_protocol.as_str() {
| "grpc" => opentelemetry_otlp::SpanExporter::builder() | "grpc" => opentelemetry_otlp::SpanExporter::builder()
.with_tonic() .with_tonic()
.with_protocol(opentelemetry_otlp::Protocol::Grpc) .with_protocol(opentelemetry_otlp::Protocol::Grpc) // TODO: build from env when 0.32 is released
.build() .build()
.expect("Failed to create OTLP gRPC exporter"), .expect("Failed to create OTLP gRPC exporter"),
| "http" => opentelemetry_otlp::SpanExporter::builder() | "http" => opentelemetry_otlp::SpanExporter::builder()
@ -93,7 +94,7 @@ pub(crate) fn init(
.build() .build()
.expect("Failed to create OTLP HTTP exporter"), .expect("Failed to create OTLP HTTP exporter"),
| protocol => { | protocol => {
debug_warn!( warn!(
"Invalid OTLP protocol '{}', falling back to HTTP. Valid options are \ "Invalid OTLP protocol '{}', falling back to HTTP. Valid options are \
'http' or 'grpc'.", 'http' or 'grpc'.",
protocol protocol

3
src/main/mod.rs
View file

@ -50,7 +50,8 @@ pub fn run_with_args(args: &Args) -> Result<()> {
#[tracing::instrument( #[tracing::instrument(
name = "main", name = "main",
parent = None, parent = None,
skip_all skip_all,
level = "info"
)] )]
async fn async_main(server: &Arc<Server>) -> Result<(), Error> { async fn async_main(server: &Arc<Server>) -> Result<(), Error> {
extern crate conduwuit_router as router; extern crate conduwuit_router as router;

6
src/main/signal.rs
View file

@ -6,7 +6,7 @@ use tokio::signal;
use super::server::Server; use super::server::Server;
#[cfg(unix)] #[cfg(unix)]
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all, level = "info")]
pub(super) async fn signal(server: Arc<Server>) { pub(super) async fn signal(server: Arc<Server>) {
use signal::unix; use signal::unix;
use unix::SignalKind; use unix::SignalKind;
@ -39,13 +39,13 @@ pub(super) async fn signal(server: Arc<Server>) {
}; };
if let Err(e) = result { if let Err(e) = result {
debug_error!(?sig, "signal: {e}"); debug_error!(%sig, "signal: {e}");
} }
} }
} }
#[cfg(not(unix))] #[cfg(not(unix))]
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all, level = "info")]
pub(super) async fn signal(server: Arc<Server>) { pub(super) async fn signal(server: Arc<Server>) {
loop { loop {
tokio::select! { tokio::select! {

8
src/router/request.rs
View file

@ -102,13 +102,13 @@ fn handle_result(method: &Method, uri: &Uri, result: Response) -> Result<Respons
let reason = status.canonical_reason().unwrap_or("Unknown Reason"); let reason = status.canonical_reason().unwrap_or("Unknown Reason");
if status.is_server_error() { if status.is_server_error() {
error!(method = ?method, uri = ?uri, "{code} {reason}"); error!(%method, %uri, "{code} {reason}");
} else if status.is_client_error() { } else if status.is_client_error() {
debug_error!(method = ?method, uri = ?uri, "{code} {reason}"); debug_error!(%method, %uri, "{code} {reason}");
} else if status.is_redirection() { } else if status.is_redirection() {
debug!(method = ?method, uri = ?uri, "{code} {reason}"); debug!(%method, %uri, "{code} {reason}");
} else { } else {
trace!(method = ?method, uri = ?uri, "{code} {reason}"); trace!(%method, %uri, "{code} {reason}");
} }
if status == StatusCode::METHOD_NOT_ALLOWED { if status == StatusCode::METHOD_NOT_ALLOWED {

10
src/router/run.rs
View file

@ -19,7 +19,7 @@ use tokio::{
use crate::serve; use crate::serve;
/// Main loop base /// Main loop base
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all, level = "info")]
pub(crate) async fn run(services: Arc<Services>) -> Result<()> { pub(crate) async fn run(services: Arc<Services>) -> Result<()> {
let server = &services.server; let server = &services.server;
debug!("Start"); debug!("Start");
@ -58,7 +58,7 @@ pub(crate) async fn run(services: Arc<Services>) -> Result<()> {
} }
/// Async initializations /// Async initializations
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all, level = "info")]
pub(crate) async fn start(server: Arc<Server>) -> Result<Arc<Services>> { pub(crate) async fn start(server: Arc<Server>) -> Result<Arc<Services>> {
debug!("Starting..."); debug!("Starting...");
@ -73,7 +73,7 @@ pub(crate) async fn start(server: Arc<Server>) -> Result<Arc<Services>> {
} }
/// Async destructions /// Async destructions
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all, level = "info")]
pub(crate) async fn stop(services: Arc<Services>) -> Result<()> { pub(crate) async fn stop(services: Arc<Services>) -> Result<()> {
debug!("Shutting down..."); debug!("Shutting down...");
@ -108,7 +108,7 @@ pub(crate) async fn stop(services: Arc<Services>) -> Result<()> {
Ok(()) Ok(())
} }
#[tracing::instrument(skip_all)] #[tracing::instrument(skip_all, level = "info")]
async fn signal(server: Arc<Server>, tx: Sender<()>, handle: axum_server::Handle) { async fn signal(server: Arc<Server>, tx: Sender<()>, handle: axum_server::Handle) {
server server
.clone() .clone()
@ -126,7 +126,7 @@ async fn handle_shutdown(server: Arc<Server>, tx: Sender<()>, handle: axum_serve
let timeout = Duration::from_secs(timeout); let timeout = Duration::from_secs(timeout);
debug!( debug!(
?timeout, ?timeout,
handle_active = ?server.metrics.requests_handle_active.load(Ordering::Relaxed), handle_active = %server.metrics.requests_handle_active.load(Ordering::Relaxed),
"Notifying for graceful shutdown" "Notifying for graceful shutdown"
); );

2
src/service/admin/grant.rs
View file

@ -122,7 +122,7 @@ pub async fn make_user_admin(&self, user_id: &UserId) -> Result {
let room_tag = self.services.server.config.admin_room_tag.as_str(); let room_tag = self.services.server.config.admin_room_tag.as_str();
if !room_tag.is_empty() { if !room_tag.is_empty() {
if let Err(e) = self.set_room_tag(&room_id, user_id, room_tag).await { if let Err(e) = self.set_room_tag(&room_id, user_id, room_tag).await {
error!(?room_id, ?user_id, ?room_tag, "Failed to set tag for admin grant: {e}"); error!(%room_id, %user_id, %room_tag, "Failed to set tag for admin grant: {e}");
} }
} }

2
src/service/announcements/mod.rs
View file

@ -96,7 +96,7 @@ impl crate::Service for Service {
} }
if let Err(e) = self.check().await { if let Err(e) = self.check().await {
warn!(%e, "Failed to check for announcements"); warn!(?e, "Failed to check for announcements");
} }
} }

14
src/service/federation/execute.rs
View file

@ -88,7 +88,7 @@ where
let url = request.url().clone(); let url = request.url().clone();
let method = request.method().clone(); let method = request.method().clone();
debug!(?method, ?url, "Sending request"); debug!(%method, %url, "Sending request");
match client.execute(request).await { match client.execute(request).await {
| Ok(response) => handle_response::<T>(dest, actual, &method, &url, response).await, | Ok(response) => handle_response::<T>(dest, actual, &method, &url, response).await,
| Err(error) => | Err(error) =>
@ -144,9 +144,9 @@ async fn into_http_response(
) -> Result<http::Response<Bytes>> { ) -> Result<http::Response<Bytes>> {
let status = response.status(); let status = response.status();
trace!( trace!(
?status, ?method, %status, %method,
request_url = ?url, request_url = %url,
response_url = ?response.url(), response_url = %response.url(),
"Received response from {}", "Received response from {}",
actual.string(), actual.string(),
); );
@ -196,9 +196,9 @@ fn handle_error(
debug_warn!("{e:?}"); debug_warn!("{e:?}");
} else if e.is_redirect() { } else if e.is_redirect() {
debug_error!( debug_error!(
method = ?method, %method,
url = ?url, %url,
final_url = ?e.url(), final_url = e.url().map(tracing::field::display),
"Redirect loop {}: {}", "Redirect loop {}: {}",
actual.host, actual.host,
e, e,

6
src/service/media/data.rs
View file

@ -124,16 +124,16 @@ impl Data {
.next() .next()
.map(string_from_bytes) .map(string_from_bytes)
.transpose() .transpose()
.map_err(|e| err!(Database(error!(?mxc, "Content-type is invalid: {e}"))))?; .map_err(|e| err!(Database(error!(%mxc, "Content-type is invalid: {e}"))))?;
let content_disposition = parts let content_disposition = parts
.next() .next()
.map(Some) .map(Some)
.ok_or_else(|| err!(Database(error!(?mxc, "Media ID in db is invalid."))))? .ok_or_else(|| err!(Database(error!(%mxc, "Media ID in db is invalid."))))?
.filter(|bytes| !bytes.is_empty()) .filter(|bytes| !bytes.is_empty())
.map(string_from_bytes) .map(string_from_bytes)
.transpose() .transpose()
.map_err(|e| err!(Database(error!(?mxc, "Content-type is invalid: {e}"))))? .map_err(|e| err!(Database(error!(%mxc, "Content-type is invalid: {e}"))))?
.as_deref() .as_deref()
.map(str::parse) .map(str::parse)
.transpose()?; .transpose()?;

14
src/service/media/mod.rs
View file

@ -118,14 +118,14 @@ impl Service {
match self.db.search_mxc_metadata_prefix(mxc).await { match self.db.search_mxc_metadata_prefix(mxc).await {
| Ok(keys) => { | Ok(keys) => {
for key in keys { for key in keys {
trace!(?mxc, "MXC Key: {key:?}"); trace!(%mxc, "MXC Key: {key:?}");
debug_info!(?mxc, "Deleting from filesystem"); debug_info!(%mxc, "Deleting from filesystem");
if let Err(e) = self.remove_media_file(&key).await { if let Err(e) = self.remove_media_file(&key).await {
debug_error!(?mxc, "Failed to remove media file: {e}"); debug_error!(%mxc, "Failed to remove media file: {e}");
} }
debug_info!(?mxc, "Deleting from database"); debug_info!(%mxc, "Deleting from database");
self.db.delete_file_mxc(mxc).await; self.db.delete_file_mxc(mxc).await;
} }
@ -148,7 +148,7 @@ impl Service {
for mxc in mxcs { for mxc in mxcs {
let Ok(mxc) = mxc.as_str().try_into().inspect_err(|e| { let Ok(mxc) = mxc.as_str().try_into().inspect_err(|e| {
debug_error!(?mxc, "Failed to parse MXC URI from database: {e}"); debug_error!(%mxc, "Failed to parse MXC URI from database: {e}");
}) else { }) else {
continue; continue;
}; };
@ -210,7 +210,7 @@ impl Service {
let Some(mxc_s) = mxc else { let Some(mxc_s) = mxc else {
debug_warn!( debug_warn!(
?mxc, mxc,
"Parsed MXC URL unicode bytes from database but is still invalid" "Parsed MXC URL unicode bytes from database but is still invalid"
); );
continue; continue;
@ -256,7 +256,7 @@ impl Service {
let Some(mxc_s) = mxc else { let Some(mxc_s) = mxc else {
debug_warn!( debug_warn!(
?mxc, mxc,
"Parsed MXC URL unicode bytes from database but is still invalid" "Parsed MXC URL unicode bytes from database but is still invalid"
); );
continue; continue;

4
src/service/media/preview.rs
View file

@ -71,10 +71,10 @@ async fn request_url_preview(&self, url: &Url) -> Result<UrlPreviewData> {
let client = &self.services.client.url_preview; let client = &self.services.client.url_preview;
let response = client.head(url.as_str()).send().await?; let response = client.head(url.as_str()).send().await?;
debug!(?url, "URL preview response headers: {:?}", response.headers()); debug!(%url, "URL preview response headers: {:?}", response.headers());
if let Some(remote_addr) = response.remote_addr() { if let Some(remote_addr) = response.remote_addr() {
debug!(?url, "URL preview response remote address: {:?}", remote_addr); debug!(%url, "URL preview response remote address: {:?}", remote_addr);
if let Ok(ip) = IPAddress::parse(remote_addr.ip().to_string()) { if let Ok(ip) = IPAddress::parse(remote_addr.ip().to_string()) {
if !self.services.client.valid_cidr_range(&ip) { if !self.services.client.valid_cidr_range(&ip) {

4
src/service/media/remote.rs
View file

@ -247,7 +247,7 @@ async fn handle_location(
) -> Result<FileMeta> { ) -> Result<FileMeta> {
self.location_request(location).await.map_err(|error| { self.location_request(location).await.map_err(|error| {
err!(Request(NotFound( err!(Request(NotFound(
debug_warn!(%mxc, ?user, ?location, ?error, "Fetching media from location failed") debug_warn!(%mxc, user = user.map(tracing::field::display), ?location, ?error, "Fetching media from location failed")
))) )))
}) })
} }
@ -320,7 +320,7 @@ fn handle_federation_error(
) -> Error { ) -> Error {
let fallback = || { let fallback = || {
err!(Request(NotFound( err!(Request(NotFound(
debug_error!(%mxc, ?user, ?server, ?error, "Remote media not found") debug_error!(%mxc, user = user.map(tracing::field::display), server = server.map(tracing::field::display), ?error, "Remote media not found")
))) )))
}; };

2
src/service/media/thumbnail.rs
View file

@ -120,7 +120,7 @@ async fn get_thumbnail_generate(
let mut cursor = std::io::Cursor::new(&mut thumbnail_bytes); let mut cursor = std::io::Cursor::new(&mut thumbnail_bytes);
thumbnail thumbnail
.write_to(&mut cursor, image::ImageFormat::Png) .write_to(&mut cursor, image::ImageFormat::Png)
.map_err(|error| err!(error!(?error, "Error writing PNG thumbnail.")))?; .map_err(|error| err!(error!(%error, "Error writing PNG thumbnail.")))?;
// Save thumbnail in database so we don't have to generate it again next time // Save thumbnail in database so we don't have to generate it again next time
let thumbnail_key = self.db.create_file_metadata( let thumbnail_key = self.db.create_file_metadata(

6
src/service/migrations.rs
View file

@ -677,7 +677,7 @@ async fn populate_userroomid_leftstate_table(services: &Services) -> Result {
shortstatehash_cache.insert(room_id.to_owned(), shortstatehash); shortstatehash_cache.insert(room_id.to_owned(), shortstatehash);
shortstatehash shortstatehash
} else { } else {
warn!(?room_id, ?user_id, "room has no shortstatehash"); warn!(%room_id, %user_id, "room has no shortstatehash");
return Ok((total, fixed, shortstatehash_cache)); return Ok((total, fixed, shortstatehash_cache));
}; };
@ -698,8 +698,8 @@ async fn populate_userroomid_leftstate_table(services: &Services) -> Result {
}, },
| Err(_) => { | Err(_) => {
warn!( warn!(
?room_id, %room_id,
?user_id, %user_id,
"room cached as left has no leave event for user, removing \ "room cached as left has no leave event for user, removing \
cache entry" cache entry"
); );

4
src/service/presence/mod.rs
View file

@ -198,11 +198,11 @@ impl Service {
presence.presence, presence.presence,
PresenceState::Unavailable | PresenceState::Online | PresenceState::Busy PresenceState::Unavailable | PresenceState::Online | PresenceState::Busy
) { ) {
trace!(?user_id, ?presence, "Skipping user"); trace!(%user_id, ?presence, "Skipping user");
continue; continue;
} }
trace!(?user_id, ?presence, "Resetting presence to offline"); trace!(%user_id, ?presence, "Resetting presence to offline");
_ = self _ = self
.set_presence( .set_presence(

12
src/service/rooms/auth_chain/mod.rs
View file

@ -151,7 +151,7 @@ async fn get_auth_chain_outer(
let auth_chain = self.get_auth_chain_inner(room_id, event_id).await?; let auth_chain = self.get_auth_chain_inner(room_id, event_id).await?;
self.cache_auth_chain_vec(vec![shortid], auth_chain.as_slice()); self.cache_auth_chain_vec(vec![shortid], auth_chain.as_slice());
debug!( debug!(
?event_id, %event_id,
elapsed = ?started.elapsed(), elapsed = ?started.elapsed(),
"Cache missed event" "Cache missed event"
); );
@ -188,18 +188,18 @@ async fn get_auth_chain_inner(
let mut found = HashSet::new(); let mut found = HashSet::new();
while let Some(event_id) = todo.pop_front() { while let Some(event_id) = todo.pop_front() {
trace!(?event_id, "processing auth event"); trace!(%event_id, "processing auth event");
match self.services.timeline.get_pdu(&event_id).await { match self.services.timeline.get_pdu(&event_id).await {
| Err(e) => { | Err(e) => {
debug_error!(?event_id, ?e, "Could not find pdu mentioned in auth events"); debug_error!(%event_id, ?e, "Could not find pdu mentioned in auth events");
}, },
| Ok(pdu) => { | Ok(pdu) => {
if let Some(claimed_room_id) = pdu.room_id.clone() { if let Some(claimed_room_id) = pdu.room_id.clone() {
if claimed_room_id != *room_id { if claimed_room_id != *room_id {
return Err!(Request(Forbidden(error!( return Err!(Request(Forbidden(error!(
?event_id, %event_id,
?room_id, %room_id,
wrong_room_id = ?pdu.room_id.unwrap(), wrong_room_id = ?pdu.room_id.unwrap(),
"auth event for incorrect room" "auth event for incorrect room"
)))); ))));
@ -214,7 +214,7 @@ async fn get_auth_chain_inner(
.await; .await;
if found.insert(sauthevent) { if found.insert(sauthevent) {
trace!(?event_id, ?auth_event, "adding auth event to processing queue"); trace!(%event_id, ?auth_event, "adding auth event to processing queue");
todo.push_back(auth_event.clone()); todo.push_back(auth_event.clone());
} }

6
src/service/rooms/event_handler/mod.rs
View file

@ -104,9 +104,9 @@ fn check_room_id<Pdu: Event>(room_id: &RoomId, pdu: &Pdu) -> Result {
.is_some_and(|claimed_room_id| claimed_room_id != room_id) .is_some_and(|claimed_room_id| claimed_room_id != room_id)
{ {
return Err!(Request(InvalidParam(error!( return Err!(Request(InvalidParam(error!(
pdu_event_id = ?pdu.event_id(), pdu_event_id = %pdu.event_id(),
pdu_room_id = ?pdu.room_id(), pdu_room_id = pdu.room_id().map(tracing::field::display),
?room_id, %room_id,
"Found event from room in room", "Found event from room in room",
)))); ))));
} }

4
src/service/rooms/event_handler/policy_server.rs
View file

@ -31,7 +31,7 @@ use serde_json::value::RawValue;
/// contacted for whatever reason, Err(e) is returned, which generally is a /// contacted for whatever reason, Err(e) is returned, which generally is a
/// fail-open operation. /// fail-open operation.
#[implement(super::Service)] #[implement(super::Service)]
#[tracing::instrument(skip(self, pdu, pdu_json, room_id))] #[tracing::instrument(skip(self, pdu, pdu_json, room_id), level = "info")]
pub async fn ask_policy_server( pub async fn ask_policy_server(
&self, &self,
pdu: &PduEvent, pdu: &PduEvent,
@ -184,7 +184,7 @@ pub async fn ask_policy_server(
/// Asks a remote policy server for a signature on this event. /// Asks a remote policy server for a signature on this event.
/// If the policy server signs this event, the original data is mutated. /// If the policy server signs this event, the original data is mutated.
#[implement(super::Service)] #[implement(super::Service)]
#[tracing::instrument(skip_all, fields(event_id=%pdu.event_id(), via=%via))] #[tracing::instrument(skip_all, fields(event_id=%pdu.event_id(), via=%via), level = "info")]
pub async fn fetch_policy_server_signature( pub async fn fetch_policy_server_signature(
&self, &self,
pdu: &PduEvent, pdu: &PduEvent,

4
src/service/rooms/timeline/redact.rs
View file

@ -28,7 +28,7 @@ pub async fn redact_pdu<Pdu: Event + Send + Sync>(
.await .await
.map(Event::into_pdu) .map(Event::into_pdu)
.map_err(|e| { .map_err(|e| {
err!(Database(error!(?pdu_id, ?event_id, ?e, "PDU ID points to invalid PDU."))) err!(Database(error!(?pdu_id, %event_id, ?e, "PDU ID points to invalid PDU.")))
})?; })?;
if let Ok(content) = pdu.get_content::<ExtractBody>() { if let Ok(content) = pdu.get_content::<ExtractBody>() {
@ -48,7 +48,7 @@ pub async fn redact_pdu<Pdu: Event + Send + Sync>(
pdu.redact(&room_version_id, reason.to_value())?; pdu.redact(&room_version_id, reason.to_value())?;
let obj = utils::to_canonical_object(&pdu).map_err(|e| { let obj = utils::to_canonical_object(&pdu).map_err(|e| {
err!(Database(error!(?event_id, ?e, "Failed to convert PDU to canonical JSON"))) err!(Database(error!(%event_id, ?e, "Failed to convert PDU to canonical JSON")))
})?; })?;
self.replace_pdu(&pdu_id, &obj).await self.replace_pdu(&pdu_id, &obj).await

6
src/service/sending/sender.rs
View file

@ -535,12 +535,12 @@ impl Service {
} }
let Ok(event) = serde_json::from_str(read_receipt.json().get()) else { let Ok(event) = serde_json::from_str(read_receipt.json().get()) else {
error!(?user_id, ?count, ?read_receipt, "Invalid edu event in read_receipts."); error!(%user_id, %count, ?read_receipt, "Invalid edu event in read_receipts.");
continue; continue;
}; };
let AnySyncEphemeralRoomEvent::Receipt(r) = event else { let AnySyncEphemeralRoomEvent::Receipt(r) = event else {
error!(?user_id, ?count, ?event, "Invalid event type in read_receipts"); error!(%user_id, %count, ?event, "Invalid event type in read_receipts");
continue; continue;
}; };
@ -755,7 +755,7 @@ impl Service {
let Ok(pusher) = self.services.pusher.get_pusher(&user_id, &pushkey).await else { let Ok(pusher) = self.services.pusher.get_pusher(&user_id, &pushkey).await else {
return Err(( return Err((
Destination::Push(user_id.clone(), pushkey.clone()), Destination::Push(user_id.clone(), pushkey.clone()),
err!(Database(error!(?user_id, ?pushkey, "Missing pusher"))), err!(Database(error!(%user_id, ?pushkey, "Missing pusher"))),
)); ));
}; };

6
src/service/server_keys/acquire.rs
View file

@ -118,7 +118,7 @@ where
} }
for (server, key_ids) in missing { for (server, key_ids) in missing {
debug_warn!(?server, ?key_ids, "missing"); debug_warn!(%server, ?key_ids, "missing");
} }
} }
@ -174,8 +174,8 @@ async fn acquire_origin(
timeout: Instant, timeout: Instant,
) -> (OwnedServerName, Vec<OwnedServerSigningKeyId>) { ) -> (OwnedServerName, Vec<OwnedServerSigningKeyId>) {
match timeout_at(timeout, self.server_request(&origin)).await { match timeout_at(timeout, self.server_request(&origin)).await {
| Err(e) => debug_warn!(?origin, "timed out: {e}"), | Err(e) => debug_warn!(%origin, "timed out: {e}"),
| Ok(Err(e)) => debug_error!(?origin, "{e}"), | Ok(Err(e)) => debug_error!(%origin, "{e}"),
| Ok(Ok(server_keys)) => { | Ok(Ok(server_keys)) => {
trace!( trace!(
%origin, %origin,

6
src/service/server_keys/get.rs
View file

@ -63,7 +63,7 @@ where
} }
#[implement(super::Service)] #[implement(super::Service)]
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self), level = "debug")]
pub async fn get_verify_key( pub async fn get_verify_key(
&self, &self,
origin: &ServerName, origin: &ServerName,
@ -96,8 +96,8 @@ pub async fn get_verify_key(
} }
Err!(BadServerResponse(debug_error!( Err!(BadServerResponse(debug_error!(
?key_id, %key_id,
?origin, %origin,
"Failed to fetch federation signing-key" "Failed to fetch federation signing-key"
))) )))
} }

4
src/service/server_keys/mod.rs
View file

@ -112,7 +112,7 @@ async fn add_signing_keys(&self, new_keys: ServerSigningKeys) {
} }
#[implement(Service)] #[implement(Service)]
#[tracing::instrument(skip(self, object))] #[tracing::instrument(skip(self, object), level = "debug")]
pub async fn required_keys_exist( pub async fn required_keys_exist(
&self, &self,
object: &CanonicalJsonObject, object: &CanonicalJsonObject,
@ -135,7 +135,7 @@ pub async fn required_keys_exist(
} }
#[implement(Service)] #[implement(Service)]
#[tracing::instrument(skip(self))] #[tracing::instrument(skip(self), level = "debug")]
pub async fn verify_key_exists(&self, origin: &ServerName, key_id: &ServerSigningKeyId) -> bool { pub async fn verify_key_exists(&self, origin: &ServerName, key_id: &ServerSigningKeyId) -> bool {
type KeysMap<'a> = BTreeMap<&'a ServerSigningKeyId, &'a RawJsonValue>; type KeysMap<'a> = BTreeMap<&'a ServerSigningKeyId, &'a RawJsonValue>;

12
src/service/users/mod.rs
View file

@ -494,8 +494,8 @@ impl Service {
let key = (user_id, device_id); let key = (user_id, device_id);
if self.db.userdeviceid_metadata.qry(&key).await.is_err() { if self.db.userdeviceid_metadata.qry(&key).await.is_err() {
return Err!(Database(error!( return Err!(Database(error!(
?user_id, %user_id,
?device_id, %device_id,
"User does not exist or device has no metadata." "User does not exist or device has no metadata."
))); )));
} }
@ -539,8 +539,8 @@ impl Service {
let key = (user_id, device_id); let key = (user_id, device_id);
if self.db.userdeviceid_metadata.qry(&key).await.is_err() { if self.db.userdeviceid_metadata.qry(&key).await.is_err() {
return Err!(Database(error!( return Err!(Database(error!(
?user_id, %user_id,
?device_id, %device_id,
"User does not exist or device has no metadata." "User does not exist or device has no metadata."
))); )));
} }
@ -1153,7 +1153,7 @@ impl Service {
let (expires_at, user_id): (u64, OwnedUserId) = value.deserialized()?; let (expires_at, user_id): (u64, OwnedUserId) = value.deserialized()?;
if expires_at < utils::millis_since_unix_epoch() { if expires_at < utils::millis_since_unix_epoch() {
trace!(?user_id, ?token, "Removing expired login token"); trace!(%user_id, ?token, "Removing expired login token");
self.db.logintoken_expiresatuserid.remove(token); self.db.logintoken_expiresatuserid.remove(token);
@ -1231,7 +1231,7 @@ impl Service {
debug!(?uri, "LDAP creating connection..."); debug!(?uri, "LDAP creating connection...");
let (conn, mut ldap) = LdapConnAsync::new(uri.as_str()) let (conn, mut ldap) = LdapConnAsync::new(uri.as_str())
.await .await
.map_err(|e| err!(Ldap(error!(?user_id, "LDAP connection setup error: {e}"))))?; .map_err(|e| err!(Ldap(error!(%user_id, "LDAP connection setup error: {e}"))))?;
let driver = self.services.server.runtime().spawn(async move { let driver = self.services.server.runtime().spawn(async move {
match conn.drive().await { match conn.drive().await {