Added logging and loglevels

Author: tluijken

oxybox/.env

@@ -1,3 +1,4 @@
 CONFIG_FILE="example-config.yml"
 DNS_HOSTS="1.1.1.1, 8.8.8.8"
 MIMIR_ENDPOINT="http://localhost:9009"
+RUST_LOG=info

oxybox/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "oxybox"
-version = "1.0.1"
+version = "1.0.2"
 authors = ["Thomas Luijken"]
 categories = ["command-line-utilities"]
 description = "A drop in replacement for blackbox exporter for Prometheus, with support for TLS and HTTP/3."
@@ -17,7 +17,7 @@ tokio = { version = "1", features = ["full"] }
 reqwest = { version = "0.12", features = ["json",  "rustls-tls", "http3"] }
 native-tls = "0.2"
 tokio-native-tls = "0.3"
-x509-parser = "0.17"
+x509-parser = "0.18"
 url = "2"
 prost = "0.14"
 snap = "1.1"
@@ -32,6 +32,8 @@ unicode-truncate = "2.0"
 openssl = { version = "0.10", features = ["vendored"] }
 serde_yaml = "0.9"
 dotenvy = "0.15"
+env_logger = "0.11"
+log = "0.4"
 
 [build-dependencies]
 prost-build = "0.14"   # Protobuf code generator for Prost

oxybox/src/config/app_config.rs

@@ -1,7 +1,6 @@
 use std::{net::IpAddr, time::Duration};
 use std::env;
 
-use dotenvy::dotenv;
 use tokio_native_tls::TlsConnector as TokioTlsConnector;
 use trust_dns_resolver::{
     TokioAsyncResolver,
@@ -23,8 +22,6 @@ pub struct AppConfig {
 /// It also sets up the DNS hosts and Mimir endpoint.
 pub fn load_config() -> AppConfig {
 
-    dotenv().ok();
-
     let config_file_location =
         env::var("CONFIG_FILE").unwrap_or_else(|_| "config.yml".to_string());
     let config_str = std::fs::read_to_string(&config_file_location)
@@ -38,7 +35,7 @@ pub fn load_config() -> AppConfig {
         .map(|s| s.trim().to_string())
         .collect();
 
-    println!("Using DNS hosts: {:?}", dns_hosts);
+    log::info!("Using DNS hosts: {:?}", dns_hosts);
 
     let mimir_endpoint =
         env::var("MIMIR_ENDPOINT").unwrap_or_else(|_| "http://localhost:9009".to_string());

oxybox/src/http_probe/probe.rs

@@ -116,7 +116,7 @@ async fn get_connect_timings(
             (tls_time, cert_validity_seconds)
         }
         Err(e) => {
-            eprintln!("Failed to establish TLS connection for host {host}: {e}");
+            log::error!("Failed to establish TLS connection for host {host}: {e}");
             return Err(format!(
                 "Failed to establish TLS connection for host {host}: {e}"
             ));
@@ -201,7 +201,7 @@ async fn probe_url(
             )
         }
         Err(e) => {
-            eprintln!("HTTP request failed for URL {url}: {e}");
+            log::error!("HTTP request failed for URL {url}: {e}");
             return Err(format!("HTTP request failed for URL {url}: {e}"));
         }
     };
@@ -323,7 +323,7 @@ async fn handle_target_probe(
                 .unwrap_or(false);
 
             if accepted {
-                println!(
+                log::debug!(
                     "[{padded_tenant}] ✅ URL: {}, Status: {:?}, Elapsed: {:.2}ms, Cert: {}",
                     url,
                     probe.http_status,
@@ -334,20 +334,20 @@ async fn handle_target_probe(
                         .unwrap_or_else(|| "N/A".to_string())
                 );
             } else {
-                println!(
+                log::error!(
                     "[{padded_tenant}] ❌ Unexpected status for {url}: {:?} (accepted: {:?})",
                     probe.http_status, target.accepted_status_codes
                 );
             }
 
             let metrics = create_probe_metrics(&probe, accepted);
             if let Err(e) = send_to_mimir(mimir_target, Some(org_id), metrics).await {
-                println!("[{padded_tenant}] Failed to send metrics for {url}: {e}");
+                log::error!("[{padded_tenant}] Failed to send metrics for {url}: {e}");
             }
         }
         Err(e) => {
             // in case we cannot probe the url, send a failed probe with zeroed metrics
-            println!("[{padded_tenant}] ❌ Probe error for {url}: {e}");
+            log::error!("[{padded_tenant}] ❌ Probe error for {url}: {e}");
             let probe = ProbeResult {
                 url: url.to_string(),
                 dns_time: None,
@@ -362,7 +362,7 @@ async fn handle_target_probe(
             };
             let metrics = create_probe_metrics(&probe, false);
             if let Err(e) = send_to_mimir(mimir_target, Some(org_id), metrics).await {
-                println!("[{padded_tenant}] Failed to send error metrics for {url}: {e}");
+                log::error!("[{padded_tenant}] Failed to send error metrics for {url}: {e}");
             }
         }
     }

oxybox/src/main.rs

@@ -1,5 +1,6 @@
 use std::time::Duration;
 use config::app_config::{load_config, setup_resolver, setup_tls_connector};
+use dotenvy::dotenv;
 use tokio::time::sleep;
 pub mod http_probe;
 use http_probe::probe::run_probe_loop;
@@ -8,11 +9,13 @@ pub mod mimir;
 
 #[tokio::main]
 async fn main() {
+    dotenv().ok();
+    env_logger::init();
     let app_config = load_config();
     let resolver = setup_resolver(&app_config.dns_hosts).expect("Failed to init resolver");
     let tls_connector = setup_tls_connector().expect("Failed to build TLS connector");
 
-    println!("Using Mimir endpoint: {}", app_config.mimir_endpoint);
+    log::info!("Using Mimir endpoint: {}", app_config.mimir_endpoint);
 
     for (key, org_config) in app_config.config {
         let resolver = resolver.clone();

oxybox/src/mimir/client.rs

@@ -26,7 +26,7 @@ pub async fn send_to_mimir(
     metrics: Vec<TimeSeries>,
 ) -> Result<(), Box<dyn std::error::Error>> {
     if metrics.is_empty() {
-        println!("No metrics to send.");
+        log::warn!("No metrics to send.");
         return Ok(());
     }
 
@@ -66,7 +66,7 @@ pub async fn send_to_mimir(
     if !response.status().is_success() {
         let status = response.status();
         let body = response.text().await.unwrap_or_default();
-        eprintln!("Failed to push to Mimir: {} - {}", status, body);
+        log::error!("Failed to push to Mimir: {} - {}", status, body);
         return Err(format!("Failed to push to Mimir: {status} - {body}").into());
     }
     Ok(())
@@ -155,8 +155,8 @@ mod tests {
 
         // Attempt to send
         match send_to_mimir(mimir_url, tenant_id, metrics_to_send).await {
-            Ok(_) => println!("Test metrics sent successfully."),
-            Err(e) => eprintln!("Failed to send test metrics: {}", e),
+            Ok(_) => log::debug!("Test metrics sent successfully."),
+            Err(e) => log::debug!("Failed to send test metrics: {}", e),
         }
 
         assert!(true);