Merge pull request dmnd-pool#83 from jbesraa/2025-06-18/improve-logs

Improve logs across codebase

Author: jbesraa

src/config.rs

@@ -5,7 +5,7 @@ use std::{
     net::{SocketAddr, ToSocketAddrs},
     path::PathBuf,
 };
-use tracing::{error, info, warn};
+use tracing::{debug, error, info, warn};
 
 use crate::{HashUnit, DEFAULT_SV1_HASHPOWER};
 lazy_static! {
@@ -190,6 +190,7 @@ impl Configuration {
             .token
             .or(config.token)
             .or_else(|| std::env::var("TOKEN").ok());
+        debug!("User Token: {:?}", token);
 
         let tp_address = args
             .tp_address

src/ingress/sv1_ingress.rs

@@ -18,13 +18,20 @@ use tracing::{error, info, warn};
 pub fn start_listen_for_downstream(
     downstreams: Sender<(Sender<String>, Receiver<String>, IpAddr)>,
 ) -> AbortOnDrop {
-    info!("Starting downstream listner");
     tokio::task::spawn(async move {
         let down_addr: String = crate::SV1_DOWN_LISTEN_ADDR.to_string();
         let downstream_addr: SocketAddr = down_addr.parse().expect("Invalid listen address");
+        info!(
+            "Trying to bind to address {} for downstream(miner) connections",
+            downstream_addr
+        );
         let downstream_listener = TcpListener::bind(downstream_addr)
             .await
             .expect("impossible to bind downstream");
+        info!(
+            "Listening for downstream connections on {:?}",
+            downstream_addr
+        );
         while let Ok((stream, addr)) = downstream_listener.accept().await {
             info!("Try to connect {:#?}", addr);
             Downstream::initialize(

src/jd_client/task_manager.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use crate::shared::utils::AbortOnDrop;
 use roles_logic_sv2::utils::Mutex;
 use tokio::sync::mpsc;
-use tracing::warn;
+use tracing::debug;
 
 #[derive(Debug)]
 #[allow(dead_code)]
@@ -29,11 +29,11 @@ impl TaskManager {
             while let Some(task) = receiver.recv().await {
                 tasks.push(task);
             }
-            warn!("Share accounter main task manager stopped, keep alive tasks");
             loop {
                 tokio::time::sleep(std::time::Duration::from_secs(1000)).await;
             }
         });
+        debug!("Share Accounter Task Manager initialized");
         Arc::new(Mutex::new(Self {
             send_task: sender,
             abort: Some(handle.into()),

src/main.rs

@@ -88,7 +88,7 @@ async fn main() {
     }
 
     if Configuration::test() {
-        info!("Connecting to test endpoint...");
+        info!("Package is running in test mode");
     }
 
     let auth_pub_k: Secp256k1PublicKey = AUTH_PUB_KEY.parse().expect("Invalid public key");
@@ -117,21 +117,18 @@ async fn initialize_proxy(
     epsilon: Duration,
 ) {
     loop {
-        // Initial setup for the proxy
         let stats_sender = api::stats::StatsSender::new();
-
         let (send_to_pool, recv_from_pool, pool_connection_abortable) =
             match router.connect_pool(pool_addr).await {
                 Ok(connection) => connection,
                 Err(_) => {
-                    error!("No upstream available. Retrying...");
-                    warn!("Are you using the correct TOKEN??");
-                    let mut secs = 10;
-                    while secs > 0 {
-                        tracing::warn!("Retrying in {} seconds...", secs);
-                        tokio::time::sleep(Duration::from_secs(1)).await;
-                        secs -= 1;
-                    }
+                    error!("No upstream available. Retrying in 5 seconds...");
+                    warn!(
+                        "Please make sure the your token {} is correct",
+                        Configuration::token().expect("Token is not set")
+                    );
+                    let secs = 5;
+                    tokio::time::sleep(Duration::from_secs(secs)).await;
                     // Restart loop, esentially restarting proxy
                     continue;
                 }
@@ -347,7 +344,7 @@ fn check_update_proxy() {
     match updater.update_extended() {
         Ok(status) => match status {
             UpdateStatus::UpToDate => {
-                info!("Starting latest version of DMND-PROXY.");
+                info!("Package is up to date");
             }
             UpdateStatus::Updated(release) => {
                 info!(

src/minin_pool_connection/mod.rs

@@ -44,7 +44,10 @@ pub async fn connect_pool(
 > {
     let socket = loop {
         match TcpStream::connect(address).await {
-            Ok(socket) => break socket,
+            Ok(socket) => {
+                info!("Socket initialized with Pool at {}", address);
+                break socket;
+            }
             Err(e) => {
                 error!(
                     "Failed to connect to Upstream role at {}, retrying in 5s: {}",
@@ -55,14 +58,9 @@ pub async fn connect_pool(
         }
     };
 
+    info!("Performing SV2 Handshake with Pool at {}", address);
     let initiator =
         Initiator::from_raw_k(authority_public_key.into_bytes()).expect("Invalid authority key");
-
-    info!(
-        "PROXY SERVER - ACCEPTING FROM UPSTREAM: {}",
-        socket.peer_addr().expect("Failed to get peer address")
-    );
-
     // Channel to send and receive messages to the SV2 Upstream role
     let (mut receiver, mut sender, _, _) =
         Connection::new(socket, HandshakeRole::Initiator(initiator))
@@ -71,6 +69,8 @@ pub async fn connect_pool(
                 error!("Failed to create connection");
                 Error::SV2Connection(e)
             })?;
+    info!("SV2 Handshake with Pool at {} completed", address);
+    info!("Sending SetupConnection message to Pool at {}", address);
     let setup_connection_msg =
         setup_connection_msg.unwrap_or(get_mining_setup_connection_msg(true));
     match mining_setup_connection(

src/minin_pool_connection/task_manager.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use crate::shared::utils::AbortOnDrop;
 use roles_logic_sv2::utils::Mutex;
 use tokio::sync::mpsc;
-use tracing::warn;
+use tracing::debug;
 
 #[derive(Debug)]
 #[allow(dead_code)]
@@ -25,11 +25,11 @@ impl TaskManager {
             while let Some(task) = receiver.recv().await {
                 tasks.push(task);
             }
-            warn!("Ingress task manager stopped, keep alive tasks");
             loop {
                 tokio::time::sleep(std::time::Duration::from_secs(1000)).await;
             }
         });
+        debug!("Mining Pool Task Manager initialized");
         Arc::new(Mutex::new(Self {
             send_task: sender,
             abort: Some(handle.into()),

src/router/mod.rs

@@ -79,13 +79,23 @@ impl Router {
 
     /// Select the best pool for connection
     pub async fn select_pool_connect(&self) -> Option<SocketAddr> {
-        info!("Selecting the best upstream ");
+        info!("Selecting best Pool for connection");
+        if self.pool_addresses.is_empty() {
+            error!("No pool addresses provided");
+            return None;
+        }
+        if self.pool_addresses.len() == 1 {
+            info!(
+                "Only one pool address available, using: {:?}",
+                self.pool_addresses[0]
+            );
+            return Some(self.pool_addresses[0]);
+        }
         if let Some((pool, latency)) = self.select_pool().await {
-            info!("Latency for upstream {:?} is {:?}", pool, latency);
+            info!("Latency for Pool {:?} is {:?}", pool, latency);
             self.latency_tx.send_replace(Some(latency)); // update latency
             Some(pool)
         } else {
-            //info!("No available pool");
             None
         }
     }
@@ -147,7 +157,7 @@ impl Router {
         };
         self.current_pool = Some(pool);
 
-        info!("Upstream {:?} selected", pool);
+        info!("Trying to connect to Pool {:?}", pool);
 
         match minin_pool_connection::connect_pool(
             pool,
@@ -166,6 +176,10 @@ impl Router {
                         error!("Pool address Mutex corrupt");
                         crate::proxy_state::ProxyState::update_inconsistency(Some(1));
                     });
+                info!(
+                    "Completed Handshake And SetupConnection with Pool at {:?}",
+                    pool
+                );
 
                 Ok((send_to_pool, recv_from_pool, pool_connection_abortable))
             }

src/translator/downstream/accept_connection.rs

@@ -14,7 +14,7 @@ use tokio::sync::{
     mpsc::{Receiver, Sender},
 };
 use tokio::task;
-use tracing::{error, info};
+use tracing::{debug, error, info};
 
 pub async fn start_accept_connection(
     task_manager: Arc<Mutex<TaskManager>>,
@@ -33,23 +33,42 @@ pub async fn start_accept_connection(
             let _s = tx_mining_notify.subscribe();
             while let Some((send, recv, addr)) = downstreams.recv().await {
                 info!("Translator opening connection for ip {}", addr);
-
                 // The initial difficulty is derived from the formula: difficulty = hash_rate / (shares_per_second * 2^32)
                 let initial_hash_rate = *crate::EXPECTED_SV1_HASHPOWER;
+                info!(
+                    "Translator initial hash rate for ip {} is {} H/s",
+                    addr, initial_hash_rate
+                );
                 let share_per_second = crate::SHARE_PER_MIN / 60.0;
-                let initial_difficulty =
-                    dbg!(initial_hash_rate / (share_per_second * 2f32.powf(32.0)));
+                info!(
+                    "Translator share per second for ip {} is {} shares/s",
+                    addr, share_per_second
+                );
+                let initial_difficulty = initial_hash_rate / (share_per_second * 2f32.powf(32.0));
                 let initial_difficulty =
                     crate::translator::downstream::diff_management::nearest_power_of_10(
                         initial_difficulty,
                     );
-
+                info!(
+                    "Translator initial difficulty for ip {} is {}",
+                    addr, initial_difficulty
+                );
                 // Formula: expected_hash_rate = (shares_per_second) * initial_difficulty * 2^32, where shares_per_second = SHARE_PER_MIN / 60
                 let expected_hash_rate =
                     (crate::SHARE_PER_MIN / 60.0) * initial_difficulty * 2f32.powf(32.0);
-                if Bridge::ready(&bridge).await.is_err() {
-                    error!("Bridge not ready");
-                    break;
+                info!(
+                    "Translator expected hash rate for ip {} is {} H/s",
+                    addr, expected_hash_rate
+                );
+
+                match Bridge::ready(&bridge).await {
+                    Ok(_) => {
+                        debug!("Bridge is ready, proceeding with connection");
+                    }
+                    Err(_) => {
+                        error!("Bridge not ready");
+                        break;
+                    }
                 };
                 let open_sv1_downstream =
                     match bridge.safe_lock(|s| s.on_new_sv1_connection(expected_hash_rate)) {

src/translator/downstream/downstream.rs

@@ -434,7 +434,7 @@ impl IsServer<'static> for Downstream {
     /// Only [Submit](client_to_server::Submit) requests for authorized user names can be submitted.
     fn handle_submit(&self, request: &client_to_server::Submit<'static>) -> bool {
         info!(
-            "Downstream {}: Handling mining.submit for job_id {}",
+            "Handling mining.submit for for downstream with connection id {} and job_id {}",
             self.connection_id, request.job_id
         );