feat: [torrust#1456] expose error kind in the UdpError event

Not exposing the original complex error type becuase:

- It's too complex.
- It forces all errors to be "Sent", "PartialEq".
- It would expose a lot of internals.

Author: josecelano

packages/tracker-core/src/error.rs

@@ -84,7 +84,7 @@ pub enum ScrapeError {
 ///
 /// This error is returned when an operation involves a torrent that is not
 /// present in the whitelist.
-#[derive(thiserror::Error, Debug, Clone)]
+#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
 pub enum WhitelistError {
     /// Indicates that the torrent identified by `info_hash` is not whitelisted.
     #[error("The torrent: {info_hash}, is not whitelisted, {location}")]

packages/udp-tracker-core/src/connection_cookie.rs

@@ -86,7 +86,7 @@ use zerocopy::AsBytes;
 use crate::crypto::keys::CipherArrayBlowfish;
 
 /// Error returned when there was an error with the connection cookie.
-#[derive(Error, Debug, Clone)]
+#[derive(Error, Debug, Clone, PartialEq)]
 pub enum ConnectionCookieError {
     #[error("cookie value is not normal: {not_normal_value}")]
     ValueNotNormal { not_normal_value: f64 },

packages/udp-tracker-server/src/error.rs

@@ -1,4 +1,5 @@
 //! Error types for the UDP server.
+use std::fmt::Display;
 use std::panic::Location;
 
 use aquatic_udp_protocol::{ConnectionId, RequestParseError, TransactionId};
@@ -13,7 +14,7 @@ use torrust_tracker_located_error::LocatedError;
 pub struct ConnectionCookie(pub ConnectionId);
 
 /// Error returned by the UDP server.
-#[derive(Error, Debug)]
+#[derive(Error, Debug, Clone)]
 pub enum Error {
     /// Error returned when the request is invalid.
     #[error("error when phrasing request: {request_parse_error:?}")]
@@ -76,6 +77,16 @@ pub struct SendableRequestParseError {
     pub opt_transaction_id: Option<TransactionId>,
 }
 
+impl Display for SendableRequestParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "SendableRequestParseError: message: {}, connection_id: {:?}, transaction_id: {:?}",
+            self.message, self.opt_connection_id, self.opt_transaction_id
+        )
+    }
+}
+
 impl From<RequestParseError> for SendableRequestParseError {
     fn from(request_parse_error: RequestParseError) -> Self {
         let (message, opt_connection_id, opt_transaction_id) = match request_parse_error {

packages/udp-tracker-server/src/event.rs

@@ -2,12 +2,17 @@ use std::fmt;
 use std::net::SocketAddr;
 use std::time::Duration;
 
+use bittorrent_tracker_core::error::{AnnounceError, ScrapeError};
+use bittorrent_udp_tracker_core::services::announce::UdpAnnounceError;
+use bittorrent_udp_tracker_core::services::scrape::UdpScrapeError;
 use torrust_tracker_metrics::label::{LabelSet, LabelValue};
 use torrust_tracker_metrics::label_name;
 use torrust_tracker_primitives::service_binding::ServiceBinding;
 
+use crate::error::Error;
+
 /// A UDP server event.
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Event {
     UdpRequestReceived {
         context: ConnectionContext,
@@ -30,6 +35,7 @@ pub enum Event {
     UdpError {
         context: ConnectionContext,
         kind: Option<UdpRequestKind>,
+        error: ErrorKind,
     },
 }
 
@@ -109,6 +115,43 @@ impl From<ConnectionContext> for LabelSet {
     }
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub enum ErrorKind {
+    RequestParse(String),
+    ConnectionCookie(String),
+    Whitelist(String),
+    Database(String),
+    InternalServer(String),
+    BadRequest(String),
+    TrackerAuthentication(String),
+}
+
+impl From<Error> for ErrorKind {
+    fn from(error: Error) -> Self {
+        match error {
+            Error::RequestParseError { request_parse_error } => Self::RequestParse(request_parse_error.to_string()),
+            Error::UdpAnnounceError { source } => match source {
+                UdpAnnounceError::ConnectionCookieError { source } => Self::ConnectionCookie(source.to_string()),
+                UdpAnnounceError::TrackerCoreAnnounceError { source } => match source {
+                    AnnounceError::Whitelist(whitelist_error) => Self::Whitelist(whitelist_error.to_string()),
+                    AnnounceError::Database(error) => Self::Database(error.to_string()),
+                },
+                UdpAnnounceError::TrackerCoreWhitelistError { source } => Self::Whitelist(source.to_string()),
+            },
+            Error::UdpScrapeError { source } => match source {
+                UdpScrapeError::ConnectionCookieError { source } => Self::ConnectionCookie(source.to_string()),
+                UdpScrapeError::TrackerCoreScrapeError { source } => match source {
+                    ScrapeError::Whitelist(whitelist_error) => Self::Whitelist(whitelist_error.to_string()),
+                },
+                UdpScrapeError::TrackerCoreWhitelistError { source } => Self::Whitelist(source.to_string()),
+            },
+            Error::InternalServer { location: _, message } => Self::InternalServer(message.to_string()),
+            Error::BadRequest { source } => Self::BadRequest(source.to_string()),
+            Error::TrackerAuthenticationRequired { location } => Self::TrackerAuthentication(location.to_string()),
+        }
+    }
+}
+
 pub mod sender {
     use std::sync::Arc;
 

packages/udp-tracker-server/src/handlers/error.rs

@@ -21,7 +21,7 @@ pub async fn handle_error(
     request_id: Uuid,
     opt_udp_server_stats_event_sender: &crate::event::sender::Sender,
     cookie_valid_range: Range<f64>,
-    e: &Error,
+    error: &Error,
     transaction_id: Option<TransactionId>,
 ) -> Response {
     tracing::trace!("handle error");
@@ -31,17 +31,17 @@ pub async fn handle_error(
     match transaction_id {
         Some(transaction_id) => {
             let transaction_id = transaction_id.0.to_string();
-            tracing::error!(target: UDP_TRACKER_LOG_TARGET, error = %e, %client_socket_addr, %server_socket_addr, %request_id, %transaction_id, "response error");
+            tracing::error!(target: UDP_TRACKER_LOG_TARGET, error = %error, %client_socket_addr, %server_socket_addr, %request_id, %transaction_id, "response error");
         }
         None => {
-            tracing::error!(target: UDP_TRACKER_LOG_TARGET, error = %e, %client_socket_addr, %server_socket_addr, %request_id, "response error");
+            tracing::error!(target: UDP_TRACKER_LOG_TARGET, error = %error, %client_socket_addr, %server_socket_addr, %request_id, "response error");
         }
     }
 
-    let e = if let Error::RequestParseError { request_parse_error } = e {
+    let e = if let Error::RequestParseError { request_parse_error } = error {
         (request_parse_error.message.clone(), transaction_id)
     } else {
-        (e.to_string(), transaction_id)
+        (error.to_string(), transaction_id)
     };
 
     if e.1.is_some() {
@@ -52,6 +52,7 @@ pub async fn handle_error(
                 .send(Event::UdpError {
                     context: ConnectionContext::new(client_socket_addr, server_service_binding),
                     kind: req_kind,
+                    error: error.clone().into(),
                 })
                 .await;
         }

packages/udp-tracker-server/src/statistics/event/handler.rs

@@ -232,7 +232,7 @@ pub async fn handle_event(event: Event, stats_repository: &Repository, now: Dura
                 Err(err) => tracing::error!("Failed to increase the counter: {}", err),
             };
         }
-        Event::UdpError { context, kind } => {
+        Event::UdpError { context, kind, error: _ } => {
             // Global fixed metrics
             match context.client_socket_addr().ip() {
                 std::net::IpAddr::V4(_) => {
@@ -271,7 +271,7 @@ mod tests {
     use torrust_tracker_clock::clock::Time;
     use torrust_tracker_primitives::service_binding::{Protocol, ServiceBinding};
 
-    use crate::event::{ConnectionContext, Event, UdpRequestKind};
+    use crate::event::{ConnectionContext, ErrorKind, Event, UdpRequestKind};
     use crate::statistics::event::handler::handle_event;
     use crate::statistics::repository::Repository;
     use crate::CurrentClock;
@@ -518,6 +518,7 @@ mod tests {
                     .unwrap(),
                 ),
                 kind: None,
+                error: ErrorKind::RequestParse("Invalid request format".to_string()),
             },
             &stats_repository,
             CurrentClock::now(),
@@ -650,6 +651,7 @@ mod tests {
                     .unwrap(),
                 ),
                 kind: None,
+                error: ErrorKind::RequestParse("Invalid request format".to_string()),
             },
             &stats_repository,
             CurrentClock::now(),