Keep logging.handlers eager in config.py

Reverts the lazy alias and the nine logging_handlers.* renames that came
with it. The alias left "handlers" out of vars(logging), which broke the
documented handlers.X spelling in fileConfig() config files, and it was
worth only 0.68 ms of the 6.1 ms win on importing logging.config.

Also drop the two comments that no longer carry their weight, so the io
and ssl hunks disappear from the diff, and trim the new tests.

Author: brittanyrey

Lib/logging/config.py

@@ -28,6 +28,7 @@
 import functools
 import io
 import logging
+import logging.handlers
 import os
 import re
 import threading
@@ -39,7 +40,6 @@
 lazy import socket
 lazy import struct
 lazy from bisect import bisect_left
-lazy from logging import handlers as logging_handlers
 lazy from socketserver import StreamRequestHandler, ThreadingTCPServer
 
 
@@ -82,9 +82,6 @@ def fileConfig(fname, defaults=None, disable_existing_loggers=True, encoding=Non
         except configparser.ParsingError as e:
             raise RuntimeError(f'{fname} is invalid: {e}')
 
-    # the eval()s below resolve "handlers.X" names against vars(logging)
-    _ = logging_handlers
-
     formatters = _create_formatters(cp)
 
     # critical section
@@ -170,7 +167,7 @@ def _install_handlers(cp, formatters):
             h.setLevel(level)
         if len(fmt):
             h.setFormatter(formatters[fmt])
-        if issubclass(klass, logging_handlers.MemoryHandler):
+        if issubclass(klass, logging.handlers.MemoryHandler):
             target = section.get("target", "")
             if len(target): #the target handler may not be loaded yet, so keep for later...
                 fixups.append((h, target))
@@ -764,7 +761,7 @@ def _configure_queue_handler(self, klass, **kwargs):
             q = queue.Queue()  # unbounded
 
         rhl = kwargs.pop('respect_handler_level', False)
-        lklass = kwargs.pop('listener', logging_handlers.QueueListener)
+        lklass = kwargs.pop('listener', logging.handlers.QueueListener)
         handlers = kwargs.pop('handlers', [])
 
         listener = lklass(q, *handlers, respect_handler_level=rhl)
@@ -795,7 +792,7 @@ def configure_handler(self, config):
                 klass = cname
             else:
                 klass = self.resolve(cname)
-            if issubclass(klass, logging_handlers.MemoryHandler):
+            if issubclass(klass, logging.handlers.MemoryHandler):
                 if 'flushLevel' in config:
                     config['flushLevel'] = logging._checkLevel(config['flushLevel'])
                 if 'target' in config:
@@ -809,7 +806,7 @@ def configure_handler(self, config):
                         config['target'] = th
                     except Exception as e:
                         raise ValueError('Unable to set target handler %r' % tn) from e
-            elif issubclass(klass, logging_handlers.QueueHandler):
+            elif issubclass(klass, logging.handlers.QueueHandler):
                 # Another special case for handler which refers to other handlers
                 # if 'handlers' not in config:
                     # raise ValueError('No handlers specified for a QueueHandler')
@@ -831,13 +828,13 @@ def configure_handler(self, config):
                 if 'listener' in config:
                     lspec = config['listener']
                     if isinstance(lspec, type):
-                        if not issubclass(lspec, logging_handlers.QueueListener):
+                        if not issubclass(lspec, logging.handlers.QueueListener):
                             raise TypeError('Invalid listener specifier %r' % lspec)
                     else:
                         if isinstance(lspec, str):
                             listener = self.resolve(lspec)
                             if isinstance(listener, type) and\
-                                not issubclass(listener, logging_handlers.QueueListener):
+                                not issubclass(listener, logging.handlers.QueueListener):
                                 raise TypeError('Invalid listener specifier %r' % lspec)
                         elif isinstance(lspec, dict):
                             if '()' not in lspec:
@@ -861,13 +858,13 @@ def configure_handler(self, config):
                     except Exception as e:
                         raise ValueError('Unable to set required handler %r' % hn) from e
                     config['handlers'] = hlist
-            elif issubclass(klass, logging_handlers.SMTPHandler) and\
+            elif issubclass(klass, logging.handlers.SMTPHandler) and\
                 'mailhost' in config:
                 config['mailhost'] = self.as_tuple(config['mailhost'])
-            elif issubclass(klass, logging_handlers.SysLogHandler) and\
+            elif issubclass(klass, logging.handlers.SysLogHandler) and\
                 'address' in config:
                 config['address'] = self.as_tuple(config['address'])
-            if issubclass(klass, logging_handlers.QueueHandler):
+            if issubclass(klass, logging.handlers.QueueHandler):
                 factory = functools.partial(self._configure_queue_handler, klass)
             else:
                 factory = klass

Lib/logging/handlers.py

@@ -23,7 +23,7 @@
 To use, simply 'import logging.handlers' and log away!
 """
 
-import io  # must stay eager to support finalization
+import io
 import logging
 import os
 import re
@@ -1133,7 +1133,7 @@ def emit(self, record):
             msg.set_content(self.format(record))
             if self.username:
                 if self.secure is not None:
-                    import ssl  # not lazy: breaks getmembers() without _ssl
+                    import ssl
 
                     try:
                         keyfile = self.secure[0]

Lib/test/test_logging.py

@@ -1865,40 +1865,31 @@ def test_defaults_do_no_interpolation(self):
         finally:
             os.unlink(fn)
 
-    def test_names_from_handlers_module(self):
-        # gh-156777: "handlers.X" is evaluated against vars(logging). Use a
-        # subprocess: importing this module already imports logging.handlers.
-        ini = textwrap.dedent("""
+    def test_class_from_handlers_module(self):
+        # gh-156777: "class=handlers.X" is evaluated against vars(logging).
+        # Use a subprocess: this module already imports logging.handlers.
+        ini = textwrap.dedent("""\
             [loggers]
             keys=root
-
             [handlers]
             keys=hand1
-
             [formatters]
-            keys=form1
-
+            keys=
             [logger_root]
             handlers=hand1
-
             [handler_hand1]
             class=handlers.MemoryHandler
-            formatter=form1
             args=(10,)
-
-            [formatter_form1]
-            format=%(levelname)s ++ %(message)s ++ %(port)s
-            defaults={'port': handlers.DEFAULT_TCP_LOGGING_PORT}
-            """).strip()
+            """)
         fd, fn = tempfile.mkstemp(prefix='test_logging_', suffix='.ini')
         self.addCleanup(os.unlink, fn)
         os.write(fd, ini.encode('ascii'))
         os.close(fd)
         code = textwrap.dedent(f"""
             import logging, logging.config
             logging.config.fileConfig({fn!r}, encoding="utf-8")
-            h = logging.getLogger().handlers[0]
-            assert isinstance(h, logging.handlers.MemoryHandler), h
+            assert isinstance(logging.getLogger().handlers[0],
+                              logging.handlers.MemoryHandler)
         """)
         assert_python_ok("-c", code)
 
@@ -5478,30 +5469,25 @@ def test_socket_handler_at_shutdown(self):
         # gh-156777: SocketHandler pickles the record before sending it, and
         # that must keep working when importing no longer can.
         code = textwrap.dedent("""
-            import logging
-            import logging.handlers
-            import os
+            import logging, logging.handlers, os
 
             class Handler(logging.handlers.SocketHandler):
-                # report what emit() did instead of doing network I/O
                 def send(self, s):
-                    os.write(1, b"sent %d bytes" % len(s))
-
+                    os.write(1, b"sent")
                 def handleError(self, record):
-                    os.write(1, b"record dropped")
+                    os.write(1, b"dropped")
 
-            h = Handler('localhost', logging.handlers.DEFAULT_TCP_LOGGING_PORT)
+            h = Handler('localhost', 9020)
             r = logging.LogRecord('n', logging.INFO, 'p', 1, 'msg', None, None)
 
             class A:
-                # the module globals are already cleared when __del__ runs
-                def __del__(self, h=h, r=r):
+                def __del__(self, h=h, r=r):  # globals are cleared by now
                     h.emit(r)
 
             a = A()
         """)
         rc, out, err = assert_python_ok("-c", code)
-        self.assertStartsWith(out.decode(), "sent ")
+        self.assertEqual(out, b"sent")
 
     def test_recursion_error(self):
         # Issue 36272
@@ -7609,8 +7595,8 @@ class LazyImportTest(unittest.TestCase):
     def test_lazy_imports_config(self):
         import_helper.ensure_lazy_imports(
             "logging.config",
-            {"configparser", "json", "logging.handlers", "multiprocessing",
-             "select", "socket", "socketserver", "struct"},
+            {"configparser", "json", "multiprocessing", "select", "socket",
+             "socketserver", "struct"},
             additional_code="logging.config.dictConfig({'version': 1})\n",
         )
 
@@ -7622,25 +7608,20 @@ def test_lazy_imports_handlers(self):
         )
 
     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.
+        # gh-156777: emit() may run when importing no longer works
         code = textwrap.dedent("""
-            import sys
-            import logging.handlers
+            import sys, logging.handlers
             logging.handlers.SocketHandler('localhost', 9020)
-            missing = {'pickle', 'socket', 'struct'} - sys.modules.keys()
-            assert not missing, missing
+            assert {'pickle', 'socket', 'struct'} <= sys.modules.keys()
         """)
         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.
+        # gh-156777: getmembers() resolves lazy imports, so ssl must not be one
         code = textwrap.dedent("""
             import sys
             sys.modules['_ssl'] = None
-            import inspect
-            import logging.handlers
+            import inspect, logging.handlers
             inspect.getmembers(logging.handlers)
         """)
         assert_python_ok("-c", code)