opentelemetry-instrumentation-botocore 0.49b2__py3-none-any.whl → 0.51b0__py3-none-any.whl

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/environment_variables.py

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

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/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()

opentelemetry/instrumentation/botocore/extensions/bedrock_utils.py

@@ -0,0 +1,222 @@
+# 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
+
+import json
+from typing import Callable, Dict, Union
+
+from botocore.eventstream import EventStream, EventStreamError
+from wrapt import ObjectProxy
+
+_StreamDoneCallableT = Callable[[Dict[str, Union[int, str]]], None]
+_StreamErrorCallableT = Callable[[Exception], None]
+
+
+# pylint: disable=abstract-method
+class ConverseStreamWrapper(ObjectProxy):
+    """Wrapper for botocore.eventstream.EventStream"""
+
+    def __init__(
+        self,
+        stream: EventStream,
+        stream_done_callback: _StreamDoneCallableT,
+        stream_error_callback: _StreamErrorCallableT,
+    ):
+        super().__init__(stream)
+
+        self._stream_done_callback = stream_done_callback
+        self._stream_error_callback = stream_error_callback
+        # accumulating things in the same shape of non-streaming version
+        # {"usage": {"inputTokens": 0, "outputTokens": 0}, "stopReason": "finish"}
+        self._response = {}
+
+    def __iter__(self):
+        try:
+            for event in self.__wrapped__:
+                self._process_event(event)
+                yield event
+        except EventStreamError as exc:
+            self._stream_error_callback(exc)
+            raise
+
+    def _process_event(self, event):
+        if "messageStart" in event:
+            # {'messageStart': {'role': 'assistant'}}
+            return
+
+        if "contentBlockDelta" in event:
+            # {'contentBlockDelta': {'delta': {'text': "Hello"}, 'contentBlockIndex': 0}}
+            return
+
+        if "contentBlockStop" in event:
+            # {'contentBlockStop': {'contentBlockIndex': 0}}
+            return
+
+        if "messageStop" in event:
+            # {'messageStop': {'stopReason': 'end_turn'}}
+            if stop_reason := event["messageStop"].get("stopReason"):
+                self._response["stopReason"] = stop_reason
+            return
+
+        if "metadata" in event:
+            # {'metadata': {'usage': {'inputTokens': 12, 'outputTokens': 15, 'totalTokens': 27}, 'metrics': {'latencyMs': 2980}}}
+            if usage := event["metadata"].get("usage"):
+                self._response["usage"] = {}
+                if input_tokens := usage.get("inputTokens"):
+                    self._response["usage"]["inputTokens"] = input_tokens
+
+                if output_tokens := usage.get("outputTokens"):
+                    self._response["usage"]["outputTokens"] = output_tokens
+
+            self._stream_done_callback(self._response)
+            return
+
+
+# pylint: disable=abstract-method
+class InvokeModelWithResponseStreamWrapper(ObjectProxy):
+    """Wrapper for botocore.eventstream.EventStream"""
+
+    def __init__(
+        self,
+        stream: EventStream,
+        stream_done_callback: _StreamDoneCallableT,
+        stream_error_callback: _StreamErrorCallableT,
+        model_id: str,
+    ):
+        super().__init__(stream)
+
+        self._stream_done_callback = stream_done_callback
+        self._stream_error_callback = stream_error_callback
+        self._model_id = model_id
+
+        # accumulating things in the same shape of the Converse API
+        # {"usage": {"inputTokens": 0, "outputTokens": 0}, "stopReason": "finish"}
+        self._response = {}
+
+    def __iter__(self):
+        try:
+            for event in self.__wrapped__:
+                self._process_event(event)
+                yield event
+        except EventStreamError as exc:
+            self._stream_error_callback(exc)
+            raise
+
+    def _process_event(self, event):
+        if "chunk" not in event:
+            return
+
+        json_bytes = event["chunk"].get("bytes", b"")
+        decoded = json_bytes.decode("utf-8")
+        try:
+            chunk = json.loads(decoded)
+        except json.JSONDecodeError:
+            return
+
+        if "amazon.titan" in self._model_id:
+            self._process_amazon_titan_chunk(chunk)
+        elif "amazon.nova" in self._model_id:
+            self._process_amazon_nova_chunk(chunk)
+        elif "anthropic.claude" in self._model_id:
+            self._process_anthropic_claude_chunk(chunk)
+
+    def _process_invocation_metrics(self, invocation_metrics):
+        self._response["usage"] = {}
+        if input_tokens := invocation_metrics.get("inputTokenCount"):
+            self._response["usage"]["inputTokens"] = input_tokens
+
+        if output_tokens := invocation_metrics.get("outputTokenCount"):
+            self._response["usage"]["outputTokens"] = output_tokens
+
+    def _process_amazon_titan_chunk(self, chunk):
+        if (stop_reason := chunk.get("completionReason")) is not None:
+            self._response["stopReason"] = stop_reason
+
+        if invocation_metrics := chunk.get("amazon-bedrock-invocationMetrics"):
+            # "amazon-bedrock-invocationMetrics":{
+            #     "inputTokenCount":9,"outputTokenCount":128,"invocationLatency":3569,"firstByteLatency":2180
+            # }
+            self._process_invocation_metrics(invocation_metrics)
+            self._stream_done_callback(self._response)
+
+    def _process_amazon_nova_chunk(self, chunk):
+        if "messageStart" in chunk:
+            # {'messageStart': {'role': 'assistant'}}
+            return
+
+        if "contentBlockDelta" in chunk:
+            # {'contentBlockDelta': {'delta': {'text': "Hello"}, 'contentBlockIndex': 0}}
+            return
+
+        if "contentBlockStop" in chunk:
+            # {'contentBlockStop': {'contentBlockIndex': 0}}
+            return
+
+        if "messageStop" in chunk:
+            # {'messageStop': {'stopReason': 'end_turn'}}
+            if stop_reason := chunk["messageStop"].get("stopReason"):
+                self._response["stopReason"] = stop_reason
+            return
+
+        if "metadata" in chunk:
+            # {'metadata': {'usage': {'inputTokens': 8, 'outputTokens': 117}, 'metrics': {}, 'trace': {}}}
+            if usage := chunk["metadata"].get("usage"):
+                self._response["usage"] = {}
+                if input_tokens := usage.get("inputTokens"):
+                    self._response["usage"]["inputTokens"] = input_tokens
+
+                if output_tokens := usage.get("outputTokens"):
+                    self._response["usage"]["outputTokens"] = output_tokens
+
+            self._stream_done_callback(self._response)
+            return
+
+    def _process_anthropic_claude_chunk(self, chunk):
+        # pylint: disable=too-many-return-statements
+        if not (message_type := chunk.get("type")):
+            return
+
+        if message_type == "message_start":
+            # {'type': 'message_start', 'message': {'id': 'id', 'type': 'message', 'role': 'assistant', 'model': 'claude-2.0', 'content': [], 'stop_reason': None, 'stop_sequence': None, 'usage': {'input_tokens': 18, 'output_tokens': 1}}}
+            return
+
+        if message_type == "content_block_start":
+            # {'type': 'content_block_start', 'index': 0, 'content_block': {'type': 'text', 'text': ''}}
+            return
+
+        if message_type == "content_block_delta":
+            # {'type': 'content_block_delta', 'index': 0, 'delta': {'type': 'text_delta', 'text': 'Here'}}
+            return
+
+        if message_type == "content_block_stop":
+            # {'type': 'content_block_stop', 'index': 0}
+            return
+
+        if message_type == "message_delta":
+            # {'type': 'message_delta', 'delta': {'stop_reason': 'end_turn', 'stop_sequence': None}, 'usage': {'output_tokens': 123}}
+            if (
+                stop_reason := chunk.get("delta", {}).get("stop_reason")
+            ) is not None:
+                self._response["stopReason"] = stop_reason
+            return
+
+        if message_type == "message_stop":
+            # {'type': 'message_stop', 'amazon-bedrock-invocationMetrics': {'inputTokenCount': 18, 'outputTokenCount': 123, 'invocationLatency': 5250, 'firstByteLatency': 290}}
+            if invocation_metrics := chunk.get(
+                "amazon-bedrock-invocationMetrics"
+            ):
+                self._process_invocation_metrics(invocation_metrics)
+            self._stream_done_callback(self._response)
+            return

opentelemetry/instrumentation/botocore/extensions/types.py

@@ -101,6 +101,14 @@ class _AwsSdkExtension:
         """
         return True
 
+    def should_end_span_on_exit(self) -> bool:  # pylint:disable=no-self-use
+        """Returns if the span should be closed automatically on exit
+
+        Extensions might override this function to disable automatic closing
+        of the span if they need to close it at a later time themselves.
+        """
+        return True
+
     def extract_attributes(self, attributes: _AttributeMapT):
         """Callback which gets invoked before the span is created.
 

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.49b2"
+__version__ = "0.51b0"

{opentelemetry_instrumentation_botocore-0.49b2.dist-info → opentelemetry_instrumentation_botocore-0.51b0.dist-info}/METADATA

@@ -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.51b0.dist-info/RECORD

@@ -0,0 +1,18 @@
+opentelemetry/instrumentation/botocore/__init__.py,sha256=ln81OVC1dMnXvEubhw9Ye-ABBPAVhwRTnWM63h6s8aA,10469
+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=xU54GoF0aIm8WYGdGIfcg45s1dMdG2m5bpBCICAKNEo,608
+opentelemetry/instrumentation/botocore/extensions/__init__.py,sha256=KhGIZFpvOCOMEtVDSP0BhRpHbrkfpJz81B772JFu0u8,1740
+opentelemetry/instrumentation/botocore/extensions/_messaging.py,sha256=ca2Uwyb1vxWu5qUkKTlfn9KJFN6k8HOTrrBYvwX4WzA,1636
+opentelemetry/instrumentation/botocore/extensions/bedrock.py,sha256=HvxltbsCGrwi_fUdO4lUoDJ59Pc959L2kdqgdvJQkao,14284
+opentelemetry/instrumentation/botocore/extensions/bedrock_utils.py,sha256=ApoIE0oNPHivq3VCek4sz5y_pxO2ZXl3TDyWkcaGXXw,8639
+opentelemetry/instrumentation/botocore/extensions/dynamodb.py,sha256=BA-zoY-Cr878t5Q3pYS3r1PKAd4FFBtdTCXZLoC3tLE,13554
+opentelemetry/instrumentation/botocore/extensions/lmbd.py,sha256=Fm4_Pq9Wl2BPsHBo6iTJtof4QZTvG1XRBLrf6t-JoWM,4153
+opentelemetry/instrumentation/botocore/extensions/sns.py,sha256=Y0P3r_9msd33UFUFeitS01QBF4Aivqo4yPIDDy-qeLw,5360
+opentelemetry/instrumentation/botocore/extensions/sqs.py,sha256=2-ifTjtMQXayKQ-fEdxS_R7ckPXl7Givq3JESFz-Ou0,2791
+opentelemetry/instrumentation/botocore/extensions/types.py,sha256=hkPNjqAJBeWtYGKunIKuIEVELi0QxMrKe8Vadd27Gp0,5188
+opentelemetry_instrumentation_botocore-0.51b0.dist-info/METADATA,sha256=tqczEhMpt0XdsI3BEkgtR-tFOBjsTzp97RPI6vN5v8Y,2122
+opentelemetry_instrumentation_botocore-0.51b0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+opentelemetry_instrumentation_botocore-0.51b0.dist-info/entry_points.txt,sha256=v5hzQbZMJ61JuhBNq5jHYAapvv3C_486h9CTqxlkUTM,100
+opentelemetry_instrumentation_botocore-0.51b0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+opentelemetry_instrumentation_botocore-0.51b0.dist-info/RECORD,,

{opentelemetry_instrumentation_botocore-0.49b2.dist-info → opentelemetry_instrumentation_botocore-0.51b0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

opentelemetry_instrumentation_botocore-0.49b2.dist-info/RECORD

@@ -1,15 +0,0 @@
-opentelemetry/instrumentation/botocore/__init__.py,sha256=GWNEAzPLwvBUhXGw0B6iAWKBgC9MjM5zHdHGquvEYcU,10223
-opentelemetry/instrumentation/botocore/package.py,sha256=6xvfRpU_C3wlSO6pto7MhGtkPoCHDEiRO_Fh4DiC_50,622
-opentelemetry/instrumentation/botocore/version.py,sha256=Axuk6SG7SQR82yhUQ-qxl0W3DkT1XdtfwpB4A3PI6pM,608
-opentelemetry/instrumentation/botocore/extensions/__init__.py,sha256=nQGZ4Clq4d2eIeDK6v0IqQVJ6SIIBpzm57DJGXgL9TA,1665
-opentelemetry/instrumentation/botocore/extensions/_messaging.py,sha256=ca2Uwyb1vxWu5qUkKTlfn9KJFN6k8HOTrrBYvwX4WzA,1636
-opentelemetry/instrumentation/botocore/extensions/dynamodb.py,sha256=BA-zoY-Cr878t5Q3pYS3r1PKAd4FFBtdTCXZLoC3tLE,13554
-opentelemetry/instrumentation/botocore/extensions/lmbd.py,sha256=Fm4_Pq9Wl2BPsHBo6iTJtof4QZTvG1XRBLrf6t-JoWM,4153
-opentelemetry/instrumentation/botocore/extensions/sns.py,sha256=Y0P3r_9msd33UFUFeitS01QBF4Aivqo4yPIDDy-qeLw,5360
-opentelemetry/instrumentation/botocore/extensions/sqs.py,sha256=2-ifTjtMQXayKQ-fEdxS_R7ckPXl7Givq3JESFz-Ou0,2791
-opentelemetry/instrumentation/botocore/extensions/types.py,sha256=JWSXOP3KC6WRXbWG4EQczDDjaYhpq2HzTisUZn9e0m4,4857
-opentelemetry_instrumentation_botocore-0.49b2.dist-info/METADATA,sha256=G2Ksm5EyHKkwEzR5XGjbA3AHIt2lh5Drf7rFClzVVck,1950
-opentelemetry_instrumentation_botocore-0.49b2.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-opentelemetry_instrumentation_botocore-0.49b2.dist-info/entry_points.txt,sha256=v5hzQbZMJ61JuhBNq5jHYAapvv3C_486h9CTqxlkUTM,100
-opentelemetry_instrumentation_botocore-0.49b2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-opentelemetry_instrumentation_botocore-0.49b2.dist-info/RECORD,,