refactor: [#1228] start using the http tracker stats

Stats have been splited into HTTP and UDP stats.

Parallel change, step 1:

1. [x] Start using HTTP Tracker Core Stats
2. [ ] Start using UDP  Tracker Core Stats
3. [ ] Get metrics from HTTP and UDP Tracker Core Stats
4. [ ] Remove deprecate unified HTTP and UDP stats.

Author: josecelano

src/container.rs

@@ -71,6 +71,7 @@ pub struct HttpTrackerContainer {
     pub scrape_handler: Arc<ScrapeHandler>,
     pub whitelist_authorization: Arc<whitelist::authorization::WhitelistAuthorization>,
     pub stats_event_sender: Arc<Option<Box<dyn Sender>>>,
+    pub http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     pub authentication_service: Arc<AuthenticationService>,
 }
 
@@ -84,6 +85,7 @@ impl HttpTrackerContainer {
             scrape_handler: app_container.scrape_handler.clone(),
             whitelist_authorization: app_container.whitelist_authorization.clone(),
             stats_event_sender: app_container.stats_event_sender.clone(),
+            http_stats_event_sender: app_container.http_stats_event_sender.clone(),
             authentication_service: app_container.authentication_service.clone(),
         }
     }

src/servers/http/v1/handlers/announce.rs

@@ -28,6 +28,7 @@ use torrust_tracker_primitives::core::AnnounceData;
 use torrust_tracker_primitives::peer;
 
 use super::common::auth::map_auth_error_to_error_response;
+use crate::packages::http_tracker_core;
 use crate::servers::http::v1::extractors::announce_request::ExtractRequest;
 use crate::servers::http::v1::extractors::authentication_key::Extract as ExtractKey;
 use crate::servers::http::v1::extractors::client_ip_sources::Extract as ExtractClientIpSources;
@@ -46,6 +47,7 @@ pub async fn handle_without_key(
         Arc<AuthenticationService>,
         Arc<whitelist::authorization::WhitelistAuthorization>,
         Arc<Option<Box<dyn Sender>>>,
+        Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     )>,
     ExtractRequest(announce_request): ExtractRequest,
     ExtractClientIpSources(client_ip_sources): ExtractClientIpSources,
@@ -58,6 +60,7 @@ pub async fn handle_without_key(
         &state.2,
         &state.3,
         &state.4,
+        &state.5,
         &announce_request,
         &client_ip_sources,
         None,
@@ -76,6 +79,7 @@ pub async fn handle_with_key(
         Arc<AuthenticationService>,
         Arc<whitelist::authorization::WhitelistAuthorization>,
         Arc<Option<Box<dyn Sender>>>,
+        Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     )>,
     ExtractRequest(announce_request): ExtractRequest,
     ExtractClientIpSources(client_ip_sources): ExtractClientIpSources,
@@ -89,6 +93,7 @@ pub async fn handle_with_key(
         &state.2,
         &state.3,
         &state.4,
+        &state.5,
         &announce_request,
         &client_ip_sources,
         Some(key),
@@ -107,6 +112,7 @@ async fn handle(
     authentication_service: &Arc<AuthenticationService>,
     whitelist_authorization: &Arc<whitelist::authorization::WhitelistAuthorization>,
     opt_stats_event_sender: &Arc<Option<Box<dyn Sender>>>,
+    opt_http_stats_event_sender: &Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     announce_request: &Announce,
     client_ip_sources: &ClientIpSources,
     maybe_key: Option<Key>,
@@ -117,6 +123,7 @@ async fn handle(
         authentication_service,
         whitelist_authorization,
         opt_stats_event_sender,
+        opt_http_stats_event_sender,
         announce_request,
         client_ip_sources,
         maybe_key,
@@ -142,6 +149,7 @@ async fn handle_announce(
     authentication_service: &Arc<AuthenticationService>,
     whitelist_authorization: &Arc<whitelist::authorization::WhitelistAuthorization>,
     opt_stats_event_sender: &Arc<Option<Box<dyn Sender>>>,
+    opt_http_stats_event_sender: &Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     announce_request: &Announce,
     client_ip_sources: &ClientIpSources,
     maybe_key: Option<Key>,
@@ -181,6 +189,7 @@ async fn handle_announce(
     let announce_data = services::announce::invoke(
         announce_handler.clone(),
         opt_stats_event_sender.clone(),
+        opt_http_stats_event_sender.clone(),
         announce_request.info_hash,
         &mut peer,
         &peers_wanted,
@@ -265,7 +274,7 @@ mod tests {
     use torrust_tracker_configuration::{Configuration, Core};
     use torrust_tracker_test_helpers::configuration;
 
-    use crate::packages;
+    use crate::packages::{self, http_tracker_core};
 
     struct CoreTrackerServices {
         pub core_config: Arc<Core>,
@@ -275,23 +284,27 @@ mod tests {
         pub authentication_service: Arc<AuthenticationService>,
     }
 
-    fn initialize_private_tracker() -> CoreTrackerServices {
+    struct CoreHttpTrackerServices {
+        pub http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
+    }
+
+    fn initialize_private_tracker() -> (CoreTrackerServices, CoreHttpTrackerServices) {
         initialize_core_tracker_services(&configuration::ephemeral_private())
     }
 
-    fn initialize_listed_tracker() -> CoreTrackerServices {
+    fn initialize_listed_tracker() -> (CoreTrackerServices, CoreHttpTrackerServices) {
         initialize_core_tracker_services(&configuration::ephemeral_listed())
     }
 
-    fn initialize_tracker_on_reverse_proxy() -> CoreTrackerServices {
+    fn initialize_tracker_on_reverse_proxy() -> (CoreTrackerServices, CoreHttpTrackerServices) {
         initialize_core_tracker_services(&configuration::ephemeral_with_reverse_proxy())
     }
 
-    fn initialize_tracker_not_on_reverse_proxy() -> CoreTrackerServices {
+    fn initialize_tracker_not_on_reverse_proxy() -> (CoreTrackerServices, CoreHttpTrackerServices) {
         initialize_core_tracker_services(&configuration::ephemeral_without_reverse_proxy())
     }
 
-    fn initialize_core_tracker_services(config: &Configuration) -> CoreTrackerServices {
+    fn initialize_core_tracker_services(config: &Configuration) -> (CoreTrackerServices, CoreHttpTrackerServices) {
         let core_config = Arc::new(config.core.clone());
         let database = initialize_database(config);
         let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
@@ -300,21 +313,31 @@ mod tests {
         let authentication_service = Arc::new(AuthenticationService::new(&config.core, &in_memory_key_repository));
         let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
         let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(&database));
-        let (stats_event_sender, _stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
-        let stats_event_sender = Arc::new(stats_event_sender);
         let announce_handler = Arc::new(AnnounceHandler::new(
             &config.core,
             &in_memory_torrent_repository,
             &db_torrent_repository,
         ));
 
-        CoreTrackerServices {
-            core_config,
-            announce_handler,
-            stats_event_sender,
-            whitelist_authorization,
-            authentication_service,
-        }
+        let (stats_event_sender, _stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
+        let stats_event_sender = Arc::new(stats_event_sender);
+
+        // HTTP stats
+        let (http_stats_event_sender, http_stats_repository) =
+            http_tracker_core::statistics::setup::factory(config.core.tracker_usage_statistics);
+        let http_stats_event_sender = Arc::new(http_stats_event_sender);
+        let _http_stats_repository = Arc::new(http_stats_repository);
+
+        (
+            CoreTrackerServices {
+                core_config,
+                announce_handler,
+                stats_event_sender,
+                whitelist_authorization,
+                authentication_service,
+            },
+            CoreHttpTrackerServices { http_stats_event_sender },
+        )
     }
 
     fn sample_announce_request() -> Announce {
@@ -357,7 +380,7 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_authentication_key_is_missing() {
-            let core_tracker_services = initialize_private_tracker();
+            let (core_tracker_services, http_core_tracker_services) = initialize_private_tracker();
 
             let maybe_key = None;
 
@@ -367,6 +390,7 @@ mod tests {
                 &core_tracker_services.authentication_service,
                 &core_tracker_services.whitelist_authorization,
                 &core_tracker_services.stats_event_sender,
+                &http_core_tracker_services.http_stats_event_sender,
                 &sample_announce_request(),
                 &sample_client_ip_sources(),
                 maybe_key,
@@ -382,7 +406,7 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_authentication_key_is_invalid() {
-            let core_tracker_services = initialize_private_tracker();
+            let (core_tracker_services, http_core_tracker_services) = initialize_private_tracker();
 
             let unregistered_key = authentication::Key::from_str("YZSl4lMZupRuOpSRC3krIKR5BPB14nrJ").unwrap();
 
@@ -394,6 +418,7 @@ mod tests {
                 &core_tracker_services.authentication_service,
                 &core_tracker_services.whitelist_authorization,
                 &core_tracker_services.stats_event_sender,
+                &http_core_tracker_services.http_stats_event_sender,
                 &sample_announce_request(),
                 &sample_client_ip_sources(),
                 maybe_key,
@@ -413,7 +438,7 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_announced_torrent_is_not_whitelisted() {
-            let core_tracker_services = initialize_listed_tracker();
+            let (core_tracker_services, http_core_tracker_services) = initialize_listed_tracker();
 
             let announce_request = sample_announce_request();
 
@@ -423,6 +448,7 @@ mod tests {
                 &core_tracker_services.authentication_service,
                 &core_tracker_services.whitelist_authorization,
                 &core_tracker_services.stats_event_sender,
+                &http_core_tracker_services.http_stats_event_sender,
                 &announce_request,
                 &sample_client_ip_sources(),
                 None,
@@ -450,7 +476,7 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_right_most_x_forwarded_for_header_ip_is_not_available() {
-            let core_tracker_services = initialize_tracker_on_reverse_proxy();
+            let (core_tracker_services, http_core_tracker_services) = initialize_tracker_on_reverse_proxy();
 
             let client_ip_sources = ClientIpSources {
                 right_most_x_forwarded_for: None,
@@ -463,6 +489,7 @@ mod tests {
                 &core_tracker_services.authentication_service,
                 &core_tracker_services.whitelist_authorization,
                 &core_tracker_services.stats_event_sender,
+                &http_core_tracker_services.http_stats_event_sender,
                 &sample_announce_request(),
                 &client_ip_sources,
                 None,
@@ -487,7 +514,7 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_client_ip_from_the_connection_info_is_not_available() {
-            let core_tracker_services = initialize_tracker_not_on_reverse_proxy();
+            let (core_tracker_services, http_core_tracker_services) = initialize_tracker_not_on_reverse_proxy();
 
             let client_ip_sources = ClientIpSources {
                 right_most_x_forwarded_for: None,
@@ -500,6 +527,7 @@ mod tests {
                 &core_tracker_services.authentication_service,
                 &core_tracker_services.whitelist_authorization,
                 &core_tracker_services.stats_event_sender,
+                &http_core_tracker_services.http_stats_event_sender,
                 &sample_announce_request(),
                 &client_ip_sources,
                 None,

src/servers/http/v1/handlers/scrape.rs

@@ -20,7 +20,7 @@ use packages::statistics::event::sender::Sender;
 use torrust_tracker_configuration::Core;
 use torrust_tracker_primitives::core::ScrapeData;
 
-use crate::packages;
+use crate::packages::{self, http_tracker_core};
 use crate::servers::http::v1::extractors::authentication_key::Extract as ExtractKey;
 use crate::servers::http::v1::extractors::client_ip_sources::Extract as ExtractClientIpSources;
 use crate::servers::http::v1::extractors::scrape_request::ExtractRequest;
@@ -36,6 +36,7 @@ pub async fn handle_without_key(
         Arc<ScrapeHandler>,
         Arc<AuthenticationService>,
         Arc<Option<Box<dyn Sender>>>,
+        Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     )>,
     ExtractRequest(scrape_request): ExtractRequest,
     ExtractClientIpSources(client_ip_sources): ExtractClientIpSources,
@@ -47,6 +48,7 @@ pub async fn handle_without_key(
         &state.1,
         &state.2,
         &state.3,
+        &state.4,
         &scrape_request,
         &client_ip_sources,
         None,
@@ -66,6 +68,7 @@ pub async fn handle_with_key(
         Arc<ScrapeHandler>,
         Arc<AuthenticationService>,
         Arc<Option<Box<dyn Sender>>>,
+        Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     )>,
     ExtractRequest(scrape_request): ExtractRequest,
     ExtractClientIpSources(client_ip_sources): ExtractClientIpSources,
@@ -78,6 +81,7 @@ pub async fn handle_with_key(
         &state.1,
         &state.2,
         &state.3,
+        &state.4,
         &scrape_request,
         &client_ip_sources,
         Some(key),
@@ -91,6 +95,7 @@ async fn handle(
     scrape_handler: &Arc<ScrapeHandler>,
     authentication_service: &Arc<AuthenticationService>,
     stats_event_sender: &Arc<Option<Box<dyn Sender>>>,
+    http_stats_event_sender: &Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     scrape_request: &Scrape,
     client_ip_sources: &ClientIpSources,
     maybe_key: Option<Key>,
@@ -100,6 +105,7 @@ async fn handle(
         scrape_handler,
         authentication_service,
         stats_event_sender,
+        http_stats_event_sender,
         scrape_request,
         client_ip_sources,
         maybe_key,
@@ -124,6 +130,7 @@ async fn handle_scrape(
     scrape_handler: &Arc<ScrapeHandler>,
     authentication_service: &Arc<AuthenticationService>,
     opt_stats_event_sender: &Arc<Option<Box<dyn Sender>>>,
+    opt_http_stats_event_sender: &Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     scrape_request: &Scrape,
     client_ip_sources: &ClientIpSources,
     maybe_key: Option<Key>,
@@ -150,9 +157,22 @@ async fn handle_scrape(
     };
 
     if return_real_scrape_data {
-        Ok(services::scrape::invoke(scrape_handler, opt_stats_event_sender, &scrape_request.info_hashes, &peer_ip).await)
+        Ok(services::scrape::invoke(
+            scrape_handler,
+            opt_stats_event_sender,
+            opt_http_stats_event_sender,
+            &scrape_request.info_hashes,
+            &peer_ip,
+        )
+        .await)
     } else {
-        Ok(services::scrape::fake(opt_stats_event_sender, &scrape_request.info_hashes, &peer_ip).await)
+        Ok(services::scrape::fake(
+            opt_stats_event_sender,
+            opt_http_stats_event_sender,
+            &scrape_request.info_hashes,
+            &peer_ip,
+        )
+        .await)
     }
 }
 
@@ -182,7 +202,7 @@ mod tests {
     use torrust_tracker_configuration::{Configuration, Core};
     use torrust_tracker_test_helpers::configuration;
 
-    use crate::packages;
+    use crate::packages::{self, http_tracker_core};
 
     struct CoreTrackerServices {
         pub core_config: Arc<Core>,
@@ -191,39 +211,52 @@ mod tests {
         pub authentication_service: Arc<AuthenticationService>,
     }
 
-    fn initialize_private_tracker() -> CoreTrackerServices {
+    struct CoreHttpTrackerServices {
+        pub http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
+    }
+
+    fn initialize_private_tracker() -> (CoreTrackerServices, CoreHttpTrackerServices) {
         initialize_core_tracker_services(&configuration::ephemeral_private())
     }
 
-    fn initialize_listed_tracker() -> CoreTrackerServices {
+    fn initialize_listed_tracker() -> (CoreTrackerServices, CoreHttpTrackerServices) {
         initialize_core_tracker_services(&configuration::ephemeral_listed())
     }
 
-    fn initialize_tracker_on_reverse_proxy() -> CoreTrackerServices {
+    fn initialize_tracker_on_reverse_proxy() -> (CoreTrackerServices, CoreHttpTrackerServices) {
         initialize_core_tracker_services(&configuration::ephemeral_with_reverse_proxy())
     }
 
-    fn initialize_tracker_not_on_reverse_proxy() -> CoreTrackerServices {
+    fn initialize_tracker_not_on_reverse_proxy() -> (CoreTrackerServices, CoreHttpTrackerServices) {
         initialize_core_tracker_services(&configuration::ephemeral_without_reverse_proxy())
     }
 
-    fn initialize_core_tracker_services(config: &Configuration) -> CoreTrackerServices {
+    fn initialize_core_tracker_services(config: &Configuration) -> (CoreTrackerServices, CoreHttpTrackerServices) {
         let core_config = Arc::new(config.core.clone());
         let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
         let whitelist_authorization = Arc::new(WhitelistAuthorization::new(&config.core, &in_memory_whitelist.clone()));
         let in_memory_key_repository = Arc::new(InMemoryKeyRepository::default());
         let authentication_service = Arc::new(AuthenticationService::new(&config.core, &in_memory_key_repository));
         let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
+        let scrape_handler = Arc::new(ScrapeHandler::new(&whitelist_authorization, &in_memory_torrent_repository));
+
         let (stats_event_sender, _stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
         let stats_event_sender = Arc::new(stats_event_sender);
-        let scrape_handler = Arc::new(ScrapeHandler::new(&whitelist_authorization, &in_memory_torrent_repository));
 
-        CoreTrackerServices {
-            core_config,
-            scrape_handler,
-            stats_event_sender,
-            authentication_service,
-        }
+        // HTTP stats
+        let (http_stats_event_sender, _http_stats_repository) =
+            http_tracker_core::statistics::setup::factory(config.core.tracker_usage_statistics);
+        let http_stats_event_sender = Arc::new(http_stats_event_sender);
+
+        (
+            CoreTrackerServices {
+                core_config,
+                scrape_handler,
+                stats_event_sender,
+                authentication_service,
+            },
+            CoreHttpTrackerServices { http_stats_event_sender },
+        )
     }
 
     fn sample_scrape_request() -> Scrape {
@@ -257,7 +290,7 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_return_zeroed_swarm_metadata_when_the_authentication_key_is_missing() {
-            let core_tracker_services = initialize_private_tracker();
+            let (core_tracker_services, core_http_tracker_services) = initialize_private_tracker();
 
             let scrape_request = sample_scrape_request();
             let maybe_key = None;
@@ -267,6 +300,7 @@ mod tests {
                 &core_tracker_services.scrape_handler,
                 &core_tracker_services.authentication_service,
                 &core_tracker_services.stats_event_sender,
+                &core_http_tracker_services.http_stats_event_sender,
                 &scrape_request,
                 &sample_client_ip_sources(),
                 maybe_key,
@@ -281,7 +315,7 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_return_zeroed_swarm_metadata_when_the_authentication_key_is_invalid() {
-            let core_tracker_services = initialize_private_tracker();
+            let (core_tracker_services, core_http_tracker_services) = initialize_private_tracker();
 
             let scrape_request = sample_scrape_request();
             let unregistered_key = authentication::Key::from_str("YZSl4lMZupRuOpSRC3krIKR5BPB14nrJ").unwrap();
@@ -292,6 +326,7 @@ mod tests {
                 &core_tracker_services.scrape_handler,
                 &core_tracker_services.authentication_service,
                 &core_tracker_services.stats_event_sender,
+                &core_http_tracker_services.http_stats_event_sender,
                 &scrape_request,
                 &sample_client_ip_sources(),
                 maybe_key,
@@ -314,7 +349,7 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_return_zeroed_swarm_metadata_when_the_torrent_is_not_whitelisted() {
-            let core_tracker_services = initialize_listed_tracker();
+            let (core_tracker_services, core_http_tracker_services) = initialize_listed_tracker();
 
             let scrape_request = sample_scrape_request();
 
@@ -323,6 +358,7 @@ mod tests {
                 &core_tracker_services.scrape_handler,
                 &core_tracker_services.authentication_service,
                 &core_tracker_services.stats_event_sender,
+                &core_http_tracker_services.http_stats_event_sender,
                 &scrape_request,
                 &sample_client_ip_sources(),
                 None,
@@ -346,7 +382,7 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_right_most_x_forwarded_for_header_ip_is_not_available() {
-            let core_tracker_services = initialize_tracker_on_reverse_proxy();
+            let (core_tracker_services, core_http_tracker_services) = initialize_tracker_on_reverse_proxy();
 
             let client_ip_sources = ClientIpSources {
                 right_most_x_forwarded_for: None,
@@ -358,6 +394,7 @@ mod tests {
                 &core_tracker_services.scrape_handler,
                 &core_tracker_services.authentication_service,
                 &core_tracker_services.stats_event_sender,
+                &core_http_tracker_services.http_stats_event_sender,
                 &sample_scrape_request(),
                 &client_ip_sources,
                 None,
@@ -382,7 +419,7 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_fail_when_the_client_ip_from_the_connection_info_is_not_available() {
-            let core_tracker_services = initialize_tracker_not_on_reverse_proxy();
+            let (core_tracker_services, core_http_tracker_services) = initialize_tracker_not_on_reverse_proxy();
 
             let client_ip_sources = ClientIpSources {
                 right_most_x_forwarded_for: None,
@@ -394,6 +431,7 @@ mod tests {
                 &core_tracker_services.scrape_handler,
                 &core_tracker_services.authentication_service,
                 &core_tracker_services.stats_event_sender,
+                &core_http_tracker_services.http_stats_event_sender,
                 &sample_scrape_request(),
                 &client_ip_sources,
                 None,

src/servers/http/v1/routes.rs

@@ -44,6 +44,7 @@ pub fn router(http_tracker_container: Arc<HttpTrackerContainer>, server_socket_a
                 http_tracker_container.authentication_service.clone(),
                 http_tracker_container.whitelist_authorization.clone(),
                 http_tracker_container.stats_event_sender.clone(),
+                http_tracker_container.http_stats_event_sender.clone(),
             )),
         )
         .route(
@@ -54,6 +55,7 @@ pub fn router(http_tracker_container: Arc<HttpTrackerContainer>, server_socket_a
                 http_tracker_container.authentication_service.clone(),
                 http_tracker_container.whitelist_authorization.clone(),
                 http_tracker_container.stats_event_sender.clone(),
+                http_tracker_container.http_stats_event_sender.clone(),
             )),
         )
         // Scrape request
@@ -64,6 +66,7 @@ pub fn router(http_tracker_container: Arc<HttpTrackerContainer>, server_socket_a
                 http_tracker_container.scrape_handler.clone(),
                 http_tracker_container.authentication_service.clone(),
                 http_tracker_container.stats_event_sender.clone(),
+                http_tracker_container.http_stats_event_sender.clone(),
             )),
         )
         .route(
@@ -73,6 +76,7 @@ pub fn router(http_tracker_container: Arc<HttpTrackerContainer>, server_socket_a
                 http_tracker_container.scrape_handler.clone(),
                 http_tracker_container.authentication_service.clone(),
                 http_tracker_container.stats_event_sender.clone(),
+                http_tracker_container.http_stats_event_sender.clone(),
             )),
         )
         // Add extension to get the client IP from the connection info

src/servers/http/v1/services/announce.rs

@@ -17,7 +17,7 @@ use packages::statistics::event::sender::Sender;
 use torrust_tracker_primitives::core::AnnounceData;
 use torrust_tracker_primitives::peer;
 
-use crate::packages;
+use crate::packages::{self, http_tracker_core};
 
 /// The HTTP tracker `announce` service.
 ///
@@ -32,6 +32,7 @@ use crate::packages;
 pub async fn invoke(
     announce_handler: Arc<AnnounceHandler>,
     opt_stats_event_sender: Arc<Option<Box<dyn Sender>>>,
+    opt_http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     info_hash: InfoHash,
     peer: &mut peer::Peer,
     peers_wanted: &PeersWanted,
@@ -52,6 +53,21 @@ pub async fn invoke(
         }
     }
 
+    if let Some(http_stats_event_sender) = opt_http_stats_event_sender.as_deref() {
+        match original_peer_ip {
+            IpAddr::V4(_) => {
+                http_stats_event_sender
+                    .send_event(http_tracker_core::statistics::event::Event::Tcp4Announce)
+                    .await;
+            }
+            IpAddr::V6(_) => {
+                http_stats_event_sender
+                    .send_event(http_tracker_core::statistics::event::Event::Tcp6Announce)
+                    .await;
+            }
+        }
+    }
+
     announce_data
 }
 
@@ -77,26 +93,41 @@ mod tests {
         pub stats_event_sender: Arc<Option<Box<dyn Sender>>>,
     }
 
-    fn initialize_core_tracker_services() -> CoreTrackerServices {
+    struct CoreHttpTrackerServices {
+        pub http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
+    }
+
+    fn initialize_core_tracker_services() -> (CoreTrackerServices, CoreHttpTrackerServices) {
         let config = configuration::ephemeral_public();
 
         let core_config = Arc::new(config.core.clone());
         let database = initialize_database(&config);
         let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default());
         let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(&database));
-        let (stats_event_sender, _stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
-        let stats_event_sender = Arc::new(stats_event_sender);
+
         let announce_handler = Arc::new(AnnounceHandler::new(
             &config.core,
             &in_memory_torrent_repository,
             &db_torrent_repository,
         ));
 
-        CoreTrackerServices {
-            core_config,
-            announce_handler,
-            stats_event_sender,
-        }
+        let (stats_event_sender, _stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
+        let stats_event_sender = Arc::new(stats_event_sender);
+
+        // HTTP stats
+        let (http_stats_event_sender, http_stats_repository) =
+            http_tracker_core::statistics::setup::factory(config.core.tracker_usage_statistics);
+        let http_stats_event_sender = Arc::new(http_stats_event_sender);
+        let _http_stats_repository = Arc::new(http_stats_repository);
+
+        (
+            CoreTrackerServices {
+                core_config,
+                announce_handler,
+                stats_event_sender,
+            },
+            CoreHttpTrackerServices { http_stats_event_sender },
+        )
     }
 
     fn sample_peer_using_ipv4() -> peer::Peer {
@@ -129,7 +160,7 @@ mod tests {
     use packages::statistics::event::Event;
     use tokio::sync::mpsc::error::SendError;
 
-    use crate::packages;
+    use crate::packages::{self, http_tracker_core};
 
     mock! {
         StatsEventSender {}
@@ -138,6 +169,13 @@ mod tests {
         }
     }
 
+    mock! {
+        HttpStatsEventSender {}
+        impl http_tracker_core::statistics::event::sender::Sender for HttpStatsEventSender {
+             fn send_event(&self, event: http_tracker_core::statistics::event::Event) -> BoxFuture<'static,Option<Result<(),SendError<http_tracker_core::statistics::event::Event> > > > ;
+        }
+    }
+
     mod with_tracker_in_any_mode {
         use std::future;
         use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
@@ -156,10 +194,10 @@ mod tests {
         use torrust_tracker_test_helpers::configuration;
 
         use super::{sample_peer_using_ipv4, sample_peer_using_ipv6};
-        use crate::packages;
+        use crate::packages::{self, http_tracker_core};
         use crate::servers::http::v1::services::announce::invoke;
         use crate::servers::http::v1::services::announce::tests::{
-            initialize_core_tracker_services, sample_peer, MockStatsEventSender,
+            initialize_core_tracker_services, sample_peer, MockHttpStatsEventSender, MockStatsEventSender,
         };
 
         fn initialize_announce_handler() -> Arc<AnnounceHandler> {
@@ -178,13 +216,14 @@ mod tests {
 
         #[tokio::test]
         async fn it_should_return_the_announce_data() {
-            let core_tracker_services = initialize_core_tracker_services();
+            let (core_tracker_services, core_http_tracker_services) = initialize_core_tracker_services();
 
             let mut peer = sample_peer();
 
             let announce_data = invoke(
                 core_tracker_services.announce_handler.clone(),
                 core_tracker_services.stats_event_sender.clone(),
+                core_http_tracker_services.http_stats_event_sender.clone(),
                 sample_info_hash(),
                 &mut peer,
                 &PeersWanted::All,
@@ -215,13 +254,23 @@ mod tests {
             let stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>> =
                 Arc::new(Some(Box::new(stats_event_sender_mock)));
 
+            let mut http_stats_event_sender_mock = MockHttpStatsEventSender::new();
+            http_stats_event_sender_mock
+                .expect_send_event()
+                .with(eq(http_tracker_core::statistics::event::Event::Tcp4Announce))
+                .times(1)
+                .returning(|_| Box::pin(future::ready(Some(Ok(())))));
+            let http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>> =
+                Arc::new(Some(Box::new(http_stats_event_sender_mock)));
+
             let announce_handler = initialize_announce_handler();
 
             let mut peer = sample_peer_using_ipv4();
 
             let _announce_data = invoke(
                 announce_handler,
                 stats_event_sender,
+                http_stats_event_sender,
                 sample_info_hash(),
                 &mut peer,
                 &PeersWanted::All,
@@ -260,13 +309,24 @@ mod tests {
             let stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>> =
                 Arc::new(Some(Box::new(stats_event_sender_mock)));
 
+            // Assert that the event sent is a TCP4 event
+            let mut http_stats_event_sender_mock = MockHttpStatsEventSender::new();
+            http_stats_event_sender_mock
+                .expect_send_event()
+                .with(eq(http_tracker_core::statistics::event::Event::Tcp4Announce))
+                .times(1)
+                .returning(|_| Box::pin(future::ready(Some(Ok(())))));
+            let http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>> =
+                Arc::new(Some(Box::new(http_stats_event_sender_mock)));
+
             let mut peer = peer_with_the_ipv4_loopback_ip();
 
             let announce_handler = tracker_with_an_ipv6_external_ip();
 
             let _announce_data = invoke(
                 announce_handler,
                 stats_event_sender,
+                http_stats_event_sender,
                 sample_info_hash(),
                 &mut peer,
                 &PeersWanted::All,
@@ -286,13 +346,24 @@ mod tests {
             let stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>> =
                 Arc::new(Some(Box::new(stats_event_sender_mock)));
 
+            // Assert that the event sent is a TCP4 event
+            let mut http_stats_event_sender_mock = MockHttpStatsEventSender::new();
+            http_stats_event_sender_mock
+                .expect_send_event()
+                .with(eq(http_tracker_core::statistics::event::Event::Tcp6Announce))
+                .times(1)
+                .returning(|_| Box::pin(future::ready(Some(Ok(())))));
+            let http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>> =
+                Arc::new(Some(Box::new(http_stats_event_sender_mock)));
+
             let announce_handler = initialize_announce_handler();
 
             let mut peer = sample_peer_using_ipv6();
 
             let _announce_data = invoke(
                 announce_handler,
                 stats_event_sender,
+                http_stats_event_sender,
                 sample_info_hash(),
                 &mut peer,
                 &PeersWanted::All,

src/servers/http/v1/services/scrape.rs

@@ -16,7 +16,7 @@ use packages::statistics::event::sender::Sender;
 use packages::statistics::{self};
 use torrust_tracker_primitives::core::ScrapeData;
 
-use crate::packages;
+use crate::packages::{self, http_tracker_core};
 
 /// The HTTP tracker `scrape` service.
 ///
@@ -31,12 +31,13 @@ use crate::packages;
 pub async fn invoke(
     scrape_handler: &Arc<ScrapeHandler>,
     opt_stats_event_sender: &Arc<Option<Box<dyn Sender>>>,
+    opt_http_stats_event_sender: &Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     info_hashes: &Vec<InfoHash>,
     original_peer_ip: &IpAddr,
 ) -> ScrapeData {
     let scrape_data = scrape_handler.scrape(info_hashes).await;
 
-    send_scrape_event(original_peer_ip, opt_stats_event_sender).await;
+    send_scrape_event(original_peer_ip, opt_stats_event_sender, opt_http_stats_event_sender).await;
 
     scrape_data
 }
@@ -49,15 +50,20 @@ pub async fn invoke(
 /// > **NOTICE**: tracker statistics are not updated in this case.
 pub async fn fake(
     opt_stats_event_sender: &Arc<Option<Box<dyn Sender>>>,
+    opt_http_stats_event_sender: &Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
     info_hashes: &Vec<InfoHash>,
     original_peer_ip: &IpAddr,
 ) -> ScrapeData {
-    send_scrape_event(original_peer_ip, opt_stats_event_sender).await;
+    send_scrape_event(original_peer_ip, opt_stats_event_sender, opt_http_stats_event_sender).await;
 
     ScrapeData::zeroed(info_hashes)
 }
 
-async fn send_scrape_event(original_peer_ip: &IpAddr, opt_stats_event_sender: &Arc<Option<Box<dyn Sender>>>) {
+async fn send_scrape_event(
+    original_peer_ip: &IpAddr,
+    opt_stats_event_sender: &Arc<Option<Box<dyn Sender>>>,
+    opt_http_stats_event_sender: &Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>>,
+) {
     if let Some(stats_event_sender) = opt_stats_event_sender.as_deref() {
         match original_peer_ip {
             IpAddr::V4(_) => {
@@ -68,6 +74,21 @@ async fn send_scrape_event(original_peer_ip: &IpAddr, opt_stats_event_sender: &A
             }
         }
     }
+
+    if let Some(http_stats_event_sender) = opt_http_stats_event_sender.as_deref() {
+        match original_peer_ip {
+            IpAddr::V4(_) => {
+                http_stats_event_sender
+                    .send_event(http_tracker_core::statistics::event::Event::Tcp4Scrape)
+                    .await;
+            }
+            IpAddr::V6(_) => {
+                http_stats_event_sender
+                    .send_event(http_tracker_core::statistics::event::Event::Tcp6Scrape)
+                    .await;
+            }
+        }
+    }
 }
 
 #[cfg(test)]
@@ -94,7 +115,7 @@ mod tests {
     use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};
     use torrust_tracker_test_helpers::configuration;
 
-    use crate::packages;
+    use crate::packages::{self, http_tracker_core};
 
     fn initialize_announce_and_scrape_handlers_for_public_tracker() -> (Arc<AnnounceHandler>, Arc<ScrapeHandler>) {
         let config = configuration::ephemeral_public();
@@ -147,6 +168,13 @@ mod tests {
         }
     }
 
+    mock! {
+        HttpStatsEventSender {}
+        impl http_tracker_core::statistics::event::sender::Sender for HttpStatsEventSender {
+             fn send_event(&self, event: http_tracker_core::statistics::event::Event) -> BoxFuture<'static,Option<Result<(),SendError<http_tracker_core::statistics::event::Event> > > > ;
+        }
+    }
+
     mod with_real_data {
 
         use std::future;
@@ -159,18 +187,22 @@ mod tests {
         use torrust_tracker_primitives::core::ScrapeData;
         use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
 
-        use crate::packages;
+        use crate::packages::{self, http_tracker_core};
         use crate::servers::http::v1::services::scrape::invoke;
         use crate::servers::http::v1::services::scrape::tests::{
             initialize_announce_and_scrape_handlers_for_public_tracker, initialize_scrape_handler, sample_info_hash,
-            sample_info_hashes, sample_peer, MockStatsEventSender,
+            sample_info_hashes, sample_peer, MockHttpStatsEventSender, MockStatsEventSender,
         };
 
         #[tokio::test]
         async fn it_should_return_the_scrape_data_for_a_torrent() {
             let (stats_event_sender, _stats_repository) = packages::statistics::setup::factory(false);
             let stats_event_sender = Arc::new(stats_event_sender);
 
+            let (http_stats_event_sender, _http_stats_repository) =
+                packages::http_tracker_core::statistics::setup::factory(false);
+            let http_stats_event_sender = Arc::new(http_stats_event_sender);
+
             let (announce_handler, scrape_handler) = initialize_announce_and_scrape_handlers_for_public_tracker();
 
             let info_hash = sample_info_hash();
@@ -181,7 +213,14 @@ mod tests {
             let original_peer_ip = peer.ip();
             announce_handler.announce(&info_hash, &mut peer, &original_peer_ip, &PeersWanted::All);
 
-            let scrape_data = invoke(&scrape_handler, &stats_event_sender, &info_hashes, &original_peer_ip).await;
+            let scrape_data = invoke(
+                &scrape_handler,
+                &stats_event_sender,
+                &http_stats_event_sender,
+                &info_hashes,
+                &original_peer_ip,
+            )
+            .await;
 
             let mut expected_scrape_data = ScrapeData::empty();
             expected_scrape_data.add_file(
@@ -207,11 +246,27 @@ mod tests {
             let stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>> =
                 Arc::new(Some(Box::new(stats_event_sender_mock)));
 
+            let mut http_stats_event_sender_mock = MockHttpStatsEventSender::new();
+            http_stats_event_sender_mock
+                .expect_send_event()
+                .with(eq(http_tracker_core::statistics::event::Event::Tcp4Scrape))
+                .times(1)
+                .returning(|_| Box::pin(future::ready(Some(Ok(())))));
+            let http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>> =
+                Arc::new(Some(Box::new(http_stats_event_sender_mock)));
+
             let scrape_handler = initialize_scrape_handler();
 
             let peer_ip = IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1));
 
-            invoke(&scrape_handler, &stats_event_sender, &sample_info_hashes(), &peer_ip).await;
+            invoke(
+                &scrape_handler,
+                &stats_event_sender,
+                &http_stats_event_sender,
+                &sample_info_hashes(),
+                &peer_ip,
+            )
+            .await;
         }
 
         #[tokio::test]
@@ -225,11 +280,27 @@ mod tests {
             let stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>> =
                 Arc::new(Some(Box::new(stats_event_sender_mock)));
 
+            let mut http_stats_event_sender_mock = MockHttpStatsEventSender::new();
+            http_stats_event_sender_mock
+                .expect_send_event()
+                .with(eq(http_tracker_core::statistics::event::Event::Tcp6Scrape))
+                .times(1)
+                .returning(|_| Box::pin(future::ready(Some(Ok(())))));
+            let http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>> =
+                Arc::new(Some(Box::new(http_stats_event_sender_mock)));
+
             let scrape_handler = initialize_scrape_handler();
 
             let peer_ip = IpAddr::V6(Ipv6Addr::new(0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969));
 
-            invoke(&scrape_handler, &stats_event_sender, &sample_info_hashes(), &peer_ip).await;
+            invoke(
+                &scrape_handler,
+                &stats_event_sender,
+                &http_stats_event_sender,
+                &sample_info_hashes(),
+                &peer_ip,
+            )
+            .await;
         }
     }
 
@@ -244,18 +315,22 @@ mod tests {
         use packages::statistics;
         use torrust_tracker_primitives::core::ScrapeData;
 
-        use crate::packages;
+        use crate::packages::{self, http_tracker_core};
         use crate::servers::http::v1::services::scrape::fake;
         use crate::servers::http::v1::services::scrape::tests::{
             initialize_announce_and_scrape_handlers_for_public_tracker, sample_info_hash, sample_info_hashes, sample_peer,
-            MockStatsEventSender,
+            MockHttpStatsEventSender, MockStatsEventSender,
         };
 
         #[tokio::test]
         async fn it_should_always_return_the_zeroed_scrape_data_for_a_torrent() {
             let (stats_event_sender, _stats_repository) = packages::statistics::setup::factory(false);
             let stats_event_sender = Arc::new(stats_event_sender);
 
+            let (http_stats_event_sender, _http_stats_repository) =
+                packages::http_tracker_core::statistics::setup::factory(false);
+            let http_stats_event_sender = Arc::new(http_stats_event_sender);
+
             let (announce_handler, _scrape_handler) = initialize_announce_and_scrape_handlers_for_public_tracker();
 
             let info_hash = sample_info_hash();
@@ -266,7 +341,7 @@ mod tests {
             let original_peer_ip = peer.ip();
             announce_handler.announce(&info_hash, &mut peer, &original_peer_ip, &PeersWanted::All);
 
-            let scrape_data = fake(&stats_event_sender, &info_hashes, &original_peer_ip).await;
+            let scrape_data = fake(&stats_event_sender, &http_stats_event_sender, &info_hashes, &original_peer_ip).await;
 
             let expected_scrape_data = ScrapeData::zeroed(&info_hashes);
 
@@ -284,9 +359,18 @@ mod tests {
             let stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>> =
                 Arc::new(Some(Box::new(stats_event_sender_mock)));
 
+            let mut http_stats_event_sender_mock = MockHttpStatsEventSender::new();
+            http_stats_event_sender_mock
+                .expect_send_event()
+                .with(eq(http_tracker_core::statistics::event::Event::Tcp4Scrape))
+                .times(1)
+                .returning(|_| Box::pin(future::ready(Some(Ok(())))));
+            let http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>> =
+                Arc::new(Some(Box::new(http_stats_event_sender_mock)));
+
             let peer_ip = IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1));
 
-            fake(&stats_event_sender, &sample_info_hashes(), &peer_ip).await;
+            fake(&stats_event_sender, &http_stats_event_sender, &sample_info_hashes(), &peer_ip).await;
         }
 
         #[tokio::test]
@@ -300,9 +384,18 @@ mod tests {
             let stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>> =
                 Arc::new(Some(Box::new(stats_event_sender_mock)));
 
+            let mut http_stats_event_sender_mock = MockHttpStatsEventSender::new();
+            http_stats_event_sender_mock
+                .expect_send_event()
+                .with(eq(http_tracker_core::statistics::event::Event::Tcp6Scrape))
+                .times(1)
+                .returning(|_| Box::pin(future::ready(Some(Ok(())))));
+            let http_stats_event_sender: Arc<Option<Box<dyn http_tracker_core::statistics::event::sender::Sender>>> =
+                Arc::new(Some(Box::new(http_stats_event_sender_mock)));
+
             let peer_ip = IpAddr::V6(Ipv6Addr::new(0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969));
 
-            fake(&stats_event_sender, &sample_info_hashes(), &peer_ip).await;
+            fake(&stats_event_sender, &http_stats_event_sender, &sample_info_hashes(), &peer_ip).await;
         }
     }
 }

tests/servers/http/environment.rs

@@ -62,6 +62,7 @@ impl Environment<Stopped> {
             scrape_handler: app_container.scrape_handler.clone(),
             whitelist_authorization: app_container.whitelist_authorization.clone(),
             stats_event_sender: app_container.stats_event_sender.clone(),
+            http_stats_event_sender: app_container.http_stats_event_sender.clone(),
             authentication_service: app_container.authentication_service.clone(),
         });