Always use logging macros prefixed with log::

10 files changed, 103 insertions, 109 deletions

diff --git a/mullvad-daemon/src/cli.rs b/mullvad-daemon/src/cli.rs
index 95e466c65e..f3b1436187 100644
--- a/mullvad-daemon/src/cli.rs
+++ b/mullvad-daemon/src/cli.rs
@@ -1,5 +1,4 @@
 use clap::{crate_authors, crate_description, crate_name, App, Arg};
-use log;
 
 use crate::version;
 
diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index 58fa2469d4..dbf1b26025 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -29,7 +29,6 @@ use futures::{
     future::{abortable, AbortHandle, Future},
     StreamExt,
 };
-use log::{debug, error, info, warn};
 use mullvad_rpc::availability::ApiAvailabilityHandle;
 use mullvad_types::{
     account::{AccountData, AccountToken, VoucherSubmission},
@@ -602,7 +601,7 @@ where
                     .map_err(Error::ReadCachedTargetState),
                 Err(e) => {
                     if e.kind() == io::ErrorKind::NotFound {
-                        debug!("No cached target state to load");
+                        log::debug!("No cached target state to load");
                         Ok(None)
                     } else {
                         Err(Error::OpenCachedTargetState(e))
@@ -610,11 +609,11 @@ where
                 }
             }
             .unwrap_or_else(|error| {
-                error!("{}", error.display_chain());
+                log::error!("{}", error.display_chain());
                 Some(TargetState::Secured)
             });
         if let Some(cached_target_state) = &cached_target_state {
-            info!(
+            log::info!(
                 "Loaded cached target state \"{}\" from {}",
                 cached_target_state,
                 target_cache.display()
@@ -628,7 +627,7 @@ where
         let initial_target_state = if settings.get_account_token().is_some() {
             if settings.auto_connect {
                 // Note: Auto-connect overrides the cached target state
-                info!("Automatically connecting since auto-connect is turned on");
+                log::info!("Automatically connecting since auto-connect is turned on");
                 TargetState::Secured
             } else {
                 cached_target_state.unwrap_or(TargetState::Unsecured)
@@ -901,7 +900,7 @@ where
         if !lock_target_cache {
             let target_cache = cache_dir.join(TARGET_START_STATE_FILE);
             let _ = fs::remove_file(target_cache).await.map_err(|e| {
-                error!("Cannot delete target tunnel state cache: {}", e);
+                log::error!("Cannot delete target tunnel state cache: {}", e);
             });
         }
     }
@@ -985,17 +984,17 @@ where
 
         self.unschedule_reconnect();
 
-        debug!("New tunnel state: {:?}", tunnel_state);
+        log::debug!("New tunnel state: {:?}", tunnel_state);
         match tunnel_state {
             TunnelState::Disconnected => self.state.disconnected(),
             TunnelState::Error(ref error_state) => {
                 if error_state.is_blocking() {
-                    info!(
+                    log::info!(
                         "Blocking all network connections, reason: {}",
                         error_state.cause()
                     );
                 } else {
-                    error!(
+                    log::error!(
                         "FAILED TO BLOCK NETWORK CONNECTIONS, ENTERED ERROR STATE BECAUSE: {}",
                         error_state.cause()
                     );
@@ -1093,7 +1092,7 @@ where
                 log::error!("Failed to send tunnel parameters");
             }
         } else {
-            error!("No account token configured");
+            log::error!("No account token configured");
         }
     }
 
@@ -1440,7 +1439,7 @@ where
             let state_change_initated = self.set_target_state(new_target_state).await;
             Self::oneshot_send(tx, state_change_initated, "state change initiated");
         } else {
-            warn!("Ignoring target state change request due to shutdown");
+            log::warn!("Ignoring target state change request due to shutdown");
         }
     }
 
@@ -1449,7 +1448,7 @@ where
             self.connect_tunnel();
             Self::oneshot_send(tx, true, "reconnect issued");
         } else {
-            debug!("Ignoring reconnect command. Currently not in secured state");
+            log::debug!("Ignoring reconnect command. Currently not in secured state");
             Self::oneshot_send(tx, false, "reconnect issued");
         }
     }
@@ -1503,7 +1502,7 @@ where
             geoip::send_location_request(rpc_service)
                 .await
                 .map_err(|e| {
-                    warn!("Unable to fetch GeoIP location: {}", e.display_chain());
+                    log::warn!("Unable to fetch GeoIP location: {}", e.display_chain());
                 })
         }
     }
@@ -1626,11 +1625,13 @@ where
                 if account_changed {
                     match account_token {
                         Some(_) => {
-                            info!("Initiating tunnel restart because the account token changed");
+                            log::info!(
+                                "Initiating tunnel restart because the account token changed"
+                            );
                             self.reconnect_tunnel();
                         }
                         None => {
-                            info!("Disconnecting because account token was cleared");
+                            log::info!("Disconnecting because account token was cleared");
                             self.set_target_state(TargetState::Unsecured).await;
                         }
                     };
@@ -1840,7 +1841,7 @@ where
     #[cfg(target_os = "linux")]
     fn on_get_split_tunnel_processes(&mut self, tx: ResponseTx<Vec<i32>, split_tunnel::Error>) {
         let result = self.exclude_pids.list().map_err(|error| {
-            error!("{}", error.display_chain_with_msg("Unable to obtain PIDs"));
+            log::error!("{}", error.display_chain_with_msg("Unable to obtain PIDs"));
             error
         });
         Self::oneshot_send(tx, result, "get_split_tunnel_processes response");
@@ -1849,7 +1850,7 @@ where
     #[cfg(target_os = "linux")]
     fn on_add_split_tunnel_process(&mut self, tx: ResponseTx<(), split_tunnel::Error>, pid: i32) {
         let result = self.exclude_pids.add(pid).map_err(|error| {
-            error!("{}", error.display_chain_with_msg("Unable to add PID"));
+            log::error!("{}", error.display_chain_with_msg("Unable to add PID"));
             error
         });
         Self::oneshot_send(tx, result, "add_split_tunnel_process response");
@@ -1862,7 +1863,7 @@ where
         pid: i32,
     ) {
         let result = self.exclude_pids.remove(pid).map_err(|error| {
-            error!("{}", error.display_chain_with_msg("Unable to remove PID"));
+            log::error!("{}", error.display_chain_with_msg("Unable to remove PID"));
             error
         });
         Self::oneshot_send(tx, result, "remove_split_tunnel_process response");
@@ -1871,7 +1872,7 @@ where
     #[cfg(target_os = "linux")]
     fn on_clear_split_tunnel_processes(&mut self, tx: ResponseTx<(), split_tunnel::Error>) {
         let result = self.exclude_pids.clear().map_err(|error| {
-            error!("{}", error.display_chain_with_msg("Unable to clear PIDs"));
+            log::error!("{}", error.display_chain_with_msg("Unable to clear PIDs"));
             error
         });
         Self::oneshot_send(tx, result, "clear_split_tunnel_processes response");
@@ -2015,13 +2016,13 @@ where
                     self.event_listener
                         .notify_settings(self.settings.to_settings());
                     if let Some(TunnelType::Wireguard) = self.get_connected_tunnel_type() {
-                        info!("Initiating tunnel restart");
+                        log::info!("Initiating tunnel restart");
                         self.reconnect_tunnel();
                     }
                 }
             }
             Err(error) => {
-                error!(
+                log::error!(
                     "{}",
                     error.display_chain_with_msg("Unable to save settings")
                 );
@@ -2042,12 +2043,12 @@ where
                 if settings_changed {
                     self.event_listener
                         .notify_settings(self.settings.to_settings());
-                    info!("Initiating tunnel restart because the relay settings changed");
+                    log::info!("Initiating tunnel restart because the relay settings changed");
                     self.reconnect_tunnel();
                 }
             }
             Err(e) => {
-                error!("{}", e.display_chain_with_msg("Unable to save settings"));
+                log::error!("{}", e.display_chain_with_msg("Unable to save settings"));
                 Self::oneshot_send(tx, Err(e), "update_relay_settings response");
             }
         }
@@ -2065,7 +2066,7 @@ where
                 }
             }
             Err(e) => {
-                error!("{}", e.display_chain_with_msg("Unable to save settings"));
+                log::error!("{}", e.display_chain_with_msg("Unable to save settings"));
                 Self::oneshot_send(tx, Err(e), "set_allow_lan response");
             }
         }
@@ -2088,7 +2089,7 @@ where
                 }
             }
             Err(e) => {
-                error!("{}", e.display_chain_with_msg("Unable to save settings"));
+                log::error!("{}", e.display_chain_with_msg("Unable to save settings"));
                 Self::oneshot_send(tx, Err(e), "set_show_beta_releases response");
             }
         }
@@ -2115,7 +2116,7 @@ where
                 }
             }
             Err(e) => {
-                error!("{}", e.display_chain_with_msg("Unable to save settings"));
+                log::error!("{}", e.display_chain_with_msg("Unable to save settings"));
                 Self::oneshot_send(tx, Err(e), "set_block_when_disconnected response");
             }
         }
@@ -2136,7 +2137,7 @@ where
                 }
             }
             Err(e) => {
-                error!("{}", e.display_chain_with_msg("Unable to save settings"));
+                log::error!("{}", e.display_chain_with_msg("Unable to save settings"));
                 Self::oneshot_send(tx, Err(e), "set auto-connect response");
             }
         }
@@ -2155,7 +2156,7 @@ where
                     self.event_listener
                         .notify_settings(self.settings.to_settings());
                     if let Some(TunnelType::OpenVpn) = self.get_connected_tunnel_type() {
-                        info!(
+                        log::info!(
                             "Initiating tunnel restart because the OpenVPN mssfix setting changed"
                         );
                         self.reconnect_tunnel();
@@ -2163,7 +2164,7 @@ where
                 }
             }
             Err(e) => {
-                error!("{}", e.display_chain_with_msg("Unable to save settings"));
+                log::error!("{}", e.display_chain_with_msg("Unable to save settings"));
                 Self::oneshot_send(tx, Err(e), "set_openvpn_mssfix response");
             }
         }
@@ -2228,12 +2229,12 @@ where
                 if settings_changed {
                     self.event_listener
                         .notify_settings(self.settings.to_settings());
-                    info!("Initiating tunnel restart because the enable IPv6 setting changed");
+                    log::info!("Initiating tunnel restart because the enable IPv6 setting changed");
                     self.reconnect_tunnel();
                 }
             }
             Err(e) => {
-                error!("{}", e.display_chain_with_msg("Unable to save settings"));
+                log::error!("{}", e.display_chain_with_msg("Unable to save settings"));
                 Self::oneshot_send(tx, Err(e), "set_enable_ipv6 response");
             }
         }
@@ -2256,7 +2257,7 @@ where
                 }
             }
             Err(e) => {
-                error!("{}", e.display_chain_with_msg("Unable to save settings"));
+                log::error!("{}", e.display_chain_with_msg("Unable to save settings"));
                 Self::oneshot_send(tx, Err(e), "set_dns_options response");
             }
         }
@@ -2319,7 +2320,7 @@ where
                     self.event_listener
                         .notify_settings(self.settings.to_settings());
                     if let Some(TunnelType::Wireguard) = self.get_connected_tunnel_type() {
-                        info!(
+                        log::info!(
                             "Initiating tunnel restart because the WireGuard MTU setting changed"
                         );
                         self.reconnect_tunnel();
@@ -2327,7 +2328,7 @@ where
                 }
             }
             Err(e) => {
-                error!("{}", e.display_chain_with_msg("Unable to save settings"));
+                log::error!("{}", e.display_chain_with_msg("Unable to save settings"));
                 Self::oneshot_send(tx, Err(e), "set_wireguard_mtu response");
             }
         }
@@ -2352,7 +2353,7 @@ where
                 }
             }
             Err(e) => {
-                error!("{}", e.display_chain_with_msg("Unable to save settings"));
+                log::error!("{}", e.display_chain_with_msg("Unable to save settings"));
                 Self::oneshot_send(tx, Err(e), "set_wireguard_rotation_interval response");
             }
         }
@@ -2486,7 +2487,7 @@ where
 
     fn oneshot_send<T>(tx: oneshot::Sender<T>, t: T, msg: &'static str) {
         if tx.send(t).is_err() {
-            warn!("Unable to send {} to the daemon command sender", msg);
+            log::warn!("Unable to send {} to the daemon command sender", msg);
         }
     }
 
@@ -2555,7 +2556,7 @@ where
     /// Returns a bool representing whether or not a state change was initiated.
     async fn set_target_state(&mut self, new_state: TargetState) -> bool {
         if new_state != self.target_state || self.tunnel_state.is_in_error_state() {
-            debug!("Target state {:?} => {:?}", self.target_state, new_state);
+            log::debug!("Target state {:?} => {:?}", self.target_state, new_state);
 
             if new_state != self.target_state {
                 self.target_state = new_state;
diff --git a/mullvad-daemon/src/logging.rs b/mullvad-daemon/src/logging.rs
index 6c5aeb98d6..5eca9b638f 100644
--- a/mullvad-daemon/src/logging.rs
+++ b/mullvad-daemon/src/logging.rs
@@ -2,7 +2,6 @@ use fern::{
     colors::{Color, ColoredLevelConfig},
     Output,
 };
-use log;
 use std::{fmt, io, path::PathBuf};
 use talpid_core::logging::rotate_log;
 
diff --git a/mullvad-daemon/src/main.rs b/mullvad-daemon/src/main.rs
index b438e112cc..f11bb30d98 100644
--- a/mullvad-daemon/src/main.rs
+++ b/mullvad-daemon/src/main.rs
@@ -1,6 +1,5 @@
 #![deny(rust_2018_idioms)]
 
-use log::{debug, error, info, trace, warn};
 use mullvad_daemon::{
     logging,
     management_interface::{ManagementInterfaceEventBroadcaster, ManagementInterfaceServer},
@@ -26,7 +25,7 @@ fn main() {
         std::process::exit(1)
     });
 
-    trace!("Using configuration: {:?}", config);
+    log::trace!("Using configuration: {:?}", config);
 
     let runtime = new_runtime_builder().build().unwrap_or_else(|error| {
         eprintln!("{}", error.display_chain());
@@ -36,11 +35,11 @@ fn main() {
     let exit_code = match runtime.block_on(run_platform(config, log_dir)) {
         Ok(_) => 0,
         Err(error) => {
-            error!("{}", error);
+            log::error!("{}", error);
             1
         }
     };
-    debug!("Process exiting with code {}", exit_code);
+    log::debug!("Process exiting with code {}", exit_code);
     std::process::exit(exit_code);
 }
 
@@ -58,7 +57,7 @@ fn init_logging(config: &cli::Config) -> Result<Option<PathBuf>, String> {
     exception_logging::enable();
     version::log_version();
     if let Some(ref log_dir) = log_dir {
-        info!("Logging to {}", log_dir.display());
+        log::info!("Logging to {}", log_dir.display());
     }
     Ok(log_dir)
 }
@@ -114,7 +113,7 @@ async fn run_standalone(log_dir: Option<PathBuf>) -> Result<(), String> {
     }
 
     if !running_as_admin() {
-        warn!("Running daemon as a non-administrator user, clients might refuse to connect");
+        log::warn!("Running daemon as a non-administrator user, clients might refuse to connect");
     }
 
     let daemon = create_daemon(log_dir).await?;
@@ -125,7 +124,7 @@ async fn run_standalone(log_dir: Option<PathBuf>) -> Result<(), String> {
 
     daemon.run().await.map_err(|e| e.display_chain())?;
 
-    info!("Mullvad daemon is quitting");
+    log::info!("Mullvad daemon is quitting");
     thread::sleep(Duration::from_millis(500));
     Ok(())
 }
@@ -163,7 +162,7 @@ async fn spawn_management_interface(
         error.display_chain_with_msg("Unable to start management interface server")
     })?;
 
-    info!("Management interface listening on {}", socket_path);
+    log::info!("Management interface listening on {}", socket_path);
 
     Ok(event_broadcaster)
 }
diff --git a/mullvad-daemon/src/relays.rs b/mullvad-daemon/src/relays.rs
index 332baf5a85..89b14f08aa 100644
--- a/mullvad-daemon/src/relays.rs
+++ b/mullvad-daemon/src/relays.rs
@@ -8,7 +8,6 @@ use futures::{
     FutureExt, SinkExt, StreamExt,
 };
 use ipnetwork::IpNetwork;
-use log::{debug, error, info, warn};
 use mullvad_rpc::{availability::ApiAvailabilityHandle, rest::MullvadRestHandle, RelayListProxy};
 use mullvad_types::{
     endpoint::MullvadEndpoint,
@@ -141,7 +140,7 @@ impl ParsedRelays {
     }
 
     pub fn from_file(path: impl AsRef<Path>) -> Result<Self, Error> {
-        debug!("Reading relays from {}", path.as_ref().display());
+        log::debug!("Reading relays from {}", path.as_ref().display());
         let (last_modified, file) =
             Self::open_file(path.as_ref()).map_err(Error::OpenRelayCache)?;
         let relay_list =
@@ -193,13 +192,13 @@ impl RelaySelector {
         let resource_path = resource_dir.join(RELAYS_FILENAME);
         let unsynchronized_parsed_relays = Self::read_relays_from_disk(&cache_path, &resource_path)
             .unwrap_or_else(|error| {
-                error!(
+                log::error!(
                     "{}",
                     error.display_chain_with_msg("Unable to load cached relays")
                 );
                 ParsedRelays::empty()
             });
-        info!(
+        log::info!(
             "Initialized with {} cached relays from {}",
             unsynchronized_parsed_relays.relays().len(),
             DateTime::<Local>::from(unsynchronized_parsed_relays.last_updated())
@@ -296,9 +295,10 @@ impl RelaySelector {
             if let Some((entry_relay, mut entry_endpoint)) = entry_endpoint.take() {
                 self.set_entry_peers(peer, &mut entry_endpoint);
                 let addr_in = entry_endpoint.to_endpoint().address.ip();
-                info!(
+                log::info!(
                     "Selected entry relay {} at {}",
-                    entry_relay.hostname, addr_in
+                    entry_relay.hostname,
+                    addr_in
                 );
                 return Ok((exit_relay, Some(entry_relay), entry_endpoint));
             } else if relay_constraints.wireguard_constraints.use_multihop {
@@ -326,7 +326,7 @@ impl RelaySelector {
         if let Some((relay, endpoint)) =
             self.get_tunnel_endpoint_internal(&preferred_constraints, wg_entry_peer)
         {
-            debug!(
+            log::debug!(
                 "Relay matched on highest preference for retry attempt {}",
                 retry_attempt
             );
@@ -334,13 +334,13 @@ impl RelaySelector {
         } else if let Some((relay, endpoint)) =
             self.get_tunnel_endpoint_internal(&relay_constraints, wg_entry_peer)
         {
-            debug!(
+            log::debug!(
                 "Relay matched on second preference for retry attempt {}",
                 retry_attempt
             );
             Ok((relay, endpoint))
         } else {
-            warn!("No relays matching {}", &relay_constraints);
+            log::warn!("No relays matching {}", &relay_constraints);
             Err(Error::NoRelay)
         }
     }
@@ -636,7 +636,7 @@ impl RelaySelector {
                     .as_ref()
                     .map(|endpoint| endpoint.to_endpoint().address.ip())
                     .unwrap_or(IpAddr::from(selected_relay.ipv4_addr_in));
-                info!("Selected relay {} at {}", selected_relay.hostname, addr_in);
+                log::info!("Selected relay {} at {}", selected_relay.hostname, addr_in);
                 endpoint.map(|endpoint| (selected_relay.clone(), endpoint))
             })
     }
@@ -801,7 +801,7 @@ impl RelaySelector {
             .shadowsocks
             .choose(&mut self.rng)
             .map(|shadowsocks_endpoint| {
-                info!(
+                log::info!(
                     "Selected Shadowsocks bridge {} at {}:{}/{}",
                     relay.hostname,
                     relay.ipv4_addr_in,
@@ -924,7 +924,7 @@ impl RelaySelector {
                     }
                     port_index -= ports_in_range;
                 }
-                error!("Port selection algorithm is broken!");
+                log::error!("Port selection algorithm is broken!");
                 None
             }
             Constraint::Only(port) => {
@@ -1120,14 +1120,14 @@ impl RelayListUpdater {
 
     async fn update_cache(&mut self, new_relay_list: RelayList) -> Result<(), Error> {
         if let Err(error) = Self::cache_relays(&self.cache_path, &new_relay_list).await {
-            error!(
+            log::error!(
                 "{}",
                 error.display_chain_with_msg("Failed to update relay cache on disk")
             );
         }
 
         let new_parsed_relays = ParsedRelays::from_relay_list(new_relay_list, SystemTime::now());
-        info!(
+        log::info!(
             "Downloaded relay inventory has {} relays",
             new_parsed_relays.relays().len()
         );
@@ -1140,7 +1140,7 @@ impl RelayListUpdater {
 
     /// Write a `RelayList` to the cache file.
     async fn cache_relays(cache_path: &Path, relays: &RelayList) -> Result<(), Error> {
-        debug!("Writing relays cache to {}", cache_path.display());
+        log::debug!("Writing relays cache to {}", cache_path.display());
         let mut file = File::create(cache_path)
             .await
             .map_err(Error::OpenRelayCache)?;
diff --git a/mullvad-types/src/settings/mod.rs b/mullvad-types/src/settings/mod.rs
index 36981b82c7..7a941d968f 100644
--- a/mullvad-types/src/settings/mod.rs
+++ b/mullvad-types/src/settings/mod.rs
@@ -7,7 +7,6 @@ use crate::{
 };
 #[cfg(target_os = "android")]
 use jnix::{jni::objects::JObject, FromJava, IntoJava, JnixEnv};
-use log::{debug, info};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::net::IpAddr;
 #[cfg(target_os = "windows")]
@@ -133,16 +132,16 @@ impl Settings {
     /// The boolean in the Result indicates if the account token changed or not
     pub fn set_account_token(&mut self, mut account_token: Option<String>) -> bool {
         if account_token.as_ref().map(String::len) == Some(0) {
-            debug!("Setting empty account token is treated as unsetting it");
+            log::debug!("Setting empty account token is treated as unsetting it");
             account_token = None;
         }
         if account_token != self.account_token {
             if account_token.is_none() {
-                info!("Unsetting account token");
+                log::info!("Unsetting account token");
             } else if self.account_token.is_none() {
-                info!("Setting account token");
+                log::info!("Setting account token");
             } else {
-                info!("Changing account token")
+                log::info!("Changing account token")
             }
             self.account_token = account_token;
             true
@@ -175,9 +174,10 @@ impl Settings {
             if !update_supports_bridge && BridgeState::On == self.bridge_state {
                 self.bridge_state = BridgeState::Auto;
             }
-            debug!(
+            log::debug!(
                 "Changing relay settings:\n\tfrom: {}\n\tto: {}",
-                self.relay_settings, new_settings
+                self.relay_settings,
+                new_settings
             );
 
             self.relay_settings = new_settings;
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")
                                 );