Allow file logging config

* Fixes lp904305
* remove module level log functions (getLogger to rule them all)
* Move specific Environment logging to the one place it is used
* Wrap getLogger to return a logger wrapped in a NovaContextAdapter
* Do not overwrite the root logger
* save_and_reraise_exception logs via error for passing exc_info
* Uses CommonConfigOptions for compatability across Openstack Projects
* Prefers CommonConfigOptions over legacy options
* Install a NullHandler on the root logger if configured by FLAGS
* Include example logging config file to mimic Nova defaults

Change-Id: Ie59c3f755c142e2b7dc3b94b4e82e142e157bfac

3 files changed, 31 insertions, 48 deletions

diff --git a/nova/tests/test_log.py b/nova/tests/test_log.py
index 122351ff6..6a4e2b671 100644
--- a/nova/tests/test_log.py
+++ b/nova/tests/test_log.py
@@ -1,4 +1,5 @@
 import cStringIO
+import logging
 
 from nova import context
 from nova import flags
@@ -12,47 +13,42 @@ def _fake_context():
     return context.RequestContext(1, 1)
 
 
-class RootLoggerTestCase(test.TestCase):
+class LoggerTestCase(test.TestCase):
     def setUp(self):
-        super(RootLoggerTestCase, self).setUp()
-        self.log = log.logging.root
-
-    def test_is_nova_instance(self):
-        self.assert_(isinstance(self.log, log.NovaLogger))
-
-    def test_name_is_nova(self):
-        self.assertEqual("nova", self.log.name)
+        super(LoggerTestCase, self).setUp()
+        self.log = log.getLogger()
 
     def test_handlers_have_nova_formatter(self):
         formatters = []
-        for h in self.log.handlers:
+        for h in self.log.logger.handlers:
             f = h.formatter
-            if isinstance(f, log.NovaFormatter):
+            if isinstance(f, log.LegacyNovaFormatter):
                 formatters.append(f)
         self.assert_(formatters)
-        self.assertEqual(len(formatters), len(self.log.handlers))
+        self.assertEqual(len(formatters), len(self.log.logger.handlers))
 
     def test_handles_context_kwarg(self):
         self.log.info("foo", context=_fake_context())
         self.assert_(True)  # didn't raise exception
 
-    def test_module_level_methods_handle_context_arg(self):
-        log.info("foo", context=_fake_context())
-        self.assert_(True)  # didn't raise exception
-
-    def test_module_level_audit_handles_context_arg(self):
-        log.audit("foo", context=_fake_context())
+    def test_audit_handles_context_arg(self):
+        self.log.audit("foo", context=_fake_context())
         self.assert_(True)  # didn't raise exception
 
     def test_will_be_verbose_if_verbose_flag_set(self):
         self.flags(verbose=True)
-        log.reset()
-        self.assertEqual(log.DEBUG, self.log.level)
+        log.setup()
+        self.assertEqual(logging.DEBUG, self.log.logger.getEffectiveLevel())
 
     def test_will_not_be_verbose_if_verbose_flag_not_set(self):
         self.flags(verbose=False)
-        log.reset()
-        self.assertEqual(log.INFO, self.log.level)
+        log.setup()
+        self.assertEqual(logging.INFO, self.log.logger.getEffectiveLevel())
+
+    def test_no_logging_via_module(self):
+        for func in ('critical', 'error', 'exception', 'warning', 'warn',
+                     'info', 'debug', 'log', 'audit'):
+            self.assertRaises(AttributeError, getattr, log, func)
 
 
 class LogHandlerTestCase(test.TestCase):
@@ -84,16 +80,17 @@ class NovaFormatterTestCase(test.TestCase):
                                               "[%(request_id)s]: %(message)s",
                    logging_default_format_string="NOCTXT: %(message)s",
                    logging_debug_format_suffix="--DBG")
-        self.log = log.logging.root
+        self.log = log.getLogger()
         self.stream = cStringIO.StringIO()
-        self.handler = log.StreamHandler(self.stream)
-        self.log.addHandler(self.handler)
-        self.level = self.log.level
-        self.log.setLevel(log.DEBUG)
+        self.handler = logging.StreamHandler(self.stream)
+        self.handler.setFormatter(log.LegacyNovaFormatter())
+        self.log.logger.addHandler(self.handler)
+        self.level = self.log.logger.getEffectiveLevel()
+        self.log.logger.setLevel(logging.DEBUG)
 
     def tearDown(self):
-        self.log.setLevel(self.level)
-        self.log.removeHandler(self.handler)
+        self.log.logger.setLevel(self.level)
+        self.log.logger.removeHandler(self.handler)
         super(NovaFormatterTestCase, self).tearDown()
 
     def test_uncontextualized_log(self):
@@ -118,11 +115,12 @@ class NovaLoggerTestCase(test.TestCase):
         levels.append("nova-test=AUDIT")
         self.flags(default_log_levels=levels,
                    verbose=True)
+        log.setup()
         self.log = log.getLogger('nova-test')
 
     def test_has_level_from_flags(self):
-        self.assertEqual(log.AUDIT, self.log.level)
+        self.assertEqual(logging.AUDIT, self.log.logger.getEffectiveLevel())
 
     def test_child_log_has_level_of_parent_flag(self):
         l = log.getLogger('nova-test.foo')
-        self.assertEqual(log.AUDIT, l.level)
+        self.assertEqual(logging.AUDIT, l.logger.getEffectiveLevel())
diff --git a/nova/tests/test_notifier.py b/nova/tests/test_notifier.py
index b13f203a4..be6c483e2 100644
--- a/nova/tests/test_notifier.py
+++ b/nova/tests/test_notifier.py
@@ -105,7 +105,7 @@ class NotifierTestCase(test.TestCase):
             'nova.notifier.rabbit_notifier')
         self.stubs.Set(nova.flags.FLAGS, 'publish_errors', True)
         LOG = log.getLogger('nova')
-        LOG.setup_from_flags()
+        log.setup()
         msgs = []
 
         def mock_notify(context, topic, data):
diff --git a/nova/tests/test_volume.py b/nova/tests/test_volume.py
index 7d7ed614c..38768fb5e 100644
--- a/nova/tests/test_volume.py
+++ b/nova/tests/test_volume.py
@@ -280,14 +280,11 @@ class DriverTestCase(test.TestCase):
 
         log = logging.getLogger()
         self.stream = cStringIO.StringIO()
-        log.addHandler(logging.StreamHandler(self.stream))
+        log.logger.addHandler(logging.logging.StreamHandler(self.stream))
 
         inst = {}
         self.instance_id = db.instance_create(self.context, inst)['id']
 
-    def tearDown(self):
-        super(DriverTestCase, self).tearDown()
-
     def _attach_volume(self):
         """Attach volumes to an instance. This function also sets
            a fake log message."""
@@ -304,12 +301,6 @@ class VolumeDriverTestCase(DriverTestCase):
     """Test case for VolumeDriver"""
     driver_name = "nova.volume.driver.VolumeDriver"
 
-    def setUp(self):
-        super(VolumeDriverTestCase, self).setUp()
-
-    def tearDown(self):
-        super(VolumeDriverTestCase, self).tearDown()
-
     def test_delete_busy_volume(self):
         """Test deleting a busy volume."""
         self.stubs.Set(self.volume.driver, '_volume_not_present',
@@ -332,12 +323,6 @@ class ISCSITestCase(DriverTestCase):
     """Test Case for ISCSIDriver"""
     driver_name = "nova.volume.driver.ISCSIDriver"
 
-    def setUp(self):
-        super(ISCSITestCase, self).setUp()
-
-    def tearDown(self):
-        super(ISCSITestCase, self).tearDown()
-
     def _attach_volume(self):
         """Attach volumes to an instance. This function also sets
            a fake log message."""