replace slog with tracing

mental32 · mental32 · commit e4a925e5a379 · 2021-10-26T22:09:13.000+03:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -25,18 +25,31 @@ cfg-if = "1.0.0"
 err-derive = "0.3.0"
 xtra = "0.5.1"
 async-trait = "0.1.49"
-slog = "2.7.0"
 xtra_proc = "0.1.0"
-tokio = { version = "1.5.0", features = ["process", "io-util", "io-std", "macros", "time", "rt"] }
-tokio-stream = { version = "0.1.5", features = ["io-util"] }
 mp4 = { git = "https://github.com/vgarleanu/mp4-rust" }
 once_cell = "1.8.0"
 
+tracing = "0.1.29"
+tokio-stream = { version = "0.1.5", features = ["io-util"] }
+tokio = { version = "1.5.0", features = [
+    "process",
+    "io-util",
+    "io-std",
+    "macros",
+    "time",
+    "rt",
+] }
+
+
 [target.'cfg(unix)'.dependencies]
 nix = "0.20.0"
 psutil = "3.2.0"
 rusty_vainfo = { version = "0.1.4", optional = true }
 
 [target.'cfg(windows)'.dependencies]
-winapi = { version = "^0.3.9", features = ["winerror", "synchapi", "minwinbase"] }
 ntapi = "^0.3.6"
+winapi = { version = "^0.3.9", features = [
+    "winerror",
+    "synchapi",
+    "minwinbase",
+] }
diff --git a/examples/dump_args.rs b/examples/dump_args.rs
@@ -8,10 +8,7 @@ fn main() {
     let profile = args.next().expect("Usage: dump_args <profile> <file>");
     let file = args.next().expect("Usage: dump_args <profile> <file>");
 
-    let drain = slog::Discard;
-    let log = slog::Logger::root(drain, slog::o!());
-
-    profiles_init(log, "/usr/bin/ffmpeg".to_string());
+    profiles_init("/usr/bin/ffmpeg".to_string());
 
     let profile = get_active_profiles()
         .into_iter()
diff --git a/examples/list_device_profiles.rs b/examples/list_device_profiles.rs
@@ -1,10 +1,7 @@
 use nightfall::profiles::*;
 
 fn main() {
-    let drain = slog::Discard;
-    let log = slog::Logger::root(drain, slog::o!());
-
-    profiles_init(log, "/usr/bin/ffmpeg".to_string());
+    profiles_init("/usr/bin/ffmpeg".to_string());
 
     for profile in get_active_profiles() {
         println!("{:?}", profile);
diff --git a/src/lib.rs b/src/lib.rs
@@ -20,19 +20,17 @@ use crate::profiles::*;
 use crate::session::Session;
 
 use std::collections::HashMap;
+use std::fmt;
 use std::time::Duration;
 use std::time::Instant;
-use std::fmt;
 
 use async_trait::async_trait;
+use tracing::debug;
+use tracing::info;
+use tracing::warn;
 use xtra_proc::actor;
 use xtra_proc::handler;
 
-use slog::debug;
-use slog::error;
-use slog::info;
-use slog::warn;
-
 pub use tokio::process::ChildStdout;
 
 pub struct StreamStat {
@@ -61,8 +59,6 @@ pub struct StateManager {
     pub stream_stats: HashMap<String, StreamStat>,
     /// Contains the exit status of dead sessions
     pub exit_statuses: HashMap<String, String>,
-    /// Logger
-    pub logger: slog::Logger,
 }
 
 impl fmt::Debug for __ActorStateManager::StateManager {
@@ -78,18 +74,16 @@ impl fmt::Debug for __ActorStateManager::StateManager {
 
 impl fmt::Debug for StateManager {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("StateManagerActor")
-            .finish()
+        f.debug_struct("StateManagerActor").finish()
     }
 }
 
 #[actor]
 impl StateManager {
-    pub fn new(outdir: String, ffmpeg: String, logger: slog::Logger) -> Self {
+    pub fn new(outdir: String, ffmpeg: String) -> Self {
         Self {
             outdir,
             ffmpeg,
-            logger,
             sessions: HashMap::new(),
             stream_stats: HashMap::new(),
             exit_statuses: HashMap::new(),
@@ -107,7 +101,11 @@ impl StateManager {
         let first_tag = if let Some(x) = profile_chain.first() {
             x.tag()
         } else {
-            error!(self.logger, "Supplied profile chain is empty"; "profile" => format!("{:?}", profile_args));
+            tracing::error!(
+                "Supplied profile chain is empty {}",
+                profile = format!("{:?}", profile_args)
+            );
+
             return Err(NightfallError::ProfileChainExhausted);
         };
 
@@ -137,8 +135,8 @@ impl StateManager {
         };
 
         info!(
-            self.logger,
-            "New session {} map {} -> {}", &session_id, profile_args.input_ctx.stream, tag
+            "New session {} map {} -> {}",
+            &session_id, profile_args.input_ctx.stream, tag
         );
 
         profile_args.output_ctx.outdir = format!("{}/{}", &self.outdir, session_id);
@@ -150,7 +148,12 @@ impl StateManager {
             .unwrap_or(false)
             && profile_chain.len() == 1;
 
-        info!(self.logger, "Session {} chain {}", &session_id, chain; "direct_play" => is_direct_play);
+        info!(
+            "Session {} chain {} {}",
+            &session_id,
+            chain,
+            direct_play = is_direct_play
+        );
 
         let new_session = Session::new(
             session_id.clone(),
@@ -176,10 +179,7 @@ impl StateManager {
         if let Some(status) = session.exit_status.take() {
             if !status.success() {
                 if let Some(x) = session.next_profile() {
-                    info!(
-                        self.logger,
-                        "Session {} chunk={} trying profile {}", &id, chunk, x
-                    );
+                    info!("Session {} chunk={} trying profile {}", &id, chunk, x);
                     session.reset_to(session.start_num());
                 } else {
                     return Err(NightfallError::ProfileChainExhausted);
@@ -253,16 +253,12 @@ impl StateManager {
                 stats.last_hard_seek = Instant::now();
                 stats.hard_seeked_at = chunk;
 
-                debug!(
-                    self.logger,
-                    "Resetting {} to chunk {} because user seeked.", &id, chunk
-                );
+                debug!("Resetting {} to chunk {} because user seeked.", &id, chunk);
             }
 
             Err(NightfallError::ChunkNotDone)
         } else {
             let chunk_path = session.chunk_to_path(chunk);
-            let log = self.logger.clone();
             let path = chunk_path.clone();
             let real_segment = session.real_segment;
 
@@ -272,31 +268,33 @@ impl StateManager {
             }
 
             if !session.is_direct_play {
-                match patch_segment(log, path, real_segment).await {
+                match patch_segment(path, real_segment).await {
                     Ok(seq) => session.real_segment = seq,
                     // Sometimes we get partial chunks, when playback goes linearly (no hard seeks have
                     // occured) we can ignore this, but when the user seeks, the player doesnt query
                     // `init.mp4` again, so we have to move the video data from `init.mp4` into
                     // `N.m4s`.
                     Err(NightfallError::PartialSegment(_)) => {
                         if session.chunks_since_init >= 1 {
-                            debug!(self.logger, "Got a partial segment, patching because the user has most likely seeked.");
+                            debug!( "Got a partial segment, patching because the user has most likely seeked.");
+
                             match patch_init_segment(
-                                self.logger.clone(),
                                 session.init_seg(),
                                 chunk_path.clone(),
                                 real_segment,
                             )
-                                .await
-                                {
-                                    Ok(seq) => session.real_segment = seq,
-                                    Err(e) => {
-                                        warn!(self.logger, "Failed to patch init segment."; "error" => e.to_string())
-                                    }
+                            .await
+                            {
+                                Ok(seq) => session.real_segment = seq,
+                                Err(e) => {
+                                    warn!("Failed to patch init segment. {}", error = e.to_string())
                                 }
+                            }
                         }
                     }
-                    Err(e) => warn!(self.logger, "Failed to patch segment."; "error" => e.to_string()),
+                    Err(e) => {
+                        warn!("Failed to patch segment. {}", error = e.to_string())
+                    }
                 }
             }
 
@@ -325,7 +323,7 @@ impl StateManager {
 
         let stats = self.stream_stats.entry(id).or_default();
 
-        if !session.has_started() || session.is_direct_play{
+        if !session.has_started() || session.is_direct_play {
             return Ok(false);
         }
         // if we are seeking backwards we always want to restart the stream
@@ -356,7 +354,7 @@ impl StateManager {
             .sessions
             .get_mut(&id)
             .ok_or(NightfallError::SessionDoesntExist)?;
-        info!(self.logger, "Killing session {}", id);
+        info!("Killing session {}", id);
         session.join().await;
         session.set_timeout();
 
@@ -369,7 +367,7 @@ impl StateManager {
             .sessions
             .get_mut(&id)
             .ok_or(NightfallError::SessionDoesntExist)?;
-        info!(self.logger, "Killing session {}", id);
+        info!("Killing session {}", id);
         session.join().await;
 
         Ok(())
@@ -427,7 +425,7 @@ impl StateManager {
         };
 
         if !to_reap.is_empty() {
-            info!(self.logger, "Reaping {} streams", to_reap.len());
+            info!("Reaping {} streams", to_reap.len());
         }
 
         for (k, v) in to_reap.iter_mut() {
@@ -446,7 +444,7 @@ impl StateManager {
         }
 
         if cnt != 0 {
-            info!(self.logger, "Paused {} streams", cnt);
+            info!("Paused {} streams", cnt);
         }
 
         Ok(())
diff --git a/src/patch/init_segment.rs b/src/patch/init_segment.rs
@@ -12,7 +12,7 @@ use crate::Result;
 use tokio::task::spawn_blocking;
 
 use mp4::mp4box::*;
-use slog::warn;
+use tracing::warn;
 
 #[derive(Default)]
 pub struct InitSegment {
@@ -24,11 +24,7 @@ pub struct InitSegment {
 }
 
 impl InitSegment {
-    pub fn from_reader(
-        mut reader: impl BufRead + Seek,
-        size: u64,
-        log: slog::Logger,
-    ) -> Result<Self> {
+    pub fn from_reader(mut reader: impl BufRead + Seek, size: u64) -> Result<Self> {
         let mut segment = Self::default();
         let start = reader.seek(SeekFrom::Current(0))?;
 
@@ -69,7 +65,7 @@ impl InitSegment {
                     current_segment.styp = Some(FtypBox::read_box(&mut reader, s)?);
                 }
                 b => {
-                    warn!(log, "Got a weird box type."; "box_type" => b.to_string());
+                    warn!("Got a weird box type. {}", box_type = b.to_string());
                     BoxHeader { name: b, size: s }.write(&mut segment.moov)?;
                     let mut boks = vec![0; (s - 8) as usize];
                     reader.read_exact(boks.as_mut_slice())?;
@@ -113,7 +109,6 @@ impl InitSegment {
 /// * `segment` - Path to the segment
 /// * `seq` - starting sequence number
 pub async fn patch_init_segment(
-    log: slog::Logger,
     init: impl AsRef<Path> + Send + 'static,
     segment_path: impl AsRef<Path> + Send + 'static,
     mut seq: u32,
@@ -123,7 +118,7 @@ pub async fn patch_init_segment(
         let size = f.metadata()?.len();
         let mut reader = BufReader::new(f);
 
-        let mut segment = InitSegment::from_reader(&mut reader, size, log.clone())?;
+        let mut segment = InitSegment::from_reader(&mut reader, size)?;
 
         let mut f = File::create(&segment_path)?;
         while let Some(segment) = segment.segments.pop_front() {
diff --git a/src/patch/segment.rs b/src/patch/segment.rs
@@ -9,10 +9,10 @@ use std::path::Path;
 use crate::NightfallError;
 use crate::Result;
 
-use slog::debug;
 use tokio::task::spawn_blocking;
 
 use mp4::mp4box::*;
+use tracing::debug;
 
 /// Struct represents an individual segment from a stream.
 #[derive(Clone, Default, Debug)]
@@ -39,11 +39,7 @@ impl Segment {
         );
     }
 
-    pub fn from_reader(
-        mut reader: impl BufRead + Seek,
-        size: u64,
-        log: slog::Logger,
-    ) -> Result<(Self, u64)> {
+    pub fn from_reader(mut reader: impl BufRead + Seek, size: u64) -> Result<(Self, u64)> {
         let start = reader.seek(SeekFrom::Current(0))?;
 
         let mut current = start;
@@ -74,7 +70,7 @@ impl Segment {
                     segment.styp = Some(styp);
                 }
                 b => {
-                    debug!(log, "Got a weird box type."; "box_type" => b.to_string());
+                    debug!("Got a weird box type. {}", box_type = b.to_string());
                     skip_box(&mut reader, s)?;
                 }
             }
@@ -166,11 +162,7 @@ impl Segment {
 ///
 /// # Returns
 /// This function will return the index of the current segment.
-pub async fn patch_segment(
-    log: slog::Logger,
-    file: impl AsRef<Path> + Send + 'static,
-    mut seq: u32,
-) -> Result<u32> {
+pub async fn patch_segment(file: impl AsRef<Path> + Send + 'static, mut seq: u32) -> Result<u32> {
     spawn_blocking(move || {
         let f = File::open(&file)?;
         let size = f.metadata()?.len();
@@ -180,7 +172,7 @@ pub async fn patch_segment(
         let mut current = reader.seek(SeekFrom::Current(0))?;
 
         while current < size {
-            let (segment, new_position) = Segment::from_reader(&mut reader, size, log.clone())?;
+            let (segment, new_position) = Segment::from_reader(&mut reader, size)?;
             segments.push_back(segment);
             current = new_position;
         }
diff --git a/src/profiles/mod.rs b/src/profiles/mod.rs
