opentelemetry-instrumentation-aiohttp-client 0.54b0__tar.gz → 0.55b0__tar.gz

{opentelemetry_instrumentation_aiohttp_client-0.54b0 → opentelemetry_instrumentation_aiohttp_client-0.55b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-aiohttp-client
-Version: 0.54b0
+Version: 0.55b0
 Summary: OpenTelemetry aiohttp client instrumentation
 Project-URL: Homepage, https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation/opentelemetry-instrumentation-aiohttp-client
 Project-URL: Repository, https://github.com/open-telemetry/opentelemetry-python-contrib
@@ -12,17 +12,16 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-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
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Requires-Dist: opentelemetry-api~=1.12
-Requires-Dist: opentelemetry-instrumentation==0.54b0
-Requires-Dist: opentelemetry-semantic-conventions==0.54b0
-Requires-Dist: opentelemetry-util-http==0.54b0
+Requires-Dist: opentelemetry-instrumentation==0.55b0
+Requires-Dist: opentelemetry-semantic-conventions==0.55b0
+Requires-Dist: opentelemetry-util-http==0.55b0
 Requires-Dist: wrapt<2.0.0,>=1.0.0
 Provides-Extra: instruments
 Requires-Dist: aiohttp~=3.0; extra == 'instruments'

{opentelemetry_instrumentation_aiohttp_client-0.54b0 → opentelemetry_instrumentation_aiohttp_client-0.55b0}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 description = "OpenTelemetry aiohttp client instrumentation"
 readme = "README.rst"
 license = "Apache-2.0"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 authors = [
   { name = "OpenTelemetry Authors", email = "cncf-opentelemetry-contributors@lists.cncf.io" },
 ]
@@ -18,7 +18,6 @@ classifiers = [
   "License :: OSI Approved :: Apache Software License",
   "Programming Language :: Python",
   "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
@@ -27,9 +26,9 @@ classifiers = [
 ]
 dependencies = [
   "opentelemetry-api ~= 1.12",
-  "opentelemetry-instrumentation == 0.54b0",
-  "opentelemetry-semantic-conventions == 0.54b0",
-  "opentelemetry-util-http == 0.54b0",
+  "opentelemetry-instrumentation == 0.55b0",
+  "opentelemetry-semantic-conventions == 0.55b0",
+  "opentelemetry-util-http == 0.55b0",
   "wrapt >= 1.0.0, < 2.0.0",
 ]
 

{opentelemetry_instrumentation_aiohttp_client-0.54b0 → opentelemetry_instrumentation_aiohttp_client-0.55b0}/src/opentelemetry/instrumentation/aiohttp_client/__init__.py

@@ -90,7 +90,9 @@ API
 
 import types
 import typing
+from timeit import default_timer
 from typing import Collection
+from urllib.parse import urlparse
 
 import aiohttp
 import wrapt
@@ -99,11 +101,20 @@ import yarl
 from opentelemetry import context as context_api
 from opentelemetry import trace
 from opentelemetry.instrumentation._semconv import (
+    HTTP_DURATION_HISTOGRAM_BUCKETS_NEW,
+    HTTP_DURATION_HISTOGRAM_BUCKETS_OLD,
+    _client_duration_attrs_new,
+    _client_duration_attrs_old,
+    _filter_semconv_duration_attrs,
     _get_schema_url,
     _OpenTelemetrySemanticConventionStability,
     _OpenTelemetryStabilitySignalType,
     _report_new,
+    _report_old,
+    _set_http_host_client,
     _set_http_method,
+    _set_http_net_peer_name_client,
+    _set_http_peer_port_client,
     _set_http_url,
     _set_status,
     _StabilityMode,
@@ -115,8 +126,13 @@ from opentelemetry.instrumentation.utils import (
     is_instrumentation_enabled,
     unwrap,
 )
+from opentelemetry.metrics import MeterProvider, get_meter
 from opentelemetry.propagate import inject
 from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
+from opentelemetry.semconv.metrics import MetricInstruments
+from opentelemetry.semconv.metrics.http_metrics import (
+    HTTP_CLIENT_REQUEST_DURATION,
+)
 from opentelemetry.trace import Span, SpanKind, TracerProvider, get_tracer
 from opentelemetry.trace.status import Status, StatusCode
 from opentelemetry.util.http import remove_url_credentials, sanitize_method
@@ -172,11 +188,14 @@ def _set_http_status_code_attribute(
     )
 
 
+# pylint: disable=too-many-locals
+# pylint: disable=too-many-statements
 def create_trace_config(
     url_filter: _UrlFilterT = None,
     request_hook: _RequestHookT = None,
     response_hook: _ResponseHookT = None,
     tracer_provider: TracerProvider = None,
+    meter_provider: MeterProvider = None,
     sem_conv_opt_in_mode: _StabilityMode = _StabilityMode.DEFAULT,
 ) -> aiohttp.TraceConfig:
     """Create an aiohttp-compatible trace configuration.
@@ -205,6 +224,7 @@ def create_trace_config(
     :param Callable request_hook: Optional callback that can modify span name and request params.
     :param Callable response_hook: Optional callback that can modify span name and response params.
     :param tracer_provider: optional TracerProvider from which to get a Tracer
+    :param meter_provider: optional Meter provider to use
 
     :return: An object suitable for use with :py:class:`aiohttp.ClientSession`.
     :rtype: :py:class:`aiohttp.TraceConfig`
@@ -214,20 +234,70 @@ def create_trace_config(
     # Explicitly specify the type for the `request_hook` and `response_hook` param and rtype to work
     # around this issue.
 
+    schema_url = _get_schema_url(sem_conv_opt_in_mode)
+
     tracer = get_tracer(
         __name__,
         __version__,
         tracer_provider,
-        schema_url=_get_schema_url(sem_conv_opt_in_mode),
+        schema_url=schema_url,
+    )
+
+    meter = get_meter(
+        __name__,
+        __version__,
+        meter_provider,
+        schema_url,
     )
 
-    # TODO: Use this when we have durations for aiohttp-client
+    start_time = 0
+
+    duration_histogram_old = None
+    if _report_old(sem_conv_opt_in_mode):
+        duration_histogram_old = meter.create_histogram(
+            name=MetricInstruments.HTTP_CLIENT_DURATION,
+            unit="ms",
+            description="measures the duration of the outbound HTTP request",
+            explicit_bucket_boundaries_advisory=HTTP_DURATION_HISTOGRAM_BUCKETS_OLD,
+        )
+    duration_histogram_new = None
+    if _report_new(sem_conv_opt_in_mode):
+        duration_histogram_new = meter.create_histogram(
+            name=HTTP_CLIENT_REQUEST_DURATION,
+            unit="s",
+            description="Duration of HTTP client requests.",
+            explicit_bucket_boundaries_advisory=HTTP_DURATION_HISTOGRAM_BUCKETS_NEW,
+        )
+
     metric_attributes = {}
 
     def _end_trace(trace_config_ctx: types.SimpleNamespace):
+        elapsed_time = max(default_timer() - trace_config_ctx.start_time, 0)
         context_api.detach(trace_config_ctx.token)
         trace_config_ctx.span.end()
 
+        if trace_config_ctx.duration_histogram_old is not None:
+            duration_attrs_old = _filter_semconv_duration_attrs(
+                metric_attributes,
+                _client_duration_attrs_old,
+                _client_duration_attrs_new,
+                _StabilityMode.DEFAULT,
+            )
+            trace_config_ctx.duration_histogram_old.record(
+                max(round(elapsed_time * 1000), 0),
+                attributes=duration_attrs_old,
+            )
+        if trace_config_ctx.duration_histogram_new is not None:
+            duration_attrs_new = _filter_semconv_duration_attrs(
+                metric_attributes,
+                _client_duration_attrs_old,
+                _client_duration_attrs_new,
+                _StabilityMode.HTTP,
+            )
+            trace_config_ctx.duration_histogram_new.record(
+                elapsed_time, attributes=duration_attrs_new
+            )
+
     async def on_request_start(
         unused_session: aiohttp.ClientSession,
         trace_config_ctx: types.SimpleNamespace,
@@ -237,6 +307,7 @@ def create_trace_config(
             trace_config_ctx.span = None
             return
 
+        trace_config_ctx.start_time = default_timer()
         method = params.method
         request_span_name = _get_span_name(method)
         request_url = (
@@ -252,8 +323,44 @@ def create_trace_config(
             sanitize_method(method),
             sem_conv_opt_in_mode,
         )
+        _set_http_method(
+            metric_attributes,
+            method,
+            sanitize_method(method),
+            sem_conv_opt_in_mode,
+        )
         _set_http_url(span_attributes, request_url, sem_conv_opt_in_mode)
 
+        try:
+            parsed_url = urlparse(request_url)
+            if parsed_url.hostname:
+                _set_http_host_client(
+                    metric_attributes,
+                    parsed_url.hostname,
+                    sem_conv_opt_in_mode,
+                )
+                _set_http_net_peer_name_client(
+                    metric_attributes,
+                    parsed_url.hostname,
+                    sem_conv_opt_in_mode,
+                )
+                if _report_new(sem_conv_opt_in_mode):
+                    _set_http_host_client(
+                        span_attributes,
+                        parsed_url.hostname,
+                        sem_conv_opt_in_mode,
+                    )
+            if parsed_url.port:
+                _set_http_peer_port_client(
+                    metric_attributes, parsed_url.port, sem_conv_opt_in_mode
+                )
+                if _report_new(sem_conv_opt_in_mode):
+                    _set_http_peer_port_client(
+                        span_attributes, parsed_url.port, sem_conv_opt_in_mode
+                    )
+        except ValueError:
+            pass
+
         trace_config_ctx.span = trace_config_ctx.tracer.start_span(
             request_span_name, kind=SpanKind.CLIENT, attributes=span_attributes
         )
@@ -298,6 +405,7 @@ def create_trace_config(
             exc_type = type(params.exception).__qualname__
             if _report_new(sem_conv_opt_in_mode):
                 trace_config_ctx.span.set_attribute(ERROR_TYPE, exc_type)
+                metric_attributes[ERROR_TYPE] = exc_type
 
             trace_config_ctx.span.set_status(
                 Status(StatusCode.ERROR, exc_type)
@@ -312,7 +420,12 @@ def create_trace_config(
     def _trace_config_ctx_factory(**kwargs):
         kwargs.setdefault("trace_request_ctx", {})
         return types.SimpleNamespace(
-            tracer=tracer, url_filter=url_filter, **kwargs
+            tracer=tracer,
+            url_filter=url_filter,
+            start_time=start_time,
+            duration_histogram_old=duration_histogram_old,
+            duration_histogram_new=duration_histogram_new,
+            **kwargs,
         )
 
     trace_config = aiohttp.TraceConfig(
@@ -328,6 +441,7 @@ def create_trace_config(
 
 def _instrument(
     tracer_provider: TracerProvider = None,
+    meter_provider: MeterProvider = None,
     url_filter: _UrlFilterT = None,
     request_hook: _RequestHookT = None,
     response_hook: _ResponseHookT = None,
@@ -357,6 +471,7 @@ def _instrument(
             request_hook=request_hook,
             response_hook=response_hook,
             tracer_provider=tracer_provider,
+            meter_provider=meter_provider,
             sem_conv_opt_in_mode=sem_conv_opt_in_mode,
         )
         trace_config._is_instrumented_by_opentelemetry = True
@@ -401,6 +516,7 @@ class AioHttpClientInstrumentor(BaseInstrumentor):
         Args:
             **kwargs: Optional arguments
                 ``tracer_provider``: a TracerProvider, defaults to global
+                ``meter_provider``: a MeterProvider, defaults to global
                 ``url_filter``: A callback to process the requested URL prior to adding
                     it as a span attribute. This can be useful to remove sensitive data
                     such as API keys or user personal information.
@@ -415,6 +531,7 @@ class AioHttpClientInstrumentor(BaseInstrumentor):
         )
         _instrument(
             tracer_provider=kwargs.get("tracer_provider"),
+            meter_provider=kwargs.get("meter_provider"),
             url_filter=kwargs.get("url_filter"),
             request_hook=kwargs.get("request_hook"),
             response_hook=kwargs.get("response_hook"),

{opentelemetry_instrumentation_aiohttp_client-0.54b0 → opentelemetry_instrumentation_aiohttp_client-0.55b0}/src/opentelemetry/instrumentation/aiohttp_client/package.py

@@ -15,6 +15,6 @@
 
 _instruments = ("aiohttp ~= 3.0",)
 
-_supports_metrics = False
+_supports_metrics = True
 
 _semconv_status = "migration"

{opentelemetry_instrumentation_aiohttp_client-0.54b0 → opentelemetry_instrumentation_aiohttp_client-0.55b0}/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.54b0"
+__version__ = "0.55b0"

{opentelemetry_instrumentation_aiohttp_client-0.54b0 → opentelemetry_instrumentation_aiohttp_client-0.55b0}/tests/test_aiohttp_client_integration.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# pylint: disable=too-many-lines
+
 import asyncio
 import contextlib
 import typing
@@ -28,6 +30,8 @@ from http_server_mock import HttpServerMock
 from opentelemetry import trace as trace_api
 from opentelemetry.instrumentation import aiohttp_client
 from opentelemetry.instrumentation._semconv import (
+    HTTP_DURATION_HISTOGRAM_BUCKETS_NEW,
+    HTTP_DURATION_HISTOGRAM_BUCKETS_OLD,
     OTEL_SEMCONV_STABILITY_OPT_IN,
     _OpenTelemetrySemanticConventionStability,
     _StabilityMode,
@@ -36,6 +40,20 @@ from opentelemetry.instrumentation.aiohttp_client import (
     AioHttpClientInstrumentor,
 )
 from opentelemetry.instrumentation.utils import suppress_instrumentation
+from opentelemetry.semconv._incubating.attributes.http_attributes import (
+    HTTP_HOST,
+    HTTP_METHOD,
+    HTTP_STATUS_CODE,
+    HTTP_URL,
+)
+from opentelemetry.semconv._incubating.attributes.net_attributes import (
+    NET_PEER_NAME,
+    NET_PEER_PORT,
+)
+from opentelemetry.semconv._incubating.attributes.server_attributes import (
+    SERVER_ADDRESS,
+    SERVER_PORT,
+)
 from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
 from opentelemetry.semconv.attributes.http_attributes import (
     HTTP_REQUEST_METHOD,
@@ -43,7 +61,6 @@ from opentelemetry.semconv.attributes.http_attributes import (
     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
@@ -84,7 +101,7 @@ class TestAioHttpIntegration(TestBase):
         super().setUp()
         _OpenTelemetrySemanticConventionStability._initialized = False
 
-    def assert_spans(self, spans, num_spans=1):
+    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(
@@ -99,6 +116,11 @@ class TestAioHttpIntegration(TestBase):
             spans,
         )
 
+    def _assert_metrics(self, num_metrics: int = 1):
+        metrics = self.get_sorted_metrics()
+        self.assertEqual(len(metrics), num_metrics)
+        return metrics
+
     @staticmethod
     def _http_request(
         trace_config,
@@ -126,6 +148,7 @@ class TestAioHttpIntegration(TestBase):
         return run_with_test_server(client_request, url, handler)
 
     def test_status_codes(self):
+        index = 0
         for status_code, span_status in self._test_status_codes:
             with self.subTest(status_code=status_code):
                 path = "test-path?query=param#foobar"
@@ -136,15 +159,34 @@ class TestAioHttpIntegration(TestBase):
                 )
                 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)
+                self._assert_spans(spans)
                 self.memory_exporter.clear()
+                metrics = self._assert_metrics(1)
+                duration_data_point = metrics[0].data.data_points[index]
+                self.assertEqual(
+                    dict(duration_data_point.attributes),
+                    {
+                        HTTP_STATUS_CODE: status_code,
+                        HTTP_METHOD: "GET",
+                        HTTP_HOST: host,
+                        NET_PEER_NAME: host,
+                        NET_PEER_PORT: port,
+                    },
+                )
+                self.assertEqual(
+                    duration_data_point.explicit_bounds,
+                    HTTP_DURATION_HISTOGRAM_BUCKETS_OLD,
+                )
+                index += 1
 
     def test_status_codes_new_semconv(self):
+        index = 0
         for status_code, span_status in self._test_status_codes:
             with self.subTest(status_code=status_code):
                 path = "test-path?query=param#foobar"
@@ -160,14 +202,39 @@ class TestAioHttpIntegration(TestBase):
                     HTTP_REQUEST_METHOD: "GET",
                     URL_FULL: url,
                     HTTP_RESPONSE_STATUS_CODE: status_code,
+                    SERVER_ADDRESS: host,
+                    SERVER_PORT: port,
                 }
                 if status_code >= 400:
                     attributes[ERROR_TYPE] = str(status_code.value)
                 spans = [("GET", (span_status, None), attributes)]
-                self.assert_spans(spans)
+                self._assert_spans(spans)
                 self.memory_exporter.clear()
+                metrics = self._assert_metrics(1)
+                duration_data_point = metrics[0].data.data_points[index]
+                self.assertEqual(
+                    duration_data_point.attributes.get(
+                        HTTP_RESPONSE_STATUS_CODE
+                    ),
+                    status_code,
+                )
+                self.assertEqual(
+                    duration_data_point.attributes.get(HTTP_REQUEST_METHOD),
+                    "GET",
+                )
+                if status_code >= 400:
+                    self.assertEqual(
+                        duration_data_point.attributes.get(ERROR_TYPE),
+                        str(status_code.value),
+                    )
+                self.assertEqual(
+                    duration_data_point.explicit_bounds,
+                    HTTP_DURATION_HISTOGRAM_BUCKETS_NEW,
+                )
+                index += 1
 
     def test_status_codes_both_semconv(self):
+        index = 0
         for status_code, span_status in self._test_status_codes:
             with self.subTest(status_code=status_code):
                 path = "test-path?query=param#foobar"
@@ -181,18 +248,79 @@ class TestAioHttpIntegration(TestBase):
                 url = f"http://{host}:{port}/{path}"
                 attributes = {
                     HTTP_REQUEST_METHOD: "GET",
-                    SpanAttributes.HTTP_METHOD: "GET",
+                    HTTP_METHOD: "GET",
+                    HTTP_HOST: host,
                     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,
+                    SERVER_ADDRESS: host,
+                    SERVER_PORT: port,
+                    NET_PEER_PORT: port,
                 }
+
                 if status_code >= 400:
                     attributes[ERROR_TYPE] = str(status_code.value)
 
                 spans = [("GET", (span_status, None), attributes)]
-                self.assert_spans(spans, 1)
+                self._assert_spans(spans, 1)
                 self.memory_exporter.clear()
+                metrics = self._assert_metrics(2)
+                duration_data_point = metrics[0].data.data_points[index]
+                self.assertEqual(
+                    duration_data_point.attributes.get(HTTP_STATUS_CODE),
+                    status_code,
+                )
+                self.assertEqual(
+                    duration_data_point.attributes.get(HTTP_METHOD),
+                    "GET",
+                )
+                self.assertEqual(
+                    duration_data_point.attributes.get(ERROR_TYPE),
+                    None,
+                )
+                duration_data_point = metrics[1].data.data_points[index]
+                self.assertEqual(
+                    duration_data_point.attributes.get(
+                        HTTP_RESPONSE_STATUS_CODE
+                    ),
+                    status_code,
+                )
+                self.assertEqual(
+                    duration_data_point.attributes.get(HTTP_REQUEST_METHOD),
+                    "GET",
+                )
+                if status_code >= 400:
+                    self.assertEqual(
+                        duration_data_point.attributes.get(ERROR_TYPE),
+                        str(status_code.value),
+                    )
+                index += 1
+
+    def test_metrics(self):
+        with self.subTest(status_code=200):
+            host, port = self._http_request(
+                trace_config=aiohttp_client.create_trace_config(),
+                url="/test-path?query=param#foobar",
+                status_code=200,
+            )
+            metrics = self._assert_metrics(1)
+            self.assertEqual(len(metrics[0].data.data_points), 1)
+            duration_data_point = metrics[0].data.data_points[0]
+            self.assertEqual(
+                dict(metrics[0].data.data_points[0].attributes),
+                {
+                    HTTP_STATUS_CODE: 200,
+                    HTTP_METHOD: "GET",
+                    HTTP_HOST: host,
+                    NET_PEER_NAME: host,
+                    NET_PEER_PORT: port,
+                },
+            )
+            self.assertEqual(duration_data_point.count, 1)
+            self.assertTrue(duration_data_point.min > 0)
+            self.assertTrue(duration_data_point.max > 0)
+            self.assertTrue(duration_data_point.sum > 0)
 
     def test_schema_url(self):
         with self.subTest(status_code=200):
@@ -292,16 +420,12 @@ class TestAioHttpIntegration(TestBase):
                 (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()
@@ -319,15 +443,15 @@ class TestAioHttpIntegration(TestBase):
             status_code=HTTPStatus.OK,
         )
 
-        self.assert_spans(
+        self._assert_spans(
             [
                 (
                     "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),
                     },
                 )
             ]
@@ -353,14 +477,14 @@ class TestAioHttpIntegration(TestBase):
                 with self.assertRaises(aiohttp.ClientConnectorError):
                     loop.run_until_complete(do_request(url))
 
-            self.assert_spans(
+            self._assert_spans(
                 [
                     (
                         "GET",
                         (expected_status, "ClientConnectorError"),
                         {
-                            SpanAttributes.HTTP_METHOD: "GET",
-                            SpanAttributes.HTTP_URL: url,
+                            HTTP_METHOD: "GET",
+                            HTTP_URL: url,
                         },
                     )
                 ]
@@ -379,18 +503,29 @@ class TestAioHttpIntegration(TestBase):
         span = self.memory_exporter.get_finished_spans()[0]
         self.assertEqual(len(span.events), 1)
         self.assertEqual(span.events[0].name, "exception")
-        self.assert_spans(
+        self._assert_spans(
             [
                 (
                     "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",
                     },
                 )
             ]
         )
+        metrics = self._assert_metrics(1)
+        duration_data_point = metrics[0].data.data_points[0]
+        self.assertEqual(
+            dict(duration_data_point.attributes),
+            {
+                HTTP_METHOD: "GET",
+                HTTP_HOST: host,
+                NET_PEER_NAME: host,
+                NET_PEER_PORT: port,
+            },
+        )
 
     def test_basic_exception_new_semconv(self):
         async def request_handler(request):
@@ -406,7 +541,7 @@ class TestAioHttpIntegration(TestBase):
         span = self.memory_exporter.get_finished_spans()[0]
         self.assertEqual(len(span.events), 1)
         self.assertEqual(span.events[0].name, "exception")
-        self.assert_spans(
+        self._assert_spans(
             [
                 (
                     "GET",
@@ -415,10 +550,23 @@ class TestAioHttpIntegration(TestBase):
                         HTTP_REQUEST_METHOD: "GET",
                         URL_FULL: f"http://{host}:{port}/test",
                         ERROR_TYPE: "ServerDisconnectedError",
+                        SERVER_ADDRESS: host,
+                        SERVER_PORT: port,
                     },
                 )
             ]
         )
+        metrics = self._assert_metrics(1)
+        duration_data_point = metrics[0].data.data_points[0]
+        self.assertEqual(
+            dict(duration_data_point.attributes),
+            {
+                HTTP_REQUEST_METHOD: "GET",
+                ERROR_TYPE: "ServerDisconnectedError",
+                SERVER_ADDRESS: host,
+                SERVER_PORT: port,
+            },
+        )
 
     def test_basic_exception_both_semconv(self):
         async def request_handler(request):
@@ -434,7 +582,7 @@ class TestAioHttpIntegration(TestBase):
         span = self.memory_exporter.get_finished_spans()[0]
         self.assertEqual(len(span.events), 1)
         self.assertEqual(span.events[0].name, "exception")
-        self.assert_spans(
+        self._assert_spans(
             [
                 (
                     "GET",
@@ -443,12 +591,37 @@ class TestAioHttpIntegration(TestBase):
                         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",
+                        HTTP_HOST: host,
+                        SERVER_ADDRESS: host,
+                        SERVER_PORT: port,
+                        NET_PEER_PORT: port,
                     },
                 )
             ]
         )
+        metrics = self._assert_metrics(2)
+        duration_data_point = metrics[0].data.data_points[0]
+        self.assertEqual(
+            dict(duration_data_point.attributes),
+            {
+                HTTP_METHOD: "GET",
+                HTTP_HOST: host,
+                NET_PEER_NAME: host,
+                NET_PEER_PORT: port,
+            },
+        )
+        duration_data_point = metrics[1].data.data_points[0]
+        self.assertEqual(
+            dict(duration_data_point.attributes),
+            {
+                HTTP_REQUEST_METHOD: "GET",
+                ERROR_TYPE: "ServerDisconnectedError",
+                SERVER_ADDRESS: host,
+                SERVER_PORT: port,
+            },
+        )
 
     def test_timeout(self):
         async def request_handler(request):
@@ -463,14 +636,14 @@ class TestAioHttpIntegration(TestBase):
             timeout=aiohttp.ClientTimeout(sock_read=0.01),
         )
 
-        self.assert_spans(
+        self._assert_spans(
             [
                 (
                     "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",
                     },
                 )
             ]
@@ -490,14 +663,14 @@ class TestAioHttpIntegration(TestBase):
             max_redirects=2,
         )
 
-        self.assert_spans(
+        self._assert_spans(
             [
                 (
                     "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",
                     },
                 )
             ]
@@ -526,17 +699,15 @@ class TestAioHttpIntegration(TestBase):
                 loop = asyncio.get_event_loop()
                 loop.run_until_complete(do_request(url))
 
-        self.assert_spans(
+        self._assert_spans(
             [
                 (
                     "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),
                     },
                 )
             ]
@@ -570,7 +741,7 @@ class TestAioHttpIntegration(TestBase):
                 loop = asyncio.get_event_loop()
                 loop.run_until_complete(do_request(url))
 
-        self.assert_spans(
+        self._assert_spans(
             [
                 (
                     "HTTP",
@@ -583,6 +754,8 @@ class TestAioHttpIntegration(TestBase):
                         ),
                         HTTP_REQUEST_METHOD_ORIGINAL: "NONSTANDARD",
                         ERROR_TYPE: "405",
+                        SERVER_ADDRESS: "localhost",
+                        SERVER_PORT: 5000,
                     },
                 )
             ]
@@ -613,17 +786,15 @@ class TestAioHttpIntegration(TestBase):
                 loop = asyncio.get_event_loop()
                 loop.run_until_complete(do_request(url))
 
-        self.assert_spans(
+        self._assert_spans(
             [
                 (
                     "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),
                     },
                 )
             ]
@@ -656,7 +827,7 @@ class TestAioHttpClientInstrumentor(TestBase):
 
         return default_request
 
-    def assert_spans(self, num_spans: int):
+    def _assert_spans(self, num_spans: int):
         finished_spans = self.memory_exporter.get_finished_spans()
         self.assertEqual(num_spans, len(finished_spans))
         if num_spans == 0:
@@ -665,18 +836,36 @@ class TestAioHttpClientInstrumentor(TestBase):
             return finished_spans[0]
         return finished_spans
 
+    def _assert_metrics(self, num_metrics: int = 1):
+        metrics = self.get_sorted_metrics()
+        self.assertEqual(len(metrics), num_metrics)
+        return metrics
+
     def test_instrument(self):
         host, port = run_with_test_server(
             self.get_default_request(), self.URL, self.default_handler
         )
-        span = self.assert_spans(1)
+        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[HTTP_STATUS_CODE])
+        metrics = self._assert_metrics(1)
+        duration_data_point = metrics[0].data.data_points[0]
+        self.assertEqual(duration_data_point.count, 1)
+        self.assertEqual(
+            dict(duration_data_point.attributes),
+            {
+                HTTP_HOST: host,
+                HTTP_STATUS_CODE: 200,
+                HTTP_METHOD: "GET",
+                NET_PEER_NAME: host,
+                NET_PEER_PORT: port,
+            },
         )
-        self.assertEqual(200, span.attributes[SpanAttributes.HTTP_STATUS_CODE])
 
     def test_instrument_new_semconv(self):
         AioHttpClientInstrumentor().uninstrument()
@@ -687,7 +876,7 @@ class TestAioHttpClientInstrumentor(TestBase):
             host, port = run_with_test_server(
                 self.get_default_request(), self.URL, self.default_handler
             )
-            span = self.assert_spans(1)
+            span = self._assert_spans(1)
             self.assertEqual("GET", span.name)
             self.assertEqual("GET", span.attributes[HTTP_REQUEST_METHOD])
             self.assertEqual(
@@ -695,6 +884,18 @@ class TestAioHttpClientInstrumentor(TestBase):
                 span.attributes[URL_FULL],
             )
             self.assertEqual(200, span.attributes[HTTP_RESPONSE_STATUS_CODE])
+            metrics = self._assert_metrics(1)
+            duration_data_point = metrics[0].data.data_points[0]
+            self.assertEqual(duration_data_point.count, 1)
+            self.assertEqual(
+                dict(duration_data_point.attributes),
+                {
+                    HTTP_RESPONSE_STATUS_CODE: 200,
+                    HTTP_REQUEST_METHOD: "GET",
+                    SERVER_ADDRESS: host,
+                    SERVER_PORT: port,
+                },
+            )
 
     def test_instrument_both_semconv(self):
         AioHttpClientInstrumentor().uninstrument()
@@ -706,17 +907,47 @@ class TestAioHttpClientInstrumentor(TestBase):
                 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)
+            span = self._assert_spans(1)
             self.assertEqual("GET", span.name)
-            self.assertEqual(span.attributes, attributes)
+            self.assertEqual(
+                dict(span.attributes),
+                {
+                    HTTP_REQUEST_METHOD: "GET",
+                    HTTP_METHOD: "GET",
+                    HTTP_HOST: host,
+                    URL_FULL: url,
+                    HTTP_URL: url,
+                    HTTP_RESPONSE_STATUS_CODE: 200,
+                    HTTP_STATUS_CODE: 200,
+                    SERVER_ADDRESS: host,
+                    SERVER_PORT: port,
+                    NET_PEER_PORT: port,
+                },
+            )
+            metrics = self._assert_metrics(2)
+            duration_data_point = metrics[0].data.data_points[0]
+            self.assertEqual(duration_data_point.count, 1)
+            self.assertEqual(
+                dict(duration_data_point.attributes),
+                {
+                    HTTP_STATUS_CODE: 200,
+                    HTTP_METHOD: "GET",
+                    HTTP_HOST: host,
+                    NET_PEER_NAME: host,
+                    NET_PEER_PORT: port,
+                },
+            )
+            duration_data_point = metrics[1].data.data_points[0]
+            self.assertEqual(duration_data_point.count, 1)
+            self.assertEqual(
+                dict(duration_data_point.attributes),
+                {
+                    HTTP_RESPONSE_STATUS_CODE: 200,
+                    HTTP_REQUEST_METHOD: "GET",
+                    SERVER_ADDRESS: host,
+                    SERVER_PORT: port,
+                },
+            )
 
     def test_instrument_with_custom_trace_config(self):
         trace_config = aiohttp.TraceConfig()
@@ -733,7 +964,7 @@ class TestAioHttpClientInstrumentor(TestBase):
                     await session.get(TestAioHttpClientInstrumentor.URL)
 
         run_with_test_server(make_request, self.URL, self.default_handler)
-        self.assert_spans(1)
+        self._assert_spans(1)
 
     def test_every_request_by_new_session_creates_one_span(self):
         async def make_request(server: aiohttp.test_utils.TestServer):
@@ -747,7 +978,7 @@ class TestAioHttpClientInstrumentor(TestBase):
                 run_with_test_server(
                     make_request, self.URL, self.default_handler
                 )
-                self.assert_spans(1)
+                self._assert_spans(1)
 
     def test_instrument_with_existing_trace_config(self):
         trace_config = aiohttp.TraceConfig()
@@ -764,7 +995,7 @@ class TestAioHttpClientInstrumentor(TestBase):
                     await session.get(TestAioHttpClientInstrumentor.URL)
 
         run_with_test_server(create_session, self.URL, self.default_handler)
-        self.assert_spans(1)
+        self._assert_spans(1)
 
     def test_no_op_tracer_provider(self):
         AioHttpClientInstrumentor().uninstrument()
@@ -784,13 +1015,13 @@ class TestAioHttpClientInstrumentor(TestBase):
             self.get_default_request(), self.URL, self.default_handler
         )
 
-        self.assert_spans(0)
+        self._assert_spans(0)
 
         AioHttpClientInstrumentor().instrument()
         run_with_test_server(
             self.get_default_request(), self.URL, self.default_handler
         )
-        self.assert_spans(1)
+        self._assert_spans(1)
 
     def test_uninstrument_session(self):
         async def uninstrument_request(server: aiohttp.test_utils.TestServer):
@@ -802,19 +1033,19 @@ class TestAioHttpClientInstrumentor(TestBase):
         run_with_test_server(
             uninstrument_request, self.URL, self.default_handler
         )
-        self.assert_spans(0)
+        self._assert_spans(0)
 
         run_with_test_server(
             self.get_default_request(), self.URL, self.default_handler
         )
-        self.assert_spans(1)
+        self._assert_spans(1)
 
     def test_suppress_instrumentation(self):
         with suppress_instrumentation():
             run_with_test_server(
                 self.get_default_request(), self.URL, self.default_handler
             )
-        self.assert_spans(0)
+        self._assert_spans(0)
 
     @staticmethod
     async def suppressed_request(server: aiohttp.test_utils.TestServer):
@@ -826,7 +1057,7 @@ class TestAioHttpClientInstrumentor(TestBase):
         run_with_test_server(
             self.suppressed_request, self.URL, self.default_handler
         )
-        self.assert_spans(0)
+        self._assert_spans(0)
 
     def test_suppress_instrumentation_with_server_exception(self):
         # pylint:disable=unused-argument
@@ -836,7 +1067,7 @@ class TestAioHttpClientInstrumentor(TestBase):
         run_with_test_server(
             self.suppressed_request, self.URL, raising_handler
         )
-        self.assert_spans(0)
+        self._assert_spans(0)
 
     def test_url_filter(self):
         def strip_query_params(url: yarl.URL) -> str:
@@ -849,10 +1080,10 @@ class TestAioHttpClientInstrumentor(TestBase):
         host, port = run_with_test_server(
             self.get_default_request(url), url, self.default_handler
         )
-        span = self.assert_spans(1)
+        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):
@@ -877,7 +1108,7 @@ class TestAioHttpClientInstrumentor(TestBase):
         run_with_test_server(
             self.get_default_request(url), url, self.default_handler
         )
-        span = self.assert_spans(1)
+        span = self._assert_spans(1)
         self.assertEqual("GET - /test-path", span.name)
         self.assertIn("response_hook_attr", span.attributes)
         self.assertEqual(span.attributes["response_hook_attr"], "value")