Resolve SocketHandler's imports at construction, not eagerly

pickle, socket and struct go back to lazy. emit() can run during
finalization, when importing no longer works, so SocketHandler.__init__
resolves them while it still can. Keeping them eager instead gives back
three quarters of the handlers.py import-time win.

Author: brittanyrey

Lib/logging/config.py

@@ -513,8 +513,7 @@ def _is_queue_like_object(obj):
     """Check that *obj* implements the Queue API."""
     if isinstance(obj, (queue.Queue, queue.SimpleQueue)):
         return True
-    # defer importing multiprocessing as much as possible; a lazy import at
-    # module level would still be resolved by getmembers() and pydoc
+    # defer importing multiprocessing as much as possible
     from multiprocessing.queues import Queue as MPQueue
     if isinstance(obj, MPQueue):
         return True

Lib/logging/handlers.py

@@ -26,18 +26,18 @@
 import io  # must stay eager to support finalization
 import logging
 import os
-import pickle
 import re
-import socket
-import struct
 import threading
 import time
 lazy import base64
 lazy import copy
 lazy import email.utils
 lazy import http.client
+lazy import pickle
 lazy import queue
 lazy import smtplib
+lazy import socket
+lazy import struct
 lazy import urllib.parse
 lazy from email.message import EmailMessage
 
@@ -610,6 +610,8 @@ def __init__(self, host, port):
         self.retryStart = 1.0
         self.retryMax = 30.0
         self.retryFactor = 2.0
+        # resolve what emit() needs now: it may run during finalization
+        _ = pickle, socket, struct
 
     def makeSocket(self, timeout=1):
         """

Lib/test/test_logging.py

@@ -1866,10 +1866,8 @@ def test_defaults_do_no_interpolation(self):
             os.unlink(fn)
 
     def test_names_from_handlers_module(self):
-        # gh-156777: "handlers.X" in a class or defaults entry is evaluated
-        # against vars(logging), so logging.handlers must be imported first.
-        # Run it in a subprocess, since importing this module already
-        # imports logging.handlers.
+        # gh-156777: "handlers.X" is evaluated against vars(logging). Use a
+        # subprocess: importing this module already imports logging.handlers.
         ini = textwrap.dedent("""
             [loggers]
             keys=root
@@ -7619,10 +7617,22 @@ def test_lazy_imports_config(self):
     def test_lazy_imports_handlers(self):
         import_helper.ensure_lazy_imports(
             "logging.handlers",
-            {"base64", "copy", "email", "http", "queue", "smtplib", "ssl",
-             "urllib"},
+            {"base64", "copy", "email", "http", "pickle", "queue", "smtplib",
+             "socket", "ssl", "struct", "urllib"},
         )
 
+    def test_socket_handler_resolves_imports_when_created(self):
+        # gh-156777: emit() may run during finalization, when importing no
+        # longer works, so the handler resolves what it needs up front.
+        code = textwrap.dedent("""
+            import sys
+            import logging.handlers
+            logging.handlers.SocketHandler('localhost', 9020)
+            missing = {'pickle', 'socket', 'struct'} - sys.modules.keys()
+            assert not missing, missing
+        """)
+        assert_python_ok("-S", "-c", code)
+
     def test_getmembers_without_ssl(self):
         # gh-156777: getmembers() and pydoc resolve lazy imports, so a module
         # level "lazy import ssl" would break them on a build without _ssl.