Restoring metrics in requests

CHANGELOG.md

@@ -14,11 +14,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   ([1109](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1109))
 - cleanup type hints for textmap `Getter` and `Setter` classes
   ([1106](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1106))
-  
+
 ### Added
 - `opentelemetry-instrumentation-remoulade` Initial release
   ([#1082](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1082))
 
+- `opentelemetry-instrumentation-requests` Restoring metrics in requests
+  ([1110](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1110)
 ### Added
 - Added `opentelemetry-instrumention-confluent-kafka`
   ([#1111](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1111))

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

@@ -50,7 +50,9 @@
 
 import functools
 import types
+from time import time
 from typing import Collection
+from urllib.parse import urlparse
 
 from requests.models import Response
 from requests.sessions import Session
@@ -64,6 +66,7 @@
     _SUPPRESS_INSTRUMENTATION_KEY,
     http_status_to_status_code,
 )
+from opentelemetry.metrics import get_meter
 from opentelemetry.propagate import inject
 from opentelemetry.semconv.trace import SpanAttributes
 from opentelemetry.trace import SpanKind, get_tracer
@@ -87,7 +90,11 @@
 # pylint: disable=unused-argument
 # pylint: disable=R0915
 def _instrument(
-    tracer, span_callback=None, name_callback=None, excluded_urls=None
+    tracer,
+    span_callback=None,
+    name_callback=None,
+    excluded_urls=None,
+    metric_recorder=None,
 ):
     """Enables tracing of all requests calls that go through
     :code:`requests.session.Session.request` (this includes
@@ -143,6 +150,7 @@ def call_wrapped():
             request.method, request.url, call_wrapped, get_or_create_headers
         )
 
+    # pylint: disable-msg=too-many-locals,too-many-branches
     def _instrumented_requests_call(
         method: str, url: str, call_wrapped, get_or_create_headers
     ):
@@ -167,6 +175,18 @@ def _instrumented_requests_call(
             SpanAttributes.HTTP_URL: url,
         }
 
+        metric_labels = {
+            "http.method": method,
+            "http.url": url,
+        }
+
+        try:
+            parsed_url = urlparse(url)
+            metric_labels["http.host"] = parsed_url.hostname
+            metric_labels["http.scheme"] = parsed_url.scheme
+        except ValueError:
+            pass
+
         with tracer.start_as_current_span(
             span_name, kind=SpanKind.CLIENT, attributes=span_attributes
         ) as span, set_ip_on_next_http_connection(span):
@@ -178,6 +198,9 @@ def _instrumented_requests_call(
             token = context.attach(
                 context.set_value(_SUPPRESS_HTTP_INSTRUMENTATION_KEY, True)
             )
+
+            start_time = time()
+
             try:
                 result = call_wrapped()  # *** PROCEED
             except Exception as exc:  # pylint: disable=W0703
@@ -194,9 +217,25 @@ def _instrumented_requests_call(
                     span.set_status(
                         Status(http_status_to_status_code(result.status_code))
                     )
+
+                metric_labels["http.status_code"] = result.status_code
+
+                if result.raw is not None:
+                    version = getattr(result.raw, "version", None)
+                    if version:
+                        metric_labels["http.flavor"] = (
+                            "1.1" if version == 11 else "1.0"
+                        )
+
             if span_callback is not None:
                 span_callback(span, result)
 
+            elapsed_time = time() - start_time
+
+            metric_recorder.record(
+                elapsed_time * 1000, attributes=metric_labels
+            )
+
             if exception is not None:
                 raise exception.with_traceback(exception.__traceback__)
 
@@ -261,13 +300,25 @@ def _instrument(self, **kwargs):
         tracer_provider = kwargs.get("tracer_provider")
         tracer = get_tracer(__name__, __version__, tracer_provider)
         excluded_urls = kwargs.get("excluded_urls")
+        meter_provider = kwargs.get("meter_provider")
+        meter = get_meter(
+            __name__,
+            __version__,
+            meter_provider,
+        )
+        metric_recorder = meter.create_histogram(
+            name="http.client.duration",
+            unit="ms",
+            description="measures the duration of the outbound HTTP request",
+        )
         _instrument(
             tracer,
             span_callback=kwargs.get("span_callback"),
             name_callback=kwargs.get("name_callback"),
             excluded_urls=_excluded_urls_from_env
             if excluded_urls is None
             else parse_excluded_urls(excluded_urls),
+            metric_recorder=metric_recorder,
         )
 
     def _uninstrument(self, **kwargs):

instrumentation/opentelemetry-instrumentation-requests/tests/test_requests_integration.py

@@ -26,6 +26,8 @@
 from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
 from opentelemetry.propagate import get_global_textmap, set_global_textmap
 from opentelemetry.sdk import resources
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import InMemoryMetricReader
 from opentelemetry.semconv.trace import SpanAttributes
 from opentelemetry.test.mock_textmap import MockTextMapPropagator
 from opentelemetry.test.test_base import TestBase
@@ -472,3 +474,49 @@ def perform_request(url: str, session: requests.Session = None):
         request = requests.Request("GET", url)
         prepared_request = session.prepare_request(request)
         return session.send(prepared_request)
+
+
+class TestRequestsIntergrationMetric(TestBase):
+    URL = "http://httpbin.org/status/200"
+
+    def setUp(self):
+        super().setUp()
+        self.reader = InMemoryMetricReader()
+        self.meter_provider = MeterProvider(metric_readers=[self.reader])
+        RequestsInstrumentor().instrument(meter_provider=self.meter_provider)
+
+        httpretty.enable()
+        httpretty.register_uri(httpretty.GET, self.URL, body="Hello!")
+
+    def tearDown(self):
+        super().tearDown()
+        RequestsInstrumentor().uninstrument()
+        httpretty.disable()
+
+    @staticmethod
+    def perform_request(url: str) -> requests.Response:
+        return requests.get(url)
+
+    def test_basic_http_success(self):
+        self.perform_request(self.URL)
+
+        expected_attributes = {
+            "http.status_code": 200,
+            "http.url": self.URL,
+            "http.host": "httpbin.org",
+            "http.method": "GET",
+            "http.flavor": "1.1",
+            "http.scheme": "http",
+        }
+
+        for (
+            resource_metrics
+        ) in self.reader.get_metrics_data().resource_metrics:
+            for scope_metrics in resource_metrics.scope_metrics:
+                for metric in scope_metrics.metrics:
+                    for data_point in metric.data.data_points:
+                        print(dict(data_point.attributes))
+                        self.assertDictEqual(
+                            expected_attributes, dict(data_point.attributes)
+                        )
+                        self.assertEqual(data_point.count, 1)