示例#1
0
    def test__build_similar_elements__metric_device(self, aggregator):
        metrics = {
            'test.similar_metric2': [
                MetricStub('test.similar_metric2', AggregatorStub.GAUGE, 10,
                           [], None, 'less_similar_device')
            ],
            'test.similar_metric1': [
                MetricStub('test.similar_metric1', AggregatorStub.GAUGE, 10,
                           [], None, 'similar_device')
            ],
            'test.similar_metric3': [
                MetricStub('test.similar_metric3', AggregatorStub.GAUGE, 10,
                           [], None, 'different')
            ],
        }

        expected_metric = MetricStub("test.test.similar_metric",
                                     type=None,
                                     value=10,
                                     tags=None,
                                     hostname=None,
                                     device='similar_device')
        similar_metrics = similar._build_similar_elements(
            expected_metric, 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_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
示例#3
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
示例#4
0
    def assert_metric(self,
                      name,
                      value=None,
                      tags=None,
                      count=None,
                      at_least=1,
                      hostname=None,
                      metric_type=None,
                      device=None):
        """
        Assert a metric was processed by this stub
        """

        self._asserted.add(name)
        expected_tags = normalize_tags(tags, sort=True)

        candidates = []
        for metric in self.metrics(name):
            if value is not None and not self.is_aggregate(
                    metric.type) and value != metric.value:
                continue

            if expected_tags and expected_tags != sorted(metric.tags):
                continue

            if hostname and hostname != metric.hostname:
                continue

            if metric_type is not None and metric_type != metric.type:
                continue

            if device is not None and device != metric.device:
                continue

            candidates.append(metric)

        expected_metric = MetricStub(name, metric_type, value, tags, hostname,
                                     device)

        if value is not None and candidates and all(
                self.is_aggregate(m.type) for m in candidates):
            got = sum(m.value for m in candidates)
            msg = "Expected count value for '{}': {}, got {}".format(
                name, value, got)
            condition = value == got
        elif count is not None:
            msg = "Needed exactly {} candidates for '{}', got {}".format(
                count, name, len(candidates))
            condition = len(candidates) == count
        else:
            msg = "Needed at least {} candidates for '{}', got {}".format(
                at_least, name, len(candidates))
            condition = len(candidates) >= at_least
        self._assert(condition,
                     msg=msg,
                     expected_stub=expected_metric,
                     submitted_elements=self._metrics)
示例#5
0
def normalize_stub_metric(stub, tags_to_skip):
    tags = [t for t in stub.tags if not is_skipped_tag(t, tags_to_skip)]  # Remove skipped tag
    return MetricStub(
        stub.name,
        stub.type,
        stub.value,
        tags,
        stub.hostname,
        stub.device,
    )
示例#6
0
def normalize_stub_metric(stub):
    tags = [t for t in stub.tags
            if not t.startswith('loader:')]  # Remove `loader` tag
    return MetricStub(
        stub.name,
        stub.type,
        stub.value,
        tags,
        stub.hostname,
        stub.device,
    )
示例#7
0
 def submit_metric_e2e(self,
                       check,
                       check_id,
                       mtype,
                       name,
                       value,
                       tags,
                       hostname,
                       device=None):
     # Device is only present in metrics read from the real agent in e2e tests. Normally it is submitted as a tag
     if not self.ignore_metric(name):
         self._metrics[name].append(
             MetricStub(name, mtype, value, tags, hostname, device))
示例#8
0
 def metrics(self, name):
     """
     Return the metrics received under the given name
     """
     return [
         MetricStub(
             ensure_unicode(stub.name),
             stub.type,
             stub.value,
             normalize_tags(stub.tags),
             ensure_unicode(stub.hostname),
         ) for stub in self._metrics.get(to_string(name), [])
     ]
    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'
    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'
示例#12
0
    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'
示例#13
0
 def submit_metric(self, check, check_id, mtype, name, value, tags,
                   hostname):
     if not self.ignore_metric(name):
         self._metrics[name].append(
             MetricStub(name, mtype, value, tags, hostname, None))