Merge branch 'main' into main

Author: TheShubhendra

CHANGELOG.md

@@ -11,6 +11,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Breaking changes
+
+- `opentelemetry-instrumentation-botocore` Use `cloud.region` instead of `aws.region` span attribute as per semantic conventions.
+  ([#3474](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/3474))
+
+
 ## Version 1.33.0/0.54b0 (2025-05-09)
 
 ### Added

RELEASING.md

@@ -9,7 +9,8 @@
       (otherwise the workflow will pick up the version from `main` and just remove the `.dev` suffix).
   * Review the two pull requests that it creates.
     (one is targeted to the release branch and one is targeted to `main`).
-    * The builds will fail for both the `main` and release pr because of validation rules. Follow the [release workflow](https://github.com/open-telemetry/opentelemetry-python/blob/main/RELEASING.md) for the core repo up until this same point. Change the SHAs of each PR to point at each other to get the `main` and release builds to pass.
+    * The builds will fail for the release PR because of validation rules. Follow the [release workflow](https://github.com/open-telemetry/opentelemetry-python/blob/main/RELEASING.md) for the core repo up until this same point.
+    * Close and reopen the PR so that the workflow will take into account the label automation we have in place
   * Merge the release PR.
   * Merge the PR to main (this can be done separately from [making the release](#making-the-release))
 

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

@@ -64,7 +64,9 @@
 import opentelemetry.trace
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
-from opentelemetry.semconv.trace import SpanAttributes
+from opentelemetry.semconv._incubating.attributes.db_attributes import (
+    DB_STATEMENT,
+)
 
 
 def _ns_to_time(nanoseconds):
@@ -120,7 +122,7 @@ def _child_add_optional_attributes(child: Tree, span: ReadableSpan):
             label=Text.from_markup("[bold cyan]Attributes :[/bold cyan] ")
         )
         for attribute in span.attributes:
-            if attribute == SpanAttributes.DB_STATEMENT:
+            if attribute == DB_STATEMENT:
                 attributes.add(
                     Text.from_markup(f"[bold cyan]{attribute} :[/bold cyan] ")
                 )

instrumentation/opentelemetry-instrumentation-aiohttp-client/tests/test_aiohttp_client_integration.py

@@ -36,14 +36,18 @@
     AioHttpClientInstrumentor,
 )
 from opentelemetry.instrumentation.utils import suppress_instrumentation
+from opentelemetry.semconv._incubating.attributes.http_attributes import (
+    HTTP_METHOD,
+    HTTP_STATUS_CODE,
+    HTTP_URL,
+)
 from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
 from opentelemetry.semconv.attributes.http_attributes import (
     HTTP_REQUEST_METHOD,
     HTTP_REQUEST_METHOD_ORIGINAL,
     HTTP_RESPONSE_STATUS_CODE,
 )
 from opentelemetry.semconv.attributes.url_attributes import URL_FULL
-from opentelemetry.semconv.trace import SpanAttributes
 from opentelemetry.test.test_base import TestBase
 from opentelemetry.trace import Span, StatusCode
 from opentelemetry.util._importlib_metadata import entry_points
@@ -136,9 +140,9 @@ def test_status_codes(self):
                 )
                 url = f"http://{host}:{port}/{path}"
                 attributes = {
-                    SpanAttributes.HTTP_METHOD: "GET",
-                    SpanAttributes.HTTP_URL: url,
-                    SpanAttributes.HTTP_STATUS_CODE: status_code,
+                    HTTP_METHOD: "GET",
+                    HTTP_URL: url,
+                    HTTP_STATUS_CODE: status_code,
                 }
                 spans = [("GET", (span_status, None), attributes)]
                 self.assert_spans(spans)
@@ -181,11 +185,11 @@ def test_status_codes_both_semconv(self):
                 url = f"http://{host}:{port}/{path}"
                 attributes = {
                     HTTP_REQUEST_METHOD: "GET",
-                    SpanAttributes.HTTP_METHOD: "GET",
+                    HTTP_METHOD: "GET",
                     URL_FULL: url,
-                    SpanAttributes.HTTP_URL: url,
+                    HTTP_URL: url,
                     HTTP_RESPONSE_STATUS_CODE: status_code,
-                    SpanAttributes.HTTP_STATUS_CODE: status_code,
+                    HTTP_STATUS_CODE: status_code,
                 }
                 if status_code >= 400:
                     attributes[ERROR_TYPE] = str(status_code.value)
@@ -292,16 +296,12 @@ def response_hook(
                 (span.status.status_code, span.status.description),
                 (StatusCode.UNSET, None),
             )
+            self.assertEqual(span.attributes[HTTP_METHOD], method)
             self.assertEqual(
-                span.attributes[SpanAttributes.HTTP_METHOD], method
-            )
-            self.assertEqual(
-                span.attributes[SpanAttributes.HTTP_URL],
+                span.attributes[HTTP_URL],
                 f"http://{host}:{port}{path}",
             )
-            self.assertEqual(
-                span.attributes[SpanAttributes.HTTP_STATUS_CODE], HTTPStatus.OK
-            )
+            self.assertEqual(span.attributes[HTTP_STATUS_CODE], HTTPStatus.OK)
             self.assertIn("response_hook_attr", span.attributes)
             self.assertEqual(span.attributes["response_hook_attr"], "value")
         self.memory_exporter.clear()
@@ -325,9 +325,9 @@ def strip_query_params(url: yarl.URL) -> str:
                     "GET",
                     (StatusCode.UNSET, None),
                     {
-                        SpanAttributes.HTTP_METHOD: "GET",
-                        SpanAttributes.HTTP_URL: f"http://{host}:{port}/some/path",
-                        SpanAttributes.HTTP_STATUS_CODE: int(HTTPStatus.OK),
+                        HTTP_METHOD: "GET",
+                        HTTP_URL: f"http://{host}:{port}/some/path",
+                        HTTP_STATUS_CODE: int(HTTPStatus.OK),
                     },
                 )
             ]
@@ -359,8 +359,8 @@ async def do_request(url):
                         "GET",
                         (expected_status, "ClientConnectorError"),
                         {
-                            SpanAttributes.HTTP_METHOD: "GET",
-                            SpanAttributes.HTTP_URL: url,
+                            HTTP_METHOD: "GET",
+                            HTTP_URL: url,
                         },
                     )
                 ]
@@ -385,8 +385,8 @@ async def request_handler(request):
                     "GET",
                     (StatusCode.ERROR, "ServerDisconnectedError"),
                     {
-                        SpanAttributes.HTTP_METHOD: "GET",
-                        SpanAttributes.HTTP_URL: f"http://{host}:{port}/test",
+                        HTTP_METHOD: "GET",
+                        HTTP_URL: f"http://{host}:{port}/test",
                     },
                 )
             ]
@@ -443,8 +443,8 @@ async def request_handler(request):
                         HTTP_REQUEST_METHOD: "GET",
                         URL_FULL: f"http://{host}:{port}/test",
                         ERROR_TYPE: "ServerDisconnectedError",
-                        SpanAttributes.HTTP_METHOD: "GET",
-                        SpanAttributes.HTTP_URL: f"http://{host}:{port}/test",
+                        HTTP_METHOD: "GET",
+                        HTTP_URL: f"http://{host}:{port}/test",
                     },
                 )
             ]
@@ -469,8 +469,8 @@ async def request_handler(request):
                     "GET",
                     (StatusCode.ERROR, "SocketTimeoutError"),
                     {
-                        SpanAttributes.HTTP_METHOD: "GET",
-                        SpanAttributes.HTTP_URL: f"http://{host}:{port}/test_timeout",
+                        HTTP_METHOD: "GET",
+                        HTTP_URL: f"http://{host}:{port}/test_timeout",
                     },
                 )
             ]
@@ -496,8 +496,8 @@ async def request_handler(request):
                     "GET",
                     (StatusCode.ERROR, "TooManyRedirects"),
                     {
-                        SpanAttributes.HTTP_METHOD: "GET",
-                        SpanAttributes.HTTP_URL: f"http://{host}:{port}/test_too_many_redirects",
+                        HTTP_METHOD: "GET",
+                        HTTP_URL: f"http://{host}:{port}/test_too_many_redirects",
                     },
                 )
             ]
@@ -532,11 +532,9 @@ async def do_request(url):
                     "HTTP",
                     (StatusCode.ERROR, None),
                     {
-                        SpanAttributes.HTTP_METHOD: "_OTHER",
-                        SpanAttributes.HTTP_URL: url,
-                        SpanAttributes.HTTP_STATUS_CODE: int(
-                            HTTPStatus.METHOD_NOT_ALLOWED
-                        ),
+                        HTTP_METHOD: "_OTHER",
+                        HTTP_URL: url,
+                        HTTP_STATUS_CODE: int(HTTPStatus.METHOD_NOT_ALLOWED),
                     },
                 )
             ]
@@ -619,11 +617,9 @@ async def do_request(url):
                     "GET",
                     (StatusCode.UNSET, None),
                     {
-                        SpanAttributes.HTTP_METHOD: "GET",
-                        SpanAttributes.HTTP_URL: (
-                            "http://localhost:5000/status/200"
-                        ),
-                        SpanAttributes.HTTP_STATUS_CODE: int(HTTPStatus.OK),
+                        HTTP_METHOD: "GET",
+                        HTTP_URL: ("http://localhost:5000/status/200"),
+                        HTTP_STATUS_CODE: int(HTTPStatus.OK),
                     },
                 )
             ]
@@ -671,12 +667,12 @@ def test_instrument(self):
         )
         span = self.assert_spans(1)
         self.assertEqual("GET", span.name)
-        self.assertEqual("GET", span.attributes[SpanAttributes.HTTP_METHOD])
+        self.assertEqual("GET", span.attributes[HTTP_METHOD])
         self.assertEqual(
             f"http://{host}:{port}/test-path",
-            span.attributes[SpanAttributes.HTTP_URL],
+            span.attributes[HTTP_URL],
         )
-        self.assertEqual(200, span.attributes[SpanAttributes.HTTP_STATUS_CODE])
+        self.assertEqual(200, span.attributes[HTTP_STATUS_CODE])
 
     def test_instrument_new_semconv(self):
         AioHttpClientInstrumentor().uninstrument()
@@ -708,11 +704,11 @@ def test_instrument_both_semconv(self):
             url = f"http://{host}:{port}/test-path"
             attributes = {
                 HTTP_REQUEST_METHOD: "GET",
-                SpanAttributes.HTTP_METHOD: "GET",
+                HTTP_METHOD: "GET",
                 URL_FULL: url,
-                SpanAttributes.HTTP_URL: url,
+                HTTP_URL: url,
                 HTTP_RESPONSE_STATUS_CODE: 200,
-                SpanAttributes.HTTP_STATUS_CODE: 200,
+                HTTP_STATUS_CODE: 200,
             }
             span = self.assert_spans(1)
             self.assertEqual("GET", span.name)
@@ -852,7 +848,7 @@ def strip_query_params(url: yarl.URL) -> str:
         span = self.assert_spans(1)
         self.assertEqual(
             f"http://{host}:{port}/test-path",
-            span.attributes[SpanAttributes.HTTP_URL],
+            span.attributes[HTTP_URL],
         )
 
     def test_hooks(self):

instrumentation/opentelemetry-instrumentation-aiohttp-server/tests/test_aiohttp_server_integration.py

@@ -24,7 +24,11 @@
     AioHttpServerInstrumentor,
 )
 from opentelemetry.instrumentation.utils import suppress_http_instrumentation
-from opentelemetry.semconv.trace import SpanAttributes
+from opentelemetry.semconv._incubating.attributes.http_attributes import (
+    HTTP_METHOD,
+    HTTP_STATUS_CODE,
+    HTTP_URL,
+)
 from opentelemetry.test.globals_test import reset_trace_globals
 from opentelemetry.test.test_base import TestBase
 from opentelemetry.util._importlib_metadata import entry_points
@@ -127,15 +131,11 @@ async def test_status_code_instrumentation(
 
     [span] = memory_exporter.get_finished_spans()
 
-    assert expected_method.value == span.attributes[SpanAttributes.HTTP_METHOD]
-    assert (
-        expected_status_code
-        == span.attributes[SpanAttributes.HTTP_STATUS_CODE]
-    )
+    assert expected_method.value == span.attributes[HTTP_METHOD]
+    assert expected_status_code == span.attributes[HTTP_STATUS_CODE]
 
     assert (
-        f"http://{server.host}:{server.port}{url}"
-        == span.attributes[SpanAttributes.HTTP_URL]
+        f"http://{server.host}:{server.port}{url}" == span.attributes[HTTP_URL]
     )
 
 

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

@@ -109,6 +109,9 @@ def response_hook(span, service_name, operation_name, result):
 )
 from opentelemetry.metrics import Instrument, Meter, get_meter
 from opentelemetry.propagators.aws.aws_xray_propagator import AwsXRayPropagator
+from opentelemetry.semconv._incubating.attributes.cloud_attributes import (
+    CLOUD_REGION,
+)
 from opentelemetry.semconv.trace import SpanAttributes
 from opentelemetry.trace import get_tracer
 from opentelemetry.trace.span import Span
@@ -276,8 +279,7 @@ def _patched_api_call(self, original_func, instance, args, kwargs):
             SpanAttributes.RPC_SYSTEM: "aws-api",
             SpanAttributes.RPC_SERVICE: call_context.service_id,
             SpanAttributes.RPC_METHOD: call_context.operation,
-            # TODO: update when semantic conventions exist
-            "aws.region": call_context.region,
+            CLOUD_REGION: call_context.region,
             **get_server_attributes(call_context.endpoint_url),
         }
 

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

@@ -27,6 +27,9 @@
 )
 from opentelemetry.propagate import get_global_textmap, set_global_textmap
 from opentelemetry.propagators.aws.aws_xray_propagator import TRACE_HEADER_KEY
+from opentelemetry.semconv._incubating.attributes.cloud_attributes import (
+    CLOUD_REGION,
+)
 from opentelemetry.semconv.trace import SpanAttributes
 from opentelemetry.test.mock_textmap import MockTextMapPropagator
 from opentelemetry.test.test_base import TestBase
@@ -61,7 +64,7 @@ def _default_span_attributes(self, service: str, operation: str):
             SpanAttributes.RPC_SYSTEM: "aws-api",
             SpanAttributes.RPC_SERVICE: service,
             SpanAttributes.RPC_METHOD: operation,
-            "aws.region": self.region,
+            CLOUD_REGION: self.region,
             "retry_attempts": 0,
             SpanAttributes.HTTP_STATUS_CODE: 200,
             # Some services like IAM or STS have a global endpoint and exclude specified region.
@@ -527,7 +530,7 @@ def test_server_attributes(self):
             attributes={
                 SpanAttributes.SERVER_ADDRESS: "iam.amazonaws.com",
                 SpanAttributes.SERVER_PORT: 443,
-                "aws.region": "aws-global",
+                CLOUD_REGION: "aws-global",
             },
         )
 

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

@@ -106,7 +106,10 @@ def response_hook(span, response):
 from opentelemetry.instrumentation.elasticsearch.version import __version__
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import unwrap
-from opentelemetry.semconv.trace import SpanAttributes
+from opentelemetry.semconv._incubating.attributes.db_attributes import (
+    DB_STATEMENT,
+    DB_SYSTEM,
+)
 from opentelemetry.trace import SpanKind, Status, StatusCode, get_tracer
 
 from .utils import sanitize_body
@@ -288,7 +291,7 @@ def normalize_kwargs(k, v):
 
             if span.is_recording():
                 attributes = {
-                    SpanAttributes.DB_SYSTEM: "elasticsearch",
+                    DB_SYSTEM: "elasticsearch",
                 }
                 if url:
                     attributes["elasticsearch.url"] = url
@@ -297,9 +300,7 @@ def normalize_kwargs(k, v):
                 if body:
                     # Don't set db.statement for bulk requests, as it can be very large
                     if isinstance(body, dict):
-                        attributes[SpanAttributes.DB_STATEMENT] = (
-                            sanitize_body(body)
-                        )
+                        attributes[DB_STATEMENT] = sanitize_body(body)
                 if params:
                     attributes["elasticsearch.params"] = str(params)
                 if doc_id:

tests/opentelemetry-docker-tests/tests/check_availability.py

@@ -42,8 +42,8 @@
 MSSQL_PORT = int(os.getenv("MSSQL_PORT", "1433"))
 MSSQL_USER = os.getenv("MSSQL_USER", "sa")
 MSSQL_PASSWORD = os.getenv("MSSQL_PASSWORD", "yourStrong(!)Password")
-RETRY_COUNT = 8
-RETRY_INTERVAL = 5  # Seconds
+RETRY_COUNT = 5
+RETRY_INITIAL_INTERVAL = 2  # Seconds
 
 logger = logging.getLogger(__name__)
 
@@ -56,14 +56,16 @@ def wrapper():
                 func()
                 return
             except Exception as ex:  # pylint: disable=broad-except
+                # Exponential backoff
+                backoff_interval = RETRY_INITIAL_INTERVAL * (2**i)
                 logger.error(
                     "waiting for %s, retry %d/%d [%s]",
                     func.__name__,
                     i + 1,
                     RETRY_COUNT,
                     ex,
                 )
-            time.sleep(RETRY_INTERVAL)
+            time.sleep(backoff_interval)
         raise Exception(f"waiting for {func.__name__} failed")
 
     return wrapper