Share logging level between beets base logger refs

Add BeetsLogger.set_global_level() so the 'beets' logger has the same
level in all threads, which is important for an import session.

beets/logging.py

@@ -114,6 +114,7 @@ class ThreadLocalLevelLogger(Logger):
     """
     def __init__(self, name, level=NOTSET):
         self._thread_level = threading.local()
+        self.default_level = NOTSET
         super(ThreadLocalLevelLogger, self).__init__(name, level)
 
     @property
@@ -121,13 +122,19 @@ class ThreadLocalLevelLogger(Logger):
         try:
             return self._thread_level.level
         except AttributeError:
-            self._thread_level.level = NOTSET
+            self._thread_level.level = self.default_level
             return self.level
 
     @level.setter
     def level(self, value):
         self._thread_level.level = value
 
+    def set_global_level(self, level):
+        """Set the level on the current thread + the default value for all
+        threads.
+        """
+        self.default_level = level
+        self.setLevel(level)
 
 class BeetsLogger(ThreadLocalLevelLogger, StrFormatLogger):
     pass

beets/ui/__init__.py

@@ -974,9 +974,9 @@ def _configure(options):
 
     # Configure the logger.
     if config['verbose'].get(int):
-        log.setLevel(logging.DEBUG)
+        log.set_global_level(logging.DEBUG)
     else:
-        log.setLevel(logging.INFO)
+        log.set_global_level(logging.INFO)
 
     # Ensure compatibility with old (top-level) color configuration.
     # Deprecation msg to motivate user to switch to config['ui']['color].

test/test_logging.py

@@ -167,7 +167,6 @@ class ConcurrentEventsTest(TestCase, helper.TestHelper):
     class DummyPlugin(plugins.BeetsPlugin):
         def __init__(self, test_case):
             plugins.BeetsPlugin.__init__(self, 'dummy')
-            # self.import_stages = [self.import_stage]
             self.register_listener('dummy_event1', self.listener1)
             self.register_listener('dummy_event2', self.listener2)
             self.lock1 = threading.Lock()
@@ -190,7 +189,7 @@ class ConcurrentEventsTest(TestCase, helper.TestHelper):
             self.test_case.assertEqual(self._log.level, log.DEBUG)
 
     def setUp(self):
-        self.setup_beets()
+        self.setup_beets(disk=True)
 
     def tearDown(self):
         self.teardown_beets()
@@ -233,6 +232,31 @@ class ConcurrentEventsTest(TestCase, helper.TestHelper):
             print("Alive threads:", threading.enumerate())
             raise
 
+    def test_root_logger_levels(self):
+        """Root logger level should be shared between threads.
+        """
+        self.config['threaded'] = True
+
+        blog.getLogger('beets').set_global_level(blog.WARNING)
+        with helper.capture_log() as logs:
+            importer = self.create_importer()
+            importer.run()
+        self.assertEqual(logs, [])
+
+        blog.getLogger('beets').set_global_level(blog.INFO)
+        with helper.capture_log() as logs:
+            importer = self.create_importer()
+            importer.run()
+        for l in logs:
+            self.assertIn("import", l)
+            self.assertIn("album", l)
+
+        blog.getLogger('beets').set_global_level(blog.DEBUG)
+        with helper.capture_log() as logs:
+            importer = self.create_importer()
+            importer.run()
+        self.assertIn("Sending event: database_change", logs)
+
 
 def suite():
     return unittest.TestLoader().loadTestsFromName(__name__)