Replace eprintln with tracing (#37)

Author: nhynes

Cargo.lock

@@ -42,6 +42,8 @@ serde_with = "3.16.1"
 tempfile = "3.24.0"
 thiserror = "2.0.9"
 tokio = "1.48.0"
+tracing = "0.1.44"
+tracing-subscriber = { version = "0.3.20", features = ["env-filter"] }
 url = "2.5.7"
 reqwest = { version = "0.13.1", default-features = false, features = ["json", "rustls", "stream"] }
 

Cargo.toml

@@ -19,9 +19,9 @@ miette = { workspace = true, features = ["fancy"] }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
-tracing = "0.1.44"
+tracing = { workspace = true }
 tracing-error = "0.2.1"
-tracing-subscriber = { version = "0.3.20", features = ["env-filter"] }
+tracing-subscriber = { workspace = true }
 url = { workspace = true }
 
 [dev-dependencies]

cli/Cargo.toml

@@ -494,7 +494,7 @@ async fn proxy(args: ProxyArgs) -> Result<()> {
                     println!("registered slot {slot} via router control ({control_endpoint})");
                 }
                 Err(ControlUpdateError::Retryable) => {
-                    eprintln!("waiting for router control at {control_endpoint}...");
+                    tracing::warn!("waiting for router control at {control_endpoint}...");
                     let control_endpoint = control_endpoint.clone();
                     let slot = slot.to_string();
                     let mesh_url = mesh_url.clone();
@@ -505,7 +505,7 @@ async fn proxy(args: ProxyArgs) -> Result<()> {
                     });
                 }
                 Err(ControlUpdateError::Fatal(err)) => {
-                    eprintln!(
+                    tracing::error!(
                         "failed to register slot via router control ({}): {err}\nfallback: set \
                          {env_var}={mesh_url} before starting the scenario",
                         control_endpoint
@@ -557,7 +557,7 @@ async fn resolve_router_identity(
                     ));
                 }
                 if !warned {
-                    eprintln!("waiting for router control at {control_endpoint}...");
+                    tracing::warn!("waiting for router control at {control_endpoint}...");
                     warned = true;
                 }
                 sleep(CONTROL_UPDATE_RETRY_INTERVAL).await;
@@ -985,7 +985,7 @@ async fn register_control_with_retry(
                 sleep(CONTROL_UPDATE_RETRY_INTERVAL).await;
             }
             Err(ControlUpdateError::Fatal(err)) => {
-                eprintln!(
+                tracing::error!(
                     "failed to register slot via router control ({}): {err}\nfallback: set \
                      {env_var}={url} before starting the scenario",
                     endpoint
@@ -1014,7 +1014,7 @@ async fn register_export_with_retry(
                     return Err(ExportRegistrationError::Timeout(timeout));
                 }
                 if !warned {
-                    eprintln!("waiting for router control at {endpoint}...");
+                    tracing::warn!("waiting for router control at {endpoint}...");
                     warned = true;
                 }
                 sleep(CONTROL_UPDATE_RETRY_INTERVAL).await;

cli/src/main.rs

@@ -8,6 +8,8 @@ publish = false
 semver = "1.0.27"
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
 
 [build-dependencies]
 semver = "1.0.27"

images/Cargo.toml

@@ -5,6 +5,7 @@ use std::{
 };
 
 use serde::{Deserialize, Serialize};
+use tracing_subscriber::EnvFilter;
 
 #[path = "../versioning.rs"]
 mod versioning;
@@ -35,6 +36,8 @@ struct ImageVersionTags {
 }
 
 fn main() {
+    init_tracing();
+
     let manifest_path = match env::args().nth(1) {
         Some(path) => PathBuf::from(path),
         None => default_manifest_path(),
@@ -43,7 +46,7 @@ fn main() {
     let manifest = match read_manifest(&manifest_path) {
         Ok(manifest) => manifest,
         Err(err) => {
-            eprintln!("{err}");
+            tracing::error!("{err}");
             process::exit(1);
         }
     };
@@ -55,16 +58,17 @@ fn main() {
         };
         let version = version.trim();
         if version.is_empty() {
-            eprintln!("image {} has an empty version", image.name);
+            tracing::error!("image {} has an empty version", image.name);
             process::exit(1);
         }
 
         let parsed = match versioning::parse_manifest_version(version) {
             Ok(parsed) => parsed,
             Err(err) => {
-                eprintln!(
+                tracing::error!(
                     "image {} has invalid version {}: {err}",
-                    image.name, version
+                    image.name,
+                    version
                 );
                 process::exit(1);
             }
@@ -82,12 +86,21 @@ fn main() {
     match serde_json::to_string(&out) {
         Ok(json) => println!("{json}"),
         Err(err) => {
-            eprintln!("failed to serialize version tag metadata: {err}");
+            tracing::error!("failed to serialize version tag metadata: {err}");
             process::exit(1);
         }
     }
 }
 
+fn init_tracing() {
+    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("warn"));
+    tracing_subscriber::fmt()
+        .with_env_filter(filter)
+        .with_target(false)
+        .without_time()
+        .init();
+}
+
 fn default_manifest_path() -> PathBuf {
     PathBuf::from(env!("CARGO_MANIFEST_DIR"))
         .parent()

images/src/bin/version_tags.rs

@@ -18,6 +18,8 @@ serde_urlencoded = "0.7.1"
 serde_with = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "net", "io-util", "sync", "time", "signal"] }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
 url = { workspace = true }
 
 [dev-dependencies]

runtime/docker-gateway/Cargo.toml

@@ -370,14 +370,14 @@ impl State {
                     }
 
                     if !saw_address {
-                        eprintln!(
+                        tracing::warn!(
                             "docker gateway caller resolution returned no addresses for host {}",
                             caller.host
                         );
                     }
                 }
                 Err(err) => {
-                    eprintln!(
+                    tracing::warn!(
                         "docker gateway caller resolution failed for host {}: {err}",
                         caller.host
                     );
@@ -418,7 +418,7 @@ impl State {
         .await
         .is_err()
         {
-            eprintln!(
+            tracing::warn!(
                 "docker gateway shutdown cleanup timed out after {:?}",
                 SHUTDOWN_CLEANUP_TIMEOUT
             );
@@ -479,7 +479,7 @@ impl State {
         let targets = match parse_targets(&response.body) {
             Ok(value) => value,
             Err(err) => {
-                eprintln!("docker gateway cleanup failed to parse {list_name} list: {err}");
+                tracing::warn!("docker gateway cleanup failed to parse {list_name} list: {err}");
                 return;
             }
         };
@@ -490,7 +490,7 @@ impl State {
                 continue;
             };
             if !is_allowed_cleanup_delete_status(delete_response.status) {
-                eprintln!(
+                tracing::warn!(
                     "docker gateway cleanup failed to delete {item_name} {target}: {}",
                     delete_response.status
                 );
@@ -542,7 +542,7 @@ pub async fn run(config: DockerGatewayConfig) -> Result<(), DockerGatewayError>
                     ShutdownReason::Terminated => {
                         // `docker compose down` sends SIGTERM and also performs its own teardown.
                         // Skipping gateway cleanup avoids duplicate deletes and "No such container" races.
-                        eprintln!(
+                        tracing::warn!(
                             "docker gateway received SIGTERM; skipping shutdown cleanup to avoid \
                              teardown races"
                         );
@@ -554,7 +554,7 @@ pub async fn run(config: DockerGatewayConfig) -> Result<(), DockerGatewayError>
                 let (stream, peer) = match accepted {
                     Ok(value) => value,
                     Err(err) => {
-                        eprintln!("docker gateway accept failed: {err}");
+                        tracing::warn!("docker gateway accept failed: {err}");
                         continue;
                     }
                 };
@@ -582,7 +582,7 @@ pub async fn run(config: DockerGatewayConfig) -> Result<(), DockerGatewayError>
                         .with_upgrades()
                         .await
                     {
-                        eprintln!("docker gateway connection failed: {err}");
+                        tracing::warn!("docker gateway connection failed: {err}");
                     }
                 });
             }
@@ -973,7 +973,7 @@ async fn forward_with_upgrade(
 
     tokio::spawn(async move {
         if let Err(err) = conn.with_upgrades().await {
-            eprintln!("docker upgrade connection failed: {err}");
+            tracing::warn!("docker upgrade connection failed: {err}");
         }
     });
 
@@ -998,19 +998,19 @@ async fn forward_with_upgrade(
 
     tokio::spawn(async move {
         let Ok(down) = on_client.await else {
-            eprintln!("downstream upgrade failed");
+            tracing::warn!("downstream upgrade failed");
             return;
         };
         let Ok(up) = on_upstream.await else {
-            eprintln!("upstream upgrade failed");
+            tracing::warn!("upstream upgrade failed");
             return;
         };
 
         let mut down = TokioIo::new(down);
         let mut up = TokioIo::new(up);
 
         if let Err(err) = tokio::io::copy_bidirectional(&mut down, &mut up).await {
-            eprintln!("upgrade tunnel error: {err}");
+            tracing::warn!("upgrade tunnel error: {err}");
         }
     });
 

runtime/docker-gateway/src/lib.rs

@@ -1,17 +1,29 @@
 use amber_docker_gateway::{DockerGatewayConfig, run};
+use tracing_subscriber::EnvFilter;
 
 #[tokio::main]
 async fn main() {
+    init_tracing();
+
     let config = match DockerGatewayConfig::from_env() {
         Ok(config) => config,
         Err(err) => {
-            eprintln!("docker gateway config error: {err}");
+            tracing::error!("docker gateway config error: {err}");
             std::process::exit(1);
         }
     };
 
     if let Err(err) = run(config).await {
-        eprintln!("docker gateway failed: {err}");
+        tracing::error!("docker gateway failed: {err}");
         std::process::exit(1);
     }
 }
+
+fn init_tracing() {
+    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("warn"));
+    tracing_subscriber::fmt()
+        .with_env_filter(filter)
+        .with_target(false)
+        .without_time()
+        .init();
+}

runtime/docker-gateway/src/main.rs

@@ -13,6 +13,8 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 signal-hook = "0.3.18"
 thiserror = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
 
 [dev-dependencies]
 tempfile = { workspace = true }