def test_message(self, logger):
"""
A message logged to the given ``LogPublisher`` is converted to an
Eliot log message.
"""
publisher = LogPublisher()
observer = EliotObserver(publisher)
observer.logger = logger
publisher.addObserver(observer)
publisher.msg(b"Hello", b"world")
assertHasMessage(self, logger, TWISTED_LOG_MESSAGE,
dict(error=False, message=u"Hello world"))
def test_message(self, logger):
"""
A message logged to the given ``LogPublisher`` is converted to an
Eliot log message.
"""
publisher = LogPublisher()
observer = EliotObserver(publisher)
observer.logger = logger
publisher.addObserver(observer)
publisher.msg(b"Hello", b"world")
assertHasMessage(self, logger, TWISTED_LOG_MESSAGE,
dict(error=False, message=u"Hello world"))
def test_error(self, logger):
"""
An error logged to the given ``LogPublisher`` is converted to an Eliot
log message.
"""
publisher = LogPublisher()
observer = EliotObserver(publisher)
observer.logger = logger
publisher.addObserver(observer)
# No public API for this unfortunately, so emulate error logging:
publisher.msg(failure=Failure(ZeroDivisionError("onoes")),
why=b"A zero division ono",
isError=True)
message = (u'A zero division ono\nTraceback (most recent call '
u'last):\nFailure: exceptions.ZeroDivisionError: onoes\n')
assertHasMessage(self, logger, TWISTED_LOG_MESSAGE,
dict(error=True, message=message))
def test_error(self, logger):
"""
An error logged to the given ``LogPublisher`` is converted to an Eliot
log message.
"""
publisher = LogPublisher()
observer = EliotObserver(publisher)
observer.logger = logger
publisher.addObserver(observer)
# No public API for this unfortunately, so emulate error logging:
publisher.msg(failure=Failure(ZeroDivisionError("onoes")),
why=b"A zero division ono",
isError=True)
message = (u'A zero division ono\nTraceback (most recent call '
u'last):\nFailure: exceptions.ZeroDivisionError: onoes\n')
assertHasMessage(self, logger, TWISTED_LOG_MESSAGE,
dict(error=True, message=message))
class TestSentryLoggerSerivce(VumiTestCase):
def setUp(self):
import vumi.sentry
self.client = DummySentryClient()
self.patch(vumi.sentry, 'vumi_raven_client', lambda dsn: self.client)
self.logger = LogPublisher()
self.service = SentryLoggerService("http://example.com/",
"test.logger",
"worker-1",
logger=self.logger)
@inlineCallbacks
def test_logging(self):
yield self.service.startService()
self.logger.msg("Hello", logLevel=logging.WARN)
self.assertEqual(self.client.messages, [(("Hello", ), {
'data': {
'level': 30,
'logger': 'test.logger'
},
'tags': {
'worker-id': 'worker-1'
}
})])
del self.client.messages[:]
yield self.service.stopService()
self.logger.msg("Foo", logLevel=logging.WARN)
self.assertEqual(self.client.messages, [])
@inlineCallbacks
def test_stop_not_running(self):
yield self.service.stopService()
self.assertFalse(self.service.running)
@inlineCallbacks
def test_start_stop(self):
self.assertFalse(self.service.registered())
self.assertEqual(self.client.teardowns, 0)
yield self.service.startService()
self.assertTrue(self.service.registered())
yield self.service.stopService()
self.assertFalse(self.service.registered())
self.assertEqual(self.client.teardowns, 1)
class TestSentryLoggerSerivce(VumiTestCase):
def setUp(self):
import vumi.sentry
self.client = DummySentryClient()
self.patch(vumi.sentry, 'vumi_raven_client', lambda dsn: self.client)
self.logger = LogPublisher()
self.service = SentryLoggerService("http://example.com/",
"test.logger",
"worker-1",
logger=self.logger)
@inlineCallbacks
def test_logging(self):
yield self.service.startService()
self.logger.msg("Hello", logLevel=logging.WARN)
self.assertEqual(self.client.messages, [
(("Hello",),
{'data': {'level': 30, 'logger': 'test.logger'},
'tags': {'worker-id': 'worker-1'}})
])
del self.client.messages[:]
yield self.service.stopService()
self.logger.msg("Foo", logLevel=logging.WARN)
self.assertEqual(self.client.messages, [])
@inlineCallbacks
def test_stop_not_running(self):
yield self.service.stopService()
self.assertFalse(self.service.running)
@inlineCallbacks
def test_start_stop(self):
self.assertFalse(self.service.registered())
self.assertEqual(self.client.teardowns, 0)
yield self.service.startService()
self.assertTrue(self.service.registered())
yield self.service.stopService()
self.assertFalse(self.service.registered())
self.assertEqual(self.client.teardowns, 1)
def test_log_legacy(self):
fout = StringIO()
p = LegacyLogPublisher(publishPublisher=LogPublisher(FileLogObserver(fout, formatForSystemd)))
p.msg('msg')
p.msg('msg', system='system')
p.msg('m\ns\ng', logLevel=logging.DEBUG)
self.assertEqual((
"<6>[-] msg\n"
"<6>[system] msg\n"
"<7>[-] m\n"
"<7> s\n"
"<7> g\n"
), fout.getvalue())
def test_log_legacy(self):
fout = StringIO()
p = LegacyLogPublisher(publishPublisher=LogPublisher(
FileLogObserver(fout, formatForSystemd)))
p.msg("msg")
p.msg("msg", system="system")
p.msg("m\ns\ng", logLevel=logging.DEBUG)
self.assertEqual(
("<6>[-] msg\n"
"<6>[system] msg\n"
"<7>[-] m\n"
"<7> s\n"
"<7> g\n"),
fout.getvalue(),
)
class TestOldLogPublisher(unittest.TestCase):
"""
L{OldLogPublisher} constructs old-style log events and then adds the
necessary new-style keys.
"""
def setUp(self):
"""
Create an L{OldLogPublisher} and a log observer to catch its output.
"""
self.events = []
self.old = OldLogPublisher(self.events.append, self.events.append)
def test_simple(self):
"""
Messages with a simple message are translated such that the readable
message remains the same.
"""
self.old.msg("Hello world.")
self.assertEquals(len(self.events), 1)
self.assertEquals(formatEvent(self.events[0]), "Hello world.")
self.assertEquals(self.events[0]['log_level'], LogLevel.info)
def test_errorSetsLevel(self):
"""
Setting the old-style 'isError' key will result in the emitted message
acquiring the 'isError' key.
"""
self.old.msg(isError=True)
self.assertEquals(len(self.events), 1)
self.assertEquals(self.events[0]['log_level'], LogLevel.critical)
def test_oldStyleLogLevel(self):
"""
Setting the old-style 'logLevel' key will result in the emitted message
acquiring the new-style 'log_level' key.
"""
self.old.msg(logLevel=py_logging.WARNING)
self.assertEquals(len(self.events), 1)
self.assertEquals(self.events[0]['log_level'], LogLevel.warn)
class TestJunebugLoggerService(JunebugTestBase):
def setUp(self):
self.patch(junebug.logging_service, 'LogFile', DummyLogFile)
self.logger = LogPublisher()
self.logpath = self.mktemp()
self.service = JunebugLoggerService(
'worker-id', self.logpath, 1000000, 7, logger=self.logger)
def assert_log(self, log, expected):
'''Assert that a log matches what is expected.'''
log = json.loads(log)
timestamp = log.pop('timestamp')
self.assertTrue(isinstance(timestamp, float))
self.assertEqual(log, expected)
@inlineCallbacks
def test_logfile_parameters(self):
'''When the logfile is created, it should be created with the correct
parameters.'''
yield self.service.startService()
logfile = self.service.logfile
self.assertEqual(logfile.worker_id, 'worker-id')
self.assertEqual(logfile.path, self.logpath)
self.assertEqual(logfile.rotateLength, 1000000)
self.assertEqual(logfile.maxRotatedFiles, 7)
@inlineCallbacks
def test_logging(self):
'''The logging service should write logs to the logfile when the
service is running.'''
self.logger.msg("Hello")
self.assertFalse(hasattr(self.service, 'logfile'))
yield self.service.startService()
logfile = self.service.logfile
self.logger.msg("Hello", logLevel=logging.WARN, system='worker-id')
[log] = logfile.logs
self.assert_log(log, {
'level': logging.WARN,
'logger': 'worker-id',
'message': 'Hello',
})
yield self.service.stopService()
self.assertEqual(len(logfile.logs), 1)
self.logger.msg("Foo", logLevel=logging.WARN)
self.assertEqual(len(logfile.logs), 1)
@inlineCallbacks
def test_stop_not_running(self):
'''If stopService is called when the service is not running, there
should be no exceptions raised.'''
yield self.service.stopService()
self.assertFalse(self.service.running)
@inlineCallbacks
def test_start_stop(self):
'''Stopping the service after it has been started should result in
properly closing the logfile.'''
self.assertFalse(self.service.registered())
yield self.service.startService()
self.assertEqual(self.service.logfile.closed_count, 0)
self.assertTrue(self.service.registered())
yield self.service.stopService()
self.assertFalse(self.service.registered())
self.assertEqual(self.service.logfile.closed_count, 1)
def msg(self, *message, **kwargs):
if message and message[0].startswith(
"Unhandled unsolicited response:"):
return
LogPublisher.msg(self, *message, **kwargs)
def msg(self, *message, **kw):
kw.setdefault("location", self.location)
kw.setdefault("transmit", self.transmit)
LogPublisher.msg(self, *message, **kw)
