test: add tool call instrumentation tests and nonstreaming recording in spans test.

Author: argaj

instrumentation-genai/opentelemetry-instrumentation-google-genai/tests/generate_content/nonstreaming_base.py

@@ -16,6 +16,7 @@
 import unittest
 from unittest.mock import patch
 
+from google.genai.types import GenerateContentConfig
 from opentelemetry.instrumentation._semconv import (
     _OpenTelemetrySemanticConventionStability,
     _OpenTelemetryStabilitySignalType,
@@ -188,7 +189,7 @@ def test_does_not_record_response_as_log_if_disabled_by_env(self):
         self.assertEqual(event_record.attributes["gen_ai.system"], "gemini")
         self.assertEqual(event_record.body["content"], "<elided>")
 
-    def test_new_semconv_record_response_as_log(self):
+    def test_new_semconv_record_completion_as_log(self):
         for mode in ContentCapturingMode:
             patched_environ = patch.dict(
                 "os.environ",
@@ -218,7 +219,42 @@ def test_new_semconv_record_response_as_log(self):
                         self.otel.assert_has_event_named("gen_ai.client.inference.operation.details")
 
                 self.tearDown()
- 
+
+    def test_new_semconv_record_completion_in_span(self):
+        for mode in ContentCapturingMode:
+            patched_environ = patch.dict(
+                "os.environ",
+                {
+                    "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT": mode.name,
+                    "OTEL_SEMCONV_STABILITY_OPT_IN": "gen_ai_latest_experimental",
+                },
+            )
+            patched_otel_mapping = patch.dict(
+                _OpenTelemetrySemanticConventionStability._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING,
+                {
+                    _OpenTelemetryStabilitySignalType.GEN_AI: _StabilityMode.GEN_AI_LATEST_EXPERIMENTAL
+                },
+            )
+            with self.subTest(f'mode: {mode}', patched_environ=patched_environ):
+                self.setUp()
+                with patched_environ, patched_otel_mapping:
+                    self.configure_valid_response(text="Some response content")
+                    self.generate_content(model="gemini-2.0-flash", contents="Some input", config=GenerateContentConfig(system_instruction="System instruction"))
+                    span = self.otel.get_span_named("generate_content gemini-2.0-flash")
+                    if mode in [
+                        ContentCapturingMode.SPAN_ONLY,
+                        ContentCapturingMode.SPAN_AND_EVENT,
+                    ]:
+                        self.assertEqual(span.attributes["gen_ai.input.messages"], '[{"role": "user", "parts": [{"content": "Some input", "type": "text"}]}]')
+                        self.assertEqual(span.attributes["gen_ai.output.messages"], '[{"role": "assistant", "parts": [{"content": "Some response content", "type": "text"}], "finish_reason": ""}]')
+                        self.assertEqual(span.attributes["gen_ai.system_instructions"], '[{"content": "System instruction", "type": "text"}]')
+                    else:
+                        self.assertNotIn("gen_ai.input.messages", span.attributes)
+                        self.assertNotIn("gen_ai.output.messages", span.attributes)
+                        self.assertNotIn("gen_ai.system_instructions", span.attributes)
+
+                self.tearDown()
+
     def test_records_metrics_data(self):
         self.configure_valid_response()
         self.generate_content(model="gemini-2.0-flash", contents="Some input")

instrumentation-genai/opentelemetry-instrumentation-google-genai/tests/generate_content/test_tool_call_instrumentation.py

@@ -15,6 +15,12 @@
 from unittest.mock import patch
 
 import google.genai.types as genai_types
+from opentelemetry.instrumentation._semconv import (
+    _OpenTelemetrySemanticConventionStability,
+    _OpenTelemetryStabilitySignalType,
+    _StabilityMode,
+)
+from opentelemetry.util.genai.types import ContentCapturingMode
 
 from .base import TestCase
 
@@ -275,3 +281,126 @@ def somefunction(x, y=2):
         self.assertNotIn(
             "code.function.return.value", generated_span.attributes
         )
+
+    def test_new_semconv_tool_calls_record_parameter_values(self):
+        for mode in ContentCapturingMode:
+            patched_environ = patch.dict(
+                "os.environ",
+                {
+                    "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT": mode.name,
+                    "OTEL_SEMCONV_STABILITY_OPT_IN": "gen_ai_latest_experimental",
+                },
+            )
+            patched_otel_mapping = patch.dict(
+                _OpenTelemetrySemanticConventionStability._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING,
+                {
+                    _OpenTelemetryStabilitySignalType.GEN_AI: _StabilityMode.GEN_AI_LATEST_EXPERIMENTAL
+                },
+            )
+            with self.subTest(f'mode: {mode}', patched_environ=patched_environ):
+                self.setUp()
+                with patched_environ, patched_otel_mapping:
+                    calls = []
+
+                    def handle(*args, **kwargs):
+                        calls.append((args, kwargs))
+                        return "some result"
+
+                    def somefunction(someparam, otherparam=2):
+                        print("someparam=%s, otherparam=%s", someparam, otherparam)
+
+                    self.mock_generate_content.side_effect = handle
+                    self.client.models.generate_content(
+                        model="some-model-name",
+                        contents="Some content",
+                        config={
+                            "tools": [somefunction],
+                        },
+                    )
+                    self.assertEqual(len(calls), 1)
+                    config = calls[0][1]["config"]
+                    tools = config.tools
+                    wrapped_somefunction = tools[0]
+                    wrapped_somefunction(123, otherparam="abc")
+                    self.otel.assert_has_span_named("execute_tool somefunction")
+                    generated_span = self.otel.get_span_named("execute_tool somefunction")
+                    self.assertEqual(
+                        generated_span.attributes[
+                            "code.function.parameters.someparam.type"
+                        ],
+                        "int",
+                    )
+                    self.assertEqual(
+                        generated_span.attributes[
+                            "code.function.parameters.otherparam.type"
+                        ],
+                        "str",
+                    )
+                    if mode in [
+                        ContentCapturingMode.SPAN_ONLY,
+                        ContentCapturingMode.SPAN_AND_EVENT,
+                    ]:
+                        self.assertEqual(generated_span.attributes["code.function.parameters.someparam.value"], 123)
+                        self.assertEqual(generated_span.attributes["code.function.parameters.otherparam.value"], "abc")
+                    else:
+                        self.assertNotIn("code.function.parameters.someparam.value", generated_span.attributes)
+                        self.assertNotIn("code.function.parameters.otherparam.value", generated_span.attributes)
+                self.tearDown()
+
+    def test_new_semconv_tool_calls_record_return_values(self):
+        for mode in ContentCapturingMode:
+            patched_environ = patch.dict(
+                "os.environ",
+                {
+                    "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT": mode.name,
+                    "OTEL_SEMCONV_STABILITY_OPT_IN": "gen_ai_latest_experimental",
+                },
+            )
+            patched_otel_mapping = patch.dict(
+                _OpenTelemetrySemanticConventionStability._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING,
+                {
+                    _OpenTelemetryStabilitySignalType.GEN_AI: _StabilityMode.GEN_AI_LATEST_EXPERIMENTAL
+                },
+            )
+            with self.subTest(f'mode: {mode}', patched_environ=patched_environ):
+                self.setUp()
+                with patched_environ, patched_otel_mapping:
+                    calls = []
+
+                    def handle(*args, **kwargs):
+                        calls.append((args, kwargs))
+                        return "some result"
+
+                    def somefunction(x, y=2):
+                        return x + y
+
+                    self.mock_generate_content.side_effect = handle
+                    self.client.models.generate_content(
+                        model="some-model-name",
+                        contents="Some content",
+                        config={
+                            "tools": [somefunction],
+                        },
+                    )
+                    self.assertEqual(len(calls), 1)
+                    config = calls[0][1]["config"]
+                    tools = config.tools
+                    wrapped_somefunction = tools[0]
+                    wrapped_somefunction(123)
+                    self.otel.assert_has_span_named("execute_tool somefunction")
+                    generated_span = self.otel.get_span_named("execute_tool somefunction")
+                    self.assertEqual(
+                        generated_span.attributes["code.function.return.type"], "int"
+                    )
+                    if mode in [
+                        ContentCapturingMode.SPAN_ONLY,
+                        ContentCapturingMode.SPAN_AND_EVENT,
+                    ]:
+                        self.assertIn(
+                            "code.function.return.value", generated_span.attributes
+                        )
+                    else:
+                        self.assertNotIn(
+                            "code.function.return.value", generated_span.attributes
+                        )
+                self.tearDown()