100% coverage for celery.utils.log (97% total)

celery/bin/base.py

@@ -220,7 +220,7 @@ class Command(object):
     #: Set to true if this command doesn't have subcommands
     leaf = True
 
-    # used by :meth:`say_remote_control_reply`.
+    # used by :meth:`say_remote_command_reply`.
     show_body = True
     # used by :meth:`say_chat`.
     show_reply = True

celery/concurrency/eventlet.py

@@ -22,14 +22,14 @@ RACE_MODS = ('billiard.', 'celery.', 'kombu.')
 #: Warn if we couldn't patch early enough,
 #: and thread/socket depending celery modules have already been loaded.
 for mod in (mod for mod in sys.modules if mod.startswith(RACE_MODS)):
-    for side in ('thread', 'threading', 'socket'):
+    for side in ('thread', 'threading', 'socket'):  # pragma: no cover
         if getattr(mod, side, None):
             import warnings
             warnings.warn(RuntimeWarning(W_RACE % side))
 
 
 PATCHED = [0]
-if not EVENTLET_NOPATCH and not PATCHED[0]:
+if not EVENTLET_NOPATCH and not PATCHED[0]:  # pragma: no cover
     PATCHED[0] += 1
     import eventlet
     import eventlet.debug

celery/concurrency/gevent.py

@@ -16,8 +16,8 @@ if not os.environ.get('GEVENT_NOPATCH') and not PATCHED[0]:
     from gevent import monkey, version_info
     monkey.patch_all()
     if version_info[0] == 0:  # pragma: no cover
-        # Signals are not working along gevent in version prior 1.0
-        # and they are not monkey patch by monkey.patch_all()
+        # Signals aren't working in gevent versions <1.0,
+        # and are not monkey patched by patch_all()
         from gevent import signal as _gevent_signal
         _signal = __import__('signal')
         _signal.signal = _gevent_signal

celery/tests/app/test_log.py

@@ -16,6 +16,8 @@ from celery.utils.log import (
     ColorFormatter,
     logger as base_logger,
     get_task_logger,
+    in_sighandler,
+    _patch_logger_class,
 )
 from celery.tests.case import (
     AppCase, Case, override_stdouts, wrap_logger, get_handlers,
@@ -61,6 +63,15 @@ class test_ColorFormatter(Case):
         if sys.version_info[0] == 2:
             self.assertTrue(safe_str.called)
 
+    @patch('logging.Formatter.format')
+    def test_format_object(self, _format):
+        x = ColorFormatter(object())
+        x.use_color = True
+        record = Mock()
+        record.levelname = 'ERROR'
+        record.msg = object()
+        self.assertTrue(x.format(record))
+
     @patch('celery.utils.log.safe_str')
     def test_format_raises(self, safe_str):
         x = ColorFormatter('HELLO')
@@ -231,6 +242,11 @@ class test_default_logger(AppCase):
             p.close()
             self.assertFalse(p.isatty())
 
+            with override_stdouts() as (stdout, stderr):
+                with in_sighandler():
+                    p.write('foo')
+                    self.assertTrue(stderr.getvalue())
+
     def test_logging_proxy_recurse_protection(self):
         logger = self.setup_logger(loglevel=logging.ERROR, logfile=None,
                                    root=False)
@@ -269,6 +285,18 @@ class test_task_logger(test_default_logger):
         return get_task_logger("test_task_logger")
 
 
+class test_patch_logger_cls(Case):
+
+    def test_patches(self):
+        _patch_logger_class()
+        self.assertTrue(logging.getLoggerClass()._signal_safe)
+        _patch_logger_class()
+        self.assertTrue(logging.getLoggerClass()._signal_safe)
+
+        with in_sighandler():
+            logging.getLoggerClass().log(get_logger('test'))
+
+
 class MockLogger(logging.Logger):
     _records = None
 

celery/utils/log.py

@@ -93,10 +93,9 @@ class ColorFormatter(logging.Formatter):
         return r
 
     def format(self, record):
-        levelname = record.levelname
-        color = self.colors.get(levelname)
+        color = self.colors.get(record.levelname)
 
-        if self.use_color and color:
+        if color and self.use_color:
             msg = record.msg
             try:
                 # safe_str will repr the color object
@@ -161,7 +160,7 @@ class LoggingProxy(object):
     def write(self, data):
         """Write message to logging object."""
         if _in_sighandler:
-            print(safe_str(data), file=sys.__stderr__)
+            return print(safe_str(data), file=sys.__stderr__)
         if getattr(self._thread, 'recurse_protection', False):
             # Logger is logging back to this file, so stop recursing.
             return