diff --git a/instrumentation/opentelemetry-instrumentation-tornado/tests/test_metrics_instrumentation.py b/instrumentation/opentelemetry-instrumentation-tornado/tests/test_metrics_instrumentation.py index fe0302a475..f155f004ed 100644 --- a/instrumentation/opentelemetry-instrumentation-tornado/tests/test_metrics_instrumentation.py +++ b/instrumentation/opentelemetry-instrumentation-tornado/tests/test_metrics_instrumentation.py @@ -22,7 +22,6 @@ class TestTornadoInstrumentor(TornadoTest): - # Return Sequence with one histogram def create_histogram_data_points(self, sum_data_point, attributes): return [ diff --git a/instrumentation/opentelemetry-instrumentation-urllib3/tests/test_urllib3_ip_support.py b/instrumentation/opentelemetry-instrumentation-urllib3/tests/test_urllib3_ip_support.py index d47cd8f1ea..5baddee516 100644 --- a/instrumentation/opentelemetry-instrumentation-urllib3/tests/test_urllib3_ip_support.py +++ b/instrumentation/opentelemetry-instrumentation-urllib3/tests/test_urllib3_ip_support.py @@ -12,11 +12,8 @@ # See the License for the specific language governing permissions and # limitations under the License. -from timeit import default_timer - import urllib3 import urllib3.exceptions -from urllib3.request import encode_multipart_formdata from opentelemetry import trace from opentelemetry.instrumentation.urllib3 import URLLib3Instrumentor @@ -87,136 +84,3 @@ def assert_success_span( "net.peer.ip": self.assert_ip, } self.assertGreaterEqual(span.attributes.items(), attributes.items()) - - -class TestURLLib3InstrumentorMetric(HttpTestBase, TestBase): - def setUp(self): - super().setUp() - self.assert_ip = self.server.server_address[0] - self.assert_port = self.server.server_address[1] - self.http_host = ":".join(map(str, self.server.server_address[:2])) - self.http_url_base = "http://" + self.http_host - self.http_url = self.http_url_base + "/status/200" - URLLib3Instrumentor().instrument(meter_provider=self.meter_provider) - - def tearDown(self): - super().tearDown() - URLLib3Instrumentor().uninstrument() - - def test_metric_uninstrument(self): - with urllib3.PoolManager() as pool: - pool.request("GET", self.http_url) - URLLib3Instrumentor().uninstrument() - pool.request("GET", self.http_url) - - metrics_list = self.memory_metrics_reader.get_metrics_data() - for resource_metric in metrics_list.resource_metrics: - for scope_metric in resource_metric.scope_metrics: - for metric in scope_metric.metrics: - for point in list(metric.data.data_points): - self.assertEqual(point.count, 1) - - def test_basic_metric_check_client_size_get(self): - with urllib3.PoolManager() as pool: - start_time = default_timer() - response = pool.request("GET", self.http_url) - client_duration_estimated = (default_timer() - start_time) * 1000 - - expected_attributes = { - "http.status_code": 200, - "http.host": self.assert_ip, - "http.method": "GET", - "http.flavor": "1.1", - "http.scheme": "http", - "net.peer.name": self.assert_ip, - "net.peer.port": self.assert_port, - } - expected_data = { - "http.client.request.size": 0, - "http.client.response.size": len(response.data), - } - expected_metrics = [ - "http.client.duration", - "http.client.request.size", - "http.client.response.size", - ] - - resource_metrics = ( - self.memory_metrics_reader.get_metrics_data().resource_metrics - ) - for metrics in resource_metrics: - for scope_metrics in metrics.scope_metrics: - self.assertEqual(len(scope_metrics.metrics), 3) - for metric in scope_metrics.metrics: - for data_point in metric.data.data_points: - if metric.name in expected_data: - self.assertEqual( - data_point.sum, expected_data[metric.name] - ) - if metric.name == "http.client.duration": - self.assertAlmostEqual( - data_point.sum, - client_duration_estimated, - delta=1000, - ) - self.assertIn(metric.name, expected_metrics) - self.assertDictEqual( - expected_attributes, - dict(data_point.attributes), - ) - self.assertEqual(data_point.count, 1) - - def test_basic_metric_check_client_size_post(self): - with urllib3.PoolManager() as pool: - start_time = default_timer() - data_fields = {"data": "test"} - response = pool.request("POST", self.http_url, fields=data_fields) - client_duration_estimated = (default_timer() - start_time) * 1000 - - expected_attributes = { - "http.status_code": 501, - "http.host": self.assert_ip, - "http.method": "POST", - "http.flavor": "1.1", - "http.scheme": "http", - "net.peer.name": self.assert_ip, - "net.peer.port": self.assert_port, - } - - body = encode_multipart_formdata(data_fields)[0] - - expected_data = { - "http.client.request.size": len(body), - "http.client.response.size": len(response.data), - } - expected_metrics = [ - "http.client.duration", - "http.client.request.size", - "http.client.response.size", - ] - - resource_metrics = ( - self.memory_metrics_reader.get_metrics_data().resource_metrics - ) - for metrics in resource_metrics: - for scope_metrics in metrics.scope_metrics: - self.assertEqual(len(scope_metrics.metrics), 3) - for metric in scope_metrics.metrics: - for data_point in metric.data.data_points: - if metric.name in expected_data: - self.assertEqual( - data_point.sum, expected_data[metric.name] - ) - if metric.name == "http.client.duration": - self.assertAlmostEqual( - data_point.sum, - client_duration_estimated, - delta=1000, - ) - self.assertIn(metric.name, expected_metrics) - - self.assertDictEqual( - expected_attributes, - dict(data_point.attributes), - ) - self.assertEqual(data_point.count, 1) diff --git a/instrumentation/opentelemetry-instrumentation-urllib3/tests/test_urllib3_metrics.py b/instrumentation/opentelemetry-instrumentation-urllib3/tests/test_urllib3_metrics.py new file mode 100644 index 0000000000..d5ba3a6393 --- /dev/null +++ b/instrumentation/opentelemetry-instrumentation-urllib3/tests/test_urllib3_metrics.py @@ -0,0 +1,203 @@ +# Copyright The OpenTelemetry Authors +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from timeit import default_timer + +import urllib3 +import urllib3.exceptions +from urllib3.request import encode_multipart_formdata + +from opentelemetry.instrumentation.urllib3 import URLLib3Instrumentor +from opentelemetry.test.httptest import HttpTestBase +from opentelemetry.test.test_base import TestBase + + +class TestURLLib3InstrumentorMetric(HttpTestBase, TestBase): + def setUp(self): + super().setUp() + self.assert_ip = self.server.server_address[0] + self.assert_port = self.server.server_address[1] + self.http_host = ":".join(map(str, self.server.server_address[:2])) + self.http_url_base = "http://" + self.http_host + self.http_url = self.http_url_base + "/status/200" + URLLib3Instrumentor().instrument(meter_provider=self.meter_provider) + + def tearDown(self): + super().tearDown() + URLLib3Instrumentor().uninstrument() + + # Return Sequence with one histogram + def create_histogram_data_points(self, sum_data_point, attributes): + return [ + self.create_histogram_data_point( + sum_data_point, 1, sum_data_point, sum_data_point, attributes + ) + ] + + def test_basic_metric_check_client_size_get(self): + with urllib3.PoolManager() as pool: + start_time = default_timer() + response = pool.request("GET", self.http_url) + client_duration_estimated = (default_timer() - start_time) * 1000 + + metrics = self.get_sorted_metrics() + + ( + client_duration, + client_request_size, + client_response_size, + ) = metrics + + self.assertEqual(client_duration.name, "http.client.duration") + self.assert_metric_expected( + client_duration, + self.create_histogram_data_points( + client_duration_estimated, + attributes={ + "http.status_code": 200, + "http.host": self.assert_ip, + "http.method": "GET", + "http.flavor": "1.1", + "http.scheme": "http", + "net.peer.name": self.assert_ip, + "net.peer.port": self.assert_port, + }, + ), + est_value_delta=200, + ) + + self.assertEqual( + client_request_size.name, "http.client.request.size" + ) + self.assert_metric_expected( + client_request_size, + self.create_histogram_data_points( + 0, + attributes={ + "http.status_code": 200, + "http.host": self.assert_ip, + "http.method": "GET", + "http.flavor": "1.1", + "http.scheme": "http", + "net.peer.name": self.assert_ip, + "net.peer.port": self.assert_port, + }, + ), + ) + + self.assertEqual( + client_response_size.name, "http.client.response.size" + ) + self.assert_metric_expected( + client_response_size, + self.create_histogram_data_points( + len(response.data), + attributes={ + "http.status_code": 200, + "http.host": self.assert_ip, + "http.method": "GET", + "http.flavor": "1.1", + "http.scheme": "http", + "net.peer.name": self.assert_ip, + "net.peer.port": self.assert_port, + }, + ), + ) + + def test_basic_metric_check_client_size_post(self): + with urllib3.PoolManager() as pool: + start_time = default_timer() + data_fields = {"data": "test"} + response = pool.request("POST", self.http_url, fields=data_fields) + client_duration_estimated = (default_timer() - start_time) * 1000 + body = encode_multipart_formdata(data_fields)[0] + + metrics = self.get_sorted_metrics() + + ( + client_duration, + client_request_size, + client_response_size, + ) = metrics + + self.assertEqual(client_duration.name, "http.client.duration") + self.assert_metric_expected( + client_duration, + self.create_histogram_data_points( + client_duration_estimated, + attributes={ + "http.status_code": 501, + "http.host": self.assert_ip, + "http.method": "POST", + "http.flavor": "1.1", + "http.scheme": "http", + "net.peer.name": self.assert_ip, + "net.peer.port": self.assert_port, + }, + ), + est_value_delta=200, + ) + + self.assertEqual( + client_request_size.name, "http.client.request.size" + ) + client_request_size_expected = len(body) + self.assert_metric_expected( + client_request_size, + self.create_histogram_data_points( + client_request_size_expected, + attributes={ + "http.status_code": 501, + "http.host": self.assert_ip, + "http.method": "POST", + "http.flavor": "1.1", + "http.scheme": "http", + "net.peer.name": self.assert_ip, + "net.peer.port": self.assert_port, + }, + ), + ) + + self.assertEqual( + client_response_size.name, "http.client.response.size" + ) + client_response_size_expected = len(response.data) + self.assert_metric_expected( + client_response_size, + self.create_histogram_data_points( + client_response_size_expected, + attributes={ + "http.status_code": 501, + "http.host": self.assert_ip, + "http.method": "POST", + "http.flavor": "1.1", + "http.scheme": "http", + "net.peer.name": self.assert_ip, + "net.peer.port": self.assert_port, + }, + ), + ) + + def test_metric_uninstrument(self): + with urllib3.PoolManager() as pool: + pool.request("GET", self.http_url) + URLLib3Instrumentor().uninstrument() + pool.request("GET", self.http_url) + + metrics = self.get_sorted_metrics() + self.assertEqual(len(metrics), 3) + + for metric in metrics: + for point in list(metric.data.data_points): + self.assertEqual(point.count, 1)