refactor: [#1184] remove stats functionality from core tracker

Author: josecelano

src/app.rs

@@ -29,6 +29,8 @@ use torrust_tracker_configuration::Configuration;
 use tracing::instrument;
 
 use crate::bootstrap::jobs::{health_check_api, http_tracker, torrent_cleanup, tracker_apis, udp_tracker};
+use crate::core::statistics::event::sender::Sender;
+use crate::core::statistics::repository::Repository;
 use crate::servers::registar::Registar;
 use crate::servers::udp::server::banning::BanService;
 use crate::{core, servers};
@@ -39,11 +41,13 @@ use crate::{core, servers};
 ///
 /// - Can't retrieve tracker keys from database.
 /// - Can't load whitelist from database.
-#[instrument(skip(config, tracker, ban_service))]
+#[instrument(skip(config, tracker, ban_service, stats_event_sender, stats_repository))]
 pub async fn start(
     config: &Configuration,
     tracker: Arc<core::Tracker>,
     ban_service: Arc<RwLock<BanService>>,
+    stats_event_sender: Arc<Option<Box<dyn Sender>>>,
+    stats_repository: Arc<Repository>,
 ) -> Vec<JoinHandle<()>> {
     if config.http_api.is_none()
         && (config.udp_trackers.is_none() || config.udp_trackers.as_ref().map_or(true, std::vec::Vec::is_empty))
@@ -115,6 +119,8 @@ pub async fn start(
             http_api_config,
             tracker.clone(),
             ban_service.clone(),
+            stats_event_sender.clone(),
+            stats_repository.clone(),
             registar.give_form(),
             servers::apis::Version::V1,
         )

src/bootstrap/app.rs

@@ -39,7 +39,13 @@ use crate::shared::crypto::keys::{self, Keeper as _};
 /// Setup can file if the configuration is invalid.
 #[must_use]
 #[instrument(skip())]
-pub fn setup() -> (Configuration, Arc<Tracker>, Arc<RwLock<BanService>>) {
+pub fn setup() -> (
+    Configuration,
+    Arc<Tracker>,
+    Arc<RwLock<BanService>>,
+    Arc<Option<Box<dyn Sender>>>,
+    Arc<Repository>,
+) {
     #[cfg(not(test))]
     check_seed();
 
@@ -49,13 +55,19 @@ pub fn setup() -> (Configuration, Arc<Tracker>, Arc<RwLock<BanService>>) {
         panic!("Configuration error: {e}");
     }
 
-    let tracker = initialize_with_configuration(&configuration);
+    // Initialize services
+
+    let (stats_event_sender, stats_repository) = statistics::setup::factory(configuration.core.tracker_usage_statistics);
+    let stats_event_sender = Arc::new(stats_event_sender);
+    let stats_repository = Arc::new(stats_repository);
 
     let udp_ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
 
+    let tracker = initialize_with_configuration(&configuration);
+
     tracing::info!("Configuration:\n{}", configuration.clone().mask_secrets().to_json());
 
-    (configuration, tracker, udp_ban_service)
+    (configuration, tracker, udp_ban_service, stats_event_sender, stats_repository)
 }
 
 /// checks if the seed is the instance seed in production.
@@ -109,28 +121,18 @@ pub fn initialize_static() {
 #[must_use]
 #[instrument(skip(config))]
 pub fn initialize_tracker(config: &Configuration) -> Tracker {
-    let (database, whitelist_manager, stats_event_sender, stats_repository) = initialize_tracker_dependencies(config);
+    let (database, whitelist_manager) = initialize_tracker_dependencies(config);
 
-    tracker_factory(config, &database, &whitelist_manager, &stats_event_sender, &stats_repository)
+    tracker_factory(config, &database, &whitelist_manager)
 }
 
 #[allow(clippy::type_complexity)]
 #[must_use]
-pub fn initialize_tracker_dependencies(
-    config: &Configuration,
-) -> (
-    Arc<Box<dyn Database>>,
-    Arc<WhiteListManager>,
-    Arc<Option<Box<dyn Sender>>>,
-    Arc<Repository>,
-) {
+pub fn initialize_tracker_dependencies(config: &Configuration) -> (Arc<Box<dyn Database>>, Arc<WhiteListManager>) {
     let database = initialize_database(config);
     let whitelist_manager = initialize_whitelist(database.clone());
-    let (stats_event_sender, stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
-    let stats_event_sender = Arc::new(stats_event_sender);
-    let stats_repository = Arc::new(stats_repository);
 
-    (database, whitelist_manager, stats_event_sender, stats_repository)
+    (database, whitelist_manager)
 }
 
 /// It initializes the log threshold, format and channel.

src/bootstrap/jobs/http_tracker.rs

@@ -85,6 +85,7 @@ mod tests {
 
     use crate::bootstrap::app::initialize_with_configuration;
     use crate::bootstrap::jobs::http_tracker::start_job;
+    use crate::core::services::statistics;
     use crate::servers::http::Version;
     use crate::servers::registar::Registar;
 
@@ -93,6 +94,9 @@ mod tests {
         let cfg = Arc::new(ephemeral_public());
         let http_tracker = cfg.http_trackers.clone().expect("missing HTTP tracker configuration");
         let config = &http_tracker[0];
+        let (stats_event_sender, stats_repository) = statistics::setup::factory(cfg.core.tracker_usage_statistics);
+        let _stats_event_sender = Arc::new(stats_event_sender);
+        let _stats_repository = Arc::new(stats_repository);
         let tracker = initialize_with_configuration(&cfg);
         let version = Version::V1;
 

src/bootstrap/jobs/tracker_apis.rs

@@ -31,6 +31,8 @@ use tracing::instrument;
 
 use super::make_rust_tls;
 use crate::core;
+use crate::core::statistics::event::sender::Sender;
+use crate::core::statistics::repository::Repository;
 use crate::servers::apis::server::{ApiServer, Launcher};
 use crate::servers::apis::Version;
 use crate::servers::registar::ServiceRegistrationForm;
@@ -56,11 +58,13 @@ pub struct ApiServerJobStarted();
 /// It would panic if unable to send the  `ApiServerJobStarted` notice.
 ///
 ///
-#[instrument(skip(config, tracker, ban_service, form))]
+#[instrument(skip(config, tracker, ban_service, stats_event_sender, stats_repository, form))]
 pub async fn start_job(
     config: &HttpApi,
     tracker: Arc<core::Tracker>,
     ban_service: Arc<RwLock<BanService>>,
+    stats_event_sender: Arc<Option<Box<dyn Sender>>>,
+    stats_repository: Arc<Repository>,
     form: ServiceRegistrationForm,
     version: Version,
 ) -> Option<JoinHandle<()>> {
@@ -73,22 +77,52 @@ pub async fn start_job(
     let access_tokens = Arc::new(config.access_tokens.clone());
 
     match version {
-        Version::V1 => Some(start_v1(bind_to, tls, tracker.clone(), ban_service.clone(), form, access_tokens).await),
+        Version::V1 => Some(
+            start_v1(
+                bind_to,
+                tls,
+                tracker.clone(),
+                ban_service.clone(),
+                stats_event_sender.clone(),
+                stats_repository.clone(),
+                form,
+                access_tokens,
+            )
+            .await,
+        ),
     }
 }
 
 #[allow(clippy::async_yields_async)]
-#[instrument(skip(socket, tls, tracker, ban_service, form, access_tokens))]
+#[instrument(skip(
+    socket,
+    tls,
+    tracker,
+    ban_service,
+    stats_event_sender,
+    stats_repository,
+    form,
+    access_tokens
+))]
 async fn start_v1(
     socket: SocketAddr,
     tls: Option<RustlsConfig>,
     tracker: Arc<core::Tracker>,
     ban_service: Arc<RwLock<BanService>>,
+    stats_event_sender: Arc<Option<Box<dyn Sender>>>,
+    stats_repository: Arc<Repository>,
     form: ServiceRegistrationForm,
     access_tokens: Arc<AccessTokens>,
 ) -> JoinHandle<()> {
     let server = ApiServer::new(Launcher::new(socket, tls))
-        .start(tracker, ban_service, form, access_tokens)
+        .start(
+            tracker,
+            ban_service,
+            stats_event_sender,
+            stats_repository,
+            form,
+            access_tokens,
+        )
         .await
         .expect("it should be able to start to the tracker api");
 
@@ -107,6 +141,7 @@ mod tests {
 
     use crate::bootstrap::app::initialize_with_configuration;
     use crate::bootstrap::jobs::tracker_apis::start_job;
+    use crate::core::services::statistics;
     use crate::servers::apis::Version;
     use crate::servers::registar::Registar;
     use crate::servers::udp::server::banning::BanService;
@@ -116,12 +151,26 @@ mod tests {
     async fn it_should_start_http_tracker() {
         let cfg = Arc::new(ephemeral_public());
         let config = &cfg.http_api.clone().unwrap();
-        let tracker = initialize_with_configuration(&cfg);
+
         let ban_service = Arc::new(RwLock::new(BanService::new(MAX_CONNECTION_ID_ERRORS_PER_IP)));
+        let (stats_event_sender, stats_repository) = statistics::setup::factory(cfg.core.tracker_usage_statistics);
+        let stats_event_sender = Arc::new(stats_event_sender);
+        let stats_repository = Arc::new(stats_repository);
+
+        let tracker = initialize_with_configuration(&cfg);
+
         let version = Version::V1;
 
-        start_job(config, tracker, ban_service, Registar::default().give_form(), version)
-            .await
-            .expect("it should be able to join to the tracker api start-job");
+        start_job(
+            config,
+            tracker,
+            ban_service,
+            stats_event_sender,
+            stats_repository,
+            Registar::default().give_form(),
+            version,
+        )
+        .await
+        .expect("it should be able to join to the tracker api start-job");
     }
 }

src/console/profiling.rs

@@ -179,9 +179,9 @@ pub async fn run() {
         return;
     };
 
-    let (config, tracker, ban_service) = bootstrap::app::setup();
+    let (config, tracker, ban_service, stats_event_sender, stats_repository) = bootstrap::app::setup();
 
-    let jobs = app::start(&config, tracker, ban_service).await;
+    let jobs = app::start(&config, tracker, ban_service, stats_event_sender, stats_repository).await;
 
     // Run the tracker for a fixed duration
     let run_duration = sleep(Duration::from_secs(duration_secs));

src/core/mod.rs

@@ -422,7 +422,7 @@
 //! For example, the HTTP tracker would send an event like the following when it handles an `announce` request received from a peer using IP version 4.
 //!
 //! ```text
-//! tracker.send_stats_event(statistics::event::Event::Tcp4Announce).await
+//! stats_event_sender.send_stats_event(statistics::event::Event::Tcp4Announce).await
 //! ```
 //!
 //! Refer to [`statistics`] module for more information about statistics.
@@ -458,7 +458,6 @@ use std::time::Duration;
 use auth::PeerKey;
 use bittorrent_primitives::info_hash::InfoHash;
 use error::PeerKeyError;
-use tokio::sync::mpsc::error::SendError;
 use torrust_tracker_clock::clock::Time;
 use torrust_tracker_configuration::{AnnouncePolicy, Core, TORRENT_PEERS_LIMIT};
 use torrust_tracker_located_error::Located;
@@ -502,12 +501,6 @@ pub struct Tracker {
 
     /// The in-memory torrents repository.
     torrents: Arc<Torrents>,
-
-    /// Service to send stats events.
-    stats_event_sender: Arc<Option<Box<dyn statistics::event::sender::Sender>>>,
-
-    /// The in-memory stats repo.
-    stats_repository: Arc<statistics::repository::Repository>,
 }
 
 /// How many peers the peer announcing wants in the announce response.
@@ -576,17 +569,13 @@ impl Tracker {
         config: &Core,
         database: &Arc<Box<dyn Database>>,
         whitelist_manager: &Arc<WhiteListManager>,
-        stats_event_sender: &Arc<Option<Box<dyn statistics::event::sender::Sender>>>,
-        stats_repository: &Arc<statistics::repository::Repository>,
     ) -> Result<Tracker, databases::error::Error> {
         Ok(Tracker {
             config: config.clone(),
             database: database.clone(),
             keys: tokio::sync::RwLock::new(std::collections::HashMap::new()),
             whitelist_manager: whitelist_manager.clone(),
             torrents: Arc::default(),
-            stats_event_sender: stats_event_sender.clone(),
-            stats_repository: stats_repository.clone(),
         })
     }
 
@@ -1054,26 +1043,6 @@ impl Tracker {
         })
     }
 
-    /// It return the `Tracker` [`statistics::metrics::Metrics`].
-    ///
-    /// # Context: Statistics
-    pub async fn get_stats(&self) -> tokio::sync::RwLockReadGuard<'_, statistics::metrics::Metrics> {
-        self.stats_repository.get_stats().await
-    }
-
-    /// It allows to send a statistic events which eventually will be used to update [`statistics::metrics::Metrics`].
-    ///
-    /// # Context: Statistics
-    pub async fn send_stats_event(
-        &self,
-        event: statistics::event::Event,
-    ) -> Option<Result<(), SendError<statistics::event::Event>>> {
-        match &*self.stats_event_sender {
-            None => None,
-            Some(stats_event_sender) => stats_event_sender.send_event(event).await,
-        }
-    }
-
     /// It drops the database tables.
     ///
     /// # Errors
@@ -1113,35 +1082,47 @@ mod tests {
 
         use crate::bootstrap::app::initialize_tracker_dependencies;
         use crate::core::peer::Peer;
-        use crate::core::services::tracker_factory;
+        use crate::core::services::{statistics, tracker_factory};
         use crate::core::whitelist::WhiteListManager;
         use crate::core::{TorrentsMetrics, Tracker};
 
         fn public_tracker() -> Tracker {
             let config = configuration::ephemeral_public();
-            let (database, whitelist_manager, stats_event_sender, stats_repository) = initialize_tracker_dependencies(&config);
-            tracker_factory(&config, &database, &whitelist_manager, &stats_event_sender, &stats_repository)
+            let (database, whitelist_manager) = initialize_tracker_dependencies(&config);
+            let (stats_event_sender, stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
+            let _stats_event_sender = Arc::new(stats_event_sender);
+            let _stats_repository = Arc::new(stats_repository);
+            tracker_factory(&config, &database, &whitelist_manager)
         }
 
         fn private_tracker() -> Tracker {
             let config = configuration::ephemeral_private();
-            let (database, whitelist_manager, stats_event_sender, stats_repository) = initialize_tracker_dependencies(&config);
-            tracker_factory(&config, &database, &whitelist_manager, &stats_event_sender, &stats_repository)
+            let (database, whitelist_manager) = initialize_tracker_dependencies(&config);
+            let (stats_event_sender, stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
+            let _stats_event_sender = Arc::new(stats_event_sender);
+            let _stats_repository = Arc::new(stats_repository);
+            tracker_factory(&config, &database, &whitelist_manager)
         }
 
         fn whitelisted_tracker() -> (Tracker, Arc<WhiteListManager>) {
             let config = configuration::ephemeral_listed();
-            let (database, whitelist_manager, stats_event_sender, stats_repository) = initialize_tracker_dependencies(&config);
-            let tracker = tracker_factory(&config, &database, &whitelist_manager, &stats_event_sender, &stats_repository);
+            let (database, whitelist_manager) = initialize_tracker_dependencies(&config);
+            let (stats_event_sender, stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
+            let _stats_event_sender = Arc::new(stats_event_sender);
+            let _stats_repository = Arc::new(stats_repository);
+            let tracker = tracker_factory(&config, &database, &whitelist_manager);
 
             (tracker, whitelist_manager)
         }
 
         pub fn tracker_persisting_torrents_in_database() -> Tracker {
             let mut config = configuration::ephemeral_listed();
             config.core.tracker_policy.persistent_torrent_completed_stat = true;
-            let (database, whitelist_manager, stats_event_sender, stats_repository) = initialize_tracker_dependencies(&config);
-            tracker_factory(&config, &database, &whitelist_manager, &stats_event_sender, &stats_repository)
+            let (database, whitelist_manager) = initialize_tracker_dependencies(&config);
+            let (stats_event_sender, stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics);
+            let _stats_event_sender = Arc::new(stats_event_sender);
+            let _stats_repository = Arc::new(stats_repository);
+            tracker_factory(&config, &database, &whitelist_manager)
         }
 
         fn sample_info_hash() -> InfoHash {