opentelemetry-instrumentation-botocore 0.49b2__tar.gz → 0.51b0__tar.gz

{opentelemetry_instrumentation_botocore-0.49b2 → opentelemetry_instrumentation_botocore-0.51b0}/PKG-INFO

@@ -1,10 +1,12 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-botocore
-Version: 0.49b2
+Version: 0.51b0
 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
 Author-email: OpenTelemetry Authors <cncf-opentelemetry-contributors@lists.cncf.io>
-License: Apache-2.0
+License-Expression: Apache-2.0
+License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -15,11 +17,12 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.8
 Requires-Dist: opentelemetry-api~=1.12
-Requires-Dist: opentelemetry-instrumentation==0.49b2
+Requires-Dist: opentelemetry-instrumentation==0.51b0
 Requires-Dist: opentelemetry-propagator-aws-xray~=1.0
-Requires-Dist: opentelemetry-semantic-conventions==0.49b2
+Requires-Dist: opentelemetry-semantic-conventions==0.51b0
 Provides-Extra: instruments
 Requires-Dist: botocore~=1.0; extra == 'instruments'
 Description-Content-Type: text/x-rst

{opentelemetry_instrumentation_botocore-0.49b2 → opentelemetry_instrumentation_botocore-0.51b0}/pyproject.toml

@@ -23,11 +23,12 @@ classifiers = [
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
   "opentelemetry-api ~= 1.12",
-  "opentelemetry-instrumentation == 0.49b2",
-  "opentelemetry-semantic-conventions == 0.49b2",
+  "opentelemetry-instrumentation == 0.51b0",
+  "opentelemetry-semantic-conventions == 0.51b0",
   "opentelemetry-propagator-aws-xray ~= 1.0",
 ]
 
@@ -41,6 +42,7 @@ botocore = "opentelemetry.instrumentation.botocore:BotocoreInstrumentor"
 
 [project.urls]
 Homepage = "https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation/opentelemetry-instrumentation-botocore"
+Repository = "https://github.com/open-telemetry/opentelemetry-python-contrib"
 
 [tool.hatch.version]
 path = "src/opentelemetry/instrumentation/botocore/version.py"

{opentelemetry_instrumentation_botocore-0.49b2 → opentelemetry_instrumentation_botocore-0.51b0}/src/opentelemetry/instrumentation/botocore/__init__.py

@@ -188,11 +188,15 @@ class BotocoreInstrumentor(BaseInstrumentor):
         }
 
         _safe_invoke(extension.extract_attributes, attributes)
+        end_span_on_exit = extension.should_end_span_on_exit()
 
         with self._tracer.start_as_current_span(
             call_context.span_name,
             kind=call_context.span_kind,
             attributes=attributes,
+            # tracing streaming services require to close the span manually
+            # at a later time after the stream has been consumed
+            end_on_exit=end_span_on_exit,
         ) as span:
             _safe_invoke(extension.before_service_call, span)
             self._call_request_hook(span, call_context)

opentelemetry_instrumentation_botocore-0.51b0/src/opentelemetry/instrumentation/botocore/environment_variables.py

@@ -0,0 +1,3 @@
+OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT = (
+    "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"
+)

{opentelemetry_instrumentation_botocore-0.49b2 → opentelemetry_instrumentation_botocore-0.51b0}/src/opentelemetry/instrumentation/botocore/extensions/__init__.py

@@ -32,6 +32,7 @@ def _lazy_load(module, cls):
 
 
 _KNOWN_EXTENSIONS = {
+    "bedrock-runtime": _lazy_load(".bedrock", "_BedrockRuntimeExtension"),
     "dynamodb": _lazy_load(".dynamodb", "_DynamoDbExtension"),
     "lambda": _lazy_load(".lmbd", "_LambdaExtension"),
     "sns": _lazy_load(".sns", "_SnsExtension"),

opentelemetry_instrumentation_botocore-0.51b0/src/opentelemetry/instrumentation/botocore/extensions/bedrock.py

@@ -0,0 +1,396 @@
+# 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.
+
+# Includes work from:
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import io
+import json
+import logging
+from typing import Any
+
+from botocore.eventstream import EventStream
+from botocore.response import StreamingBody
+
+from opentelemetry.instrumentation.botocore.extensions.bedrock_utils import (
+    ConverseStreamWrapper,
+    InvokeModelWithResponseStreamWrapper,
+)
+from opentelemetry.instrumentation.botocore.extensions.types import (
+    _AttributeMapT,
+    _AwsSdkExtension,
+    _BotoClientErrorT,
+)
+from opentelemetry.semconv._incubating.attributes.error_attributes import (
+    ERROR_TYPE,
+)
+from opentelemetry.semconv._incubating.attributes.gen_ai_attributes import (
+    GEN_AI_OPERATION_NAME,
+    GEN_AI_REQUEST_MAX_TOKENS,
+    GEN_AI_REQUEST_MODEL,
+    GEN_AI_REQUEST_STOP_SEQUENCES,
+    GEN_AI_REQUEST_TEMPERATURE,
+    GEN_AI_REQUEST_TOP_P,
+    GEN_AI_RESPONSE_FINISH_REASONS,
+    GEN_AI_SYSTEM,
+    GEN_AI_USAGE_INPUT_TOKENS,
+    GEN_AI_USAGE_OUTPUT_TOKENS,
+    GenAiOperationNameValues,
+    GenAiSystemValues,
+)
+from opentelemetry.trace.span import Span
+from opentelemetry.trace.status import Status, StatusCode
+
+_logger = logging.getLogger(__name__)
+
+_MODEL_ID_KEY: str = "modelId"
+
+
+class _BedrockRuntimeExtension(_AwsSdkExtension):
+    """
+    This class is an extension for <a
+    href="https://docs.aws.amazon.com/bedrock/latest/APIReference/API_Operations_Amazon_Bedrock_Runtime.html">
+    Amazon Bedrock Runtime</a>.
+    """
+
+    _HANDLED_OPERATIONS = {
+        "Converse",
+        "ConverseStream",
+        "InvokeModel",
+        "InvokeModelWithResponseStream",
+    }
+    _DONT_CLOSE_SPAN_ON_END_OPERATIONS = {
+        "ConverseStream",
+        "InvokeModelWithResponseStream",
+    }
+
+    def should_end_span_on_exit(self):
+        return (
+            self._call_context.operation
+            not in self._DONT_CLOSE_SPAN_ON_END_OPERATIONS
+        )
+
+    def extract_attributes(self, attributes: _AttributeMapT):
+        if self._call_context.operation not in self._HANDLED_OPERATIONS:
+            return
+
+        attributes[GEN_AI_SYSTEM] = GenAiSystemValues.AWS_BEDROCK.value
+
+        model_id = self._call_context.params.get(_MODEL_ID_KEY)
+        if model_id:
+            attributes[GEN_AI_REQUEST_MODEL] = model_id
+            attributes[GEN_AI_OPERATION_NAME] = (
+                GenAiOperationNameValues.CHAT.value
+            )
+
+            # Converse / ConverseStream
+            if inference_config := self._call_context.params.get(
+                "inferenceConfig"
+            ):
+                self._set_if_not_none(
+                    attributes,
+                    GEN_AI_REQUEST_TEMPERATURE,
+                    inference_config.get("temperature"),
+                )
+                self._set_if_not_none(
+                    attributes,
+                    GEN_AI_REQUEST_TOP_P,
+                    inference_config.get("topP"),
+                )
+                self._set_if_not_none(
+                    attributes,
+                    GEN_AI_REQUEST_MAX_TOKENS,
+                    inference_config.get("maxTokens"),
+                )
+                self._set_if_not_none(
+                    attributes,
+                    GEN_AI_REQUEST_STOP_SEQUENCES,
+                    inference_config.get("stopSequences"),
+                )
+
+            # InvokeModel
+            # Get the request body if it exists
+            body = self._call_context.params.get("body")
+            if body:
+                try:
+                    request_body = json.loads(body)
+
+                    if "amazon.titan" in model_id:
+                        # titan interface is a text completion one
+                        attributes[GEN_AI_OPERATION_NAME] = (
+                            GenAiOperationNameValues.TEXT_COMPLETION.value
+                        )
+                        self._extract_titan_attributes(
+                            attributes, request_body
+                        )
+                    elif "amazon.nova" in model_id:
+                        self._extract_nova_attributes(attributes, request_body)
+                    elif "anthropic.claude" in model_id:
+                        self._extract_claude_attributes(
+                            attributes, request_body
+                        )
+                except json.JSONDecodeError:
+                    _logger.debug("Error: Unable to parse the body as JSON")
+
+    def _extract_titan_attributes(self, attributes, request_body):
+        config = request_body.get("textGenerationConfig", {})
+        self._set_if_not_none(
+            attributes, GEN_AI_REQUEST_TEMPERATURE, config.get("temperature")
+        )
+        self._set_if_not_none(
+            attributes, GEN_AI_REQUEST_TOP_P, config.get("topP")
+        )
+        self._set_if_not_none(
+            attributes, GEN_AI_REQUEST_MAX_TOKENS, config.get("maxTokenCount")
+        )
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_STOP_SEQUENCES,
+            config.get("stopSequences"),
+        )
+
+    def _extract_nova_attributes(self, attributes, request_body):
+        config = request_body.get("inferenceConfig", {})
+        self._set_if_not_none(
+            attributes, GEN_AI_REQUEST_TEMPERATURE, config.get("temperature")
+        )
+        self._set_if_not_none(
+            attributes, GEN_AI_REQUEST_TOP_P, config.get("topP")
+        )
+        self._set_if_not_none(
+            attributes, GEN_AI_REQUEST_MAX_TOKENS, config.get("max_new_tokens")
+        )
+        self._set_if_not_none(
+            attributes,
+            GEN_AI_REQUEST_STOP_SEQUENCES,
+            config.get("stopSequences"),
+        )
+
+    def _extract_claude_attributes(self, attributes, request_body):
+        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_sequences"),
+        )
+
+    @staticmethod
+    def _set_if_not_none(attributes, key, value):
+        if value is not None:
+            attributes[key] = value
+
+    def before_service_call(self, span: Span):
+        if self._call_context.operation not in self._HANDLED_OPERATIONS:
+            return
+
+        if not span.is_recording():
+            return
+
+        operation_name = span.attributes.get(GEN_AI_OPERATION_NAME, "")
+        request_model = span.attributes.get(GEN_AI_REQUEST_MODEL, "")
+        # avoid setting to an empty string if are not available
+        if operation_name and request_model:
+            span.update_name(f"{operation_name} {request_model}")
+
+    # pylint: disable=no-self-use
+    def _converse_on_success(self, span: Span, result: dict[str, Any]):
+        if usage := result.get("usage"):
+            if input_tokens := usage.get("inputTokens"):
+                span.set_attribute(
+                    GEN_AI_USAGE_INPUT_TOKENS,
+                    input_tokens,
+                )
+            if output_tokens := usage.get("outputTokens"):
+                span.set_attribute(
+                    GEN_AI_USAGE_OUTPUT_TOKENS,
+                    output_tokens,
+                )
+
+        if stop_reason := result.get("stopReason"):
+            span.set_attribute(
+                GEN_AI_RESPONSE_FINISH_REASONS,
+                [stop_reason],
+            )
+
+    def _invoke_model_on_success(
+        self, span: Span, result: dict[str, Any], model_id: str
+    ):
+        original_body = None
+        try:
+            original_body = result["body"]
+            body_content = original_body.read()
+
+            # Replenish stream for downstream application use
+            new_stream = io.BytesIO(body_content)
+            result["body"] = StreamingBody(new_stream, len(body_content))
+
+            response_body = json.loads(body_content.decode("utf-8"))
+            if "amazon.titan" in model_id:
+                self._handle_amazon_titan_response(span, response_body)
+            elif "amazon.nova" in model_id:
+                self._handle_amazon_nova_response(span, response_body)
+            elif "anthropic.claude" in model_id:
+                self._handle_anthropic_claude_response(span, response_body)
+
+        except json.JSONDecodeError:
+            _logger.debug("Error: Unable to parse the response body as JSON")
+        except Exception as exc:  # pylint: disable=broad-exception-caught
+            _logger.debug("Error processing response: %s", exc)
+        finally:
+            if original_body is not None:
+                original_body.close()
+
+    def _on_stream_error_callback(self, span: Span, exception):
+        span.set_status(Status(StatusCode.ERROR, str(exception)))
+        if span.is_recording():
+            span.set_attribute(ERROR_TYPE, type(exception).__qualname__)
+        span.end()
+
+    def on_success(self, span: Span, result: dict[str, Any]):
+        if self._call_context.operation not in self._HANDLED_OPERATIONS:
+            return
+
+        if not span.is_recording():
+            if not self.should_end_span_on_exit():
+                span.end()
+            return
+
+        # ConverseStream
+        if "stream" in result and isinstance(result["stream"], EventStream):
+
+            def stream_done_callback(response):
+                self._converse_on_success(span, response)
+                span.end()
+
+            def stream_error_callback(exception):
+                self._on_stream_error_callback(span, exception)
+
+            result["stream"] = ConverseStreamWrapper(
+                result["stream"], stream_done_callback, stream_error_callback
+            )
+            return
+
+        # Converse
+        self._converse_on_success(span, result)
+
+        model_id = self._call_context.params.get(_MODEL_ID_KEY)
+        if not model_id:
+            return
+
+        # InvokeModel
+        if "body" in result and isinstance(result["body"], StreamingBody):
+            self._invoke_model_on_success(span, result, model_id)
+            return
+
+        # InvokeModelWithResponseStream
+        if "body" in result and isinstance(result["body"], EventStream):
+
+            def invoke_model_stream_done_callback(response):
+                # the callback gets data formatted as the simpler converse API
+                self._converse_on_success(span, response)
+                span.end()
+
+            def invoke_model_stream_error_callback(exception):
+                self._on_stream_error_callback(span, exception)
+
+            result["body"] = InvokeModelWithResponseStreamWrapper(
+                result["body"],
+                invoke_model_stream_done_callback,
+                invoke_model_stream_error_callback,
+                model_id,
+            )
+            return
+
+    # pylint: disable=no-self-use
+    def _handle_amazon_titan_response(
+        self, span: Span, response_body: dict[str, Any]
+    ):
+        if "inputTextTokenCount" in response_body:
+            span.set_attribute(
+                GEN_AI_USAGE_INPUT_TOKENS, response_body["inputTextTokenCount"]
+            )
+            if "results" in response_body and response_body["results"]:
+                result = response_body["results"][0]
+                if "tokenCount" in result:
+                    span.set_attribute(
+                        GEN_AI_USAGE_OUTPUT_TOKENS, result["tokenCount"]
+                    )
+                if "completionReason" in result:
+                    span.set_attribute(
+                        GEN_AI_RESPONSE_FINISH_REASONS,
+                        [result["completionReason"]],
+                    )
+
+    # pylint: disable=no-self-use
+    def _handle_amazon_nova_response(
+        self, span: Span, response_body: dict[str, Any]
+    ):
+        if "usage" in response_body:
+            usage = response_body["usage"]
+            if "inputTokens" in usage:
+                span.set_attribute(
+                    GEN_AI_USAGE_INPUT_TOKENS, usage["inputTokens"]
+                )
+            if "outputTokens" in usage:
+                span.set_attribute(
+                    GEN_AI_USAGE_OUTPUT_TOKENS, usage["outputTokens"]
+                )
+        if "stopReason" in response_body:
+            span.set_attribute(
+                GEN_AI_RESPONSE_FINISH_REASONS, [response_body["stopReason"]]
+            )
+
+    # pylint: disable=no-self-use
+    def _handle_anthropic_claude_response(
+        self, span: Span, response_body: dict[str, Any]
+    ):
+        if usage := response_body.get("usage"):
+            if "input_tokens" in usage:
+                span.set_attribute(
+                    GEN_AI_USAGE_INPUT_TOKENS, usage["input_tokens"]
+                )
+            if "output_tokens" in usage:
+                span.set_attribute(
+                    GEN_AI_USAGE_OUTPUT_TOKENS, usage["output_tokens"]
+                )
+        if "stop_reason" in response_body:
+            span.set_attribute(
+                GEN_AI_RESPONSE_FINISH_REASONS, [response_body["stop_reason"]]
+            )
+
+    def on_error(self, span: Span, exception: _BotoClientErrorT):
+        if self._call_context.operation not in self._HANDLED_OPERATIONS:
+            return
+
+        span.set_status(Status(StatusCode.ERROR, str(exception)))
+        if span.is_recording():
+            span.set_attribute(ERROR_TYPE, type(exception).__qualname__)
+
+        if not self.should_end_span_on_exit():
+            span.end()