opentelemetry-instrumentation-botocore 0.53b1__tar.gz → 0.54b0__tar.gz

{opentelemetry_instrumentation_botocore-0.53b1 → opentelemetry_instrumentation_botocore-0.54b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-botocore
-Version: 0.53b1
+Version: 0.54b0
 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.54b0
 Requires-Dist: opentelemetry-propagator-aws-xray~=1.0
-Requires-Dist: opentelemetry-semantic-conventions==0.53b1
+Requires-Dist: opentelemetry-semantic-conventions==0.54b0
 Provides-Extra: instruments
 Requires-Dist: botocore~=1.0; extra == 'instruments'
 Description-Content-Type: text/x-rst

{opentelemetry_instrumentation_botocore-0.53b1 → opentelemetry_instrumentation_botocore-0.54b0}/pyproject.toml

@@ -27,8 +27,8 @@ classifiers = [
 ]
 dependencies = [
   "opentelemetry-api ~= 1.30",
-  "opentelemetry-instrumentation == 0.53b1",
-  "opentelemetry-semantic-conventions == 0.53b1",
+  "opentelemetry-instrumentation == 0.54b0",
+  "opentelemetry-semantic-conventions == 0.54b0",
   "opentelemetry-propagator-aws-xray ~= 1.0",
 ]
 

{opentelemetry_instrumentation_botocore-0.53b1 → opentelemetry_instrumentation_botocore-0.54b0}/src/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-0.53b1 → opentelemetry_instrumentation_botocore-0.54b0}/src/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-0.53b1 → opentelemetry_instrumentation_botocore-0.54b0}/src/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-0.54b0/src/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-0.53b1 → opentelemetry_instrumentation_botocore-0.54b0}/src/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.54b0"

{opentelemetry_instrumentation_botocore-0.53b1 → opentelemetry_instrumentation_botocore-0.54b0}/tests/README.md

@@ -1,7 +1,8 @@
 ## Recording calls
 
 If you need to record calls you may need to export authentication variables and the default region as environment
-variables in order to have the code work properly.
+variables in order to have the code work properly. The recorded tests assume the region us-east-1, so ensure that
+AWS_DEFAULT_REGION is set accordingly when recording new calls.
 Since tox blocks environment variables by default you need to override its configuration to let them pass:
 
 ```

{opentelemetry_instrumentation_botocore-0.53b1 → opentelemetry_instrumentation_botocore-0.54b0}/tests/bedrock_utils.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import json
+import math
 from typing import Any
 
 from botocore.response import StreamingBody
@@ -31,6 +32,9 @@ from opentelemetry.semconv._incubating.attributes import (
 from opentelemetry.semconv._incubating.attributes import (
     gen_ai_attributes as GenAIAttributes,
 )
+from opentelemetry.semconv._incubating.attributes import (
+    server_attributes as ServerAttributes,
+)
 from opentelemetry.semconv._incubating.attributes.error_attributes import (
     ERROR_TYPE,
 )
@@ -40,7 +44,7 @@ from opentelemetry.semconv._incubating.metrics.gen_ai_metrics import (
 )
 
 
-# pylint: disable=too-many-branches, too-many-locals
+# pylint: disable=too-many-branches, too-many-locals, too-many-statements
 def assert_completion_attributes_from_streaming_body(
     span: ReadableSpan,
     request_model: str,
@@ -54,6 +58,7 @@ def assert_completion_attributes_from_streaming_body(
     input_tokens = None
     output_tokens = None
     finish_reason = None
+    request_prompt = "Say this is a test"
     if response is not None:
         original_body = response["body"]
         body_content = original_body.read()
@@ -89,6 +94,33 @@ def assert_completion_attributes_from_streaming_body(
                 finish_reason = (response["stop_reason"],)
             else:
                 finish_reason = None
+        elif "cohere.command-r" in request_model:
+            input_tokens = math.ceil(len(request_prompt) / 6)
+            text = response.get("text")
+            if text:
+                output_tokens = math.ceil(len(text) / 6)
+            finish_reason = (response["finish_reason"],)
+        elif "cohere.command" in request_model:
+            input_tokens = math.ceil(len(request_prompt) / 6)
+            generations = response.get("generations")
+            if generations:
+                first_generation = generations[0]
+                output_tokens = math.ceil(len(first_generation["text"]) / 6)
+                finish_reason = (first_generation["finish_reason"],)
+        elif "meta.llama" in request_model:
+            if "prompt_token_count" in response:
+                input_tokens = response.get("prompt_token_count")
+            if "generation_token_count" in response:
+                output_tokens = response.get("generation_token_count")
+            if "stop_reason" in response:
+                finish_reason = (response["stop_reason"],)
+        elif "mistral.mistral" in request_model:
+            input_tokens = math.ceil(len(request_prompt) / 6)
+            outputs = response.get("outputs")
+            if outputs:
+                first_output = outputs[0]
+                output_tokens = math.ceil(len(first_output["text"]) / 6)
+                finish_reason = (first_output["stop_reason"],)
 
     return assert_all_attributes(
         span,
@@ -192,6 +224,8 @@ def assert_all_attributes(
     request_temperature: int | None = None,
     request_max_tokens: int | None = None,
     request_stop_sequences: tuple[str] | None = None,
+    server_address: str = "bedrock-runtime.us-east-1.amazonaws.com",
+    server_port: int = 443,
 ):
     assert span.name == f"{operation_name} {request_model}"
     assert (
@@ -206,6 +240,9 @@ def assert_all_attributes(
         request_model == span.attributes[GenAIAttributes.GEN_AI_REQUEST_MODEL]
     )
 
+    assert server_address == span.attributes[ServerAttributes.SERVER_ADDRESS]
+    assert server_port == span.attributes[ServerAttributes.SERVER_PORT]
+
     assert_equal_or_not_present(
         input_tokens, GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, span
     )
@@ -274,7 +311,12 @@ def assert_message_in_logs(log, event_name, expected_content, parent_span):
 
 
 def assert_all_metric_attributes(
-    data_point, operation_name: str, model: str, error_type: str | None = None
+    data_point,
+    operation_name: str,
+    model: str,
+    error_type: str | None = None,
+    server_address: str = "bedrock-runtime.us-east-1.amazonaws.com",
+    server_port: int = 443,
 ):
     assert GenAIAttributes.GEN_AI_OPERATION_NAME in data_point.attributes
     assert (
@@ -289,6 +331,14 @@ def assert_all_metric_attributes(
     assert GenAIAttributes.GEN_AI_REQUEST_MODEL in data_point.attributes
     assert data_point.attributes[GenAIAttributes.GEN_AI_REQUEST_MODEL] == model
 
+    assert ServerAttributes.SERVER_ADDRESS in data_point.attributes
+    assert (
+        data_point.attributes[ServerAttributes.SERVER_ADDRESS]
+        == server_address
+    )
+    assert ServerAttributes.SERVER_PORT in data_point.attributes
+    assert data_point.attributes[ServerAttributes.SERVER_PORT] == server_port
+
     if error_type is not None:
         assert ERROR_TYPE in data_point.attributes
         assert data_point.attributes[ERROR_TYPE] == error_type