debug: Add forced stderr flush to ensure startup logs are visible

backend/src/main.rs

@@ -16,18 +16,32 @@ use tower_http::{
     trace::TraceLayer,
 };
 use config::Config;
+use std::io::Write;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    eprintln!("NORMOGEN BACKEND STARTING...");
+    // Force flush immediately to ensure we see output
-    eprintln!("Loading environment variables...");
+    let mut stderr = std::io::stderr();
+    writeln!(stderr, "=== NORMOGEN BACKEND STARTING ===")?;
+    stderr.flush()?;
+    
+    writeln!(stderr, "[STARTUP] Loading environment variables...")?;
+    stderr.flush()?;
     
     match dotenv::dotenv() {
-        Ok(path) => eprintln!("Loaded .env from: {:?}", path),
+        Ok(path) => {
-        Err(e) => eprintln!("No .env file found (this is OK in Docker): {}", e),
+            writeln!(stderr, "[STARTUP] Loaded .env from: {:?}", path)?;
+            stderr.flush()?;
+        }
+        Err(e) => {
+            writeln!(stderr, "[STARTUP] No .env file found (this is OK in Docker): {}", e)?;
+            stderr.flush()?;
+        }
     }
     
-    eprintln!("Initializing logging...");
+    writeln!(stderr, "[STARTUP] Initializing logging...")?;
+    stderr.flush()?;
+    
     tracing_subscriber::fmt()
         .with_env_filter(
             tracing_subscriber::EnvFilter::try_from_default_env()
@@ -35,34 +49,52 @@ async fn main() -> anyhow::Result<()> {
         )
         .init();
     
-    eprintln!("Loading configuration...");
+    writeln!(stderr, "[STARTUP] Loading configuration...")?;
+    stderr.flush()?;
+    
     let config = match Config::from_env() {
         Ok(cfg) => {
-            tracing::info!("Configuration loaded successfully");
+            writeln!(stderr, "[STARTUP] Config loaded: DB={}, Port={}", cfg.database.database, cfg.server.port)?;
-            eprintln!("Config loaded: DB={}, Port={}", cfg.database.database, cfg.server.port);
+            stderr.flush()?;
             cfg
         }
         Err(e) => {
-            eprintln!("FATAL: Failed to load configuration: {}", e);
+            writeln!(stderr, "[FATAL] Failed to load configuration: {}", e)?;
+            stderr.flush()?;
             return Err(e);
         }
     };
     
-    tracing::info!("Connecting to MongoDB at {}", config.database.uri);
+    writeln!(stderr, "[STARTUP] Connecting to MongoDB at {}...", config.database.uri)?;
-    eprintln!("Connecting to MongoDB...");
+    stderr.flush()?;
+    
     let db = match db::MongoDb::new(&config.database.uri, &config.database.database).await {
         Ok(db) => {
-            tracing::info!("Connected to MongoDB database: {}", config.database.database);
+            writeln!(stderr, "[STARTUP] MongoDB connection successful!")?;
-            eprintln!("MongoDB connection successful");
+            stderr.flush()?;
             db
         }
         Err(e) => {
-            eprintln!("FATAL: Failed to connect to MongoDB: {}", e);
+            writeln!(stderr, "[FATAL] Failed to connect to MongoDB: {}", e)?;
+            stderr.flush()?;
             return Err(e);
         }
     };
     
-    tracing::info!("MongoDB health check: {}", db.health_check().await?);
+    writeln!(stderr, "[STARTUP] Performing health check...")?;
+    stderr.flush()?;
+    
+    match db.health_check().await {
+        Ok(health) => {
+            writeln!(stderr, "[STARTUP] MongoDB health check: {}", health)?;
+            stderr.flush()?;
+        }
+        Err(e) => {
+            writeln!(stderr, "[FATAL] MongoDB health check failed: {}", e)?;
+            stderr.flush()?;
+            return Err(e);
+        }
+    }
     
     let jwt_service = auth::JwtService::new(config.jwt.clone());
     
@@ -72,7 +104,8 @@ async fn main() -> anyhow::Result<()> {
         config: config.clone(),
     };
     
-    eprintln!("Building router...");
+    writeln!(stderr, "[STARTUP] Building router...")?;
+    stderr.flush()?;
     
     let public_routes = Router::new()
         .route("/health", get(handlers::health_check))
@@ -115,12 +148,17 @@ async fn main() -> anyhow::Result<()> {
     
     let app = public_routes.merge(protected_routes).with_state(app_state);
     
-    eprintln!("Binding to {}:{}...", config.server.host, config.server.port);
+    writeln!(stderr, "[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)?;
+    writeln!(stderr, "[STARTUP] Server ready to accept connections!")?;
+    stderr.flush()?;
+    
     tracing::info!("Server listening on {}:{}", config.server.host, config.server.port);
-    eprintln!("Server is running on http://{}:{}", config.server.host, config.server.port);
     
     axum::serve(listener, app).await?;