add logger

src/main.rs

@@ -1,3 +1,4 @@
+use anyhow::Context;
 use bollard::container::ListContainersOptions;
 use bollard::Docker;
 
@@ -9,6 +10,8 @@ use std::default::Default;
 
 use tokio::time::{timeout, Instant};
 
+use flexi_logger::{AdaptiveFormat, Logger, LoggerHandle};
+
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -24,6 +27,18 @@ fn get_query_options() -> ListContainersOptions<&'static str> {
     }
 }
 
+fn create_logger() -> anyhow::Result<LoggerHandle> {
+    let logger = Logger::try_with_str("info")
+        .context("default logging level invalid")?
+        .format(flexi_logger::detailed_format)
+        .adaptive_format_for_stdout(AdaptiveFormat::Detailed)
+        .log_to_stdout()
+        .start()
+        .context("can't start logger");
+    log_panics::init();
+    logger
+}
+
 async fn query_containers<T>(
     connection: &Docker,
     query_options: ListContainersOptions<T>,
@@ -55,7 +70,7 @@ async fn query_task(
 ) {
     let query_options = get_query_options();
     let mut query_time = Duration::new(0, 0);
-    println!("start recv");
+    log::debug!("query_task -> start recv");
     while (timeout(interval - query_time, shutdown_rx.recv()).await).is_err() {
         let start = Instant::now();
 
@@ -82,7 +97,7 @@ async fn filter_task(
     while let Some(containers) = in_rx.recv().await {
         let now = Instant::now();
 
-        println!("filter -> found unhealthy: {}", containers.len());
+        log::info!("filter -> found unhealthy: {}", containers.len());
 
         let prev_times = unhealthy_time.take().unwrap();
         let mut new_times: HashMap<String, Instant> = prev_times
@@ -102,7 +117,7 @@ async fn filter_task(
 
         let _ = unhealthy_time.replace(new_times);
 
-        println!("filter -> filtered unhealthy: {}", containers.len());
+        log::info!("filter -> filtered unhealthy: {}", containers.len());
 
         if containers.is_empty() {
             continue;
@@ -116,15 +131,15 @@ async fn filter_task(
 }
 
 async fn restart_task(connection: Arc<Docker>, mut rx: mpsc::Receiver<Containers>) {
-    println!("restart task start");
+    log::debug!("restart task start");
     while let Some(containers) = rx.recv().await {
-        println!("restart -> found: {}", containers.len());
+        log::info!("restart -> found: {}", containers.len());
         for container_id in containers {
-            print!("restart -> container: {}...", &container_id);
+            log::warn!("restart -> container: {}...", &container_id);
             let res = restart_container(&connection, container_id.as_str()).await;
             match res {
-                Ok(_) => println!("ok\n"),
-                Err(e) => println!("error: \n{e:?}\n"),
+                Ok(_) => log::info!("ok\n"),
+                Err(e) => log::error!("error: \n{e:?}\n"),
             }
         }
     }
@@ -132,7 +147,15 @@ async fn restart_task(connection: Arc<Docker>, mut rx: mpsc::Receiver<Containers
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
+    let logger = create_logger()?;
+
     let connection = Arc::new(Docker::connect_with_defaults()?);
+    let _ = connection
+        .as_ref()
+        .ping()
+        .await
+        .context("ping on docker connection")?;
+
     let query_connection = connection.clone();
     let restart_connection = connection.clone();
 
@@ -154,15 +177,14 @@ async fn main() -> anyhow::Result<()> {
         tokio::spawn(filter_task(unhealthy_timeout, filter_rx, filter_tx)),
         tokio::spawn(restart_task(restart_connection, restart_rx)),
         tokio::spawn(async {
-            println!("shutdown -> sleep");
+            log::debug!("shutdown -> sleep");
             tokio::time::sleep(Duration::from_secs(80)).await;
-            println!("shutdown -> drop");
+            log::warn!("shutdown -> drop");
             drop(shutdown_tx);
         })
     )?;
 
-    //let restart = restart_container(&connection, container_id.as_str()).await;
-    //println!("restart: {}", restart.is_ok());
+    drop(logger);
 
     Ok(())
 }