def test_required_field(self):
config = MonitorConfig({"foo": 10})
self.assertEquals(config.get("foo", required_field=True), 10)
self.assertRaises(
BadMonitorConfiguration, config.get, "fo", required_field=True
)
def test_get_initial_sleep_delay_jitter_disabled(self):
logger = mock.Mock()
# 1. Default value is used
monitor_config = MonitorConfig(
{"module": "test_module"}, monitor_module="test_monitor"
)
global_config = mock.Mock()
global_config.global_monitor_sample_interval_enable_jitter = False
monitor = ScalyrMonitor(
monitor_config=monitor_config,
logger=logger,
sample_interval_secs=None,
global_config=global_config,
)
sleep_delay = monitor._get_initial_sleep_delay()
self.assertEqual(sleep_delay, 0)
# 2. Value is overridden on per monitor basis
monitor_config = MonitorConfig(
{"module": "test_module", "sample_interval": 10},
monitor_module="test_monitor",
)
global_config = mock.Mock()
global_config.global_monitor_sample_interval_enable_jitter = False
monitor = ScalyrMonitor(
monitor_config=monitor_config,
logger=logger,
sample_interval_secs=None,
global_config=global_config,
)
sleep_delay = monitor._get_initial_sleep_delay()
self.assertEqual(sleep_delay, 0)
def get(self,
original_value,
convert_to=None,
required_field=False,
max_value=None,
min_value=None):
config = MonitorConfig({'foo': original_value})
return config.get('foo',
convert_to=convert_to,
required_field=required_field,
max_value=max_value,
min_value=min_value)
def test_base(self):
test_array = ["a", 1, False]
test_obj = {"a": 100, "b": 200}
config = MonitorConfig({
"int": 1,
"bool": True,
"string": "hi",
"unicode": u"bye",
"float": 1.4,
"long": 1,
"JsonArray": JsonArray(*test_array),
"JsonObject": JsonObject(**test_obj),
})
self.assertEquals(len(config), 8)
self.assertTrue("int" in config)
self.assertFalse("foo" in config)
self.assertEquals(config["int"], 1)
self.assertEquals(config["bool"], True)
self.assertEquals(config["string"], "hi")
self.assertEquals(config["unicode"], u"bye")
self.assertEquals(config["float"], 1.4)
self.assertEquals(config["long"], 1)
self.assertEquals(config["JsonArray"], JsonArray(*test_array))
self.assertEquals(config["JsonObject"], JsonObject(**test_obj))
count = 0
for _ in config:
count += 1
self.assertEquals(count, 8)
def define_and_get_from_env(
self,
environment_value,
default_value=None,
convert_to=None,
required_field=None,
max_value=None,
min_value=None,
env_name=None,
):
"""
Tests the entire process of defining a configuration option that can be set via the environment,
setting the environment variable, and retrieving its value from an empty MonitorConfig object.
:param environment_value: The value to set in the environment before trying to retrieve it. If None, no
environment value will be set.
:param default_value: The default value to use when defining the option.
:param convert_to: The convert_to value to use when defining the option.
:param required_field: The required_field value to use when defining the option.
:param max_value: The max_value value to use when defining the option.
:param min_value: The max_value value to use when defining the option.
:param env_name: The env_name value to use when defining the option.
:return: The value retrieved from the option
:type environment_value: six.text_type|None
:type convert_to: ArrayOfStrings|JsonArray|six.text_type|Number|bool
:type default_value: six.text_type
:type required_field: bool
:type max_value: Number
:type min_value: Number
:type env_name: six.text_type
:rtype: ArrayOfStrings|JsonArray|six.text_type|Number|bool
"""
define_config_option(
"foo_env",
"foo",
"Some description",
default=default_value,
convert_to=convert_to,
required_option=required_field,
max_value=max_value,
min_value=min_value,
env_aware=True,
env_name=env_name,
)
if env_name is None:
env_name = "SCALYR_FOO"
if environment_value is not None:
os_environ_unicode[env_name] = environment_value
else:
os_environ_unicode.pop(env_name, None)
try:
return MonitorConfig(monitor_module="foo_env").get("foo")
finally:
os_environ_unicode.pop(env_name, None)
def test_define_config_option(self):
define_config_option("foo",
"a",
"Description",
required_option=True,
convert_to=int)
self.assertRaises(BadMonitorConfiguration,
MonitorConfig, {"b": 1},
monitor_module="foo")
config = MonitorConfig({"a": "5"}, monitor_module="foo")
self.assertEquals(config.get("a"), 5)
define_config_option(
"foo",
"b",
"Description",
min_value=5,
max_value=10,
default=7,
convert_to=int,
)
config = MonitorConfig({"a": 5}, monitor_module="foo")
self.assertEquals(config.get("b"), 7)
self.assertRaises(
BadMonitorConfiguration,
MonitorConfig,
{
"a": 5,
"b": 1
},
monitor_module="foo",
)
self.assertRaises(
BadMonitorConfiguration,
MonitorConfig,
{
"a": 5,
"b": 11
},
monitor_module="foo",
)
# Test case where no value in config for option with no default value should result in no value in
# MonitorConfig object
define_config_option("foo",
"c",
"Description",
min_value=5,
max_value=10,
convert_to=int)
config = MonitorConfig({"a": 5}, monitor_module="foo")
self.assertTrue("c" not in config)
def test_define_config_option(self):
define_config_option('foo', 'a', 'Description', required_option=True, convert_to=int)
self.assertRaises(BadMonitorConfiguration, MonitorConfig, {'b': 1}, monitor_module='foo')
config = MonitorConfig({'a': '5'}, monitor_module='foo')
self.assertEquals(config.get('a'), 5)
define_config_option('foo', 'b', 'Description', min_value=5, max_value=10, default=7, convert_to=int)
config = MonitorConfig({'a': 5}, monitor_module='foo')
self.assertEquals(config.get('b'), 7)
self.assertRaises(BadMonitorConfiguration, MonitorConfig, {'a': 5, 'b': 1}, monitor_module='foo')
self.assertRaises(BadMonitorConfiguration, MonitorConfig, {'a': 5, 'b': 11}, monitor_module='foo')
# Test case where no value in config for option with no default value should result in no value in
# MonitorConfig object
define_config_option('foo', 'c', 'Description', min_value=5, max_value=10, convert_to=int)
config = MonitorConfig({'a': 5}, monitor_module='foo')
self.assertTrue('c' not in config)
def test_malformed_headers(self):
mock_logger = mock.MagicMock()
config_data = {
'url': 'fooUrl',
'request_method': 'POST',
'request_data': '{fakejsonthatisnotlegit}',
'request_headers': 'not legit headers',
'module': self.module
}
config = MonitorConfig(content=config_data)
with self.assertRaises(Exception):
_ = UrlMonitor(monitor_config=config, logger=mock_logger)
def test_malformed_headers(self):
mock_logger = mock.MagicMock()
config_data = {
"url": "fooUrl",
"request_method": "POST",
"request_data": "{fakejsonthatisnotlegit}",
"request_headers": "not legit headers",
"module": self.module,
}
config = MonitorConfig(content=config_data)
self.assertRaises(
Exception,
lambda: UrlMonitor(monitor_config=config, logger=mock_logger))
def test_define_config_option(self):
define_config_option('foo',
'a',
'Description',
required_option=True,
convert_to=int)
self.assertRaises(BadMonitorConfiguration,
MonitorConfig, {'b': 1},
monitor_module='foo')
config = MonitorConfig({'a': '5'}, monitor_module='foo')
self.assertEquals(config.get('a'), 5)
define_config_option('foo',
'b',
'Description',
min_value=5,
max_value=10,
default=7,
convert_to=int)
config = MonitorConfig({'a': 5}, monitor_module='foo')
self.assertEquals(config.get('b'), 7)
self.assertRaises(BadMonitorConfiguration,
MonitorConfig, {
'a': 5,
'b': 1
},
monitor_module='foo')
self.assertRaises(BadMonitorConfiguration,
MonitorConfig, {
'a': 5,
'b': 11
},
monitor_module='foo')
# Test case where no value in config for option with no default value should result in no value in
# MonitorConfig object
define_config_option('foo',
'c',
'Description',
min_value=5,
max_value=10,
convert_to=int)
config = MonitorConfig({'a': 5}, monitor_module='foo')
self.assertTrue('c' not in config)
def test_get_request_no_headers(self):
mock_logger = mock.MagicMock()
config_data = {
'url': 'fooUrl',
'request_method': 'GET',
'request_data': None,
'request_headers': [],
'module': self.module
}
config = MonitorConfig(content=config_data)
url_monitor = UrlMonitor(monitor_config=config, logger=mock_logger)
actual_request = url_monitor.build_request()
self.assertEqual(actual_request.get_method(), 'GET')
self.assertFalse(actual_request.has_data())
self.assertEqual(actual_request.header_items(), [])
def test_get_request_no_headers(self):
mock_logger = mock.MagicMock()
config_data = {
"url": "http://fooUrl",
"request_method": "GET",
"request_data": None,
"request_headers": [],
"module": self.module,
}
config = MonitorConfig(content=config_data)
url_monitor = UrlMonitor(monitor_config=config, logger=mock_logger)
actual_request = url_monitor.build_request()
self.assertEqual(actual_request.get_method(), "GET")
self.assertFalse(actual_request.data is not None)
self.assertEqual(actual_request.header_items(), [])
def test_post_request_with_data(self):
mock_logger = mock.MagicMock()
config_data = {
'url': 'fooUrl',
'request_method': 'POST',
'request_data': '{fakejsonthatisnotlegit}',
'request_headers': self.legit_headers,
'module': self.module
}
config = MonitorConfig(content=config_data)
url_monitor = UrlMonitor(monitor_config=config, logger=mock_logger)
actual_request = url_monitor.build_request()
self.assertEqual(actual_request.get_method(), 'POST')
self.assertEqual(actual_request.data, '{fakejsonthatisnotlegit}')
self.assertEqual(actual_request.header_items(),
[('Header_foo', 'foo'), ('Header_bar', 'bar')])
def test_get_request_with_headers(self):
mock_logger = mock.MagicMock()
config_data = {
"url": "http://fooUrl",
"request_method": "GET",
"request_data": None,
"request_headers": self.legit_headers,
"module": self.module,
}
config = MonitorConfig(content=config_data)
url_monitor = UrlMonitor(monitor_config=config, logger=mock_logger)
actual_request = url_monitor.build_request()
self.assertEqual(actual_request.get_method(), "GET")
self.assertFalse(actual_request.data is not None)
self.assertEqual(
sorted(actual_request.header_items()),
sorted([("Header_foo", "foo"), ("Header_bar", "bar")]),
)
def test_monitor_run_random_initial_sleep_delay_enabled(self):
def make_mock_thread_is_stopped(monitor):
def mock_is_thread_stopped(*args, **kwargs):
if monitor.counter >= 3:
return True
monitor.counter += 1
return False
return mock_is_thread_stopped
mock_sleep_but_awaken_if_stopped = mock.Mock()
mock_logger = mock.Mock()
mock_gather_sample = mock.Mock()
monitor_config = MonitorConfig(
{
"module": "test_module",
"sample_interval": 10
},
monitor_module="test_monitor",
)
global_config = mock.Mock()
global_config.global_monitor_sample_interval_enable_jitter = True
monitor = ScalyrMonitor(
monitor_config=monitor_config,
logger=mock_logger,
sample_interval_secs=None,
global_config=global_config,
)
monitor.counter = 0
monitor._sleep_but_awaken_if_stopped = mock_sleep_but_awaken_if_stopped
monitor._is_thread_stopped = make_mock_thread_is_stopped(monitor)
monitor.gather_sample = mock_gather_sample
monitor.run()
self.assertEqual(monitor.counter, 3)
# + 1 is for initial sleep delay before first sample gather interval
self.assertEqual(mock_sleep_but_awaken_if_stopped.call_count, 1 + 3)
# 1 call is to debug function when we are initially sleeping before the gather
self.assertEqual(mock_logger.debug.call_count, 1)
# 1 call is for monitor has finished message
self.assertEqual(mock_logger.info.call_count, 1)
self.assertEqual(mock_logger.exception.call_count, 0)
def test_post_request_with_data(self):
mock_logger = mock.MagicMock()
config_data = {
"url": "fooUrl",
"request_method": "POST",
"request_data": "{fakejsonthatisnotlegit}",
"request_headers": self.legit_headers,
"module": self.module,
}
config = MonitorConfig(content=config_data)
url_monitor = UrlMonitor(monitor_config=config, logger=mock_logger)
actual_request = url_monitor.build_request()
self.assertEqual(actual_request.get_method(), "POST")
self.assertEqual(actual_request.data, "{fakejsonthatisnotlegit}")
self.assertEqual(
actual_request.header_items(),
[("Header_foo", "foo"), ("Header_bar", "bar")],
)
def test_default_value(self):
config = MonitorConfig({'foo': 10})
self.assertEquals(config.get('foo', default=20), 10)
self.assertEquals(config.get('fee', default=20), 20)
def test_default_value(self):
config = MonitorConfig({"foo": 10})
self.assertEquals(config.get("foo", default=20), 10)
self.assertEquals(config.get("fee", default=20), 20)
def get(self, original_value, convert_to=None, required_field=False, max_value=None,
min_value=None):
config = MonitorConfig({'foo': original_value})
return config.get('foo', convert_to=convert_to, required_field=required_field,
max_value=max_value, min_value=min_value)
def test_get_initial_sleep_delay_with_random_jitter_enabled(self):
logger = mock.Mock()
# 1. Default value is used
monitor_sample_interval = ScalyrMonitor.DEFAULT_SAMPLE_INTERVAL_SECS
monitor_config = MonitorConfig(
{"module": "test_module"}, monitor_module="test_monitor"
)
global_config = mock.Mock()
global_config.global_monitor_sample_interval_enable_jitter = True
monitor = ScalyrMonitor(
monitor_config=monitor_config,
logger=logger,
sample_interval_secs=None,
global_config=global_config,
)
for i in range(0, 100):
sleep_delay = monitor._get_initial_sleep_delay()
min_jitter = round(monitor_sample_interval / 10) * 2
max_jitter = round(monitor_sample_interval / 10) * 8
self.assertFalse(sleep_delay == monitor_sample_interval)
self.assertTrue(sleep_delay >= min_jitter and sleep_delay <= max_jitter)
# 2. Value is overridden on per monitor basis
monitor_sample_interval = 10
monitor_config = MonitorConfig(
{"module": "test_module", "sample_interval": 10},
monitor_module="test_monitor",
)
global_config = mock.Mock()
global_config.global_monitor_sample_interval_enable_jitter = True
monitor = ScalyrMonitor(
monitor_config=monitor_config,
logger=logger,
sample_interval_secs=None,
global_config=global_config,
)
for i in range(0, 100):
sleep_delay = monitor._get_initial_sleep_delay()
min_jitter = round(monitor_sample_interval / 10) * 2
max_jitter = round(monitor_sample_interval / 10) * 8
self.assertFalse(sleep_delay == monitor_sample_interval)
self.assertTrue(sleep_delay >= min_jitter and sleep_delay <= max_jitter)
# 3. Verify there is an upper bound of 40 seconds
monitor_sample_interval = 1000
monitor_config = MonitorConfig(
{"module": "test_module", "sample_interval": 1000},
monitor_module="test_monitor",
)
global_config = mock.Mock()
global_config.global_monitor_sample_interval_enable_jitter = True
monitor = ScalyrMonitor(
monitor_config=monitor_config,
logger=logger,
sample_interval_secs=None,
global_config=global_config,
)
for i in range(0, 100):
sleep_delay = monitor._get_initial_sleep_delay()
min_jitter = MIN_INITIAL_GATHER_SAMPLE_SLEEP_SECS
max_jitter = MAX_INITIAL_GATHER_SAMPLE_SLEEP_SECS
self.assertTrue(sleep_delay >= min_jitter and sleep_delay <= max_jitter)
def test_default_value(self):
config = MonitorConfig({'foo': 10})
self.assertEquals(config.get('foo', default=20), 10)
self.assertEquals(config.get('fee', default=20), 20)
def test_required_field(self):
config = MonitorConfig({'foo': 10})
self.assertEquals(config.get('foo', required_field=True), 10)
self.assertRaises(BadMonitorConfiguration, config.get, 'fo', required_field=True)
