chore: add diagnostic eprintln in serve() Event arms and stats_flusher loop heartbeat

Adds eprintln to every match arm in mini_agent::serve() to identify
which task event terminates the supervisor, plus a per-iteration
heartbeat in start_stats_flusher's select loop. Goal: distinguish
"select! is still alive but no arm fires" from "the task was aborted
by a *Died path in serve()".

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Lewis-E

crates/datadog-trace-agent/src/mini_agent.rs

@@ -333,48 +333,68 @@ impl MiniAgent {
 
         let result: Result<(), Box<dyn std::error::Error>> = match event {
             Event::Shutdown => {
+                eprintln!("[diag mini_agent] serve(): Event::Shutdown selected");
                 // The same shutdown_rx fan-out has already fired in each
                 // accept loop concurrently with our select arm here.
                 // Awaiting the transport handles waits for them to drain.
-                if let Some(h) = tcp_handle.as_mut()
-                    && let Err(e) = h.await
-                {
-                    error!("TCP accept loop failed during shutdown: {e:?}");
+                if let Some(h) = tcp_handle.as_mut() {
+                    eprintln!("[diag mini_agent] awaiting tcp_handle drain");
+                    if let Err(e) = h.await {
+                        eprintln!("[diag mini_agent] tcp_handle await Err: {e:?}");
+                        error!("TCP accept loop failed during shutdown: {e:?}");
+                    } else {
+                        eprintln!("[diag mini_agent] tcp_handle drained");
+                    }
                 }
                 #[cfg(all(windows, feature = "windows-pipes"))]
-                if let Some(h) = pipe_handle.as_mut()
-                    && let Err(e) = h.await
-                {
-                    error!("Named pipe accept loop failed during shutdown: {e:?}");
+                if let Some(h) = pipe_handle.as_mut() {
+                    eprintln!("[diag mini_agent] awaiting pipe_handle drain");
+                    if let Err(e) = h.await {
+                        eprintln!("[diag mini_agent] pipe_handle await Err: {e:?}");
+                        error!("Named pipe accept loop failed during shutdown: {e:?}");
+                    } else {
+                        eprintln!("[diag mini_agent] pipe_handle drained");
+                    }
                 }
                 // Now all handlers have written to the channels. Force-flush
                 // the stats flusher.
+                eprintln!("[diag mini_agent] sending flusher_shutdown_tx");
                 let _ = flusher_shutdown_tx.send(());
+                eprintln!("[diag mini_agent] awaiting stats_flusher_handle");
                 match (&mut stats_flusher_handle).await {
-                    Ok(()) => Ok(()),
+                    Ok(()) => {
+                        eprintln!("[diag mini_agent] stats_flusher_handle returned Ok");
+                        Ok(())
+                    }
                     Err(e) => {
+                        eprintln!("[diag mini_agent] stats_flusher_handle returned Err: {e:?}");
                         Err(format!("Stats flusher task failed during shutdown: {e:?}").into())
                     }
                 }
             }
             Event::TcpDied(s) => {
+                eprintln!("[diag mini_agent] Event::TcpDied: {s}");
                 error!("TCP accept loop died: {s}");
                 Err("TCP accept loop terminated unexpectedly".into())
             }
             #[cfg(all(windows, feature = "windows-pipes"))]
             Event::PipeDied(s) => {
+                eprintln!("[diag mini_agent] Event::PipeDied: {s}");
                 error!("Named pipe accept loop died: {s}");
                 Err("Named pipe accept loop terminated unexpectedly".into())
             }
             Event::TraceFlusherDied(s) => {
+                eprintln!("[diag mini_agent] Event::TraceFlusherDied: {s}");
                 error!("Trace flusher task died: {s}");
                 Err("Trace flusher task terminated unexpectedly".into())
             }
             Event::StatsFlusherDied(s) => {
+                eprintln!("[diag mini_agent] Event::StatsFlusherDied: {s}");
                 error!("Stats flusher task died: {s}");
                 Err("Stats flusher task terminated unexpectedly".into())
             }
             Event::ConcentratorDied(s) => {
+                eprintln!("[diag mini_agent] Event::ConcentratorDied: {s}");
                 error!("Stats concentrator service task died: {s}");
                 Err("Stats concentrator service task terminated unexpectedly".into())
             }

crates/datadog-trace-agent/src/stats_flusher.rs

@@ -90,8 +90,11 @@ impl StatsFlusher for ServerlessStatsFlusher {
         let mut interval =
             tokio::time::interval(time::Duration::from_secs(config.stats_flush_interval_secs));
         let mut buffer: Vec<pb::ClientStatsPayload> = Vec::new();
+        let mut iter: u32 = 0;
 
         loop {
+            iter += 1;
+            eprintln!("[diag stats_flusher] loop iter {iter}: awaiting select");
             tokio::select! {
                 // Receive client stats and add them to the buffer
                 Some(stats) = rx.recv() => {