def setup_logging_subsystem(self, loglevel=None, logfile=None,
format=None, colorize=None, **kwargs):
loglevel = loglevel or self.loglevel
format = format or self.format
colorize = self.app.either("CELERYD_LOG_COLOR", colorize)
if self.__class__._setup:
return
try:
mputil._logger = None
except AttributeError:
pass
ensure_process_aware_logger()
logging.Logger.manager.loggerDict.clear()
receivers = signals.setup_logging.send(sender=None,
loglevel=loglevel,
logfile=logfile,
format=format,
colorize=colorize)
if not receivers:
root = logging.getLogger()
mp = mputil.get_logger()
for logger in (root, mp):
self._setup_logger(logger, logfile,
format, colorize, **kwargs)
logger.setLevel(loglevel)
self.__class__._setup = True
return receivers
def setup_logging_subsystem(self, loglevel=None, logfile=None,
format=None, colorize=None, **kwargs):
if Logging._setup:
return
loglevel = loglevel or self.loglevel
format = format or self.format
if colorize is None:
colorize = self.supports_color(logfile)
if mputil and hasattr(mputil, "_logger"):
mputil._logger = None
ensure_process_aware_logger()
receivers = signals.setup_logging.send(sender=None,
loglevel=loglevel, logfile=logfile,
format=format, colorize=colorize)
if not receivers:
root = logging.getLogger()
if self.app.conf.CELERYD_HIJACK_ROOT_LOGGER:
root.handlers = []
mp = mputil.get_logger() if mputil else None
for logger in filter(None, (root, mp)):
self._setup_logger(logger, logfile, format, colorize, **kwargs)
logger.setLevel(loglevel)
signals.after_setup_logger.send(sender=None, logger=logger,
loglevel=loglevel, logfile=logfile,
format=format, colorize=colorize)
Logging._setup = True
return receivers
def setup_logging_subsystem(self, loglevel=None, logfile=None,
format=None, colorize=None, **kwargs):
if Logging._setup:
return
loglevel = loglevel or self.loglevel
format = format or self.format
if colorize is None:
colorize = self.supports_color(logfile)
if mputil:
try:
mputil._logger = None
except AttributeError:
pass
ensure_process_aware_logger()
receivers = signals.setup_logging.send(sender=None,
loglevel=loglevel,
logfile=logfile,
format=format,
colorize=colorize)
if not receivers:
root = logging.getLogger()
if self.app.conf.CELERYD_HIJACK_ROOT_LOGGER:
root.handlers = []
mp = mputil and mputil.get_logger() or None
for logger in (root, mp):
if logger:
self._setup_logger(logger, logfile, format,
colorize, **kwargs)
logger.setLevel(loglevel)
Logging._setup = True
return receivers
def setup_logging_subsystem(self, loglevel=None, logfile=None,
format=None, colorize=None, **kwargs):
if Logging._setup:
return
loglevel = loglevel or self.loglevel
format = format or self.format
if colorize is None:
colorize = self.supports_color(logfile)
if mputil and hasattr(mputil, "_logger"):
mputil._logger = None
ensure_process_aware_logger()
receivers = signals.setup_logging.send(sender=None,
loglevel=loglevel, logfile=logfile,
format=format, colorize=colorize)
if not receivers:
root = logging.getLogger()
if self.app.conf.CELERYD_HIJACK_ROOT_LOGGER:
root.handlers = []
mp = mputil.get_logger() if mputil else None
for logger in filter(None, (root, mp)):
self._setup_logger(logger, logfile, format, colorize, **kwargs)
logger.setLevel(loglevel)
Logging._setup = True
return receivers
def setup_logging_subsystem(loglevel=conf.CELERYD_LOG_LEVEL, logfile=None,
format=conf.CELERYD_LOG_FORMAT, colorize=conf.CELERYD_LOG_COLOR,
**kwargs):
global _setup
if not _setup:
try:
mputil._logger = None
except AttributeError:
pass
ensure_process_aware_logger()
logging.Logger.manager.loggerDict.clear()
receivers = signals.setup_logging.send(sender=None,
loglevel=loglevel,
logfile=logfile,
format=format,
colorize=colorize)
if not receivers:
root = logging.getLogger()
if conf.CELERYD_HIJACK_ROOT_LOGGER:
root.handlers = []
mp = mputil.get_logger()
for logger in (root, mp):
_setup_logger(logger, logfile, format, colorize, **kwargs)
logger.setLevel(loglevel)
_setup = True
return receivers
def setup_logging_subsystem(loglevel=conf.CELERYD_LOG_LEVEL,
logfile=None,
format=conf.CELERYD_LOG_FORMAT,
colorize=conf.CELERYD_LOG_COLOR,
**kwargs):
global _setup
if not _setup:
try:
mputil._logger = None
except AttributeError:
pass
ensure_process_aware_logger()
logging.Logger.manager.loggerDict.clear()
receivers = signals.setup_logging.send(sender=None,
loglevel=loglevel,
logfile=logfile,
format=format,
colorize=colorize)
if not receivers:
root = logging.getLogger()
if conf.CELERYD_HIJACK_ROOT_LOGGER:
root.handlers = []
mp = mputil.get_logger()
for logger in (root, mp):
_setup_logger(logger, logfile, format, colorize, **kwargs)
logger.setLevel(loglevel)
_setup = True
return receivers
def _hijack_multiprocessing_logger():
from multiprocessing import util as mputil
global _hijacked
if _hijacked:
return mputil.get_logger()
ensure_process_aware_logger()
logging.Logger.manager.loggerDict.clear()
try:
if mputil._logger is not None:
mputil.logger = None
except AttributeError:
pass
_hijacked = True
return mputil.get_logger()
def _hijack_multiprocessing_logger():
from multiprocessing import util as mputil
global _hijacked
if _hijacked:
return mputil.get_logger()
ensure_process_aware_logger()
logging.Logger.manager.loggerDict.clear()
try:
if mputil._logger is not None:
mputil.logger = None
except AttributeError:
pass
_hijacked = True
return mputil.get_logger()
def setup_logging_subsystem(loglevel=conf.CELERYD_LOG_LEVEL, logfile=None,
format=conf.CELERYD_LOG_FORMAT, colorize=conf.CELERYD_LOG_COLOR,
**kwargs):
global _setup
if not _setup:
ensure_process_aware_logger()
logging.Logger.manager.loggerDict.clear()
from multiprocessing import util as mputil
try:
if mputil._logger is not None:
mputil.logger = None
except AttributeError:
pass
receivers = signals.setup_logging.send(sender=None,
loglevel=loglevel,
logfile=logfile,
format=format,
colorize=colorize)
if not receivers:
root = logging.getLogger()
_setup_logger(root, logfile, format, colorize, **kwargs)
root.setLevel(loglevel)
_setup = True
return receivers
from celery import Celery
from celery import platforms
from celery import signals
from celery import current_app
from celery.apps import worker as cd
from celery.bin.celeryd import WorkerCommand, windows_main, \
main as celeryd_main
from celery.exceptions import ImproperlyConfigured
from celery.utils import patch
from celery.tests.compat import catch_warnings
from celery.tests.utils import AppCase, StringIO
patch.ensure_process_aware_logger()
def disable_stdouts(fun):
@wraps(fun)
def disable(*args, **kwargs):
sys.stdout, sys.stderr = StringIO(), StringIO()
try:
return fun(*args, **kwargs)
finally:
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
return disable
def get_task_logger(loglevel=None):
ensure_process_aware_logger()
logger = logging.getLogger("celery.Task")
if loglevel is not None:
logger.setLevel(loglevel)
return logger
from multiprocessing import get_logger, current_process
from StringIO import StringIO
from celery import conf
from celery import platform
from celery import signals
from celery.bin import celeryd as cd
from celery.exceptions import ImproperlyConfigured
from celery.utils import patch
from celery.utils.functional import wraps
from celery.tests.compat import catch_warnings
from celery.tests.utils import execute_context
patch.ensure_process_aware_logger()
def disable_stdouts(fun):
@wraps(fun)
def disable(*args, **kwargs):
sys.stdout, sys.stderr = StringIO(), StringIO()
try:
return fun(*args, **kwargs)
finally:
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
return disable
def get_task_logger(loglevel=None, name=None):
ensure_process_aware_logger()
logger = logging.getLogger(name or "celery.task.default")
if loglevel is not None:
logger.setLevel(loglevel)
return logger
from nose import SkipTest
from celery import Celery
from celery import platforms
from celery import signals
from celery import current_app
from celery.apps import worker as cd
from celery.bin.celeryd import WorkerCommand, main as celeryd_main
from celery.exceptions import ImproperlyConfigured, SystemTerminate
from celery.tests.utils import AppCase, WhateverIO, mask_modules, reset_modules, skip_unless_module
from celery.utils.patch import ensure_process_aware_logger
ensure_process_aware_logger()
def disable_stdouts(fun):
@wraps(fun)
def disable(*args, **kwargs):
sys.stdout, sys.stderr = WhateverIO(), WhateverIO()
try:
return fun(*args, **kwargs)
finally:
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
return disable
from celery import Celery
from celery import platforms
from celery import signals
from celery import current_app
from celery.apps import worker as cd
from celery.bin.celeryd import WorkerCommand, windows_main, \
main as celeryd_main
from celery.exceptions import ImproperlyConfigured
from celery.tests.compat import catch_warnings
from celery.tests.utils import (AppCase, StringIO, mask_modules, reset_modules,
skip_unless_module)
from celery.utils.patch import ensure_process_aware_logger
ensure_process_aware_logger()
def disable_stdouts(fun):
@wraps(fun)
def disable(*args, **kwargs):
sys.stdout, sys.stderr = StringIO(), StringIO()
try:
return fun(*args, **kwargs)
finally:
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
return disable
def get_task_logger(loglevel=None, name=None):
ensure_process_aware_logger()
logger = logging.getLogger(name or "celery.task.default")
if loglevel is not None:
logger.setLevel(loglevel)
return logger
