Improve the recording of span request attributes.

Author: michaelsafyan

instrumentation-genai/opentelemetry-instrumentation-google-genai/src/opentelemetry/instrumentation/google_genai/dict_util.py

@@ -71,6 +71,8 @@ def _flatten_value(
     rename_keys: Dict[str, str],
     flatten_functions: Dict[str, Callable],
     _from_json=False) -> FlattenedDict:
+  if value is None:
+    return {}
   key_names = set([key])
   renamed_key = rename_keys.get(key)
   if renamed_key is not None:
@@ -132,7 +134,6 @@ def _flatten_list(
  return result
 
 
-
 def flatten_dict(
     d: Dict[str, Any],
     key_prefix: Optional[str] = None,

instrumentation-genai/opentelemetry-instrumentation-google-genai/src/opentelemetry/instrumentation/google_genai/generate_content.py

@@ -165,6 +165,7 @@ def _add_request_options_to_span(span, config: Optional[GenerateContentConfigOrD
             "gen_ai.gcp.request.candidate_count": "gen_ai.request.choice.count",
             "gen_ai.gcp.request.max_output_tokens": "gen_ai.request.max_tokens",
             "gen_ai.gcp.request.stop_sequences": "gen_ai.request.stop_sequences",
+            "gen_ai.gcp.request.frequency_penalty": "gen_ai.request.frequency_penalty",
             "gen_ai.gcp.request.presence_penalty": "gen_ai.request.presence_penalty",
             "gen_ai.gcp.request.seed": "gen_ai.request.seed",
         }
@@ -302,7 +303,7 @@ def _maybe_log_system_instruction(
         system_instruction = None
         if config is not None:
             if isinstance(config, dict):
-                system_instruction = config["system_instruction"]
+                system_instruction = config.get("system_instruction")
             else:
                 system_instruction = config.system_instruction
         if not system_instruction:

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

@@ -17,6 +17,7 @@
 import unittest
 
 from .base import TestCase
+from google.genai.types import GenerateContentConfig
 
 
 class NonStreamingTestCase(TestCase):
@@ -35,6 +36,14 @@ def generate_content(self, *args, **kwargs):
     def expected_function_name(self):
         raise NotImplementedError("Must implement 'expected_function_name'.")
 
+    def generate_and_get_span(self, config):
+        self.generate_content(
+            model="gemini-2.0-flash",
+            contents="Some input prompt",
+            config=config)
+        self.otel.assert_has_span_named("generate_content gemini-2.0-flash")
+        return self.otel.get_span_named("generate_content gemini-2.0-flash")
+
     def test_instrumentation_does_not_break_core_functionality(self):
         self.configure_valid_response(text="Yep, it works!")
         response = self.generate_content(
@@ -94,6 +103,92 @@ def test_generated_span_has_vertex_ai_system_when_configured(self):
             span.attributes["gen_ai.operation.name"], "generate_content"
         )
 
+    def test_option_reflected_to_span_attribute_choice_count_config_dict(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config={"candidate_count": 2})
+        self.assertEqual(span.attributes["gen_ai.request.choice.count"], 2)
+
+    def test_option_reflected_to_span_attribute_choice_count_config_obj(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config=GenerateContentConfig(candidate_count = 2))
+        self.assertEqual(span.attributes["gen_ai.request.choice.count"], 2)
+
+    def test_option_reflected_to_span_attribute_seed_config_dict(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config={"seed": 12345})
+        self.assertEqual(span.attributes["gen_ai.request.seed"], 12345)
+
+    def test_option_reflected_to_span_attribute_seed_config_obj(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config=GenerateContentConfig(seed = 12345))
+        self.assertEqual(span.attributes["gen_ai.request.seed"], 12345)
+
+    def test_option_reflected_to_span_attribute_frequency_penalty(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config={"frequency_penalty": 1.0})
+        self.assertEqual(span.attributes["gen_ai.request.frequency_penalty"], 1.0)
+
+    def test_option_reflected_to_span_attribute_max_tokens(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config=GenerateContentConfig(max_output_tokens=5000))
+        self.assertEqual(span.attributes["gen_ai.request.max_tokens"], 5000)
+
+    def test_option_reflected_to_span_attribute_presence_penalty(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config=GenerateContentConfig(presence_penalty=0.5))
+        self.assertEqual(span.attributes["gen_ai.request.presence_penalty"], 0.5)
+
+    def test_option_reflected_to_span_attribute_stop_sequences(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config={"stop_sequences": ["foo", "bar"]})
+        stop_sequences = span.attributes["gen_ai.request.stop_sequences"]
+        self.assertEqual(len(stop_sequences), 2)
+        self.assertEqual(stop_sequences[0], "foo")
+        self.assertEqual(stop_sequences[1], "bar")
+
+    def test_option_reflected_to_span_attribute_top_k(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config=GenerateContentConfig(top_k=20))
+        self.assertEqual(span.attributes["gen_ai.request.top_k"], 20)
+
+    def test_option_reflected_to_span_attribute_top_p(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config={"top_p": 10})
+        self.assertEqual(span.attributes["gen_ai.request.top_p"], 10)
+
+    def test_option_not_reflected_to_span_attribute_system_instruction(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config={"system_instruction": "Yadda yadda yadda"})
+        self.assertNotIn("gen_ai.gcp.request.system_instruction", span.attributes)
+        self.assertNotIn("gen_ai.request.system_instruction", span.attributes)
+        for key in span.attributes:
+            value = span.attributes[key]
+            if isinstance(value, str):
+                self.assertNotIn("Yadda yadda yadda", value)
+
+    def test_option_not_reflected_to_span_attribute_http_headers(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config={"http_options": {
+            "base_url": "my.backend.override",
+            "headers": {
+                "sensitive": 12345,
+            }
+        }})
+        self.assertEqual(
+            span.attributes["gen_ai.gcp.request.http_options.base_url"], "my.backend.override")
+        self.assertNotIn(
+            "gen_ai.gcp.request.http_options.headers.sensitive",
+            span.attributes
+        )
+
+    def test_option_reflected_to_span_attribute_automatic_func_calling(self):
+        self.configure_valid_response(text='Some response')
+        span = self.generate_and_get_span(config={"automatic_function_calling": {
+            "ignore_call_history": True,
+        }})
+        self.assertTrue(
+            span.attributes["gen_ai.gcp.request.automatic_function_calling.ignore_call_history"])
+
     def test_generated_span_counts_tokens(self):
         self.configure_valid_response(input_tokens=123, output_tokens=456)
         self.generate_content(model="gemini-2.0-flash", contents="Some input")