deps: smithay + egui update

src/logger/mod.rs

@@ -1,104 +1,16 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
-#[cfg(feature = "debug")]
-use std::{
-    collections::VecDeque,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc, Mutex,
-    },
-};
-
 use anyhow::Result;
 use slog::Drain;
 
-#[cfg(feature = "debug")]
-mod serializer;
-
-#[cfg(feature = "debug")]
-const MAX_RECORDS: usize = 1000;
-
-#[cfg(feature = "debug")]
-pub type LogBuffer = Arc<Mutex<VecDeque<OwnedRecord>>>;
-
-#[cfg(feature = "debug")]
-#[derive(Clone)]
-struct DebugDrain {
-    buffer: LogBuffer,
-    dirty_flag: Arc<AtomicBool>,
-}
-
 pub struct LogState {
     _guard: slog_scope::GlobalLoggerGuard,
-    #[cfg(feature = "debug")]
-    pub dirty_flag: Arc<AtomicBool>,
-    #[cfg(feature = "debug")]
-    pub debug_buffer: LogBuffer,
-}
-
-#[cfg(feature = "debug")]
-pub struct OwnedRecord {
-    pub message: String,
-    pub level: slog::Level,
-    pub kv: serde_json::map::Map<String, serde_json::Value>,
-}
-
-#[cfg(feature = "debug")]
-impl DebugDrain {
-    fn new() -> (DebugDrain, LogBuffer, Arc<AtomicBool>) {
-        let dirty_flag = Arc::new(AtomicBool::new(false));
-        let buffer = Arc::new(Mutex::new(VecDeque::new()));
-        (
-            DebugDrain {
-                buffer: buffer.clone(),
-                dirty_flag: dirty_flag.clone(),
-            },
-            buffer,
-            dirty_flag,
-        )
-    }
-}
-
-#[cfg(feature = "debug")]
-impl Drain for DebugDrain {
-    type Ok = ();
-    type Err = slog::Error;
-
-    fn log(
-        &self,
-        record: &slog::Record<'_>,
-        values: &slog::OwnedKVList,
-    ) -> Result<Self::Ok, Self::Err> {
-        use serde_json::value::{Serializer as ValueSerializer, Value};
-        use serializer::SerdeSerializer;
-        use slog::KV;
-
-        let mut serializer = SerdeSerializer::start(ValueSerializer, None)?;
-        values.serialize(record, &mut serializer)?;
-        record.kv().serialize(record, &mut serializer)?;
-        let value = match serializer.end().map_err(|_| slog::Error::Other)? {
-            Value::Object(map) => map,
-            _ => unreachable!(),
-        };
-
-        let mut buffer = self.buffer.lock().unwrap();
-        buffer.push_front(OwnedRecord {
-            message: format!("{}", record.msg()),
-            level: record.level(),
-            kv: value,
-        });
-        buffer.truncate(MAX_RECORDS);
-        self.dirty_flag.store(true, Ordering::SeqCst);
-
-        Ok(())
-    }
 }
 
 pub fn init_logger() -> Result<LogState> {
     let decorator = slog_term::TermDecorator::new().stderr().build();
     // usually we would not want to use a Mutex here, but this is usefull for a prototype,
     // to make sure we do not miss any in-flight messages, when we crash.
-    #[cfg(not(feature = "debug"))]
     let logger = slog::Logger::root(
         std::sync::Mutex::new(
             slog_term::CompactFormat::new(decorator)
@@ -108,21 +20,6 @@ pub fn init_logger() -> Result<LogState> {
         .fuse(),
         slog::o!(),
     );
-    #[cfg(feature = "debug")]
-    let (debug_drain, debug_buffer, dirty_flag) = DebugDrain::new();
-    #[cfg(feature = "debug")]
-    let logger = slog::Logger::root(
-        slog::Duplicate::new(
-            std::sync::Mutex::new(
-                slog_term::CompactFormat::new(decorator)
-                    .build()
-                    .ignore_res(),
-            ),
-            debug_drain,
-        )
-        .fuse(),
-        slog::o!(),
-    );
 
     let _guard = slog_scope::set_global_logger(logger);
     slog_stdlog::init().unwrap();
@@ -135,11 +32,5 @@ pub fn init_logger() -> Result<LogState> {
         );
     }
 
-    Ok(LogState {
-        _guard,
-        #[cfg(feature = "debug")]
-        debug_buffer,
-        #[cfg(feature = "debug")]
-        dirty_flag,
-    })
+    Ok(LogState { _guard })
 }