Merge branch 'main' into feature/valkey

Author: sightseeker

CHANGELOG.md

@@ -31,6 +31,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ([#3380](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3381))
 - `opentelemetry-instrumentation-[asynclick/click]` Add missing opentelemetry-instrumentation dep
   ([#3447](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3447))
+- `opentelemetry-instrumentation-botocore` Capture server attributes for botocore API calls
+  ([#3448](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3448))
 
 ## Version 1.32.0/0.53b0 (2025-04-10)
 

exporter/opentelemetry-exporter-richconsole/src/opentelemetry/exporter/richconsole/__init__.py

@@ -68,7 +68,9 @@
 
 
 def _ns_to_time(nanoseconds):
-    ts = datetime.datetime.utcfromtimestamp(nanoseconds / 1e9)
+    ts = datetime.datetime.fromtimestamp(
+        nanoseconds / 1e9, datetime.timezone.utc
+    )
     return ts.strftime("%H:%M:%S.%f")
 
 

instrumentation-genai/opentelemetry-instrumentation-google-genai/CHANGELOG.md

@@ -7,7 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
-## Version 0.2b0 (2025-04-25)
+## Version 0.2b0 (2025-04-28)
 
 - Add more request configuration options to the span attributes ([#3374](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3374))
 - Restructure tests to keep in line with repository conventions ([#3344](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3344))

instrumentation/opentelemetry-instrumentation-aiokafka/src/opentelemetry/instrumentation/aiokafka/__init__.py

@@ -20,20 +20,35 @@
 
 .. code:: python
 
+    import asyncio
     from opentelemetry.instrumentation.aiokafka import AIOKafkaInstrumentor
     from aiokafka import AIOKafkaProducer, AIOKafkaConsumer
 
     # Instrument kafka
     AIOKafkaInstrumentor().instrument()
 
     # report a span of type producer with the default settings
-    producer = AIOKafkaProducer(bootstrap_servers=['localhost:9092'])
-    await producer.send('my-topic', b'raw_bytes')
+    async def produce():
+        producer = AIOKafkaProducer(bootstrap_servers=['localhost:9092'])
+        await producer.start()
+        try:
+            await producer.send_and_wait('my-topic', b'raw_bytes')
+        finally:
+            await producer.stop()
 
     # report a span of type consumer with the default settings
-    consumer = AIOKafkaConsumer('my-topic', group_id='my-group', bootstrap_servers=['localhost:9092'])
-    async for message in consumer:
-    # process message
+    async def consume():
+        consumer = AIOKafkaConsumer('my-topic', group_id='my-group', bootstrap_servers=['localhost:9092'])
+        await consumer.start()
+        try:
+            async for message in consumer:
+                # process message
+                print(message)
+        finally:
+            await consumer.stop()
+
+    asyncio.run(produce())
+    asyncio.run(consume())
 
 The _instrument() method accepts the following keyword args:
 tracer_provider (TracerProvider) - an optional tracer provider
@@ -47,12 +62,14 @@ def async_consume_hook(span: Span, record: kafka.record.ABCRecord, args, kwargs)
 
 .. code:: python
 
-    from opentelemetry.instrumentation.kafka import AIOKafkaInstrumentor
+    import asyncio
+    from opentelemetry.instrumentation.aiokafka import AIOKafkaInstrumentor
     from aiokafka import AIOKafkaProducer, AIOKafkaConsumer
 
     async def async_produce_hook(span, args, kwargs):
         if span and span.is_recording():
             span.set_attribute("custom_user_attribute_from_async_response_hook", "some-value")
+
     async def async_consume_hook(span, record, args, kwargs):
         if span and span.is_recording():
             span.set_attribute("custom_user_attribute_from_consume_hook", "some-value")
@@ -62,8 +79,15 @@ async def async_consume_hook(span, record, args, kwargs):
 
     # Using kafka as normal now will automatically generate spans,
     # including user custom attributes added from the hooks
-    producer = AIOKafkaProducer(bootstrap_servers=['localhost:9092'])
-    await producer.send('my-topic', b'raw_bytes')
+    async def produce():
+        producer = AIOKafkaProducer(bootstrap_servers=['localhost:9092'])
+        await producer.start()
+        try:
+            await producer.send_and_wait('my-topic', b'raw_bytes')
+        finally:
+            await producer.stop()
+
+    asyncio.run(produce())
 
 API
 ___

instrumentation/opentelemetry-instrumentation-aiopg/src/opentelemetry/instrumentation/aiopg/__init__.py

@@ -23,40 +23,53 @@
 
 .. code-block:: python
 
+    import asyncio
     import aiopg
     from opentelemetry.instrumentation.aiopg import AiopgInstrumentor
     # Call instrument() to wrap all database connections
     AiopgInstrumentor().instrument()
 
-    cnx = await aiopg.connect(database='Database')
-    cursor = await cnx.cursor()
-    await cursor.execute("CREATE TABLE IF NOT EXISTS test (testField INTEGER)")
-    await cursor.execute("INSERT INTO test (testField) VALUES (123)")
-    cursor.close()
-    cnx.close()
+    dsn = 'user=user password=password host=127.0.0.1'
 
-    pool = await aiopg.create_pool(database='Database')
+    async def connect():
+        cnx = await aiopg.connect(dsn)
+        cursor = await cnx.cursor()
+        await cursor.execute("CREATE TABLE IF NOT EXISTS test (testField INTEGER)")
+        await cursor.execute("INSERT INTO test (testField) VALUES (123)")
+        cursor.close()
+        cnx.close()
 
-    cnx = await pool.acquire()
-    cursor = await cnx.cursor()
-    await cursor.execute("CREATE TABLE IF NOT EXISTS test (testField INTEGER)")
-    await cursor.execute("INSERT INTO test (testField) VALUES (123)")
-    cursor.close()
-    cnx.close()
+    async def create_pool():
+        pool = await aiopg.create_pool(dsn)
+        cnx = await pool.acquire()
+        cursor = await cnx.cursor()
+        await cursor.execute("CREATE TABLE IF NOT EXISTS test (testField INTEGER)")
+        await cursor.execute("INSERT INTO test (testField) VALUES (123)")
+        cursor.close()
+        cnx.close()
+
+    asyncio.run(connect())
+    asyncio.run(create_pool())
 
 .. code-block:: python
 
+    import asyncio
     import aiopg
     from opentelemetry.instrumentation.aiopg import AiopgInstrumentor
 
+    dsn = 'user=user password=password host=127.0.0.1'
+
     # Alternatively, use instrument_connection for an individual connection
-    cnx = await aiopg.connect(database='Database')
-    instrumented_cnx = AiopgInstrumentor().instrument_connection(cnx)
-    cursor = await instrumented_cnx.cursor()
-    await cursor.execute("CREATE TABLE IF NOT EXISTS test (testField INTEGER)")
-    await cursor.execute("INSERT INTO test (testField) VALUES (123)")
-    cursor.close()
-    instrumented_cnx.close()
+    async def go():
+        cnx = await aiopg.connect(dsn)
+        instrumented_cnx = AiopgInstrumentor().instrument_connection(cnx)
+        cursor = await instrumented_cnx.cursor()
+        await cursor.execute("CREATE TABLE IF NOT EXISTS test (testField INTEGER)")
+        await cursor.execute("INSERT INTO test (testField) VALUES (123)")
+        cursor.close()
+        instrumented_cnx.close()
+
+    asyncio.run(go())
 
 API
 ---

instrumentation/opentelemetry-instrumentation-botocore/src/opentelemetry/instrumentation/botocore/__init__.py

@@ -99,6 +99,7 @@ def response_hook(span, service_name, operation_name, result):
     _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 @@ def _patched_api_call(self, original_func, instance, args, kwargs):
             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)

instrumentation/opentelemetry-instrumentation-botocore/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
 
@@ -41,6 +42,7 @@
     _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,
@@ -146,7 +148,10 @@ def setup_metrics(self, meter: Meter, metrics: dict[str, Instrument]):
         )
 
     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:
@@ -163,6 +168,7 @@ def _extract_metrics_attributes(self) -> _AttributeMapT:
             attributes[GEN_AI_OPERATION_NAME] = (
                 GenAiOperationNameValues.CHAT.value
             )
+
         return attributes
 
     def extract_attributes(self, attributes: _AttributeMapT):

instrumentation/opentelemetry-instrumentation-botocore/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

instrumentation/opentelemetry-instrumentation-botocore/tests/bedrock_utils.py

@@ -32,6 +32,9 @@
 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,
 )
@@ -221,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 (
@@ -235,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
     )
@@ -303,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 (
@@ -318,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