refactor: [torrust#1145] add type and processing time to UDP response events

- The `kind`is the type of response: connect, annouince, etc
- The req_processing_time is the time it took to process the requests on
  the backend, without including sending the response back to the client
(network latency).

Author: josecelano

src/core/statistics/event/handler.rs

@@ -44,7 +44,10 @@ pub async fn handle_event(event: Event, stats_repository: &Repository) {
         Event::Udp4Scrape => {
             stats_repository.increase_udp4_scrapes().await;
         }
-        Event::Udp4Response => {
+        Event::Udp4Response {
+            kind: _,
+            req_processing_time: _,
+        } => {
             stats_repository.increase_udp4_responses().await;
         }
         Event::Udp4Error => {
@@ -64,7 +67,10 @@ pub async fn handle_event(event: Event, stats_repository: &Repository) {
         Event::Udp6Scrape => {
             stats_repository.increase_udp6_scrapes().await;
         }
-        Event::Udp6Response => {
+        Event::Udp6Response {
+            kind: _,
+            req_processing_time: _,
+        } => {
             stats_repository.increase_udp6_responses().await;
         }
         Event::Udp6Error => {

src/core/statistics/event/mod.rs

@@ -1,3 +1,5 @@
+use std::time::Duration;
+
 pub mod handler;
 pub mod listener;
 pub mod sender;
@@ -24,12 +26,26 @@ pub enum Event {
     Udp4Connect,
     Udp4Announce,
     Udp4Scrape,
-    Udp4Response,
+    Udp4Response {
+        kind: UdpResponseKind,
+        req_processing_time: Duration,
+    },
     Udp4Error,
     Udp6Request,
     Udp6Connect,
     Udp6Announce,
     Udp6Scrape,
-    Udp6Response,
+    Udp6Response {
+        kind: UdpResponseKind,
+        req_processing_time: Duration,
+    },
     Udp6Error,
 }
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum UdpResponseKind {
+    Connect,
+    Announce,
+    Scrape,
+    Error,
+}

src/servers/udp/server/processor.rs

@@ -1,13 +1,16 @@
 use std::io::Cursor;
 use std::net::{IpAddr, SocketAddr};
 use std::sync::Arc;
+use std::time::Duration;
 
 use aquatic_udp_protocol::Response;
 use tokio::sync::RwLock;
+use tokio::time::Instant;
 use tracing::{instrument, Level};
 
 use super::banning::BanService;
 use super::bound_socket::BoundSocket;
+use crate::core::statistics::event::UdpResponseKind;
 use crate::core::{statistics, Tracker};
 use crate::servers::udp::handlers::CookieTimeValues;
 use crate::servers::udp::{handlers, RawRequest};
@@ -30,6 +33,9 @@ impl Processor {
     #[instrument(skip(self, request, ban_service))]
     pub async fn process_request(self, request: RawRequest, ban_service: Arc<RwLock<BanService>>) {
         let from = request.from;
+
+        let start_time = Instant::now();
+
         let response = handlers::handle_packet(
             request,
             &self.tracker,
@@ -39,11 +45,13 @@ impl Processor {
         )
         .await;
 
-        self.send_response(from, response).await;
+        let elapsed_time = start_time.elapsed();
+
+        self.send_response(from, response, elapsed_time).await;
     }
 
     #[instrument(skip(self))]
-    async fn send_response(self, target: SocketAddr, response: Response) {
+    async fn send_response(self, target: SocketAddr, response: Response, req_processing_time: Duration) {
         tracing::debug!("send response");
 
         let response_type = match &response {
@@ -54,6 +62,13 @@ impl Processor {
             Response::Error(e) => format!("Error: {e:?}"),
         };
 
+        let response_kind = match &response {
+            Response::Connect(_) => UdpResponseKind::Connect,
+            Response::AnnounceIpv4(_) | Response::AnnounceIpv6(_) => UdpResponseKind::Announce,
+            Response::Scrape(_) => UdpResponseKind::Scrape,
+            Response::Error(_e) => UdpResponseKind::Error,
+        };
+
         let mut writer = Cursor::new(Vec::with_capacity(200));
 
         match response.write_bytes(&mut writer) {
@@ -71,10 +86,20 @@ impl Processor {
 
                         match target.ip() {
                             IpAddr::V4(_) => {
-                                self.tracker.send_stats_event(statistics::event::Event::Udp4Response).await;
+                                self.tracker
+                                    .send_stats_event(statistics::event::Event::Udp4Response {
+                                        kind: response_kind,
+                                        req_processing_time,
+                                    })
+                                    .await;
                             }
                             IpAddr::V6(_) => {
-                                self.tracker.send_stats_event(statistics::event::Event::Udp6Response).await;
+                                self.tracker
+                                    .send_stats_event(statistics::event::Event::Udp6Response {
+                                        kind: response_kind,
+                                        req_processing_time,
+                                    })
+                                    .await;
                             }
                         }
                     }