packages/opentelemetry-instrumentation-watsonx/opentelemetry/instrumentation/watsonx/__init__.py (1)

210-225: Replace LLM token attributes with GEN_AI equivalents

The semantic-conventions package exports GEN_AI_USAGE_INPUT_TOKENS and GEN_AI_USAGE_OUTPUT_TOKENS, so we should stop using the old LLM_USAGE_PROMPT_TOKENS and LLM_USAGE_COMPLETION_TOKENS. The total-tokens attribute remains LLM_USAGE_TOTAL_TOKENS (no GEN_AI_USAGE_TOTAL_TOKENS is defined).

Locations to update:

• packages/opentelemetry-instrumentation-watsonx/opentelemetry/instrumentation/watsonx/init.py lines ~210–225
• packages/opentelemetry-instrumentation-watsonx/opentelemetry/instrumentation/watsonx/init.py lines ~324–336

Suggested diff:

-    _set_span_attribute(
-        span,
-        SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
-        stream_response.get("input_token_count"),
-    )
+    _set_span_attribute(
+        span,
+        SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS,
+        stream_response.get("input_token_count"),
+    )

-    _set_span_attribute(
-        span,
-        SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
-        stream_response.get("generated_token_count"),
-    )
+    _set_span_attribute(
+        span,
+        SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS,
+        stream_response.get("generated_token_count"),
+    )

     total_token = stream_response.get("input_token_count") + stream_response.get(
         "generated_token_count"
     )
-    _set_span_attribute(
-        span,
-        SpanAttributes.LLM_USAGE_TOTAL_TOKENS,
-        total_token,
-    )
+    _set_span_attribute(
+        span,
+        SpanAttributes.LLM_USAGE_TOTAL_TOKENS,
+        total_token,
+    )

Please apply the same replacements in the second block (lines 324–336) and update any related tests to expect the new GEN_AI_USAGE_* constants.

packages/traceloop-sdk/traceloop/sdk/tracing/manual.py (1)

49-65: Align usage attributes with Gen AI semantic conventions

The Gen AI spec defines gen_ai.usage.input_tokens, gen_ai.usage.output_tokens, and the cache‐related usage attributes, but does not yet provide gen_ai.usage.total_tokens or a gen_ai.request.type. To stay consistent:

• Replace LLM prompt/completion and cache‐input tokens with the GEN_AI equivalents
• Keep LLM_USAGE_TOTAL_TOKENS and LLM_REQUEST_TYPE as they have no Gen AI counterparts

Locations to update (packages/traceloop-sdk/traceloop/sdk/tracing/manual.py, lines 49–65):

-        self._span.set_attribute(
-            SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.prompt_tokens
-        )
-        self._span.set_attribute(
-            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, usage.completion_tokens
-        )
+        self._span.set_attribute(
+            SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage.prompt_tokens
+        )
+        self._span.set_attribute(
+            SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, usage.completion_tokens
+        )
         self._span.set_attribute(
             SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.total_tokens
         )
-        self._span.set_attribute(
-            SpanAttributes.LLM_USAGE_CACHE_CREATION_INPUT_TOKENS,
-            usage.cache_creation_input_tokens,
-        )
-        self._span.set_attribute(
-            SpanAttributes.LLM_USAGE_CACHE_READ_INPUT_TOKENS,
-            usage.cache_read_input_tokens,
-        )
+        self._span.set_attribute(
+            SpanAttributes.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS,
+            usage.cache_creation_input_tokens,
+        )
+        self._span.set_attribute(
+            SpanAttributes.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS,
+            usage.cache_read_input_tokens,
+        )

No change needed for LLM_REQUEST_TYPE—the semantic conventions only define "llm.request.type" at this time.

packages/opentelemetry-instrumentation-langchain/opentelemetry/instrumentation/langchain/callback_handler.py (1)

479-497: None > 0 guard needed before metric recording

prompt_tokens or completion_tokens can be None when the provider omits usage stats.
Comparing None > 0 raises TypeError.

-            if prompt_tokens > 0:
+            if isinstance(prompt_tokens, (int, float)) and prompt_tokens > 0:
@@
-            if completion_tokens > 0:
+            if isinstance(completion_tokens, (int, float)) and completion_tokens > 0:

packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/v1/assistant_wrappers.py (1)

226-233: Inconsistent token usage attribute naming.

The token usage attributes still use the legacy LLM_USAGE_* naming instead of the newer GEN_AI_USAGE_* conventions. Based on the PR objectives to update token terminology, these should be updated to align with the new naming conventions.

Apply this diff to align with the new token usage attribute naming:

         _set_span_attribute(
             span,
-            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
+            SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS,
             usage_dict.get("completion_tokens"),
         )
         _set_span_attribute(
             span,
-            SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
+            SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS,
             usage_dict.get("prompt_tokens"),
         )

packages/opentelemetry-instrumentation-openai-agents/opentelemetry/instrumentation/openai_agents/__init__.py (1)

402-416: Inconsistent token usage attribute naming.

The token usage span attributes still use the legacy LLM_USAGE_* naming instead of the newer GEN_AI_USAGE_* conventions, which is inconsistent with the overall migration to GenAI semantic conventions.

Consider updating these attributes to align with the new naming conventions:

             set_span_attribute(
                 span,
-                SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
+                SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS,
                 input_tokens,
             )

             set_span_attribute(
                 span,
-                SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
+                SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS,
                 output_tokens,
             )

packages/opentelemetry-instrumentation-llamaindex/opentelemetry/instrumentation/llamaindex/span_utils.py (1)

80-89: Inconsistent attribute naming - some LLM_ attributes remain.*

While the response model was updated, the token usage attributes and finish reason attribute still use the legacy LLM_* naming instead of the newer GEN_AI_* conventions.

Consider updating these remaining attributes for consistency:

         span.set_attribute(
-            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, usage.completion_tokens
+            SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, usage.completion_tokens
         )
-        span.set_attribute(SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.prompt_tokens)
+        span.set_attribute(SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage.prompt_tokens)

And for the finish reason attribute:

         span.set_attribute(
-            SpanAttributes.LLM_RESPONSE_FINISH_REASON, choices[0].finish_reason
+            SpanAttributes.GEN_AI_RESPONSE_FINISH_REASONS, choices[0].finish_reason
         )

packages/opentelemetry-instrumentation-together/opentelemetry/instrumentation/together/span_utils.py (1)

88-109: Incomplete semantic convention migration for token usage attributes

While GEN_AI_RESPONSE_MODEL has been correctly updated, the token usage attributes on lines 97, 102, and 107 still use the legacy LLM_USAGE_* naming convention. Based on the PR objectives to update token usage terminology, these should be updated to:

• LLM_USAGE_PROMPT_TOKENS → GEN_AI_USAGE_INPUT_TOKENS
• LLM_USAGE_COMPLETION_TOKENS → GEN_AI_USAGE_OUTPUT_TOKENS
• LLM_USAGE_TOTAL_TOKENS → GEN_AI_USAGE_TOTAL_TOKENS

    _set_span_attribute(
        span,
-       SpanAttributes.LLM_USAGE_TOTAL_TOKENS,
+       SpanAttributes.GEN_AI_USAGE_TOTAL_TOKENS,
        input_tokens + output_tokens,
    )
    _set_span_attribute(
        span,
-       SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
+       SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS,
        output_tokens,
    )
    _set_span_attribute(
        span,
-       SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
+       SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS,
        input_tokens,
    )

packages/opentelemetry-instrumentation-bedrock/tests/traces/test_nova.py (1)

902-911: Update token usage attribute names in streaming tests

The new semantic conventions define GEN_AI_USAGE_INPUT_TOKENS and GEN_AI_USAGE_OUTPUT_TOKENS, so the legacy LLM_USAGE_* constants should be replaced accordingly. Since there is no GEN_AI_USAGE_TOTAL_TOKENS constant, compute the total by summing input and output tokens.

• File: packages/opentelemetry-instrumentation-bedrock/tests/traces/test_nova.py (around lines 902–911)

• Replace SpanAttributes.LLM_USAGE_PROMPT_TOKENS → SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS
• Replace SpanAttributes.LLM_USAGE_COMPLETION_TOKENS → SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS
• Update total‐tokens assertion to sum the two new attributes instead of using LLM_USAGE_TOTAL_TOKENS

Suggested diff:

- assert (
-     bedrock_span.attributes[SpanAttributes.LLM_USAGE_PROMPT_TOKENS]
-     == inputTokens
- )
- assert (
-     bedrock_span.attributes[SpanAttributes.LLM_USAGE_COMPLETION_TOKENS]
-     == outputTokens
- )
- assert (
-     bedrock_span.attributes[SpanAttributes.LLM_USAGE_TOTAL_TOKENS]
-     == inputTokens + outputTokens
- )
+ assert bedrock_span.attributes[SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS] == inputTokens
+ assert bedrock_span.attributes[SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS] == outputTokens
+ assert (
+     bedrock_span.attributes[SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS]
+     + bedrock_span.attributes[SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]
+     == inputTokens + outputTokens
+ )

packages/opentelemetry-instrumentation-anthropic/opentelemetry/instrumentation/anthropic/span_utils.py (2)

222-230: Token usage attributes not updated to new semantic conventions

Similar to other files in this PR, the token usage attributes still use legacy LLM_USAGE_* naming:

• LLM_USAGE_PROMPT_TOKENS (line 222)
• LLM_USAGE_COMPLETION_TOKENS (line 224)
• LLM_USAGE_TOTAL_TOKENS (line 228)

For consistency with the PR objectives, these should be updated to use GEN_AI_USAGE_* equivalents with the new "input/output" terminology instead of "prompt/completion".

---

76-90: Update semantic convention prefixes for penalty attributes and confirm streaming attribute

The semantic conventions for frequency and presence penalties have GEN_AI_REQUEST_* equivalents and should replace the legacy LLM_* prefixes. The streaming attribute currently has no GEN_AI_* equivalent in the semantic conventions—continue using LLM_IS_STREAMING or propose adding GEN_AI_REQUEST_STREAMING.

• In packages/opentelemetry-instrumentation-anthropic/opentelemetry/instrumentation/anthropic/span_utils.py

• Line 85: replace SpanAttributes.LLM_FREQUENCY_PENALTY with SpanAttributes.GEN_AI_REQUEST_FREQUENCY_PENALTY
• Line 88: replace SpanAttributes.LLM_PRESENCE_PENALTY with SpanAttributes.GEN_AI_REQUEST_PRESENCE_PENALTY
• Line 90: retain SpanAttributes.LLM_IS_STREAMING (no GEN_AI_REQUEST_STREAMING found in opentelemetry-semantic-conventions-ai)

Suggested diff:

- set_span_attribute(
-     span, SpanAttributes.LLM_FREQUENCY_PENALTY, kwargs.get("frequency_penalty")
- )
+ set_span_attribute(
+     span, SpanAttributes.GEN_AI_REQUEST_FREQUENCY_PENALTY, kwargs.get("frequency_penalty")
+ )

- set_span_attribute(
-     span, SpanAttributes.LLM_PRESENCE_PENALTY, kwargs.get("presence_penalty")
- )
+ set_span_attribute(
+     span, SpanAttributes.GEN_AI_REQUEST_PRESENCE_PENALTY, kwargs.get("presence_penalty")
+ )

packages/opentelemetry-instrumentation-groq/opentelemetry/instrumentation/groq/span_utils.py (1)

86-140: Migrate legacy LLM_USAGE_* attributes to the new naming convention

The old token-usage constants (LLM_USAGE_COMPLETION_TOKENS, LLM_USAGE_PROMPT_TOKENS, LLM_USAGE_TOTAL_TOKENS) are still in use across multiple instrumentation packages (e.g., groq/span_utils.py, together/span_utils.py, vertexai/span_utils.py, etc.). All of these must be updated to the new attribute names alongside the already-migrated GEN_AI_TOKEN_TYPE and GEN_AI_RESPONSE_MODEL.

Please update every occurrence in your span utilities—including tests—to use the correct, non-legacy constants. You can locate all remaining uses with:

rg -l 'LLM_USAGE_.*TOKEN' packages/opentelemetry-instrumentation-*/

• Replace LLM_USAGE_PROMPT_TOKENS
• Replace LLM_USAGE_COMPLETION_TOKENS
• Replace LLM_USAGE_TOTAL_TOKENS

with their new equivalents in each span_utils.py (and related test files).

packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/shared/__init__.py (1)

287-300: _get_vendor_from_url returns capital-cased values that violate the GenAI enum

GenAISystemValues in the incuabating semconv are lower-case ("openai", "aws", "azure", …).
Here we return "AWS", "Azure", etc.; this will produce spans that fail semantic-convention
validation and break downstream queries that expect the canonical values.

-    if "openai.azure.com" in base_url:
-        return "Azure"
-    elif "amazonaws.com" in base_url or "bedrock" in base_url:
-        return "AWS"
-    elif "googleapis.com" in base_url or "vertex" in base_url:
-        return "Google"
-    elif "openrouter.ai" in base_url:
-        return "OpenRouter"
+    if "openai.azure.com" in base_url:
+        return "azure"
+    elif "amazonaws.com" in base_url or "bedrock" in base_url:
+        return "aws"
+    elif "googleapis.com" in base_url or "vertex" in base_url:
+        return "google"
+    elif "openrouter.ai" in base_url:
+        return "openrouter"

A one-line return vendor.lower() after detection would also work.

packages/opentelemetry-instrumentation-bedrock/tests/traces/test_titan.py (1)

269-276: Repeat comment: use enum for vendor

Same concern as above—replace the literal "AWS" with the enum value to stay future-proof.

packages/opentelemetry-instrumentation-llamaindex/opentelemetry/instrumentation/llamaindex/custom_llm_instrumentor.py (1)

177-181: Simplify nested if statements.

The static analysis tool correctly identified nested if statements that can be combined for better readability.

Apply this diff to combine the nested if statements:

-    if should_send_prompts():
-        if llm_request_type == LLMRequestTypeValues.COMPLETION:
+    if should_send_prompts() and llm_request_type == LLMRequestTypeValues.COMPLETION:
             _set_span_attribute(
                 span, f"{SpanAttributes.GEN_AI_COMPLETION}.0.content", response.text
             )

packages/opentelemetry-instrumentation-bedrock/tests/traces/test_titan.py (1)

51-52: Prefer the official enum to avoid string drift

"AWS" is hard-coded while elsewhere the enum GenAIAttributes.GenAiSystemValues.AWS_BEDROCK.value is used. Using the enum keeps tests aligned if the canonical value ever changes.

-assert bedrock_span.attributes[SpanAttributes.GEN_AI_SYSTEM] == "AWS"
+assert (
+    bedrock_span.attributes[SpanAttributes.GEN_AI_SYSTEM]
+    == GenAIAttributes.GenAiSystemValues.AWS_BEDROCK.value
+)

packages/opentelemetry-instrumentation-cohere/tests/test_completion.py (1)

53-56: Minor consistency nit

Consider using GenAIAttributes.GenAiSystemValues.COHERE.value instead of the literal "Cohere" for the vendor check.

packages/opentelemetry-instrumentation-openai/tests/traces/test_embeddings.py (2)

145-153: Duplication across tests

The same literal prompt string & model ID are asserted in ~20 places. Parametrize via pytest.mark.parametrize or a fixture to reduce duplication and improve maintainability.

---

321-327: Enum vs literal vendor value

Throughout the file vendor strings ("openai", etc.) are hard-coded. Prefer the enum values from GenAIAttributes for future resiliency.

packages/opentelemetry-instrumentation-mistralai/tests/test_chat.py (2)

27-41: Repeated literal "MistralAI" vendor

Same comment as other files – consider centralising vendor constant via enum to avoid divergence.

Also applies to: 73-89, 126-143, 179-197

---

176-197: Large duplication – consider parametrised fixtures

The chat & streaming variants share extensive duplicated assertions differing only by the fixture used (instrument_*). A helper asserting common span attributes would shrink the test file and make future convention changes easier.

packages/opentelemetry-instrumentation-vertexai/opentelemetry/instrumentation/vertexai/span_utils.py (2)

25-29: Minor naming mismatch in prompt attribute key

Other instrumentations store the user prompt under …prompt.0.content, but here it is stored under …prompt.0.user.
If this was accidental, switching to content keeps cross-provider parity.

-            f"{SpanAttributes.GEN_AI_PROMPT}.0.user",
+            f"{SpanAttributes.GEN_AI_PROMPT}.0.content",

---

57-66: Unused parameter (llm_model) in set_response_attributes

llm_model is accepted but never referenced. Either remove the argument or use it (e.g., set GEN_AI_RESPONSE_MODEL).

packages/opentelemetry-instrumentation-langchain/opentelemetry/instrumentation/langchain/callback_handler.py (1)

273-276: Mixed attribute families in the same span

GEN_AI_SYSTEM replaces LLM_SYSTEM, but the next line still sets LLM_REQUEST_TYPE. Consider moving that one to a GEN_AI_REQUEST_TYPE constant (if defined) for consistency.

packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/shared/__init__.py (1)

391-402: Hard-coded strings for usage metrics – prefer the SpanAttributes constants

metric_shared_attributes builds the dict with string literals
"gen_ai.operation.name" etc., but uses SpanAttributes.GEN_AI_SYSTEM
and GEN_AI_RESPONSE_MODEL. For the two usage keys introduced in this
PR we now have SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS /
GEN_AI_USAGE_OUTPUT_TOKENS. Using the constants avoids typos and keeps
refactors mechanical.

packages/opentelemetry-instrumentation-anthropic/tests/test_messages.py (2)

1291-1299: Raw "gen_ai.usage.*" literals – use the constants to avoid drift

These assertions use bare strings for the input / output token counters.
Now that SpanAttributes exposes
GEN_AI_USAGE_INPUT_TOKENS / GEN_AI_USAGE_OUTPUT_TOKENS, switch to:

-assert anthropic_span.attributes["gen_ai.usage.input_tokens"] == 514
+assert anthropic_span.attributes[SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS] == 514

Besides eliminating magic strings, it guarantees the tests fail when the
spec keys change again.

Also applies to: 1468-1474, 1604-1610

---

433-468: Verbose prompt/completion assertions – extractor helper would shrink test noise

The repeated pattern

assert span.attributes[f"{SpanAttributes.GEN_AI_PROMPT}.{n}.role"] == ...
assert span.attributes[f"{SpanAttributes.GEN_AI_PROMPT}.{n}.content"] == ...

appears dozens of times. A small helper such as
assert_prompt(span, idx, role, content) would make the intentions
clearer and the diff noise smaller when the convention inevitably
evolves again.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

packages/opentelemetry-semantic-conventions-ai/opentelemetry/semconv_ai/__init__.py (1)

2-4: Long-term direction: prefer using incubating attributes directly in instrumentation.

You’re already moving callers to import gen_ai_attributes directly (good). Keeping these re-exports for now is fine, but plan to deprecate/remove once all instrumentations rely on the incubating package.

Also applies to: 40-78

packages/opentelemetry-instrumentation-vertexai/tests/disabled_test_gemini.py (3)

35-36: Migration to GEN_AI_ keys looks correct; consider referencing SpanAttributes for stability*

The key renames to GEN_AI_* align with the PR objective and the semconv exports. To reduce direct coupling to the incubating OTel module and be consistent with the repository convention referenced by @nirga, prefer accessing these keys via SpanAttributes. This keeps tests resilient if the underlying source of the constants changes.

Apply this diff within the selected ranges:

-        in vertexai_span.attributes[f"{GenAIAttributes.GEN_AI_PROMPT}.0.user"]
+        in vertexai_span.attributes[f"{SpanAttributes.GEN_AI_PROMPT}.0.user"]
@@
-        vertexai_span.attributes[GenAIAttributes.GEN_AI_REQUEST_MODEL]
+        vertexai_span.attributes[SpanAttributes.GEN_AI_REQUEST_MODEL]
@@
-        vertexai_span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS]
+        vertexai_span.attributes[SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS]
@@
-        vertexai_span.attributes[GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]
+        vertexai_span.attributes[SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]
@@
-        vertexai_span.attributes[f"{GenAIAttributes.GEN_AI_COMPLETION}.0.content"]
+        vertexai_span.attributes[f"{SpanAttributes.GEN_AI_COMPLETION}.0.content"]

Also applies to: 38-39, 46-48, 50-52, 54-56

---

86-89: Keep attribute access consistent via SpanAttributes

Same rationale as earlier: swap direct GenAIAttributes usage for SpanAttributes to avoid tying tests to the incubating import path.

-        vertexai_span.attributes[GenAIAttributes.GEN_AI_REQUEST_MODEL]
+        vertexai_span.attributes[SpanAttributes.GEN_AI_REQUEST_MODEL]
@@
-        vertexai_span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS]
+        vertexai_span.attributes[SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS]
@@
-        vertexai_span.attributes[GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]
+        vertexai_span.attributes[SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]

Also applies to: 95-97, 99-101

---

146-149: Use SpanAttributes for GEN_AI_ keys in the third test as well*

For consistency across the file, mirror the same change here.

-        vertexai_span.attributes[GenAIAttributes.GEN_AI_REQUEST_MODEL]
+        vertexai_span.attributes[SpanAttributes.GEN_AI_REQUEST_MODEL]
@@
-        vertexai_span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS]
+        vertexai_span.attributes[SpanAttributes.GEN_AI_USAGE_INPUT_TOKENS]
@@
-        vertexai_span.attributes[GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]
+        vertexai_span.attributes[SpanAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]

Also applies to: 155-157, 159-161

packages/opentelemetry-instrumentation-ollama/tests/test_generation.py (2)

23-36: Drop redundant f-strings around constant keys

f"{GenAIAttributes.GEN_AI_SYSTEM}" and similar are already strings; f-strings add noise without benefit. Prefer passing constants directly for clarity and to avoid accidental formatting bugs.

Example for this block:

-    assert ollama_span.attributes.get(f"{GenAIAttributes.GEN_AI_SYSTEM}") == "ollama"
+    assert ollama_span.attributes.get(GenAIAttributes.GEN_AI_SYSTEM) == "ollama"
@@
-    assert (
-        ollama_span.attributes.get(f"{SpanAttributes.LLM_REQUEST_TYPE}") == "completion"
-    )
+    assert ollama_span.attributes.get(SpanAttributes.LLM_REQUEST_TYPE) == "completion"
-    assert not ollama_span.attributes.get(f"{SpanAttributes.LLM_IS_STREAMING}")
+    assert not ollama_span.attributes.get(SpanAttributes.LLM_IS_STREAMING)
-    assert ollama_span.attributes.get(f"{GenAIAttributes.GEN_AI_REQUEST_MODEL}") == "llama3"
+    assert ollama_span.attributes.get(GenAIAttributes.GEN_AI_REQUEST_MODEL) == "llama3"
-    assert (
-        ollama_span.attributes.get(f"{GenAIAttributes.GEN_AI_PROMPT}.0.content")
-        == "Tell me a joke about OpenTelemetry"
-    )
+    assert ollama_span.attributes.get(f"{GenAIAttributes.GEN_AI_PROMPT}.0.content") \
+        == "Tell me a joke about OpenTelemetry"
-    assert (
-        ollama_span.attributes.get(f"{GenAIAttributes.GEN_AI_COMPLETION}.0.content")
-        == response["response"]
-    )
+    assert ollama_span.attributes.get(f"{GenAIAttributes.GEN_AI_COMPLETION}.0.content") \
+        == response["response"]

Apply the same pattern across the file.

---

74-92: Reduce flakiness: don’t assume log ordering; assert by event name instead

Relying on logs[0]/logs[1] ordering can be brittle across exporters. Resolve by selecting logs by EventAttributes.EVENT_NAME.

For example:

logs = log_exporter.get_finished_logs()
by_name = {log.log_record.attributes.get(EventAttributes.EVENT_NAME): log for log in logs}
assert_message_in_logs(by_name["gen_ai.user.message"], "gen_ai.user.message", {...})
assert_message_in_logs(by_name["gen_ai.choice"], "gen_ai.choice", choice_event)

Also applies to: 116-129, 202-219, 250-263, 332-349, 378-391, 468-485, 518-531

packages/opentelemetry-instrumentation-groq/opentelemetry/instrumentation/groq/span_utils.py (2)

9-14: Consolidate GenAI imports for consistency

Minor nit: Importing GEN_AI_RESPONSE_ID from the submodule while importing gen_ai_attributes from the package root is slightly inconsistent. If the aggregator re-exports the constant, prefer a single import source for readability; otherwise, this is fine to keep as-is.

---

50-58: Support multiple max-tokens parameter names (Groq typically uses max_tokens)

Using only max_tokens_to_sample is Anthropic-specific. Groq/OpenAI-style clients generally use max_tokens. Consider a tolerant fallback to capture whichever the upstream SDK provides.

Apply this diff:

-    set_span_attribute(
-        span, GenAIAttributes.GEN_AI_REQUEST_MAX_TOKENS, kwargs.get("max_tokens_to_sample")
-    )
+    set_span_attribute(
+        span,
+        GenAIAttributes.GEN_AI_REQUEST_MAX_TOKENS,
+        kwargs.get("max_tokens") or kwargs.get("max_output_tokens") or kwargs.get("max_tokens_to_sample"),
+    )

packages/opentelemetry-instrumentation-llamaindex/opentelemetry/instrumentation/llamaindex/custom_llm_instrumentor.py (6)

10-12: Avoid depending on incubating internals; prefer SpanAttributes for stability

Using opentelemetry.semconv._incubating.attributes tightly couples us to an internal path that can change. We already import SpanAttributes, which exposes the same constants and is the stable facade used across the repo.

Apply this diff to drop the direct incubating import:

-from opentelemetry.semconv._incubating.attributes import (
-    gen_ai_attributes as GenAIAttributes,
-)

I’ve proposed replacements below to use SpanAttributes.* where GenAIAttributes.* is referenced.

---

148-151: Use SpanAttributes. instead of GenAIAttributes.**

Stay consistent with the rest of the codebase and reduce direct dependency on incubating internals.

-    _set_span_attribute(span, GenAIAttributes.GEN_AI_SYSTEM, instance.__class__.__name__)
+    _set_span_attribute(span, SpanAttributes.GEN_AI_SYSTEM, instance.__class__.__name__)
     _set_span_attribute(span, SpanAttributes.LLM_REQUEST_TYPE, llm_request_type.value)
     _set_span_attribute(
-        span, GenAIAttributes.GEN_AI_REQUEST_MODEL, instance.metadata.model_name
+        span, SpanAttributes.GEN_AI_REQUEST_MODEL, instance.metadata.model_name
     )

---

176-178: Use SpanAttributes for response model attribute

Consistency with the rest of the instrumentation and avoidance of incubating internals.

     _set_span_attribute(
-        span, GenAIAttributes.GEN_AI_RESPONSE_MODEL, instance.metadata.model_name
+        span, SpanAttributes.GEN_AI_RESPONSE_MODEL, instance.metadata.model_name
     )

---

180-184: Flatten nested condition and use SpanAttributes in completion content

Minor readability nit and consistency improvement.

-    if should_send_prompts():
-        if llm_request_type == LLMRequestTypeValues.COMPLETION:
-            _set_span_attribute(
-                span, f"{GenAIAttributes.GEN_AI_COMPLETION}.0.content", response.text
-            )
+    if should_send_prompts() and llm_request_type == LLMRequestTypeValues.COMPLETION:
+        _set_span_attribute(
+            span, f"{SpanAttributes.GEN_AI_COMPLETION}.0.content", response.text
+        )

---

160-163: Flatten nested condition (ruff SIM102)

Combine the conditions to reduce nesting and match ruff’s SIM102 recommendation.

-    if should_send_prompts():
-        # TODO: add support for chat
-        if llm_request_type == LLMRequestTypeValues.COMPLETION:
+    # TODO: add support for chat
+    if should_send_prompts() and llm_request_type == LLMRequestTypeValues.COMPLETION:

---

167-169: Use SpanAttributes for prompt attribute; keep .0.user suffix

The .0.user suffix is consistent with how COM­PLE­TION requests are instrumented elsewhere. Swap in the stable SpanAttributes constant for the prefix:

Locations to update:

• packages/opentelemetry-instrumentation-llamaindex/opentelemetry/instrumentation/llamaindex/custom_llm_instrumentor.py around lines 167–169

Recommended diff:

-                    f"{GenAIAttributes.GEN_AI_PROMPT}.0.user",
+                    f"{SpanAttributes.GEN_AI_PROMPT}.0.user",

packages/opentelemetry-instrumentation-mistralai/tests/test_chat.py (4)

43-48: Make total token assertion resilient when a usage attribute is missing

If either input or output token usage is absent (common in some async/streaming providers), the current sum will raise a TypeError (None + int). Default missing token attributes to 0 in the equality check to keep tests robust while still validating the accounting.

Apply this pattern at each occurrence:

-    ) == mistral_span.attributes.get(
-        GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS
-    ) + mistral_span.attributes.get(GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS)
+    ) == (
+        (mistral_span.attributes.get(GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS) or 0)
+        + (mistral_span.attributes.get(GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS) or 0)
+    )

Also applies to: 80-86, 133-139, 195-200, 236-242, 293-299, 353-358, 393-398, 447-452, 506-511, 546-551, 602-607

---

496-496: Use the GenAI constant for the request model key for consistency

Avoid hardcoded strings for attribute keys; use the same GenAIAttributes constant you use elsewhere in this file.

-    assert mistral_span.attributes.get("gen_ai.request.model") == "mistral-tiny"
+    assert mistral_span.attributes.get(GenAIAttributes.GEN_AI_REQUEST_MODEL) == "mistral-tiny"

Apply at all three locations.

Also applies to: 544-544, 600-600

---

351-353: Fix copy/paste in comment and clarify provider

These async tests are for Mistral, not Ollama. Also, consider keeping the comment but ensure the total-token assertion won’t fail when prompt tokens are missing (see prior suggestion).

-    # For some reason, async ollama chat doesn't report prompt token usage back
+    # For some reason, async Mistral chat sometimes doesn't report prompt (input) token usage back

Also applies to: 391-393, 445-447

---

27-27: Avoid unnecessary f-strings around attribute key constants

f"{GenAIAttributes.GEN_AI_SYSTEM}" is identical to GenAIAttributes.GEN_AI_SYSTEM. Using the constant directly is cleaner and avoids accidental formatting bugs.

Example edit:

-    assert mistral_span.attributes.get(f"{GenAIAttributes.GEN_AI_SYSTEM}") == "MistralAI"
+    assert mistral_span.attributes.get(GenAIAttributes.GEN_AI_SYSTEM) == "MistralAI"

Apply similarly to GEN_AI_REQUEST_MODEL, GEN_AI_PROMPT, GEN_AI_COMPLETION, etc.

Also applies to: 31-31, 35-35, 39-39, 73-73, 77-77, 183-183, 187-187, 191-191, 229-229, 233-233, 286-286, 290-290, 336-336, 340-340, 343-343, 348-348, 384-384, 388-388, 438-438, 442-442, 493-493, 498-498, 502-502, 541-541, 597-597

packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/v1/assistant_wrappers.py (2)

151-163: Prefer enum value for system attribute to avoid magic strings

Use the GenAI system enum for consistency with other tests and modules.

Apply this diff in both places:

-        _set_span_attribute(
-            span,
-            GenAIAttributes.GEN_AI_SYSTEM,
-            "openai",
-        )
+        _set_span_attribute(
+            span,
+            GenAIAttributes.GEN_AI_SYSTEM,
+            GenAIAttributes.GenAiSystemValues.OPENAI.value,
+        )

Also applies to: 271-279

---

176-185: Inconsistent event emission for run instructions; guard with should_emit_events()

Unlike the assistant-instructions block above, this unconditionally emits an event and also sets span attributes. Align with the pattern: emit events when enabled, otherwise set span attributes, not both.

Apply this refactor:

-    _set_span_attribute(
-        span, f"{GenAIAttributes.GEN_AI_PROMPT}.{prompt_index}.role", "system"
-    )
-    _set_span_attribute(
-        span,
-        f"{GenAIAttributes.GEN_AI_PROMPT}.{prompt_index}.content",
-        run["instructions"],
-    )
-    emit_event(MessageEvent(content=run["instructions"], role="system"))
-    prompt_index += 1
+    if should_emit_events():
+        emit_event(MessageEvent(content=run["instructions"], role="system"))
+    else:
+        _set_span_attribute(
+            span, f"{GenAIAttributes.GEN_AI_PROMPT}.{prompt_index}.role", "system"
+        )
+        _set_span_attribute(
+            span,
+            f"{GenAIAttributes.GEN_AI_PROMPT}.{prompt_index}.content",
+            run["instructions"],
+        )
+        prompt_index += 1

packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/v1/responses_wrappers.py (1)

180-186: Guard usage attribute access for older SDKs
When RESPONSES_AVAILABLE is False, traced_response.usage is a plain Dict[str, Any], so expressions like usage.input_tokens will raise an attribute error. To ensure compatibility, normalize usage via model_as_dict or switch to dict-style access.

Pay special attention to these lines in
packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/v1/responses_wrappers.py

• 182: usage.input_tokens
• 183: usage.output_tokens
• 185: usage.total_tokens
• 187: usage.input_tokens_details
• 191: usage.input_tokens_details.cached_tokens

For example:

if usage := traced_response.usage:
    usage_dict = model_as_dict(usage)
    _set_span_attribute(span, GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage_dict.get("input_tokens"))
    …

packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/shared/chat_wrappers.py (1)

736-874: Minor duplication: consider extracting shared post-stream handling.

_build_from_streaming_response and _abuild_from_streaming_response duplicate logic for shared attributes, token/choice/duration metrics, response attribute setting, and span closure. Optional: extract a small helper to reduce duplication and future drift.

packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/shared/__init__.py (1)

115-131: Set GEN_AI_SYSTEM using canonical enum value (when available).

Right now vendor values like "openai" (lowercase) or "AWS" are set directly. The spec exposes canonical system enum values (e.g., GenAiSystemValues.OPENAI). To avoid casing drift and improve consistency across providers, normalize to the enum value when present and fall back to the raw string.

Apply this diff in-place:

-    _set_span_attribute(span, GenAIAttributes.GEN_AI_SYSTEM, vendor)
+    # Normalize to spec enum value when available; fallback to string
+    system_enum = getattr(getattr(GenAIAttributes, "GenAiSystemValues", object()), vendor.upper(), None)
+    _set_span_attribute(
+        span,
+        GenAIAttributes.GEN_AI_SYSTEM,
+        system_enum.value if system_enum is not None else vendor,
+    )

Optionally, to keep the call-site lean, add a small helper and use it here:

# Define once near other helpers in this module (outside this diff hunk)
def _normalize_gen_ai_system(vendor: str) -> str:
    enum_cls = getattr(GenAIAttributes, "GenAiSystemValues", None)
    if enum_cls:
        maybe = getattr(enum_cls, vendor.upper(), None)
        if maybe:
            return maybe.value
    return vendor

Then change the set call to:

_set_span_attribute(span, GenAIAttributes.GEN_AI_SYSTEM, _normalize_gen_ai_system(vendor))

packages/opentelemetry-instrumentation-cohere/opentelemetry/instrumentation/cohere/span_utils.py (1)

142-145: Inline the generations selection (Ruff SIM108).

Minor readability nit: prefer a ternary expression.

-    if hasattr(response, "generations"):
-        generations = response.generations  # Cohere v5
-    else:
-        generations = response  # Cohere v4
+    generations = response.generations if hasattr(response, "generations") else response  # Cohere v5 vs v4

packages/opentelemetry-instrumentation-cohere/tests/test_rerank.py (1)

41-45: Prefer enum value for GEN_AI_SYSTEM in assertions.

Use the spec enum to avoid casing drift and keep tests resilient to normalization changes.

-    assert cohere_span.attributes.get(GenAIAttributes.GEN_AI_SYSTEM) == "Cohere"
+    assert cohere_span.attributes.get(GenAIAttributes.GEN_AI_SYSTEM) == GenAIAttributes.GenAiSystemValues.COHERE.value

Repeat similarly for the other two occurrences in this file.

Also applies to: 121-126, 185-190

packages/opentelemetry-semantic-conventions-ai/opentelemetry/semconv_ai/__init__.py (1)

42-78: Style: normalize spacing around '=' for readability (PEP 8).

Several assignments have inconsistent spacing. Not a blocker, but easy to tidy.

-    GEN_AI_AGENT_DESCRIPTION=GenAIAttributes.GEN_AI_AGENT_DESCRIPTION
-    GEN_AI_AGENT_ID= GenAIAttributes.GEN_AI_AGENT_ID
-    GEN_AI_AGENT_NAME= GenAIAttributes.GEN_AI_AGENT_NAME
-    GEN_AI_COMPLETION=GenAIAttributes.GEN_AI_COMPLETION
-    GEN_AI_CONVERSATION_ID=GenAIAttributes.GEN_AI_CONVERSATION_ID
-    GEN_AI_DATA_SOURCE_ID=GenAIAttributes.GEN_AI_DATA_SOURCE_ID
-    GEN_AI_OPENAI_REQUEST_SERVICE_TIER=GenAIAttributes.GEN_AI_OPENAI_REQUEST_SERVICE_TIER
-    GEN_AI_OPENAI_RESPONSE_SERVICE_TIER=GenAIAttributes.GEN_AI_OPENAI_RESPONSE_SERVICE_TIER
-    GEN_AI_OPENAI_RESPONSE_SYSTEM_FINGERPRINT=GenAIAttributes.GEN_AI_OPENAI_RESPONSE_SYSTEM_FINGERPRINT
-    GEN_AI_OUTPUT_TYPE=GenAIAttributes.GEN_AI_OUTPUT_TYPE
-    GEN_AI_PROMPT=GenAIAttributes.GEN_AI_PROMPT
-    GEN_AI_REQUEST_CHOICE_COUNT=GenAIAttributes.GEN_AI_REQUEST_CHOICE_COUNT
-    GEN_AI_REQUEST_ENCODING_FORMATS= GenAIAttributes.GEN_AI_REQUEST_ENCODING_FORMATS
-    GEN_AI_REQUEST_FREQUENCY_PENALTY= GenAIAttributes.GEN_AI_REQUEST_FREQUENCY_PENALTY
-    GEN_AI_REQUEST_MAX_TOKENS=GenAIAttributes.GEN_AI_REQUEST_MAX_TOKENS
-    GEN_AI_REQUEST_MODEL=GenAIAttributes.GEN_AI_REQUEST_MODEL
-    GEN_AI_REQUEST_PRESENCE_PENALTY=GenAIAttributes.GEN_AI_REQUEST_PRESENCE_PENALTY
-    GEN_AI_REQUEST_SEED=GenAIAttributes.GEN_AI_REQUEST_SEED
-    GEN_AI_REQUEST_STOP_SEQUENCES=GenAIAttributes.GEN_AI_REQUEST_STOP_SEQUENCES
-    GEN_AI_REQUEST_TEMPERATURE=GenAIAttributes.GEN_AI_REQUEST_TEMPERATURE
-    GEN_AI_REQUEST_TOP_K=GenAIAttributes.GEN_AI_REQUEST_TOP_K
-    GEN_AI_REQUEST_TOP_P=GenAIAttributes.GEN_AI_REQUEST_TOP_P
+    GEN_AI_AGENT_DESCRIPTION = GenAIAttributes.GEN_AI_AGENT_DESCRIPTION
+    GEN_AI_AGENT_ID = GenAIAttributes.GEN_AI_AGENT_ID
+    GEN_AI_AGENT_NAME = GenAIAttributes.GEN_AI_AGENT_NAME
+    GEN_AI_COMPLETION = GenAIAttributes.GEN_AI_COMPLETION
+    GEN_AI_CONVERSATION_ID = GenAIAttributes.GEN_AI_CONVERSATION_ID
+    GEN_AI_DATA_SOURCE_ID = GenAIAttributes.GEN_AI_DATA_SOURCE_ID
+    GEN_AI_OPENAI_REQUEST_SERVICE_TIER = GenAIAttributes.GEN_AI_OPENAI_REQUEST_SERVICE_TIER
+    GEN_AI_OPENAI_RESPONSE_SERVICE_TIER = GenAIAttributes.GEN_AI_OPENAI_RESPONSE_SERVICE_TIER
+    GEN_AI_OPENAI_RESPONSE_SYSTEM_FINGERPRINT = GenAIAttributes.GEN_AI_OPENAI_RESPONSE_SYSTEM_FINGERPRINT
+    GEN_AI_OUTPUT_TYPE = GenAIAttributes.GEN_AI_OUTPUT_TYPE
+    GEN_AI_PROMPT = GenAIAttributes.GEN_AI_PROMPT
+    GEN_AI_REQUEST_CHOICE_COUNT = GenAIAttributes.GEN_AI_REQUEST_CHOICE_COUNT
+    GEN_AI_REQUEST_ENCODING_FORMATS = GenAIAttributes.GEN_AI_REQUEST_ENCODING_FORMATS
+    GEN_AI_REQUEST_FREQUENCY_PENALTY = GenAIAttributes.GEN_AI_REQUEST_FREQUENCY_PENALTY
+    GEN_AI_REQUEST_MAX_TOKENS = GenAIAttributes.GEN_AI_REQUEST_MAX_TOKENS
+    GEN_AI_REQUEST_MODEL = GenAIAttributes.GEN_AI_REQUEST_MODEL
+    GEN_AI_REQUEST_PRESENCE_PENALTY = GenAIAttributes.GEN_AI_REQUEST_PRESENCE_PENALTY
+    GEN_AI_REQUEST_SEED = GenAIAttributes.GEN_AI_REQUEST_SEED
+    GEN_AI_REQUEST_STOP_SEQUENCES = GenAIAttributes.GEN_AI_REQUEST_STOP_SEQUENCES
+    GEN_AI_REQUEST_TEMPERATURE = GenAIAttributes.GEN_AI_REQUEST_TEMPERATURE
+    GEN_AI_REQUEST_TOP_K = GenAIAttributes.GEN_AI_REQUEST_TOP_K
+    GEN_AI_REQUEST_TOP_P = GenAIAttributes.GEN_AI_REQUEST_TOP_P

packages/opentelemetry-instrumentation-replicate/opentelemetry/instrumentation/replicate/__init__.py (1)

124-132: Use canonical enum for GEN_AI_SYSTEM (if available).

Minor consistency tweak: prefer the spec enum over a raw string.

-            GenAIAttributes.GEN_AI_SYSTEM: "Replicate",
+            GenAIAttributes.GEN_AI_SYSTEM: GenAIAttributes.GenAiSystemValues.REPLICATE.value,

packages/opentelemetry-instrumentation-langchain/tests/test_tool_calls.py (1)

59-67: Nit: reduce repetition when building attribute keys.

The repeated f-strings for keys like f"{GenAIAttributes.GEN_AI_PROMPT}.N.role/content" and f"{GenAIAttributes.GEN_AI_COMPLETION}.M.tool_calls.K.*" can be slightly DRYed in tests with small helpers (e.g., prompt_key(i, suffix), completion_tool_call_key(i, j, suffix)). Not required, but would improve readability.

packages/opentelemetry-instrumentation-anthropic/tests/utils.py (1)

60-63: Optional: use the constant for system attribute for consistency.

You assert against the literal "gen_ai.system" key; consider using GenAIAttributes.GEN_AI_SYSTEM as elsewhere in the repo.

Apply this diff:

-                assert all(
-                    data_point.attributes.get("gen_ai.system") == "anthropic"
-                    for data_point in metric.data.data_points
-                )
+                assert all(
+                    data_point.attributes.get(GenAIAttributes.GEN_AI_SYSTEM) == "anthropic"
+                    for data_point in metric.data.data_points
+                )

packages/opentelemetry-instrumentation-bedrock/tests/metrics/test_bedrock_guardrails_metrics.py (1)

126-129: Safer assertion on first datapoint access.

Indexing metric.data.data_points[0] assumes at least one datapoint; guard it to avoid potential IndexError in edge cases.

Apply this diff:

-                assert (
-                    metric.data.data_points[0].attributes[GenAIAttributes.GEN_AI_SYSTEM]
-                    == "bedrock"
-                )
+                # Ensure at least one datapoint exists before indexing
+                assert metric.data.data_points, f"No datapoints for metric {metric.name}"
+                assert (
+                    metric.data.data_points[0].attributes[GenAIAttributes.GEN_AI_SYSTEM]
+                    == "bedrock"
+                )

packages/opentelemetry-instrumentation-anthropic/opentelemetry/instrumentation/anthropic/__init__.py (2)

185-191: Use SpanAttributes for cache token attributes to avoid potential AttributeError

GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS and GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS are guaranteed on SpanAttributes (string constants). Depending on your semconv version, they may not exist on GenAIAttributes. For consistency with streaming.py and to avoid runtime attribute errors, use SpanAttributes here too.

Proposed change:

-    set_span_attribute(
-        span, GenAIAttributes.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, cache_read_tokens
-    )
+    set_span_attribute(
+        span, SpanAttributes.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, cache_read_tokens
+    )
-    set_span_attribute(
-        span,
-        GenAIAttributes.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS,
-        cache_creation_tokens,
-    )
+    set_span_attribute(
+        span,
+        SpanAttributes.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS,
+        cache_creation_tokens,
+    )

And likewise for the synchronous path:

-    set_span_attribute(
-        span, GenAIAttributes.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, cache_read_tokens
-    )
+    set_span_attribute(
+        span, SpanAttributes.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS, cache_read_tokens
+    )
-    set_span_attribute(
-        span,
-        GenAIAttributes.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS,
-        cache_creation_tokens,
-    )
+    set_span_attribute(
+        span,
+        SpanAttributes.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS,
+        cache_creation_tokens,
+    )

Also applies to: 276-283

---

101-110: Nit: avoid mutable default arguments

metric_attributes: dict = {} creates a shared default across calls. Prefer None default and initialize inside.

Minimal patch:

-async def _aset_token_usage(..., metric_attributes: dict = {}, token_histogram: Histogram = None, choice_counter: Counter = None):
+async def _aset_token_usage(..., metric_attributes: dict | None = None, token_histogram: Histogram | None = None, choice_counter: Counter | None = None):
+    metric_attributes = metric_attributes or {}
 
-def _set_token_usage(..., metric_attributes: dict = {}, token_histogram: Histogram = None, choice_counter: Counter = None):
+def _set_token_usage(..., metric_attributes: dict | None = None, token_histogram: Histogram | None = None, choice_counter: Counter | None = None):
+    metric_attributes = metric_attributes or {}

Also applies to: 194-203

packages/opentelemetry-instrumentation-anthropic/opentelemetry/instrumentation/anthropic/streaming.py (1)

105-112: Prefer isinstance over direct type comparison for ints

type(x) is int is brittle; use isinstance(x, int). Same for completion_tokens.

Apply:

-    if token_histogram and type(input_tokens) is int and input_tokens >= 0:
+    if token_histogram and isinstance(input_tokens, int) and input_tokens >= 0:
...
-    if token_histogram and type(completion_tokens) is int and completion_tokens >= 0:
+    if token_histogram and isinstance(completion_tokens, int) and completion_tokens >= 0:

Also applies to: 114-121

packages/opentelemetry-instrumentation-anthropic/tests/test_messages.py (3)

1294-1299: Prefer constants over string literals for usage keys (and consider aligning total_tokens constant)

Use GenAIAttributes/SpanAttributes constants instead of raw strings to reduce drift and ease refactors. Also prefer the SpanAttributes constant over "llm.usage.total_tokens" literal.

Apply these diffs:

@@
-    assert anthropic_span.attributes["gen_ai.usage.input_tokens"] == 514
-    assert (
-        anthropic_span.attributes["gen_ai.usage.output_tokens"]
-        + anthropic_span.attributes["gen_ai.usage.input_tokens"]
-        == anthropic_span.attributes["llm.usage.total_tokens"]
-    )
+    assert anthropic_span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS] == 514
+    assert (
+        anthropic_span.attributes[GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]
+        + anthropic_span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS]
+        == anthropic_span.attributes[SpanAttributes.LLM_USAGE_TOTAL_TOKENS]
+    )

@@
-    assert anthropic_span.attributes["gen_ai.usage.input_tokens"] == 514
-    assert (
-        anthropic_span.attributes["gen_ai.usage.output_tokens"]
-        + anthropic_span.attributes["gen_ai.usage.input_tokens"]
-        == anthropic_span.attributes["llm.usage.total_tokens"]
-    )
+    assert anthropic_span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS] == 514
+    assert (
+        anthropic_span.attributes[GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]
+        + anthropic_span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS]
+        == anthropic_span.attributes[SpanAttributes.LLM_USAGE_TOTAL_TOKENS]
+    )

@@
-    assert anthropic_span.attributes["gen_ai.usage.input_tokens"] == 514
-    assert (
-        anthropic_span.attributes["gen_ai.usage.output_tokens"]
-        + anthropic_span.attributes["gen_ai.usage.input_tokens"]
-        == anthropic_span.attributes["llm.usage.total_tokens"]
-    )
+    assert anthropic_span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS] == 514
+    assert (
+        anthropic_span.attributes[GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]
+        + anthropic_span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS]
+        == anthropic_span.attributes[SpanAttributes.LLM_USAGE_TOTAL_TOKENS]
+    )

If verification (see prior comment) confirms a GenAI total tokens attribute is available and set by the instrumentation, switch the right-hand side to GenAIAttributes.GEN_AI_USAGE_TOTAL_TOKENS instead of SpanAttributes.LLM_USAGE_TOTAL_TOKENS.

Also applies to: 1469-1474, 1605-1610

---

64-66: Nit: Use direct indexing instead of .get for required attributes to fail fast

Using dict-style indexing will surface missing attributes as KeyError instead of silently returning None, making failures more actionable in tests.

Example change (apply similarly to other occurrences):

-    assert (
-        anthropic_span.attributes.get(f"{GenAIAttributes.GEN_AI_COMPLETION}.0.content")
-        == response.content[0].text
-    )
+    assert (
+        anthropic_span.attributes[f"{GenAIAttributes.GEN_AI_COMPLETION}.0.content"]
+        == response.content[0].text
+    )

Also applies to: 247-249, 528-529, 713-714, 900-901, 1078-1079

---

71-76: Optional: factor usage-token sum assertion into a small helper to reduce duplication

This assertion pattern repeats throughout the file. A tiny helper improves readability and maintenance.

Add once near the bottom (outside current ranges):

def assert_usage_sums(span):
    assert span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS] >= 0
    assert span.attributes[GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS] >= 0
    assert (
        span.attributes[GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]
        + span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS]
        == span.attributes[SpanAttributes.LLM_USAGE_TOTAL_TOKENS]
    )

And replace here as:

-    assert (
-        anthropic_span.attributes[GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS]
-        + anthropic_span.attributes[GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS]
-        == anthropic_span.attributes[SpanAttributes.LLM_USAGE_TOTAL_TOKENS]
-    )
+    assert_usage_sums(anthropic_span)

If we later migrate total_tokens to GenAI, the change is centralized.

packages/opentelemetry-instrumentation-watsonx/opentelemetry/instrumentation/watsonx/__init__.py (3)

135-146: Prompt attribute keys migrated to GEN_AI_PROMPT — avoid shadowing built-in input

The rename to gen-ai prompt keys is correct. Minor nit: the loop variable name input shadows the built-in. Rename to avoid confusion.

Apply this diff:

-        for index, input in enumerate(prompt):
+        for index, message in enumerate(prompt):
             _set_span_attribute(
                 span,
-                f"{GenAIAttributes.GEN_AI_PROMPT}.{index}.user",
-                input,
+                f"{GenAIAttributes.GEN_AI_PROMPT}.{index}.user",
+                message,
             )

---

563-570: Use consistent system casing ("watsonx") to match metric_shared_attributes

Start span sets GEN_AI_SYSTEM to "Watsonx" (capitalized), while metrics use "watsonx". Suggest using lowercase across the board.

Apply this diff:

-        attributes={
-            GenAIAttributes.GEN_AI_SYSTEM: "Watsonx",
+        attributes={
+            GenAIAttributes.GEN_AI_SYSTEM: "watsonx",
             SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
         },

---

442-445: Unify GEN_AI_SYSTEM value casing

Confirmed inconsistent values in this file:

• packages/opentelemetry-instrumentation-watsonx/opentelemetry/instrumentation/watsonx/init.py:443 uses "watsonx"
• packages/opentelemetry-instrumentation-watsonx/opentelemetry/instrumentation/watsonx/init.py:567 uses "Watsonx"

To avoid metric/attribute fragmentation, pick a single canonical casing (e.g. "Watsonx") and update the lowercase occurrence:

--- a/packages/opentelemetry-instrumentation-watsonx/opentelemetry/instrumentation/watsonx/__init__.py
+++ b/packages/opentelemetry-instrumentation-watsonx/opentelemetry/instrumentation/watsonx/__init__.py
@@ -440,7 +440,7 @@ def _build_attributes(...):
         GenAIAttributes.GEN_AI_RESPONSE_MODEL: response_model,
-        GenAIAttributes.GEN_AI_SYSTEM: "watsonx",
+        GenAIAttributes.GEN_AI_SYSTEM: "Watsonx",
         "stream": is_streaming,
     }

packages/opentelemetry-instrumentation-openai-agents/opentelemetry/instrumentation/openai_agents/__init__.py (2)

517-523: Confirm prompt attribute structure vs. semconv; indexing may cause high cardinality

You emit ...GEN_AI_PROMPT.{i}.role/content. Many semconvs prefer arrays (e.g., ...prompt.roles: [], ...prompt.contents: []) over dynamic keys. Verify this matches the GenAI spec you’re targeting; if not, consider array attributes to reduce attribute-cardinality.

Would you like me to propose an alternative that emits arrays instead of index-suffixed keys?

---

426-439: Use the set_span_attribute helper for GenAI tool fields

All direct calls to span.set_attribute on tool-specific completion attributes should use the set_span_attribute(span, key, value) helper so that null or empty values are skipped.

• File: packages/opentelemetry-instrumentation-openai-agents/opentelemetry/instrumentation/openai_agents/init.py
– Lines 426–439 (FunctionTool fields)
– Lines 471–501 (WebSearchTool, FileSearchTool, ComputerTool fields)

Example diff:

@@ -426,7 +426,7 @@
-   span.set_attribute(
-       f"{GenAIAttributes.GEN_AI_COMPLETION}.tool.name", tool_name
-   )
+   set_span_attribute(
+       span, f"{GenAIAttributes.GEN_AI_COMPLETION}.tool.name", tool_name
+   )

@@ -430,7 +430,7 @@
-   span.set_attribute(
-       f"{GenAIAttributes.GEN_AI_COMPLETION}.tool.type", "FunctionTool"
-   )
+   set_span_attribute(
+       span, f"{GenAIAttributes.GEN_AI_COMPLETION}.tool.type", "FunctionTool"
+   )

...and so on for `.tool.description` and `.tool.strict_json_schema`, and likewise in the 471–501 block.

Note: the current semconv package does not yet define dedicated constants for these tool-specific attributes (e.g. GEN_AI_COMPLETION_TOOL_NAME), so formatted strings are required for now.

packages/opentelemetry-instrumentation-anthropic/tests/utils.py (1)

1-3: Import fix resolves prior F821 (undefined name) for GenAIAttributes

Good catch adding the incubating GenAIAttributes import; this unblocks lint/tests and aligns with PR goals.

packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/v1/responses_wrappers.py (1)

181-193: Back-compat bug: usage fields may be dicts; attribute access will raise; also support legacy prompt/completion token names

On older OpenAI SDKs (RESPONSES_AVAILABLE=False), usage and input_tokens_details are dicts. Accessing usage.input_tokens / usage.input_tokens_details.cached_tokens will raise. Also, some providers still emit prompt_tokens/completion_tokens. Handle both object and dict shapes and map legacy names.

Apply this diff:

-    if usage := traced_response.usage:
-        _set_span_attribute(span, GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage.input_tokens)
-        _set_span_attribute(span, GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, usage.output_tokens)
-        _set_span_attribute(
-            span, SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.total_tokens
-        )
-        if usage.input_tokens_details:
-            _set_span_attribute(
-                span,
-                GenAIAttributes.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS,
-                usage.input_tokens_details.cached_tokens,
-            )
+    if usage := traced_response.usage:
+        # usage can be a pydantic model or a plain dict (older SDKs)
+        is_dict = isinstance(usage, dict)
+
+        input_tokens = (usage.get("input_tokens") if is_dict else getattr(usage, "input_tokens", None))
+        # Back-compat: some SDKs used 'prompt_tokens'
+        if input_tokens is None and is_dict:
+            input_tokens = usage.get("prompt_tokens")
+        _set_span_attribute(span, GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)
+
+        output_tokens = (usage.get("output_tokens") if is_dict else getattr(usage, "output_tokens", None))
+        # Back-compat: some SDKs used 'completion_tokens'
+        if output_tokens is None and is_dict:
+            output_tokens = usage.get("completion_tokens")
+        _set_span_attribute(span, GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, output_tokens)
+
+        total_tokens = (usage.get("total_tokens") if is_dict else getattr(usage, "total_tokens", None))
+        _set_span_attribute(span, SpanAttributes.LLM_USAGE_TOTAL_TOKENS, total_tokens)
+
+        input_tokens_details = (usage.get("input_tokens_details") if is_dict else getattr(usage, "input_tokens_details", None))
+        if input_tokens_details:
+            details_is_dict = isinstance(input_tokens_details, dict)
+            cached_tokens = (
+                input_tokens_details.get("cached_tokens") if details_is_dict
+                else getattr(input_tokens_details, "cached_tokens", None)
+            )
+            _set_span_attribute(
+                span,
+                GenAIAttributes.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS,
+                cached_tokens,
+            )

packages/opentelemetry-semantic-conventions-ai/opentelemetry/semconv_ai/__init__.py (1)

2-4: Fix F401: GenAIAttributes imported but unused (make it an explicit re-export).

Linters (Ruff/Flake8) flag this as unused. If the intent is to re-export GenAIAttributes from this package, annotate the import with a noqa or add it to all.

Apply this minimal diff to silence F401 while keeping the public alias:

-from opentelemetry.semconv._incubating.attributes import (
-    gen_ai_attributes as GenAIAttributes,
-)
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,  # noqa: F401 - re-exported
+)

Optionally, also define all to make the re-export explicit:

__all__ = [
    "Meters",
    "SpanAttributes",
    "Events",
    "EventAttributes",
    "LLMRequestTypeValues",
    "TraceloopSpanKindValues",
    "GenAIAttributes",
]

packages/opentelemetry-instrumentation-langchain/opentelemetry/instrumentation/langchain/span_utils.py (3)

76-79: Question: Should response model be set at request time?

You set both request and response model to the same value during request parameter extraction. If the response model can differ (provider-side routing), consider deferring setting the response model until a response is available to avoid misleading spans.

Apply this minimal change if you prefer to avoid setting response model at request time:

 _set_span_attribute(span, GenAIAttributes.GEN_AI_REQUEST_MODEL, model)
 # response is not available for LLM requests (as opposed to chat)
-_set_span_attribute(span, GenAIAttributes.GEN_AI_RESPONSE_MODEL, model)
+# Consider setting GEN_AI_RESPONSE_MODEL when a response is received.

---

97-114: Add a TODO to migrate function metadata to GenAIAttributes

We couldn’t find any GenAIAttributes constant for request/functions metadata, so continue using SpanAttributes.LLM_REQUEST_FUNCTIONS for now. To avoid mixing conventions once an equivalent lands, please:

• In packages/opentelemetry-instrumentation-langchain/opentelemetry/instrumentation/langchain/span_utils.py (at lines 97–114 and 151–161), add a TODO comment above each usage of SpanAttributes.LLM_REQUEST_FUNCTIONS noting to switch to the new GenAI attribute once it’s available.

---

343-361: Use GenAI token attributes instead of LLM ones for consistency
In packages/opentelemetry-instrumentation-langchain/opentelemetry/instrumentation/langchain/span_utils.py replace the mixed families in your histogram calls:

• At the input-tokens record
• At the output-tokens record

Example diff:

--- a/packages/opentelemetry-instrumentation-langchain/opentelemetry/instrumentation/langchain/span_utils.py
+++ b/packages/opentelemetry-instrumentation-langchain/opentelemetry/instrumentation/langchain/span_utils.py
@@ -346,7 +346,7 @@ def _record_token_usage(span: Span, model_name: str, record_token_usage: boo
-                token_histogram.record(
-                    input_tokens,
-                    attributes={
-                        GenAIAttributes.GEN_AI_SYSTEM: vendor,
-                        SpanAttributes.LLM_TOKEN_TYPE: "input",
-                        SpanAttributes.LLM_RESPONSE_MODEL: model_name,
-                    },
-                )
+                token_histogram.record(
+                    input_tokens,
+                    attributes={
+                        GenAIAttributes.GEN_AI_SYSTEM: vendor,
+                        GenAIAttributes.GEN_AI_TOKEN_TYPE: "input",
+                        GenAIAttributes.GEN_AI_RESPONSE_MODEL: model_name,
+                    },
+                )
@@ -356,7 +356,7 @@ def _record_token_usage(span: Span, model_name: str, record_token_usage: boo
-                token_histogram.record(
-                    output_tokens,
-                    attributes={
-                        GenAIAttributes.GEN_AI_SYSTEM: vendor,
-                        SpanAttributes.LLM_TOKEN_TYPE: "output",
-                        SpanAttributes.LLM_RESPONSE_MODEL: model_name,
-                    },
-                )
+                token_histogram.record(
+                    output_tokens,
+                    attributes={
+                        GenAIAttributes.GEN_AI_SYSTEM: vendor,
+                        GenAIAttributes.GEN_AI_TOKEN_TYPE: "output",
+                        GenAIAttributes.GEN_AI_RESPONSE_MODEL: model_name,
+                    },
+                )

This aligns with other instrumentation (e.g. OpenAI-agents) and avoids mixing GEN_AI_* and LLM_* families.

packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/v1/responses_wrappers.py (1)

181-187: Optional: unify total tokens key with GenAI namespace (if available)

You’re mixing GenAIAttributes.* for input/output tokens and SpanAttributes.LLM_USAGE_TOTAL_TOKENS for totals. If the incubating GenAI namespace defines a total tokens key, consider switching for consistency; otherwise keeping the stable key is fine.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

packages/opentelemetry-instrumentation-anthropic/opentelemetry/instrumentation/anthropic/__init__.py (1)

39-41: Resolved: GenAIAttributes import correctly added

This addresses the prior undefined-name (F821) issue flagged in earlier reviews. Linting/runtime should now pass for GenAIAttributes references in this module.

packages/opentelemetry-instrumentation-langchain/tests/test_tool_call_content.py (1)

122-130: Same undefined name issue applies here.

The references to GenAIAttributes in this test will also error without the import fix suggested above.

After applying the import change, please run the tests locally to ensure no remaining references to SpanAttributes exist in this file.

packages/opentelemetry-instrumentation-anthropic/tests/test_bedrock_with_raw_response.py (2)

111-115: Same fixes as above apply here.

Import GenAIAttributes and update completion/usage keys to GEN_AI_* in this test section as well.

---

162-166: Same fixes as above apply here (beta variant).

Ensure the import is present and migrate completion/usage keys to GEN_AI_*.

packages/opentelemetry-instrumentation-anthropic/opentelemetry/instrumentation/anthropic/__init__.py (1)

178-191: Avoid mutable default arguments and tighten type hints

metric_attributes defaults to {} in both paths. While not mutated here, mutable defaults are best avoided. Also, token_histogram and choice_counter are annotated as non-optional but default to None.

Proposed refactor:

• Use Optional[...] for the counters/histogram and metric_attributes.
• Normalize metric_attributes to {} inside the function.

Apply these diffs:

Async path:

 async def _aset_token_usage(
     span,
     anthropic,
     request,
     response,
-    metric_attributes: dict = {},
-    token_histogram: Histogram = None,
-    choice_counter: Counter = None,
+    metric_attributes: Optional[dict] = None,
+    token_histogram: Optional[Histogram] = None,
+    choice_counter: Optional[Counter] = None,
 ):
     import inspect
+    if metric_attributes is None:
+        metric_attributes = {}

Sync path:

 def _set_token_usage(
     span,
     anthropic,
     request,
     response,
-    metric_attributes: dict = {},
-    token_histogram: Histogram = None,
-    choice_counter: Counter = None,
+    metric_attributes: Optional[dict] = None,
+    token_histogram: Optional[Histogram] = None,
+    choice_counter: Optional[Counter] = None,
 ):
     import inspect
+    if metric_attributes is None:
+        metric_attributes = {}

Also applies to: 295-309

packages/opentelemetry-instrumentation-langchain/tests/test_tool_call_content.py (1)

151-156: LGTM after adding the missing import.

Assertions correctly validate content presence and the absence of tool_calls for assistant-only content scenarios. With the GenAIAttributes import in place, this block looks good.

Optionally, mirror the call.args pattern here for readability, as suggested earlier.

packages/opentelemetry-instrumentation-openai-agents/opentelemetry/instrumentation/openai_agents/_hooks.py (5)

340-356: Use GenAI usage token attributes (input/output/total) instead of legacy LLM_USAGE_ here.*

The PR objective is to replace prompt_tokens/completion_tokens with input_tokens/output_tokens; however, this block still writes LLM_USAGE_* attributes. Recommend migrating to GenAI usage attributes for consistency.

Apply this diff:

-                        if hasattr(usage, 'input_tokens') and usage.input_tokens is not None:
-                            otel_span.set_attribute(SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.input_tokens)
-                        elif hasattr(usage, 'prompt_tokens') and usage.prompt_tokens is not None:
-                            otel_span.set_attribute(SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.prompt_tokens)
+                        if hasattr(usage, 'input_tokens') and usage.input_tokens is not None:
+                            otel_span.set_attribute(GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage.input_tokens)
+                        elif hasattr(usage, 'prompt_tokens') and usage.prompt_tokens is not None:
+                            otel_span.set_attribute(GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage.prompt_tokens)
 
-                        if hasattr(usage, 'output_tokens') and usage.output_tokens is not None:
-                            otel_span.set_attribute(SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, usage.output_tokens)
-                        elif hasattr(usage, 'completion_tokens') and usage.completion_tokens is not None:
-                            otel_span.set_attribute(SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, usage.completion_tokens)
+                        if hasattr(usage, 'output_tokens') and usage.output_tokens is not None:
+                            otel_span.set_attribute(GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, usage.output_tokens)
+                        elif hasattr(usage, 'completion_tokens') and usage.completion_tokens is not None:
+                            otel_span.set_attribute(GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, usage.completion_tokens)
 
-                        if hasattr(usage, 'total_tokens') and usage.total_tokens is not None:
-                            otel_span.set_attribute(SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.total_tokens)
+                        if hasattr(usage, 'total_tokens') and usage.total_tokens is not None:
+                            otel_span.set_attribute(GenAIAttributes.GEN_AI_USAGE_TOTAL_TOKENS, usage.total_tokens)

Note: This requires the import suggested above:

from opentelemetry.semconv_ai import GenAIAttributes

---

443-459: Mirror the GenAI usage token migration in the legacy fallback block.

The legacy path still writes LLM_USAGE_* attributes. Align it with the GenAI usage attributes for consistency.

Apply this diff:

-                        if hasattr(usage, 'input_tokens') and usage.input_tokens is not None:
-                            otel_span.set_attribute(SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.input_tokens)
-                        elif hasattr(usage, 'prompt_tokens') and usage.prompt_tokens is not None:
-                            otel_span.set_attribute(SpanAttributes.LLM_USAGE_PROMPT_TOKENS, usage.prompt_tokens)
+                        if hasattr(usage, 'input_tokens') and usage.input_tokens is not None:
+                            otel_span.set_attribute(GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage.input_tokens)
+                        elif hasattr(usage, 'prompt_tokens') and usage.prompt_tokens is not None:
+                            otel_span.set_attribute(GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage.prompt_tokens)
 
-                        if hasattr(usage, 'output_tokens') and usage.output_tokens is not None:
-                            otel_span.set_attribute(SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, usage.output_tokens)
-                        elif hasattr(usage, 'completion_tokens') and usage.completion_tokens is not None:
-                            otel_span.set_attribute(SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, usage.completion_tokens)
+                        if hasattr(usage, 'output_tokens') and usage.output_tokens is not None:
+                            otel_span.set_attribute(GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, usage.output_tokens)
+                        elif hasattr(usage, 'completion_tokens') and usage.completion_tokens is not None:
+                            otel_span.set_attribute(GenAIAttributes.GEN_AI_USAGE_OUTPUT_TOKENS, usage.completion_tokens)
 
-                        if hasattr(usage, 'total_tokens') and usage.total_tokens is not None:
-                            otel_span.set_attribute(SpanAttributes.LLM_USAGE_TOTAL_TOKENS, usage.total_tokens)
+                        if hasattr(usage, 'total_tokens') and usage.total_tokens is not None:
+                            otel_span.set_attribute(GenAIAttributes.GEN_AI_USAGE_TOTAL_TOKENS, usage.total_tokens)

---

304-334: Migrate completion payload attributes from LLM_COMPLETIONS → GenAI completion.

You already use GEN_AI_* for tools; keep completions consistent with GenAI by switching off SpanAttributes.LLM_COMPLETIONS here.

Apply this diff:

-                                    otel_span.set_attribute(
-                                        f"{SpanAttributes.LLM_COMPLETIONS}.{i}.content", content_text)
-                                    otel_span.set_attribute(
-                                        f"{SpanAttributes.LLM_COMPLETIONS}.{i}.role", getattr(
-                                            output, 'role', 'assistant'))
+                                    otel_span.set_attribute(
+                                        f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.content", content_text)
+                                    otel_span.set_attribute(
+                                        f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.role", getattr(
+                                            output, 'role', 'assistant'))
@@
-                                otel_span.set_attribute(f"{SpanAttributes.LLM_COMPLETIONS}.{i}.role", "assistant")
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.finish_reason", "tool_calls")
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.tool_calls.0.name", tool_name)
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.tool_calls.0.arguments", arguments)
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.tool_calls.0.id", tool_call_id)
+                                otel_span.set_attribute(f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.role", "assistant")
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.finish_reason", "tool_calls")
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.tool_calls.0.name", tool_name)
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.tool_calls.0.arguments", arguments)
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.tool_calls.0.id", tool_call_id)
@@
-                                otel_span.set_attribute(f"{SpanAttributes.LLM_COMPLETIONS}.{i}.content", output.text)
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.role", getattr(
-                                        output, 'role', 'assistant'))
+                                otel_span.set_attribute(f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.content", output.text)
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.role", getattr(
+                                        output, 'role', 'assistant'))
@@
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.finish_reason", response.finish_reason)
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.finish_reason", response.finish_reason)

Note: Ensure the alias import exists:

from opentelemetry.semconv_ai import GenAIAttributes

---

409-441: Do the same GenAI completion migration in the legacy block.

Mirror the change for the second completions block to keep attributes consistent.

Apply this diff:

-                                    otel_span.set_attribute(
-                                        f"{SpanAttributes.LLM_COMPLETIONS}.{i}.content", content_text)
-                                    otel_span.set_attribute(
-                                        f"{SpanAttributes.LLM_COMPLETIONS}.{i}.role", getattr(
-                                            output, 'role', 'assistant'))
+                                    otel_span.set_attribute(
+                                        f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.content", content_text)
+                                    otel_span.set_attribute(
+                                        f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.role", getattr(
+                                            output, 'role', 'assistant'))
@@
-                                otel_span.set_attribute(f"{SpanAttributes.LLM_COMPLETIONS}.{i}.role", "assistant")
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.finish_reason", "tool_calls")
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.tool_calls.0.name", tool_name)
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.tool_calls.0.arguments", arguments)
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.tool_calls.0.id", tool_call_id)
+                                otel_span.set_attribute(f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.role", "assistant")
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.finish_reason", "tool_calls")
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.tool_calls.0.name", tool_name)
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.tool_calls.0.arguments", arguments)
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.tool_calls.0.id", tool_call_id)
@@
-                                otel_span.set_attribute(f"{SpanAttributes.LLM_COMPLETIONS}.{i}.content", output.text)
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.role", getattr(
-                                        output, 'role', 'assistant'))
+                                otel_span.set_attribute(f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.content", output.text)
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.role", getattr(
+                                        output, 'role', 'assistant'))
@@
-                                otel_span.set_attribute(
-                                    f"{SpanAttributes.LLM_COMPLETIONS}.{i}.finish_reason", response.finish_reason)
+                                otel_span.set_attribute(
+                                    f"{GenAIAttributes.GEN_AI_COMPLETION}.{i}.finish_reason", response.finish_reason)

---

10-11: Avoid private incubating module imports where possible.

You import GEN_AI_COMPLETION from a private incubating path. Prefer stable exports to reduce churn and align with the PR’s GenAIAttributes usage.

Two options:

• Switch to the alias everywhere and drop the incubating import:
  • Import: from opentelemetry.semconv_ai import GenAIAttributes
  • Replace usages of GEN_AI_COMPLETION with GenAIAttributes.GEN_AI_COMPLETION.
• Or, if you keep the constant import, ensure all GenAI keys consistently use either the alias or constants, not a mix.

Happy to provide a follow-up diff if you want to unify the file one way or the other.

packages/opentelemetry-instrumentation-openai/opentelemetry/instrumentation/openai/v1/assistant_wrappers.py (1)

206-213: LGTM with a consistency suggestion: user/system message prompts use GEN_AI_PROMPT; consider migrating completions too

For user/system messages, writing role/content under GEN_AI_PROMPT is correct. However, completion messages in this function still use the legacy LLM_COMPLETIONS prefix and a raw "gen_ai.response" string for IDs, which mixes namespaces.

Consider migrating completions to the GenAI response path for consistency, e.g.:

• Use a GEN_AI response base instead of LLM_COMPLETIONS (if available in GenAIAttributes, e.g., GenAIAttributes.GEN_AI_RESPONSE).
• Write role/content/id under f"{GenAIAttributes.GEN_AI_RESPONSE}.{completion_index}.*".

This avoids mixing old and new conventions in a single span.

packages/opentelemetry-semantic-conventions-ai/opentelemetry/semconv_ai/__init__.py (1)

2-4: Fix lint failure: imported alias is unused (F401) — explicitly re-export or silence.

Ruff/Flake8 flags GenAIAttributes as an unused import. If the intent is to re-export the incubating attributes through this module (recommended for callers), add an inline noqa or explicitly reference it.

Apply one of the following:

Option A (noqa on import):

-from opentelemetry.semconv._incubating.attributes import (
-    gen_ai_attributes as GenAIAttributes,
-)
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,  # noqa: F401  (public re-export)
+)

Option B (explicit re-export; also keeps linters happy):

 from opentelemetry.semconv._incubating.attributes import (
-    gen_ai_attributes as GenAIAttributes,
+    gen_ai_attributes as GenAIAttributes,
 )
+# Public re-export for downstreams to import from opentelemetry.semconv_ai
+GenAIAttributes  # touch symbol to satisfy F401

packages/opentelemetry-instrumentation-bedrock/opentelemetry/instrumentation/bedrock/span_utils.py (3)

116-118: Inconsistent prompt schema: use .role/.content instead of .user.

Everywhere else you use ...prompt.{i}.role and ...prompt.{i}.content. Here it writes to ...prompt.0.user, which is inconsistent and breaks consumers expecting role/content.

-def _set_prompt_span_attributes(span, request_body):
-    _set_span_attribute(
-        span, f"{GenAIAttributes.GEN_AI_PROMPT}.0.user", request_body.get("prompt")
-    )
+def _set_prompt_span_attributes(span, request_body):
+    _set_span_attribute(
+        span, f"{GenAIAttributes.GEN_AI_PROMPT}.0.content", request_body.get("prompt")
+    )
+    _set_span_attribute(span, f"{GenAIAttributes.GEN_AI_PROMPT}.0.role", "user")

---

441-444: Amazon input prompt: align with role/content (avoid .user).

Same inconsistency as above: prefer ...prompt.0.content + ...prompt.0.role = "user".

-        _set_span_attribute(
-            span,
-            f"{GenAIAttributes.GEN_AI_PROMPT}.0.user",
-            request_body.get("inputText"),
-        )
+        _set_span_attribute(
+            span,
+            f"{GenAIAttributes.GEN_AI_PROMPT}.0.content",
+            request_body.get("inputText"),
+        )
+        _set_span_attribute(span, f"{GenAIAttributes.GEN_AI_PROMPT}.0.role", "user")

---

546-558: Guard against None when summing token usage.

If either prompt_tokens or completion_tokens is None (possible in some provider responses), prompt_tokens + completion_tokens raises TypeError. Upstream callsites largely avoid this, but _set_imported_model_span_attributes can pass None.

Consider normalizing to ints (default 0) before summing:

# outside selected range; illustrative patch
pt = int(prompt_tokens or 0)
ct = int(completion_tokens or 0)
_set_span_attribute(span, SpanAttributes.LLM_USAGE_TOTAL_TOKENS, pt + ct)

Alternatively, skip the total attribute if either is missing.

packages/opentelemetry-instrumentation-langchain/opentelemetry/instrumentation/langchain/span_utils.py (1)

76-96: LGTM: migrate request model and request params to GEN_AI_ keys*

The move to GEN_AI_REQUEST_MODEL/RESPONSE_MODEL/MAX_TOKENS/TEMPERATURE/TOP_P looks correct. Minor note: if no model is found, span_holder.request_model remains None; consider defaulting it to "unknown" for consistency.

     else:
-        model = "unknown"
+        model = "unknown"
+        span_holder.request_model = model

packages/opentelemetry-instrumentation-openai/tests/traces/test_streaming_with_api_usage.py (1)

9-12: Avoid hardcoding API keys in code, even in tests

Use an env var (e.g., OPENAI_API_KEY="test-api-key") to prevent accidental leakage if the value changes in the future.

Example:

import os
return OpenAI(
    api_key=os.getenv("OPENAI_API_KEY", "test-api-key"),
    base_url="https://api.deepseek.com/beta",
)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: traceloop/openllmetry#0
File: CLAUDE.md:0-0
Timestamp: 2025-08-17T15:06:48.109Z
Learning: Semantic conventions must follow the OpenTelemetry GenAI specification