opentelemetry-instrumentation-botocore 0.53b1__py3-none-any.whl → 0.54b1__py3-none-any.whl

opentelemetry/instrumentation/botocore/__init__.py

@@ -99,6 +99,7 @@ from opentelemetry.instrumentation.botocore.extensions.types import (
     _BotocoreInstrumentorContext,
 )
 from opentelemetry.instrumentation.botocore.package import _instruments
+from opentelemetry.instrumentation.botocore.utils import get_server_attributes
 from opentelemetry.instrumentation.botocore.version import __version__
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import (
@@ -277,6 +278,7 @@ class BotocoreInstrumentor(BaseInstrumentor):
             SpanAttributes.RPC_METHOD: call_context.operation,
             # TODO: update when semantic conventions exist
             "aws.region": call_context.region,
+            **get_server_attributes(call_context.endpoint_url),
         }
 
         _safe_invoke(extension.extract_attributes, attributes)

opentelemetry/instrumentation/botocore/extensions/bedrock.py

@@ -15,6 +15,7 @@
 # Includes work from:
 # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 # SPDX-License-Identifier: Apache-2.0
+# pylint: disable=too-many-lines
 
 from __future__ import annotations
 
@@ -31,6 +32,7 @@ from opentelemetry.instrumentation.botocore.extensions.bedrock_utils import (
     ConverseStreamWrapper,
     InvokeModelWithResponseStreamWrapper,
     _Choice,
+    estimate_token_count,
     genai_capture_message_content,
     message_to_event,
 )
@@ -40,6 +42,7 @@ from opentelemetry.instrumentation.botocore.extensions.types import (
     _BotoClientErrorT,
     _BotocoreInstrumentorContext,
 )
+from opentelemetry.instrumentation.botocore.utils import get_server_attributes
 from opentelemetry.metrics import Instrument, Meter
 from opentelemetry.semconv._incubating.attributes.error_attributes import (
     ERROR_TYPE,
@@ -145,7 +148,10 @@ class _BedrockRuntimeExtension(_AwsSdkExtension):
         )
 
     def _extract_metrics_attributes(self) -> _AttributeMapT:
-        attributes = {GEN_AI_SYSTEM: GenAiSystemValues.AWS_BEDROCK.value}
+        attributes = {
+            GEN_AI_SYSTEM: GenAiSystemValues.AWS_BEDROCK.value,
+            **get_server_attributes(self._call_context.endpoint_url),
+        }
 
         model_id = self._call_context.params.get(_MODEL_ID_KEY)
         if not model_id:
@@ -162,6 +168,7 @@ class _BedrockRuntimeExtension(_AwsSdkExtension):
             attributes[GEN_AI_OPERATION_NAME] = (
                 GenAiOperationNameValues.CHAT.value
             )
+
         return attributes
 
     def extract_attributes(self, attributes: _AttributeMapT):
@@ -223,6 +230,23 @@ class _BedrockRuntimeExtension(_AwsSdkExtension):
                         self._extract_claude_attributes(
                             attributes, request_body
                         )
+                    elif "cohere.command-r" in model_id:
+                        self._extract_command_r_attributes(
+                            attributes, request_body
+                        )
+                    elif "cohere.command" in model_id:
+                        self._extract_command_attributes(
+                            attributes, request_body
+                        )
+                    elif "meta.llama" in model_id:
+                        self._extract_llama_attributes(
+                            attributes, request_body
+                        )
+                    elif "mistral" in model_id:
+                        self._extract_mistral_attributes(
+                            attributes, request_body
+                        )
+
                 except json.JSONDecodeError:
                     _logger.debug("Error: Unable to parse the body as JSON")
 
@@ -280,6 +304,95 @@ class _BedrockRuntimeExtension(_AwsSdkExtension):
             request_body.get("stop_sequences"),
         )
 
+    def _extract_command_r_attributes(self, attributes, request_body):
+        prompt = request_body.get("message")
+        self._set_if_not_none(
+            attributes, GEN_AI_USAGE_INPUT_TOKENS, estimate_token_count(prompt)
+        )
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_MAX_TOKENS,
+            request_body.get("max_tokens"),
+        )
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_TEMPERATURE,
+            request_body.get("temperature"),
+        )
+        self._set_if_not_none(
+            attributes, GEN_AI_REQUEST_TOP_P, request_body.get("p")
+        )
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_STOP_SEQUENCES,
+            request_body.get("stop_sequences"),
+        )
+
+    def _extract_command_attributes(self, attributes, request_body):
+        prompt = request_body.get("prompt")
+        self._set_if_not_none(
+            attributes, GEN_AI_USAGE_INPUT_TOKENS, estimate_token_count(prompt)
+        )
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_MAX_TOKENS,
+            request_body.get("max_tokens"),
+        )
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_TEMPERATURE,
+            request_body.get("temperature"),
+        )
+        self._set_if_not_none(
+            attributes, GEN_AI_REQUEST_TOP_P, request_body.get("p")
+        )
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_STOP_SEQUENCES,
+            request_body.get("stop_sequences"),
+        )
+
+    def _extract_llama_attributes(self, attributes, request_body):
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_MAX_TOKENS,
+            request_body.get("max_gen_len"),
+        )
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_TEMPERATURE,
+            request_body.get("temperature"),
+        )
+        self._set_if_not_none(
+            attributes, GEN_AI_REQUEST_TOP_P, request_body.get("top_p")
+        )
+        # request for meta llama models does not contain stop_sequences field
+
+    def _extract_mistral_attributes(self, attributes, request_body):
+        prompt = request_body.get("prompt")
+        if prompt:
+            self._set_if_not_none(
+                attributes,
+                GEN_AI_USAGE_INPUT_TOKENS,
+                estimate_token_count(prompt),
+            )
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_MAX_TOKENS,
+            request_body.get("max_tokens"),
+        )
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_TEMPERATURE,
+            request_body.get("temperature"),
+        )
+        self._set_if_not_none(
+            attributes, GEN_AI_REQUEST_TOP_P, request_body.get("top_p")
+        )
+        self._set_if_not_none(
+            attributes, GEN_AI_REQUEST_STOP_SEQUENCES, request_body.get("stop")
+        )
+
     @staticmethod
     def _set_if_not_none(attributes, key, value):
         if value is not None:
@@ -287,7 +400,6 @@ class _BedrockRuntimeExtension(_AwsSdkExtension):
 
     def _get_request_messages(self):
         """Extracts and normalize system and user / assistant messages"""
-        input_text = None
         if system := self._call_context.params.get("system", []):
             system_messages = [{"role": "system", "content": system}]
         else:
@@ -304,15 +416,37 @@ class _BedrockRuntimeExtension(_AwsSdkExtension):
                     system_messages = [{"role": "system", "content": content}]
 
                 messages = decoded_body.get("messages", [])
+                # if no messages interface, convert to messages format from generic API
                 if not messages:
-                    # transform old school amazon titan invokeModel api to messages
-                    if input_text := decoded_body.get("inputText"):
-                        messages = [
-                            {"role": "user", "content": [{"text": input_text}]}
-                        ]
+                    model_id = self._call_context.params.get(_MODEL_ID_KEY)
+                    if "amazon.titan" in model_id:
+                        messages = self._get_messages_from_input_text(
+                            decoded_body, "inputText"
+                        )
+                    elif "cohere.command-r" in model_id:
+                        # chat_history can be converted to messages; for now, just use message
+                        messages = self._get_messages_from_input_text(
+                            decoded_body, "message"
+                        )
+                    elif (
+                        "cohere.command" in model_id
+                        or "meta.llama" in model_id
+                        or "mistral.mistral" in model_id
+                    ):
+                        messages = self._get_messages_from_input_text(
+                            decoded_body, "prompt"
+                        )
 
         return system_messages + messages
 
+    # pylint: disable=no-self-use
+    def _get_messages_from_input_text(
+        self, decoded_body: dict[str, Any], input_name: str
+    ):
+        if input_text := decoded_body.get(input_name):
+            return [{"role": "user", "content": [{"text": input_text}]}]
+        return []
+
     def before_service_call(
         self, span: Span, instrumentor_context: _BotocoreInstrumentorContext
     ):
@@ -439,6 +573,22 @@ class _BedrockRuntimeExtension(_AwsSdkExtension):
                 self._handle_anthropic_claude_response(
                     span, response_body, instrumentor_context, capture_content
                 )
+            elif "cohere.command-r" in model_id:
+                self._handle_cohere_command_r_response(
+                    span, response_body, instrumentor_context, capture_content
+                )
+            elif "cohere.command" in model_id:
+                self._handle_cohere_command_response(
+                    span, response_body, instrumentor_context, capture_content
+                )
+            elif "meta.llama" in model_id:
+                self._handle_meta_llama_response(
+                    span, response_body, instrumentor_context, capture_content
+                )
+            elif "mistral" in model_id:
+                self._handle_mistral_ai_response(
+                    span, response_body, instrumentor_context, capture_content
+                )
         except json.JSONDecodeError:
             _logger.debug("Error: Unable to parse the response body as JSON")
         except Exception as exc:  # pylint: disable=broad-exception-caught
@@ -725,6 +875,106 @@ class _BedrockRuntimeExtension(_AwsSdkExtension):
                         output_tokens, output_attributes
                     )
 
+    def _handle_cohere_command_r_response(
+        self,
+        span: Span,
+        response_body: dict[str, Any],
+        instrumentor_context: _BotocoreInstrumentorContext,
+        capture_content: bool,
+    ):
+        if "text" in response_body:
+            span.set_attribute(
+                GEN_AI_USAGE_OUTPUT_TOKENS,
+                estimate_token_count(response_body["text"]),
+            )
+        if "finish_reason" in response_body:
+            span.set_attribute(
+                GEN_AI_RESPONSE_FINISH_REASONS,
+                [response_body["finish_reason"]],
+            )
+
+        event_logger = instrumentor_context.event_logger
+        choice = _Choice.from_invoke_cohere_command_r(
+            response_body, capture_content
+        )
+        event_logger.emit(choice.to_choice_event())
+
+    def _handle_cohere_command_response(
+        self,
+        span: Span,
+        response_body: dict[str, Any],
+        instrumentor_context: _BotocoreInstrumentorContext,
+        capture_content: bool,
+    ):
+        if "generations" in response_body and response_body["generations"]:
+            generations = response_body["generations"][0]
+            if "text" in generations:
+                span.set_attribute(
+                    GEN_AI_USAGE_OUTPUT_TOKENS,
+                    estimate_token_count(generations["text"]),
+                )
+            if "finish_reason" in generations:
+                span.set_attribute(
+                    GEN_AI_RESPONSE_FINISH_REASONS,
+                    [generations["finish_reason"]],
+                )
+
+        event_logger = instrumentor_context.event_logger
+        choice = _Choice.from_invoke_cohere_command(
+            response_body, capture_content
+        )
+        event_logger.emit(choice.to_choice_event())
+
+    def _handle_meta_llama_response(
+        self,
+        span: Span,
+        response_body: dict[str, Any],
+        instrumentor_context: _BotocoreInstrumentorContext,
+        capture_content: bool,
+    ):
+        if "prompt_token_count" in response_body:
+            span.set_attribute(
+                GEN_AI_USAGE_INPUT_TOKENS, response_body["prompt_token_count"]
+            )
+        if "generation_token_count" in response_body:
+            span.set_attribute(
+                GEN_AI_USAGE_OUTPUT_TOKENS,
+                response_body["generation_token_count"],
+            )
+        if "stop_reason" in response_body:
+            span.set_attribute(
+                GEN_AI_RESPONSE_FINISH_REASONS, [response_body["stop_reason"]]
+            )
+
+        event_logger = instrumentor_context.event_logger
+        choice = _Choice.from_invoke_meta_llama(response_body, capture_content)
+        event_logger.emit(choice.to_choice_event())
+
+    def _handle_mistral_ai_response(
+        self,
+        span: Span,
+        response_body: dict[str, Any],
+        instrumentor_context: _BotocoreInstrumentorContext,
+        capture_content: bool,
+    ):
+        if "outputs" in response_body:
+            outputs = response_body["outputs"][0]
+            if "text" in outputs:
+                span.set_attribute(
+                    GEN_AI_USAGE_OUTPUT_TOKENS,
+                    estimate_token_count(outputs["text"]),
+                )
+            if "stop_reason" in outputs:
+                span.set_attribute(
+                    GEN_AI_RESPONSE_FINISH_REASONS, [outputs["stop_reason"]]
+                )
+
+        event_logger = instrumentor_context.event_logger
+        choice = _Choice.from_invoke_mistral_mistral(
+            response_body, capture_content
+        )
+        event_logger.emit(choice.to_choice_event())
+
     def on_error(
         self,
         span: Span,

opentelemetry/instrumentation/botocore/extensions/bedrock_utils.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import json
+import math
 from os import environ
 from typing import Any, Callable, Dict, Iterator, Sequence, Union
 
@@ -358,6 +359,12 @@ class InvokeModelWithResponseStreamWrapper(ObjectProxy):
             return
 
 
+def estimate_token_count(message: str) -> int:
+    # https://docs.aws.amazon.com/bedrock/latest/userguide/model-customization-prepare.html
+    # use 6 chars per token to approximate token count when not provided in response body
+    return math.ceil(len(message) / 6)
+
+
 def genai_capture_message_content() -> bool:
     capture_content = environ.get(
         OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT, "false"
@@ -519,6 +526,48 @@ class _Choice:
             message["content"] = response["content"]
         return cls(message, response["stop_reason"], index=0)
 
+    @classmethod
+    def from_invoke_cohere_command_r(
+        cls, response: dict[str, Any], capture_content: bool
+    ) -> _Choice:
+        if capture_content:
+            message = {"content": response["text"]}
+        else:
+            message = {}
+        return cls(message, response["finish_reason"], index=0)
+
+    @classmethod
+    def from_invoke_cohere_command(
+        cls, response: dict[str, Any], capture_content: bool
+    ) -> _Choice:
+        result = response["generations"][0]
+        if capture_content:
+            message = {"content": result["text"]}
+        else:
+            message = {}
+        return cls(message, result["finish_reason"], index=0)
+
+    @classmethod
+    def from_invoke_meta_llama(
+        cls, response: dict[str, Any], capture_content: bool
+    ) -> _Choice:
+        if capture_content:
+            message = {"content": response["generation"]}
+        else:
+            message = {}
+        return cls(message, response["stop_reason"], index=0)
+
+    @classmethod
+    def from_invoke_mistral_mistral(
+        cls, response: dict[str, Any], capture_content: bool
+    ) -> _Choice:
+        result = response["outputs"][0]
+        if capture_content:
+            message = {"content": result["text"]}
+        else:
+            message = {}
+        return cls(message, result["stop_reason"], index=0)
+
     def _to_body_dict(self) -> dict[str, Any]:
         return {
             "finish_reason": self.finish_reason,

opentelemetry/instrumentation/botocore/utils.py

@@ -0,0 +1,31 @@
+# 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.
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+from opentelemetry.semconv._incubating.attributes import (
+    server_attributes as ServerAttributes,
+)
+from opentelemetry.util.types import AttributeValue
+
+
+def get_server_attributes(endpoint_url: str) -> dict[str, AttributeValue]:
+    """Extract server.* attributes from AWS endpoint URL."""
+    parsed = urlparse(endpoint_url)
+    attributes = {}
+    if parsed.hostname:
+        attributes[ServerAttributes.SERVER_ADDRESS] = parsed.hostname
+        attributes[ServerAttributes.SERVER_PORT] = parsed.port or 443
+    return attributes

opentelemetry/instrumentation/botocore/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.53b1"
+__version__ = "0.54b1"

{opentelemetry_instrumentation_botocore-0.53b1.dist-info → opentelemetry_instrumentation_botocore-0.54b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-botocore
-Version: 0.53b1
+Version: 0.54b1
 Summary: OpenTelemetry Botocore instrumentation
 Project-URL: Homepage, https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation/opentelemetry-instrumentation-botocore
 Project-URL: Repository, https://github.com/open-telemetry/opentelemetry-python-contrib
@@ -20,9 +20,9 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.8
 Requires-Dist: opentelemetry-api~=1.30
-Requires-Dist: opentelemetry-instrumentation==0.53b1
+Requires-Dist: opentelemetry-instrumentation==0.54b1
 Requires-Dist: opentelemetry-propagator-aws-xray~=1.0
-Requires-Dist: opentelemetry-semantic-conventions==0.53b1
+Requires-Dist: opentelemetry-semantic-conventions==0.54b1
 Provides-Extra: instruments
 Requires-Dist: botocore~=1.0; extra == 'instruments'
 Description-Content-Type: text/x-rst

{opentelemetry_instrumentation_botocore-0.53b1.dist-info → opentelemetry_instrumentation_botocore-0.54b1.dist-info}/RECORD

@@ -1,18 +1,19 @@
-opentelemetry/instrumentation/botocore/__init__.py,sha256=vqJdCimwcLKwvGfXvsT-UW4PD5R0MLb4xPAB1Xdk_Lo,14565
+opentelemetry/instrumentation/botocore/__init__.py,sha256=O2RNAc7SGEWSaBnniTfedrIsNDER01h4VRPJgxxIG_8,14708
 opentelemetry/instrumentation/botocore/environment_variables.py,sha256=c1lrIEj5wwxZwLd5ppJsfGADBfQLnb_HuxXDLv7ul6s,114
 opentelemetry/instrumentation/botocore/package.py,sha256=6xvfRpU_C3wlSO6pto7MhGtkPoCHDEiRO_Fh4DiC_50,622
-opentelemetry/instrumentation/botocore/version.py,sha256=uYW9AHe_CTRZoi-ExYtUTquCExW6ZiH18ELKvuFwO1I,608
+opentelemetry/instrumentation/botocore/utils.py,sha256=dM5LW5PjIdErBFESyxh6b8oBvbmQ7dPyYOn1YLOUFaQ,1191
+opentelemetry/instrumentation/botocore/version.py,sha256=LAnaEWDOviU2kJ-Xmrhq1biqtDukCylZDisfX_ER5Ng,608
 opentelemetry/instrumentation/botocore/extensions/__init__.py,sha256=IqMWsCI0HL8gvL8-0Svn9Rp7dz2HKMcIuhRRM0twmCU,1857
 opentelemetry/instrumentation/botocore/extensions/_messaging.py,sha256=ca2Uwyb1vxWu5qUkKTlfn9KJFN6k8HOTrrBYvwX4WzA,1636
-opentelemetry/instrumentation/botocore/extensions/bedrock.py,sha256=fF_SdRGZzTyGDprlffh84bMVQhq3AZMcMAZAUTj1SDA,27814
-opentelemetry/instrumentation/botocore/extensions/bedrock_utils.py,sha256=vR_INPz0UeT_ShajwZdLbXcys6mOmXSHwOxP3gR139I,20555
+opentelemetry/instrumentation/botocore/extensions/bedrock.py,sha256=Z0emYAoeP9RzuddnqWr8I-xzI3LAKp0eGc7-WSMKZmo,37169
+opentelemetry/instrumentation/botocore/extensions/bedrock_utils.py,sha256=KyiL_RpU4c-gyXojJcMgXe2IK5DYVY17cyx3iZrI8UI,22178
 opentelemetry/instrumentation/botocore/extensions/dynamodb.py,sha256=cmTzHnLCO731v8L5wN-rPRyVgQHmRvH3tuG5wrFhqyA,13745
 opentelemetry/instrumentation/botocore/extensions/lmbd.py,sha256=mqPbgwDFy3XYg-pLo6A6eNu0iKSGa2-tPLwroJDuavY,4253
 opentelemetry/instrumentation/botocore/extensions/sns.py,sha256=MfppfL91tAbAjp6CIiqvYIuXQRq-PeIYbB1ZKWO5kW4,5334
 opentelemetry/instrumentation/botocore/extensions/sqs.py,sha256=9_LjlzQ0Sg92hgaL8P31cbpq_C71qCTucjj0SX1Ct5o,2916
 opentelemetry/instrumentation/botocore/extensions/types.py,sha256=jCIJXt0Zvdn2qVwX6bLUaCLgBPy6XyJ-nYEwurxAZo8,6681
-opentelemetry_instrumentation_botocore-0.53b1.dist-info/METADATA,sha256=_MVAZ_TUsHjY7hcIWfUqvJkXslqgp0Xpq0aDNZUorkg,3101
-opentelemetry_instrumentation_botocore-0.53b1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-opentelemetry_instrumentation_botocore-0.53b1.dist-info/entry_points.txt,sha256=v5hzQbZMJ61JuhBNq5jHYAapvv3C_486h9CTqxlkUTM,100
-opentelemetry_instrumentation_botocore-0.53b1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-opentelemetry_instrumentation_botocore-0.53b1.dist-info/RECORD,,
+opentelemetry_instrumentation_botocore-0.54b1.dist-info/METADATA,sha256=S5XHFnHRY2tMF3FfFkyY86c_krOw0ewBnDQwQi4rnxw,3101
+opentelemetry_instrumentation_botocore-0.54b1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+opentelemetry_instrumentation_botocore-0.54b1.dist-info/entry_points.txt,sha256=v5hzQbZMJ61JuhBNq5jHYAapvv3C_486h9CTqxlkUTM,100
+opentelemetry_instrumentation_botocore-0.54b1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+opentelemetry_instrumentation_botocore-0.54b1.dist-info/RECORD,,