def test_check(instance, dd_run_check, aggregator, tag_condition, base_tags): check = ArangodbCheck('arangodb', {}, [instance]) def mock_requests_get(url, *args, **kwargs): fixture = url.rsplit('/', 1)[-1] return MockResponse(file_path=os.path.join(os.path.dirname( __file__), 'fixtures', tag_condition, fixture)) with mock.patch('requests.get', side_effect=mock_requests_get, autospec=True): dd_run_check(check) aggregator.assert_service_check( 'arangodb.openmetrics.health', ArangodbCheck.OK, count=1, tags=['endpoint:http://localhost:8529/_admin/metrics/v2'], ) aggregator.assert_metrics_using_metadata(get_metadata_metrics()) for metric in METRICS: aggregator.assert_metric(metric) for tag in base_tags: aggregator.assert_metric_has_tag(metric, tag) aggregator.assert_all_metrics_covered()
def test_submitted_metrics_count(aggregator): instance = common.generate_instance_config(common.SCALAR_OBJECTS) check = common.create_check(instance) check.check(instance) for metric in common.SCALAR_OBJECTS: metric_name = "snmp." + (metric.get('name') or metric.get('symbol')) aggregator.assert_metric(metric_name, tags=common.CHECK_TAGS, count=1) total_snmp_submitted_metrics = len(common.SCALAR_OBJECTS) + 1 # +1 for snmp.sysUpTimeInstance aggregator.assert_metric('snmp.sysUpTimeInstance', count=1) aggregator.assert_metric( 'datadog.snmp.submitted_metrics', value=total_snmp_submitted_metrics, metric_type=aggregator.GAUGE, count=1, tags=common.CHECK_TAGS, ) aggregator.assert_metric( 'datadog.snmp.check_duration', metric_type=aggregator.GAUGE, count=1, tags=common.CHECK_TAGS ) aggregator.assert_metric( 'datadog.snmp.check_interval', metric_type=aggregator.MONOTONIC_COUNT, count=1, tags=common.CHECK_TAGS ) common.assert_common_device_metrics(aggregator, tags=common.CHECK_TAGS) aggregator.all_metrics_asserted() aggregator.assert_metrics_using_metadata( get_metadata_metrics(), check_submission_type=True, exclude=['snmp.snmpEngineTime', 'snmp.tcpInSegs', 'snmp.udpDatagrams'], )
def test_check_docker(dd_agent_check, init_config, instance_e2e): # run run sync to ensure only a single run of both instance_e2e['query_activity'] = {'run_sync': True} instance_e2e['query_metrics'] = {'run_sync': True} aggregator = dd_agent_check( { 'init_config': init_config, 'instances': [instance_e2e] }, rate=True) aggregator.assert_metric_has_tag('sqlserver.db.commit_table_entries', 'db:master') # ignore DBM debug metrics for the following tests as they're not currently part of the public set of product # metrics dbm_debug_metrics = [ m for m in aggregator._metrics.keys() if m.startswith('dd.sqlserver.') ] for m in dbm_debug_metrics: del aggregator._metrics[m] for mname in EXPECTED_METRICS_DBM_ENABLED: aggregator.assert_metric(mname) for mname in UNEXPECTED_FCI_METRICS + UNEXPECTED_QUERY_EXECUTOR_AO_METRICS: aggregator.assert_metric(mname, count=0) aggregator.assert_service_check('sqlserver.can_connect', status=SQLServer.OK) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics(), exclude=CUSTOM_METRICS)
def test(aggregator, dd_default_hostname, dd_run_check, mock_performance_objects): mock_performance_objects(PERFORMANCE_OBJECTS) check = DotnetclrCheck('dotnetclr', {}, [{'host': dd_default_hostname}]) check.hostname = dd_default_hostname dd_run_check(check) global_tags = ['server:{}'.format(dd_default_hostname)] aggregator.assert_service_check('dotnetclr.windows.perf.health', ServiceCheck.OK, count=1, tags=global_tags) for object_name, (instances, _) in PERFORMANCE_OBJECTS.items(): config = METRICS_CONFIG[object_name] counters = config['counters'][0] for data in counters.values(): if isinstance(data, str): metric = 'dotnetclr.{}.{}'.format(config['name'], data) else: metric = 'dotnetclr.{}'.format(data.get('metric_name')) for instance in instances: if instance is None: tags = global_tags else: tags = ['instance:{}'.format(instance)] tags.extend(global_tags) aggregator.assert_metric(metric, 9000, count=1, tags=tags) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_e2e(dd_agent_check): aggregator = dd_agent_check(CONFIG, rate=True) assert_check(aggregator, METRICS_TO_TEST) # Excluding gitlab.rack.http_requests_total because it is a distribution metric # (its sum and count metrics are in the metadata) aggregator.assert_metrics_using_metadata( get_metadata_metrics(), exclude=["gitlab.rack.http_requests_total"])
def test_e2e(dd_agent_check, instance_complex): aggregator = dd_agent_check(instance_complex) _assert_complex_config(aggregator) aggregator.assert_metrics_using_metadata(get_metadata_metrics(), exclude=['alice.age', 'bob.age'] + variables.STATEMENT_VARS)
def test_check(aggregator, instance): # type: (AggregatorStub, Dict[str, Any]) -> None check = {check_class}('{check_name}', {{}}, [instance]) check.check(instance) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_integration_mongos(instance_integration, aggregator, check): mongos_check = check(instance_integration) mongos_check._last_states_by_server = {0: 1, 1: 2, 2: 2} with mock_pymongo("mongos"): mongos_check.check(None) _assert_metrics( aggregator, [ 'default', 'custom-queries', 'dbstats', 'indexes-stats', 'collection', 'connection-pool', 'jumbo', 'sessions' ], ['sharding_cluster_role:mongos'], ) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata( get_metadata_metrics(), exclude=[ 'dd.custom.mongo.aggregate.total', 'dd.custom.mongo.count', 'dd.custom.mongo.query_a.amount', 'dd.custom.mongo.query_a.el', ], check_submission_type=True, ) assert len(aggregator._events) == 0
def test_minimal_config(aggregator, instance_basic): mysql_check = MySql(common.CHECK_NAME, {}, [instance_basic]) mysql_check.check(instance_basic) # Test service check aggregator.assert_service_check('mysql.can_connect', status=MySql.OK, tags=tags.SC_TAGS_MIN, count=1) # Test metrics testable_metrics = variables.STATUS_VARS + variables.VARIABLES_VARS + variables.INNODB_VARS + variables.BINLOG_VARS for mname in testable_metrics: aggregator.assert_metric(mname, at_least=1) optional_metrics = (variables.COMPLEX_STATUS_VARS + variables.COMPLEX_VARIABLES_VARS + variables.COMPLEX_INNODB_VARS + variables.SYSTEM_METRICS + variables.SYNTHETIC_VARS) _test_optional_metrics(aggregator, optional_metrics) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics(), check_submission_type=True)
def test_check(cursor_factory, aggregator, instance, dd_run_check, expected_metrics): with cursor_factory(): check = TeradataCheck(CHECK_NAME, {}, [instance]) dd_run_check(check) for metric in expected_metrics: aggregator.assert_metric( metric['name'], metric['value'], sorted(metric['tags'] + ['td_env:dev']), count=1, metric_type=metric['type'], ) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics(), check_submission_type=True) aggregator.assert_service_check( SERVICE_CHECK_CONNECT, ServiceCheck.OK, tags=['teradata_server:tdserver', 'teradata_port:1025', 'td_env:dev'], ) aggregator.assert_service_check( SERVICE_CHECK_QUERY, ServiceCheck.OK, tags=['teradata_server:tdserver', 'teradata_port:1025', 'td_env:dev'], )
def test_check(dd_run_check, aggregator, instance): # type: (Callable[[AgentCheck, bool], None], AggregatorStub, Dict[str, Any]) -> None check = {check_class}('{check_name}', {{}}, [instance]) dd_run_check(check) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_integration_replicaset_secondary(instance_integration, aggregator, check): mongo_check = check(instance_integration) mongo_check.last_states_by_server = {0: 2, 1: 1, 2: 7, 3: 2} with mock_pymongo("replica-secondary"): mongo_check.check(None) replica_tags = ['replset_name:replset', 'replset_state:secondary'] metrics_categories = [ 'default', 'custom-queries', 'oplog', 'replset-secondary', 'top', 'dbstats-local', 'fsynclock', ] _assert_metrics(aggregator, metrics_categories, replica_tags) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata( get_metadata_metrics(), exclude=[ 'dd.custom.mongo.aggregate.total', 'dd.custom.mongo.count', 'dd.custom.mongo.query_a.amount', 'dd.custom.mongo.query_a.el', ], check_metric_type=False, ) assert len(aggregator._events) == 0
def test_e2e(dd_agent_check): instance = {} aggregator = dd_agent_check(instance) metrics = [ 'resin.thread_pool.thread_active_count', 'resin.thread_pool.thread_count', 'resin.thread_pool.thread_idle_count', 'resin.thread_pool.thread_max', 'resin.thread_pool.thread_wait_count', 'resin.connection_pool.connection_active_count', 'resin.connection_pool.connection_count', 'resin.connection_pool.connection_create_count', 'resin.connection_pool.connection_idle_count', 'resin.connection_pool.max_connections', 'resin.connection_pool.max_create_connections', 'resin.connection_pool.max_overflow_connections', ] for metric in metrics: aggregator.assert_metric(metric, at_least=0) # needed because https://github.com/DataDog/integrations-core/pull/9501 jvm_e2e_metrics_new = list(JVM_E2E_METRICS) jvm_e2e_metrics_new.remove('jvm.gc.cms.count') jvm_e2e_metrics_new.remove('jvm.gc.parnew.time') for metric in jvm_e2e_metrics_new: aggregator.assert_metric(metric) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics(), exclude=jvm_e2e_metrics_new)
def test_check(aggregator, dd_run_check, check): c = check(DEFAULT_INSTANCE) dd_run_check(c) dd_run_check(c) for metric in PROMETHEUS_METRICS: formatted_metric = "envoy.{}".format(metric) if metric in FLAKY_METRICS: aggregator.assert_metric(formatted_metric, at_least=0) continue aggregator.assert_metric(formatted_metric) collected_metrics = aggregator.metrics(METRIC_PREFIX + metric) legacy_metric = METRICS.get(metric) if collected_metrics and legacy_metric and metric not in SKIP_TAG_ASSERTION: expected_tags = [t for t in legacy_metric.get('tags', []) if t] for tag_set in expected_tags: assert all( all(any(tag in mt for mt in m.tags) for tag in tag_set) for m in collected_metrics if m.tags), ('tags ' + str(expected_tags) + ' not found in ' + formatted_metric) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_mongo_replset(instance_shard, aggregator, check): mongo_check = check(instance_shard) mongo_check.check(None) replset_metrics = [ 'mongodb.replset.health', 'mongodb.replset.replicationlag', 'mongodb.replset.state', 'mongodb.replset.votefraction', 'mongodb.replset.votes', ] replset_common_tags = [ "replset_name:shard01", "server:mongodb://localhost:27018/", "sharding_cluster_role:shardsvr", ] for metric in replset_metrics: aggregator.assert_metric(metric, tags=replset_common_tags + ['replset_state:primary']) aggregator.assert_metric( 'mongodb.replset.optime_lag', tags=replset_common_tags + ['replset_state:primary', 'member:shard01a:27018'] ) aggregator.assert_metric( 'mongodb.replset.optime_lag', tags=replset_common_tags + ['replset_state:secondary', 'member:shard01b:27018'] ) aggregator.assert_metrics_using_metadata(get_metadata_metrics(), check_submission_type=True)
def test_check_with_filters(aggregator): # type: (AggregatorStub) -> None check = MarklogicCheck('marklogic', {}, [INSTANCE_FILTERS]) check.check(INSTANCE_FILTERS) _assert_metrics(aggregator, COMMON_TAGS) # Resource filter only for metric in STORAGE_HOST_METRICS + RESOURCE_STORAGE_FOREST_METRICS: aggregator.assert_metric_has_tag(metric, 'forest_name:Security', count=1) for metric in RESOURCE_STATUS_DATABASE_METRICS: aggregator.assert_metric_has_tag(metric, 'database_name:Documents', count=1) for metric in [ 'marklogic.requests.query-count', 'marklogic.requests.total-requests', 'marklogic.requests.update-count', ]: aggregator.assert_metric(metric, tags=COMMON_TAGS + ['server_name:Admin', 'group_name:Default'], count=1) aggregator.assert_all_metrics_covered() # Service checks _assert_service_checks(aggregator, COMMON_TAGS) aggregator.assert_no_duplicate_all() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_e2e(dd_agent_check, instance): aggregator = dd_agent_check(instance) aggregator.assert_metric('network.tcp.can_connect', value=1, count=1) aggregator.assert_service_check('tcp.can_connect', status=TCPCheck.OK, count=1) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_integration_replicaset_arbiter(instance_integration, aggregator, check, dd_run_check): for query in instance_integration['custom_queries']: query['run_on_secondary'] = True instance_integration['is_arbiter'] = True mongo_check = check(instance_integration) mongo_check.last_states_by_server = {0: 2, 1: 1, 2: 7, 3: 2} with mock_pymongo("replica-arbiter"): dd_run_check(mongo_check) replica_tags = ['replset_name:replset', 'replset_state:arbiter'] metrics_categories = ['serverStatus', 'replset-arbiter'] _assert_metrics(aggregator, metrics_categories, replica_tags) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata( get_metadata_metrics(), exclude=[ 'dd.custom.mongo.aggregate.total', 'dd.custom.mongo.count', 'dd.custom.mongo.query_a.amount', 'dd.custom.mongo.query_a.el', ], check_submission_type=True, ) assert len(aggregator._events) == 0
def test_standalone(instance_integration, aggregator, check): mongo_check = check(instance_integration) mongo_check.last_states_by_server = {0: 2, 1: 1, 2: 7, 3: 2} with mock_pymongo("standalone"): mongo_check.check(None) metrics_categories = [ 'default', 'custom-queries', 'top', 'dbstats-local', 'fsynclock', 'dbstats', 'indexes-stats', 'collection', ] _assert_metrics(aggregator, metrics_categories) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata( get_metadata_metrics(), exclude=[ 'dd.custom.mongo.aggregate.total', 'dd.custom.mongo.count', 'dd.custom.mongo.query_a.amount', 'dd.custom.mongo.query_a.el', ], check_submission_type=True, ) assert len(aggregator._events) == 0
def test_check(aggregator, instance): # type: (AggregatorStub, Dict[str, Any]) -> None check = IbmICheck('ibm_i', {}, [instance]) check.check(instance) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_integration_replicaset_primary_in_shard(instance_integration, aggregator, check): mongo_check = check(instance_integration) mongo_check.last_states_by_server = {0: 2, 1: 1, 2: 7, 3: 2} with mock_pymongo("replica-primary-in-shard"): mongo_check.check(None) replica_tags = ['replset_name:mongo-mongodb-sharded-shard-0', 'replset_state:primary'] metrics_categories = ['default', 'custom-queries', 'oplog', 'replset-primary', 'top', 'dbstats-local', 'fsynclock'] _assert_metrics(aggregator, metrics_categories, replica_tags) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata( get_metadata_metrics(), exclude=[ 'dd.custom.mongo.aggregate.total', 'dd.custom.mongo.count', 'dd.custom.mongo.query_a.amount', 'dd.custom.mongo.query_a.el', ], check_metric_type=False, ) assert len(aggregator._events) == 3 aggregator.assert_event( "MongoDB mongo-mongodb-sharded-shard0-data-0.mongo-mongodb-sharded-headless.default.svc.cluster.local:27017 " "(_id: 0, mongodb://testUser2:*****@localhost:27017/test) just reported as Primary (PRIMARY) for " "mongo-mongodb-sharded-shard-0; it was SECONDARY before.", tags=[ 'action:mongo_replset_member_status_change', 'member_status:PRIMARY', 'previous_member_status:SECONDARY', 'replset:mongo-mongodb-sharded-shard-0', ], count=1, ) aggregator.assert_event( "MongoDB mongo-mongodb-sharded-shard0-arbiter-0.mongo-mongodb-sharded-headless.default.svc.cluster.local:27017 " "(_id: 1, mongodb://testUser2:*****@localhost:27017/test) just reported as Arbiter (ARBITER) for " "mongo-mongodb-sharded-shard-0; it was PRIMARY before.", tags=[ 'action:mongo_replset_member_status_change', 'member_status:ARBITER', 'previous_member_status:PRIMARY', 'replset:mongo-mongodb-sharded-shard-0', ], count=1, ) aggregator.assert_event( "MongoDB mongo-mongodb-sharded-shard0-data-1.mongo-mongodb-sharded-headless.default.svc.cluster.local:27017 " "(_id: 2, mongodb://testUser2:*****@localhost:27017/test) just reported as Secondary (SECONDARY) " "for mongo-mongodb-sharded-shard-0; it was ARBITER before.", tags=[ 'action:mongo_replset_member_status_change', 'member_status:SECONDARY', 'previous_member_status:ARBITER', 'replset:mongo-mongodb-sharded-shard-0', ], count=1, )
def test_integration(instance_custom_queries, aggregator, mock_pymongo, check): instance_custom_queries["additional_metrics"] = [ "metrics.commands", "tcmalloc", "collection", "top" ] instance_custom_queries["collections"] = ["foo", "bar"] instance_custom_queries["collections_indexes_stats"] = True mongo_check = check(instance_custom_queries) # Set node as "secondary" initially to trigger an event mongo_check._last_state_by_server[mongo_check.clean_server_name] = 2 mongo_check.check(instance_custom_queries) expected_metrics = [] with open(os.path.join(HERE, "results", "metrics.json"), 'r') as f: expected_metrics = json.load(f) for metric in expected_metrics: aggregator.assert_metric(metric['name'], value=metric['value'], tags=metric['tags'], metric_type=metric['type']) aggregator.assert_all_metrics_covered() metadata_metrics = get_metadata_metrics() aggregator.assert_metrics_using_metadata( metadata_metrics, exclude=[ 'dd.custom.mongo.aggregate.total', 'dd.custom.mongo.count', 'dd.custom.mongo.query_a.amount', 'dd.custom.mongo.query_a.el', ], check_metric_type=False, ) # Additionally assert that all metrics in the metadata.csv were submitted in this check run: for metric in metadata_metrics: assert [ x for x in expected_metrics if x['name'] == metric ], "Metric {} is in metadata.csv but was not submitted.".format(metric) assert len(aggregator._service_checks) == 1 aggregator.assert_service_check( 'mongodb.can_connect', AgentCheck.OK, tags=['db:test', 'host:localhost', 'port:27017']) assert len(aggregator._events) == 1 aggregator.assert_event( "MongoDB stubbed.hostname (mongodb://testUser2:*****@localhost:27017/test) " "just reported as Primary (PRIMARY) for shard01; it was SECONDARY before.", tags=[ 'action:mongo_replset_member_status_change', 'member_status:PRIMARY', 'previous_member_status:SECONDARY', 'replset:shard01', ], )
def test_e2e(dd_agent_check): aggregator = dd_agent_check(CONFIG) for metric in METRICS: aggregator.assert_metric(metric) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_e2e(dd_agent_check, instance_e2e): aggregator = dd_agent_check(instance_e2e) for metric in EXPECTED_METRICS: aggregator.assert_metric(metric, at_least=0) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_check(aggregator, instance): check = MaprCheck('mapr', {}, [instance]) check.check(instance) for m in METRICS_IN_FIXTURE: aggregator.assert_metric(m) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_check(mock_client, get_expected_metrics, aggregator, unit_instance, dd_run_check): check = AviVantageCheck('avi_vantage', {}, [unit_instance]) dd_run_check(check) aggregator.assert_service_check("avi_vantage.can_connect", AviVantageCheck.OK) for metric in get_expected_metrics(): aggregator.assert_metric(metric['name'], metric['value'], metric['tags'], metric_type=metric['type']) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_agent_check(aggregator, agent_instance_use_openmetrics, mock_agent_data, dd_run_check, check): c = check(agent_instance_use_openmetrics(True)) dd_run_check(c) for m in AGENT_V2_METRICS: aggregator.assert_metric(m) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_check_ok(dd_agent_check): aggregator = dd_agent_check(rate=True) metrics = common.FORMATTED_EXTRA_METRICS for metric in metrics: aggregator.assert_metric(metric) aggregator.assert_metrics_using_metadata(get_metadata_metrics())
def test_complex_config(aggregator, instance_complex): mysql_check = MySql(common.CHECK_NAME, {}, instances=[instance_complex]) mysql_check.check(instance_complex) _assert_complex_config(aggregator) aggregator.assert_metrics_using_metadata( get_metadata_metrics(), check_submission_type=True, exclude=['alice.age', 'bob.age'] + variables.STATEMENT_VARS )
def test_check_ok_omv2(dd_agent_check, omv2_instance): aggregator = dd_agent_check(omv2_instance, rate=True) for metric in METRICS_V2: aggregator.assert_metric(metric) aggregator.assert_all_metrics_covered() aggregator.assert_metrics_using_metadata(get_metadata_metrics(), check_submission_type=True)