Implement a log handler using notifier

Change-Id: Iccac043d46a733e965b3310bbbe9c7d6c07a46ac
Blueprint: logging-and-notification

doc/source/notifier.rst

@@ -6,3 +6,6 @@ Notifier
 
 .. autoclass:: Notifier
    :members:
+
+.. autoclass:: LoggingNotificationHandler
+   :members:

oslo/messaging/notify/__init__.py

@@ -13,6 +13,8 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-__all__ = ['Notifier']
+__all__ = ['Notifier',
+           'LoggingNotificationHandler']
 
 from .notifier import *
+from .logger import *

oslo/messaging/notify/logger.py

@@ -0,0 +1,82 @@
+# Copyright 2013 eNovance
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+"""
+Driver for the Python logging package that sends log records as a notification.
+"""
+import logging
+
+from oslo.config import cfg
+
+from oslo.messaging.notify import notifier
+from oslo.messaging import transport
+
+
+class LoggingNotificationHandler(logging.Handler):
+    """Handler for logging to the messaging notification system.
+
+    Each time the application logs a message using the :py:mod:`logging`
+    module, it will be sent as a notification. The severity used for the
+    notification will be the same as the one used for the log record.
+
+    This can be used into a Python logging configuration this way::
+
+      [handler_notifier]
+      class=oslo.messaging.LoggingNotificationHandler
+      level=ERROR
+      args=('qpid:///')
+
+    """
+
+    CONF = cfg.CONF
+    """Default configuration object used, subclass this class if you want to
+    use another one.
+
+    """
+
+    def __init__(self, url, publisher_id=None, driver=None,
+                 topic=None, serializer=None):
+        self.notifier = notifier.Notifier(
+            transport.get_transport(self.CONF, url),
+            publisher_id, driver,
+            topic,
+            serializer() if serializer else None)
+        logging.Handler.__init__(self)
+
+    def emit(self, record):
+        """Emit the log record to the messaging notification system.
+
+        :param record: A log record to emit.
+
+        """
+        method = getattr(self.notifier, record.levelname.lower(), None)
+
+        if not method:
+            return
+
+        method(None,
+               'logrecord',
+               {
+                   'name': record.name,
+                   'levelno': record.levelno,
+                   'levelname': record.levelname,
+                   'exc_info': record.exc_info,
+                   'pathname': record.pathname,
+                   'lineno': record.lineno,
+                   'msg': record.getMessage(),
+                   'funcName': record.funcName,
+                   'thread': record.thread,
+                   'processName': record.processName,
+                   'process': record.process,
+                   'extra': getattr(record, 'extra', None),
+               })

test-requirements.txt

@@ -6,6 +6,7 @@ hacking>=0.8.0,<0.9
 
 discover
 fixtures>=0.3.14
+mock>=1.0
 mox>=0.5.3
 python-subunit
 testrepository>=0.0.17

tests/test_notifier_logger.py

@@ -0,0 +1,142 @@
+# Copyright 2013 eNovance
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import logging
+import logging.config
+import os
+
+import mock
+import testscenarios
+import testtools
+
+from oslo import messaging
+from oslo.messaging.openstack.common import timeutils
+from tests import test_notifier
+from tests import utils as test_utils
+
+
+load_tests = testscenarios.load_tests_apply_scenarios
+
+# Stolen from openstack.common.logging
+logging.AUDIT = logging.INFO + 1
+logging.addLevelName(logging.AUDIT, 'AUDIT')
+
+
+class TestLogNotifier(test_utils.BaseTestCase):
+
+    scenarios = [
+        ('debug', dict(priority='debug')),
+        ('info', dict(priority='info')),
+        ('warning', dict(priority='warning', queue='WARN')),
+        ('warn', dict(priority='warn')),
+        ('error', dict(priority='error')),
+        ('critical', dict(priority='critical')),
+        ('audit', dict(priority='audit')),
+    ]
+
+    def setUp(self):
+        super(TestLogNotifier, self).setUp()
+        self.addCleanup(timeutils.clear_time_override)
+        self.addCleanup(messaging.notify._impl_test.reset)
+        self.config(notification_driver=['test'])
+
+    def test_logger(self):
+        with mock.patch('oslo.messaging.transport.get_transport',
+                        return_value=test_notifier._FakeTransport(self.conf)):
+            self.logger = messaging.LoggingNotificationHandler('test://')
+
+        timeutils.set_time_override()
+
+        levelno = getattr(logging, self.priority.upper(), 42)
+
+        record = logging.LogRecord('foo',
+                                   levelno,
+                                   '/foo/bar',
+                                   42,
+                                   'Something happened',
+                                   None,
+                                   None)
+
+        self.logger.emit(record)
+
+        n = messaging.notify._impl_test.NOTIFICATIONS[0][1]
+        self.assertEqual(n['priority'],
+                         getattr(self, 'queue', self.priority.upper()))
+        self.assertEqual(n['event_type'], 'logrecord')
+        self.assertEqual(n['timestamp'], str(timeutils.utcnow.override_time))
+        self.assertEqual(n['publisher_id'], None)
+        self.assertEqual(
+            n['payload'],
+            {'process': os.getpid(),
+             'funcName': None,
+             'name': 'foo',
+             'thread': logging.thread.get_ident() if logging.thread else None,
+             'levelno': levelno,
+             'processName': 'MainProcess',
+             'pathname': '/foo/bar',
+             'lineno': 42,
+             'msg': 'Something happened',
+             'exc_info': None,
+             'levelname': logging.getLevelName(levelno),
+             'extra': None})
+
+    @testtools.skipUnless(hasattr(logging.config, 'dictConfig'),
+                          "Need logging.config.dictConfig (Python >= 2.7)")
+    def test_logging_conf(self):
+        with mock.patch('oslo.messaging.transport.get_transport',
+                        return_value=test_notifier._FakeTransport(self.conf)):
+            logging.config.dictConfig({
+                'version': 1,
+                'handlers': {
+                    'notification': {
+                        'class': 'oslo.messaging.LoggingNotificationHandler',
+                        'level': self.priority.upper(),
+                        'url': 'test://',
+                    },
+                },
+                'loggers': {
+                    'default': {
+                        'handlers': ['notification'],
+                        'level': self.priority.upper(),
+                    },
+                },
+            })
+
+        timeutils.set_time_override()
+
+        levelno = getattr(logging, self.priority.upper())
+
+        logger = logging.getLogger('default')
+        logger.log(levelno, 'foobar')
+
+        n = messaging.notify._impl_test.NOTIFICATIONS[0][1]
+        self.assertEqual(n['priority'],
+                         getattr(self, 'queue', self.priority.upper()))
+        self.assertEqual(n['event_type'], 'logrecord')
+        self.assertEqual(n['timestamp'], str(timeutils.utcnow.override_time))
+        self.assertEqual(n['publisher_id'], None)
+        self.assertDictEqual(
+            n['payload'],
+            {'process': os.getpid(),
+             'funcName': 'test_logging_conf',
+             'name': 'default',
+             'thread': logging.thread.get_ident() if logging.thread else None,
+             'levelno': levelno,
+             'processName': 'MainProcess',
+             'pathname': __file__[:-1],  # Remove the 'c' of .pyc
+             'lineno': 121,
+             'msg': 'foobar',
+             'exc_info': None,
+             'levelname': logging.getLevelName(levelno),
+             'extra': None})