Change the mapping from zLOG to the logging package:

- don't dump everything into the "event" logger;
  use the subsystem argument to zLOG.LOG to get a specific logger
- move some comments into docstrings

src/zLOG/EventLogger.py

@@ -19,8 +19,10 @@ This uses Vinay Sajip's PEP 282 logging module.
 
 __version__='$Revision$'[11:-2]
 
-import os, time
 import logging
+import os
+import time
+
 from BaseLogger import BaseLogger
 from ZConfig.components.logger import loghandler
 from logging import StreamHandler, Formatter
@@ -31,33 +33,18 @@ CUSTOM_TRACE = 5 # Mapping for zLOG.TRACE
 logging.addLevelName("BLATHER", CUSTOM_BLATHER)
 logging.addLevelName("TRACE", CUSTOM_TRACE)
 
-class EventLogger(BaseLogger):
-
-    # Get our logger object:
-    logger = logging.getLogger('event')
-    if not logger.handlers:
-        # Add a null handler to prevent warnings about loggers with no
-        # handlers:
-        logger.addHandler(loghandler.NullHandler())
-
-    def log(self, subsystem, severity, summary, detail, error):
 
+def log_write(subsystem, severity, summary, detail, error):
     level = (zlog_to_pep282_severity_cache_get(severity) or
              zlog_to_pep282_severity(severity))
 
-        msg = "%s %s %s" % (
-            severity_string_cache_get(severity) or severity_string(severity),
-            subsystem,
-            summary)
-
+    msg = summary
     if detail:
         msg = "%s\n%s" % (msg, detail)
 
-        self.logger.log(level, msg, exc_info=(error is not None))
-
-event_logger = EventLogger()
+    logger = logging.getLogger(subsystem)
+    logger.log(level, msg, exc_info=(error is not None))
 
-log_write = event_logger.log
 
 def severity_string(severity, mapping={
     -300: 'TRACE',
@@ -72,10 +59,6 @@ def severity_string(severity, mapping={
     s = mapping.get(int(severity), '')
     return "%s(%s)" % (s, severity)
 
-severity_string_cache = {}
-for _sev in range(-300, 301, 100):
-    severity_string_cache[_sev] = severity_string(_sev)
-severity_string_cache_get = severity_string_cache.get
 
 def zlog_to_pep282_severity(zlog_severity):
     """
@@ -114,14 +97,21 @@ for _sev in range(-300, 301, 100):
     zlog_to_pep282_severity_cache[_sev] = zlog_to_pep282_severity(_sev)
 zlog_to_pep282_severity_cache_get = zlog_to_pep282_severity_cache.get
 
+
 def log_time():
     """Return a simple time string without spaces suitable for logging."""
     return ("%4.4d-%2.2d-%2.2dT%2.2d:%2.2d:%2.2d"
             % time.localtime()[:6])
 
+
 def get_env_severity_info():
-    # EVENT_LOG_SEVERITY is the preferred envvar, but we accept
-    # STUPID_LOG_SEVERITY also
+    """Return the severity setting based on the environment.
+
+    The value returned is a zLOG severity, not a logging package severity.
+
+    EVENT_LOG_SEVERITY is the preferred envvar, but we accept
+    STUPID_LOG_SEVERITY also.
+    """
     eget = os.environ.get
     severity = eget('EVENT_LOG_SEVERITY') or eget('STUPID_LOG_SEVERITY')
     if severity:
@@ -130,6 +120,7 @@ def get_env_severity_info():
         severity = 0 # INFO
     return severity
 
+
 def get_env_syslog_info():
     eget = os.environ.get
     addr = None
@@ -145,30 +136,31 @@ def get_env_syslog_info():
     else:
         return (facility, path)
 
+
 def get_env_file_info():
+    """Return the path of the log file to write to based on the
+    environment.
+
+    EVENT_LOG_FILE is the preferred envvar, but we accept
+    STUPID_LOG_FILE also.
+    """
     eget = os.environ.get
-    # EVENT_LOG_FILE is the preferred envvar, but we accept
-    # STUPID_LOG_FILE also
-    path = eget('EVENT_LOG_FILE')
-    if path is None:
-        path = eget('STUPID_LOG_FILE')
-    if path is None:
-        dest = None
-    else:
-        dest = path
-    return dest
+    return eget('EVENT_LOG_FILE') or eget('STUPID_LOG_FILE')
+
 
 formatters = {
-    'file':    Formatter(fmt='------\n%(asctime)s %(message)s',
+    'file':   Formatter(fmt=('------\n%(asctime)s %(levelname)s %(name)s'
+                             ' %(message)s'),
                         datefmt='%Y-%m-%dT%H:%M:%S'),
-    'syslog':  Formatter(fmt='%(message)s'),
+    'syslog': Formatter(fmt='%(levelname)s %(name)s %(message)s'),
     }
 
 def initialize_from_environment():
     """ Reinitialize the event logger from the environment """
     # clear the current handlers from the event logger
-    for h in event_logger.logger.handlers[:]:
-        event_logger.logger.removeHandler(h)
+    logger = logging.getLogger()
+    for h in logger.handlers[:]:
+        logger.removeHandler(h)
 
     handlers = []
 
@@ -197,9 +189,7 @@ def initialize_from_environment():
 
     severity = get_env_severity_info()
     severity = zlog_to_pep282_severity(severity)
-    event_logger.logger.setLevel(severity)
+    logger.setLevel(severity)
 
     for handler in handlers:
-        event_logger.logger.addHandler(handler)
-
-    event_logger.logger.propagate = 0
+        logger.addHandler(handler)

src/zLOG/datatypes.py

@@ -44,7 +44,6 @@ class EventLogFactory(logger.EventLogFactory):
         for handler in logger.handlers:
             if hasattr(handler, "reopen"):
                 handler.reopen()
-        EventLogger.event_logger.logger = self()
 
     def startup(self):
         zLOG.set_initializer(self.initialize)

src/zLOG/tests/test_logging.py

+##############################################################################
+#
+# Copyright (c) 2004 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""Tests of the integration with the standard logging package."""
+
+import logging
+import unittest
+
+from ZConfig.components.logger.tests.test_logger import LoggingTestBase
+
+import zLOG
+
+from zLOG.EventLogger import log_write
+
+
+class CollectingHandler(logging.Handler):
+
+    def __init__(self):
+        logging.Handler.__init__(self)
+        self.records = []
+
+    def emit(self, record):
+        self.records.append(record)
+
+
+class LoggingIntegrationTestCase(LoggingTestBase):
+
+    def setUp(self):
+        LoggingTestBase.setUp(self)
+        self.handler = CollectingHandler()
+        self.records = self.handler.records
+        self.logger = logging.getLogger()
+        self.logger.addHandler(self.handler)
+
+    def test_log_record(self):
+        #log_write(subsystem, severity, summary, detail, error)
+        log_write("sample.subsystem", zLOG.WARNING, "summary", "detail", None)
+        self.assertEqual(len(self.records), 1)
+        record = self.records[0]
+        self.assertEqual(record.levelno, logging.WARN)
+        self.assertEqual(record.name, "sample.subsystem")
+        # Make sure both the message and the detail information appear
+        # in the text that gets logged:
+        record.msg.index("summary")
+        record.msg.index("detail")
+
+
+def test_suite():
+    return unittest.makeSuite(LoggingIntegrationTestCase)
+
+if __name__ == "__main__":
+    unittest.main(defaultTest="test_suite")

src/zLOG/tests/testzLogConfig.py

@@ -29,7 +29,7 @@ class TestzLOGConfig(unittest.TestCase):
     # the test.  Somewhat surgical; there may be a better way.
 
     def setUp(self):
-        self._old_logger = logging.getLogger("event")
+        self._old_logger = logging.getLogger()
         self._old_level = self._old_logger.level
         self._old_handlers = self._old_logger.handlers[:]
         self._old_logger.handlers[:] = [loghandler.NullHandler()]