Improve support for querying for definitions and add support for upcoming feature of 0.16.0 to support querying tag values

Author: burmanm

hawkular/metrics.py

@@ -34,10 +34,10 @@
 """
 TODO: Search datapoints with tags.. tag datapoints.
 TODO: Allow changing instance's tenant?
-TODO: Authentication when it's done..
+TODO: Authentication
 TODO: Remove HawkularMetricsConnectionError and use HawkularMetricsError only?
 TODO: HWKMETRICS-110 (fetching a single definition)
-TODO: Tag queries, stats queries
+TODO: Stats queries
 """
 
 class MetricType:
@@ -50,6 +50,8 @@ class MetricType:
     def short(metric_type):
         if metric_type is MetricType.Gauge:
             return 'gauge'
+        elif metric_type is MetricType.Counter:
+            return 'counter'
         else:
             return 'availability'
 
@@ -132,6 +134,10 @@ def _get_metrics_tags_url(self, metrics_url):
 
     def _get_tenants_url(self):
         return self._get_base_url() + 'tenants'
+
+    @staticmethod
+    def _transform_tags(**tags):
+        return ','.join("%s:%s" % (key,val) for (key,val) in tags.items())
 
     def _http(self, url, method, data=None):
         res = None
@@ -281,16 +287,38 @@ def query_single_availability(self, metric_id, **search_options):
         """
         return self.query_metric(MetricType.Availability, metric_id, **search_options)
 
-    def query_definitions(self, query_type):
+    def query_definitions(self, metric_type=None, id_filter=None, **tags):
+        """
+        Query available metric definitions. Available query options are id_filter for id filtering and tags (dict) as tag based query.
+        Tags filtering is required for the id filtering to work.
+        """
+        if id is not None and tags is None:
+            raise HawkularMetricsError('Tags query is required when id filter is used')
+
+        params = {}
+
+        if metric_type is not None:
+            params = { 'type': MetricType.short(metric_type) }
+
+        if len(tags) > 0:
+            params['tags'] = self._transform_tags(**tags)
+
+        return self._get(self._get_url('metrics'), **params)
+
+    def query_tagvalues(self, metric_type=None, **tags):
         """
-        Query available metric definitions. 
+        Query for possible tag values.
         """
-        definition_url = self._get_url('metrics') + '?type=' + MetricType.short(query_type)
-        return self._get(definition_url)
+        tagql = self._transform_tags(**tags)
+
+        if metric_type is None:
+            metric_type = 'metrics'
+
+        return self._get(self._get_metrics_tags_url(self._get_url(metric_type)) + '/{}'.format(tagql))
 
     def create_metric_definition(self, metric_type, metric_id, **tags):
         """
-        Create metric definition with custom definition. **options should be a set of tags, such as
+        Create metric definition with custom definition. **tags should be a set of tags, such as
         units, env ..
 
         Use methods create_gauge_definition and create_availability_definition to avoid using
@@ -334,7 +362,6 @@ def query_metric_tags(self, metric_type, metric_id):
         """
         definition = self._get(self._get_metrics_tags_url(self._get_metrics_single_url(metric_type, metric_id)))
         return definition
-        # return definition.get('tags', {})
 
     def update_metric_tags(self, metric_type, metric_id, **tags):
         """
@@ -346,7 +373,7 @@ def delete_metric_tags(self, metric_type, metric_id, **deleted_tags):
         """
         Delete one or more tags from the metric definition. The tag values must match what's stored on the server.
         """
-        tags = ','.join("%s:%s" % (key,val) for (key,val) in deleted_tags.items())
+        tags = self._transform_tags(**deleted_tags)
         tags_url = self._get_metrics_tags_url(self._get_metrics_single_url(metric_type, metric_id)) + '/{0}'.format(tags)
 
         self._delete(tags_url)    

hawkular/metrics_test.py

@@ -42,14 +42,7 @@ def test_tenant_creation(self):
         self.assertIn(expect, tenants)
 
     def test_tenant_creation_with_retentions_and_aggregations(self):
-        # This feature isn't finished in the current master version of Hawkular-Metrics
         pass
-        # tenant = str(uuid.uuid4())
-        # self.client.create_tenant(tenant, 40)
-        # tenants = self.client.query_tenants()
-
-        # expect = { 'id': tenant, 'dataRetention': 40 }
-        # self.assertIn(expect, tenants)
 
 class MetricsTestCase(TestMetricFunctionsBase):
     """
@@ -122,18 +115,18 @@ def test_tags_modifications(self):
         tags_2 = self.client.query_metric_tags(MetricType.Gauge, m)
         self.assertEqual(0, len(tags_2))
 
-    # def test_tags_behavior(self):
-    #     print 'START: TEST TAGS'
-    #     metric = float(1.2345)
-    #     print 'CREATE'
-    #     self.client.create_gauge_definition('test.gauge.single.tags.1', hostname='')
-    #     print 'POST'
-    #     self.client.push('test.gauge.single.tags.1', metric, hostname='localhost')
-    #     print 'GET'
-    #     data = self.client.query_single_gauge('test.gauge.single.tags.1')
-    #     print data
-    #     print 'END: TEST TAGS'
-    
+    def test_tags_queries(self):
+        for i in range(1,9):
+            m_id = 'test.query.tags.{}'.format(i)
+            hostname = 'host{}'.format(i)
+            self.client.create_metric_definition(MetricType.Counter, m_id, hostname=hostname, env='qa')
+
+        mds = self.client.query_definitions(hostname='host[123]')
+        self.assertEqual(3, len(mds))
+
+        values = self.client.query_tagvalues(MetricType.Counter, hostname='host*', env='qa')
+        self.assertEqual(2, len(values))
+
     def test_add_gauge_single(self):
         # Normal way
         value = float(4.35)
@@ -223,21 +216,6 @@ def test_query_options(self):
         # Query for data which has start time limitation
         d = self.client.query_metric(MetricType.Gauge, 'test.query.gauge.1', start=(t-1000))
         self.assertEqual(1, len(d))
-
-    # This feature isn't really ready for prime time in Hawkular-Metrics yet.. 
-    # def test_tags_finding(self):        
-    #     # Create metrics with tags
-    #     m = 'test.create.data.tags.1'
-    #     self.client.create_metric_definition(MetricType.Gauge, m, ab='cd')
-    #     # Push some data to them
-    #     t = time_millis()
-    #     v = float(1.4)
-    #     self.client.push(MetricType.Gauge, m, v, t)
-    #     # Fetch data with certain tags
-    #     expected = { 'id': m, 'timestamp': t, 'value': v }
-    #     d = self.client.query_data_with_tags(MetricType.Gauge, ab='cd')
-    #     self.assertIsNotNone(d)
-    #     self.assertIn(expected, d)        
 
 if __name__ == '__main__':
     unittest.main()