Add client instrumentation

Author: sroda

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

@@ -236,29 +236,45 @@ def _instrument(self, **kwargs):
         self.tracer = trace.get_tracer(__name__, __version__, tracer_provider)
 
         meter_provider = kwargs.get("meter_provider")
-        self.meter = get_meter(__name__, __version__, meter_provider)
+        meter = get_meter(__name__, __version__, meter_provider)
 
-        self.duration_histogram = self.meter.create_histogram(
+        self.duration_histogram = meter.create_histogram(
             name="http.server.duration",
             unit="ms",
             description="measures the duration outbound HTTP requests",
         )
-        self.request_size_histogram = self.meter.create_histogram(
+        self.request_size_histogram = meter.create_histogram(
             name="http.server.request.size",
             unit="By",
             description="measures the size of HTTP request messages (compressed)",
         )
-        self.response_size_histogram = self.meter.create_histogram(
+        self.response_size_histogram = meter.create_histogram(
             name="http.server.response.size",
             unit="By",
             description="measures the size of HTTP response messages (compressed)",
         )
-        self.active_requests_histogram = self.meter.create_up_down_counter(
+        self.active_requests_histogram = meter.create_up_down_counter(
             name="http.server.active_requests",
             unit="requests",
             description="measures the number of concurrent HTTP requests that are currently in-flight",
         )
 
+        client_duration_histogram = meter.create_histogram(
+            name="http.client.duration",
+            unit="ms",
+            description="measures the duration outbound HTTP requests",
+        )
+        client_request_size_histogram = meter.create_histogram(
+            name="http.client.request.size",
+            unit="By",
+            description="measures the size of HTTP request messages (compressed)",
+        )
+        client_response_size_histogram = meter.create_histogram(
+            name="http.client.response.size",
+            unit="By",
+            description="measures the size of HTTP response messages (compressed)",
+        )
+
         client_request_hook = kwargs.get("client_request_hook", None)
         client_response_hook = kwargs.get("client_response_hook", None)
         server_request_hook = kwargs.get("server_request_hook", None)
@@ -280,7 +296,9 @@ def handler_init(init, handler, args, kwargs):
                 self.tracer,
                 client_request_hook,
                 client_response_hook,
-                self.response_size_histogram,
+                client_duration_histogram,
+                client_request_size_histogram,
+                client_response_size_histogram,
             ),
         )
 
@@ -520,7 +538,12 @@ def _record_prepare_metrics(instrumentation, handler):
 def _record_on_finish_metrics(instrumentation, handler):
     elapsed_time = round((default_timer() - instrumentation.start_time) * 1000)
 
+    response_size = int(handler._headers.get("Content-Length", 0))
     metric_attributes = _create_metric_attributes(handler)
+    instrumentation.response_size_histogram.record(
+        response_size, attributes=metric_attributes
+    )
+
     instrumentation.duration_histogram.record(
         elapsed_time, attributes=metric_attributes
     )
@@ -539,6 +562,7 @@ def _create_active_requests_attributes(request):
         SpanAttributes.HTTP_SCHEME: request.protocol,
         SpanAttributes.HTTP_FLAVOR: request.version,
         SpanAttributes.HTTP_HOST: request.host,
+        SpanAttributes.HTTP_TARGET: request.path,
     }
 
     return metric_attributes

instrumentation/opentelemetry-instrumentation-tornado/src/opentelemetry/instrumentation/tornado/client.py

@@ -45,6 +45,8 @@ def fetch_async(
     tracer,
     request_hook,
     response_hook,
+    duration_histogram,
+    request_size_histogram,
     response_size_histogram,
     func,
     _,
@@ -87,19 +89,28 @@ def fetch_async(
                 _finish_tracing_callback,
                 span=span,
                 response_hook=response_hook,
+                duration_histogram=duration_histogram,
+                request_size_histogram=request_size_histogram,
                 response_size_histogram=response_size_histogram,
             )
         )
         return future
 
 
 def _finish_tracing_callback(
-    future, span, response_hook, response_size_histogram
+    future,
+    span,
+    response_hook,
+    duration_histogram,
+    request_size_histogram,
+    response_size_histogram,
 ):
     status_code = None
     description = None
     exc = future.exception()
+
     response = future.result()
+
     if span.is_recording() and exc:
         if isinstance(exc, HTTPError):
             status_code = exc.code
@@ -115,9 +126,15 @@ def _finish_tracing_callback(
                 description=description,
             )
         )
+
     metric_attributes = _create_metric_attributes(response)
-    response_size = int(response.headers["Content-Length"])
+    request_size = int(response.request.headers.get("Content-Length", 0))
+    response_size = int(response.headers.get("Content-Length", 0))
 
+    duration_histogram.record(
+        response.request_time, attributes=metric_attributes
+    )
+    request_size_histogram.record(request_size, attributes=metric_attributes)
     response_size_histogram.record(response_size, attributes=metric_attributes)
 
     if response_hook:

instrumentation/opentelemetry-instrumentation-tornado/tests/test_metrics_instrumentation.py

@@ -19,7 +19,10 @@
 
 from opentelemetry import trace
 from opentelemetry.instrumentation.tornado import TornadoInstrumentor
-from opentelemetry.sdk.metrics.export import HistogramDataPoint
+from opentelemetry.sdk.metrics.export import (
+    HistogramDataPoint,
+    NumberDataPoint,
+)
 from opentelemetry.test.test_base import TestBase
 
 from .tornado_test_app import make_app
@@ -51,13 +54,43 @@ def sorted_metrics(metrics):
             key=lambda m: m.name,
         )
 
-    def assertMetricHasAttributes(self, metric, expected_attributes):
-        for data_point in metric.data.data_points:
-            self.assertDictEqual(
-                expected_attributes,
-                dict(data_point.attributes),
+    def assertMetricExpected(
+        self, metric, expected_value, expected_attributes
+    ):
+        data_point = next(metric.data.data_points)
+
+        if isinstance(data_point, HistogramDataPoint):
+            self.assertEqual(
+                data_point.sum,
+                expected_value,
+            )
+        elif isinstance(data_point, NumberDataPoint):
+            self.assertEqual(
+                data_point.value,
+                expected_value,
             )
 
+        self.assertDictEqual(
+            expected_attributes,
+            dict(data_point.attributes),
+        )
+
+    def assertDurationMetricExpected(
+        self, metric, duration_estimated, expected_attributes
+    ):
+        data_point = next(metric.data.data_points)
+
+        self.assertAlmostEqual(
+            data_point.sum,
+            duration_estimated,
+            delta=200,
+        )
+
+        self.assertDictEqual(
+            expected_attributes,
+            dict(data_point.attributes),
+        )
+
     def setUp(self):
         super().setUp()
         TornadoInstrumentor().instrument(
@@ -79,57 +112,112 @@ def test_basic_metrics(self):
         client_duration_estimated = (default_timer() - start_time) * 1000
 
         metrics = self.get_sorted_metrics()
-        self.assertEqual(len(metrics), 4)
-        active_request, duration, request_size, response_size = metrics
-
-        self.assertEqual(active_request.name, "http.server.active_requests")
-        self.assertMetricHasAttributes(
-            active_request,
+        self.assertEqual(len(metrics), 7)
+
+        (
+            client_duration,
+            client_request_size,
+            client_response_size,
+        ) = metrics[:3]
+
+        (
+            server_active_request,
+            server_duration,
+            server_request_size,
+            server_response_size,
+        ) = metrics[3:]
+
+        self.assertEqual(
+            server_active_request.name, "http.server.active_requests"
+        )
+        self.assertMetricExpected(
+            server_active_request,
+            0,
             {
                 "http.method": "GET",
                 "http.flavor": "HTTP/1.1",
                 "http.scheme": "http",
+                "http.target": "/",
                 "http.host": response.request.headers["host"],
             },
         )
 
-        self.assertEqual(duration.name, "http.server.duration")
-        data_point = list(duration.data.data_points)[0]
-        self.assertAlmostEqual(
-            data_point.sum,
+        self.assertEqual(server_duration.name, "http.server.duration")
+        self.assertDurationMetricExpected(
+            server_duration,
             client_duration_estimated,
-            delta=200,
-        )
-        self.assertMetricHasAttributes(
-            duration,
             {
-                "http.status_code": 201,
+                "http.status_code": response.code,
                 "http.method": "GET",
                 "http.flavor": "HTTP/1.1",
                 "http.scheme": "http",
+                "http.target": "/",
                 "http.host": response.request.headers["host"],
             },
         )
 
-        self.assertEqual(request_size.name, "http.server.request.size")
-        self.assertMetricHasAttributes(
-            request_size,
+        self.assertEqual(server_request_size.name, "http.server.request.size")
+        self.assertMetricExpected(
+            server_request_size,
+            0,
             {
                 "http.status_code": 200,
                 "http.method": "GET",
                 "http.flavor": "HTTP/1.1",
                 "http.scheme": "http",
+                "http.target": "/",
                 "http.host": response.request.headers["host"],
             },
         )
 
-        self.assertEqual(response_size.name, "http.server.response.size")
-        self.assertMetricHasAttributes(
-            response_size,
+        self.assertEqual(
+            server_response_size.name, "http.server.response.size"
+        )
+        self.assertMetricExpected(
+            server_response_size,
+            len(response.body),
+            {
+                "http.status_code": response.code,
+                "http.method": "GET",
+                "http.flavor": "HTTP/1.1",
+                "http.scheme": "http",
+                "http.target": "/",
+                "http.host": response.request.headers["host"],
+            },
+        )
+
+        self.assertEqual(client_duration.name, "http.client.duration")
+        self.assertDurationMetricExpected(
+            client_duration,
+            client_duration_estimated,
+            {
+                "http.status_code": response.code,
+                "http.method": "GET",
+                "http.url": response.effective_url,
+            },
+        )
+
+        self.assertEqual(client_request_size.name, "http.client.request.size")
+        self.assertMetricExpected(
+            client_request_size,
+            0,
+            {
+                "http.status_code": response.code,
+                "http.method": "GET",
+                "http.url": response.effective_url,
+            },
+        )
+
+        self.assertEqual(
+            client_response_size.name, "http.client.response.size"
+        )
+        self.assertMetricExpected(
+            client_response_size,
+            len(response.body),
             {
                 "http.status_code": response.code,
                 "http.method": "GET",
-                "http.url": self.get_url("/"),
+                "http.url": response.effective_url,
             },
         )