tracing imporvements

Author: algorithmiker

Cargo.toml

@@ -17,6 +17,7 @@ itoa = "1.0.11"
 midly = "0.5.3"
 rustc-hash = "2.1.1"
 tracing = {version = "0.1.41", features = ["max_level_off","release_max_level_off"]}
+#tracing = {version = "0.1.41", features = []}
 tracing-subscriber = "0.3.20"
 yansi = "1.0.1"
 

src/backend/fixup/mod.rs

@@ -13,7 +13,7 @@ use crate::{
         Backend,
     },
     parser::parser::parse,
-    time, traceln,
+    time,
 };
 
 pub struct FixupBackend();

src/backend/midi/mod.rs

@@ -10,7 +10,7 @@ use super::{Backend, BackendResult};
 use crate::parser::parser::{parse, ParseResult};
 use crate::parser::tab_element::TabElement;
 use crate::parser::tab_element::TabElement::Fret;
-use crate::{debugln, time};
+use crate::time;
 
 const BPM: u32 = 80;
 const MINUTE_IN_MS: u32 = 60 * 1000;

src/backend/muxml/formatters.rs

@@ -1,5 +1,4 @@
 use crate::backend::muxml::{NoteProperties, Vibrato};
-use crate::debugln;
 use itoa::Buffer;
 use tracing::debug;
 // This file uses explicit .write_str() -s, instead of writing a format!()ted string, because I

src/backend/muxml/mod.rs

@@ -9,7 +9,7 @@ use crate::parser::parser::{source_location_from_stream, ParseResult};
 use crate::parser::tab_element::TabElement;
 use crate::{
     backend::{Backend, BackendResult},
-    debugln, rlen, time, traceln,
+    rlen, time,
 };
 use formatters::{
     write_muxml2_measure_prelude, write_muxml2_note, write_muxml2_rest, MUXML2_DOCUMENT_END,
@@ -135,7 +135,7 @@ impl MuxmlGenerator {
         let cap = Self::estimate_capacity(&parsed);
         let mut document = String::from(MUXML_INCOMPLETE_DOC_PRELUDE);
         document.reserve(cap);
-        debug!("muxml2: reserved {}", cap);
+        debug!(capacity = cap, "reserved capacity");
 
         Self {
             parsed,
@@ -226,7 +226,7 @@ impl MuxmlGenerator {
         Ok(())
     }
     pub fn process_measure(&mut self, measure_idx: usize) -> Result<(), BackendError> {
-        let meas = span!(Level::TRACE, "Muxml2: processing measure {}", measure_idx);
+        let meas = span!(Level::TRACE, "Muxml2: processing measure", measure_idx);
         let _meas = meas.enter();
         let ticks_in_measure = rlen(&self.parsed.measures[measure_idx].data_range) / 6;
         debug_assert!(rlen(&self.parsed.measures[measure_idx].data_range) % 6 == 0);

src/backend/muxml/muxml2_tests.rs

@@ -3,7 +3,6 @@ use crate::backend::{
     muxml::{settings::Settings, MuxmlBackend},
     Backend,
 };
-use crate::debugln;
 use crate::parser::parser::{parse, source_location_from_stream};
 use itertools::Itertools;
 

src/lib.rs

@@ -20,42 +20,6 @@ use std::{
 
 pub mod backend;
 pub mod parser;
-#[macro_export]
-macro_rules! traceln {
-    (depth=$depth:literal, $($t:expr),*) => {
-        #[cfg(feature="sm_trace")]
-        {
-            use yansi::Paint;
-            let padding=" ".repeat($depth);
-            println!("{padding}{} {}", "[T]:".blue().bold(), format_args!($($t),*));
-        }
-    };
-    ($($t:expr),*) => {
-        #[cfg(feature="sm_trace")]
-        {
-            use yansi::Paint;
-            println!("{} {}", "[T]:".blue().bold(), format_args!($($t),*));
-        }
-    };
-}
-#[macro_export]
-macro_rules! debugln {
-    (depth=$depth:literal, $($t:expr),*) => {
-        #[cfg(feature="sm_debug")]
-        {
-            use yansi::Paint;
-            let padding=" ".repeat($depth);
-            println!("{padding}{} {}", "[D]:".green().bold(), format_args!($($t),*));
-        }
-    };
-    ($($t:expr),*) => {
-        #[cfg(feature="sm_debug")]
-        {
-            use yansi::Paint;
-            println!("{} {}", "[D]:".green().bold(), format_args!($($t),*));
-        }
-    };
-}
 
 pub fn rlen<T: std::ops::Sub<Output = T> + Copy + std::ops::Add<u32, Output = T>>(
     r: &RangeInclusive<T>,

src/main.rs

@@ -2,10 +2,12 @@ use std::{
     fmt::Write,
     fs::{File, OpenOptions},
     io::{BufRead, BufReader, BufWriter, Read, StdoutLock},
+    sync::Arc,
 };
 
 use anyhow::{Context, Ok};
 use clap::Parser;
+use entrace_core::remote::IETStorage;
 use scoreman::{
     backend::errors::{
         backend_error::BackendError, diagnostic::Diagnostic, error_location::ErrorLocation,
@@ -63,7 +65,28 @@ impl std::io::Write for OutputType {
     }
 }
 
+/// tracing via entrace. don't forget to disable the tracing feature flags too!
+#[allow(unreachable_code)]
+fn setup_tracing() -> Option<Arc<IETStorage<BufWriter<File>>>> {
+    return None;
+
+    use entrace_core::{remote::IETStorage, remote::IETStorageConfig, TreeLayer};
+    use std::{fs::OpenOptions, sync::Arc};
+    use tracing::level_filters::LevelFilter;
+    use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, Registry};
+
+    let file =
+        OpenOptions::new().write(true).create(true).truncate(true).open("scoreman.iet").unwrap();
+    let storage =
+        Arc::new(IETStorage::init(IETStorageConfig::non_length_prefixed(BufWriter::new(file))));
+    let tree_layer = TreeLayer::from_storage(storage.clone());
+
+    Registry::default().with(LevelFilter::TRACE).with(tree_layer).init();
+    Some(storage)
+}
+
 fn main() -> anyhow::Result<()> {
+    let trace_storage = setup_tracing();
     let cli = Cli::parse();
     let input_path = cli.command.input_path();
     let lines: Vec<String> = get_lines(input_path)?;
@@ -103,6 +126,9 @@ fn main() -> anyhow::Result<()> {
             }
         }
     }
+    if let Some(s) = trace_storage {
+        s.finish().unwrap();
+    }
     if result.err.is_some() {
         std::process::exit(1)
     }
@@ -131,8 +157,7 @@ pub fn handle_error(
     let max_digit_cnt = digit_cnt_usize(*extended_range.end());
     for line_idx in extended_range {
         let zero_pad_cnt = max_digit_cnt.saturating_sub(digit_cnt_usize(line_idx + 1)) as usize;
-        let mut line_num = String::new();
-        line_num += &*" ".repeat(zero_pad_cnt);
+        let mut line_num = " ".repeat(zero_pad_cnt);
         write!(&mut line_num, "{}", line_idx + 1)?;
 
         let line_num = if relevant_lines.contains(&line_idx) {

src/parser/parser.rs

@@ -4,10 +4,7 @@ use super::{
     string_name,
     tab_element::{self, tab_element3, TabElement},
 };
-use crate::{
-    backend::errors::backend_error::BackendError, debugln, parser::tab_element::TabElementError,
-    traceln,
-};
+use crate::{backend::errors::backend_error::BackendError, parser::tab_element::TabElementError};
 use std::ops::RangeInclusive;
 
 pub fn line_is_valid(line: &str) -> bool {
@@ -93,7 +90,8 @@ pub fn parse<T: AsRef<str>>(lines: &[T]) -> ParseResult {
             part_first_line += 1
         }
         let range = part_first_line..=part_first_line + 5;
-        trace!(?range, "found part");
+        let _part = span!(Level::DEBUG, "parsing part", ?range);
+        let _part = _part.enter();
         r.offsets.push((part_first_line as u32, r.tick_stream.len() as u32));
         let mut part: Vec<&str> = lines[range].iter().map(|s| s.as_ref().trim()).collect(); // TODO: check if this is slow
 
@@ -161,7 +159,8 @@ pub fn parse<T: AsRef<str>>(lines: &[T]) -> ParseResult {
                 r.tick_stream.push(te);
             }
             if is_multichar {
-                trace!(tick, "marked as multichar, running fixup");
+                let _ms = span!(Level::DEBUG, "marked as multichar, running fixup", tick);
+                let _ms = _ms.enter();
                 tick_cnt_est -= 1;
                 for s in 0..6 {
                     if is_multi_on[s] {
@@ -170,7 +169,8 @@ pub fn parse<T: AsRef<str>>(lines: &[T]) -> ParseResult {
                     };
                     let elem_idx = r.tick_stream.len() - (6 - s);
                     let elem = &r.tick_stream[elem_idx];
-                    trace!(string = s, ?elem);
+                    let _s = span!(Level::DEBUG, "fixing up string", string = s, ?elem);
+                    let _s = _s.enter();
                     if let TabElement::Rest = elem {
                         let _s2 = span!(
                             Level::TRACE,
@@ -194,7 +194,9 @@ pub fn parse<T: AsRef<str>>(lines: &[T]) -> ParseResult {
                         r.tick_stream[len - (6 - s)] = next.1;
                         part[s] = next.0;
                     } else {
-                        trace!("this is not a Rest, so we check the next element");
+                        let _q =
+                            span!(Level::TRACE, "this is not a Rest, so we check the next element");
+                        let _q = _q.enter();
                         if part[s].starts_with("-") {
                             trace!("next element is Rest so we skip it");
                             part[s] = &part[s][1..];
@@ -310,7 +312,7 @@ pub fn source_location_from_stream(r: &ParseResult, tick_location: u32) -> (u32,
 
 pub fn dump_source(input: &Vec<&str>) -> String {
     use itertools::Itertools;
-    input.iter().join("\n")
+    std::iter::once(&"").chain(input.iter()).join("\n")
 }
 
 #[test]