support GKE resource detection (#24)

add support for GKE resource detection

Author: Andrew Xue

opentelemetry-exporter-cloud-monitoring/src/opentelemetry/exporter/cloud_monitoring/__init__.py

@@ -23,10 +23,19 @@
 
 OT_RESOURCE_LABEL_TO_GCP = {
     "gce_instance": {
+        "host.id": "instance_id",
         "cloud.account.id": "project_id",
+        "cloud.zone": "zone",
+    },
+    "gke_container": {
+        "k8s.cluster.name": "cluster_name",
+        "k8s.namespace.name": "namespace_id",
+        "k8s.pod.name": "pod_id",
         "host.id": "instance_id",
+        "container.name": "container_name",
+        "cloud.account.id": "project_id",
         "cloud.zone": "zone",
-    }
+    },
 }
 
 

opentelemetry-exporter-cloud-trace/src/opentelemetry/exporter/cloud_trace/__init__.py

@@ -303,10 +303,19 @@ def _strip_characters(ot_version):
 
 OT_RESOURCE_LABEL_TO_GCP = {
     "gce_instance": {
+        "host.id": "instance_id",
         "cloud.account.id": "project_id",
+        "cloud.zone": "zone",
+    },
+    "gke_container": {
+        "k8s.cluster.name": "cluster_name",
+        "k8s.namespace.name": "namespace_id",
+        "k8s.pod.name": "pod_id",
         "host.id": "instance_id",
+        "container.name": "container_name",
+        "cloud.account.id": "project_id",
         "cloud.zone": "zone",
-    }
+    },
 }
 
 

opentelemetry-exporter-cloud-trace/src/opentelemetry/tools/resource_detector.py

@@ -1,3 +1,5 @@
+import os
+
 import requests
 from opentelemetry.context import attach, detach, set_value
 from opentelemetry.sdk.resources import Resource, ResourceDetector
@@ -8,27 +10,82 @@
 _GCP_METADATA_URL_HEADER = {"Metadata-Flavor": "Google"}
 
 
-def get_gce_resources():
-    """ Resource finder for common GCE attributes
-
-        See: https://cloud.google.com/compute/docs/storing-retrieving-metadata
-    """
+def _get_google_metadata_and_common_attributes():
     token = attach(set_value("suppress_instrumentation", True))
     all_metadata = requests.get(
         _GCP_METADATA_URL, headers=_GCP_METADATA_URL_HEADER
     ).json()
     detach(token)
-    gce_resources = {
-        "host.id": all_metadata["instance"]["id"],
+    common_attributes = {
         "cloud.account.id": all_metadata["project"]["projectId"],
-        "cloud.zone": all_metadata["instance"]["zone"].split("/")[-1],
         "cloud.provider": "gcp",
-        "gcp.resource_type": "gce_instance",
+        "cloud.zone": all_metadata["instance"]["zone"].split("/")[-1],
     }
-    return gce_resources
+    return common_attributes, all_metadata
+
+
+def get_gce_resources():
+    """ Resource finder for common GCE attributes
+
+        See: https://cloud.google.com/compute/docs/storing-retrieving-metadata
+    """
+    (
+        common_attributes,
+        all_metadata,
+    ) = _get_google_metadata_and_common_attributes()
+    common_attributes.update(
+        {
+            "host.id": all_metadata["instance"]["id"],
+            "gcp.resource_type": "gce_instance",
+        }
+    )
+    return common_attributes
+
+
+def get_gke_resources():
+    """ Resource finder for GKE attributes
+
+    """
+    # The user must specify the container name via the Downward API
+    container_name = os.getenv("CONTAINER_NAME")
+    if container_name is None:
+        return {}
+    (
+        common_attributes,
+        all_metadata,
+    ) = _get_google_metadata_and_common_attributes()
+
+    # Fallback to reading namespace from a file is the env var is not set
+    pod_namespace = os.getenv("NAMESPACE")
+    if pod_namespace is None:
+        try:
+            with open(
+                "/var/run/secrets/kubernetes.io/serviceaccount/namespace", "r"
+            ) as namespace_file:
+                pod_namespace = namespace_file.read().strip()
+        except FileNotFoundError:
+            pod_namespace = ""
+
+    common_attributes.update(
+        {
+            "k8s.cluster.name": all_metadata["instance"]["attributes"][
+                "cluster-name"
+            ],
+            "k8s.namespace.name": pod_namespace,
+            "k8s.pod.name": os.getenv("POD_NAME", os.getenv("HOSTNAME", "")),
+            "host.id": all_metadata["instance"]["id"],
+            "container.name": container_name,
+            "gcp.resource_type": "gke_container",
+        }
+    )
+    return common_attributes
 
 
-_RESOURCE_FINDERS = [get_gce_resources]
+# Order here matters. Since a GKE_CONTAINER is a specialized type of GCE_INSTANCE
+# We need to first check if it matches the criteria for being a GKE_CONTAINER
+# before falling back and checking if its a GCE_INSTANCE.
+# This list should be sorted from most specialized to least specialized.
+_RESOURCE_FINDERS = [get_gke_resources, get_gce_resources]
 
 
 class GoogleCloudResourceDetector(ResourceDetector):
@@ -41,6 +98,12 @@ def detect(self) -> "Resource":
         if not self.cached:
             self.cached = True
             for resource_finder in _RESOURCE_FINDERS:
-                found_resources = resource_finder()
-                self.gcp_resources.update(found_resources)
+                try:
+                    found_resources = resource_finder()
+                # pylint: disable=broad-except
+                except Exception:
+                    found_resources = None
+                if found_resources:
+                    self.gcp_resources = found_resources
+                    break
         return Resource(self.gcp_resources)

opentelemetry-exporter-cloud-trace/tests/test_gcp_resource_detector.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
 import unittest
 from unittest import mock
 
@@ -20,18 +21,35 @@
     _GCP_METADATA_URL,
     GoogleCloudResourceDetector,
     get_gce_resources,
+    get_gke_resources,
 )
 
-RESOURCES_JSON_STRING = {
+NAMESPACE = "NAMESPACE"
+CONTAINER_NAME = "CONTAINER_NAME"
+HOSTNAME = "HOSTNAME"
+POD_NAME = "POD_NAME"
+
+GCE_RESOURCES_JSON_STRING = {
     "instance": {"id": "instance_id", "zone": "projects/123/zones/zone"},
     "project": {"projectId": "project_id"},
 }
 
+GKE_RESOURCES_JSON_STRING = {
+    "instance": {
+        "id": "instance_id",
+        "zone": "projects/123/zones/zone",
+        "attributes": {"cluster-name": "cluster_name"},
+    },
+    "project": {"projectId": "project_id"},
+}
+
 
+@mock.patch(
+    "opentelemetry.tools.resource_detector.requests.get",
+    **{"return_value.json.return_value": GCE_RESOURCES_JSON_STRING}
+)
 class TestGCEResourceFinder(unittest.TestCase):
-    @mock.patch("opentelemetry.tools.resource_detector.requests.get")
     def test_finding_gce_resources(self, getter):
-        getter.return_value.json.return_value = RESOURCES_JSON_STRING
         found_resources = get_gce_resources()
         self.assertEqual(getter.call_args_list[0][0][0], _GCP_METADATA_URL)
         self.assertEqual(
@@ -46,11 +64,123 @@ def test_finding_gce_resources(self, getter):
         )
 
 
+def pop_environ_key(key):
+    if key in os.environ:
+        os.environ.pop(key)
+
+
+def clear_gke_env_vars():
+    pop_environ_key(CONTAINER_NAME)
+    pop_environ_key(NAMESPACE)
+    pop_environ_key(HOSTNAME)
+    pop_environ_key(POD_NAME)
+
+
+@mock.patch(
+    "opentelemetry.tools.resource_detector.requests.get",
+    **{"return_value.json.return_value": GKE_RESOURCES_JSON_STRING}
+)
+class TestGKEResourceFinder(unittest.TestCase):
+    def tearDown(self) -> None:
+        clear_gke_env_vars()
+
+    # pylint: disable=unused-argument
+    def test_missing_container_name(self, getter):
+        pop_environ_key(CONTAINER_NAME)
+        self.assertEqual(get_gke_resources(), {})
+
+    # pylint: disable=unused-argument
+    def test_environment_empty_strings(self, getter):
+        os.environ[CONTAINER_NAME] = ""
+        os.environ[NAMESPACE] = ""
+        found_resources = get_gke_resources()
+        self.assertEqual(
+            found_resources,
+            {
+                "cloud.account.id": "project_id",
+                "k8s.cluster.name": "cluster_name",
+                "k8s.namespace.name": "",
+                "host.id": "instance_id",
+                "k8s.pod.name": "",
+                "container.name": "",
+                "cloud.zone": "zone",
+                "cloud.provider": "gcp",
+                "gcp.resource_type": "gke_container",
+            },
+        )
+
+    def test_missing_namespace_file(self, getter):
+        os.environ[CONTAINER_NAME] = "container_name"
+        found_resources = get_gke_resources()
+        self.assertEqual(
+            found_resources,
+            {
+                "cloud.account.id": "project_id",
+                "k8s.cluster.name": "cluster_name",
+                "k8s.namespace.name": "",
+                "host.id": "instance_id",
+                "k8s.pod.name": "",
+                "container.name": "container_name",
+                "cloud.zone": "zone",
+                "cloud.provider": "gcp",
+                "gcp.resource_type": "gke_container",
+            },
+        )
+
+    def test_finding_gke_resources(self, getter):
+        os.environ[NAMESPACE] = "namespace"
+        os.environ[CONTAINER_NAME] = "container_name"
+        os.environ[HOSTNAME] = "host_name"
+        found_resources = get_gke_resources()
+        self.assertEqual(getter.call_args_list[0][0][0], _GCP_METADATA_URL)
+        self.assertEqual(
+            found_resources,
+            {
+                "cloud.account.id": "project_id",
+                "k8s.cluster.name": "cluster_name",
+                "k8s.namespace.name": "namespace",
+                "host.id": "instance_id",
+                "k8s.pod.name": "host_name",
+                "container.name": "container_name",
+                "cloud.zone": "zone",
+                "cloud.provider": "gcp",
+                "gcp.resource_type": "gke_container",
+            },
+        )
+
+    def test_finding_gke_resources_with_pod_name(self, getter):
+        os.environ[NAMESPACE] = "namespace"
+        os.environ[CONTAINER_NAME] = "container_name"
+        os.environ[HOSTNAME] = "host_name"
+        os.environ[POD_NAME] = "pod_name"
+        found_resources = get_gke_resources()
+        self.assertEqual(getter.call_args_list[0][0][0], _GCP_METADATA_URL)
+        self.assertEqual(
+            found_resources,
+            {
+                "cloud.account.id": "project_id",
+                "k8s.cluster.name": "cluster_name",
+                "k8s.namespace.name": "namespace",
+                "host.id": "instance_id",
+                "k8s.pod.name": "pod_name",
+                "container.name": "container_name",
+                "cloud.zone": "zone",
+                "cloud.provider": "gcp",
+                "gcp.resource_type": "gke_container",
+            },
+        )
+
+
+@mock.patch("opentelemetry.tools.resource_detector.requests.get")
 class TestGoogleCloudResourceDetector(unittest.TestCase):
-    @mock.patch("opentelemetry.tools.resource_detector.requests.get")
-    def test_finding_resources(self, getter):
+    def tearDown(self) -> None:
+        clear_gke_env_vars()
+
+    def test_finding_gce_resources(self, getter):
+        # The necessary env variables were not set for GKE resource detection
+        # to succeed. We should be falling back to detecting GCE resources
         resource_finder = GoogleCloudResourceDetector()
-        getter.return_value.json.return_value = RESOURCES_JSON_STRING
+        getter.return_value.json.return_value = GCE_RESOURCES_JSON_STRING
         found_resources = resource_finder.detect()
         self.assertEqual(getter.call_args_list[0][0][0], _GCP_METADATA_URL)
         self.assertEqual(
@@ -82,3 +212,56 @@ def test_finding_resources(self, getter):
                 }
             ),
         )
+
+    def test_finding_gke_resources(self, getter):
+        # The necessary env variables were set for GKE resource detection
+        # to succeed. No GCE resource info should be extracted
+
+        os.environ[NAMESPACE] = "namespace"
+        os.environ[CONTAINER_NAME] = "container_name"
+        os.environ[HOSTNAME] = "host_name"
+
+        resource_finder = GoogleCloudResourceDetector()
+        getter.return_value.json.return_value = GKE_RESOURCES_JSON_STRING
+        found_resources = resource_finder.detect()
+        self.assertEqual(getter.call_args_list[0][0][0], _GCP_METADATA_URL)
+        self.assertEqual(
+            found_resources,
+            Resource(
+                labels={
+                    "cloud.account.id": "project_id",
+                    "k8s.cluster.name": "cluster_name",
+                    "k8s.namespace.name": "namespace",
+                    "host.id": "instance_id",
+                    "k8s.pod.name": "host_name",
+                    "container.name": "container_name",
+                    "cloud.zone": "zone",
+                    "cloud.provider": "gcp",
+                    "gcp.resource_type": "gke_container",
+                }
+            ),
+        )
+        self.assertEqual(getter.call_count, 1)
+
+    def test_resource_finding_fallback(self, getter):
+        # The environment variables imply its on GKE, but the metadata doesn't
+        # have GKE information
+        getter.return_value.json.return_value = GCE_RESOURCES_JSON_STRING
+        os.environ[CONTAINER_NAME] = "container_name"
+
+        # This detection will cause an error in get_gke_resources and should
+        # swallow the error and fall back to get_gce_resources
+        resource_finder = GoogleCloudResourceDetector()
+        found_resources = resource_finder.detect()
+        self.assertEqual(
+            found_resources,
+            Resource(
+                labels={
+                    "host.id": "instance_id",
+                    "cloud.provider": "gcp",
+                    "cloud.account.id": "project_id",
+                    "cloud.zone": "zone",
+                    "gcp.resource_type": "gce_instance",
+                }
+            ),
+        )