Resource Detector for Cloud Run/Cloud Functions (#194)

* Add support for cloud run and cloud functions

Co-authored-by: Aaron Abbott <[email protected]>

Author: RangelReale

opentelemetry-resourcedetector-gcp/src/opentelemetry/resourcedetector/gcp_resource_detector/__init__.py

@@ -99,12 +99,74 @@ def get_gke_resources():
     return common_attributes
 
 
+def get_cloudrun_resources():
+    """Resource finder for Cloud Run attributes"""
+
+    if os.getenv("K_CONFIGURATION") is None:
+        return {}
+
+    (
+        common_attributes,
+        all_metadata,
+    ) = _get_google_metadata_and_common_attributes()
+
+    faas_name = os.getenv("K_SERVICE")
+    if faas_name is not None:
+        common_attributes["faas.name"] = str(faas_name)
+
+    faas_version = os.getenv("K_REVISION")
+    if faas_version is not None:
+        common_attributes["faas.version"] = str(faas_version)
+
+    common_attributes.update(
+        {
+            "cloud.platform": "gcp_cloud_run",
+            "cloud.region": all_metadata["instance"]["region"].split("/")[-1],
+            "faas.id": all_metadata["instance"]["id"],
+            "gcp.resource_type": "cloud_run",
+        }
+    )
+    return common_attributes
+
+
+def get_cloudfunctions_resources():
+    """Resource finder for Cloud Functions attributes"""
+
+    if os.getenv("FUNCTION_TARGET") is None:
+        return {}
+
+    (
+        common_attributes,
+        all_metadata,
+    ) = _get_google_metadata_and_common_attributes()
+
+    faas_name = os.getenv("K_SERVICE")
+    if faas_name is not None:
+        common_attributes["faas.name"] = str(faas_name)
+
+    faas_version = os.getenv("K_REVISION")
+    if faas_version is not None:
+        common_attributes["faas.version"] = str(faas_version)
+
+    common_attributes.update(
+        {
+            "cloud.platform": "gcp_cloud_functions",
+            "cloud.region": all_metadata["instance"]["region"].split("/")[-1],
+            "faas.id": all_metadata["instance"]["id"],
+            "gcp.resource_type": "cloud_functions",
+        }
+    )
+    return common_attributes
+
+
 # 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 = [
     ("gke_container", get_gke_resources),
+    ("cloud_run", get_cloudrun_resources),
+    ("cloud_functions", get_cloudfunctions_resources),
     ("gce_instance", get_gce_resources),
 ]
 

opentelemetry-resourcedetector-gcp/tests/test_gcp_resource_detector.py

@@ -20,6 +20,8 @@
     _GCP_METADATA_URL,
     GoogleCloudResourceDetector,
     NoGoogleResourcesFound,
+    get_cloudfunctions_resources,
+    get_cloudrun_resources,
     get_gce_resources,
     get_gke_resources,
 )
@@ -30,6 +32,10 @@
 HOSTNAME = "HOSTNAME"
 POD_NAME = "POD_NAME"
 KUBERNETES_SERVICE_HOST = "KUBERNETES_SERVICE_HOST"
+K_CONFIGURATION = "K_CONFIGURATION"
+FUNCTION_TARGET = "FUNCTION_TARGET"
+K_SERVICE = "K_SERVICE"
+K_REVISION = "K_REVISION"
 
 GCE_RESOURCES_JSON_STRING = {
     "instance": {"id": "instance_id", "zone": "projects/123/zones/zone"},
@@ -45,6 +51,24 @@
     "project": {"projectId": "project_id"},
 }
 
+CLOUDRUN_RESOURCES_JSON_STRING = {
+    "instance": {
+        "id": "instance_id",
+        "zone": "projects/123/zones/zone",
+        "region": "projects/123/regions/region",
+    },
+    "project": {"projectId": "project_id"},
+}
+
+CLOUDFUNCTIONS_RESOURCES_JSON_STRING = {
+    "instance": {
+        "id": "instance_id",
+        "zone": "projects/123/zones/zone",
+        "region": "projects/123/regions/region",
+    },
+    "project": {"projectId": "project_id"},
+}
+
 
 @mock.patch(
     "opentelemetry.resourcedetector.gcp_resource_detector.requests.get",
@@ -197,6 +221,170 @@ def test_finding_gke_resources_with_pod_name(self, getter):
         )
 
 
+def clear_cloudrun_env_vars():
+    pop_environ_key(K_CONFIGURATION)
+    pop_environ_key(K_SERVICE)
+    pop_environ_key(K_REVISION)
+
+
+@mock.patch(
+    "opentelemetry.resourcedetector.gcp_resource_detector.requests.get",
+    **{"return_value.json.return_value": CLOUDRUN_RESOURCES_JSON_STRING}
+)
+class TestCloudRunResourceFinder(unittest.TestCase):
+    def tearDown(self) -> None:
+        clear_cloudrun_env_vars()
+
+    # pylint: disable=unused-argument
+    def test_not_running_on_cloudrun(self, getter):
+        pop_environ_key(K_CONFIGURATION)
+        found_resources = get_cloudrun_resources()
+        self.assertEqual(found_resources, {})
+
+    # pylint: disable=unused-argument
+    def test_missing_service_name(self, getter):
+        os.environ[K_CONFIGURATION] = "cloudrun_config"
+        pop_environ_key(K_SERVICE)
+        pop_environ_key(K_REVISION)
+        found_resources = get_cloudrun_resources()
+        self.assertEqual(
+            found_resources,
+            {
+                "cloud.account.id": "project_id",
+                "cloud.platform": "gcp_cloud_run",
+                "cloud.region": "region",
+                "faas.id": "instance_id",
+                "cloud.zone": "zone",
+                "cloud.provider": "gcp",
+                "gcp.resource_type": "cloud_run",
+            },
+        )
+
+    # pylint: disable=unused-argument
+    def test_environment_empty_strings(self, getter):
+        os.environ[K_CONFIGURATION] = "cloudrun_config"
+        os.environ[K_SERVICE] = ""
+        os.environ[K_REVISION] = ""
+        found_resources = get_cloudrun_resources()
+        self.assertEqual(
+            found_resources,
+            {
+                "cloud.account.id": "project_id",
+                "cloud.platform": "gcp_cloud_run",
+                "cloud.region": "region",
+                "faas.id": "instance_id",
+                "faas.name": "",
+                "faas.version": "",
+                "cloud.zone": "zone",
+                "cloud.provider": "gcp",
+                "gcp.resource_type": "cloud_run",
+            },
+        )
+
+    def test_finding_cloudrun_resources(self, getter):
+        os.environ[K_CONFIGURATION] = "cloudrun_config"
+        os.environ[K_SERVICE] = "service"
+        os.environ[K_REVISION] = "revision"
+        found_resources = get_cloudrun_resources()
+        self.assertEqual(getter.call_args_list[0][0][0], _GCP_METADATA_URL)
+        self.assertEqual(
+            found_resources,
+            {
+                "cloud.account.id": "project_id",
+                "cloud.platform": "gcp_cloud_run",
+                "cloud.region": "region",
+                "faas.id": "instance_id",
+                "faas.name": "service",
+                "faas.version": "revision",
+                "cloud.zone": "zone",
+                "cloud.provider": "gcp",
+                "gcp.resource_type": "cloud_run",
+            },
+        )
+
+
+def clear_cloudfunctions_env_vars():
+    pop_environ_key(FUNCTION_TARGET)
+    pop_environ_key(K_SERVICE)
+    pop_environ_key(K_REVISION)
+
+
+@mock.patch(
+    "opentelemetry.resourcedetector.gcp_resource_detector.requests.get",
+    **{"return_value.json.return_value": CLOUDFUNCTIONS_RESOURCES_JSON_STRING}
+)
+class TestCloudFunctionsResourceFinder(unittest.TestCase):
+    def tearDown(self) -> None:
+        clear_cloudfunctions_env_vars()
+
+    # pylint: disable=unused-argument
+    def test_not_running_on_cloudfunctions(self, getter):
+        pop_environ_key(FUNCTION_TARGET)
+        found_resources = get_cloudfunctions_resources()
+        self.assertEqual(found_resources, {})
+
+    # pylint: disable=unused-argument
+    def test_missing_service_name(self, getter):
+        os.environ[FUNCTION_TARGET] = "function"
+        pop_environ_key(K_SERVICE)
+        pop_environ_key(K_REVISION)
+        found_resources = get_cloudfunctions_resources()
+        self.assertEqual(
+            found_resources,
+            {
+                "cloud.account.id": "project_id",
+                "cloud.platform": "gcp_cloud_functions",
+                "cloud.region": "region",
+                "faas.id": "instance_id",
+                "cloud.zone": "zone",
+                "cloud.provider": "gcp",
+                "gcp.resource_type": "cloud_functions",
+            },
+        )
+
+    # pylint: disable=unused-argument
+    def test_environment_empty_strings(self, getter):
+        os.environ[FUNCTION_TARGET] = "function"
+        os.environ[K_SERVICE] = ""
+        os.environ[K_REVISION] = ""
+        found_resources = get_cloudfunctions_resources()
+        self.assertEqual(
+            found_resources,
+            {
+                "cloud.account.id": "project_id",
+                "cloud.platform": "gcp_cloud_functions",
+                "cloud.region": "region",
+                "faas.id": "instance_id",
+                "faas.name": "",
+                "faas.version": "",
+                "cloud.zone": "zone",
+                "cloud.provider": "gcp",
+                "gcp.resource_type": "cloud_functions",
+            },
+        )
+
+    def test_finding_cloudfunctions_resources(self, getter):
+        os.environ[FUNCTION_TARGET] = "function"
+        os.environ[K_SERVICE] = "service"
+        os.environ[K_REVISION] = "revision"
+        found_resources = get_cloudfunctions_resources()
+        self.assertEqual(getter.call_args_list[0][0][0], _GCP_METADATA_URL)
+        self.assertEqual(
+            found_resources,
+            {
+                "cloud.account.id": "project_id",
+                "cloud.platform": "gcp_cloud_functions",
+                "cloud.region": "region",
+                "faas.id": "instance_id",
+                "faas.name": "service",
+                "faas.version": "revision",
+                "cloud.zone": "zone",
+                "cloud.provider": "gcp",
+                "gcp.resource_type": "cloud_functions",
+            },
+        )
+
+
 @mock.patch(
     "opentelemetry.resourcedetector.gcp_resource_detector.requests.get"
 )
@@ -208,6 +396,8 @@ 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
         pop_environ_key(KUBERNETES_SERVICE_HOST)
+        pop_environ_key(K_CONFIGURATION)
+        pop_environ_key(FUNCTION_TARGET)
         resource_finder = GoogleCloudResourceDetector()
         getter.return_value.json.return_value = GCE_RESOURCES_JSON_STRING
         found_resources = resource_finder.detect()
@@ -272,6 +462,66 @@ def test_finding_gke_resources(self, getter):
         )
         self.assertEqual(getter.call_count, 1)
 
+    def test_finding_cloudrun_resources(self, getter):
+        # The necessary env variables were set for CloudRun resource detection
+        # to succeed. No GCE resource info should be extracted
+        os.environ[K_CONFIGURATION] = "cloudrun_config"
+        os.environ[K_SERVICE] = "service"
+        os.environ[K_REVISION] = "revision"
+
+        resource_finder = GoogleCloudResourceDetector()
+        getter.return_value.json.return_value = CLOUDRUN_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(
+                attributes={
+                    "cloud.account.id": "project_id",
+                    "cloud.platform": "gcp_cloud_run",
+                    "cloud.region": "region",
+                    "faas.id": "instance_id",
+                    "faas.name": "service",
+                    "faas.version": "revision",
+                    "cloud.zone": "zone",
+                    "cloud.provider": "gcp",
+                    "gcp.resource_type": "cloud_run",
+                }
+            ),
+        )
+        self.assertEqual(getter.call_count, 1)
+
+    def test_finding_cloudfunctions_resources(self, getter):
+        # The necessary env variables were set for Cloudfunctions resource detection
+        # to succeed. No GCE resource info should be extracted
+        os.environ[FUNCTION_TARGET] = "function"
+        os.environ[K_SERVICE] = "service"
+        os.environ[K_REVISION] = "revision"
+
+        resource_finder = GoogleCloudResourceDetector()
+        getter.return_value.json.return_value = (
+            CLOUDFUNCTIONS_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(
+                attributes={
+                    "cloud.account.id": "project_id",
+                    "cloud.platform": "gcp_cloud_functions",
+                    "cloud.region": "region",
+                    "faas.id": "instance_id",
+                    "faas.name": "service",
+                    "faas.version": "revision",
+                    "cloud.zone": "zone",
+                    "cloud.provider": "gcp",
+                    "gcp.resource_type": "cloud_functions",
+                }
+            ),
+        )
+        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