backups/grapevine
1
0
Fork 0
mirror of https://gitlab.computer.surgery/matrix/grapevine.git synced 2025-12-18 08:11:24 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

switch all error logs to using *_err macros

Browse source
This commit is contained in:
Olivia Lee 2024-12-14 01:42:59 -08:00
parent d28135f7ca
commit a3448b5c84
No known key found for this signature in database
GPG key ID: 54D568A15B9CD1F9
29 changed files with 145 additions and 153 deletions
Download patch file Download diff file Expand all files Collapse all files

10
src/api/appservice_server.rs
View file

@ -62,8 +62,8 @@ where
.execute(reqwest_request) .execute(reqwest_request)
.await .await
.inspect_err(|error| { .inspect_err(|error| {
t::warn!( warn_err!(
%error, error,
appservice = registration.id, appservice = registration.id,
%destination, %destination,
"Could not send request to appservice", "Could not send request to appservice",
@ -83,7 +83,7 @@ where
// TODO: handle timeout // TODO: handle timeout
let body = response.bytes().await.unwrap_or_else(|error| { let body = response.bytes().await.unwrap_or_else(|error| {
t::warn!(%error, "Server error"); warn_err!(error, "Server error");
Vec::new().into() Vec::new().into()
}); });
@ -107,8 +107,8 @@ where
); );
response.map(Some).map_err(|error| { response.map(Some).map_err(|error| {
t::warn!( warn_err!(
%error, error,
appservice = %destination, appservice = %destination,
%url, %url,
"Appservice returned invalid response bytes", "Appservice returned invalid response bytes",

4
src/api/client_server/directory.rs
View file

@ -371,8 +371,8 @@ fn room_id_to_chunk(room_id: ruma::OwnedRoomId) -> Result<PublicRoomsChunk> {
_ => None, _ => None,
}) })
.map_err(|error| { .map_err(|error| {
t::error!( error_err!(
%error, error,
"Invalid room join rule event in database" "Invalid room join rule event in database"
); );
Error::BadDatabase( Error::BadDatabase(

2
src/api/client_server/keys.rs
View file

@ -505,7 +505,7 @@ async fn request_keys_from(
match &result { match &result {
Ok(_) => reset_key_request_back_off(server).await, Ok(_) => reset_key_request_back_off(server).await,
Err(error) => { Err(error) => {
t::debug!(%server, %error, "remote device key query failed"); debug_err!(error, %server, "remote device key query failed");
back_off_key_requests(server.to_owned()).await; back_off_key_requests(server.to_owned()).await;
} }
} }

18
src/api/client_server/media.rs
View file

@ -212,7 +212,7 @@ async fn get_redirected_content(
location: String, location: String,
) -> Result<authenticated_media_fed::Content> { ) -> Result<authenticated_media_fed::Content> {
let location = location.parse().map_err(|error| { let location = location.parse().map_err(|error| {
t::warn!(location, %error, "Invalid redirect location"); warn_err!(error, location, "Invalid redirect location");
Error::BadServerResponse("Invalid redirect location") Error::BadServerResponse("Invalid redirect location")
})?; })?;
let response = services() let response = services()
@ -226,11 +226,7 @@ async fn get_redirected_content(
.get(CONTENT_TYPE) .get(CONTENT_TYPE)
.map(|value| { .map(|value| {
value.to_str().map_err(|error| { value.to_str().map_err(|error| {
t::error!( error_err!(error, ?value, "Invalid Content-Type header");
?value,
%error,
"Invalid Content-Type header"
);
Error::BadServerResponse("Invalid Content-Type header") Error::BadServerResponse("Invalid Content-Type header")
}) })
}) })
@ -242,11 +238,7 @@ async fn get_redirected_content(
.get(CONTENT_DISPOSITION) .get(CONTENT_DISPOSITION)
.map(|value| { .map(|value| {
ContentDisposition::try_from(value.as_bytes()).map_err(|error| { ContentDisposition::try_from(value.as_bytes()).map_err(|error| {
t::error!( error_err!(error, ?value, "Invalid Content-Disposition header");
?value,
%error,
"Invalid Content-Disposition header"
);
Error::BadServerResponse("Invalid Content-Disposition header") Error::BadServerResponse("Invalid Content-Disposition header")
}) })
}) })
@ -895,8 +887,8 @@ async fn get_content_thumbnail_route_ruma(
resp.content.content_type, resp.content.content_type,
)); ));
} }
Err(error) => t::warn!( Err(error) => warn_err!(
%error, error,
"Failed to fetch thumbnail via federation, trying to fetch \ "Failed to fetch thumbnail via federation, trying to fetch \
original media and create thumbnail ourselves" original media and create thumbnail ourselves"
), ),

26
src/api/client_server/membership.rs
View file

@ -537,7 +537,7 @@ async fn join_room_by_id_helper(
.map(|join_rules_event| { .map(|join_rules_event| {
serde_json::from_str(join_rules_event.content.get()) serde_json::from_str(join_rules_event.content.get())
.map_err(|error| { .map_err(|error| {
t::warn!(%error, "Invalid join rules event"); warn_err!(error, "Invalid join rules event");
Error::bad_database( Error::bad_database(
"Invalid join rules event in db.", "Invalid join rules event in db.",
) )
@ -956,8 +956,8 @@ async fn join_room_by_id_helper(
.insert(remote_server.to_string(), signature.clone()); .insert(remote_server.to_string(), signature.clone());
} }
Err(error) => { Err(error) => {
t::warn!( warn_err!(
%error, error,
server = %remote_server, server = %remote_server,
event = ?signed_value, event = ?signed_value,
"Other server sent invalid signature in sendjoin \ "Other server sent invalid signature in sendjoin \
@ -999,8 +999,8 @@ async fn join_room_by_id_helper(
let pdu = PduEvent::from_id_val(&event_id, value.clone()).map_err( let pdu = PduEvent::from_id_val(&event_id, value.clone()).map_err(
|error| { |error| {
t::warn!( warn_err!(
%error, error,
object = ?value, object = ?value,
"Invalid PDU in send_join response", "Invalid PDU in send_join response",
); );
@ -1062,7 +1062,7 @@ async fn join_room_by_id_helper(
}, },
) )
.map_err(|error| { .map_err(|error| {
t::warn!(%error, "Auth check failed"); warn_err!(error, "Auth check failed");
Error::BadRequest(ErrorKind::InvalidParam, "Auth check failed") Error::BadRequest(ErrorKind::InvalidParam, "Auth check failed")
})?; })?;
@ -1164,8 +1164,8 @@ async fn make_join_request(
return Ok((r, remote_server.clone())); return Ok((r, remote_server.clone()));
} }
Err(error) => { Err(error) => {
t::warn!( warn_err!(
%error, error,
server = %remote_server, server = %remote_server,
"Remote join request failed", "Remote join request failed",
); );
@ -1184,7 +1184,7 @@ async fn validate_and_add_event_id(
) -> Result<(OwnedEventId, CanonicalJsonObject)> { ) -> Result<(OwnedEventId, CanonicalJsonObject)> {
let mut value: CanonicalJsonObject = serde_json::from_str(pdu.get()) let mut value: CanonicalJsonObject = serde_json::from_str(pdu.get())
.map_err(|error| { .map_err(|error| {
t::error!(%error, object = ?pdu, "Invalid PDU in server response"); error_err!(error, object = ?pdu, "Invalid PDU in server response");
Error::BadServerResponse("Invalid PDU in server response") Error::BadServerResponse("Invalid PDU in server response")
})?; })?;
let event_id = EventId::parse(format!( let event_id = EventId::parse(format!(
@ -1258,9 +1258,9 @@ async fn validate_and_add_event_id(
if let Err(error) = if let Err(error) =
ruma::signatures::verify_event(&keys, &value, room_version) ruma::signatures::verify_event(&keys, &value, room_version)
{ {
t::warn!( warn_err!(
error,
%event_id, %event_id,
%error,
?pdu, ?pdu,
"Event failed verification", "Event failed verification",
); );
@ -1481,7 +1481,7 @@ pub(crate) async fn leave_all_rooms(user_id: &UserId) -> Result<()> {
}; };
if let Err(error) = leave_room(user_id, &room_id, None).await { if let Err(error) = leave_room(user_id, &room_id, None).await {
t::warn!(%user_id, %room_id, %error, "Failed to leave room"); warn_err!(error, %user_id, %room_id, "Failed to leave room");
} }
} }
@ -1557,7 +1557,7 @@ pub(crate) async fn leave_room(
.await?; .await?;
} else { } else {
if let Err(error) = remote_leave_room(user_id, room_id).await { if let Err(error) = remote_leave_room(user_id, room_id).await {
t::warn!(%error, "Failed to leave room remotely"); warn_err!(error, "Failed to leave room remotely");
// Don't tell the client about this error // Don't tell the client about this error
} }

4
src/api/client_server/profile.rs
View file

@ -93,7 +93,7 @@ pub(crate) async fn set_displayname_route(
.build_and_append_pdu(pdu_builder, sender_user, &room_token) .build_and_append_pdu(pdu_builder, sender_user, &room_token)
.await .await
{ {
t::warn!(%error, "failed to add PDU"); warn_err!(error, "failed to add PDU");
} }
} }
@ -205,7 +205,7 @@ pub(crate) async fn set_avatar_url_route(
.build_and_append_pdu(pdu_builder, sender_user, &room_token) .build_and_append_pdu(pdu_builder, sender_user, &room_token)
.await .await
{ {
t::warn!(%error, "failed to add PDU"); warn_err!(error, "failed to add PDU");
}; };
} }

4
src/api/client_server/room.rs
View file

@ -400,7 +400,7 @@ pub(crate) async fn create_room_route(
for event in &body.initial_state { for event in &body.initial_state {
let mut pdu_builder = let mut pdu_builder =
event.deserialize_as::<PduBuilder>().map_err(|error| { event.deserialize_as::<PduBuilder>().map_err(|error| {
t::warn!(%error, "Invalid initial state event"); warn_err!(error, "Invalid initial state event");
Error::BadRequest( Error::BadRequest(
ErrorKind::InvalidParam, ErrorKind::InvalidParam,
"Invalid initial state event.", "Invalid initial state event.",
@ -474,7 +474,7 @@ pub(crate) async fn create_room_route(
invite_helper(sender_user, user_id, &room_id, None, body.is_direct) invite_helper(sender_user, user_id, &room_id, None, body.is_direct)
.await .await
{ {
t::warn!(%error, "Invite helper failed"); warn_err!(error, "Invite helper failed");
}; };
} }

2
src/api/client_server/sync.rs
View file

@ -26,7 +26,7 @@ fn load_timeline(
.filter_map(|x| match x { .filter_map(|x| match x {
Ok(x) => Some(x), Ok(x) => Some(x),
Err(error) => { Err(error) => {
t::error!(%error, "Bad PDU in pdus_since"); error_err!(error, "Bad PDU in pdus_since");
None None
} }
}) })

2
src/api/client_server/sync/msc3575.rs
View file

@ -605,7 +605,7 @@ pub(crate) async fn sync_events_v4_route(
} }
match tokio::time::timeout(duration, watcher).await { match tokio::time::timeout(duration, watcher).await {
Ok(x) => x.expect("watcher should succeed"), Ok(x) => x.expect("watcher should succeed"),
Err(error) => t::debug!(%error, "Timed out"), Err(error) => debug_err!(error, "Timed out"),
}; };
} }

6
src/api/client_server/sync/v3.rs
View file

@ -279,7 +279,7 @@ pub(crate) async fn sync_events_route(
} }
match tokio::time::timeout(duration, watcher).await { match tokio::time::timeout(duration, watcher).await {
Ok(x) => x.expect("watcher should succeed"), Ok(x) => x.expect("watcher should succeed"),
Err(error) => t::debug!(%error, "Timed out"), Err(error) => debug_err!(error, "Timed out"),
}; };
} }
Ok(Ra(response)) Ok(Ra(response))
@ -748,9 +748,9 @@ async fn load_joined_room(
lazy_loaded.insert(state_key_userid); lazy_loaded.insert(state_key_userid);
} }
Err(error) => { Err(error) => {
t::error!( error_err!(
error,
event_id = %pdu.event_id, event_id = %pdu.event_id,
%error,
"Invalid state key for member event", "Invalid state key for member event",
); );
} }

16
src/api/ruma_wrapper/axum.rs
View file

@ -84,7 +84,7 @@ async fn ar_from_request_inner(
let query_params: QueryParams = match serde_html_form::from_str(query) { let query_params: QueryParams = match serde_html_form::from_str(query) {
Ok(params) => params, Ok(params) => params,
Err(error) => { Err(error) => {
t::error!(%error, %query, "Failed to deserialize query parameters"); error_err!(error, %query, "Failed to deserialize query parameters");
return Err(Error::BadRequest( return Err(Error::BadRequest(
ErrorKind::Unknown, ErrorKind::Unknown,
"Failed to read query parameters", "Failed to read query parameters",
@ -184,8 +184,8 @@ async fn ar_from_request_inner(
.extract::<TypedHeader<Authorization<XMatrix>>>() .extract::<TypedHeader<Authorization<XMatrix>>>()
.await .await
.map_err(|error| { .map_err(|error| {
t::warn!( warn_err!(
%error, error,
"Missing or invalid Authorization header" "Missing or invalid Authorization header"
); );
@ -283,7 +283,7 @@ async fn ar_from_request_inner(
let keys = match keys_result { let keys = match keys_result {
Ok(b) => b, Ok(b) => b,
Err(error) => { Err(error) => {
t::warn!(%error, "Failed to fetch signing keys"); warn_err!(error, "Failed to fetch signing keys");
return Err(Error::BadRequest( return Err(Error::BadRequest(
ErrorKind::forbidden(), ErrorKind::forbidden(),
"Failed to fetch signing keys.", "Failed to fetch signing keys.",
@ -309,8 +309,8 @@ async fn ar_from_request_inner(
{ {
Ok(()) => (None, None, Some(x_matrix.origin), None), Ok(()) => (None, None, Some(x_matrix.origin), None),
Err(error) => { Err(error) => {
t::warn!( warn_err!(
%error, error,
origin = %x_matrix.origin, origin = %x_matrix.origin,
object = ?request_map, object = ?request_map,
"Failed to verify JSON request" "Failed to verify JSON request"
@ -420,8 +420,8 @@ where
let body = let body =
T::try_from_http_request(pieces.http_request, &pieces.path_params) T::try_from_http_request(pieces.http_request, &pieces.path_params)
.map_err(|error| { .map_err(|error| {
t::warn!( warn_err!(
%error, error,
body = ?pieces.json_body, body = ?pieces.json_body,
"Request body JSON structure is incorrect" "Request body JSON structure is incorrect"
); );

39
src/api/server_server.rs
View file

@ -200,8 +200,8 @@ where
&[MatrixVersion::V1_11], &[MatrixVersion::V1_11],
) )
.map_err(|error| { .map_err(|error| {
t::warn!( warn_err!(
%error, error,
actual_destination = actual_destination_str, actual_destination = actual_destination_str,
"Failed to find destination", "Failed to find destination",
); );
@ -289,7 +289,7 @@ where
let mut response = response.inspect_err(|error| { let mut response = response.inspect_err(|error| {
if log_error == LogRequestError::Yes { if log_error == LogRequestError::Yes {
t::warn!(%error, "Could not send request"); warn_err!(error, "Could not send request");
} }
})?; })?;
@ -308,7 +308,7 @@ where
t::debug!("Getting response bytes"); t::debug!("Getting response bytes");
// TODO: handle timeout // TODO: handle timeout
let body = response.bytes().await.unwrap_or_else(|error| { let body = response.bytes().await.unwrap_or_else(|error| {
t::warn!(%error, "Server error"); warn_err!(error, "Server error");
Vec::new().into() Vec::new().into()
}); });
t::debug!("Got response bytes"); t::debug!("Got response bytes");
@ -345,7 +345,7 @@ where
} }
response.map_err(|e| { response.map_err(|e| {
t::warn!(error = %e, "Invalid 200 response"); warn_err!(e, "Invalid 200 response");
Error::BadServerResponse("Server returned bad 200 response.") Error::BadServerResponse("Server returned bad 200 response.")
}) })
} }
@ -566,7 +566,7 @@ async fn request_well_known(destination: &str) -> Option<String> {
.await; .await;
t::debug!("Got well known response"); t::debug!("Got well known response");
if let Err(error) = &response { if let Err(error) = &response {
t::debug!(%error, "Failed to request .well-known"); debug_err!(error, "Failed to request .well-known");
return None; return None;
} }
let text = response.ok()?.text().await; let text = response.ok()?.text().await;
@ -704,7 +704,7 @@ pub(crate) fn parse_incoming_pdu(
) -> Result<(OwnedEventId, CanonicalJsonObject, OwnedRoomId)> { ) -> Result<(OwnedEventId, CanonicalJsonObject, OwnedRoomId)> {
let value: CanonicalJsonObject = let value: CanonicalJsonObject =
serde_json::from_str(pdu.get()).map_err(|error| { serde_json::from_str(pdu.get()).map_err(|error| {
t::warn!(%error, object = ?pdu, "Error parsing incoming event"); warn_err!(error, object = ?pdu, "Error parsing incoming event");
Error::BadServerResponse("Invalid PDU in server response") Error::BadServerResponse("Invalid PDU in server response")
})?; })?;
@ -750,7 +750,7 @@ pub(crate) async fn send_transaction_message_route(
for pdu in &body.pdus { for pdu in &body.pdus {
let value: CanonicalJsonObject = serde_json::from_str(pdu.get()) let value: CanonicalJsonObject = serde_json::from_str(pdu.get())
.map_err(|error| { .map_err(|error| {
t::warn!(%error, object = ?pdu, "Error parsing incoming event"); warn_err!(error, object = ?pdu, "Error parsing incoming event");
Error::BadServerResponse("Invalid PDU in server response") Error::BadServerResponse("Invalid PDU in server response")
})?; })?;
let room_id: OwnedRoomId = value let room_id: OwnedRoomId = value
@ -775,7 +775,7 @@ pub(crate) async fn send_transaction_message_route(
let (event_id, value, room_id) = match r { let (event_id, value, room_id) = match r {
Ok(t) => t, Ok(t) => t,
Err(error) => { Err(error) => {
t::warn!(%error, object = ?pdu, "Error parsing incoming event"); warn_err!(error, object = ?pdu, "Error parsing incoming event");
continue; continue;
} }
}; };
@ -816,7 +816,7 @@ pub(crate) async fn send_transaction_message_route(
for pdu in &resolved_map { for pdu in &resolved_map {
if let (event_id, Err(error)) = pdu { if let (event_id, Err(error)) = pdu {
if matches!(error, Error::BadRequest(ErrorKind::NotFound, _)) { if matches!(error, Error::BadRequest(ErrorKind::NotFound, _)) {
t::warn!(%error, %event_id, "Incoming PDU failed"); warn_err!(error, %event_id, "Incoming PDU failed");
} }
} }
} }
@ -968,8 +968,8 @@ pub(crate) async fn send_transaction_message_route(
&ev_type.to_string(), &ev_type.to_string(),
event.deserialize_as().map_err( event.deserialize_as().map_err(
|error| { |error| {
t::warn!( warn_err!(
%error, error,
object = ?event.json(), object = ?event.json(),
"To-Device event is invalid", "To-Device event is invalid",
); );
@ -1507,7 +1507,7 @@ pub(crate) async fn create_join_event_template_route(
.map(|join_rules_event| { .map(|join_rules_event| {
serde_json::from_str(join_rules_event.content.get()).map_err( serde_json::from_str(join_rules_event.content.get()).map_err(
|error| { |error| {
t::warn!(%error, "Invalid join rules event"); warn_err!(error, "Invalid join rules event");
Error::bad_database("Invalid join rules event in db.") Error::bad_database("Invalid join rules event in db.")
}, },
) )
@ -1604,7 +1604,7 @@ async fn create_join_event(
.map(|join_rules_event| { .map(|join_rules_event| {
serde_json::from_str(join_rules_event.content.get()).map_err( serde_json::from_str(join_rules_event.content.get()).map_err(
|error| { |error| {
t::warn!(%error, "Invalid join rules event"); warn_err!(error, "Invalid join rules event");
Error::bad_database("Invalid join rules event in db.") Error::bad_database("Invalid join rules event in db.")
}, },
) )
@ -1867,7 +1867,7 @@ pub(crate) async fn create_invite_route(
let pdu: PduEvent = let pdu: PduEvent =
serde_json::from_value(event.into()).map_err(|error| { serde_json::from_value(event.into()).map_err(|error| {
t::warn!(%error, "Invalid invite event"); warn_err!(error, "Invalid invite event");
Error::BadRequest(ErrorKind::InvalidParam, "Invalid invite event.") Error::BadRequest(ErrorKind::InvalidParam, "Invalid invite event.")
})?; })?;
@ -2101,10 +2101,11 @@ pub(crate) async fn media_download_route(
}; };
let content_disposition = content_disposition.and_then(|s| { let content_disposition = content_disposition.and_then(|s| {
s.parse().inspect_err( s.parse()
|error| t::warn!(%error, "Invalid Content-Disposition in database"), .inspect_err(|error| {
) warn_err!(error, "Invalid Content-Disposition in database");
.ok() })
.ok()
}); });
Ok(Ra(authenticated_media::get_content::v1::Response { Ok(Ra(authenticated_media::get_content::v1::Response {

10
src/database.rs
View file

@ -848,8 +848,8 @@ impl KeyValueDatabase {
) { ) {
Ok(u) => u, Ok(u) => u,
Err(error) => { Err(error) => {
t::warn!( warn_err!(
%error, error,
user_localpart = %username, user_localpart = %username,
"Invalid username", "Invalid username",
); );
@ -950,8 +950,8 @@ impl KeyValueDatabase {
) { ) {
Ok(u) => u, Ok(u) => u,
Err(error) => { Err(error) => {
t::warn!( warn_err!(
%error, error,
user_localpart = %username, user_localpart = %username,
"Invalid username", "Invalid username",
); );
@ -1062,7 +1062,7 @@ impl KeyValueDatabase {
msg(); msg();
let start = Instant::now(); let start = Instant::now();
if let Err(error) = services().globals.cleanup() { if let Err(error) = services().globals.cleanup() {
t::error!(%error, "cleanup: Error"); error_err!(error, "cleanup: Error");
} else { } else {
t::debug!( t::debug!(
elapsed = ?start.elapsed(), elapsed = ?start.elapsed(),

1
src/observability/prelude.rs
View file

@ -17,7 +17,6 @@ pub(crate) use tracing::Instrument;
/// ///
/// The `parent:` and `target:` arguments from the original macro are not /// The `parent:` and `target:` arguments from the original macro are not
/// supported. /// supported.
#[allow(unused)]
macro_rules! event_err { macro_rules! event_err {
($level:expr, $error:expr, $($rest:tt)+) => { ($level:expr, $error:expr, $($rest:tt)+) => {
::tracing::event!( ::tracing::event!(

4
src/service/admin.rs
View file

@ -1068,9 +1068,9 @@ impl Service {
if leave_rooms { if leave_rooms {
for &user_id in &user_ids { for &user_id in &user_ids {
if let Err(error) = leave_all_rooms(user_id).await { if let Err(error) = leave_all_rooms(user_id).await {
t::warn!( warn_err!(
error,
%user_id, %user_id,
%error,
"failed to leave one or more rooms" "failed to leave one or more rooms"
); );
} }

4
src/service/globals.rs
View file

@ -502,8 +502,8 @@ impl Service {
} }
} }
Err(error) => { Err(error) => {
t::error!( error_err!(
%error, error,
"Could not set the configured emergency password for the \ "Could not set the configured emergency password for the \
Grapevine user", Grapevine user",
); );

25
src/service/media.rs
View file

@ -110,11 +110,10 @@ impl Service {
any_files = true; any_files = true;
self.delete_by_key(thumbnail_key.clone()).await.inspect_err( self.delete_by_key(thumbnail_key.clone()).await.inspect_err(
|error| { |error| {
t::warn!( warn_err!(
thumbnail_key = utils::u8_slice_to_hex( error,
thumbnail_key.as_bytes() thumbnail_key =
), utils::u8_slice_to_hex(thumbnail_key.as_bytes()),
%error,
"Failed to delete thumbnail media" "Failed to delete thumbnail media"
); );
}, },
@ -122,14 +121,14 @@ impl Service {
} }
if let Some((_, key)) = if let Some((_, key)) =
self.db.search_file_metadata(mxc, 0, 0).inspect_err( self.db.search_file_metadata(mxc, 0, 0).inspect_err(|error| {
|error| t::warn!(%error, "Failed to find original media key"), warn_err!(error, "Failed to find original media key");
)? })?
{ {
any_files = true; any_files = true;
self.delete_by_key(key).await.inspect_err( self.delete_by_key(key).await.inspect_err(|error| {
|error| t::warn!(%error, "Failed to delete original media"), warn_err!(error, "Failed to delete original media");
)?; })?;
} }
if any_files { if any_files {
@ -137,7 +136,7 @@ impl Service {
} else { } else {
let error = let error =
Error::BadRequest(ErrorKind::NotFound, "Media not found"); Error::BadRequest(ErrorKind::NotFound, "Media not found");
t::warn!(%error, "Failed to delete media"); warn_err!(error, "Failed to delete media");
Err(error) Err(error)
} }
} }
@ -218,7 +217,7 @@ impl Service {
let image = match image::load_from_memory(file) { let image = match image::load_from_memory(file) {
Ok(image) => image, Ok(image) => image,
Err(error) => { Err(error) => {
t::warn!(%error, "Failed to parse source image"); warn_err!(error, "Failed to parse source image");
return Ok(None); return Ok(None);
} }
}; };

2
src/service/pdu.rs
View file

@ -474,7 +474,7 @@ pub(crate) fn gen_event_id_canonical_json(
) -> crate::Result<(OwnedEventId, CanonicalJsonObject)> { ) -> crate::Result<(OwnedEventId, CanonicalJsonObject)> {
let value: CanonicalJsonObject = let value: CanonicalJsonObject =
serde_json::from_str(pdu.get()).map_err(|error| { serde_json::from_str(pdu.get()).map_err(|error| {
t::warn!(%error, object = ?pdu, "Error parsing incoming event"); warn_err!(error, object = ?pdu, "Error parsing incoming event");
Error::BadServerResponse("Invalid PDU in server response") Error::BadServerResponse("Invalid PDU in server response")
})?; })?;

12
src/service/pusher.rs
View file

@ -82,7 +82,7 @@ impl Service {
&[MatrixVersion::V1_0], &[MatrixVersion::V1_0],
) )
.map_err(|error| { .map_err(|error| {
t::warn!(%error, %destination, "Failed to find destination"); warn_err!(error, %destination, "Failed to find destination");
Error::BadServerResponse("Invalid destination") Error::BadServerResponse("Invalid destination")
})? })?
.map(BytesMut::freeze); .map(BytesMut::freeze);
@ -109,7 +109,7 @@ impl Service {
// TODO: handle timeout // TODO: handle timeout
let body = response.bytes().await.unwrap_or_else(|error| { let body = response.bytes().await.unwrap_or_else(|error| {
t::warn!(%error, "Server error"); warn_err!(error, "Server error");
Vec::new().into() Vec::new().into()
}); });
@ -132,8 +132,8 @@ impl Service {
.expect("reqwest body is valid http body"), .expect("reqwest body is valid http body"),
); );
response.map_err(|error| { response.map_err(|error| {
t::warn!( warn_err!(
%error, error,
appservice = %destination, appservice = %destination,
%url, %url,
"Push gateway returned invalid response bytes", "Push gateway returned invalid response bytes",
@ -144,8 +144,8 @@ impl Service {
}) })
} }
Err(error) => { Err(error) => {
t::warn!( warn_err!(
%error, error,
%destination, %destination,
"Could not send request to push gateway", "Could not send request to push gateway",
); );

4
src/service/rooms/auth_chain.rs
View file

@ -223,9 +223,9 @@ impl Service {
); );
} }
Err(error) => { Err(error) => {
t::error!( error_err!(
error,
?event_id, ?event_id,
?error,
"Could not load event in auth chain" "Could not load event in auth chain"
); );
} }

35
src/service/rooms/event_handler.rs
View file

@ -242,7 +242,7 @@ impl Service {
.await .await
{ {
errors += 1; errors += 1;
t::warn!(%error, event_id = %prev_id, "Prev event failed"); warn_err!(error, event_id = %prev_id, "Prev event failed");
match services() match services()
.globals .globals
.bad_event_ratelimiter .bad_event_ratelimiter
@ -380,7 +380,7 @@ impl Service {
) { ) {
Err(error) => { Err(error) => {
// Drop // Drop
t::warn!(%event_id, %error, "Dropping bad event"); warn_err!(error, %event_id, "Dropping bad event");
return Err(Error::BadRequest( return Err(Error::BadRequest(
ErrorKind::InvalidParam, ErrorKind::InvalidParam,
"Signature verification failed", "Signature verification failed",
@ -733,9 +733,10 @@ impl Service {
|event_id| { |event_id| {
let res = services().rooms.timeline.get_pdu(event_id); let res = services().rooms.timeline.get_pdu(event_id);
if let Err(error) = &res { if let Err(error) = &res {
t::error!( error_err!(
%error, error,
%event_id, "Failed to fetch event" %event_id,
"Failed to fetch event"
); );
} }
res.ok().flatten() res.ok().flatten()
@ -760,10 +761,10 @@ impl Service {
.collect::<Result<_>>()?, .collect::<Result<_>>()?,
), ),
Err(error) => { Err(error) => {
t::warn!( warn_err!(
%error, error,
"State resolution on prev events failed, either \ "State resolution on prev events failed, either \
an event could not be found or deserialization" an event could not be found or deserialization"
); );
None None
} }
@ -872,7 +873,7 @@ impl Service {
state_at_incoming_event = Some(state); state_at_incoming_event = Some(state);
} }
Err(error) => { Err(error) => {
t::warn!(%error, "Fetching state for event failed"); warn_err!(error, "Fetching state for event failed");
return Err(error); return Err(error);
} }
}; };
@ -1169,7 +1170,7 @@ impl Service {
let fetch_event = |id: &_| { let fetch_event = |id: &_| {
let res = services().rooms.timeline.get_pdu(id); let res = services().rooms.timeline.get_pdu(id);
if let Err(error) = &res { if let Err(error) = &res {
t::error!(%error, "Failed to fetch event"); error_err!(error, "Failed to fetch event");
} }
res.ok().flatten() res.ok().flatten()
}; };
@ -1415,9 +1416,9 @@ impl Service {
} }
} }
Err(error) => { Err(error) => {
t::warn!( warn_err!(
error,
event_id = %next_id, event_id = %next_id,
%error,
"Event failed auth checks", "Event failed auth checks",
); );
back_off((**next_id).to_owned()).await; back_off((**next_id).to_owned()).await;
@ -1598,7 +1599,7 @@ impl Service {
) -> Result<()> { ) -> Result<()> {
let value: CanonicalJsonObject = serde_json::from_str(pdu.get()) let value: CanonicalJsonObject = serde_json::from_str(pdu.get())
.map_err(|error| { .map_err(|error| {
t::error!(%error, ?pdu, "Invalid PDU in server response"); error_err!(error, ?pdu, "Invalid PDU in server response");
Error::BadServerResponse("Invalid PDU in server response") Error::BadServerResponse("Invalid PDU in server response")
})?; })?;
@ -1739,7 +1740,7 @@ impl Service {
) )
.await .await
{ {
t::debug!(%error, "Failed to get server keys from cache"); debug_err!(error, "Failed to get server keys from cache");
}; };
} }
@ -1769,8 +1770,8 @@ impl Service {
let k = match k.deserialize() { let k = match k.deserialize() {
Ok(key) => key, Ok(key) => key,
Err(error) => { Err(error) => {
t::warn!( warn_err!(
%error, error,
%server, %server,
object = ?k.json(), object = ?k.json(),
"Failed to fetch keys from trusted server", "Failed to fetch keys from trusted server",
@ -1861,7 +1862,7 @@ impl Service {
{ {
Ok(x) => x, Ok(x) => x,
Err(error) => { Err(error) => {
t::warn!(%error, "Invalid ACL event"); warn_err!(error, "Invalid ACL event");
return Ok(()); return Ok(());
} }
}; };

28
src/service/rooms/spaces.rs
View file

@ -184,8 +184,8 @@ impl Service {
serde_json::from_str(s.content.get()) serde_json::from_str(s.content.get())
.map(|c: RoomJoinRulesEventContent| c.join_rule) .map(|c: RoomJoinRulesEventContent| c.join_rule)
.map_err(|error| { .map_err(|error| {
t::error!( error_err!(
%error, error,
"Invalid room join rule event" "Invalid room join rule event"
); );
Error::BadDatabase( Error::BadDatabase(
@ -352,8 +352,8 @@ impl Service {
serde_json::from_str(s.content.get()) serde_json::from_str(s.content.get())
.map(|c: RoomCanonicalAliasEventContent| c.alias) .map(|c: RoomCanonicalAliasEventContent| c.alias)
.map_err(|error| { .map_err(|error| {
t::error!( error_err!(
%error, error,
event_id = %s.event_id, event_id = %s.event_id,
"Invalid room canonical alias event" "Invalid room canonical alias event"
); );
@ -382,8 +382,8 @@ impl Service {
serde_json::from_str(s.content.get()) serde_json::from_str(s.content.get())
.map(|c: RoomTopicEventContent| Some(c.topic)) .map(|c: RoomTopicEventContent| Some(c.topic))
.map_err(|error| { .map_err(|error| {
t::error!( error_err!(
%error, error,
event_id = %s.event_id, event_id = %s.event_id,
"Invalid room topic event" "Invalid room topic event"
); );
@ -407,8 +407,8 @@ impl Service {
== HistoryVisibility::WorldReadable == HistoryVisibility::WorldReadable
}) })
.map_err(|error| { .map_err(|error| {
t::error!( error_err!(
%error, error,
event_id = %s.event_id, event_id = %s.event_id,
"Invalid room history visibility event" "Invalid room history visibility event"
); );
@ -428,8 +428,8 @@ impl Service {
c.guest_access == GuestAccess::CanJoin c.guest_access == GuestAccess::CanJoin
}) })
.map_err(|error| { .map_err(|error| {
t::error!( error_err!(
%error, error,
event_id = %s.event_id, event_id = %s.event_id,
"Invalid room guest access event" "Invalid room guest access event"
); );
@ -446,8 +446,8 @@ impl Service {
serde_json::from_str(s.content.get()) serde_json::from_str(s.content.get())
.map(|c: RoomAvatarEventContent| c.url) .map(|c: RoomAvatarEventContent| c.url)
.map_err(|error| { .map_err(|error| {
t::error!( error_err!(
%error, error,
event_id = %s.event_id, event_id = %s.event_id,
"Invalid room avatar event" "Invalid room avatar event"
); );
@ -471,8 +471,8 @@ impl Service {
serde_json::from_str(s.content.get()) serde_json::from_str(s.content.get())
.map(|c: RoomJoinRulesEventContent| c.join_rule) .map(|c: RoomJoinRulesEventContent| c.join_rule)
.map_err(|error| { .map_err(|error| {
t::error!( error_err!(
%error, error,
event_id = %s.event_id, event_id = %s.event_id,
"Invalid room join rule event", "Invalid room join rule event",
); );

2
src/service/rooms/state.rs
View file

@ -381,7 +381,7 @@ impl Service {
.map(|create_event| { .map(|create_event| {
serde_json::from_str::<T>(create_event.content.get()).map_err( serde_json::from_str::<T>(create_event.content.get()).map_err(
|error| { |error| {
t::warn!(%error, "Invalid create event"); warn_err!(error, "Invalid create event");
Error::BadDatabase("Invalid create event in db.") Error::BadDatabase("Invalid create event in db.")
}, },
) )

4
src/service/rooms/state_accessor.rs
View file

@ -496,8 +496,8 @@ impl Service {
serde_json::from_str(s.content.get()) serde_json::from_str(s.content.get())
.map(|c: RoomNameEventContent| Some(c.name)) .map(|c: RoomNameEventContent| Some(c.name))
.map_err(|error| { .map_err(|error| {
t::error!( error_err!(
%error, error,
"Invalid room name event in database" "Invalid room name event in database"
); );
Error::BadDatabase( Error::BadDatabase(

14
src/service/rooms/state_cache.rs
View file

@ -75,7 +75,7 @@ impl Service {
.state .state
.get_create_content::<ExtractPredecessor>(room_id) .get_create_content::<ExtractPredecessor>(room_id)
.inspect_err(|error| { .inspect_err(|error| {
t::warn!(%error, "Failed to get room predecessor"); warn_err!(error, "Failed to get room predecessor");
}) })
.ok() .ok()
.flatten() .flatten()
@ -110,8 +110,8 @@ impl Service {
event.get(), event.get(),
) )
.map_err(|error| { .map_err(|error| {
t::warn!( warn_err!(
%error, error,
%event_kind, %event_kind,
"Invalid account data event", "Invalid account data event",
); );
@ -215,8 +215,8 @@ impl Service {
RoomAccountDataEventType::Tag, RoomAccountDataEventType::Tag,
&event, &event,
) { ) {
t::warn!( warn_err!(
%error, error,
"error writing m.tag account data to upgraded room" "error writing m.tag account data to upgraded room"
); );
} }
@ -293,9 +293,9 @@ impl Service {
event_kind.clone(), event_kind.clone(),
&event, &event,
) { ) {
t::warn!( warn_err!(
error,
%event_kind, %event_kind,
%error,
"error writing account data event after upgrading room" "error writing account data event after upgrading room"
); );
} }

10
src/service/rooms/timeline.rs
View file

@ -161,7 +161,7 @@ impl Service {
.find_map(|x| match x { .find_map(|x| match x {
Ok(x) => Some(x), Ok(x) => Some(x),
Err(error) => { Err(error) => {
t::error!(%error, "Bad pdu in pdus_since"); error_err!(error, "Bad pdu in pdus_since");
None None
} }
}) })
@ -879,7 +879,7 @@ impl Service {
|k, s| auth_events.get(&(k.clone(), s.to_owned())), |k, s| auth_events.get(&(k.clone(), s.to_owned())),
) )
.map_err(|error| { .map_err(|error| {
t::error!(%error, "Auth check failed"); error_err!(error, "Auth check failed");
Error::BadDatabase("Auth check failed.") Error::BadDatabase("Auth check failed.")
})?; })?;
@ -1340,15 +1340,15 @@ impl Service {
.backfill_pdu(backfill_server, pdu, &pub_key_map) .backfill_pdu(backfill_server, pdu, &pub_key_map)
.await .await
{ {
t::warn!(%error, "Failed to add backfilled pdu"); warn_err!(error, "Failed to add backfilled pdu");
} }
} }
return Ok(()); return Ok(());
} }
Err(error) => { Err(error) => {
t::warn!( warn_err!(
error,
server = %backfill_server, server = %backfill_server,
%error,
"Server could not provide backfill", "Server could not provide backfill",
); );
} }

4
src/service/sending.rs
View file

@ -267,7 +267,7 @@ impl Service {
} }
if let Err(error) = result { if let Err(error) = result {
t::warn!(%error, "Marking transaction as failed"); warn_err!(error, "Marking transaction as failed");
current_transaction_status.entry(destination).and_modify(|e| { current_transaction_status.entry(destination).and_modify(|e| {
use TransactionStatus::{Failed, Retrying, Running}; use TransactionStatus::{Failed, Retrying, Running};
@ -354,7 +354,7 @@ impl Service {
None None
} }
Err(error) => { Err(error) => {
t::error!(%error, "Failed to select events to send"); error_err!(error, "Failed to select events to send");
None None
} }
} }

2
src/utils/on_demand_hashmap.rs
View file

@ -199,7 +199,7 @@ impl<K> Drop for EntryDropGuard<K> {
if let Err(error) = cleanup_sender if let Err(error) = cleanup_sender
.send(self.key.take().expect("drop should only be called once")) .send(self.key.take().expect("drop should only be called once"))
{ {
t::warn!(%error, "Failed to send cleanup message"); warn_err!(error, "Failed to send cleanup message");
}; };
} }
} }

4
src/utils/proxy_protocol.rs
View file

@ -145,8 +145,8 @@ where
std::io::Error::new(ErrorKind::TimedOut, e) std::io::Error::new(ErrorKind::TimedOut, e)
})? })?
.inspect_err(|error| { .inspect_err(|error| {
t::warn!( warn_err!(
%error, error,
"Failed to parse HAProxy protocol header" "Failed to parse HAProxy protocol header"
); );
})?; })?;