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