clean log!

counterparty-rs/src/indexer/logging.rs

@@ -1,7 +1,7 @@
 use std::{fs::OpenOptions, io, sync::Once};
 
 use colored::{Color, Colorize};
-use tracing::{level_filters::LevelFilter, Event, Level, Subscriber};
+use tracing::{level_filters::LevelFilter, Event, Level, Subscriber, span};
 use tracing_subscriber::{
     fmt::{
         format::Writer,
@@ -10,7 +10,7 @@ use tracing_subscriber::{
         writer::BoxMakeWriter,
         FmtContext, FormatEvent, FormatFields,
     },
-    layer::SubscriberExt,
+    layer::{SubscriberExt, Context},
     registry::LookupSpan,
     Layer, Registry,
 };
@@ -19,6 +19,75 @@ use super::config::Config;
 
 static INIT: Once = Once::new();
 
+// Créons un Layer personnalisé pour filtrer les messages spécifiques
+struct ConnectionPoolFilter<L> {
+    inner: L,
+}
+
+impl<L> ConnectionPoolFilter<L> {
+    fn new(inner: L) -> Self {
+        Self { inner }
+    }
+
+    fn is_connection_pool_message(event: &Event) -> bool {
+        let mut message = String::new();
+        let mut visitor = MessageVisitor(&mut message);
+        event.record(&mut visitor);
+
+        message.contains("take?") ||
+        message.contains("reuse idle connection") ||
+        message.contains("put; add idle connection") ||
+        message.contains("pooling idle connection") ||
+        hmessage.contains("hyper_util")
+    }
+}
+
+// Un simple visiteur pour extraire le message
+struct MessageVisitor<'a>(&'a mut String);
+
+impl<'a> tracing::field::Visit for MessageVisitor<'a> {
+    fn record_debug(&mut self, _field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
+        use std::fmt::Write;
+        let _ = write!(self.0, "{:?}", value);
+    }
+}
+
+impl<S, L> Layer<S> for ConnectionPoolFilter<L>
+where
+    S: Subscriber + for<'a> LookupSpan<'a>,
+    L: Layer<S>,
+{
+    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
+        if !Self::is_connection_pool_message(event) {
+            self.inner.on_event(event, ctx);
+        }
+    }
+
+    fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+        self.inner.on_new_span(attrs, id, ctx)
+    }
+
+    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
+        self.inner.on_record(span, values, ctx)
+    }
+
+    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
+        self.inner.on_follows_from(span, follows, ctx)
+    }
+
+    fn on_close(&self, span: span::Id, ctx: Context<'_, S>) {
+        self.inner.on_close(span, ctx)
+    }
+
+    fn on_enter(&self, span: &span::Id, ctx: Context<'_, S>) {
+        self.inner.on_enter(span, ctx)
+    }
+
+    fn on_exit(&self, span: &span::Id, ctx: Context<'_, S>) {
+        self.inner.on_exit(span, ctx)
+    }
+}
+
 #[allow(clippy::expect_used)]
 pub fn setup_logging(config: &Config) {
     INIT.call_once(|| {
@@ -31,30 +100,35 @@ pub fn setup_logging(config: &Config) {
         let file_writer = BoxMakeWriter::new(file);
         let stderr_writer = BoxMakeWriter::new(io::stderr);
 
-        let file_layer = layer()
-            .json()
-            .with_timer(custom_time_format())
-            .with_writer(file_writer)
-            .with_filter(LevelFilter::TRACE);
+        let file_layer = ConnectionPoolFilter::new(
+            layer()
+                .json()
+                .with_timer(custom_time_format())
+                .with_writer(file_writer)
+                .with_filter(LevelFilter::TRACE)
+        );
 
         let stderr_layer: Box<dyn Layer<_> + Send + Sync> = if config.json_format {
-            Box::new(
+            Box::new(ConnectionPoolFilter::new(
                 layer()
                     .json()
                     .with_timer(custom_time_format())
                     .with_writer(stderr_writer)
-                    .with_filter(LevelFilter::from(config.log_level)),
-            )
+                    .with_filter(LevelFilter::from(config.log_level))
+            ))
         } else {
-            Box::new(
+            Box::new(ConnectionPoolFilter::new(
                 layer()
                     .event_format(new_custom_formatter())
                     .with_writer(stderr_writer)
-                    .with_filter(LevelFilter::from(config.log_level)),
-            )
+                    .with_filter(LevelFilter::from(config.log_level))
+            ))
         };
 
-        let subscriber = Registry::default().with(file_layer).with(stderr_layer);
+        let subscriber = Registry::default()
+            .with(file_layer)
+            .with(stderr_layer);
+
         tracing::subscriber::set_global_default(subscriber)
             .expect("Failed to set global subscriber");
     });
@@ -95,8 +169,9 @@ where
         let metadata = event.metadata();
         write!(
             writer,
-            " - [{}] - RSFetcher - ",
-            format!("{:>8}", metadata.level().to_string()).color(self.get_color(metadata.level()))
+            " - [{}] - {} - ",
+            format!("{:>8}", metadata.level().to_string()).color(self.get_color(metadata.level())),
+            metadata.target()
         )?;
         ctx.field_format().format_fields(writer.by_ref(), event)?;
         writeln!(writer)
@@ -107,4 +182,4 @@ fn new_custom_formatter() -> CustomFormatter {
     CustomFormatter {
         timer: custom_time_format(),
     }
-}
+}