feat: logging for DNS resolver (also fixes #1417) (#1436)

* feat: logging for dns resolver

* refactor: fix clippy warnings

* refactor: actually fix clippy warnings

* refactor: apply requested changes

crates/binstalk-downloader/src/remote/resolver.rs

@@ -3,10 +3,13 @@ use std::{net::SocketAddr, sync::Arc};
 use hyper::client::connect::dns::Name;
 use once_cell::sync::OnceCell;
 use reqwest::dns::{Addrs, Resolve};
+use tracing::{debug, info, instrument, trace, warn};
 #[cfg(windows)]
 use trust_dns_resolver::config::{NameServerConfig, Protocol, ResolverConfig, ResolverOpts};
 use trust_dns_resolver::TokioAsyncResolver;
 
+type BoxError = Box<dyn std::error::Error + Send + Sync>;
+
 #[derive(Debug, Default, Clone)]
 pub struct TrustDnsResolver(Arc<OnceCell<TokioAsyncResolver>>);
 
@@ -23,42 +26,59 @@ impl Resolve for TrustDnsResolver {
     }
 }
 
-fn new_resolver() -> Result<TokioAsyncResolver, Box<dyn std::error::Error + Send + Sync>> {
+#[instrument(level = "trace")]
+fn new_resolver() -> Result<TokioAsyncResolver, BoxError> {
     #[cfg(unix)]
     {
+        info!("Using system DNS resolver configuration");
         Ok(TokioAsyncResolver::tokio_from_system_conf()?)
     }
     #[cfg(windows)]
     {
+        info!("Using custom DNS resolver configuration");
         let mut config = ResolverConfig::new();
         let opts = ResolverOpts::default();
 
-        let current_interface = default_net::get_default_interface()?;
-        ipconfig::get_adapters()?
-            .iter()
-            .filter_map(|adapter| {
-                if adapter.adapter_name() == current_interface.name {
-                    Some(adapter.dns_servers())
-                } else {
-                    None
-                }
-            })
-            .flatten()
-            .for_each(|addr| {
-                let socket_addr = SocketAddr::new(*addr, 53);
-                for protocol in [Protocol::Udp, Protocol::Tcp] {
-                    config.add_name_server(NameServerConfig {
-                        socket_addr,
-                        protocol,
-                        tls_dns_name: None,
-                        trust_negative_responses: false,
-                        #[cfg(feature = "rustls")]
-                        tls_config: None,
-                        bind_addr: None,
-                    })
-                }
-            });
+        get_adapter()?.dns_servers().iter().for_each(|addr| {
+            trace!("Adding DNS server: {}", addr);
+            let socket_addr = SocketAddr::new(*addr, 53);
+            for protocol in [Protocol::Udp, Protocol::Tcp] {
+                config.add_name_server(NameServerConfig {
+                    socket_addr,
+                    protocol,
+                    tls_dns_name: None,
+                    trust_negative_responses: false,
+                    #[cfg(feature = "rustls")]
+                    tls_config: None,
+                    bind_addr: None,
+                })
+            }
+        });
 
+        debug!("Resolver configuration complete");
         Ok(TokioAsyncResolver::tokio(config, opts))
     }
 }
+
+#[cfg(windows)]
+#[instrument(level = "trace")]
+fn get_adapter() -> Result<ipconfig::Adapter, BoxError> {
+    debug!("Retrieving local IP address");
+    let local_ip =
+        default_net::interface::get_local_ipaddr().ok_or("Local IP address not found")?;
+    debug!("Local IP address: {local_ip}");
+    debug!("Retrieving network adapters");
+    let adapters = ipconfig::get_adapters()?;
+    debug!("Found {} network adapters", adapters.len());
+    debug!("Searching for adapter with IP address {local_ip}");
+    let adapter = adapters
+        .into_iter()
+        .find(|adapter| adapter.ip_addresses().contains(&local_ip))
+        .ok_or("Adapter not found")?;
+    debug!(
+        "Using adapter {} with {} DNS servers",
+        adapter.friendly_name(),
+        adapter.dns_servers().len()
+    );
+    Ok(adapter)
+}