sdk: Implement basic os resource detector

opentelemetry-sdk/pyproject.toml

@@ -67,6 +67,7 @@ console = "opentelemetry.sdk.trace.export:ConsoleSpanExporter"
 [project.entry-points.opentelemetry_resource_detector]
 otel = "opentelemetry.sdk.resources:OTELResourceDetector"
 process = "opentelemetry.sdk.resources:ProcessResourceDetector"
+os = "opentelemetry.sdk.resources:OsResourceDetector"
 
 [project.urls]
 Homepage = "https://github.com/open-telemetry/opentelemetry-python/tree/main/opentelemetry-sdk"

opentelemetry-sdk/src/opentelemetry/sdk/resources/__init__.py

@@ -59,6 +59,7 @@
 import concurrent.futures
 import logging
 import os
+import platform
 import sys
 import typing
 from json import dumps
@@ -119,8 +120,9 @@
 KUBERNETES_JOB_NAME = ResourceAttributes.K8S_JOB_NAME
 KUBERNETES_CRON_JOB_UID = ResourceAttributes.K8S_CRONJOB_UID
 KUBERNETES_CRON_JOB_NAME = ResourceAttributes.K8S_CRONJOB_NAME
-OS_TYPE = ResourceAttributes.OS_TYPE
 OS_DESCRIPTION = ResourceAttributes.OS_DESCRIPTION
+OS_TYPE = ResourceAttributes.OS_TYPE
+OS_VERSION = ResourceAttributes.OS_VERSION
 PROCESS_PID = ResourceAttributes.PROCESS_PID
 PROCESS_PARENT_PID = ResourceAttributes.PROCESS_PARENT_PID
 PROCESS_EXECUTABLE_NAME = ResourceAttributes.PROCESS_EXECUTABLE_NAME
@@ -173,17 +175,19 @@ def create(
         if not attributes:
             attributes = {}
 
-        resource_detectors = []
-
-        resource = _DEFAULT_RESOURCE
-
-        otel_experimental_resource_detectors = environ.get(
-            OTEL_EXPERIMENTAL_RESOURCE_DETECTORS, "otel"
-        ).split(",")
-
-        if "otel" not in otel_experimental_resource_detectors:
-            otel_experimental_resource_detectors.append("otel")
+        otel_experimental_resource_detectors = {"otel", "os"}.union(
+            set(
+                [
+                    otel_experimental_resource_detector.strip()
+                    for otel_experimental_resource_detector in environ.get(
+                        "OTEL_EXPERIMENTAL_RESOURCE_DETECTORS", ""
+                    ).split(",")
+                    if otel_experimental_resource_detector
+                ]
+            )
+        )
 
+        resource_detectors = []
         for resource_detector in otel_experimental_resource_detectors:
             resource_detectors.append(
                 next(
@@ -371,6 +375,73 @@ def detect(self) -> "Resource":
         return Resource(resource_info)
 
 
+class OsResourceDetector(ResourceDetector):
+    """Detect os resources based on `Operating System conventions <https://opentelemetry.io/docs/specs/semconv/resource/os/`_."""
+
+    def detect(self) -> "Resource":
+        """Returns a resource with with `os.type` and `os.version`. Example of
+        return values for `platform` calls in different systems:
+
+        Linux:
+        >>> platform.system()
+        'Linux'
+        >>> platform.release()
+        '6.5.0-35-generic'
+        >>> platform.version()
+        '#35~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May  7 09:00:52 UTC 2'
+
+        MacOS:
+        >>> platform.system()
+        'Darwin'
+        >>> platform.release()
+        '23.0.0'
+        >>> platform.version()
+        'Darwin Kernel Version 23.0.0: Fri Sep 15 14:42:57 PDT 2023; root:xnu-10002.1.13~1/RELEASE_ARM64_T8112'
+
+        Windows:
+        >>> platform.system()
+        'Windows'
+        >>> platform.release()
+        '2022Server'
+        >>> platform.version()
+        '10.0.20348'
+
+        FreeBSD:
+        >>> platform.system()
+        'FreeBSD'
+        >>> platform.release()
+        '14.1-RELEASE'
+        >>> platform.version()
+        'FreeBSD 14.1-RELEASE releng/14.1-n267679-10e31f0946d8 GENERIC'
+
+        Solaris:
+        >>> platform.system()
+        'SunOS'
+        >>> platform.release()
+        '5.11'
+        >>> platform.version()
+        '11.4.0.15.0'
+        """
+
+        os_type = platform.system().lower()
+        os_version = platform.release()
+
+        # See docstring
+        if os_type == "windows":
+            os_version = platform.version()
+        # Align SunOS with conventions
+        elif os_type == "sunos":
+            os_type = "solaris"
+            os_version = platform.version()
+
+        return Resource(
+            {
+                OS_TYPE: os_type,
+                OS_VERSION: os_version,
+            }
+        )
+
+
 def get_aggregated_resources(
     detectors: typing.List["ResourceDetector"],
     initial_resource: typing.Optional[Resource] = None,

opentelemetry-sdk/tests/resources/test_resources.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import os
+import platform
 import sys
 import unittest
 import uuid
@@ -28,6 +29,8 @@
     _DEFAULT_RESOURCE,
     _EMPTY_RESOURCE,
     _OPENTELEMETRY_SDK_VERSION,
+    OS_TYPE,
+    OS_VERSION,
     OTEL_RESOURCE_ATTRIBUTES,
     OTEL_SERVICE_NAME,
     PROCESS_COMMAND,
@@ -45,6 +48,7 @@
     TELEMETRY_SDK_LANGUAGE,
     TELEMETRY_SDK_NAME,
     TELEMETRY_SDK_VERSION,
+    OsResourceDetector,
     OTELResourceDetector,
     ProcessResourceDetector,
     Resource,
@@ -58,10 +62,31 @@
     psutil = None
 
 
+@patch(
+    "platform.uname",
+    lambda: platform.uname_result(
+        system="Linux",
+        node="node",
+        release="1.2.3",
+        version="4.5.6",
+        machine="x86_64",
+    ),
+)
 class TestResources(unittest.TestCase):
     def setUp(self) -> None:
         environ[OTEL_RESOURCE_ATTRIBUTES] = ""
 
+        # OsResourceDetector calls into `platform` functions to grab its info,
+        # which is not part of the default resource. Provide the mock values
+        # and an extended default resource to be used throughout tests.
+        self.mock_platform = {
+            OS_TYPE: "linux",
+            OS_VERSION: "1.2.3",
+        }
+        self.default_resource = _DEFAULT_RESOURCE.merge(
+            Resource(self.mock_platform)
+        )
+
     def tearDown(self) -> None:
         environ.pop(OTEL_RESOURCE_ATTRIBUTES)
 
@@ -83,6 +108,7 @@ def test_create(self):
             TELEMETRY_SDK_VERSION: _OPENTELEMETRY_SDK_VERSION,
             SERVICE_NAME: "unknown_service",
         }
+        expected_attributes.update(self.mock_platform)
 
         resource = Resource.create(attributes)
         self.assertIsInstance(resource, Resource)
@@ -110,7 +136,7 @@ def test_create(self):
         resource = Resource.create(None)
         self.assertEqual(
             resource,
-            _DEFAULT_RESOURCE.merge(
+            self.default_resource.merge(
                 Resource({SERVICE_NAME: "unknown_service"}, "")
             ),
         )
@@ -119,7 +145,7 @@ def test_create(self):
         resource = Resource.create(None, None)
         self.assertEqual(
             resource,
-            _DEFAULT_RESOURCE.merge(
+            self.default_resource.merge(
                 Resource({SERVICE_NAME: "unknown_service"}, "")
             ),
         )
@@ -128,7 +154,7 @@ def test_create(self):
         resource = Resource.create({})
         self.assertEqual(
             resource,
-            _DEFAULT_RESOURCE.merge(
+            self.default_resource.merge(
                 Resource({SERVICE_NAME: "unknown_service"}, "")
             ),
         )
@@ -137,7 +163,7 @@ def test_create(self):
         resource = Resource.create({}, None)
         self.assertEqual(
             resource,
-            _DEFAULT_RESOURCE.merge(
+            self.default_resource.merge(
                 Resource({SERVICE_NAME: "unknown_service"}, "")
             ),
         )
@@ -206,6 +232,7 @@ def test_immutability(self):
             TELEMETRY_SDK_VERSION: _OPENTELEMETRY_SDK_VERSION,
             SERVICE_NAME: "unknown_service",
         }
+        default_attributes.update(self.mock_platform)
 
         attributes_copy = attributes.copy()
         attributes_copy.update(default_attributes)
@@ -258,7 +285,7 @@ def test_aggregated_resources_no_detectors(self):
         aggregated_resources = get_aggregated_resources([])
         self.assertEqual(
             aggregated_resources,
-            _DEFAULT_RESOURCE.merge(
+            self.default_resource.merge(
                 Resource({SERVICE_NAME: "unknown_service"}, "")
             ),
         )
@@ -309,7 +336,7 @@ def test_aggregated_resources_multiple_detectors(self):
             get_aggregated_resources(
                 [resource_detector1, resource_detector2, resource_detector3]
             ),
-            _DEFAULT_RESOURCE.merge(
+            self.default_resource.merge(
                 Resource({SERVICE_NAME: "unknown_service"}, "")
             ).merge(
                 Resource(
@@ -352,7 +379,7 @@ def test_aggregated_resources_different_schema_urls(self):
         )
         self.assertEqual(
             get_aggregated_resources([resource_detector1, resource_detector2]),
-            _DEFAULT_RESOURCE.merge(
+            self.default_resource.merge(
                 Resource({SERVICE_NAME: "unknown_service"}, "")
             ).merge(
                 Resource(
@@ -366,7 +393,7 @@ def test_aggregated_resources_different_schema_urls(self):
                 get_aggregated_resources(
                     [resource_detector2, resource_detector3]
                 ),
-                _DEFAULT_RESOURCE.merge(
+                self.default_resource.merge(
                     Resource({SERVICE_NAME: "unknown_service"}, "")
                 ).merge(
                     Resource({"key2": "value2", "key3": "value3"}, "url1")
@@ -384,7 +411,7 @@ def test_aggregated_resources_different_schema_urls(self):
                         resource_detector1,
                     ]
                 ),
-                _DEFAULT_RESOURCE.merge(
+                self.default_resource.merge(
                     Resource({SERVICE_NAME: "unknown_service"}, "")
                 ).merge(
                     Resource(
@@ -408,7 +435,7 @@ def test_resource_detector_ignore_error(self):
         with self.assertLogs(level=WARNING):
             self.assertEqual(
                 get_aggregated_resources([resource_detector]),
-                _DEFAULT_RESOURCE.merge(
+                self.default_resource.merge(
                     Resource({SERVICE_NAME: "unknown_service"}, "")
                 ),
             )
@@ -428,7 +455,7 @@ def test_resource_detector_timeout(self, mock_logger):
         resource_detector.raise_on_error = False
         self.assertEqual(
             get_aggregated_resources([resource_detector]),
-            _DEFAULT_RESOURCE.merge(
+            self.default_resource.merge(
                 Resource({SERVICE_NAME: "unknown_service"}, "")
             ),
         )
@@ -673,6 +700,15 @@ def test_resource_detector_entry_points_non_default(self):
         self.assertEqual(resource.attributes["a"], "b")
         self.assertEqual(resource.schema_url, "")
 
+    @patch.dict(
+        environ, {OTEL_EXPERIMENTAL_RESOURCE_DETECTORS: ""}, clear=True
+    )
+    def test_resource_detector_entry_points_empty(self):
+        resource = Resource({}).create()
+        self.assertEqual(
+            resource.attributes["telemetry.sdk.language"], "python"
+        )
+
     def test_resource_detector_entry_points_otel(self):
         """
         Test that OTELResourceDetector-resource-generated attributes are
@@ -723,3 +759,36 @@ def test_resource_detector_entry_points_otel(self):
             )
             self.assertIn(PROCESS_RUNTIME_VERSION, resource.attributes.keys())
             self.assertEqual(resource.schema_url, "")
+
+    @patch("platform.system", lambda: "Linux")
+    @patch("platform.release", lambda: "666.5.0-35-generic")
+    def test_os_detector_linux(self):
+        resource = get_aggregated_resources(
+            [OsResourceDetector()],
+            Resource({}),
+        )
+
+        self.assertEqual(resource.attributes[OS_TYPE], "linux")
+        self.assertEqual(resource.attributes[OS_VERSION], "666.5.0-35-generic")
+
+    @patch("platform.system", lambda: "Windows")
+    @patch("platform.version", lambda: "10.0.666")
+    def test_os_detector_windows(self):
+        resource = get_aggregated_resources(
+            [OsResourceDetector()],
+            Resource({}),
+        )
+
+        self.assertEqual(resource.attributes[OS_TYPE], "windows")
+        self.assertEqual(resource.attributes[OS_VERSION], "10.0.666")
+
+    @patch("platform.system", lambda: "SunOS")
+    @patch("platform.version", lambda: "666.4.0.15.0")
+    def test_os_detector_solaris(self):
+        resource = get_aggregated_resources(
+            [OsResourceDetector()],
+            Resource({}),
+        )
+
+        self.assertEqual(resource.attributes[OS_TYPE], "solaris")
+        self.assertEqual(resource.attributes[OS_VERSION], "666.4.0.15.0")