def test_setup_logger_no_handlers_file(self, *args):
tempfile = mktemp(suffix='unittest', prefix='celery')
_open = ('builtins.open'
if sys.version_info[0] == 3 else '__builtin__.open')
with patch(_open) as osopen:
with restore_logging():
files = defaultdict(StringIO)
def open_file(filename, *args, **kwargs):
f = files[filename]
f.fileno = Mock()
f.fileno.return_value = 99
return f
osopen.side_effect = open_file
l = self.get_logger()
l.handlers = []
l = self.setup_logger(
logfile=tempfile,
loglevel=logging.INFO,
root=False,
)
self.assertIsInstance(
get_handlers(l)[0],
logging.FileHandler,
)
self.assertIn(tempfile, files)
def test_process_initializer(self, set_mp_process_title, _signals):
with restore_logging():
from celery import signals
from celery._state import _tls
from celery.concurrency.processes import process_initializer, WORKER_SIGRESET, WORKER_SIGIGNORE
def on_worker_process_init(**kwargs):
on_worker_process_init.called = True
on_worker_process_init.called = False
signals.worker_process_init.connect(on_worker_process_init)
def Loader(*args, **kwargs):
loader = Mock(*args, **kwargs)
loader.conf = {}
loader.override_backends = {}
return loader
with self.Celery(loader=Loader) as app:
app.conf = AttributeDict(DEFAULTS)
process_initializer(app, "awesome.worker.com")
_signals.ignore.assert_any_call(*WORKER_SIGIGNORE)
_signals.reset.assert_any_call(*WORKER_SIGRESET)
self.assertTrue(app.loader.init_worker.call_count)
self.assertTrue(on_worker_process_init.called)
self.assertIs(_tls.current_app, app)
set_mp_process_title.assert_called_with("celeryd", hostname="awesome.worker.com")
with patch("celery.app.trace.setup_worker_optimizations") as S:
os.environ["FORKED_BY_MULTIPROCESSING"] = "1"
try:
process_initializer(app, "luke.worker.com")
S.assert_called_with(app)
finally:
os.environ.pop("FORKED_BY_MULTIPROCESSING", None)
def test_setup_logging_subsystem_misc2(self):
with restore_logging():
self.app.conf.CELERYD_HIJACK_ROOT_LOGGER = True
try:
self.app.log.setup_logging_subsystem()
finally:
self.app.conf.CELERYD_HIJACK_ROOT_LOGGER = False
def test_logging_proxy(self):
with restore_logging():
logger = self.setup_logger(loglevel=logging.ERROR, logfile=None,
root=False)
with wrap_logger(logger) as sio:
p = LoggingProxy(logger, loglevel=logging.ERROR)
p.close()
p.write('foo')
self.assertNotIn('foo', sio.getvalue())
p.closed = False
p.write('foo')
self.assertIn('foo', sio.getvalue())
lines = ['baz', 'xuzzy']
p.writelines(lines)
for line in lines:
self.assertIn(line, sio.getvalue())
p.flush()
p.close()
self.assertFalse(p.isatty())
with override_stdouts() as (stdout, stderr):
with in_sighandler():
p.write('foo')
self.assertTrue(stderr.getvalue())
def test_logs_errors(self, logger, stdout, stderr):
with restore_logging():
b = MockBeat3(
app=self.app, redirect_stdouts=False, socket_timeout=None,
)
b.start_scheduler()
self.assertTrue(logger.critical.called)
def test_setup_logger_no_handlers_file(self):
with restore_logging():
l = self.get_logger()
l.handlers = []
tempfile = mktemp(suffix='unittest', prefix='celery')
l = self.setup_logger(logfile=tempfile, loglevel=0, root=False)
self.assertIsInstance(get_handlers(l)[0], logging.FileHandler)
def test_setup_logging_subsystem_no_mputil(self):
from celery.utils import log as logtools
with restore_logging():
mputil, logtools.mputil = logtools.mputil, None
try:
self.app.log.setup_logging_subsystem()
finally:
logtools.mputil = mputil
def test_setup_logger_no_handlers_file(self):
with restore_logging():
l = self.get_logger()
l.handlers = []
tempfile = mktemp(suffix='unittest', prefix='celery')
l = self.setup_logger(logfile=tempfile, loglevel=0, root=False)
self.assertIsInstance(get_handlers(l)[0],
logging.FileHandler)
def test_logs_errors(self, logger, stdout, stderr):
with restore_logging():
b = MockBeat3(
app=self.app,
redirect_stdouts=False,
socket_timeout=None,
)
b.start_scheduler()
self.assertTrue(logger.critical.called)
def test_evcam(self):
with restore_logging():
evcam(Polaroid, timer=timer, app=self.app)
evcam(Polaroid, timer=timer, loglevel='CRITICAL', app=self.app)
self.MockReceiver.raise_keyboard_interrupt = True
try:
with self.assertRaises(SystemExit):
evcam(Polaroid, timer=timer, app=self.app)
finally:
self.MockReceiver.raise_keyboard_interrupt = False
def test_evcam(self):
with restore_logging():
evcam(Polaroid, timer=timer, app=self.app)
evcam(Polaroid, timer=timer, loglevel='CRITICAL', app=self.app)
self.MockReceiver.raise_keyboard_interrupt = True
try:
with self.assertRaises(SystemExit):
evcam(Polaroid, timer=timer, app=self.app)
finally:
self.MockReceiver.raise_keyboard_interrupt = False
def test_logging_proxy_recurse_protection(self):
with restore_logging():
logger = self.setup_logger(loglevel=logging.ERROR, logfile=None,
root=False)
p = LoggingProxy(logger, loglevel=logging.ERROR)
p._thread.recurse_protection = True
try:
self.assertIsNone(p.write('FOOFO'))
finally:
p._thread.recurse_protection = False
def test_setup_logger_no_handlers_stream(self):
with restore_logging():
l = self.get_logger()
l.handlers = []
with override_stdouts() as outs:
stdout, stderr = outs
l = self.setup_logger(logfile=sys.stderr,
loglevel=logging.INFO, root=False)
l.info('The quick brown fox...')
self.assertIn('The quick brown fox...', stderr.getvalue())
def test_setup_logger(self):
with restore_logging():
logger = self.setup_logger(loglevel=logging.ERROR, logfile=None,
root=False, colorize=True)
logger.handlers = []
self.app.log.already_setup = False
logger = self.setup_logger(loglevel=logging.ERROR, logfile=None,
root=False, colorize=None)
self.assertIs(
get_handlers(logger)[0].stream, sys.__stderr__,
'setup_logger logs to stderr without logfile argument.',
)
def test_setup_logging(self):
with restore_logging():
try:
# py3k
delattr(sys.stdout, 'logger')
except AttributeError:
pass
b = beatapp.Beat(app=self.app)
b.redirect_stdouts = False
b.app.log.__class__._setup = False
b.setup_logging()
with self.assertRaises(AttributeError):
sys.stdout.logger
def test_setup_logging(self):
with restore_logging():
try:
# py3k
delattr(sys.stdout, 'logger')
except AttributeError:
pass
b = beatapp.Beat(app=self.app)
b.redirect_stdouts = False
b.app.log.__class__._setup = False
b.setup_logging()
with self.assertRaises(AttributeError):
sys.stdout.logger
def test_process_initializer(self, set_mp_process_title, _signals):
with restore_logging():
from celery import signals
from celery._state import _tls
from celery.concurrency.prefork import (
process_initializer,
WORKER_SIGRESET,
WORKER_SIGIGNORE,
)
def on_worker_process_init(**kwargs):
on_worker_process_init.called = True
on_worker_process_init.called = False
signals.worker_process_init.connect(on_worker_process_init)
def Loader(*args, **kwargs):
loader = Mock(*args, **kwargs)
loader.conf = {}
loader.override_backends = {}
return loader
with self.Celery(loader=Loader) as app:
app.conf = AttributeDict(DEFAULTS)
process_initializer(app, 'awesome.worker.com')
_signals.ignore.assert_any_call(*WORKER_SIGIGNORE)
_signals.reset.assert_any_call(*WORKER_SIGRESET)
self.assertTrue(app.loader.init_worker.call_count)
self.assertTrue(on_worker_process_init.called)
self.assertIs(_tls.current_app, app)
set_mp_process_title.assert_called_with(
'celeryd',
hostname='awesome.worker.com',
)
with patch('celery.app.trace.setup_worker_optimizations') as S:
os.environ['FORKED_BY_MULTIPROCESSING'] = "1"
try:
process_initializer(app, 'luke.worker.com')
S.assert_called_with(app, 'luke.worker.com')
finally:
os.environ.pop('FORKED_BY_MULTIPROCESSING', None)
os.environ['CELERY_LOG_FILE'] = 'worker%I.log'
app.log.setup = Mock(name='log_setup')
try:
process_initializer(app, 'luke.worker.com')
finally:
os.environ.pop('CELERY_LOG_FILE', None)
def test_redirect_stdouts(self):
with restore_logging():
logger = self.setup_logger(loglevel=logging.ERROR, logfile=None,
root=False)
try:
with wrap_logger(logger) as sio:
self.app.log.redirect_stdouts_to_logger(
logger, loglevel=logging.ERROR,
)
logger.error('foo')
self.assertIn('foo', sio.getvalue())
self.app.log.redirect_stdouts_to_logger(
logger, stdout=False, stderr=False,
)
finally:
sys.stdout, sys.stderr = sys.__stdout__, sys.__stderr__
def test_process_initializer(self, set_mp_process_title, _signals):
with restore_logging():
from celery import signals
from celery._state import _tls
from celery.concurrency.prefork import (
process_initializer, WORKER_SIGRESET, WORKER_SIGIGNORE,
)
def on_worker_process_init(**kwargs):
on_worker_process_init.called = True
on_worker_process_init.called = False
signals.worker_process_init.connect(on_worker_process_init)
def Loader(*args, **kwargs):
loader = Mock(*args, **kwargs)
loader.conf = {}
loader.override_backends = {}
return loader
with self.Celery(loader=Loader) as app:
app.conf = AttributeDict(DEFAULTS)
process_initializer(app, 'awesome.worker.com')
_signals.ignore.assert_any_call(*WORKER_SIGIGNORE)
_signals.reset.assert_any_call(*WORKER_SIGRESET)
self.assertTrue(app.loader.init_worker.call_count)
self.assertTrue(on_worker_process_init.called)
self.assertIs(_tls.current_app, app)
set_mp_process_title.assert_called_with(
'celeryd', hostname='awesome.worker.com',
)
with patch('celery.app.trace.setup_worker_optimizations') as S:
os.environ['FORKED_BY_MULTIPROCESSING'] = '1'
try:
process_initializer(app, 'luke.worker.com')
S.assert_called_with(app, 'luke.worker.com')
finally:
os.environ.pop('FORKED_BY_MULTIPROCESSING', None)
os.environ['CELERY_LOG_FILE'] = 'worker%I.log'
app.log.setup = Mock(name='log_setup')
try:
process_initializer(app, 'luke.worker.com')
finally:
os.environ.pop('CELERY_LOG_FILE', None)
def test_process_initializer(self, set_mp_process_title, _signals):
with restore_logging():
from celery import Celery
from celery import signals
from celery._state import _tls
from celery.concurrency.processes import process_initializer
from celery.concurrency.processes import (WORKER_SIGRESET,
WORKER_SIGIGNORE)
def on_worker_process_init(**kwargs):
on_worker_process_init.called = True
on_worker_process_init.called = False
signals.worker_process_init.connect(on_worker_process_init)
loader = Mock()
loader.override_backends = {}
app = Celery(loader=loader, set_as_current=False)
app.loader = loader
app.conf = AttributeDict(DEFAULTS)
process_initializer(app, 'awesome.worker.com')
_signals.ignore.assert_any_call(*WORKER_SIGIGNORE)
_signals.reset.assert_any_call(*WORKER_SIGRESET)
self.assertTrue(app.loader.init_worker.call_count)
self.assertTrue(on_worker_process_init.called)
self.assertIs(_tls.current_app, app)
set_mp_process_title.assert_called_with(
'celeryd',
hostname='awesome.worker.com',
)
with patch('celery.app.trace.setup_worker_optimizations') as swo:
os.environ['FORKED_BY_MULTIPROCESSING'] = "1"
try:
process_initializer(app, 'luke.worker.com')
swo.assert_called_with(app)
finally:
os.environ.pop('FORKED_BY_MULTIPROCESSING', None)
def test_process_initializer(self, set_mp_process_title, _signals):
with restore_logging():
from celery import Celery
from celery import signals
from celery._state import _tls
from celery.concurrency.processes import process_initializer
from celery.concurrency.processes import (WORKER_SIGRESET,
WORKER_SIGIGNORE)
def on_worker_process_init(**kwargs):
on_worker_process_init.called = True
on_worker_process_init.called = False
signals.worker_process_init.connect(on_worker_process_init)
loader = Mock()
loader.override_backends = {}
app = Celery(loader=loader, set_as_current=False)
app.loader = loader
app.conf = AttributeDict(DEFAULTS)
process_initializer(app, 'awesome.worker.com')
_signals.ignore.assert_any_call(*WORKER_SIGIGNORE)
_signals.reset.assert_any_call(*WORKER_SIGRESET)
self.assertTrue(app.loader.init_worker.call_count)
self.assertTrue(on_worker_process_init.called)
self.assertIs(_tls.current_app, app)
set_mp_process_title.assert_called_with(
'celeryd', hostname='awesome.worker.com',
)
with patch('celery.app.trace.setup_worker_optimizations') as swo:
os.environ['FORKED_BY_MULTIPROCESSING'] = "1"
try:
process_initializer(app, 'luke.worker.com')
swo.assert_called_with(app)
finally:
os.environ.pop('FORKED_BY_MULTIPROCESSING', None)
def test_setup_logger_no_handlers_file(self, *args):
tempfile = mktemp(suffix='unittest', prefix='celery')
_open = ('builtins.open' if sys.version_info[0] == 3
else '__builtin__.open')
with patch(_open) as osopen:
with restore_logging():
files = defaultdict(StringIO)
def open_file(filename, *args, **kwargs):
f = files[filename]
f.fileno = Mock()
f.fileno.return_value = 99
return f
osopen.side_effect = open_file
l = self.get_logger()
l.handlers = []
l = self.setup_logger(
logfile=tempfile, loglevel=logging.INFO, root=False,
)
self.assertIsInstance(
get_handlers(l)[0], logging.FileHandler,
)
self.assertIn(tempfile, files)
def test_setup_logging_subsystem_no_mputil(self):
from celery.utils import log as logtools
with restore_logging():
with mask_modules('billiard.util'):
self.app.log.setup_logging_subsystem()
def test_setup_logging_subsystem_colorize(self):
with restore_logging():
self.app.log.setup_logging_subsystem(colorize=None)
self.app.log.setup_logging_subsystem(colorize=True)
def test_setup_logging_subsystem_misc2(self):
with restore_logging():
self.app.conf.worker_hijack_root_logger = True
self.app.log.setup_logging_subsystem()
def test_setup_logging_subsystem_no_mputil(self):
with restore_logging():
with mask_modules('billiard.util'):
self.app.log.setup_logging_subsystem()
def test_setup_logging_subsystem_no_mputil(self):
with restore_logging():
with mask_modules('billiard.util'):
self.app.log.setup_logging_subsystem()
def test_setup_logging_subsystem_misc(self):
with restore_logging():
self.app.log.setup_logging_subsystem(loglevel=None)
def test_setup_logging_subsystem_misc2(self):
with restore_logging():
self.app.conf.worker_hijack_root_logger = True
self.app.log.setup_logging_subsystem()
