gh-84532: Reopen the socket in SocketHandler.send() when sending fails

Lib/logging/handlers.py

@@ -657,15 +657,20 @@ def send(self, s):
  This function allows for partial sends which can happen when the
  network is busy.
  """
- if self.sock is None:
- self.createSocket()
- #self.sock can be None either because we haven't reached the retry
- #time yet, or because we have reached the retry time and retried,
- #but are still unable to connect.
- if self.sock:
+ # Reopen the socket once if sending fails, e.g. the connection was
+ # closed after a timeout, so the record is not lost (gh-84532).
+ for attempt in range(2):
+ if self.sock is None:
+ self.createSocket()
+ # self.sock can be None either because we haven't reached the
+ # retry time yet, or because we have reached the retry time
+ # and retried, but are still unable to connect.
+ if self.sock is None:
+ return
  try:
  self.sock.sendall(s)
- except OSError: #pragma: no cover
+ return
+ except OSError:
  self.sock.close()
  self.sock = None # so we can call createSocket next time
 

Lib/test/test_logging.py

@@ -38,6 +38,7 @@
 import queue
 import random
 import re
+import select
 import shutil
 import socket
 import struct
@@ -1940,6 +1941,44 @@ def test_noserver(self):
  time.sleep(self.sock_hdlr.retryTime - now + 0.001)
  self.root_logger.error('Nor this')
 
+ def test_reconnect(self):
+ # If the server closes the connection, the record whose send fails is
+ # not dropped, but resent on a reopened socket (gh-84532).
+ server = socket.create_server(('localhost', 0))
+ self.addCleanup(server.close)
+ server.settimeout(support.LONG_TIMEOUT)
+ port = server.getsockname()[1]
+ hdlr = logging.handlers.SocketHandler('localhost', port)
+ self.addCleanup(hdlr.close)
+
+ def recv_message():
+ conn, _ = server.accept()
+ self.addCleanup(conn.close)
+ chunk = conn.recv(4)
+ slen = struct.unpack(">L", chunk)[0]
+ chunk = b''
+ while len(chunk) < slen:
+ chunk += conn.recv(slen - len(chunk))
+ return conn, logging.makeLogRecord(pickle.loads(chunk)).msg
+
+ # Connect and receive the first record.
+ hdlr.handle(logging.makeLogRecord({'msg': 'spam'}))
+ conn, msg = recv_message()
+ self.assertEqual(msg, 'spam')
+
+ # Close the connection on the server side. After a peer close the
+ # first send still succeeds (the data is lost when the reset arrives),
+ # so a throwaway send is used up here to make the next send fail.
+ conn.close()
+ # Wait until the close is received, so the sends below are ordered.
+ select.select([hdlr.sock], [], [], support.LONG_TIMEOUT)
+ hdlr.sock.sendall(b'\x00\x00\x00\x00')
+
+ # The next send fails and the record is resent on a new connection.
+ hdlr.handle(logging.makeLogRecord({'msg': 'eggs'}))
+ conn, msg = recv_message()
+ self.assertEqual(msg, 'eggs')
+
 
 @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "Unix sockets required")
 class UnixSocketHandlerTest(SocketHandlerTest):

Misc/NEWS.d/next/Library/2026-07-23-08-46-07.gh-issue-84532.NSN7fJ.rst

@@ -0,0 +1,2 @@
+:class:`logging.handlers.SocketHandler` now loses fewer log records when the
+connection to the server is closed, for example after an idle timeout.