feat: [torrust#1145] add UDP avg processing time to stats

```json
{
  "torrents": 1,
  "seeders": 1,
  "completed": 0,
  "leechers": 0,
  "tcp4_connections_handled": 0,
  "tcp4_announces_handled": 0,
  "tcp4_scrapes_handled": 0,
  "tcp6_connections_handled": 0,
  "tcp6_announces_handled": 0,
  "tcp6_scrapes_handled": 0,
  "udp_requests_aborted": 0,
  "udp_requests_banned": 0,
  "udp_banned_ips_total": 0,
  "udp_avg_connect_processing_time_ns": 37000,
  "udp_avg_announce_processing_time_ns": 42067,
  "udp_avg_scrape_processing_time_ns": 0,
  "udp4_requests": 60,
  "udp4_connections_handled": 30,
  "udp4_announces_handled": 30,
  "udp4_scrapes_handled": 0,
  "udp4_responses": 60,
  "udp4_errors_handled": 0,
  "udp6_requests": 0,
  "udp6_connections_handled": 0,
  "udp6_announces_handled": 0,
  "udp6_scrapes_handled": 0,
  "udp6_responses": 0,
  "udp6_errors_handled": 0
}
```

New metrcis are:

- udp_avg_connect_processing_time_ns
- udp_avg_announce_processing_time_ns
- udp_avg_scrape_processing_time_ns

Author: josecelano

src/core/services/statistics/mod.rs

@@ -70,23 +70,29 @@ pub async fn get_metrics(tracker: Arc<Tracker>, ban_service: Arc<RwLock<BanServi
     TrackerMetrics {
         torrents_metrics,
         protocol_metrics: Metrics {
-            // TCP
+            // TCPv4
             tcp4_connections_handled: stats.tcp4_connections_handled,
             tcp4_announces_handled: stats.tcp4_announces_handled,
             tcp4_scrapes_handled: stats.tcp4_scrapes_handled,
+            // TCPv6
             tcp6_connections_handled: stats.tcp6_connections_handled,
             tcp6_announces_handled: stats.tcp6_announces_handled,
             tcp6_scrapes_handled: stats.tcp6_scrapes_handled,
             // UDP
             udp_requests_aborted: stats.udp_requests_aborted,
             udp_requests_banned: stats.udp_requests_banned,
             udp_banned_ips_total: udp_banned_ips_total as u64,
+            udp_avg_connect_processing_time_ns: stats.udp_avg_connect_processing_time_ns,
+            udp_avg_announce_processing_time_ns: stats.udp_avg_announce_processing_time_ns,
+            udp_avg_scrape_processing_time_ns: stats.udp_avg_scrape_processing_time_ns,
+            // UDPv4
             udp4_requests: stats.udp4_requests,
             udp4_connections_handled: stats.udp4_connections_handled,
             udp4_announces_handled: stats.udp4_announces_handled,
             udp4_scrapes_handled: stats.udp4_scrapes_handled,
             udp4_responses: stats.udp4_responses,
             udp4_errors_handled: stats.udp4_errors_handled,
+            // UDPv6
             udp6_requests: stats.udp6_requests,
             udp6_connections_handled: stats.udp6_connections_handled,
             udp6_announces_handled: stats.udp6_announces_handled,

src/core/statistics/event/handler.rs

@@ -1,4 +1,4 @@
-use crate::core::statistics::event::Event;
+use crate::core::statistics::event::{Event, UdpResponseKind};
 use crate::core::statistics::repository::Repository;
 
 pub async fn handle_event(event: Event, stats_repository: &Repository) {
@@ -45,10 +45,29 @@ pub async fn handle_event(event: Event, stats_repository: &Repository) {
             stats_repository.increase_udp4_scrapes().await;
         }
         Event::Udp4Response {
-            kind: _,
-            req_processing_time: _,
+            kind,
+            req_processing_time,
         } => {
             stats_repository.increase_udp4_responses().await;
+
+            match kind {
+                UdpResponseKind::Connect => {
+                    stats_repository
+                        .recalculate_udp_avg_connect_processing_time_ns(req_processing_time)
+                        .await;
+                }
+                UdpResponseKind::Announce => {
+                    stats_repository
+                        .recalculate_udp_avg_announce_processing_time_ns(req_processing_time)
+                        .await;
+                }
+                UdpResponseKind::Scrape => {
+                    stats_repository
+                        .recalculate_udp_avg_scrape_processing_time_ns(req_processing_time)
+                        .await;
+                }
+                UdpResponseKind::Error => {}
+            }
         }
         Event::Udp4Error => {
             stats_repository.increase_udp4_errors().await;

src/core/statistics/metrics.rs

@@ -28,6 +28,7 @@ pub struct Metrics {
     /// Total number of TCP (HTTP tracker) `scrape` requests from IPv6 peers.
     pub tcp6_scrapes_handled: u64,
 
+    // UDP
     /// Total number of UDP (UDP tracker) requests aborted.
     pub udp_requests_aborted: u64,
 
@@ -37,6 +38,16 @@ pub struct Metrics {
     /// Total number of banned IPs.
     pub udp_banned_ips_total: u64,
 
+    /// Average rounded time spent processing UDP connect requests.
+    pub udp_avg_connect_processing_time_ns: u64,
+
+    /// Average rounded time spent processing UDP announce requests.
+    pub udp_avg_announce_processing_time_ns: u64,
+
+    /// Average rounded time spent processing UDP scrape requests.
+    pub udp_avg_scrape_processing_time_ns: u64,
+
+    // UDPv4
     /// Total number of UDP (UDP tracker) requests from IPv4 peers.
     pub udp4_requests: u64,
 
@@ -55,6 +66,7 @@ pub struct Metrics {
     /// Total number of UDP (UDP tracker) `error` requests from IPv4 peers.
     pub udp4_errors_handled: u64,
 
+    // UDPv6
     /// Total number of UDP (UDP tracker) requests from IPv6 peers.
     pub udp6_requests: u64,
 

src/core/statistics/repository.rs

@@ -1,4 +1,5 @@
 use std::sync::Arc;
+use std::time::Duration;
 
 use tokio::sync::{RwLock, RwLockReadGuard};
 
@@ -112,6 +113,64 @@ impl Repository {
         drop(stats_lock);
     }
 
+    #[allow(clippy::cast_precision_loss)]
+    #[allow(clippy::cast_possible_truncation)]
+    #[allow(clippy::cast_sign_loss)]
+    pub async fn recalculate_udp_avg_connect_processing_time_ns(&self, req_processing_time: Duration) {
+        let mut stats_lock = self.stats.write().await;
+
+        let req_processing_time = req_processing_time.as_nanos() as f64;
+        let udp_connections_handled = (stats_lock.udp4_connections_handled + stats_lock.udp6_connections_handled) as f64;
+
+        let previous_avg = stats_lock.udp_avg_connect_processing_time_ns;
+
+        // Moving average: https://en.wikipedia.org/wiki/Moving_average
+        let new_avg = previous_avg as f64 + (req_processing_time - previous_avg as f64) / udp_connections_handled;
+
+        stats_lock.udp_avg_connect_processing_time_ns = new_avg.ceil() as u64;
+
+        drop(stats_lock);
+    }
+
+    #[allow(clippy::cast_precision_loss)]
+    #[allow(clippy::cast_possible_truncation)]
+    #[allow(clippy::cast_sign_loss)]
+    pub async fn recalculate_udp_avg_announce_processing_time_ns(&self, req_processing_time: Duration) {
+        let mut stats_lock = self.stats.write().await;
+
+        let req_processing_time = req_processing_time.as_nanos() as f64;
+
+        let udp_announces_handled = (stats_lock.udp4_announces_handled + stats_lock.udp6_announces_handled) as f64;
+
+        let previous_avg = stats_lock.udp_avg_announce_processing_time_ns;
+
+        // Moving average: https://en.wikipedia.org/wiki/Moving_average
+        let new_avg = previous_avg as f64 + (req_processing_time - previous_avg as f64) / udp_announces_handled;
+
+        stats_lock.udp_avg_announce_processing_time_ns = new_avg.ceil() as u64;
+
+        drop(stats_lock);
+    }
+
+    #[allow(clippy::cast_precision_loss)]
+    #[allow(clippy::cast_possible_truncation)]
+    #[allow(clippy::cast_sign_loss)]
+    pub async fn recalculate_udp_avg_scrape_processing_time_ns(&self, req_processing_time: Duration) {
+        let mut stats_lock = self.stats.write().await;
+
+        let req_processing_time = req_processing_time.as_nanos() as f64;
+        let udp_scrapes_handled = (stats_lock.udp4_scrapes_handled + stats_lock.udp6_scrapes_handled) as f64;
+
+        let previous_avg = stats_lock.udp_avg_scrape_processing_time_ns;
+
+        // Moving average: https://en.wikipedia.org/wiki/Moving_average
+        let new_avg = previous_avg as f64 + (req_processing_time - previous_avg as f64) / udp_scrapes_handled;
+
+        stats_lock.udp_avg_scrape_processing_time_ns = new_avg.ceil() as u64;
+
+        drop(stats_lock);
+    }
+
     pub async fn increase_udp6_requests(&self) {
         let mut stats_lock = self.stats.write().await;
         stats_lock.udp6_requests += 1;

src/servers/apis/v1/context/stats/resources.rs

@@ -34,13 +34,21 @@ pub struct Stats {
     /// Total number of TCP (HTTP tracker) `scrape` requests from IPv6 peers.
     pub tcp6_scrapes_handled: u64,
 
+    // UDP
     /// Total number of UDP (UDP tracker) requests aborted.
     pub udp_requests_aborted: u64,
     /// Total number of UDP (UDP tracker) requests banned.
     pub udp_requests_banned: u64,
     /// Total number of IPs banned for UDP (UDP tracker) requests.
     pub udp_banned_ips_total: u64,
+    /// Average rounded time spent processing UDP connect requests.
+    pub udp_avg_connect_processing_time_ns: u64,
+    /// Average rounded time spent processing UDP announce requests.
+    pub udp_avg_announce_processing_time_ns: u64,
+    /// Average rounded time spent processing UDP scrape requests.
+    pub udp_avg_scrape_processing_time_ns: u64,
 
+    // UDPv4
     /// Total number of UDP (UDP tracker) requests from IPv4 peers.
     pub udp4_requests: u64,
     /// Total number of UDP (UDP tracker) connections from IPv4 peers.
@@ -54,6 +62,7 @@ pub struct Stats {
     /// Total number of UDP (UDP tracker) `scrape` requests from IPv4 peers.
     pub udp4_errors_handled: u64,
 
+    // UDPv6
     /// Total number of UDP (UDP tracker) requests from IPv6 peers.
     pub udp6_requests: u64,
     /// Total number of UDP (UDP tracker) `connection` requests from IPv6 peers.
@@ -86,12 +95,17 @@ impl From<TrackerMetrics> for Stats {
             udp_requests_aborted: metrics.protocol_metrics.udp_requests_aborted,
             udp_requests_banned: metrics.protocol_metrics.udp_requests_banned,
             udp_banned_ips_total: metrics.protocol_metrics.udp_banned_ips_total,
+            udp_avg_connect_processing_time_ns: metrics.protocol_metrics.udp_avg_connect_processing_time_ns,
+            udp_avg_announce_processing_time_ns: metrics.protocol_metrics.udp_avg_announce_processing_time_ns,
+            udp_avg_scrape_processing_time_ns: metrics.protocol_metrics.udp_avg_scrape_processing_time_ns,
+            // UDPv4
             udp4_requests: metrics.protocol_metrics.udp4_requests,
             udp4_connections_handled: metrics.protocol_metrics.udp4_connections_handled,
             udp4_announces_handled: metrics.protocol_metrics.udp4_announces_handled,
             udp4_scrapes_handled: metrics.protocol_metrics.udp4_scrapes_handled,
             udp4_responses: metrics.protocol_metrics.udp4_responses,
             udp4_errors_handled: metrics.protocol_metrics.udp4_errors_handled,
+            // UDPv6
             udp6_requests: metrics.protocol_metrics.udp6_requests,
             udp6_connections_handled: metrics.protocol_metrics.udp6_connections_handled,
             udp6_announces_handled: metrics.protocol_metrics.udp6_announces_handled,
@@ -132,48 +146,59 @@ mod tests {
                     udp_requests_aborted: 11,
                     udp_requests_banned: 12,
                     udp_banned_ips_total: 13,
-                    udp4_requests: 14,
-                    udp4_connections_handled: 15,
-                    udp4_announces_handled: 16,
-                    udp4_scrapes_handled: 17,
-                    udp4_responses: 18,
-                    udp4_errors_handled: 19,
-                    udp6_requests: 20,
-                    udp6_connections_handled: 21,
-                    udp6_announces_handled: 22,
-                    udp6_scrapes_handled: 23,
-                    udp6_responses: 24,
-                    udp6_errors_handled: 25
+                    udp_avg_connect_processing_time_ns: 14,
+                    udp_avg_announce_processing_time_ns: 15,
+                    udp_avg_scrape_processing_time_ns: 16,
+                    // UDPv4
+                    udp4_requests: 17,
+                    udp4_connections_handled: 18,
+                    udp4_announces_handled: 19,
+                    udp4_scrapes_handled: 20,
+                    udp4_responses: 21,
+                    udp4_errors_handled: 22,
+                    // UDPv6
+                    udp6_requests: 23,
+                    udp6_connections_handled: 24,
+                    udp6_announces_handled: 25,
+                    udp6_scrapes_handled: 26,
+                    udp6_responses: 27,
+                    udp6_errors_handled: 28
                 }
             }),
             Stats {
                 torrents: 4,
                 seeders: 1,
                 completed: 2,
                 leechers: 3,
-                // TCP
+                // TCPv4
                 tcp4_connections_handled: 5,
                 tcp4_announces_handled: 6,
                 tcp4_scrapes_handled: 7,
+                // TCPv6
                 tcp6_connections_handled: 8,
                 tcp6_announces_handled: 9,
                 tcp6_scrapes_handled: 10,
                 // UDP
                 udp_requests_aborted: 11,
                 udp_requests_banned: 12,
                 udp_banned_ips_total: 13,
-                udp4_requests: 14,
-                udp4_connections_handled: 15,
-                udp4_announces_handled: 16,
-                udp4_scrapes_handled: 17,
-                udp4_responses: 18,
-                udp4_errors_handled: 19,
-                udp6_requests: 20,
-                udp6_connections_handled: 21,
-                udp6_announces_handled: 22,
-                udp6_scrapes_handled: 23,
-                udp6_responses: 24,
-                udp6_errors_handled: 25
+                udp_avg_connect_processing_time_ns: 14,
+                udp_avg_announce_processing_time_ns: 15,
+                udp_avg_scrape_processing_time_ns: 16,
+                // UDPv4
+                udp4_requests: 17,
+                udp4_connections_handled: 18,
+                udp4_announces_handled: 19,
+                udp4_scrapes_handled: 20,
+                udp4_responses: 21,
+                udp4_errors_handled: 22,
+                // UDPv6
+                udp6_requests: 23,
+                udp6_connections_handled: 24,
+                udp6_announces_handled: 25,
+                udp6_scrapes_handled: 26,
+                udp6_responses: 27,
+                udp6_errors_handled: 28
             }
         );
     }

src/servers/apis/v1/context/stats/responses.rs

@@ -21,6 +21,10 @@ pub fn metrics_response(tracker_metrics: &TrackerMetrics) -> Response {
     lines.push(format!("completed {}", tracker_metrics.torrents_metrics.downloaded));
     lines.push(format!("leechers {}", tracker_metrics.torrents_metrics.incomplete));
 
+    // TCP
+
+    // TCPv4
+
     lines.push(format!(
         "tcp4_connections_handled {}",
         tracker_metrics.protocol_metrics.tcp4_connections_handled
@@ -34,6 +38,8 @@ pub fn metrics_response(tracker_metrics: &TrackerMetrics) -> Response {
         tracker_metrics.protocol_metrics.tcp4_scrapes_handled
     ));
 
+    // TCPv6
+
     lines.push(format!(
         "tcp6_connections_handled {}",
         tracker_metrics.protocol_metrics.tcp6_connections_handled
@@ -47,10 +53,34 @@ pub fn metrics_response(tracker_metrics: &TrackerMetrics) -> Response {
         tracker_metrics.protocol_metrics.tcp6_scrapes_handled
     ));
 
+    // UDP
+
     lines.push(format!(
         "udp_requests_aborted {}",
         tracker_metrics.protocol_metrics.udp_requests_aborted
     ));
+    lines.push(format!(
+        "udp_requests_banned {}",
+        tracker_metrics.protocol_metrics.udp_requests_banned
+    ));
+    lines.push(format!(
+        "udp_banned_ips_total {}",
+        tracker_metrics.protocol_metrics.udp_banned_ips_total
+    ));
+    lines.push(format!(
+        "udp_avg_connect_processing_time_ns {}",
+        tracker_metrics.protocol_metrics.udp_avg_connect_processing_time_ns
+    ));
+    lines.push(format!(
+        "udp_avg_announce_processing_time_ns {}",
+        tracker_metrics.protocol_metrics.udp_avg_announce_processing_time_ns
+    ));
+    lines.push(format!(
+        "udp_avg_scrape_processing_time_ns {}",
+        tracker_metrics.protocol_metrics.udp_avg_scrape_processing_time_ns
+    ));
+
+    // UDPv4
 
     lines.push(format!("udp4_requests {}", tracker_metrics.protocol_metrics.udp4_requests));
     lines.push(format!(
@@ -71,6 +101,8 @@ pub fn metrics_response(tracker_metrics: &TrackerMetrics) -> Response {
         tracker_metrics.protocol_metrics.udp4_errors_handled
     ));
 
+    // UDPv6
+
     lines.push(format!("udp6_requests {}", tracker_metrics.protocol_metrics.udp6_requests));
     lines.push(format!(
         "udp6_connections_handled {}",

tests/servers/api/v1/contract/context/stats.rs

@@ -47,12 +47,17 @@ async fn should_allow_getting_tracker_statistics() {
             udp_requests_aborted: 0,
             udp_requests_banned: 0,
             udp_banned_ips_total: 0,
+            udp_avg_connect_processing_time_ns: 0,
+            udp_avg_announce_processing_time_ns: 0,
+            udp_avg_scrape_processing_time_ns: 0,
+            // UDPv4
             udp4_requests: 0,
             udp4_connections_handled: 0,
             udp4_announces_handled: 0,
             udp4_scrapes_handled: 0,
             udp4_responses: 0,
             udp4_errors_handled: 0,
+            // UDPv6
             udp6_requests: 0,
             udp6_connections_handled: 0,
             udp6_announces_handled: 0,