Remove celery.log.emergency_error.

It was a nice idea at the time, but the implementation is just not good
enough. E.g. it doesn't do locking, so there's at least a potential race
condition.

celery/apps/beat.py

@@ -6,7 +6,6 @@ from celery import __version__
 from celery import beat
 from celery import platform
 from celery.app import app_or_default
-from celery.log import emergency_error
 from celery.utils import LOG_LEVELS
 
 STARTUP_INFO_FMT = """
@@ -63,8 +62,7 @@ class Beat(object):
             self.install_sync_handler(beat)
             beat.start()
         except Exception, exc:
-            emergency_error(self.logfile,
-                    "celerybeat raised exception %s: %s\n%s" % (
+            logger.critical("celerybeat raised exception %s: %r\n%s" % (
                             exc.__class__, exc, traceback.format_exc()))
 
     def init_loader(self):

celery/log.py

@@ -185,26 +185,6 @@ get_task_logger = _default_logging.get_task_logger
 redirect_stdouts_to_logger = _default_logging.redirect_stdouts_to_logger
 
 
-def emergency_error(logfile, message):
-    """Emergency error logging, for when there's no standard file
-    descriptors open because the process has been daemonized or for
-    some other reason."""
-    closefh = noop
-    logfile = logfile or sys.__stderr__
-    if hasattr(logfile, "write"):
-        logfh = logfile
-    else:
-        logfh = open(logfile, "a")
-        closefh = logfh.close
-    try:
-        logfh.write("[%(asctime)s: CRITICAL/%(pid)d]: %(message)s\n" % {
-                        "asctime": time.asctime(),
-                        "pid": os.getpid(),
-                        "message": message})
-    finally:
-        closefh()
-
-
 
 class LoggingProxy(object):
     """Forward file object to :class:`logging.Logger` instance.

celery/tests/test_log.py

@@ -15,7 +15,7 @@ except ImportError:
 from carrot.utils import rpartition
 
 from celery import log
-from celery.log import (setup_logger, setup_task_logger, emergency_error,
+from celery.log import (setup_logger, setup_task_logger,
                         get_default_logger, get_task_logger,
                         redirect_stdouts_to_logger, LoggingProxy)
 from celery.tests.utils import override_stdouts, execute_context
@@ -84,12 +84,6 @@ class test_default_logger(unittest.TestCase):
                 "Logger doesn't info when loglevel is ERROR",
                 loglevel=logging.INFO)
 
-    def test_emergency_error(self):
-        sio = StringIO()
-        emergency_error(sio, "Testing emergency error facility")
-        self.assertEqual(rpartition(sio.getvalue(), ":")[2].strip(),
-                             "Testing emergency error facility")
-
     def test_setup_logger_no_handlers_stream(self):
         l = self.get_logger()
         set_handlers(l, [])
@@ -112,26 +106,6 @@ class test_default_logger(unittest.TestCase):
         self.assertIsInstance(get_handlers(l)[0],
                               logging.FileHandler)
 
-    def test_emergency_error_stderr(self):
-        def with_override_stdouts(outs):
-            stdout, stderr = outs
-            emergency_error(None, "The lazy dog crawls under the fast fox")
-            self.assertIn("The lazy dog crawls under the fast fox",
-                          stderr.getvalue())
-
-        context = override_stdouts()
-        execute_context(context, with_override_stdouts)
-
-    def test_emergency_error_file(self):
-        tempfile = mktemp(suffix="unittest", prefix="celery")
-        emergency_error(tempfile, "Vandelay Industries")
-        tempfilefh = open(tempfile, "r")
-        try:
-            self.assertIn("Vandelay Industries", "".join(tempfilefh))
-        finally:
-            tempfilefh.close()
-            os.unlink(tempfile)
-
     def test_redirect_stdouts(self):
         logger = self.setup_logger(loglevel=logging.ERROR, logfile=None,
                                    root=False)