feat(distro): add host.ip and gen_ai.instrumentation.sdk.name resources

Add a LoongSuiteResourceDetector that contributes two resource attributes
to the agent:

* host.ip: the local host IP combined with the process id, formatted as
  <ip>-<pid> (e.g. 127.0.0.1-1).
* gen_ai.instrumentation.sdk.name: set to "loongsuite-genai-utils".

The detector is wired into LoongSuiteConfigurator so the attributes are
always present on the SDK resource. Includes unit tests for the detector
(ip-pid format, fixed sdk name, fallback on socket error) and the
configurator wiring.

Change-Id: I7fdfd07ffa8e2021e82c1d85d7d6b527c2cf8170
Co-developed-by: Claude <noreply@anthropic.com>
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 123liuziming

loongsuite-distro/src/loongsuite/distro/__init__.py

@@ -24,12 +24,23 @@
 from opentelemetry.sdk._configuration import _OTelSDKConfigurator
 from opentelemetry.sdk.environment_variables import OTEL_EXPORTER_OTLP_PROTOCOL
 
+from loongsuite.distro.resource import LoongSuiteResourceDetector
+
 
 class LoongSuiteConfigurator(_OTelSDKConfigurator):
     """
     LoongSuite configurator, inherits from OpenTelemetry SDK configurator.
+
+    Augments the resource with LoongSuite specific attributes (``host.ip`` and
+    ``gen_ai.instrumentation.sdk.name``) before delegating to the OpenTelemetry
+    SDK configurator.
     """
 
+    def _configure(self, **kwargs: Any) -> None:
+        resource_attributes = dict(kwargs.pop("resource_attributes", None) or {})
+        resource_attributes.update(LoongSuiteResourceDetector().detect().attributes)
+        super()._configure(resource_attributes=resource_attributes, **kwargs)
+
 
 class LoongSuiteDistro(BaseDistro):
     """

loongsuite-distro/src/loongsuite/distro/resource.py

@@ -0,0 +1,80 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import socket
+from logging import getLogger
+
+from opentelemetry.sdk.resources import Resource, ResourceDetector
+
+logger = getLogger(__name__)
+
+# Resource attribute keys contributed by LoongSuite.
+HOST_IP = "host.ip"
+GEN_AI_INSTRUMENTATION_SDK_NAME = "gen_ai.instrumentation.sdk.name"
+
+# Fixed value identifying the GenAI instrumentation SDK shipped with LoongSuite.
+_GEN_AI_INSTRUMENTATION_SDK_NAME_VALUE = "loongsuite-genai-utils"
+
+_FALLBACK_HOST_IP = "127.0.0.1"
+
+
+def _get_host_ip() -> str:
+    """Best-effort detection of the local host IP address.
+
+    Opens a UDP socket towards a public address to discover which local
+    interface would be used for outbound traffic. No packet is actually sent.
+    Falls back to ``127.0.0.1`` when detection fails.
+    """
+    sock = None
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.connect(("8.8.8.8", 80))
+        return sock.getsockname()[0]
+    except OSError as exception:
+        logger.debug(
+            "Failed to detect host ip, falling back to %s. Exception: %s",
+            _FALLBACK_HOST_IP,
+            exception,
+        )
+        return _FALLBACK_HOST_IP
+    finally:
+        if sock is not None:
+            sock.close()
+
+
+def _get_host_ip_with_pid() -> str:
+    """Returns the host IP combined with the current process id.
+
+    The format is ``<ip>-<pid>``, for example ``127.0.0.1-1``.
+    """
+    return f"{_get_host_ip()}-{os.getpid()}"
+
+
+class LoongSuiteResourceDetector(ResourceDetector):
+    """Detects LoongSuite specific resource attributes.
+
+    Contributes the following attributes to the resource:
+
+    * ``host.ip`` formatted as ``<ip>-<pid>`` (e.g. ``127.0.0.1-1``).
+    * ``gen_ai.instrumentation.sdk.name`` set to ``loongsuite-genai-utils``.
+    """
+
+    def detect(self) -> Resource:
+        return Resource(
+            {
+                HOST_IP: _get_host_ip_with_pid(),
+                GEN_AI_INSTRUMENTATION_SDK_NAME: _GEN_AI_INSTRUMENTATION_SDK_NAME_VALUE,
+            }
+        )

loongsuite-distro/tests/__init__.py

@@ -0,0 +1,13 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

loongsuite-distro/tests/test_configurator.py

@@ -0,0 +1,70 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+from unittest import mock
+
+from loongsuite.distro import LoongSuiteConfigurator
+from loongsuite.distro.resource import (
+    GEN_AI_INSTRUMENTATION_SDK_NAME,
+    HOST_IP,
+)
+
+
+class TestLoongSuiteConfigurator(unittest.TestCase):
+    @mock.patch("opentelemetry.sdk._configuration._initialize_components")
+    def test_configure_injects_loongsuite_attributes(self, mock_init):
+        LoongSuiteConfigurator().configure()
+
+        mock_init.assert_called_once()
+        resource_attributes = mock_init.call_args.kwargs[
+            "resource_attributes"
+        ]
+        self.assertIn(HOST_IP, resource_attributes)
+        self.assertEqual(
+            resource_attributes[GEN_AI_INSTRUMENTATION_SDK_NAME],
+            "loongsuite-genai-utils",
+        )
+
+    @mock.patch("opentelemetry.sdk._configuration._initialize_components")
+    def test_configure_preserves_existing_attributes(self, mock_init):
+        LoongSuiteConfigurator().configure(
+            resource_attributes={"service.name": "my-service"}
+        )
+
+        resource_attributes = mock_init.call_args.kwargs[
+            "resource_attributes"
+        ]
+        self.assertEqual(
+            resource_attributes["service.name"], "my-service"
+        )
+        self.assertIn(HOST_IP, resource_attributes)
+        self.assertIn(
+            GEN_AI_INSTRUMENTATION_SDK_NAME, resource_attributes
+        )
+
+    @mock.patch("opentelemetry.sdk._configuration._initialize_components")
+    def test_configure_forwards_other_kwargs(self, mock_init):
+        LoongSuiteConfigurator().configure(
+            auto_instrumentation_version="1.2.3"
+        )
+
+        self.assertEqual(
+            mock_init.call_args.kwargs["auto_instrumentation_version"],
+            "1.2.3",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

loongsuite-distro/tests/test_resource.py

@@ -0,0 +1,92 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+from unittest import mock
+
+from opentelemetry.sdk.resources import Resource, ResourceDetector
+
+from loongsuite.distro.resource import (
+    GEN_AI_INSTRUMENTATION_SDK_NAME,
+    HOST_IP,
+    LoongSuiteResourceDetector,
+    _get_host_ip,
+    _get_host_ip_with_pid,
+)
+
+
+class TestLoongSuiteResourceDetector(unittest.TestCase):
+    def test_is_resource_detector(self):
+        self.assertIsInstance(
+            LoongSuiteResourceDetector(), ResourceDetector
+        )
+
+    def test_detect_returns_resource(self):
+        resource = LoongSuiteResourceDetector().detect()
+        self.assertIsInstance(resource, Resource)
+
+    def test_detect_contains_expected_keys(self):
+        attributes = LoongSuiteResourceDetector().detect().attributes
+        self.assertIn(HOST_IP, attributes)
+        self.assertIn(GEN_AI_INSTRUMENTATION_SDK_NAME, attributes)
+
+    def test_gen_ai_instrumentation_sdk_name_value(self):
+        attributes = LoongSuiteResourceDetector().detect().attributes
+        self.assertEqual(
+            attributes[GEN_AI_INSTRUMENTATION_SDK_NAME],
+            "loongsuite-genai-utils",
+        )
+
+    @mock.patch("loongsuite.distro.resource.os.getpid", return_value=1)
+    @mock.patch(
+        "loongsuite.distro.resource._get_host_ip", return_value="127.0.0.1"
+    )
+    def test_host_ip_format_is_ip_dash_pid(self, _mock_ip, _mock_pid):
+        attributes = LoongSuiteResourceDetector().detect().attributes
+        self.assertEqual(attributes[HOST_IP], "127.0.0.1-1")
+
+    @mock.patch("loongsuite.distro.resource.os.getpid", return_value=42)
+    @mock.patch(
+        "loongsuite.distro.resource._get_host_ip", return_value="10.0.0.5"
+    )
+    def test_get_host_ip_with_pid(self, _mock_ip, _mock_pid):
+        self.assertEqual(_get_host_ip_with_pid(), "10.0.0.5-42")
+
+
+class TestGetHostIp(unittest.TestCase):
+    def test_returns_detected_ip(self):
+        mock_sock = mock.MagicMock()
+        mock_sock.getsockname.return_value = ("192.168.1.100", 12345)
+        with mock.patch(
+            "loongsuite.distro.resource.socket.socket",
+            return_value=mock_sock,
+        ):
+            self.assertEqual(_get_host_ip(), "192.168.1.100")
+        mock_sock.connect.assert_called_once()
+        mock_sock.close.assert_called_once()
+
+    def test_falls_back_to_loopback_on_error(self):
+        mock_sock = mock.MagicMock()
+        mock_sock.connect.side_effect = OSError("no network")
+        with mock.patch(
+            "loongsuite.distro.resource.socket.socket",
+            return_value=mock_sock,
+        ):
+            self.assertEqual(_get_host_ip(), "127.0.0.1")
+        # The socket must still be closed even when detection fails.
+        mock_sock.close.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()