def test_namespace(self, aggregator):
        check = AgentCheck()
        check.__NAMESPACE__ = 'test'

        check.gauge('metric', 0)

        aggregator.assert_metric('test.metric')
Exemple #2
0
    def test_metric_limit_instance_config_zero_unlimited(self, aggregator):
        instances = [{"max_returned_metrics": 0}]
        check = AgentCheck("test", {}, instances)
        assert len(check.get_warnings()) == 0

        for _ in range(0, 42):
            check.gauge("metric", 0)
        assert len(check.get_warnings()) == 0  # get_warnings resets the array
        assert len(aggregator.metrics("metric")) == 42
    def test_metric_limit_instance_config(self, aggregator):
        instances = [{"max_returned_metrics": 42}]
        check = AgentCheck("test", {}, instances)
        assert check.get_warnings() == []

        for _ 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__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, device=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'
Exemple #5
0
    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_build_similar_elements_msg(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", None, None, None,
                                     None)
        actual_msg = similar.build_similar_elements_msg(
            expected_metric, aggregator._metrics)

        expected_msg = '''
Expected:
        MetricStub(name='test.similar_metric', type=None, value=None, tags=None, hostname=None)
Similar submitted:
Score   Most similar
0.88    MetricStub(name='test.most_similar_metric', type=0, value=0.0, tags=[], hostname='')
0.83    MetricStub(name='test.another_similar_metric', type=0, value=0.0, tags=[], hostname='')
0.62    MetricStub(name='test.very_different_metric', type=0, value=0.0, tags=[], hostname='')
0.42    MetricStub(name='test.very_very_different', type=0, value=0.0, tags=[], hostname='')
        '''
        assert expected_msg.strip() == actual_msg.strip(
        ), "Actual message:\n" + actual_msg
def test_assert_no_duplicate_message(aggregator):
    check = AgentCheck()
    check.gauge('check.metric.dup1', 1, tags=['aa'])
    check.gauge('check.metric.dup1', 2, tags=['aa'])
    check.gauge('check.metric.dup2', 3, tags=['aa'])
    check.gauge('check.metric.dup2', 4, tags=['aa'])
    check.gauge('check.metric.no_dup1', 5, tags=['aa'])
    check.gauge('check.metric.no_dup2', 6, tags=['aa'])

    actual_msg = ""
    try:
        aggregator.assert_no_duplicate_metrics()
    except AssertionError as e:
        actual_msg = str(e)

    expected_msg = '''
Duplicate metrics found:
  - check.metric.dup1
      MetricStub(name='check.metric.dup1', type=0, value=1.0, tags=['aa'], hostname='')
      MetricStub(name='check.metric.dup1', type=0, value=2.0, tags=['aa'], hostname='')
  - check.metric.dup2
      MetricStub(name='check.metric.dup2', type=0, value=3.0, tags=['aa'], hostname='')
      MetricStub(name='check.metric.dup2', type=0, value=4.0, tags=['aa'], hostname='')
'''
    print("\n===\n{}\n===\n".format(expected_msg.strip()))
    print("\n===\n{}\n===\n".format(actual_msg.strip()))
    assert expected_msg.strip() == actual_msg.split("assert")[0].strip()
Exemple #8
0
    def test_build_similar_elements_msg(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", None, None, None,
                                     None, None)
        actual_msg = similar.build_similar_elements_msg(
            expected_metric, aggregator._metrics).strip()

        expected_msg = '''
    Expected:
        MetricStub(name='test.similar_metric', type=None, value=None, tags=None, hostname=None, device=None, flush_first_value=None)
Similar submitted:
Score   Most similar
0.88    MetricStub(name='test.most_similar_metric', type=0, value=0.0, tags=[], hostname='', device=None, flush_first_value=False)
0.83    MetricStub(name='test.another_similar_metric', type=0, value=0.0, tags=[], hostname='', device=None, flush_first_value=False)
0.62    MetricStub(name='test.very_different_metric', type=0, value=0.0, tags=[], hostname='', device=None, flush_first_value=False)
0.42    MetricStub(name='test.very_very_different', type=0, value=0.0, tags=[], hostname='', device=None, flush_first_value=False)
    '''.strip()  # noqa: E501
        delta = difflib.ndiff([expected_msg], [actual_msg])
        assert expected_msg == actual_msg, delta
def test_assert_no_duplicate_message(aggregator):
    check = AgentCheck()
    check.gauge('check.metric.dup1', 1, tags=['aa'])
    check.gauge('check.metric.dup1', 2, tags=['aa'])
    check.gauge('check.metric.dup2', 3, tags=['aa'])
    check.gauge('check.metric.dup2', 4, tags=['aa'])
    check.gauge('check.metric.no_dup1', 5, tags=['aa'])
    check.gauge('check.metric.no_dup2', 6, tags=['aa'])

    actual_msg = "  "
    try:
        aggregator.assert_no_duplicate_metrics()
    except AssertionError as e:
        actual_msg += str(e).split("assert")[0].lstrip()
    actual_msg = dedent(actual_msg)

    expected_msg = '''
Duplicate metrics found:
- check.metric.dup1
    MetricStub(name='check.metric.dup1', type=0, value=1.0, tags=['aa'], hostname='', device=None, flush_first_value=False)
    MetricStub(name='check.metric.dup1', type=0, value=2.0, tags=['aa'], hostname='', device=None, flush_first_value=False)
- check.metric.dup2
    MetricStub(name='check.metric.dup2', type=0, value=3.0, tags=['aa'], hostname='', device=None, flush_first_value=False)
    MetricStub(name='check.metric.dup2', type=0, value=4.0, tags=['aa'], hostname='', device=None, flush_first_value=False)
'''  # noqa: E501
    assert expected_msg.strip() == actual_msg.strip()
    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__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__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_non_float_metric(self, aggregator):
     check = AgentCheck()
     metric_name = 'test_metric'
     with pytest.raises(ValueError):
         check.gauge(metric_name, '85k')
     aggregator.assert_metric(metric_name, count=0)