def test_semver_release_and_build(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', '1.0.5-gke.6+3', scheme='semver')
m.assert_any_call('test:123', 'version.major', '1')
m.assert_any_call('test:123', 'version.minor', '0')
m.assert_any_call('test:123', 'version.patch', '5')
m.assert_any_call('test:123', 'version.release', 'gke.6')
m.assert_any_call('test:123', 'version.build', '3')
m.assert_any_call('test:123', 'version.raw', '1.0.5-gke.6+3')
m.assert_any_call('test:123', 'version.scheme', 'semver')
assert m.call_count == 7
def test_dbm_async_job_rate_limit(aggregator):
# test the main collection loop rate limit
rate_limit = 10
limit_time = 1.0
sleep_time = 0.9 # just below what the rate limit should hit to buffer before cancelling the loop
job = TestJob(AgentCheck(), rate_limit=rate_limit)
job.run_job_loop([])
time.sleep(sleep_time)
max_collections = int(rate_limit * limit_time) + 1
job.cancel()
metrics = aggregator.metrics("dbm.async_job_test.run_job")
assert max_collections / 2.0 <= len(metrics) <= max_collections
def test_unknown_scheme(self, caplog):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with caplog.at_level(logging.DEBUG), mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', '1.0.0', scheme='foo')
assert m.call_count == 0
expected_message = 'Unable to transform `version` metadata value `1.0.0`: Unsupported version scheme `foo`'
for _, level, message in caplog.record_tuples:
if level == logging.WARNING and message == expected_message:
break
else:
raise AssertionError('Expected ERROR log with message: {}'.format(expected_message))
def test_semver_invalid(self, caplog):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with caplog.at_level(logging.DEBUG), mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', '1.0', scheme='semver')
assert m.call_count == 0
expected_prefix = 'Unable to transform `version` metadata value `1.0`: '
for _, level, message in caplog.record_tuples:
if level == logging.WARNING and message.startswith(expected_prefix):
break
else:
raise AssertionError('Expected ERROR log starting with message: {}'.format(expected_prefix))
def test_no_section(self, caplog):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with caplog.at_level(logging.DEBUG), mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('config', {})
assert m.call_count == 0
expected_message = 'Unable to transform `config` metadata: The `section` option is required'
for _, level, message in caplog.record_tuples:
if level == logging.WARNING and message == expected_message:
break
else:
raise AssertionError('Expected ERROR log with message: {}'.format(expected_message))
def test_unicode_string(self):
check = AgentCheck()
tag = u'unicode:string'
tags = [tag]
normalized_tags = check._normalize_tags_type(tags, None)
normalized_tag = normalized_tags[0]
assert normalized_tags is not tags
if PY3:
# Ensure no new allocation occurs
assert normalized_tag is tag
else:
assert normalized_tag == tag.encode('utf-8')
def test_metric_limit_instance_config(self, aggregator):
instances = [{
"max_returned_metrics": 42,
}]
check = AgentCheck("test", {}, instances)
assert check.get_warnings() == []
for i in range(0, 42):
check.gauge("metric", 0)
assert len(check.get_warnings()) == 0
assert len(aggregator.metrics("metric")) == 42
check.gauge("metric", 0)
assert len(check.get_warnings()) == 1
assert len(aggregator.metrics("metric")) == 42
def test_bytes_string(self):
check = AgentCheck()
tag = b'bytes:string'
tags = [tag]
normalized_tags = check._normalize_tags_type(tags, None)
normalized_tag = normalized_tags[0]
assert normalized_tags is not tags
if PY3:
assert normalized_tag == tag.decode('utf-8')
else:
# Ensure no new allocation occurs
assert normalized_tag is tag
def test_assert_no_duplicate_service_checks_cases(aggregator, case_name,
service_checks,
expect_assertion_error):
check = AgentCheck()
for metric_params in service_checks:
check.service_check(**metric_params)
try:
aggregator.assert_no_duplicate_service_checks()
assertion_error_raised = False
except AssertionError:
assertion_error_raised = True
assert assertion_error_raised == expect_assertion_error
def test__build_similar_elements__service_check_hostname(self, aggregator):
check = AgentCheck()
check.service_check('test.similar1', AgentCheck.OK, hostname="aa")
check.service_check('test.similar2', AgentCheck.OK, hostname="bb")
check.service_check('test.similar3', AgentCheck.OK, hostname="cc")
check.service_check('test.similar4', AgentCheck.OK, hostname="dd")
expected_service_check = ServiceCheckStub(
None, "test.similar", status=AgentCheck.OK, tags=None, hostname="cc", message=None
)
similar_service_checks = similar._build_similar_elements(expected_service_check, aggregator._service_checks)
# expect similar metrics in a similarity order
assert similar_service_checks[0][1].name == 'test.similar3'
def test_namespace(self, aggregator):
check = AgentCheck()
check.__NAMESPACE__ = 'test'
event = {
'event_type': 'new.event',
'msg_title': 'new test event',
'aggregation_key': 'test.event',
'msg_text': 'test event test event',
'tags': ['foo', 'bar'],
'timestamp': 1,
}
check.event(event)
aggregator.assert_event('test event test event',
source_type_name='test',
tags=['foo', 'bar'])
def test_global_include(self, aggregator):
query_manager = create_query_manager(
check=AgentCheck(
'test',
{
'global_custom_queries': [
{
'query': 'foo',
'columns': [{
'name': 'test.foo',
'type': 'gauge'
}],
'tags': ['test:bar']
},
],
},
[
{
'use_global_custom_queries':
'extend',
'custom_queries': [
{
'query': 'foo',
'columns': [{
'name': 'test.bar',
'type': 'gauge'
}],
'tags': ['test:bar']
},
],
},
],
),
executor=mock_executor([[1]]),
tags=['test:foo'],
)
query_manager.compile_queries()
query_manager.execute()
aggregator.assert_metric('test.foo',
1,
metric_type=aggregator.GAUGE,
tags=['test:foo', 'test:bar'])
aggregator.assert_metric('test.bar',
1,
metric_type=aggregator.GAUGE,
tags=['test:foo', 'test:bar'])
aggregator.assert_all_metrics_covered()
def test_assert_no_duplicate_metrics_cases(aggregator, case_name, metrics, expect_assertion_error):
check = AgentCheck()
for metric_params in metrics:
metric_type = metric_params.pop("type")
getattr(check, metric_type)(**metric_params)
msg = ''
try:
aggregator.assert_no_duplicate_metrics()
assertion_error_raised = False
except AssertionError as e:
assertion_error_raised = True
msg = str(e)
assert assertion_error_raised == expect_assertion_error, msg
def test__build_similar_elements__metric_hostname(self, aggregator):
check = AgentCheck()
check.gauge('test.similar_metric2', 10, hostname='less_similar_host')
check.gauge('test.similar_metric1', 10, hostname='similar_host')
check.gauge('test.similar_metric3', 10, hostname='different')
expected_metric = MetricStub(
"test.test.similar_metric", type=None, value=10, tags=None, hostname='similar_host', device=None
)
similar_metrics = similar._build_similar_elements(expected_metric, aggregator._metrics)
# expect similar metrics in a similarity order
assert similar_metrics[0][1].name == 'test.similar_metric1'
assert similar_metrics[1][1].name == 'test.similar_metric2'
assert similar_metrics[2][1].name == 'test.similar_metric3'
def test__build_similar_elements__service_check_tags(self, aggregator):
check = AgentCheck()
check.service_check('test.similar2', AgentCheck.OK, tags=['name:less_similar_tag'])
check.service_check('test.similar1', AgentCheck.OK, tags=['name:similar_tag'])
check.service_check('test.similar3', AgentCheck.OK, tags=['something:different'])
expected_service_check = ServiceCheckStub(
None, "test.similar", status=AgentCheck.OK, tags=['name:similar_tag'], hostname=None, message=None
)
similar_service_checks = similar._build_similar_elements(expected_service_check, aggregator._service_checks)
# expect similar metrics in a similarity order
assert similar_service_checks[0][1].name == 'test.similar1'
assert similar_service_checks[1][1].name == 'test.similar2'
assert similar_service_checks[2][1].name == 'test.similar3'
def test_regex(self, version, pattern, expected_parts):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version',
version,
scheme='regex',
pattern=pattern)
for name, value in expected_parts.items():
m.assert_any_call('test:123', 'version.{}'.format(name), value)
m.assert_any_call('test:123', 'version.raw', version)
m.assert_any_call('test:123', 'version.scheme', 'test')
assert m.call_count == len(expected_parts) + 2
def test_init_config(self, caplog):
instance = {}
init_config = {'log_requests': True}
check = AgentCheck('test', init_config, [instance])
assert check.http.logger is check.log
with caplog.at_level(logging.DEBUG), mock.patch('requests.get'):
check.http.get('https://www.google.com')
expected_message = 'Sending GET request to https://www.google.com'
for _, level, message in caplog.record_tuples:
if level == logging.DEBUG and message == expected_message:
break
else:
raise AssertionError('Expected DEBUG log with message `{}`'.format(expected_message))
def test_encoding(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
if PY3:
constructor = ensure_bytes
finalizer = ensure_unicode
else:
constructor = ensure_unicode
finalizer = ensure_bytes
name = constructor(u'nam\u00E9')
value = constructor(u'valu\u00E9')
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata(name, value)
m.assert_called_once_with('test:123', finalizer(name), finalizer(value))
def test_whitelist_no_field(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('config', check.instance, section='instance', whitelist=['foo'])
assert m.call_count == 1
args, _ = m.call_args
assert args[0] == 'test:123'
assert args[1] == 'config.instance'
data = json.loads(args[2])[0]
assert data.pop('is_set', None) is False
assert not data
def test_regex_no_pattern(self, caplog):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with caplog.at_level(logging.DEBUG), mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', '1.0', scheme='regex')
assert m.call_count == 0
expected_message = (
'Unable to transform `version` metadata value `1.0`: Version scheme `regex` requires a `pattern` option'
)
for _, level, message in caplog.record_tuples:
if level == logging.WARNING and message == expected_message:
break
else:
raise AssertionError('Expected ERROR log with message: {}'.format(expected_message))
def test__build_similar_elements__metric_name(self, aggregator):
check = AgentCheck()
check.gauge('test.another_similar_metric', 0)
check.gauge('test.very_different_metric', 0)
check.gauge('test.most_similar_metric', 0)
check.gauge('test.very_very_different', 0)
expected_metric = MetricStub(
"test.similar_metric", type=None, value=None, tags=None, hostname=None, device=None
)
similar_metrics = similar._build_similar_elements(expected_metric, aggregator._metrics)
expected_most_similar_metric = similar_metrics[0][1]
expected_second_most_similar_metric = similar_metrics[1][1]
assert expected_most_similar_metric.name == 'test.most_similar_metric'
assert expected_second_most_similar_metric.name == 'test.another_similar_metric'
def test_regex_no_subgroups(self, caplog):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with caplog.at_level(logging.DEBUG), mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata('version', '1.0.0', scheme='regex', pattern=r'\d\.\d\.\d')
assert m.call_count == 0
expected_message = (
'Unable to transform `version` metadata value `1.0.0`: '
'Regular expression pattern has no named subgroups'
)
for _, level, message in caplog.record_tuples:
if level == logging.ERROR and message == expected_message:
break
else:
raise AssertionError('Expected ERROR log with message: {}'.format(expected_message))
def test__build_similar_elements__service_check_status(self, aggregator):
check = AgentCheck()
check.service_check('test.similar1', AgentCheck.OK)
check.service_check('test.similar2', AgentCheck.CRITICAL)
check.service_check('test.similar3', AgentCheck.WARNING)
expected_service_check = ServiceCheckStub(None,
"test.similar",
status=AgentCheck.CRITICAL,
tags=None,
hostname=None,
message=None)
similar_service_checks = similar._build_similar_elements(
expected_service_check, aggregator._service_checks)
# expect similar metrics in a similarity order
assert similar_service_checks[0][1].name == 'test.similar2'
def test__build_similar_elements__service_check_name(self, aggregator):
check = AgentCheck()
check.service_check('test.second_similar_service_check', AgentCheck.OK)
check.service_check('test.very_different_service_check', AgentCheck.OK)
check.service_check('test.most_similar_service_check', AgentCheck.OK)
check.service_check('test.very_very_different', AgentCheck.OK)
expected_service_check = ServiceCheckStub(
None, "test.similar_service_check", status=AgentCheck.OK, tags=None, hostname=None, message=None
)
similar_service_checks = similar._build_similar_elements(expected_service_check, aggregator._service_checks)
# expect similar metrics in a similarity order
assert similar_service_checks[0][1].name == 'test.most_similar_service_check'
assert similar_service_checks[1][1].name == 'test.second_similar_service_check'
assert similar_service_checks[2][1].name == 'test.very_different_service_check'
assert similar_service_checks[3][1].name == 'test.very_very_different'
def test_detect_typos_configuration_models(
dd_run_check, mocker, caplog, check_instance_config, default_instance_config, log_lines
):
caplog.clear()
caplog.set_level(logging.WARNING)
empty_config = {}
default_instance = mocker.MagicMock()
default_instance.__iter__ = mocker.MagicMock(return_value=iter(default_instance_config))
check = AgentCheck('test', empty_config, [check_instance_config])
check.check_id = 'test:123'
check.log_typos_in_options(check_instance_config, default_instance, 'instance')
if log_lines is not None:
for log_line in log_lines:
assert log_line in caplog.text
else:
assert 'Detected potential typo in configuration option' not in caplog.text
def test__build_similar_elements__metric_tags(self, aggregator):
check = AgentCheck()
check.gauge('test.similar_metric2', 10, tags=['name:less_similar_tag'])
check.gauge('test.similar_metric1', 10, tags=['name:similar_tag'])
check.gauge('test.similar_metric3', 10, tags=['something:different'])
expected_metric = MetricStub("test.test.similar_metric",
type=None,
value=10,
tags=['name:similar_tag'],
hostname=None)
similar_metrics = similar._build_similar_elements(
expected_metric, aggregator._metrics)
# expect similar metrics in a similarity order
assert similar_metrics[0][1].name == 'test.similar_metric1'
assert similar_metrics[1][1].name == 'test.similar_metric2'
assert similar_metrics[2][1].name == 'test.similar_metric3'
def test__build_similar_elements__metric_value(self, aggregator):
check = AgentCheck()
check.gauge('test.similar_metric1', 10)
check.gauge('test.similar_metric2', 20)
check.gauge('test.similar_metric3', 30)
expected_metric = MetricStub("test.my_metric",
type=None,
value=20,
tags=None,
hostname=None)
similar_metrics = similar._build_similar_elements(
expected_metric, aggregator._metrics)
expected_most_similar_metric = similar_metrics[0][1]
print(similar_metrics)
assert expected_most_similar_metric.name == 'test.similar_metric2'
def test_metrics_filters(self, exclude_metrics_filters, include_metrics_filters, expected_metrics, aggregator):
instance = {
'metric_patterns': {
'exclude': exclude_metrics_filters,
'include': include_metrics_filters,
}
}
check = AgentCheck('myintegration', {}, [instance])
check.__NAMESPACE__ = 'ns'
check.gauge('my_metric', 0)
check.count('my_metric_count', 0)
check.count('test.my_metric1', 1)
check.monotonic_count('hello', 0)
check.service_check('test.can_check', status=AgentCheck.OK)
for metric_name in expected_metrics:
aggregator.assert_metric('ns.{}'.format(metric_name), count=1)
aggregator.assert_service_check('ns.test.can_check', status=AgentCheck.OK)
aggregator.assert_all_metrics_covered()
def test_parts(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata(
'version',
'19.15.2.2',
scheme='parts',
part_map={'year': '19', 'major': '15', 'minor': '2', 'patch': '2', 'revision': '56789'},
)
m.assert_any_call('test:123', 'version.year', '19')
m.assert_any_call('test:123', 'version.major', '15')
m.assert_any_call('test:123', 'version.minor', '2')
m.assert_any_call('test:123', 'version.patch', '2')
m.assert_any_call('test:123', 'version.revision', '56789')
m.assert_any_call('test:123', 'version.raw', '19.15.2.2')
m.assert_any_call('test:123', 'version.scheme', 'test')
assert m.call_count == 7
def test_regex_final_scheme(self):
check = AgentCheck('test', {}, [{}])
check.check_id = 'test:123'
with mock.patch(SET_CHECK_METADATA_METHOD) as m:
check.set_metadata(
'version',
'1.2.3.beta',
scheme='regex',
final_scheme='semver',
pattern=r'(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+).(?P<release>\w+)',
)
m.assert_any_call('test:123', 'version.major', '1')
m.assert_any_call('test:123', 'version.minor', '2')
m.assert_any_call('test:123', 'version.patch', '3')
m.assert_any_call('test:123', 'version.release', 'beta')
m.assert_any_call('test:123', 'version.raw', '1.2.3.beta')
m.assert_any_call('test:123', 'version.scheme', 'semver')
assert m.call_count == 6
