Monitored Resource: replace gke_container with k8s_container in Stack… (#322)

* Monitored Resource: replace gke_container with k8s_container in Stackdriver exporter

* minor fix

Author: mayurkale22

.gitignore

@@ -63,3 +63,6 @@ system_tests/local_test_setup
 # Make sure a generated file isn't accidentally committed.
 pylintrc
 pylintrc.test
+
+# Ignore default file, used for exporting the trace spans.
+opencensus-traces.json

examples/stats/exporter/stackdriver.py

@@ -53,10 +53,10 @@
 
 # Process video.
 # Record the processed video size.
-tag_value = tag_value_module.TagValue(1200)
+tag_value = tag_value_module.TagValue(str(1200))
 tag_map = tag_map_module.TagMap()
 tag_map.insert(FRONTEND_KEY, tag_value)
 measure_map = stats_recorder.new_measurement_map()
 measure_map.measure_int_put(VIDEO_SIZE_MEASURE, 25 * MiB)
 
-measure_map.record(tag_map)
+measure_map.record(tag_map)

opencensus/stats/exporters/stackdriver_exporter.py

@@ -32,6 +32,7 @@
 CONS_TIME_SERIES = "timeseries"
 EPOCH_DATETIME = datetime(1970, 1, 1)
 EPOCH_PATTERN = "%Y-%m-%dT%H:%M:%S.%fZ"
+GLOBAL_RESOURCE_TYPE = 'global'
 
 
 class Options(object):
@@ -188,26 +189,14 @@ def make_request(self, view_data, limit):
                 time_series = []
         return requests
 
-    def create_time_series_list(self, v_data, resource_type, metric_prefix):
+    def create_time_series_list(self, v_data, option_resource_type,
+                                metric_prefix):
         """ Create the TimeSeries object based on the view data
         """
         series = monitoring_v3.types.TimeSeries()
         series.metric.type = namespaced_view_name(v_data.view.name,
                                                   metric_prefix)
-
-        if resource_type == "":
-            monitor_resource = MonitoredResourceUtil.get_instance()
-            if monitor_resource is not None:
-                series.resource.type = monitor_resource.resource_type
-                labels = monitor_resource.get_resource_labels()
-                for attribute_key, attribute_value in labels.items():
-                    attribute_value = 'aws:' + attribute_value if \
-                        attribute_key == 'region' else attribute_value
-                    series.resource.labels[attribute_key] = attribute_value
-            else:
-                series.resource.type = 'global'
-        else:
-            series.resource.type = resource_type
+        set_monitored_resource(series, option_resource_type)
 
         tag_agg = v_data.tag_value_aggregation_data_map
         for tag_value, agg in tag_agg.items():
@@ -330,6 +319,65 @@ def create_metric_descriptor(self, view):
         return descriptor
 
 
+def set_monitored_resource(series, option_resource_type):
+    """Set a resource(type and labels) that can be used for monitoring.
+    :param series: TimeSeries object based on view data
+    :param option_resource_type: Resource is an optional field that
+    represents the Stackdriver MonitoredResource type.
+    """
+    resource_type = GLOBAL_RESOURCE_TYPE
+
+    if option_resource_type == "":
+        monitored_resource = MonitoredResourceUtil.get_instance()
+        if monitored_resource is not None:
+            resource_labels = monitored_resource.get_resource_labels()
+
+            if monitored_resource.resource_type == 'gke_container':
+                resource_type = 'k8s_container'
+                set_attribute_label(series, resource_labels, 'project_id')
+                set_attribute_label(series, resource_labels, 'cluster_name')
+                set_attribute_label(series, resource_labels, 'container_name')
+                set_attribute_label(series, resource_labels, 'namespace_id',
+                                    'namespace_name')
+                set_attribute_label(series, resource_labels, 'pod_id',
+                                    'pod_name')
+                set_attribute_label(series, resource_labels, 'zone',
+                                    'location')
+
+            elif monitored_resource.resource_type == 'gce_instance':
+                resource_type = monitored_resource.resource_type
+                set_attribute_label(series, resource_labels, 'project_id')
+                set_attribute_label(series, resource_labels, 'instance_id')
+                set_attribute_label(series, resource_labels, 'zone')
+
+            elif monitored_resource.resource_type == 'aws_ec2_instance':
+                resource_type = monitored_resource.resource_type
+                set_attribute_label(series, resource_labels, 'aws_account')
+                set_attribute_label(series, resource_labels, 'instance_id')
+                set_attribute_label(series, resource_labels, 'region',
+                                    label_value_prefix='aws:')
+    else:
+        resource_type = option_resource_type
+    series.resource.type = resource_type
+
+
+def set_attribute_label(series, resource_labels, attribute_key,
+                        canonical_key=None, label_value_prefix=''):
+    """Set a label to timeseries that can be used for monitoring
+    :param series: TimeSeries object based on view data
+    :param resource_labels: collection of labels
+    :param attribute_key: actual label key
+    :param canonical_key: exporter specific label key, Optional
+    :param label_value_prefix: exporter specific label value prefix, Optional
+    """
+    if attribute_key in resource_labels:
+        if canonical_key is None:
+            canonical_key = attribute_key
+
+        series.resource.labels[canonical_key] = \
+            label_value_prefix + resource_labels[attribute_key]
+
+
 def new_stats_exporter(options):
     """ new_stats_exporter returns an exporter that
         uploads stats data to Stackdriver Monitoring.

opencensus/trace/exporters/stackdriver_exporter.py

@@ -77,21 +77,68 @@ def set_attributes(trace):
 
 
 def set_monitored_resource_attributes(span):
+    """Set labels to span that can be used for tracing.
+    :param span: Span object
+    """
     monitored_resource = MonitoredResourceUtil.get_instance()
-
     if monitored_resource is not None:
+        resource_type = monitored_resource.resource_type
         resource_labels = monitored_resource.get_resource_labels()
-        for attribute_key, attribute_value in resource_labels.items():
-
-            attribute_value = 'aws:' + attribute_value if \
-                attribute_key == 'region' else attribute_value
-            pair = {RESOURCE_LABEL % (monitored_resource.resource_type,
-                                      attribute_key): attribute_value}
-            pair_attrs = Attributes(pair) \
-                .format_attributes_json() \
-                .get('attributeMap')
 
-            _update_attr_map(span, pair_attrs)
+        if resource_type == 'gke_container':
+            resource_type = 'k8s_container'
+            set_attribute_label(span, resource_type, resource_labels,
+                                'project_id')
+            set_attribute_label(span, resource_type, resource_labels,
+                                'cluster_name')
+            set_attribute_label(span, resource_type, resource_labels,
+                                'container_name')
+            set_attribute_label(span, resource_type, resource_labels,
+                                'namespace_id', 'namespace_name')
+            set_attribute_label(span, resource_type, resource_labels,
+                                'pod_id', 'pod_name')
+            set_attribute_label(span, resource_type, resource_labels,
+                                'zone', 'location')
+
+        elif resource_type == 'gce_instance':
+            set_attribute_label(span, resource_type, resource_labels,
+                                'project_id')
+            set_attribute_label(span, resource_type, resource_labels,
+                                'instance_id')
+            set_attribute_label(span, resource_type, resource_labels,
+                                'zone')
+
+        elif resource_type == 'aws_ec2_instance':
+            set_attribute_label(span, resource_type, resource_labels,
+                                'aws_account')
+            set_attribute_label(span, resource_type, resource_labels,
+                                'instance_id')
+            set_attribute_label(span, resource_type, resource_labels,
+                                'region', label_value_prefix='aws:')
+
+
+def set_attribute_label(span, resource_type, resource_labels, attribute_key,
+                        canonical_key=None, label_value_prefix=''):
+    """Set a label to span that can be used for tracing.
+    :param span: Span object
+    :param resource_type: resource type
+    :param resource_labels: collection of labels
+    :param attribute_key: actual label key
+    :param canonical_key: exporter specific label key, Optional
+    :param label_value_prefix: exporter specific label value prefix, Optional
+    """
+
+    if attribute_key in resource_labels:
+        if canonical_key is None:
+            canonical_key = attribute_key
+
+        pair = {RESOURCE_LABEL % (resource_type, canonical_key):
+                label_value_prefix + resource_labels[attribute_key]
+                }
+        pair_attrs = Attributes(pair).format_attributes_json()\
+            .get('attributeMap')
+
+        _update_attr_map(span, pair_attrs)
 
 
 def set_common_attributes(span):

tests/unit/stats/exporter/test_stackdriver_stats.py

@@ -335,6 +335,7 @@ def test_create_timeseries_with_resource(self, monitor_resource_mock):
 
         v_data = measure_map.measure_to_view_map.get_view(VIDEO_SIZE_VIEW_NAME, None)
 
+        # check for gce_instance monitored resource
         mocked_labels = {
             'instance_id': 'my-instance',
             'project_id': 'my-project',
@@ -351,11 +352,68 @@ def test_create_timeseries_with_resource(self, monitor_resource_mock):
         self.assertEquals(time_series.resource.type, "gce_instance")
         self.assertEquals(time_series.metric.type, "custom.googleapis.com/opencensus/my.org/views/video_size_test2")
         self.assertIsNotNone(time_series)
+        self.assertEquals(time_series.resource.labels['instance_id'], 'my-instance')
+        self.assertEquals(time_series.resource.labels['project_id'], 'my-project')
+        self.assertEquals(time_series.resource.labels['zone'], 'us-east1')
 
         time_series = exporter.create_time_series_list(v_data, "global", "")
         self.assertEquals(time_series.metric.type, "custom.googleapis.com/opencensus/my.org/views/video_size_test2")
         self.assertIsNotNone(time_series)
 
+        # check for gke_container monitored resource
+        mocked_labels = {
+            'instance_id': 'my-instance',
+            'project_id': 'my-project',
+            'zone': 'us-east1',
+            'pod_id': 'localhost',
+            'cluster_name': 'cluster',
+            'namespace_id': 'namespace'
+        }
+
+        monitor_resource_mock.return_value = mock.Mock()
+        monitor_resource_mock.return_value.resource_type = 'gke_container'
+        monitor_resource_mock.return_value.get_resource_labels.return_value = mocked_labels
+
+        time_series = exporter.create_time_series_list(v_data, "", "")
+        self.assertEquals(time_series.resource.type, "k8s_container")
+        self.assertEquals(time_series.metric.type, "custom.googleapis.com/opencensus/my.org/views/video_size_test2")
+        self.assertIsNotNone(time_series)
+        self.assertEquals(time_series.resource.labels['project_id'], 'my-project')
+        self.assertEquals(time_series.resource.labels['location'], 'us-east1')
+        self.assertEquals(time_series.resource.labels['pod_name'], 'localhost')
+        self.assertEquals(time_series.resource.labels['namespace_name'], 'namespace')
+        self.assertEquals(time_series.resource.labels['container_name'], '')
+
+        # check for aws_ec2_instance monitored resource
+        mocked_labels = {
+            'instance_id': 'my-instance',
+            'aws_account': 'my-project',
+            'region': 'us-east1',
+        }
+
+        monitor_resource_mock.return_value = mock.Mock()
+        monitor_resource_mock.return_value.resource_type = 'aws_ec2_instance'
+        monitor_resource_mock.return_value.get_resource_labels.return_value = mocked_labels
+
+        time_series = exporter.create_time_series_list(v_data, "", "")
+        self.assertEquals(time_series.resource.type, "aws_ec2_instance")
+        self.assertEquals(time_series.metric.type, "custom.googleapis.com/opencensus/my.org/views/video_size_test2")
+        self.assertIsNotNone(time_series)
+        self.assertEquals(time_series.resource.labels['instance_id'], 'my-instance')
+        self.assertEquals(time_series.resource.labels['aws_account'], 'my-project')
+        self.assertEquals(time_series.resource.labels['region'], 'aws:us-east1')
+
+        # check for out of box monitored resource
+        monitor_resource_mock.return_value = mock.Mock()
+        monitor_resource_mock.return_value.resource_type = ''
+        monitor_resource_mock.return_value.get_resource_labels.return_value = mock.Mock()
+
+        time_series = exporter.create_time_series_list(v_data, "", "")
+        self.assertEquals(time_series.resource.type, 'global')
+        self.assertEquals(time_series.metric.type, "custom.googleapis.com/opencensus/my.org/views/video_size_test2")
+        self.assertIsNotNone(time_series)
+
+
     @mock.patch('opencensus.stats.exporters.stackdriver_exporter.'
                 'MonitoredResourceUtil.get_instance', return_value=None)
     def test_create_timeseries_str_tagvalue(self, monitor_resource_mock):