svaluer: Finish tracing migration

Author: MikailBag

Cargo.lock

@@ -12,9 +12,6 @@ crossbeam-channel = "0.5.1"
 serde_json = "1.0.64"
 serde = "1.0.125"
 serde_yaml = "0.8.17"
-log = "0.4.14"
 either = "1.6.1"
 tracing-subscriber = "0.2.17"
-
-[dev-dependencies]
-simple_logger = "1.11.0"
+tracing = "0.1.26"

svaluer/Cargo.toml

@@ -2,7 +2,6 @@ mod group;
 
 use crate::cfg::Config;
 use group::Group;
-use log::{debug, info};
 use pom::TestId;
 use std::{collections::HashSet, num::NonZeroU32};
 use valuer_api::{
@@ -138,7 +137,7 @@ impl Fiber {
     }
 
     fn emit_judgelog(&mut self) -> FiberReply {
-        debug!("Emitting {:?} judge log", self.kind);
+        tracing::info!("Emitting {:?} judge log", self.kind);
         let is_full = self.groups.iter().all(|g| g.is_passed());
         let mut judge_log = JudgeLog {
             kind: self.kind,
@@ -148,7 +147,7 @@ impl Fiber {
             score: 0,
         };
         for (i, g) in self.groups.iter().enumerate() {
-            debug!("extending judge log with group {}", i);
+            tracing::debug!("extending judge log with group {}", i);
             g.update_judge_log(&mut judge_log);
         }
 
@@ -159,10 +158,10 @@ impl Fiber {
         for &i in &self.active_groups {
             let g = &mut self.groups[i];
             if let reply @ Some(_) = g.pop_test() {
-                debug!("group {} returned {}", i, reply.unwrap());
+                tracing::debug!("group {} returned {}", i, reply.unwrap());
                 return reply;
             }
-            debug!("group {} is not ready to run yet", i);
+            tracing::debug!("group {} is not ready to run yet", i);
         }
         None
     }
@@ -180,17 +179,18 @@ impl Fiber {
     }
 
     pub(crate) fn poll(&mut self) -> FiberReply {
-        debug!("Fiber {:?}: poll iteration", self.kind);
+        tracing::debug!("Fiber {:?}: poll iteration", self.kind);
         if self.finished {
-            debug!("Returning none: already finished");
+            tracing::debug!("Returning none: already finished");
             return FiberReply::None;
         }
         let cur_live_score = self.current_score();
-        debug!("live score: {}", cur_live_score);
+        tracing::debug!("live score: {}", cur_live_score);
         if cur_live_score != self.last_live_score {
-            info!(
+            tracing::debug!(
                 "live score updated: old={}, cur={}",
-                self.last_live_score, cur_live_score
+                self.last_live_score,
+                cur_live_score
             );
             self.last_live_score = cur_live_score;
             return FiberReply::LiveScore {
@@ -203,20 +203,20 @@ impl Fiber {
             let is_passed = g.is_passed();
             let is_failed = g.is_failed();
             if is_passed || is_failed {
-                info!("group {} is finished", i);
+                tracing::debug!("group {} is finished", i);
             } else {
                 new_active_groups.push(i);
             }
             assert!(!(is_passed && is_failed));
             if g.is_passed() {
-                debug!("group {} is passed", i);
+                tracing::debug!("group {} is passed", i);
                 for group in &mut self.groups {
                     group.on_group_pass(i as u32);
                 }
             } else if g.is_failed() {
                 let mut queue = vec![i as u32];
                 while let Some(k) = queue.pop() {
-                    debug!("group {} is failed", k);
+                    tracing::debug!("group {} is failed", k);
                     for (j, group) in self.groups.iter_mut().enumerate() {
                         if !group.is_waiting() {
                             continue;
@@ -231,10 +231,10 @@ impl Fiber {
         }
         self.active_groups = new_active_groups;
         if let Some(test_id) = self.poll_groups_for_tests() {
-            debug!("got test from groups: {}", test_id);
+            tracing::debug!("got test from groups: {}", test_id);
             FiberReply::Test { test_id }
         } else if self.running_tests() == 0 {
-            debug!(
+            tracing::debug!(
                 "this fiber is finished, emitting judge log of kind {:?}",
                 self.kind
             );
@@ -248,7 +248,7 @@ impl Fiber {
                 .flatten()
                 .next()
                 .expect("unreachable: running_tests() > 0, but no test found");
-            debug!(
+            tracing::debug!(
                 "no updates yet, waiting for running tests, incl. {:?}",
                 running_test
             );
@@ -259,9 +259,9 @@ impl Fiber {
     }
 
     fn add_test(&mut self, test: TestId, status: &Status) {
-        debug!("processing status {:?} for test {}", status, test);
+        tracing::debug!("processing status {:?} for test {}", status, test);
         if !self.visible_tests.contains(&test) {
-            debug!("skipping: test is not visible");
+            tracing::debug!("skipping: test is not visible");
             return;
         }
         for g in &mut self.groups {
@@ -289,7 +289,7 @@ mod tests {
     }
     #[test]
     fn simple() {
-        simple_logger::SimpleLogger::new().init().ok();
+        crate::setup_log();
         let mut f = make_fiber(
             "
 groups:

svaluer/src/fiber.rs

@@ -1,5 +1,4 @@
 use either::{Left, Right};
-use log::debug;
 use pom::TestId;
 use std::collections::BTreeSet;
 use valuer_api::{
@@ -180,7 +179,7 @@ impl Group {
             _ => return,
         };
         if state.deps.remove(&other_group_id) {
-            debug!("group {:?}: dep {} passed", self.id, other_group_id);
+            tracing::debug!("group {:?}: dep {} passed", self.id, other_group_id);
             self.maybe_stop_waiting();
         }
     }
@@ -194,39 +193,39 @@ impl Group {
             // that group was not required, so we ignore this failure
             return;
         }
-        debug!("group {:?}: dep {} failed", self.id, other_group_id);
+        tracing::debug!("group {:?}: dep {} failed", self.id, other_group_id);
         self.state = State::Skipped(SkippedState {
             failed_dep: other_group_id,
         });
     }
 
     /// Returns next test from this group that can be executed
     pub(crate) fn pop_test(&mut self) -> Option<TestId> {
-        debug!("Group {:?}: searching for test", self.id);
+        tracing::debug!("Group {:?}: searching for test", self.id);
         // we can't run if some deps are running or failed
         let state = match &mut self.state {
             State::Building => unreachable!(),
             State::Finished(_) | State::Skipped(_) => {
-                debug!("Returning None: group has been done");
+                tracing::debug!("Returning None: group has been done");
                 return None;
             }
             State::Waiting(_) => {
-                debug!("Returning None: some deps still not finished");
+                tracing::debug!("Returning None: some deps still not finished");
                 return None;
             }
             State::Running(state) => state,
         };
         if !state.running_tests.is_empty() && !self.run_all_tests {
-            debug!("Returning None: run_all_tests=false, and a test is already running");
+            tracing::debug!("Returning None: run_all_tests=false, and a test is already running");
             return None;
         }
         if let Some(t) = state.queued_tests.iter().next().copied() {
-            debug!("found test: {}", t);
+            tracing::debug!("found test: {}", t);
             state.queued_tests.remove(&t);
             state.running_tests.insert(t);
             Some(t)
         } else {
-            debug!("Queue is empty");
+            tracing::debug!("Queue is empty");
             None
         }
     }
@@ -243,7 +242,7 @@ impl Group {
         let must_run_all_tests = self.run_all_tests;
         let state = self.running_state();
         if state.failed_tests.is_empty() {
-            debug!("group {:?} is now failed", id);
+            tracing::debug!("group {:?} is now failed", id);
         }
         state.failed_tests.insert((test_id, status));
         if !must_run_all_tests {
@@ -281,7 +280,7 @@ impl Group {
         if !state.running_tests.remove(&test_id) {
             return;
         }
-        debug!(
+        tracing::debug!(
             "got test result: test={}, status={:?}",
             test_id.get(),
             status
@@ -340,7 +339,7 @@ mod tests {
     use valuer_api::StatusKind;
     #[test]
     fn simple() {
-        simple_logger::SimpleLogger::new().init().ok();
+        crate::setup_log();
         let st = || Status {
             kind: StatusKind::Accepted,
             code: "MOCK_OK".to_string(),