fix: Use println! instead of stderr for reliable Docker logging

backend/src/main.rs

@@ -16,31 +16,23 @@ use tower_http::{
     trace::TraceLayer,
 };
 use config::Config;
-use std::io::Write;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    // Force flush immediately to ensure we see output
+    // Use println! which is more reliable in Docker
-    let mut stderr = std::io::stderr();
+    println!("=== NORMOGEN BACKEND STARTING ===");
-    writeln!(stderr, "=== NORMOGEN BACKEND STARTING ===")?;
+    println!("[STARTUP] Loading environment variables...");
-    stderr.flush()?;
-    
-    writeln!(stderr, "[STARTUP] Loading environment variables...")?;
-    stderr.flush()?;
     
     match dotenv::dotenv() {
         Ok(path) => {
-            writeln!(stderr, "[STARTUP] Loaded .env from: {:?}", path)?;
+            println!("[STARTUP] Loaded .env from: {:?}", path);
-            stderr.flush()?;
         }
         Err(e) => {
-            writeln!(stderr, "[STARTUP] No .env file found (this is OK in Docker): {}", e)?;
+            println!("[STARTUP] No .env file found (this is OK in Docker): {}", e);
-            stderr.flush()?;
         }
     }
     
-    writeln!(stderr, "[STARTUP] Initializing logging...")?;
+    println!("[STARTUP] Initializing logging...");
-    stderr.flush()?;
     
     tracing_subscriber::fmt()
         .with_env_filter(
@@ -49,49 +41,40 @@ async fn main() -> anyhow::Result<()> {
         )
         .init();
     
-    writeln!(stderr, "[STARTUP] Loading configuration...")?;
+    println!("[STARTUP] Loading configuration...");
-    stderr.flush()?;
     
     let config = match Config::from_env() {
         Ok(cfg) => {
-            writeln!(stderr, "[STARTUP] Config loaded: DB={}, Port={}", cfg.database.database, cfg.server.port)?;
+            println!("[STARTUP] Config loaded: DB={}, Port={}", cfg.database.database, cfg.server.port);
-            stderr.flush()?;
             cfg
         }
         Err(e) => {
-            writeln!(stderr, "[FATAL] Failed to load configuration: {}", e)?;
+            println!("[FATAL] Failed to load configuration: {}", e);
-            stderr.flush()?;
             return Err(e);
         }
     };
     
-    writeln!(stderr, "[STARTUP] Connecting to MongoDB at {}...", config.database.uri)?;
+    println!("[STARTUP] Connecting to MongoDB at {}...", config.database.uri);
-    stderr.flush()?;
     
     let db = match db::MongoDb::new(&config.database.uri, &config.database.database).await {
         Ok(db) => {
-            writeln!(stderr, "[STARTUP] MongoDB connection successful!")?;
+            println!("[STARTUP] MongoDB connection successful!");
-            stderr.flush()?;
             db
         }
         Err(e) => {
-            writeln!(stderr, "[FATAL] Failed to connect to MongoDB: {}", e)?;
+            println!("[FATAL] Failed to connect to MongoDB: {}", e);
-            stderr.flush()?;
             return Err(e);
         }
     };
     
-    writeln!(stderr, "[STARTUP] Performing health check...")?;
+    println!("[STARTUP] Performing health check...");
-    stderr.flush()?;
     
     match db.health_check().await {
         Ok(health) => {
-            writeln!(stderr, "[STARTUP] MongoDB health check: {}", health)?;
+            println!("[STARTUP] MongoDB health check: {}", health);
-            stderr.flush()?;
         }
         Err(e) => {
-            writeln!(stderr, "[FATAL] MongoDB health check failed: {}", e)?;
+            println!("[FATAL] MongoDB health check failed: {}", e);
-            stderr.flush()?;
             return Err(e);
         }
     }
@@ -104,8 +87,7 @@ async fn main() -> anyhow::Result<()> {
         config: config.clone(),
     };
     
-    writeln!(stderr, "[STARTUP] Building router...")?;
+    println!("[STARTUP] Building router...");
-    stderr.flush()?;
     
     let public_routes = Router::new()
         .route("/health", get(handlers::health_check))
@@ -148,15 +130,13 @@ async fn main() -> anyhow::Result<()> {
     
     let app = public_routes.merge(protected_routes).with_state(app_state);
     
-    writeln!(stderr, "[STARTUP] Binding to {}:{}...", config.server.host, config.server.port)?;
+    println!("[STARTUP] Binding to {}:{}...", config.server.host, config.server.port);
-    stderr.flush()?;
     
     let listener = tokio::net::TcpListener::bind(&format!("{}:{}", config.server.host, config.server.port))
         .await?;
     
-    writeln!(stderr, "[STARTUP] Server listening on http://{}:{}", config.server.host, config.server.port)?;
+    println!("[STARTUP] Server listening on http://{}:{}", config.server.host, config.server.port);
-    writeln!(stderr, "[STARTUP] Server ready to accept connections!")?;
+    println!("[STARTUP] Server ready to accept connections!");
-    stderr.flush()?;
     
     tracing::info!("Server listening on {}:{}", config.server.host, config.server.port);