ref: rename tracing package to log

conflicts with running cargo check and test
kkharji · Jun 19, 2022 · c28a0ef · c28a0ef
1 parent 860b37c
commit c28a0ef
Show file tree

Hide file tree

Showing 26 changed files with 107 additions and 108 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/daemon/Cargo.toml b/daemon/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2021"
 [dependencies]
 
 # Internal
-tracing               = { path = "./../tracing/" }
+log                   = { path = "./../log/" }
 xbase-proto           = { path = "./../proto/" }
 
 # Error Handling

diff --git a/daemon/src/build.rs b/daemon/src/build.rs
@@ -37,7 +37,7 @@ impl RequestHandler for BuildRequest {
 #[async_trait]
 impl Watchable for BuildRequest {
     async fn trigger(&self, state: &MutexGuard<State>, _event: &Event) -> Result<()> {
-        tracing::info!("Building {}", self.client.abbrev_root());
+        log::info!("Building {}", self.client.abbrev_root());
         let is_once = self.ops.is_once();
         let (root, config) = (&self.client.root, &self.settings);
         // let args = state.projects.get(root)?.build_args(&config, &None)?;
@@ -52,7 +52,7 @@ impl Watchable for BuildRequest {
             config.target
         ));
 
-        tracing::trace!("building with [{}]", args.join(" "));
+        log::trace!("building with [{}]", args.join(" "));
         let xclogger = XCLogger::new(&root, args)?;
         let success = logger.consume_build_logs(xclogger, false, is_once).await?;
 

diff --git a/daemon/src/compile.rs b/daemon/src/compile.rs
@@ -19,7 +19,7 @@ pub async fn ensure_server_config(root: &PathBuf) -> Result<()> {
         return Ok(());
     }
 
-    tracing::info!("Creating {:?}", path);
+    log::info!("Creating {:?}", path);
 
     let mut file = tokio::fs::File::create(path).await?;
     file.write_all(

diff --git a/daemon/src/drop.rs b/daemon/src/drop.rs
@@ -12,7 +12,7 @@ impl RequestHandler for DropRequest {
         let ref mut state = state.lock().await;
 
         if state.clients.contains_key(&client.pid) {
-            tracing::info!("Drop({}: {})", client.pid, client.abbrev_root());
+            log::info!("Drop({}: {})", client.pid, client.abbrev_root());
             // NOTE: Should only be Some if no more client depend on it
             if let Some(_) = state.projects.remove(&client).await? {
                 // NOTE: Remove project watchers

diff --git a/daemon/src/error.rs b/daemon/src/error.rs
@@ -10,7 +10,7 @@ pub enum Error {
     #[error("[Error] (Compile): {0}")]
     Compile(#[from] CompileError),
     #[error("{0}")]
-    Tracing(#[from] tracing::TracingError),
+    Tracing(#[from] log::TracingError),
     #[error("[Error] (Conversion) {0}")]
     Conversion(#[from] ConversionError),
     #[error("[Error] (Lookup) {0} with {0} doesn't exist")]

diff --git a/daemon/src/lib.rs b/daemon/src/lib.rs
@@ -21,7 +21,7 @@ pub trait RequestHandler {
     where
         Self: Sized + std::fmt::Debug,
     {
-        tracing::error!("Not Implemented! {:#?}", self);
+        log::error!("Not Implemented! {:#?}", self);
         Ok(())
     }
 }
diff --git a/daemon/src/main.rs b/daemon/src/main.rs
@@ -2,7 +2,7 @@ use tap::Pipe;
 use tokio::fs::{metadata, read_to_string, remove_file, write};
 use tokio::io::AsyncReadExt;
 use tokio::net::UnixListener;
-use tracing::Level;
+use log::Level;
 use xbase_daemon::util::pid;
 use xbase_daemon::Result;
 use xbase_daemon::{constants::*, RequestHandler};
@@ -14,16 +14,16 @@ async fn main() -> Result<()> {
 
     let listener = UnixListener::bind(DAEMON_SOCKET_PATH).unwrap();
 
-    tracing::setup("/tmp", "xbase-daemon.log", Level::TRACE, true)?;
+    log::setup("/tmp", "xbase-daemon.log", Level::TRACE, true)?;
 
-    tracing::info!("Started");
+    log::info!("Started");
     loop {
         if let Ok((mut s, _)) = listener.accept().await {
             tokio::spawn(async move {
                 let msg = {
                     let mut msg = String::default();
                     if let Err(e) = s.read_to_string(&mut msg).await {
-                        return tracing::error!("[Read Error]: {:?}", e);
+                        return log::error!("[Read Error]: {:?}", e);
                     };
                     msg
                 };
@@ -34,13 +34,13 @@ async fn main() -> Result<()> {
 
                 let req = match Request::read(msg.clone()) {
                     Err(e) => {
-                        return tracing::error!("[Parse Error]: {:?} message: {msg}", e);
+                        return log::error!("[Parse Error]: {:?} message: {msg}", e);
                     }
                     Ok(req) => req,
                 };
 
                 if let Err(e) = handle(req).await {
-                    return tracing::error!("[Failure]: Cause: ({:?})", e);
+                    return log::error!("[Failure]: Cause: ({:?})", e);
                 };
 
                 let state = DAEMON_STATE.clone();
@@ -50,7 +50,7 @@ async fn main() -> Result<()> {
                 // update_watchers(state.clone()).await;
             });
         } else {
-            tracing::error!("Fail to accept a connection")
+            log::error!("Fail to accept a connection")
         };
     }
 }

diff --git a/daemon/src/nvim/logger.rs b/daemon/src/nvim/logger.rs
@@ -78,7 +78,7 @@ impl<'a> Logger<'a> {
 
     // TODO(logger): always show current new logs in middle of the window
     pub async fn append(&mut self, msg: String) -> Result<()> {
-        tracing::trace!("{msg}");
+        log::trace!("{msg}");
         let win_info = self.win().await;
         let mut c = self.get_line_count().await?;
 
@@ -135,7 +135,7 @@ impl<'a> Logger<'a> {
             return Ok(win);
         }
 
-        tracing::info!("Openning a new window");
+        log::info!("Openning a new window");
 
         if self.open_cmd.is_none() {
             let v = self.nvim.get_window_direction(None).await?;
@@ -222,7 +222,7 @@ impl NvimClient {
         {
             Ok(open_command) => open_command,
             Err(e) => {
-                tracing::error!("Unable to convert value to string {e}");
+                log::error!("Unable to convert value to string {e}");
                 BufferDirection::Horizontal.to_nvim_command(*bufnr)
             }
         }

diff --git a/daemon/src/project/mod.rs b/daemon/src/project/mod.rs
@@ -63,7 +63,7 @@ impl Project {
         project.generator = ProjectGenerator::new(root);
 
         project.inner = if root.join("Package.swift").exists() {
-            tracing::debug!("[Project] Kind: \"Swift\"",);
+            log::debug!("[Project] Kind: \"Swift\"",);
             // TODO(project): Get swift project name
             project.name = "UnknownSwiftProject".into();
             ProjectInner::Swift
@@ -72,10 +72,10 @@ impl Project {
             project.name = xcodeproj.name().to_owned();
             project.targets = xcodeproj.targets_platform();
 
-            tracing::debug!("[New Project] name: {:?}", project.name);
-            tracing::debug!("[New Project] Kind: \"XCodeProject\"");
-            tracing::debug!("[New Project] Generator: \"{:?}\"", project.generator);
-            tracing::debug!("[New Project] targets: {:?}", project.targets);
+            log::debug!("[New Project] name: {:?}", project.name);
+            log::debug!("[New Project] Kind: \"XCodeProject\"");
+            log::debug!("[New Project] Generator: \"{:?}\"", project.generator);
+            log::debug!("[New Project] targets: {:?}", project.targets);
 
             ProjectInner::XCodeProject(xcodeproj)
         };
@@ -102,7 +102,7 @@ impl Project {
 
         self.root = root;
         self.clients = clients;
-        tracing::info!("[Projects] update({:?})", self.name);
+        log::info!("[Projects] update({:?})", self.name);
 
         Ok(())
     }
@@ -140,7 +140,7 @@ impl Project {
     pub async fn generate_compile_commands(&self) -> Result<()> {
         use xclog::{XCCompilationDatabase, XCCompileCommand};
 
-        tracing::info!("Generating compile commands ... ");
+        log::info!("Generating compile commands ... ");
         let mut compile_commands: Vec<XCCompileCommand> = vec![];
         let cache_root = get_build_cache_dir(&self.root)?;
         // Because xcodebuild clean can't remove it
@@ -161,7 +161,7 @@ impl Project {
             .into_iter()
             .for_each(|cmd| compile_commands.push(cmd));
 
-        tracing::info!("Compile Commands Generated");
+        log::info!("Compile Commands Generated");
 
         let json = serde_json::to_vec_pretty(&compile_commands)?;
         tokio::fs::write(self.root.join(".compile"), &json).await?;

diff --git a/daemon/src/run.rs b/daemon/src/run.rs
@@ -17,7 +17,7 @@ impl RequestHandler for RunRequest {
     where
         Self: Sized + std::fmt::Debug,
     {
-        tracing::info!("⚙️ Running: {}", self.settings.to_string());
+        log::info!("⚙️ Running: {}", self.settings.to_string());
 
         let ref key = self.to_string();
         let state = DAEMON_STATE.clone();

diff --git a/daemon/src/run/handler.rs b/daemon/src/run/handler.rs
@@ -24,7 +24,7 @@ impl RunServiceHandler {
                 let ref mut logger = match state.clients.get(&client.pid) {
                     Ok(nvim) => nvim.logger(),
                     Err(_) => {
-                        tracing::info!("Nvim Instance closed, closing runner ..");
+                        log::info!("Nvim Instance closed, closing runner ..");
                         state.watcher.get_mut(&client.root)?.listeners.remove(&key);
                         kill_send.send(()).await.ok();
                         break;

diff --git a/daemon/src/run/service.rs b/daemon/src/run/service.rs
@@ -75,7 +75,7 @@ impl RunService {
 #[async_trait::async_trait]
 impl Watchable for RunService {
     async fn trigger(&self, state: &MutexGuard<State>, _event: &Event) -> Result<()> {
-        tracing::info!("Running {}", self.client.abbrev_root());
+        log::info!("Running {}", self.client.abbrev_root());
 
         let (root, config) = (&self.client.root, &self.medium.settings());
         let mut handler = self.handler.clone().lock_owned().await;