sidecar: fix resource leak and state corruption in UdpWriter

Address additional bugs in the reconnect logic beyond the initial
thread-safety fix:

1. **Resource leak**: If DatagramChannel.open() succeeds but connect()
   fails, the opened channel is never closed, causing file descriptor
   exhaustion.

2. **State corruption**: If connect() fails after opening the channel,
   this.channel points to an open but unconnected channel. Subsequent
   writes throw NotYetConnectedException (not caught by the
   ClosedChannelException handler), permanently breaking the writer.

3. **Data loss**: Original code dropped data after reconnection even
   if reconnection succeeded.

**Changes:**
- Use local variable in connect() and only assign on success
- Close channel in connect() if connection fails (prevents leak)
- Retry write after successful reconnection (prevents data loss)
- Handle case where another thread already reconnected
- Update test to verify data delivery after reconnection

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <[email protected]>

Author: jzhuge

spectator-reg-sidecar/src/main/java/com/netflix/spectator/sidecar/UdpWriter.java

@@ -44,8 +44,17 @@ final class UdpWriter extends SidecarWriter {
   private void connect() throws IOException {
     synchronized (lock) {
       DatagramChannel newChannel = DatagramChannel.open();
-      newChannel.connect(address);
-      channel = newChannel;
+      try {
+        newChannel.connect(address);
+        channel = newChannel;
+      } catch (Throwable t) {
+        try {
+          newChannel.close();
+        } catch (IOException ignored) {
+          // Suppress close exception during error handling
+        }
+        throw t;
+      }
     }
   }
 
@@ -60,12 +69,26 @@ private void connect() throws IOException {
         if (channel == ch) {
           try {
             connect();
+            // After successful reconnection, retry the write once
+            buffer.rewind();
+            channel.write(buffer);
+            return; // Write succeeded after reconnection
           } catch (IOException ex) {
             LOGGER.warn("channel closed, failed to reconnect", ex);
+            throw ex;
+          }
+        } else {
+          // Another thread reconnected, retry the write once with new channel
+          try {
+            buffer.rewind();
+            channel.write(buffer);
+            return; // Write succeeded with reconnected channel
+          } catch (IOException ex) {
+            LOGGER.warn("failed to write after reconnection by another thread", ex);
+            throw ex;
           }
         }
       }
-      throw e;
     }
   }
 

spectator-reg-sidecar/src/test/java/com/netflix/spectator/sidecar/UdpWriterTest.java

@@ -44,9 +44,11 @@ public void udpReconnectIfClosed() throws IOException {
     try (UdpServer server = new UdpServer()) {
       try (SidecarWriter w = SidecarWriter.create(server.address())) {
         // Used to simulate close from something like an interrupt. The next write
-        // will fail and it should try to reconnect.
+        // will trigger reconnection and retry the write.
         w.close();
         w.write("1");
+        // After reconnection, the write should succeed (retry logic)
+        Assertions.assertEquals("1", server.read());
 
         w.write("2");
         Assertions.assertEquals("2", server.read());