Include more request configuration options into the span attributes for the Google GenAI SDK instrumentation

instrumentation-genai/opentelemetry-instrumentation-google-genai/CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+- Add more request configuration options to the span attributes ([#3374](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3374))
 - Restructure tests to keep in line with repository conventions ([#3344](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3344))
 
 ## Version 0.1b0 (2025-03-05)

instrumentation-genai/opentelemetry-instrumentation-google-genai/TODOS.md

@@ -4,7 +4,6 @@
 
 Here are some TODO items required to achieve stability for this package:
 
- - Add more span-level attributes for request configuration
  - Add more span-level attributes for response information
  - Verify and correct formatting of events:
    - Including the 'role' field for message events

instrumentation-genai/opentelemetry-instrumentation-google-genai/pyproject.toml

@@ -37,9 +37,9 @@ classifiers = [
   "Programming Language :: Python :: 3.12"
 ]
 dependencies = [
-  "opentelemetry-api >=1.30.0, <2",
-  "opentelemetry-instrumentation >=0.51b0, <2",
-  "opentelemetry-semantic-conventions >=0.51b0, <2"
+  "opentelemetry-api >=1.31.1, <2",
+  "opentelemetry-instrumentation >=0.52b1, <2",
+  "opentelemetry-semantic-conventions >=0.52b1, <2"
 ]
 
 [project.optional-dependencies]

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

@@ -0,0 +1,62 @@
+# 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
+from typing import Callable, List, Optional, Set, Union
+
+ALLOWED = True
+DENIED = False
+
+
+def _parse_env_list(s: str) -> Set[str]:
+    result = set()
+    for entry in s.split(","):
+        stripped_entry = entry.strip()
+        if not stripped_entry:
+            continue
+        result.add(stripped_entry)
+    return result
+
+
+class AllowList:
+    def __init__(
+        self,
+        includes: Optional[Union[Set[str], List[str]]] = None,
+        excludes: Optional[Union[Set[str], List[str]]] = None,
+        if_none_match: Optional[Callable[str, bool]] = None,
+    ):
+        self._includes = set(includes or [])
+        self._excludes = set(excludes or [])
+        self._include_all = "*" in self._includes
+        self._exclude_all = "*" in self._excludes
+        assert (not self._include_all) or (
+            not self._exclude_all
+        ), "Can't have '*' in both includes and excludes."
+
+    def allowed(self, x: str):
+        if self._exclude_all:
+            return x in self._includes
+        if self._include_all:
+            return x not in self._excludes
+        return (x in self._includes) and (x not in self._excludes)
+
+    @staticmethod
+    def from_env(
+        includes_env_var: str, excludes_env_var: Optional[str] = None
+    ):
+        includes = _parse_env_list(os.getenv(includes_env_var) or "")
+        excludes = set()
+        if excludes_env_var:
+            excludes = _parse_env_list(os.getenv(excludes_env_var) or "")
+        return AllowList(includes=includes, excludes=excludes)

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

@@ -0,0 +1,18 @@
+# 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.
+
+
+# Prefix to use for LLM model request attributes that are unique GCP
+# (or that have not yet been formally defined in the GenAI/LLM SIG).
+CUSTOM_LLM_REQUEST_PREFIX = "gcp.gen_ai.request"

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

@@ -0,0 +1,257 @@
+# 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 json
+from typing import Any, Callable, Dict, Optional, Sequence, Set, Tuple, Union
+
+Primitive = Union[bool, str, int, float]
+BoolList = list[bool]
+StringList = list[str]
+IntList = list[int]
+FloatList = list[float]
+HomogenousPrimitiveList = Union[BoolList, StringList, IntList, FloatList]
+FlattenedValue = Union[Primitive, HomogenousPrimitiveList]
+FlattenedDict = Dict[str, FlattenedValue]
+
+
+def _concat_key(prefix: Optional[str], suffix: str):
+    if not prefix:
+        return suffix
+    return f"{prefix}.{suffix}"
+
+
+def _is_primitive(v):
+    for t in [str, bool, int, float]:
+        if isinstance(v, t):
+            return True
+    return False
+
+
+def _is_homogenous_primitive_list(v):
+    if not isinstance(v, list):
+        return False
+    if len(v) == 0:
+        return True
+    if not _is_primitive(v[0]):
+        return False
+    first_entry_value_type = type(v[0])
+    for entry in v[1:]:
+        if not isinstance(entry, first_entry_value_type):
+            return False
+    return True
+
+
+def _get_flatten_func(
+    flatten_functions: Dict[str, Callable], key_names: set[str]
+):
+    for key in key_names:
+        flatten_func = flatten_functions.get(key)
+        if flatten_func is not None:
+            return flatten_func
+    return None
+
+
+def _flatten_with_flatten_func(
+    key: str,
+    value: Any,
+    exclude_keys: Set[str],
+    rename_keys: Dict[str, str],
+    flatten_functions: Dict[str, Callable],
+    key_names: Set[str],
+) -> Tuple[bool, Any]:
+    flatten_func = _get_flatten_func(flatten_functions, key_names)
+    if flatten_func is None:
+        return False, value
+    func_output = flatten_func(
+        key,
+        value,
+        exclude_keys=exclude_keys,
+        rename_keys=rename_keys,
+        flatten_functions=flatten_functions,
+    )
+    if func_output is None:
+        return True, {}
+    if _is_primitive(func_output) or _is_homogenous_primitive_list(
+        func_output
+    ):
+        return True, {key: func_output}
+    return False, func_output
+
+
+def _flatten_compound_value(
+    key: str,
+    value: Any,
+    exclude_keys: Set[str],
+    rename_keys: Dict[str, str],
+    flatten_functions: Dict[str, Callable],
+    key_names: Set[str],
+    _from_json=False,
+) -> FlattenedDict:
+    fully_flattened_with_flatten_func, value = _flatten_with_flatten_func(
+        key=key,
+        value=value,
+        exclude_keys=exclude_keys,
+        rename_keys=rename_keys,
+        flatten_functions=flatten_functions,
+        key_names=key_names,
+    )
+    if fully_flattened_with_flatten_func:
+        return value
+    if isinstance(value, dict):
+        return _flatten_dict(
+            value,
+            key_prefix=key,
+            exclude_keys=exclude_keys,
+            rename_keys=rename_keys,
+            flatten_functions=flatten_functions,
+        )
+    if isinstance(value, list):
+        if _is_homogenous_primitive_list(value):
+            return {key: value}
+        return _flatten_list(
+            value,
+            key_prefix=key,
+            exclude_keys=exclude_keys,
+            rename_keys=rename_keys,
+            flatten_functions=flatten_functions,
+        )
+    if hasattr(value, "model_dump"):
+        return _flatten_dict(
+            value.model_dump(),
+            key_prefix=key,
+            exclude_keys=exclude_keys,
+            rename_keys=rename_keys,
+            flatten_functions=flatten_functions,
+        )
+    if _from_json:
+        raise ValueError(
+            f"Cannot flatten value with key {key}; value: {value}"
+        )
+    try:
+        json_string = json.dumps(value)
+    except TypeError as exc:
+        raise ValueError(
+            f"Cannot flatten value with key {key}; value: {value}. Not JSON serializable."
+        ) from exc
+    json_value = json.loads(json_string)
+    return _flatten_value(
+        key,
+        json_value,
+        exclude_keys=exclude_keys,
+        rename_keys=rename_keys,
+        flatten_functions=flatten_functions,
+        # Ensure that we don't recurse indefinitely if "json.loads()" somehow returns
+        # a complex, compound object that does not get handled by the "primitive", "list",
+        # or "dict" cases. Prevents falling back on the JSON serialization fallback path.
+        _from_json=True,
+    )
+
+
+def _flatten_value(
+    key: str,
+    value: Any,
+    exclude_keys: Set[str],
+    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:
+        key_names.add(renamed_key)
+        key = renamed_key
+    if key_names & exclude_keys:
+        return {}
+    if _is_primitive(value):
+        return {key: value}
+    return _flatten_compound_value(
+        key=key,
+        value=value,
+        exclude_keys=exclude_keys,
+        rename_keys=rename_keys,
+        flatten_functions=flatten_functions,
+        key_names=key_names,
+        _from_json=_from_json,
+    )
+
+
+def _flatten_dict(
+    d: Dict[str, Any],
+    key_prefix: str,
+    exclude_keys: Set[str],
+    rename_keys: Dict[str, str],
+    flatten_functions: Dict[str, Callable],
+) -> FlattenedDict:
+    result = {}
+    for key, value in d.items():
+        if key in exclude_keys:
+            continue
+        full_key = _concat_key(key_prefix, key)
+        flattened = _flatten_value(
+            full_key,
+            value,
+            exclude_keys=exclude_keys,
+            rename_keys=rename_keys,
+            flatten_functions=flatten_functions,
+        )
+        result.update(flattened)
+    return result
+
+
+def _flatten_list(
+    lst: list[Any],
+    key_prefix: str,
+    exclude_keys: Set[str],
+    rename_keys: Dict[str, str],
+    flatten_functions: Dict[str, Callable],
+) -> FlattenedDict:
+    result = {}
+    result[_concat_key(key_prefix, "length")] = len(lst)
+    for index, value in enumerate(lst):
+        full_key = f"{key_prefix}[{index}]"
+        flattened = _flatten_value(
+            full_key,
+            value,
+            exclude_keys=exclude_keys,
+            rename_keys=rename_keys,
+            flatten_functions=flatten_functions,
+        )
+        result.update(flattened)
+    return result
+
+
+def flatten_dict(
+    d: Dict[str, Any],
+    key_prefix: Optional[str] = None,
+    exclude_keys: Optional[Sequence[str]] = None,
+    rename_keys: Optional[Dict[str, str]] = None,
+    flatten_functions: Optional[Dict[str, Callable]] = None,
+):
+    key_prefix = key_prefix or ""
+    if exclude_keys is None:
+        exclude_keys = set()
+    elif isinstance(exclude_keys, list):
+        exclude_keys = set(exclude_keys)
+    rename_keys = rename_keys or {}
+    flatten_functions = flatten_functions or {}
+    return _flatten_dict(
+        d,
+        key_prefix=key_prefix,
+        exclude_keys=exclude_keys,
+        rename_keys=rename_keys,
+        flatten_functions=flatten_functions,
+    )