tracing: add spans to many functions

Author: da2ce7

src/app.rs

@@ -25,6 +25,7 @@ use std::sync::Arc;
 
 use tokio::task::JoinHandle;
 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::servers::registar::Registar;
@@ -36,6 +37,7 @@ use crate::{core, servers};
 ///
 /// - Can't retrieve tracker keys from database.
 /// - Can't load whitelist from database.
+#[instrument(skip(config, tracker))]
 pub async fn start(config: &Configuration, tracker: Arc<core::Tracker>) -> 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))

src/bootstrap/app.rs

@@ -16,6 +16,7 @@ use std::sync::Arc;
 use torrust_tracker_clock::static_time;
 use torrust_tracker_configuration::validator::Validator;
 use torrust_tracker_configuration::Configuration;
+use tracing::instrument;
 
 use super::config::initialize_configuration;
 use crate::bootstrap;
@@ -29,6 +30,7 @@ use crate::shared::crypto::ephemeral_instance_keys;
 ///
 /// Setup can file if the configuration is invalid.
 #[must_use]
+#[instrument(skip())]
 pub fn setup() -> (Configuration, Arc<Tracker>) {
     let configuration = initialize_configuration();
 
@@ -47,6 +49,7 @@ pub fn setup() -> (Configuration, Arc<Tracker>) {
 ///
 /// The configuration may be obtained from the environment (via config file or env vars).
 #[must_use]
+#[instrument(skip())]
 pub fn initialize_with_configuration(configuration: &Configuration) -> Arc<Tracker> {
     initialize_static();
     initialize_logging(configuration);
@@ -59,6 +62,7 @@ pub fn initialize_with_configuration(configuration: &Configuration) -> Arc<Track
 ///
 /// - The time when the application started.
 /// - An ephemeral instance random seed. This seed is used for encryption and it's changed when the main application process is restarted.
+#[instrument(skip())]
 pub fn initialize_static() {
     // Set the time of Torrust app starting
     lazy_static::initialize(&static_time::TIME_AT_APP_START);
@@ -72,13 +76,15 @@ pub fn initialize_static() {
 /// The tracker is the domain layer service. It's the entrypoint to make requests to the domain layer.
 /// It's used by other higher-level components like the UDP and HTTP trackers or the tracker API.
 #[must_use]
+#[instrument(skip(config))]
 pub fn initialize_tracker(config: &Configuration) -> Tracker {
     tracker_factory(config)
 }
 
 /// It initializes the log threshold, format and channel.
 ///
 /// See [the logging setup](crate::bootstrap::logging::setup) for more info about logging.
+#[instrument(skip(config))]
 pub fn initialize_logging(config: &Configuration) {
     bootstrap::logging::setup(config);
 }

src/bootstrap/jobs/health_check_api.rs

@@ -17,6 +17,7 @@
 use tokio::sync::oneshot;
 use tokio::task::JoinHandle;
 use torrust_tracker_configuration::HealthCheckApi;
+use tracing::instrument;
 
 use super::Started;
 use crate::servers::health_check_api::{server, HEALTH_CHECK_API_LOG_TARGET};
@@ -34,6 +35,8 @@ use crate::servers::signals::Halted;
 /// # Panics
 ///
 /// It would panic if unable to send the  `ApiServerJobStarted` notice.
+#[allow(clippy::async_yields_async)]
+#[instrument(skip(config, register))]
 pub async fn start_job(config: &HealthCheckApi, register: ServiceRegistry) -> JoinHandle<()> {
     let bind_addr = config.bind_address;
 

src/bootstrap/jobs/http_tracker.rs

@@ -16,6 +16,7 @@ use std::sync::Arc;
 use axum_server::tls_rustls::RustlsConfig;
 use tokio::task::JoinHandle;
 use torrust_tracker_configuration::HttpTracker;
+use tracing::instrument;
 
 use super::make_rust_tls;
 use crate::core;
@@ -32,6 +33,7 @@ use crate::servers::registar::ServiceRegistrationForm;
 ///
 /// It would panic if the `config::HttpTracker` struct would contain inappropriate values.
 ///
+#[instrument(skip(config, tracker, form))]
 pub async fn start_job(
     config: &HttpTracker,
     tracker: Arc<core::Tracker>,
@@ -49,6 +51,8 @@ pub async fn start_job(
     }
 }
 
+#[allow(clippy::async_yields_async)]
+#[instrument(skip(socket, tls, tracker, form))]
 async fn start_v1(
     socket: SocketAddr,
     tls: Option<RustlsConfig>,

src/bootstrap/jobs/mod.rs

@@ -20,6 +20,7 @@ pub struct Started {
     pub address: std::net::SocketAddr,
 }
 
+#[instrument(skip(opt_tsl_config))]
 pub async fn make_rust_tls(opt_tsl_config: &Option<TslConfig>) -> Option<Result<RustlsConfig, Error>> {
     match opt_tsl_config {
         Some(tsl_config) => {
@@ -89,6 +90,7 @@ use axum_server::tls_rustls::RustlsConfig;
 use thiserror::Error;
 use torrust_tracker_configuration::TslConfig;
 use torrust_tracker_located_error::{DynError, LocatedError};
+use tracing::instrument;
 
 /// Error returned by the Bootstrap Process.
 #[derive(Error, Debug)]

src/bootstrap/jobs/torrent_cleanup.rs

@@ -15,6 +15,7 @@ use std::sync::Arc;
 use chrono::Utc;
 use tokio::task::JoinHandle;
 use torrust_tracker_configuration::Core;
+use tracing::instrument;
 
 use crate::core;
 
@@ -24,6 +25,7 @@ use crate::core;
 ///
 /// Refer to [`torrust-tracker-configuration documentation`](https://docs.rs/torrust-tracker-configuration) for more info about that option.
 #[must_use]
+#[instrument(skip(config, tracker))]
 pub fn start_job(config: &Core, tracker: &Arc<core::Tracker>) -> JoinHandle<()> {
     let weak_tracker = std::sync::Arc::downgrade(tracker);
     let interval = config.inactive_peer_cleanup_interval;

src/bootstrap/jobs/tracker_apis.rs

@@ -26,6 +26,7 @@ use std::sync::Arc;
 use axum_server::tls_rustls::RustlsConfig;
 use tokio::task::JoinHandle;
 use torrust_tracker_configuration::{AccessTokens, HttpApi};
+use tracing::instrument;
 
 use super::make_rust_tls;
 use crate::core;
@@ -53,6 +54,7 @@ pub struct ApiServerJobStarted();
 /// It would panic if unable to send the  `ApiServerJobStarted` notice.
 ///
 ///
+#[instrument(skip(config, tracker, form))]
 pub async fn start_job(
     config: &HttpApi,
     tracker: Arc<core::Tracker>,
@@ -72,6 +74,8 @@ pub async fn start_job(
     }
 }
 
+#[allow(clippy::async_yields_async)]
+#[instrument(skip(socket, tls, tracker, form, access_tokens))]
 async fn start_v1(
     socket: SocketAddr,
     tls: Option<RustlsConfig>,

src/bootstrap/jobs/udp_tracker.rs

@@ -10,6 +10,7 @@ use std::sync::Arc;
 
 use tokio::task::JoinHandle;
 use torrust_tracker_configuration::UdpTracker;
+use tracing::instrument;
 
 use crate::core;
 use crate::servers::registar::ServiceRegistrationForm;
@@ -27,6 +28,8 @@ use crate::servers::udp::UDP_TRACKER_LOG_TARGET;
 /// It will panic if it is unable to start the UDP service.
 /// It will panic if the task did not finish successfully.
 #[must_use]
+#[allow(clippy::async_yields_async)]
+#[instrument(skip(config, tracker, form))]
 pub async fn start_job(config: &UdpTracker, tracker: Arc<core::Tracker>, form: ServiceRegistrationForm) -> JoinHandle<()> {
     let bind_to = config.bind_address;
 

src/servers/apis/routes.rs

@@ -21,7 +21,7 @@ use tower_http::compression::CompressionLayer;
 use tower_http::propagate_header::PropagateHeaderLayer;
 use tower_http::request_id::{MakeRequestUuid, SetRequestIdLayer};
 use tower_http::trace::{DefaultMakeSpan, TraceLayer};
-use tracing::{Level, Span};
+use tracing::{instrument, Level, Span};
 
 use super::v1;
 use super::v1::context::health_check::handlers::health_check_handler;
@@ -31,6 +31,7 @@ use crate::servers::apis::API_LOG_TARGET;
 
 /// Add all API routes to the router.
 #[allow(clippy::needless_pass_by_value)]
+#[instrument(skip(tracker, access_tokens))]
 pub fn router(tracker: Arc<Tracker>, access_tokens: Arc<AccessTokens>) -> Router {
     let router = Router::new();
 

src/servers/apis/server.rs

@@ -28,10 +28,13 @@ use std::sync::Arc;
 
 use axum_server::tls_rustls::RustlsConfig;
 use axum_server::Handle;
+use derive_more::derive::Display;
 use derive_more::Constructor;
 use futures::future::BoxFuture;
+use thiserror::Error;
 use tokio::sync::oneshot::{Receiver, Sender};
 use torrust_tracker_configuration::AccessTokens;
+use tracing::{instrument, Level};
 
 use super::routes::router;
 use crate::bootstrap::jobs::Started;
@@ -43,9 +46,10 @@ use crate::servers::registar::{ServiceHealthCheckJob, ServiceRegistration, Servi
 use crate::servers::signals::{graceful_shutdown, Halted};
 
 /// Errors that can occur when starting or stopping the API server.
-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum Error {
-    Error(String),
+    #[error("Error when starting or stopping the API server")]
+    FailedToStartOrStop(String),
 }
 
 /// An alias for the `ApiServer` struct with the `Stopped` state.
@@ -62,31 +66,39 @@ pub type RunningApiServer = ApiServer<Running>;
 /// It's a state machine that can be in one of two
 /// states: `Stopped` or `Running`.
 #[allow(clippy::module_name_repetitions)]
-pub struct ApiServer<S> {
+#[derive(Debug, Display)]
+pub struct ApiServer<S>
+where
+    S: std::fmt::Debug + std::fmt::Display,
+{
     pub state: S,
 }
 
 /// The `Stopped` state of the `ApiServer` struct.
+#[derive(Debug, Display)]
+#[display("Stopped: {launcher}")]
 pub struct Stopped {
     launcher: Launcher,
 }
 
 /// The `Running` state of the `ApiServer` struct.
+#[derive(Debug, Display)]
+#[display("Running (with local address): {local_addr}")]
 pub struct Running {
-    pub binding: SocketAddr,
+    pub local_addr: SocketAddr,
     pub halt_task: tokio::sync::oneshot::Sender<Halted>,
     pub task: tokio::task::JoinHandle<Launcher>,
 }
 
 impl Running {
     #[must_use]
     pub fn new(
-        binding: SocketAddr,
+        local_addr: SocketAddr,
         halt_task: tokio::sync::oneshot::Sender<Halted>,
         task: tokio::task::JoinHandle<Launcher>,
     ) -> Self {
         Self {
-            binding,
+            local_addr,
             halt_task,
             task,
         }
@@ -110,6 +122,7 @@ impl ApiServer<Stopped> {
     /// # Panics
     ///
     /// It would panic if the bound socket address cannot be sent back to this starter.
+    #[instrument(skip(self, tracker, form, access_tokens), err, ret(Display, level = Level::INFO))]
     pub async fn start(
         self,
         tracker: Arc<Tracker>,
@@ -157,13 +170,14 @@ impl ApiServer<Running> {
     /// # Errors
     ///
     /// It would return an error if the channel for the task killer signal was closed.
+    #[instrument(skip(self), err, ret(Display, level = Level::INFO))]
     pub async fn stop(self) -> Result<ApiServer<Stopped>, Error> {
         self.state
             .halt_task
             .send(Halted::Normal)
-            .map_err(|_| Error::Error("Task killer channel was closed.".to_string()))?;
+            .map_err(|_| Error::FailedToStartOrStop("Task killer channel was closed.".to_string()))?;
 
-        let launcher = self.state.task.await.map_err(|e| Error::Error(e.to_string()))?;
+        let launcher = self.state.task.await.map_err(|e| Error::FailedToStartOrStop(e.to_string()))?;
 
         Ok(ApiServer {
             state: Stopped { launcher },
@@ -178,6 +192,7 @@ impl ApiServer<Running> {
 /// This function will return an error if unable to connect.
 /// Or if there request returns an error code.
 #[must_use]
+#[instrument(skip())]
 pub fn check_fn(binding: &SocketAddr) -> ServiceHealthCheckJob {
     let url = format!("http://{binding}/api/health_check"); // DevSkim: ignore DS137138
 
@@ -199,6 +214,16 @@ pub struct Launcher {
     tls: Option<RustlsConfig>,
 }
 
+impl std::fmt::Display for Launcher {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.tls.is_some() {
+            write!(f, "(with socket): {}, using TLS", self.bind_to,)
+        } else {
+            write!(f, "(with socket): {}, without TLS", self.bind_to,)
+        }
+    }
+}
+
 impl Launcher {
     /// Starts the API server with graceful shutdown.
     ///
@@ -210,6 +235,7 @@ impl Launcher {
     ///
     /// Will panic if unable to bind to the socket, or unable to get the address of the bound socket.
     /// Will also panic if unable to send message regarding the bound socket address.
+    #[instrument(skip(self, tracker, access_tokens, tx_start, rx_halt))]
     pub fn start(
         &self,
         tracker: Arc<Tracker>,

src/servers/health_check_api/handlers.rs

@@ -2,6 +2,7 @@ use std::collections::VecDeque;
 
 use axum::extract::State;
 use axum::Json;
+use tracing::{instrument, Level};
 
 use super::resources::{CheckReport, Report};
 use super::responses;
@@ -11,6 +12,7 @@ use crate::servers::registar::{ServiceHealthCheckJob, ServiceRegistration, Servi
 ///
 /// Creates a vector [`CheckReport`] from the input set of [`CheckJob`], and then builds a report from the results.
 ///
+#[instrument(skip(register), ret(level = Level::DEBUG))]
 pub(crate) async fn health_check_handler(State(register): State<ServiceRegistry>) -> Json<Report> {
     #[allow(unused_assignments)]
     let mut checks: VecDeque<ServiceHealthCheckJob> = VecDeque::new();

src/servers/health_check_api/server.rs

@@ -18,7 +18,7 @@ use tower_http::compression::CompressionLayer;
 use tower_http::propagate_header::PropagateHeaderLayer;
 use tower_http::request_id::{MakeRequestUuid, SetRequestIdLayer};
 use tower_http::trace::{DefaultMakeSpan, TraceLayer};
-use tracing::{Level, Span};
+use tracing::{instrument, Level, Span};
 
 use crate::bootstrap::jobs::Started;
 use crate::servers::health_check_api::handlers::health_check_handler;
@@ -31,6 +31,7 @@ use crate::servers::signals::{graceful_shutdown, Halted};
 /// # Panics
 ///
 /// Will panic if binding to the socket address fails.
+#[instrument(skip(bind_to, tx, rx_halt, register))]
 pub fn start(
     bind_to: SocketAddr,
     tx: Sender<Started>,

src/servers/http/server.rs

@@ -7,6 +7,7 @@ use axum_server::Handle;
 use derive_more::Constructor;
 use futures::future::BoxFuture;
 use tokio::sync::oneshot::{Receiver, Sender};
+use tracing::instrument;
 
 use super::v1::routes::router;
 use crate::bootstrap::jobs::Started;
@@ -41,6 +42,7 @@ pub struct Launcher {
 }
 
 impl Launcher {
+    #[instrument(skip(self, tracker, tx_start, rx_halt))]
     fn start(&self, tracker: Arc<Tracker>, tx_start: Sender<Started>, rx_halt: Receiver<Halted>) -> BoxFuture<'static, ()> {
         let socket = std::net::TcpListener::bind(self.bind_to).expect("Could not bind tcp_listener to address.");
         let address = socket.local_addr().expect("Could not get local_addr from tcp_listener.");

src/servers/http/v1/routes.rs

@@ -17,7 +17,7 @@ use tower_http::compression::CompressionLayer;
 use tower_http::propagate_header::PropagateHeaderLayer;
 use tower_http::request_id::{MakeRequestUuid, SetRequestIdLayer};
 use tower_http::trace::{DefaultMakeSpan, TraceLayer};
-use tracing::{Level, Span};
+use tracing::{instrument, Level, Span};
 
 use super::handlers::{announce, health_check, scrape};
 use crate::core::Tracker;
@@ -28,6 +28,7 @@ use crate::servers::http::HTTP_TRACKER_LOG_TARGET;
 /// > **NOTICE**: it's added a layer to get the client IP from the connection
 /// > info. The tracker could use the connection info to get the client IP.
 #[allow(clippy::needless_pass_by_value)]
+#[instrument(skip(tracker, server_socket_addr))]
 pub fn router(tracker: Arc<Tracker>, server_socket_addr: SocketAddr) -> Router {
     Router::new()
         // Health check