opentelemetry-instrumentation-aiohttp-client 0.46b0__tar.gz → 0.47b0__tar.gz

{opentelemetry_instrumentation_aiohttp_client-0.46b0 → opentelemetry_instrumentation_aiohttp_client-0.47b0}/.gitignore

@@ -58,3 +58,6 @@ _build/
 # mypy
 .mypy_cache/
 target
+
+# Benchmark result files
+*-benchmark.json

{opentelemetry_instrumentation_aiohttp_client-0.46b0 → opentelemetry_instrumentation_aiohttp_client-0.47b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: opentelemetry-instrumentation-aiohttp-client
-Version: 0.46b0
+Version: 0.47b0
 Summary: OpenTelemetry aiohttp client instrumentation
 Project-URL: Homepage, https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation/opentelemetry-instrumentation-aiohttp-client
 Author-email: OpenTelemetry Authors <cncf-opentelemetry-contributors@lists.cncf.io>
@@ -15,11 +15,12 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8
 Requires-Dist: opentelemetry-api~=1.12
-Requires-Dist: opentelemetry-instrumentation==0.46b0
-Requires-Dist: opentelemetry-semantic-conventions==0.46b0
-Requires-Dist: opentelemetry-util-http==0.46b0
+Requires-Dist: opentelemetry-instrumentation==0.47b0
+Requires-Dist: opentelemetry-semantic-conventions==0.47b0
+Requires-Dist: opentelemetry-util-http==0.47b0
 Requires-Dist: wrapt<2.0.0,>=1.0.0
 Provides-Extra: instruments
 Requires-Dist: aiohttp~=3.0; extra == 'instruments'

{opentelemetry_instrumentation_aiohttp_client-0.46b0 → opentelemetry_instrumentation_aiohttp_client-0.47b0}/pyproject.toml

@@ -22,12 +22,13 @@ classifiers = [
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
   "opentelemetry-api ~= 1.12",
-  "opentelemetry-instrumentation == 0.46b0",
-  "opentelemetry-semantic-conventions == 0.46b0",
-  "opentelemetry-util-http == 0.46b0",
+  "opentelemetry-instrumentation == 0.47b0",
+  "opentelemetry-semantic-conventions == 0.47b0",
+  "opentelemetry-util-http == 0.47b0",
   "wrapt >= 1.0.0, < 2.0.0",
 ]
 

{opentelemetry_instrumentation_aiohttp_client-0.46b0 → opentelemetry_instrumentation_aiohttp_client-0.47b0}/src/opentelemetry/instrumentation/aiohttp_client/__init__.py

@@ -90,19 +90,28 @@ import yarl
 
 from opentelemetry import context as context_api
 from opentelemetry import trace
+from opentelemetry.instrumentation._semconv import (
+    _get_schema_url,
+    _HTTPStabilityMode,
+    _OpenTelemetrySemanticConventionStability,
+    _OpenTelemetryStabilitySignalType,
+    _report_new,
+    _set_http_method,
+    _set_http_url,
+    _set_status,
+)
 from opentelemetry.instrumentation.aiohttp_client.package import _instruments
 from opentelemetry.instrumentation.aiohttp_client.version import __version__
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.instrumentation.utils import (
-    http_status_to_status_code,
     is_instrumentation_enabled,
     unwrap,
 )
 from opentelemetry.propagate import inject
-from opentelemetry.semconv.trace import SpanAttributes
+from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
 from opentelemetry.trace import Span, SpanKind, TracerProvider, get_tracer
 from opentelemetry.trace.status import Status, StatusCode
-from opentelemetry.util.http import remove_url_credentials
+from opentelemetry.util.http import remove_url_credentials, sanitize_method
 
 _UrlFilterT = typing.Optional[typing.Callable[[yarl.URL], str]]
 _RequestHookT = typing.Optional[
@@ -122,11 +131,45 @@ _ResponseHookT = typing.Optional[
 ]
 
 
+def _get_span_name(method: str) -> str:
+    method = sanitize_method(method.strip())
+    if method == "_OTHER":
+        method = "HTTP"
+    return method
+
+
+def _set_http_status_code_attribute(
+    span,
+    status_code,
+    metric_attributes=None,
+    sem_conv_opt_in_mode=_HTTPStabilityMode.DEFAULT,
+):
+    status_code_str = str(status_code)
+    try:
+        status_code = int(status_code)
+    except ValueError:
+        status_code = -1
+    if metric_attributes is None:
+        metric_attributes = {}
+    # When we have durations we should set metrics only once
+    # Also the decision to include status code on a histogram should
+    # not be dependent on tracing decisions.
+    _set_status(
+        span,
+        metric_attributes,
+        status_code,
+        status_code_str,
+        server_span=False,
+        sem_conv_opt_in_mode=sem_conv_opt_in_mode,
+    )
+
+
 def create_trace_config(
     url_filter: _UrlFilterT = None,
     request_hook: _RequestHookT = None,
     response_hook: _ResponseHookT = None,
     tracer_provider: TracerProvider = None,
+    sem_conv_opt_in_mode: _HTTPStabilityMode = _HTTPStabilityMode.DEFAULT,
 ) -> aiohttp.TraceConfig:
     """Create an aiohttp-compatible trace configuration.
 
@@ -167,9 +210,12 @@ def create_trace_config(
         __name__,
         __version__,
         tracer_provider,
-        schema_url="https://opentelemetry.io/schemas/1.11.0",
+        schema_url=_get_schema_url(sem_conv_opt_in_mode),
     )
 
+    # TODO: Use this when we have durations for aiohttp-client
+    metric_attributes = {}
+
     def _end_trace(trace_config_ctx: types.SimpleNamespace):
         context_api.detach(trace_config_ctx.token)
         trace_config_ctx.span.end()
@@ -183,18 +229,22 @@ def create_trace_config(
             trace_config_ctx.span = None
             return
 
-        http_method = params.method.upper()
-        request_span_name = f"{http_method}"
+        method = params.method
+        request_span_name = _get_span_name(method)
         request_url = (
             remove_url_credentials(trace_config_ctx.url_filter(params.url))
             if callable(trace_config_ctx.url_filter)
             else remove_url_credentials(str(params.url))
         )
 
-        span_attributes = {
-            SpanAttributes.HTTP_METHOD: http_method,
-            SpanAttributes.HTTP_URL: request_url,
-        }
+        span_attributes = {}
+        _set_http_method(
+            span_attributes,
+            method,
+            sanitize_method(method),
+            sem_conv_opt_in_mode,
+        )
+        _set_http_url(span_attributes, request_url, sem_conv_opt_in_mode)
 
         trace_config_ctx.span = trace_config_ctx.tracer.start_span(
             request_span_name, kind=SpanKind.CLIENT, attributes=span_attributes
@@ -219,14 +269,13 @@ def create_trace_config(
 
         if callable(response_hook):
             response_hook(trace_config_ctx.span, params)
+        _set_http_status_code_attribute(
+            trace_config_ctx.span,
+            params.response.status,
+            metric_attributes,
+            sem_conv_opt_in_mode,
+        )
 
-        if trace_config_ctx.span.is_recording():
-            trace_config_ctx.span.set_status(
-                Status(http_status_to_status_code(int(params.response.status)))
-            )
-            trace_config_ctx.span.set_attribute(
-                SpanAttributes.HTTP_STATUS_CODE, params.response.status
-            )
         _end_trace(trace_config_ctx)
 
     async def on_request_exception(
@@ -238,7 +287,13 @@ def create_trace_config(
             return
 
         if trace_config_ctx.span.is_recording() and params.exception:
-            trace_config_ctx.span.set_status(Status(StatusCode.ERROR))
+            exc_type = type(params.exception).__qualname__
+            if _report_new(sem_conv_opt_in_mode):
+                trace_config_ctx.span.set_attribute(ERROR_TYPE, exc_type)
+
+            trace_config_ctx.span.set_status(
+                Status(StatusCode.ERROR, exc_type)
+            )
             trace_config_ctx.span.record_exception(params.exception)
 
         if callable(response_hook):
@@ -271,6 +326,7 @@ def _instrument(
     trace_configs: typing.Optional[
         typing.Sequence[aiohttp.TraceConfig]
     ] = None,
+    sem_conv_opt_in_mode: _HTTPStabilityMode = _HTTPStabilityMode.DEFAULT,
 ):
     """Enables tracing of all ClientSessions
 
@@ -293,6 +349,7 @@ def _instrument(
             request_hook=request_hook,
             response_hook=response_hook,
             tracer_provider=tracer_provider,
+            sem_conv_opt_in_mode=sem_conv_opt_in_mode,
         )
         trace_config._is_instrumented_by_opentelemetry = True
         client_trace_configs.append(trace_config)
@@ -344,12 +401,17 @@ class AioHttpClientInstrumentor(BaseInstrumentor):
                 ``trace_configs``: An optional list of aiohttp.TraceConfig items, allowing customize enrichment of spans
                  based on aiohttp events (see specification: https://docs.aiohttp.org/en/stable/tracing_reference.html)
         """
+        _OpenTelemetrySemanticConventionStability._initialize()
+        _sem_conv_opt_in_mode = _OpenTelemetrySemanticConventionStability._get_opentelemetry_stability_opt_in_mode(
+            _OpenTelemetryStabilitySignalType.HTTP,
+        )
         _instrument(
             tracer_provider=kwargs.get("tracer_provider"),
             url_filter=kwargs.get("url_filter"),
             request_hook=kwargs.get("request_hook"),
             response_hook=kwargs.get("response_hook"),
             trace_configs=kwargs.get("trace_configs"),
+            sem_conv_opt_in_mode=_sem_conv_opt_in_mode,
         )
 
     def _uninstrument(self, **kwargs):

{opentelemetry_instrumentation_aiohttp_client-0.46b0 → opentelemetry_instrumentation_aiohttp_client-0.47b0}/src/opentelemetry/instrumentation/aiohttp_client/package.py

@@ -14,3 +14,7 @@
 
 
 _instruments = ("aiohttp ~= 3.0",)
+
+_supports_metrics = False
+
+_semconv_status = "migration"

{opentelemetry_instrumentation_aiohttp_client-0.46b0 → opentelemetry_instrumentation_aiohttp_client-0.47b0}/src/opentelemetry/instrumentation/aiohttp_client/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.46b0"
+__version__ = "0.47b0"

{opentelemetry_instrumentation_aiohttp_client-0.46b0 → opentelemetry_instrumentation_aiohttp_client-0.47b0}/tests/test_aiohttp_client_integration.py

@@ -14,7 +14,6 @@
 
 import asyncio
 import contextlib
-import sys
 import typing
 import unittest
 import urllib.parse
@@ -29,10 +28,22 @@ from pkg_resources import iter_entry_points
 
 from opentelemetry import trace as trace_api
 from opentelemetry.instrumentation import aiohttp_client
+from opentelemetry.instrumentation._semconv import (
+    OTEL_SEMCONV_STABILITY_OPT_IN,
+    _HTTPStabilityMode,
+    _OpenTelemetrySemanticConventionStability,
+)
 from opentelemetry.instrumentation.aiohttp_client import (
     AioHttpClientInstrumentor,
 )
 from opentelemetry.instrumentation.utils import suppress_instrumentation
+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
@@ -60,7 +71,23 @@ def run_with_test_server(
 
 
 class TestAioHttpIntegration(TestBase):
-    def assert_spans(self, spans):
+
+    _test_status_codes = (
+        (HTTPStatus.OK, StatusCode.UNSET),
+        (HTTPStatus.TEMPORARY_REDIRECT, StatusCode.UNSET),
+        (HTTPStatus.NOT_FOUND, StatusCode.ERROR),
+        (HTTPStatus.BAD_REQUEST, StatusCode.ERROR),
+        (HTTPStatus.SERVICE_UNAVAILABLE, StatusCode.ERROR),
+        (HTTPStatus.GATEWAY_TIMEOUT, StatusCode.ERROR),
+    )
+
+    def setUp(self):
+        super().setUp()
+        _OpenTelemetrySemanticConventionStability._initialized = False
+
+    def assert_spans(self, spans, num_spans=1):
+        finished_spans = self.memory_exporter.get_finished_spans()
+        self.assertEqual(num_spans, len(finished_spans))
         self.assertEqual(
             [
                 (
@@ -68,7 +95,7 @@ class TestAioHttpIntegration(TestBase):
                     (span.status.status_code, span.status.description),
                     dict(span.attributes),
                 )
-                for span in self.memory_exporter.get_finished_spans()
+                for span in finished_spans
             ],
             spans,
         )
@@ -100,43 +127,72 @@ class TestAioHttpIntegration(TestBase):
         return run_with_test_server(client_request, url, handler)
 
     def test_status_codes(self):
-        for status_code, span_status in (
-            (HTTPStatus.OK, StatusCode.UNSET),
-            (HTTPStatus.TEMPORARY_REDIRECT, StatusCode.UNSET),
-            (HTTPStatus.SERVICE_UNAVAILABLE, StatusCode.ERROR),
-            (
-                HTTPStatus.GATEWAY_TIMEOUT,
-                StatusCode.ERROR,
-            ),
-        ):
+        for status_code, span_status in self._test_status_codes:
             with self.subTest(status_code=status_code):
+                path = "test-path?query=param#foobar"
                 host, port = self._http_request(
                     trace_config=aiohttp_client.create_trace_config(),
-                    url="/test-path?query=param#foobar",
+                    url=f"/{path}",
                     status_code=status_code,
                 )
+                url = f"http://{host}:{port}/{path}"
+                attributes = {
+                    SpanAttributes.HTTP_METHOD: "GET",
+                    SpanAttributes.HTTP_URL: url,
+                    SpanAttributes.HTTP_STATUS_CODE: status_code,
+                }
+                spans = [("GET", (span_status, None), attributes)]
+                self.assert_spans(spans)
+                self.memory_exporter.clear()
 
-                url = f"http://{host}:{port}/test-path?query=param#foobar"
-                # if python version is < 3.8, then the url will be
-                if sys.version_info[1] < 8:
-                    url = f"http://{host}:{port}/test-path#foobar"
-
-                self.assert_spans(
-                    [
-                        (
-                            "GET",
-                            (span_status, None),
-                            {
-                                SpanAttributes.HTTP_METHOD: "GET",
-                                SpanAttributes.HTTP_URL: url,
-                                SpanAttributes.HTTP_STATUS_CODE: int(
-                                    status_code
-                                ),
-                            },
-                        )
-                    ]
+    def test_status_codes_new_semconv(self):
+        for status_code, span_status in self._test_status_codes:
+            with self.subTest(status_code=status_code):
+                path = "test-path?query=param#foobar"
+                host, port = self._http_request(
+                    trace_config=aiohttp_client.create_trace_config(
+                        sem_conv_opt_in_mode=_HTTPStabilityMode.HTTP
+                    ),
+                    url=f"/{path}",
+                    status_code=status_code,
                 )
+                url = f"http://{host}:{port}/{path}"
+                attributes = {
+                    HTTP_REQUEST_METHOD: "GET",
+                    URL_FULL: url,
+                    HTTP_RESPONSE_STATUS_CODE: status_code,
+                }
+                if status_code >= 400:
+                    attributes[ERROR_TYPE] = str(status_code.value)
+                spans = [("GET", (span_status, None), attributes)]
+                self.assert_spans(spans)
+                self.memory_exporter.clear()
 
+    def test_status_codes_both_semconv(self):
+        for status_code, span_status in self._test_status_codes:
+            with self.subTest(status_code=status_code):
+                path = "test-path?query=param#foobar"
+                host, port = self._http_request(
+                    trace_config=aiohttp_client.create_trace_config(
+                        sem_conv_opt_in_mode=_HTTPStabilityMode.HTTP_DUP
+                    ),
+                    url=f"/{path}",
+                    status_code=status_code,
+                )
+                url = f"http://{host}:{port}/{path}"
+                attributes = {
+                    HTTP_REQUEST_METHOD: "GET",
+                    SpanAttributes.HTTP_METHOD: "GET",
+                    URL_FULL: url,
+                    SpanAttributes.HTTP_URL: url,
+                    HTTP_RESPONSE_STATUS_CODE: status_code,
+                    SpanAttributes.HTTP_STATUS_CODE: status_code,
+                }
+                if status_code >= 400:
+                    attributes[ERROR_TYPE] = str(status_code.value)
+
+                spans = [("GET", (span_status, None), attributes)]
+                self.assert_spans(spans, 1)
                 self.memory_exporter.clear()
 
     def test_schema_url(self):
@@ -154,6 +210,40 @@ class TestAioHttpIntegration(TestBase):
             )
             self.memory_exporter.clear()
 
+    def test_schema_url_new_semconv(self):
+        with self.subTest(status_code=200):
+            self._http_request(
+                trace_config=aiohttp_client.create_trace_config(
+                    sem_conv_opt_in_mode=_HTTPStabilityMode.HTTP
+                ),
+                url="/test-path?query=param#foobar",
+                status_code=200,
+            )
+
+            span = self.memory_exporter.get_finished_spans()[0]
+            self.assertEqual(
+                span.instrumentation_info.schema_url,
+                "https://opentelemetry.io/schemas/1.21.0",
+            )
+            self.memory_exporter.clear()
+
+    def test_schema_url_both_semconv(self):
+        with self.subTest(status_code=200):
+            self._http_request(
+                trace_config=aiohttp_client.create_trace_config(
+                    sem_conv_opt_in_mode=_HTTPStabilityMode.HTTP_DUP
+                ),
+                url="/test-path?query=param#foobar",
+                status_code=200,
+            )
+
+            span = self.memory_exporter.get_finished_spans()[0]
+            self.assertEqual(
+                span.instrumentation_info.schema_url,
+                "https://opentelemetry.io/schemas/1.21.0",
+            )
+            self.memory_exporter.clear()
+
     def test_not_recording(self):
         mock_tracer = mock.Mock()
         mock_span = mock.Mock()
@@ -268,7 +358,7 @@ class TestAioHttpIntegration(TestBase):
                 [
                     (
                         "GET",
-                        (expected_status, None),
+                        (expected_status, "ClientConnectorError"),
                         {
                             SpanAttributes.HTTP_METHOD: "GET",
                             SpanAttributes.HTTP_URL: url,
@@ -278,6 +368,89 @@ class TestAioHttpIntegration(TestBase):
             )
             self.memory_exporter.clear()
 
+    def test_basic_exception(self):
+        async def request_handler(request):
+            assert "traceparent" in request.headers
+
+        host, port = self._http_request(
+            trace_config=aiohttp_client.create_trace_config(),
+            url="/test",
+            request_handler=request_handler,
+        )
+        span = self.memory_exporter.get_finished_spans()[0]
+        self.assertEqual(len(span.events), 1)
+        self.assertEqual(span.events[0].name, "exception")
+        self.assert_spans(
+            [
+                (
+                    "GET",
+                    (StatusCode.ERROR, "ServerDisconnectedError"),
+                    {
+                        SpanAttributes.HTTP_METHOD: "GET",
+                        SpanAttributes.HTTP_URL: f"http://{host}:{port}/test",
+                    },
+                )
+            ]
+        )
+
+    def test_basic_exception_new_semconv(self):
+        async def request_handler(request):
+            assert "traceparent" in request.headers
+
+        host, port = self._http_request(
+            trace_config=aiohttp_client.create_trace_config(
+                sem_conv_opt_in_mode=_HTTPStabilityMode.HTTP
+            ),
+            url="/test",
+            request_handler=request_handler,
+        )
+        span = self.memory_exporter.get_finished_spans()[0]
+        self.assertEqual(len(span.events), 1)
+        self.assertEqual(span.events[0].name, "exception")
+        self.assert_spans(
+            [
+                (
+                    "GET",
+                    (StatusCode.ERROR, "ServerDisconnectedError"),
+                    {
+                        HTTP_REQUEST_METHOD: "GET",
+                        URL_FULL: f"http://{host}:{port}/test",
+                        ERROR_TYPE: "ServerDisconnectedError",
+                    },
+                )
+            ]
+        )
+
+    def test_basic_exception_both_semconv(self):
+        async def request_handler(request):
+            assert "traceparent" in request.headers
+
+        host, port = self._http_request(
+            trace_config=aiohttp_client.create_trace_config(
+                sem_conv_opt_in_mode=_HTTPStabilityMode.HTTP_DUP
+            ),
+            url="/test",
+            request_handler=request_handler,
+        )
+        span = self.memory_exporter.get_finished_spans()[0]
+        self.assertEqual(len(span.events), 1)
+        self.assertEqual(span.events[0].name, "exception")
+        self.assert_spans(
+            [
+                (
+                    "GET",
+                    (StatusCode.ERROR, "ServerDisconnectedError"),
+                    {
+                        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",
+                    },
+                )
+            ]
+        )
+
     def test_timeout(self):
         async def request_handler(request):
             await asyncio.sleep(1)
@@ -295,7 +468,7 @@ class TestAioHttpIntegration(TestBase):
             [
                 (
                     "GET",
-                    (StatusCode.ERROR, None),
+                    (StatusCode.ERROR, "ServerTimeoutError"),
                     {
                         SpanAttributes.HTTP_METHOD: "GET",
                         SpanAttributes.HTTP_URL: f"http://{host}:{port}/test_timeout",
@@ -322,7 +495,7 @@ class TestAioHttpIntegration(TestBase):
             [
                 (
                     "GET",
-                    (StatusCode.ERROR, None),
+                    (StatusCode.ERROR, "TooManyRedirects"),
                     {
                         SpanAttributes.HTTP_METHOD: "GET",
                         SpanAttributes.HTTP_URL: f"http://{host}:{port}/test_too_many_redirects",
@@ -331,6 +504,92 @@ class TestAioHttpIntegration(TestBase):
             ]
         )
 
+    def test_nonstandard_http_method(self):
+        trace_configs = [aiohttp_client.create_trace_config()]
+        app = HttpServerMock("nonstandard_method")
+
+        @app.route("/status/200", methods=["NONSTANDARD"])
+        def index():
+            return ("", 405, {})
+
+        url = "http://localhost:5000/status/200"
+
+        with app.run("localhost", 5000):
+            with self.subTest(url=url):
+
+                async def do_request(url):
+                    async with aiohttp.ClientSession(
+                        trace_configs=trace_configs,
+                    ) as session:
+                        async with session.request("NONSTANDARD", url):
+                            pass
+
+                loop = asyncio.get_event_loop()
+                loop.run_until_complete(do_request(url))
+
+        self.assert_spans(
+            [
+                (
+                    "HTTP",
+                    (StatusCode.ERROR, None),
+                    {
+                        SpanAttributes.HTTP_METHOD: "_OTHER",
+                        SpanAttributes.HTTP_URL: url,
+                        SpanAttributes.HTTP_STATUS_CODE: int(
+                            HTTPStatus.METHOD_NOT_ALLOWED
+                        ),
+                    },
+                )
+            ]
+        )
+        self.memory_exporter.clear()
+
+    def test_nonstandard_http_method_new_semconv(self):
+        trace_configs = [
+            aiohttp_client.create_trace_config(
+                sem_conv_opt_in_mode=_HTTPStabilityMode.HTTP
+            )
+        ]
+        app = HttpServerMock("nonstandard_method")
+
+        @app.route("/status/200", methods=["NONSTANDARD"])
+        def index():
+            return ("", 405, {})
+
+        url = "http://localhost:5000/status/200"
+
+        with app.run("localhost", 5000):
+            with self.subTest(url=url):
+
+                async def do_request(url):
+                    async with aiohttp.ClientSession(
+                        trace_configs=trace_configs,
+                    ) as session:
+                        async with session.request("NONSTANDARD", url):
+                            pass
+
+                loop = asyncio.get_event_loop()
+                loop.run_until_complete(do_request(url))
+
+        self.assert_spans(
+            [
+                (
+                    "HTTP",
+                    (StatusCode.ERROR, None),
+                    {
+                        HTTP_REQUEST_METHOD: "_OTHER",
+                        URL_FULL: url,
+                        HTTP_RESPONSE_STATUS_CODE: int(
+                            HTTPStatus.METHOD_NOT_ALLOWED
+                        ),
+                        HTTP_REQUEST_METHOD_ORIGINAL: "NONSTANDARD",
+                        ERROR_TYPE: "405",
+                    },
+                )
+            ]
+        )
+        self.memory_exporter.clear()
+
     def test_credential_removal(self):
         trace_configs = [aiohttp_client.create_trace_config()]
 
@@ -379,6 +638,7 @@ class TestAioHttpClientInstrumentor(TestBase):
     def setUp(self):
         super().setUp()
         AioHttpClientInstrumentor().instrument()
+        _OpenTelemetrySemanticConventionStability._initialized = False
 
     def tearDown(self):
         super().tearDown()
@@ -419,6 +679,46 @@ class TestAioHttpClientInstrumentor(TestBase):
         )
         self.assertEqual(200, span.attributes[SpanAttributes.HTTP_STATUS_CODE])
 
+    def test_instrument_new_semconv(self):
+        AioHttpClientInstrumentor().uninstrument()
+        with mock.patch.dict(
+            "os.environ", {OTEL_SEMCONV_STABILITY_OPT_IN: "http"}
+        ):
+            AioHttpClientInstrumentor().instrument()
+            host, port = run_with_test_server(
+                self.get_default_request(), self.URL, self.default_handler
+            )
+            span = self.assert_spans(1)
+            self.assertEqual("GET", span.name)
+            self.assertEqual("GET", span.attributes[HTTP_REQUEST_METHOD])
+            self.assertEqual(
+                f"http://{host}:{port}/test-path",
+                span.attributes[URL_FULL],
+            )
+            self.assertEqual(200, span.attributes[HTTP_RESPONSE_STATUS_CODE])
+
+    def test_instrument_both_semconv(self):
+        AioHttpClientInstrumentor().uninstrument()
+        with mock.patch.dict(
+            "os.environ", {OTEL_SEMCONV_STABILITY_OPT_IN: "http/dup"}
+        ):
+            AioHttpClientInstrumentor().instrument()
+            host, port = run_with_test_server(
+                self.get_default_request(), self.URL, self.default_handler
+            )
+            url = f"http://{host}:{port}/test-path"
+            attributes = {
+                HTTP_REQUEST_METHOD: "GET",
+                SpanAttributes.HTTP_METHOD: "GET",
+                URL_FULL: url,
+                SpanAttributes.HTTP_URL: url,
+                HTTP_RESPONSE_STATUS_CODE: 200,
+                SpanAttributes.HTTP_STATUS_CODE: 200,
+            }
+            span = self.assert_spans(1)
+            self.assertEqual("GET", span.name)
+            self.assertEqual(span.attributes, attributes)
+
     def test_instrument_with_custom_trace_config(self):
         trace_config = aiohttp.TraceConfig()