remove unnecessarily revealing information in log messages that may be exported to the log server

appmgr/src/context/rpc.rs

@@ -145,7 +145,18 @@ impl RpcContext {
     ) -> Result<Self, Error> {
         let base = RpcContextConfig::load(cfg_path).await?;
         tracing::info!("Loaded Config");
-        let logger = EmbassyLogger::init(base.log_server.clone(), false);
+        let log_epoch = Arc::new(AtomicU64::new(rand::random()));
+        let tor_proxy = base.tor_socks.unwrap_or(SocketAddr::V4(SocketAddrV4::new(
+            Ipv4Addr::new(127, 0, 0, 1),
+            9050,
+        )));
+        let logger = EmbassyLogger::init(
+            log_epoch.clone(),
+            base.log_server.clone(),
+            false,
+            tor_proxy.ip(),
+            tor_proxy.port(),
+        )?;
         tracing::info!("Set Logger");
         let (shutdown, _) = tokio::sync::broadcast::channel(1);
         let secret_store = base.secret_store().await?;
@@ -193,10 +204,7 @@ impl RpcContext {
             websocket_count: AtomicUsize::new(0),
             log_epoch: logger.epoch(),
             logger,
-            tor_socks: base.tor_socks.unwrap_or(SocketAddr::V4(SocketAddrV4::new(
+            tor_socks: tor_proxy,
-                Ipv4Addr::new(127, 0, 0, 1),
-                9050,
-            ))),
             notification_manager,
             open_authed_websockets: Mutex::new(BTreeMap::new()),
             rpc_stream_continuations: Mutex::new(BTreeMap::new()),

appmgr/src/net/mdns.rs

@@ -131,8 +131,7 @@ impl MdnsControllerInner {
                 if res < avahi_sys::AVAHI_OK {
                     let e_str = avahi_strerror(res);
                     tracing::error!(
-                        "Could not add record for {:?} to Avahi entry group: {:?}",
+                        "Could not add CNAME record to Avahi entry group: {:?}",
-                        lan_address_ptr,
                         std::ffi::CStr::from_ptr(e_str)
                     );
                     avahi_free(e_str as *mut c_void);

appmgr/src/net/wifi.rs

@@ -59,7 +59,7 @@ pub async fn add(
             let mut wpa_supplicant = wifi_manager.write().await;
             let connected = wpa_supplicant.select_network(ssid).await?;
             if !connected {
-                tracing::error!("Faild to add new WiFi network: '{}'", ssid);
+                tracing::info!("Failed to add new WiFi network: '{}'", ssid);
                 wpa_supplicant.remove_network(ssid).await?;
                 match current {
                     None => {}
@@ -82,7 +82,7 @@ pub async fn add(
         .await
         {
             Err(e) => {
-                tracing::error!("Failed to add new WiFi network '{}': {}", ssid, e);
+                tracing::info!("Failed to add new WiFi network '{}': {}", ssid, e);
                 tracing::debug!("{:?}", e);
             }
             Ok(_) => {}
@@ -112,10 +112,10 @@ pub async fn connect(#[context] ctx: RpcContext, #[arg] ssid: String) -> Result<
         if connected {
             tracing::info!("Successfully connected to WiFi: '{}'", ssid);
         } else {
-            tracing::error!("Failed to connect to WiFi: '{}'", ssid);
+            tracing::info!("Failed to connect to WiFi: '{}'", ssid);
             match current {
                 None => {
-                    tracing::warn!("No WiFi to revert to!");
+                    tracing::info!("No WiFi to revert to!");
                 }
                 Some(current) => {
                     wpa_supplicant.select_network(&current).await?;
@@ -127,7 +127,7 @@ pub async fn connect(#[context] ctx: RpcContext, #[arg] ssid: String) -> Result<
     tokio::spawn(async move {
         match connect_procedure(ctx.wifi_manager.clone(), &ssid).await {
             Err(e) => {
-                tracing::error!("Failed to connect to WiFi network '{}': {}", &ssid, e);
+                tracing::info!("Failed to connect to WiFi network '{}': {}", &ssid, e);
             }
             Ok(_) => {}
         }

appmgr/src/util/logger.rs

@@ -1,18 +1,20 @@
+use std::net::IpAddr;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 
-use lazy_static::lazy_static;
+use reqwest::{Client, Proxy, Url};
-use reqwest::{Client, Url};
 use serde::Serialize;
 use tracing::Subscriber;
 use tracing_subscriber::Layer;
 
 use crate::version::COMMIT_HASH;
+use crate::{Error, ResultExt};
 
 pub struct SharingLayer {
     log_epoch: Arc<AtomicU64>,
     sharing: Arc<AtomicBool>,
     share_dest: String,
+    tor_proxy: Client,
 }
 impl<S: Subscriber> Layer<S> for SharingLayer {
     fn on_event(
@@ -71,7 +73,7 @@ impl<S: Subscriber> Layer<S> for SharingLayer {
                     log_message: message.0,
                 };
                 // we don't care about the result and need it to be fast
-                tokio::spawn(Client::new().post(&self.share_dest).json(&body).send());
+                tokio::spawn(self.tor_proxy.post(&self.share_dest).json(&body).send());
             }
         }
     }
@@ -101,9 +103,14 @@ impl EmbassyLogger {
             .with(ErrorLayer::default())
     }
     pub fn no_sharing() {
-        Self::init(None, false);
+        Self::init(None, false, IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 9050);
     }
-    pub fn init(share_dest: Option<Url>, share_errors: bool) -> Self {
+    pub fn init(
+        share_dest: Option<Url>,
+        share_errors: bool,
+        tor_proxy_ip: IpAddr,
+        tor_proxy_port: u16,
+    ) -> Self {
         use tracing_subscriber::prelude::*;
 
         let mut guard = LOGGER.lock().unwrap();
@@ -117,10 +124,18 @@ impl EmbassyLogger {
                 None => "https://beta-registry-0-3.start9labs.com/error-logs".to_owned(), // TODO
                 Some(a) => a.to_string(),
             };
+            let tor_proxy = Client::builder()
+                .proxy(
+                    Proxy::http(format!("socks5h://{}:{}", tor_proxy_ip, tor_proxy_port))
+                        .with_kind(crate::ErrorKind::Network)?,
+                )
+                .build()
+                .with_kind(crate::ErrorKind::Network)?;
             let sharing_layer = SharingLayer {
                 log_epoch: log_epoch.clone(),
                 share_dest,
                 sharing: sharing.clone(),
+                tor_proxy,
             };
 
             Self::base_subscriber().with(sharing_layer).init();
@@ -129,7 +144,7 @@ impl EmbassyLogger {
         };
         *guard = Some((log_epoch.clone(), sharing.clone()));
 
-        EmbassyLogger { log_epoch, sharing }
+        Ok(EmbassyLogger { log_epoch, sharing })
     }
     pub fn epoch(&self) -> Arc<AtomicU64> {
         self.log_epoch.clone()