def test_bad_option(self):
cfg_txt = """
[metlog]
sender_class=metlog.senders.DebugCaptureSender
[metlog_plugin_cef]
provider=metlog_cef.cef_plugin:config_plugin
syslog_options=PIDBAD
"""
client_from_text_config(cfg_txt, 'metlog')
def test_bad_option(self):
cfg_txt = """
[metlog]
sender_class=metlog.senders.DebugCaptureSender
[metlog_plugin_cef]
provider=metlog_cef.cef_plugin:config_plugin
syslog_options=PIDBAD
"""
client_from_text_config(cfg_txt, 'metlog')
def test_global_config():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
global_foo = bar
global_multi = one
two
"""
client_from_text_config(cfg_txt, 'metlog')
from metlog.holder import CLIENT_HOLDER
expected = {'foo': 'bar', 'multi': ['one', 'two']}
eq_(expected, CLIENT_HOLDER.global_config)
def test_global_config():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
global_foo = bar
global_multi = one
two
"""
client_from_text_config(cfg_txt, 'metlog')
from metlog.holder import CLIENT_HOLDER
expected = {'foo': 'bar', 'multi': ['one', 'two']}
eq_(expected, CLIENT_HOLDER.global_config)
def setUp(self):
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_cef]
provider=metlog_cef.cef_plugin:config_plugin
"""
###
self.client = client_from_text_config(cfg_txt, 'metlog')
self.environ = {'REMOTE_ADDR': '127.0.0.1', 'HTTP_HOST': '127.0.0.1',
'PATH_INFO': '/', 'REQUEST_METHOD': 'GET',
'HTTP_USER_AGENT': 'MySuperBrowser'}
self.config = {'cef.version': '0', 'cef.vendor': 'mozilla',
'cef.device_version': '3', 'cef.product': 'weave',
'cef': True}
self._warn = []
def _warning(warn):
self._warn.append(warn)
self.old_logger = logger.warning
logger.warning = _warning
def test_plugins_config():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_raven]
net=True
"""
from metlog.config import client_from_text_config
import json
client = client_from_text_config(cfg_txt, 'metlog')
def exception_call2(a, b, c):
return a + b + c / (a-b)
def exception_call1(x, y):
return exception_call2(y, x, 42)
try:
exception_call1(5, 5)
except:
client.raven('some_logger_name', 'Caught an error')
eq_(1, len(client.sender.msgs))
msg = json.loads(client.sender.msgs[0])
assert msg['fields']['culprit'] == 'test_metlog.exception_call2'
assert len(msg['fields']['frames']) == 3
assert msg['logger'] == 'some_logger_name'
assert msg['type'] == 'stacktrace'
def test_filters_config():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_filter_sev_max]
provider = metlog.filters.severity_max_provider
severity = 6
[metlog_filter_type_whitelist]
provider = metlog.filters.type_whitelist_provider
types = foo
bar
baz
"""
client = client_from_text_config(cfg_txt, 'metlog')
eq_(len(client.filters), 2)
severity_max = client.filters[0]
eq_(severity_max.func_name, 'severity_max')
msg = {'severity': 6}
ok_(severity_max(msg))
msg = {'severity': 7}
ok_(not severity_max(msg))
type_whitelist = client.filters[1]
eq_(type_whitelist.func_name, 'type_whitelist')
msg = {'type': 'bar'}
ok_(type_whitelist(msg))
msg = {'type': 'bawlp'}
ok_(not type_whitelist(msg))
def setUp(self):
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_cef]
provider=metlog_cef.cef_plugin:config_plugin
"""
###
self.client = client_from_text_config(cfg_txt, 'metlog')
self.environ = {
'REMOTE_ADDR': '127.0.0.1',
'HTTP_HOST': '127.0.0.1',
'PATH_INFO': '/',
'REQUEST_METHOD': 'GET',
'HTTP_USER_AGENT': 'MySuperBrowser'
}
self.config = {
'cef.version': '0',
'cef.vendor': 'mozilla',
'cef.device_version': '3',
'cef.product': 'weave',
'cef': True
}
self._warn = []
def _warning(warn):
self._warn.append(warn)
self.old_logger = logger.warning
logger.warning = _warning
def test_filters_config():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_filter_sev_max]
provider = metlog.filters.severity_max_provider
severity = 6
[metlog_filter_type_whitelist]
provider = metlog.filters.type_whitelist_provider
types = foo
bar
baz
"""
client = client_from_text_config(cfg_txt, 'metlog')
eq_(len(client.filters), 2)
severity_max = client.filters[0]
eq_(severity_max.func_name, 'severity_max')
msg = {'severity': 6}
ok_(severity_max(msg))
msg = {'severity': 7}
ok_(not severity_max(msg))
type_whitelist = client.filters[1]
eq_(type_whitelist.func_name, 'type_whitelist')
msg = {'type': 'bar'}
ok_(type_whitelist(msg))
msg = {'type': 'bawlp'}
ok_(not type_whitelist(msg))
def test_int_bool_conversions():
cfg_txt = """
[metlog_config]
sender_class = metlog.tests.test_config.MockSender
sender_integer = 123
sender_true1 = True
sender_true2 = t
sender_true3 = Yes
sender_true4 = on
sender_false1 = false
sender_false2 = F
sender_false3 = no
sender_false4 = OFF
"""
client = client_from_text_config(cfg_txt, 'metlog_config')
ok_(isinstance(client.sender, Mock))
MockSender.assert_called_with(integer=123,
true1=True,
true2=True,
true3=True,
true4=True,
false1=False,
false2=False,
false3=False,
false4=False)
def test_simple_config():
cfg_txt = """
[metlog_config]
sender_class = metlog.senders.DebugCaptureSender
"""
client = client_from_text_config(cfg_txt, 'metlog_config')
eq_(client.__class__, MetlogClient)
eq_(client.sender.__class__, DebugCaptureSender)
def test_simple_config():
cfg_txt = """
[metlog_config]
sender_class = metlog.senders.DebugCaptureSender
"""
client = client_from_text_config(cfg_txt, 'metlog_config')
eq_(client.__class__, MetlogClient)
eq_(client.sender.__class__, DebugCaptureSender)
def setUp(self):
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_psutil]
provider=metlog_psutils.psutil_plugin:config_plugin
"""
self.client = client_from_text_config(cfg_txt, 'metlog')
def test_multiline_config():
cfg_txt = """
[metlog_config]
sender_class = metlog.tests.test_config.MockSender
sender_multi = foo
bar
"""
client = client_from_text_config(cfg_txt, 'metlog_config')
ok_(isinstance(client.sender, Mock))
MockSender.assert_called_with(multi=['foo', 'bar'])
def test_multiline_config():
cfg_txt = """
[metlog_config]
sender_class = metlog.tests.test_config.MockSender
sender_multi = foo
bar
"""
client = client_from_text_config(cfg_txt, 'metlog_config')
ok_(isinstance(client.sender, Mock))
MockSender.assert_called_with(multi=['foo', 'bar'])
def setUp(self):
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_procinfo]
provider=metlog_psutils.psutil_plugin:config_plugin
"""
###
self.client = client_from_text_config(cfg_txt, 'metlog')
self.HOST = 'localhost' # Symbolic name meaning the local host
self.PORT = 50007 # Arbitrary non-privileged port
self.MAX_CONNECTIONS = 10
self.wait_for_network_shutdown()
def test_simple_client_use():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_raven]
provider=metlog_raven.raven_plugin:config_plugin
[metlog_plugin_error]
provider=metlog_raven.raven_plugin:config_plugin
override=True
"""
from metlog.config import client_from_text_config
import json
client = client_from_text_config(cfg_txt, 'metlog')
msgs = [json.loads(m) for m in client.sender.msgs]
assert len(msgs) == 0
try:
5 / 0
except:
try:
client.raven()
except:
raise AssertionError()
msgs = [json.loads(m) for m in client.sender.msgs]
assert len(msgs) == 1
client.sender.msgs.clear()
msgs = [json.loads(m) for m in client.sender.msgs]
assert len(msgs) == 0
try:
5 / 0
except:
try:
client.error()
except:
raise AssertionError()
msgs = [json.loads(m) for m in client.sender.msgs]
assert len(msgs) == 1
def test_int_bool_conversions():
cfg_txt = """
[metlog_config]
sender_class = metlog.tests.test_config.MockSender
sender_integer = 123
sender_true1 = True
sender_true2 = t
sender_true3 = Yes
sender_true4 = on
sender_false1 = false
sender_false2 = F
sender_false3 = no
sender_false4 = OFF
"""
client = client_from_text_config(cfg_txt, 'metlog_config')
ok_(isinstance(client.sender, Mock))
MockSender.assert_called_with(integer=123, true1=True, true2=True,
true3=True, true4=True, false1=False,
false2=False, false3=False, false4=False)
def test_plugin_override():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_exception]
override=True
provider=metlog.tests.plugin:config_plugin
"""
client = client_from_text_config(cfg_txt, 'metlog')
eq_('my_plugin', client.exception.__name__)
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_exception]
provider=metlog.tests.plugin:config_plugin
"""
# Failure to set an override argument will throw an exception
assert_raises(SyntaxError, client_from_text_config, cfg_txt, 'metlog')
def test_config(self):
cfg_txt = """
[metlog]
sender_class=metlog.senders.DebugCaptureSender
[metlog_plugin_cef]
provider=metlog_cef.cef_plugin:config_plugin
syslog_options=PID,NDELAY
syslog_facility=KERN
syslog_ident=some_identifier
syslog_priority=EMERG
"""
client = client_from_text_config(cfg_txt, 'metlog')
expected = {'syslog_priority': 'EMERG',
'syslog_ident': 'some_identifier',
'syslog_facility': 'KERN',
'syslog_options': 'PID,NDELAY'}
eq_(client.cef.cef_meta, expected)
def test_handshake_sender_with_backend():
cfg_txt = """
[metlog]
sender_class = metlog.senders.ZmqHandshakePubSender
sender_handshake_bind = tcp://localhost:5180
sender_connect_bind = tcp://localhost:5190
sender_handshake_timeout = 200
sender_hwm = 100
sender_livecheck = 30
"""
import json
import sys # NOQA
# Redirect stderr
with patch('sys.stderr') as mock_stderr:
# Patch the reconnect_clients call so that we don't spawn a
# background thread to bind to a server
with patch('metlog.senders.zmq.Pool.start_reconnecting'):
client = client_from_text_config(cfg_txt, 'metlog')
# Now patch the ZmqHandshakePubSender and replace the pool
# with a mock - this will make sure that all requests to
# obtain a new 0mq socket will just pass so nothing will
# go to stderr
eq_(client.sender.pool._livecheck, 30)
with patch.object(client.sender, 'pool') as mock_pool:
msg = {'milk': 'shake'}
# Note that this JSON dump does *not* have a newline appended
# to it. Only JSON messages to stderr have the newline
expected = json.dumps(msg)
client.send_message(msg)
eq_(mock_stderr.write.call_count, 0)
eq_(mock_stderr.flush.call_count, 0)
# Check that we called send once with the proper JSON
# string to the pool
eq_(mock_pool.send.call_count, 1)
call_args = mock_pool.send.call_args[0]
eq_(call_args[0], expected)
def test_handshake_sender_no_backend():
cfg_txt = """
[metlog]
sender_class = metlog.senders.zmq.ZmqHandshakePubSender
sender_handshake_bind = tcp://localhost:5180
sender_connect_bind = tcp://localhost:5190
sender_handshake_timeout = 200
sender_hwm = 100
"""
msg = {'milk': 'shake'}
expected = "%s\n" % json.dumps(msg)
with patch('sys.stderr') as mock_stderr:
with patch('metlog.senders.zmq.Pool.start_reconnecting'):
client = client_from_text_config(cfg_txt, 'metlog')
client.send_message(msg)
eq_(mock_stderr.write.call_count, 1)
eq_(mock_stderr.flush.call_count, 1)
call_args = mock_stderr.write.call_args[0]
eq_(call_args[0], expected)
def test_handshake_sender_with_backend():
cfg_txt = """
[metlog]
sender_class = metlog.senders.ZmqHandshakePubSender
sender_handshake_bind = tcp://localhost:5180
sender_connect_bind = tcp://localhost:5190
sender_handshake_timeout = 200
sender_hwm = 100
sender_livecheck = 30
"""
import json
import sys # NOQA
# Redirect stderr
with patch('sys.stderr') as mock_stderr:
# Patch the reconnect_clients call so that we don't spawn a
# background thread to bind to a server
with patch('metlog.senders.zmq.Pool.start_reconnecting'):
client = client_from_text_config(cfg_txt, 'metlog')
# Now patch the ZmqHandshakePubSender and replace the pool
# with a mock - this will make sure that all requests to
# obtain a new 0mq socket will just pass so nothing will
# go to stderr
eq_(client.sender.pool._livecheck, 30)
with patch.object(client.sender, 'pool') as mock_pool:
msg = {'milk': 'shake'}
# Note that this JSON dump does *not* have a newline appended
# to it. Only JSON messages to stderr have the newline
expected = json.dumps(msg)
client.send_message(msg)
eq_(mock_stderr.write.call_count, 0)
eq_(mock_stderr.flush.call_count, 0)
# Check that we called send once with the proper JSON
# string to the pool
eq_(mock_pool.send.call_count, 1)
call_args = mock_pool.send.call_args[0]
eq_(call_args[0], expected)
def test_plugin_override():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_exception]
override=True
provider=metlog.tests.plugin:config_plugin
"""
client = client_from_text_config(cfg_txt, 'metlog')
eq_('my_plugin', client.exception.__name__)
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_exception]
provider=metlog.tests.plugin:config_plugin
"""
# Failure to set an override argument will throw an exception
assert_raises(SyntaxError, client_from_text_config, cfg_txt, 'metlog')
def test_plugins_config():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_dummy]
provider=metlog.tests.plugin:config_plugin
verbose=True
foo=bar
some_list = dog
cat
bus
port=8080
host=lolcathost
"""
client = client_from_text_config(cfg_txt, 'metlog')
actual = client.dummy(verbose=True)
expected = {'host': 'lolcathost',
'foo': 'bar', 'some_list': ['dog', 'cat', 'bus'],
'port': 8080}
assert actual == expected
def test_config(self):
cfg_txt = """
[metlog]
sender_class=metlog.senders.DebugCaptureSender
[metlog_plugin_cef]
provider=metlog_cef.cef_plugin:config_plugin
syslog_options=PID,NDELAY
syslog_facility=KERN
syslog_ident=some_identifier
syslog_priority=EMERG
"""
client = client_from_text_config(cfg_txt, 'metlog')
expected = {
'syslog_priority': 'EMERG',
'syslog_ident': 'some_identifier',
'syslog_facility': 'KERN',
'syslog_options': 'PID,NDELAY'
}
eq_(client.cef.cef_meta, expected)
def test_handshake_sender_no_backend():
cfg_txt = """
[metlog]
sender_class = metlog.senders.ZmqHandshakePubSender
sender_handshake_bind = tcp://localhost:5180
sender_connect_bind = tcp://localhost:5190
sender_handshake_timeout = 200
sender_hwm = 100
"""
import json
import sys # NOQA
msg = {'milk': 'shake'}
expected = "%s\n" % json.dumps(msg)
with patch('sys.stderr') as mock_stderr:
with patch('metlog.senders.zmq.Pool.start_reconnecting'):
client = client_from_text_config(cfg_txt, 'metlog')
client.send_message(msg)
eq_(mock_stderr.write.call_count, 1)
eq_(mock_stderr.flush.call_count, 1)
call_args = mock_stderr.write.call_args[0]
eq_(call_args[0], expected)
def test_plugins_config():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_procinfo]
provider=metlog_psutils.psutil_plugin:config_plugin
"""
client = client_from_text_config(cfg_txt, 'metlog')
client.procinfo(cpu=True)
eq_(len(client.sender.msgs), 2)
msgs = [json.loads(m) for m in client.sender.msgs]
for m in msgs:
del m['timestamp']
for m in msgs:
assert m['fields']['logger'].startswith('psutil.cpu')
assert m['fields']['name'] in ('user', 'sys')
assert isinstance(m['payload'], float)
def test_plugins_config():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_raven]
provider=metlog_raven.raven_plugin:config_plugin
"""
from metlog.config import client_from_text_config
import json
client = client_from_text_config(cfg_txt, 'metlog')
def exception_call2(a, b, c):
return a + b + c / (a - b)
def exception_call1(x, y):
return exception_call2(y, x, 42)
try:
exception_call1(5, 5)
except:
client.raven('some message')
eq_(1, len(client.sender.msgs))
msg = json.loads(client.sender.msgs[0])
rc = RavenClient()
sentry_fields = rc.decode(msg['payload'])
eq_(sentry_fields['culprit'], 'test_metlog.exception_call2')
eq_(len(sentry_fields['sentry.interfaces.Stacktrace']['frames']), 3)
eq_(sentry_fields['extra']['msg'], 'some message')
eq_(msg['logger'], '')
eq_(msg['fields']['msg'], 'some message')
eq_(msg['type'], 'sentry')
eq_(msg['severity'], SEVERITY.ERROR)
def test_plugins_config():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_procinfo]
net=True
"""
from metlog.config import client_from_text_config
import json
client = client_from_text_config(cfg_txt, 'metlog')
client.procinfo(net=True)
assert len(client.sender.msgs) == 1
actual = json.loads(client.sender.msgs[0])
del actual['timestamp']
expected = {"severity": 6,
"fields": {"net": []},
"logger": "",
"type": "procinfo",
"payload": "",
"env_version": "0.8"}
assert actual == expected
def test_plugins_config():
cfg_txt = """
[metlog]
sender_class = metlog.senders.DebugCaptureSender
[metlog_plugin_dummy]
provider=metlog.tests.plugin:config_plugin
verbose=True
foo=bar
some_list = dog
cat
bus
port=8080
host=lolcathost
"""
client = client_from_text_config(cfg_txt, 'metlog')
actual = client.dummy(verbose=True)
expected = {
'host': 'lolcathost',
'foo': 'bar',
'some_list': ['dog', 'cat', 'bus'],
'port': 8080
}
assert actual == expected
def test_environ_vars():
env_var = 'SENDER_TEST'
marker = object()
orig_value = marker
if env_var in os.environ:
orig_value = os.environ[env_var]
os.environ[env_var] = 'metlog.senders.DebugCaptureSender'
cfg_txt = """
[test1]
sender_class = ${SENDER_TEST}
"""
client = client_from_text_config(cfg_txt, 'test1')
eq_(client.sender.__class__, DebugCaptureSender)
cfg_txt = """
[test1]
sender_class = ${NO_SUCH_VAR}
"""
assert_raises(EnvironmentNotFoundError, client_from_text_config, cfg_txt,
'test1')
if orig_value is not marker:
os.environ[env_var] = orig_value
else:
del os.environ[env_var]
def test_environ_vars():
env_var = 'SENDER_TEST'
marker = object()
orig_value = marker
if env_var in os.environ:
orig_value = os.environ[env_var]
os.environ[env_var] = 'metlog.senders.DebugCaptureSender'
cfg_txt = """
[test1]
sender_class = ${SENDER_TEST}
"""
client = client_from_text_config(cfg_txt, 'test1')
eq_(client.sender.__class__, DebugCaptureSender)
cfg_txt = """
[test1]
sender_class = ${NO_SUCH_VAR}
"""
assert_raises(EnvironmentNotFoundError, client_from_text_config,
cfg_txt, 'test1')
if orig_value is not marker:
os.environ[env_var] = orig_value
else:
del os.environ[env_var]
