Always use logging macros prefixed with log::

4 files changed, 36 insertions, 40 deletions

diff --git a/talpid-core/src/dns/macos.rs b/talpid-core/src/dns/macos.rs
index 393de23dd9..b3d2a5280f 100644
--- a/talpid-core/src/dns/macos.rs
+++ b/talpid-core/src/dns/macos.rs
@@ -1,6 +1,5 @@
 use crate::tunnel_state_machine::TunnelCommand;
 use futures::channel::mpsc;
-use log::{debug, trace};
 use parking_lot::Mutex;
 use std::{
     collections::HashMap,
@@ -132,7 +131,7 @@ impl DnsSettings {
         store: &SCDynamicStore,
         path: S,
     ) -> Result<()> {
-        trace!(
+        log::trace!(
             "Setting DNS to [{}] for {}",
             self.server_addresses().join(", "),
             path.to_string()
@@ -256,7 +255,7 @@ impl super::DnsMonitorT for DnsMonitor {
         *state_lock = Some(match state_lock.take() {
             None => {
                 let backup = read_all_dns(&self.store);
-                trace!("Backup of DNS settings: {:#?}", backup);
+                log::trace!("Backup of DNS settings: {:#?}", backup);
                 for service_path in backup.keys() {
                     settings.save(&self.store, service_path.as_str())?;
                 }
@@ -277,7 +276,7 @@ impl super::DnsMonitorT for DnsMonitor {
                         tunnel_tx: self.tunnel_tx.clone(),
                     }
                 } else {
-                    debug!("No change, new DNS same as the one already set");
+                    log::debug!("No change, new DNS same as the one already set");
                     state
                 }
             }
@@ -288,12 +287,12 @@ impl super::DnsMonitorT for DnsMonitor {
     fn reset(&mut self) -> Result<()> {
         let mut state_lock = self.state.lock();
         if let Some(state) = state_lock.take() {
-            trace!("Restoring DNS settings to: {:#?}", state.backup);
+            log::trace!("Restoring DNS settings to: {:#?}", state.backup);
             for (service_path, settings) in state.backup {
                 if let Some(settings) = settings {
                     settings.save(&self.store, service_path.as_str())?;
                 } else {
-                    debug!("Removing DNS for {}", service_path);
+                    log::debug!("Removing DNS for {}", service_path);
                     if !self.store.remove(CFString::new(&service_path)) {
                         return Err(Error::SettingDnsFailed);
                     }
@@ -368,7 +367,7 @@ fn create_dynamic_store(state: Arc<Mutex<Option<State>>>) -> Result<SCDynamicSto
     ]);
 
     if store.set_notification_keys(&watch_keys, &watch_patterns) {
-        trace!("Registered for dynamic store notifications");
+        log::trace!("Registered for dynamic store notifications");
         Ok(store)
     } else {
         Err(Error::DynamicStoreInitError)
@@ -379,7 +378,7 @@ fn run_dynamic_store_runloop(store: SCDynamicStore) {
     let run_loop_source = store.create_run_loop_source();
     CFRunLoop::get_current().add_source(&run_loop_source, unsafe { kCFRunLoopCommonModes });
 
-    trace!("Entering DNS CFRunLoop");
+    log::trace!("Entering DNS CFRunLoop");
     CFRunLoop::run_current();
 }
 
@@ -393,7 +392,7 @@ fn dns_change_callback(
     let mut state_lock = state.lock();
     match *state_lock {
         None => {
-            trace!("Not injecting DNS at this time");
+            log::trace!("Not injecting DNS at this time");
         }
         Some(ref mut state) => {
             dns_change_callback_internal(store, changed_keys, state);
@@ -410,17 +409,17 @@ fn dns_change_callback_internal(
     for path in &changed_keys {
         let should_set_dns = match DnsSettings::load(&store, path.clone()).ok() {
             None => {
-                debug!("Detected DNS removed for {}", *path);
+                log::debug!("Detected DNS removed for {}", *path);
                 state.backup.insert(path.to_string(), None);
                 true
             }
             Some(new_settings) => {
                 if new_settings.dict != state.dns_settings.dict {
-                    debug!("Detected DNS change for {}", *path);
+                    log::debug!("Detected DNS change for {}", *path);
                     state.backup.insert(path.to_string(), Some(new_settings));
                     true
                 } else {
-                    trace!("Ignoring DNS change since it's equal to desired DNS");
+                    log::trace!("Ignoring DNS change since it's equal to desired DNS");
                     false
                 }
             }
diff --git a/talpid-core/src/dns/windows/mod.rs b/talpid-core/src/dns/windows/mod.rs
index bdfae85fc2..5ee5e56049 100644
--- a/talpid-core/src/dns/windows/mod.rs
+++ b/talpid-core/src/dns/windows/mod.rs
@@ -4,7 +4,6 @@ use crate::{
 };
 
 use lazy_static::lazy_static;
-use log::{error, trace, warn};
 use std::{env, io, net::IpAddr, path::Path};
 use talpid_types::ErrorExt;
 use widestring::WideCString;
@@ -84,8 +83,8 @@ impl super::DnsMonitorT for DnsMonitor {
             .map(|ip_cstr| ip_cstr.as_ptr())
             .collect::<Vec<_>>();
 
-        trace!("ipv4 ips - {:?} - {}", ipv4, ipv4.len());
-        trace!("ipv6 ips - {:?} - {}", ipv6, ipv6.len());
+        log::trace!("ipv4 ips - {:?} - {}", ipv4, ipv4.len());
+        log::trace!("ipv6 ips - {:?} - {}", ipv6, ipv6.len());
 
         let luid = luid_from_alias(interface).map_err(Error::InterfaceLuidError)?;
 
@@ -102,8 +101,8 @@ impl super::DnsMonitorT for DnsMonitor {
 
         if *GLOBAL_DNS_CACHE_POLICY && is_minimum_windows10() {
             if let Err(error) = set_dns_cache_policy(servers) {
-                error!("{}", error.display_chain());
-                warn!("DNS resolution may be slowed down");
+                log::error!("{}", error.display_chain());
+                log::warn!("DNS resolution may be slowed down");
             }
         }
 
@@ -127,7 +126,7 @@ impl Drop for DnsMonitor {
     fn drop(&mut self) {
         if *GLOBAL_DNS_CACHE_POLICY && is_minimum_windows10() {
             if let Err(error) = reset_dns_cache_policy() {
-                warn!(
+                log::warn!(
                     "{}",
                     error.display_chain_with_msg("Failed to reset DNS cache policy")
                 );
@@ -135,9 +134,9 @@ impl Drop for DnsMonitor {
         }
 
         if unsafe { WinDns_Deinitialize().into_result().is_ok() } {
-            trace!("Successfully deinitialized WinDns");
+            log::trace!("Successfully deinitialized WinDns");
         } else {
-            error!("Failed to deinitialize WinDns");
+            log::error!("Failed to deinitialize WinDns");
         }
     }
 }
@@ -213,7 +212,7 @@ fn is_minimum_windows10() -> bool {
     match talpid_platform_metadata::WindowsVersion::new() {
         Ok(version_info) => version_info.major_version() >= 10,
         Err(error) => {
-            error!(
+            log::error!(
                 "{}",
                 error.display_chain_with_msg("OS version check failed")
             );
diff --git a/talpid-core/src/firewall/windows.rs b/talpid-core/src/firewall/windows.rs
index 26f773eff4..81640038b6 100644
--- a/talpid-core/src/firewall/windows.rs
+++ b/talpid-core/src/firewall/windows.rs
@@ -5,7 +5,6 @@ use std::{net::IpAddr, path::Path, ptr};
 use self::winfw::*;
 use super::{FirewallArguments, FirewallPolicy, FirewallT, InitialFirewallState};
 use crate::winnet;
-use log::{debug, error, trace};
 use talpid_types::{
     net::{AllowedEndpoint, Endpoint},
     tunnel::FirewallPolicyError,
@@ -77,7 +76,7 @@ impl FirewallT for Firewall {
             };
         }
 
-        trace!("Successfully initialized windows firewall module");
+        log::trace!("Successfully initialized windows firewall module");
         Ok(Firewall(()))
     }
 
@@ -136,9 +135,9 @@ impl Drop for Firewall {
                 .into_result()
                 .is_ok()
         } {
-            trace!("Successfully deinitialized windows firewall module");
+            log::trace!("Successfully deinitialized windows firewall module");
         } else {
-            error!("Failed to deinitialize windows firewall module");
+            log::error!("Failed to deinitialize windows firewall module");
         };
     }
 }
@@ -152,7 +151,7 @@ impl Firewall {
         allowed_endpoint: &WinFwAllowedEndpoint<'_>,
         relay_client: &Path,
     ) -> Result<(), Error> {
-        trace!("Applying 'connecting' firewall policy");
+        log::trace!("Applying 'connecting' firewall policy");
         let ip_str = widestring_ip(endpoint.address.ip());
         let winfw_relay = WinFwEndpoint {
             ip: ip_str.as_ptr(),
@@ -192,7 +191,7 @@ impl Firewall {
         dns_servers: &[IpAddr],
         relay_client: &Path,
     ) -> Result<(), Error> {
-        trace!("Applying 'connected' firewall policy");
+        log::trace!("Applying 'connected' firewall policy");
         let ip_str = widestring_ip(endpoint.address.ip());
         let v4_gateway = widestring_ip(tunnel_metadata.ipv4_gateway.into());
         let v6_gateway = tunnel_metadata
@@ -212,9 +211,9 @@ impl Firewall {
             .map_err(Error::SetTunMetric)?;
 
         if metrics_set {
-            debug!("Network interface metrics were changed");
+            log::debug!("Network interface metrics were changed");
         } else {
-            debug!("Network interface metrics were not changed");
+            log::debug!("Network interface metrics were not changed");
         }
 
         let v6_gateway_ptr = match &v6_gateway {
@@ -249,7 +248,7 @@ impl Firewall {
         winfw_settings: &WinFwSettings,
         allowed_endpoint: &WinFwAllowedEndpoint<'_>,
     ) -> Result<(), Error> {
-        trace!("Applying 'blocked' firewall policy");
+        log::trace!("Applying 'blocked' firewall policy");
         unsafe {
             WinFw_ApplyPolicyBlocked(winfw_settings, allowed_endpoint)
                 .into_result()
diff --git a/talpid-core/src/tunnel_state_machine/connecting_state.rs b/talpid-core/src/tunnel_state_machine/connecting_state.rs
index 8b4c9f5855..74b6d116b5 100644
--- a/talpid-core/src/tunnel_state_machine/connecting_state.rs
+++ b/talpid-core/src/tunnel_state_machine/connecting_state.rs
@@ -16,7 +16,6 @@ use futures::{
     future::Fuse,
     FutureExt, StreamExt,
 };
-use log::{debug, error, info, trace, warn};
 use std::{
     path::{Path, PathBuf},
     thread,
@@ -77,7 +76,7 @@ impl ConnectingState {
             .firewall
             .apply_policy(policy)
             .map_err(|error| {
-                error!(
+                log::error!(
                     "{}",
                     error.display_chain_with_msg(
                         "Failed to apply firewall policy for connecting state"
@@ -145,7 +144,7 @@ impl ConnectingState {
 
             let block_reason = if let Some(monitor) = tunnel_monitor {
                 let reason = Self::wait_for_tunnel_monitor(monitor, retry_attempt);
-                debug!("Tunnel monitor exited with block reason: {:?}", reason);
+                log::debug!("Tunnel monitor exited with block reason: {:?}", reason);
                 reason
             } else {
                 None
@@ -158,10 +157,10 @@ impl ConnectingState {
             }
 
             if tunnel_close_event_tx.send(block_reason).is_err() {
-                warn!("Tunnel state machine stopped before receiving tunnel closed event");
+                log::warn!("Tunnel state machine stopped before receiving tunnel closed event");
             }
 
-            trace!("Tunnel monitor thread exit");
+            log::trace!("Tunnel monitor thread exit");
         });
 
         tunnel_close_event_rx.fuse()
@@ -183,14 +182,14 @@ impl ConnectingState {
                 error @ tunnel::Error::WireguardTunnelMonitoringError(..)
                     if !should_retry(&error, retry_attempt) =>
                 {
-                    error!(
+                    log::error!(
                         "{}",
                         error.display_chain_with_msg("Tunnel has stopped unexpectedly")
                     );
                     Some(ErrorStateCause::StartTunnelError)
                 }
                 error => {
-                    warn!(
+                    log::warn!(
                         "{}",
                         error.display_chain_with_msg("Tunnel has stopped unexpectedly")
                     );
@@ -402,7 +401,7 @@ impl ConnectingState {
             Some((TunnelEvent::Down, _)) => SameState(self.into()),
             None => {
                 // The channel was closed
-                debug!("The tunnel disconnected unexpectedly");
+                log::debug!("The tunnel disconnected unexpectedly");
                 let retry_attempt = self.retry_attempt + 1;
                 self.disconnect(shared_values, AfterDisconnect::Reconnect(retry_attempt))
             }
@@ -421,7 +420,7 @@ impl ConnectingState {
             return NewState(ErrorState::enter(shared_values, block_reason));
         }
 
-        info!(
+        log::info!(
             "Tunnel closed. Reconnecting, attempt {}.",
             self.retry_attempt + 1
         );
@@ -533,7 +532,7 @@ impl TunnelState for ConnectingState {
                     {
                         if retry_attempt > 0 && retry_attempt % MAX_ATTEMPTS_WITH_SAME_TUN == 0 {
                             if let Err(error) = shared_values.tun_provider.create_tun() {
-                                error!(
+                                log::error!(
                                     "{}",
                                     error.display_chain_with_msg("Failed to recreate tun device")
                                 );