From 08db974e262d33c6cb36643826ca1f0966bec517 Mon Sep 17 00:00:00 2001 From: Srikanth Chekuri Date: Wed, 21 Sep 2022 22:32:08 +0530 Subject: [PATCH] =?UTF-8?q?Revert=20"updated=20to=20remove=20directions=20?= =?UTF-8?q?from=20existing=20metrics.=20tests=20updated=20to=20=E2=80=A6?= =?UTF-8?q?=20(#1213)"=20(#1346)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 270b73f55c32cdfad2a208fed06fb08f555cb4a7. --- CHANGELOG.md | 2 - .../system_metrics/__init__.py | 411 ++++++---------- .../tests/test_system_metrics.py | 442 ++++-------------- 3 files changed, 234 insertions(+), 621 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3629cf1e5..99892765b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -46,8 +46,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ([#1206](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1206)) - Add psycopg2 native tags to sqlcommenter ([#1203](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1203)) -- Deprecation of direction attribute for metrics. Addition of direction based metric names - ([#1214](https://github.com/open-telemetry/opentelemetry-python-contrib/pull/1214)) ### Added - `opentelemetry-instrumentation-redis` add support to instrument RedisCluster clients diff --git a/instrumentation/opentelemetry-instrumentation-system-metrics/src/opentelemetry/instrumentation/system_metrics/__init__.py b/instrumentation/opentelemetry-instrumentation-system-metrics/src/opentelemetry/instrumentation/system_metrics/__init__.py index d0cd10739..1c7c90a3d 100644 --- a/instrumentation/opentelemetry-instrumentation-system-metrics/src/opentelemetry/instrumentation/system_metrics/__init__.py +++ b/instrumentation/opentelemetry-instrumentation-system-metrics/src/opentelemetry/instrumentation/system_metrics/__init__.py @@ -25,24 +25,16 @@ following metrics are configured: "system.memory.utilization": ["used", "free", "cached"], "system.swap.usage": ["used", "free"], "system.swap.utilization": ["used", "free"], - "system.disk.io.read": None, - "system.disk.io.write": None, - "system.disk.operations.read": None, - "system.disk.operations.write": None, - "system.disk.operation_time.read": None, - "system.disk.operation_time.write": None, - "system.network.dropped.transmit": None, - "system.network.dropped.receive": None, - "system.network.packets.transmit": None, - "system.network.packets.receive": None, - "system.network.errors.transmit": None, - "system.network.errors.receive": None, - "system.network.io.transmit": None, - "system.network.io.receive": None, + "system.disk.io": ["read", "write"], + "system.disk.operations": ["read", "write"], + "system.disk.time": ["read", "write"], + "system.network.dropped.packets": ["transmit", "receive"], + "system.network.packets": ["transmit", "receive"], + "system.network.errors": ["transmit", "receive"], + "system.network.io": ["transmit", "receive"], "system.network.connections": ["family", "type"], "runtime.memory": ["rss", "vms"], "runtime.cpu.time": ["user", "system"], - "runtime.gc_count": None } Usage @@ -67,8 +59,7 @@ Usage configuration = { "system.memory.usage": ["used", "free", "cached"], "system.cpu.time": ["idle", "user", "system", "irq"], - "system.network.io.transmit": None, - "system.network.io.receive": None, + "system.network.io": ["transmit", "receive"], "runtime.memory": ["rss", "vms"], "runtime.cpu.time": ["user", "system"], } @@ -100,20 +91,13 @@ _DEFAULT_CONFIG = { "system.memory.utilization": ["used", "free", "cached"], "system.swap.usage": ["used", "free"], "system.swap.utilization": ["used", "free"], - "system.disk.io.read": None, - "system.disk.io.write": None, - "system.disk.operations.read": None, - "system.disk.operations.write": None, - "system.disk.operation_time.read": None, - "system.disk.operation_time.write": None, - "system.network.dropped.transmit": None, - "system.network.dropped.receive": None, - "system.network.packets.transmit": None, - "system.network.packets.receive": None, - "system.network.errors.transmit": None, - "system.network.errors.receive": None, - "system.network.io.transmit": None, - "system.network.io.receive": None, + "system.disk.io": ["read", "write"], + "system.disk.operations": ["read", "write"], + "system.disk.time": ["read", "write"], + "system.network.dropped.packets": ["transmit", "receive"], + "system.network.packets": ["transmit", "receive"], + "system.network.errors": ["transmit", "receive"], + "system.network.io": ["transmit", "receive"], "system.network.connections": ["family", "type"], "runtime.memory": ["rss", "vms"], "runtime.cpu.time": ["user", "system"], @@ -147,22 +131,15 @@ class SystemMetricsInstrumentor(BaseInstrumentor): self._system_swap_usage_labels = self._labels.copy() self._system_swap_utilization_labels = self._labels.copy() - self._system_disk_io_read_labels = self._labels.copy() - self._system_disk_io_write_labels = self._labels.copy() - self._system_disk_operations_read_labels = self._labels.copy() - self._system_disk_operations_write_labels = self._labels.copy() - self._system_disk_operation_time_read_labels = self._labels.copy() - self._system_disk_operation_time_write_labels = self._labels.copy() + self._system_disk_io_labels = self._labels.copy() + self._system_disk_operations_labels = self._labels.copy() + self._system_disk_time_labels = self._labels.copy() self._system_disk_merged_labels = self._labels.copy() - self._system_network_dropped_transmit_labels = self._labels.copy() - self._system_network_dropped_receive_labels = self._labels.copy() - self._system_network_packets_transmit_labels = self._labels.copy() - self._system_network_packets_receive_labels = self._labels.copy() - self._system_network_errors_transmit_labels = self._labels.copy() - self._system_network_errors_receive_labels = self._labels.copy() - self._system_network_io_transmit_labels = self._labels.copy() - self._system_network_io_receive_labels = self._labels.copy() + self._system_network_dropped_packets_labels = self._labels.copy() + self._system_network_packets_labels = self._labels.copy() + self._system_network_errors_labels = self._labels.copy() + self._system_network_io_labels = self._labels.copy() self._system_network_connections_labels = self._labels.copy() self._runtime_memory_labels = self._labels.copy() @@ -172,7 +149,6 @@ class SystemMetricsInstrumentor(BaseInstrumentor): def instrumentation_dependencies(self) -> Collection[str]: return _instruments - # pylint: disable=too-many-statements def _instrument(self, **kwargs): # pylint: disable=too-many-branches meter_provider = kwargs.get("meter_provider") @@ -249,51 +225,27 @@ class SystemMetricsInstrumentor(BaseInstrumentor): # value_type=int, # ) - if "system.disk.io.read" in self._config: + if "system.disk.io" in self._config: self._meter.create_observable_counter( - name="system.disk.io.read", - callbacks=[self._get_system_disk_io_read], - description="", + name="system.disk.io", + callbacks=[self._get_system_disk_io], + description="System disk IO", unit="bytes", ) - if "system.disk.io.write" in self._config: + if "system.disk.operations" in self._config: self._meter.create_observable_counter( - name="system.disk.io.write", - callbacks=[self._get_system_disk_io_write], - description="", - unit="bytes", - ) - - if "system.disk.operations.read" in self._config: - self._meter.create_observable_counter( - name="system.disk.operations.read", - callbacks=[self._get_system_disk_operations_read], - description="", + name="system.disk.operations", + callbacks=[self._get_system_disk_operations], + description="System disk operations", unit="operations", ) - if "system.disk.operations.write" in self._config: + if "system.disk.time" in self._config: self._meter.create_observable_counter( - name="system.disk.operations.write", - callbacks=[self._get_system_disk_operations_write], - description="", - unit="operations", - ) - - if "system.disk.operation_time.read" in self._config: - self._meter.create_observable_counter( - name="system.disk.operation_time.read", - callbacks=[self._get_system_disk_operation_time_read], - description="Sum of the time each operation took to complete", - unit="seconds", - ) - - if "system.disk.operation_time.write" in self._config: - self._meter.create_observable_counter( - name="system.disk.operation_time.write", - callbacks=[self._get_system_disk_operation_time_write], - description="Sum of the time each operation took to complete", + name="system.disk.time", + callbacks=[self._get_system_disk_time], + description="System disk time", unit="seconds", ) @@ -319,67 +271,35 @@ class SystemMetricsInstrumentor(BaseInstrumentor): # TODO Filesystem information can be obtained with os.statvfs in Unix-like # OSs, how to do the same in Windows? - if "system.network.dropped.transmit" in self._config: + if "system.network.dropped.packets" in self._config: self._meter.create_observable_counter( - name="system.network.dropped.transmit", - callbacks=[self._get_system_network_dropped_transmit], - description="Count of packets that are dropped or discarded on transmit even though there was no error", + name="system.network.dropped_packets", + callbacks=[self._get_system_network_dropped_packets], + description="System network dropped_packets", unit="packets", ) - if "system.network.dropped.receive" in self._config: + if "system.network.packets" in self._config: self._meter.create_observable_counter( - name="system.network.dropped.receive", - callbacks=[self._get_system_network_dropped_receive], - description="Count of packets that are dropped or discarded on receive even though there was no error", + name="system.network.packets", + callbacks=[self._get_system_network_packets], + description="System network packets", unit="packets", ) - if "system.network.packets.transmit" in self._config: + if "system.network.errors" in self._config: self._meter.create_observable_counter( - name="system.network.packets.transmit", - callbacks=[self._get_system_network_packets_transmit], - description="Count of packets transmitted", - unit="packets", - ) - - if "system.network.packets.receive" in self._config: - self._meter.create_observable_counter( - name="system.network.packets.receive", - callbacks=[self._get_system_network_packets_receive], - description="Count of packets received", - unit="packets", - ) - - if "system.network.errors.transmit" in self._config: - self._meter.create_observable_counter( - name="system.network.errors.transmit", - callbacks=[self._get_system_network_errors_transmit], - description="Count of network errors detected on transmit", + name="system.network.errors", + callbacks=[self._get_system_network_errors], + description="System network errors", unit="errors", ) - if "system.network.errors.receive" in self._config: + if "system.network.io" in self._config: self._meter.create_observable_counter( - name="system.network.errors.receive", - callbacks=[self._get_system_network_errors_receive], - description="Count of network errors detected on receive", - unit="errors", - ) - - if "system.network.io.transmit" in self._config: - self._meter.create_observable_counter( - name="system.network.io.transmit", - callbacks=[self._get_system_network_io_transmit], - description="Bytes sent", - unit="bytes", - ) - - if "system.network.io.receive" in self._config: - self._meter.create_observable_counter( - name="system.network.io.receive", - callbacks=[self._get_system_network_io_receive], - description="Bytes received", + name="system.network.io", + callbacks=[self._get_system_network_io], + description="System network io", unit="bytes", ) @@ -504,175 +424,132 @@ class SystemMetricsInstrumentor(BaseInstrumentor): self._system_swap_utilization_labels.copy(), ) - def _get_system_disk_io_read( + def _get_system_disk_io( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for disk IO read""" + """Observer callback for disk IO""" for device, counters in psutil.disk_io_counters(perdisk=True).items(): - if hasattr(counters, "read_bytes"): - self._system_disk_io_read_labels["device"] = device - yield Observation( - getattr(counters, "read_bytes"), - self._system_disk_io_read_labels.copy(), - ) + for metric in self._config["system.disk.io"]: + if hasattr(counters, f"{metric}_bytes"): + self._system_disk_io_labels["device"] = device + self._system_disk_io_labels["direction"] = metric + yield Observation( + getattr(counters, f"{metric}_bytes"), + self._system_disk_io_labels.copy(), + ) - def _get_system_disk_io_write( + def _get_system_disk_operations( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for disk IO write""" + """Observer callback for disk operations""" for device, counters in psutil.disk_io_counters(perdisk=True).items(): - if hasattr(counters, "write_bytes"): - self._system_disk_io_write_labels["device"] = device - yield Observation( - getattr(counters, "write_bytes"), - self._system_disk_io_write_labels.copy(), - ) + for metric in self._config["system.disk.operations"]: + if hasattr(counters, f"{metric}_count"): + self._system_disk_operations_labels["device"] = device + self._system_disk_operations_labels["direction"] = metric + yield Observation( + getattr(counters, f"{metric}_count"), + self._system_disk_operations_labels.copy(), + ) - def _get_system_disk_operations_read( + def _get_system_disk_time( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for disk operations read""" + """Observer callback for disk time""" for device, counters in psutil.disk_io_counters(perdisk=True).items(): - if hasattr(counters, "read_count"): - self._system_disk_operations_read_labels["device"] = device - yield Observation( - getattr(counters, "read_count"), - self._system_disk_operations_read_labels.copy(), - ) + for metric in self._config["system.disk.time"]: + if hasattr(counters, f"{metric}_time"): + self._system_disk_time_labels["device"] = device + self._system_disk_time_labels["direction"] = metric + yield Observation( + getattr(counters, f"{metric}_time") / 1000, + self._system_disk_time_labels.copy(), + ) - def _get_system_disk_operations_write( + def _get_system_disk_merged( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for disk operations write""" + """Observer callback for disk merged operations""" + + # FIXME The units in the spec is 1, it seems like it should be + # operations or the value type should be Double + for device, counters in psutil.disk_io_counters(perdisk=True).items(): - if hasattr(counters, "write_count"): - self._system_disk_operations_write_labels["device"] = device - yield Observation( - getattr(counters, "write_count"), - self._system_disk_operations_write_labels.copy(), - ) + for metric in self._config["system.disk.time"]: + if hasattr(counters, f"{metric}_merged_count"): + self._system_disk_merged_labels["device"] = device + self._system_disk_merged_labels["direction"] = metric + yield Observation( + getattr(counters, f"{metric}_merged_count"), + self._system_disk_merged_labels.copy(), + ) - def _get_system_disk_operation_time_read( + def _get_system_network_dropped_packets( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for disk operation time read""" - for device, counters in psutil.disk_io_counters(perdisk=True).items(): - if hasattr(counters, "read_time"): - self._system_disk_operation_time_read_labels["device"] = device - yield Observation( - getattr(counters, "read_time") / 1000, - self._system_disk_operation_time_read_labels.copy(), - ) + """Observer callback for network dropped packets""" - def _get_system_disk_operation_time_write( - self, options: CallbackOptions - ) -> Iterable[Observation]: - """Observer callback for disk operation time write""" - for device, counters in psutil.disk_io_counters(perdisk=True).items(): - if hasattr(counters, "write_time"): - self._system_disk_operation_time_write_labels[ - "device" - ] = device - yield Observation( - getattr(counters, "write_time") / 1000, - self._system_disk_operation_time_write_labels.copy(), - ) - - def _get_system_network_dropped_transmit( - self, options: CallbackOptions - ) -> Iterable[Observation]: - """Observer callback for network dropped packets transmit""" for device, counters in psutil.net_io_counters(pernic=True).items(): - if hasattr(counters, "dropout"): - self._system_network_dropped_transmit_labels["device"] = device - yield Observation( - getattr(counters, "dropout"), - self._system_network_dropped_transmit_labels.copy(), - ) + for metric in self._config["system.network.dropped.packets"]: + in_out = {"receive": "in", "transmit": "out"}[metric] + if hasattr(counters, f"drop{in_out}"): + self._system_network_dropped_packets_labels[ + "device" + ] = device + self._system_network_dropped_packets_labels[ + "direction" + ] = metric + yield Observation( + getattr(counters, f"drop{in_out}"), + self._system_network_dropped_packets_labels.copy(), + ) - def _get_system_network_dropped_receive( + def _get_system_network_packets( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for network dropped packets receive""" - for device, counters in psutil.net_io_counters(pernic=True).items(): - if hasattr(counters, "dropin"): - self._system_network_dropped_receive_labels["device"] = device - yield Observation( - getattr(counters, "dropin"), - self._system_network_dropped_receive_labels.copy(), - ) + """Observer callback for network packets""" - def _get_system_network_packets_transmit( + for device, counters in psutil.net_io_counters(pernic=True).items(): + for metric in self._config["system.network.dropped.packets"]: + recv_sent = {"receive": "recv", "transmit": "sent"}[metric] + if hasattr(counters, f"packets_{recv_sent}"): + self._system_network_packets_labels["device"] = device + self._system_network_packets_labels["direction"] = metric + yield Observation( + getattr(counters, f"packets_{recv_sent}"), + self._system_network_packets_labels.copy(), + ) + + def _get_system_network_errors( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for network packets transmit""" + """Observer callback for network errors""" for device, counters in psutil.net_io_counters(pernic=True).items(): - if hasattr(counters, "packets_sent"): - self._system_network_packets_transmit_labels["device"] = device - yield Observation( - getattr(counters, "packets_sent"), - self._system_network_packets_transmit_labels.copy(), - ) + for metric in self._config["system.network.errors"]: + in_out = {"receive": "in", "transmit": "out"}[metric] + if hasattr(counters, f"err{in_out}"): + self._system_network_errors_labels["device"] = device + self._system_network_errors_labels["direction"] = metric + yield Observation( + getattr(counters, f"err{in_out}"), + self._system_network_errors_labels.copy(), + ) - def _get_system_network_packets_receive( + def _get_system_network_io( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for network packets receive""" - for device, counters in psutil.net_io_counters(pernic=True).items(): - if hasattr(counters, "packets_recv"): - self._system_network_packets_receive_labels["device"] = device - yield Observation( - getattr(counters, "packets_recv"), - self._system_network_packets_receive_labels.copy(), - ) + """Observer callback for network IO""" - def _get_system_network_errors_transmit( - self, options: CallbackOptions - ) -> Iterable[Observation]: - """Observer callback for network errors transmit""" for device, counters in psutil.net_io_counters(pernic=True).items(): - if hasattr(counters, "errout"): - self._system_network_errors_transmit_labels["device"] = device - yield Observation( - getattr(counters, "errout"), - self._system_network_errors_transmit_labels.copy(), - ) - - def _get_system_network_errors_receive( - self, options: CallbackOptions - ) -> Iterable[Observation]: - """Observer callback for network errors receive""" - for device, counters in psutil.net_io_counters(pernic=True).items(): - if hasattr(counters, "errin"): - self._system_network_errors_receive_labels["device"] = device - yield Observation( - getattr(counters, "errin"), - self._system_network_errors_receive_labels.copy(), - ) - - def _get_system_network_io_transmit( - self, options: CallbackOptions - ) -> Iterable[Observation]: - """Observer callback for network IO transmit""" - for device, counters in psutil.net_io_counters(pernic=True).items(): - if hasattr(counters, "bytes_sent"): - self._system_network_io_transmit_labels["device"] = device - yield Observation( - getattr(counters, "bytes_sent"), - self._system_network_io_transmit_labels.copy(), - ) - - def _get_system_network_io_receive( - self, options: CallbackOptions - ) -> Iterable[Observation]: - """Observer callback for network IO receive""" - for device, counters in psutil.net_io_counters(pernic=True).items(): - if hasattr(counters, "bytes_recv"): - self._system_network_io_receive_labels["device"] = device - yield Observation( - getattr(counters, "bytes_recv"), - self._system_network_io_receive_labels.copy(), - ) + for metric in self._config["system.network.dropped.packets"]: + recv_sent = {"receive": "recv", "transmit": "sent"}[metric] + if hasattr(counters, f"bytes_{recv_sent}"): + self._system_network_io_labels["device"] = device + self._system_network_io_labels["direction"] = metric + yield Observation( + getattr(counters, f"bytes_{recv_sent}"), + self._system_network_io_labels.copy(), + ) def _get_system_network_connections( self, options: CallbackOptions diff --git a/instrumentation/opentelemetry-instrumentation-system-metrics/tests/test_system_metrics.py b/instrumentation/opentelemetry-instrumentation-system-metrics/tests/test_system_metrics.py index dd1ede0b0..04d7674db 100644 --- a/instrumentation/opentelemetry-instrumentation-system-metrics/tests/test_system_metrics.py +++ b/instrumentation/opentelemetry-instrumentation-system-metrics/tests/test_system_metrics.py @@ -51,7 +51,6 @@ class _SystemMetricsResult: self.value = value -# pylint: disable=too-many-public-methods class TestSystemMetrics(TestBase): def setUp(self): super().setUp() @@ -76,7 +75,7 @@ class TestSystemMetrics(TestBase): for scope_metrics in resource_metrics.scope_metrics: for metric in scope_metrics.metrics: metric_names.append(metric.name) - self.assertEqual(len(metric_names), 24) + self.assertEqual(len(metric_names), 17) observer_names = [ "system.cpu.time", @@ -85,20 +84,13 @@ class TestSystemMetrics(TestBase): "system.memory.utilization", "system.swap.usage", "system.swap.utilization", - "system.disk.io.read", - "system.disk.io.write", - "system.disk.operations.read", - "system.disk.operations.write", - "system.disk.operation_time.read", - "system.disk.operation_time.write", - "system.network.dropped.transmit", - "system.network.dropped.receive", - "system.network.packets.transmit", - "system.network.packets.receive", - "system.network.errors.transmit", - "system.network.errors.receive", - "system.network.io.transmit", - "system.network.io.receive", + "system.disk.io", + "system.disk.operations", + "system.disk.time", + "system.network.dropped_packets", + "system.network.packets", + "system.network.errors", + "system.network.io", "system.network.connections", f"runtime.{self.implementation}.memory", f"runtime.{self.implementation}.cpu_time", @@ -286,7 +278,7 @@ class TestSystemMetrics(TestBase): self._test_metrics("system.swap.utilization", expected) @mock.patch("psutil.disk_io_counters") - def test_system_disk_io_read(self, mock_disk_io_counters): + def test_system_disk_io(self, mock_disk_io_counters): DiskIO = namedtuple( "DiskIO", [ @@ -324,13 +316,15 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult({"device": "sda"}, 3), - _SystemMetricsResult({"device": "sdb"}, 11), + _SystemMetricsResult({"device": "sda", "direction": "read"}, 3), + _SystemMetricsResult({"device": "sda", "direction": "write"}, 4), + _SystemMetricsResult({"device": "sdb", "direction": "read"}, 11), + _SystemMetricsResult({"device": "sdb", "direction": "write"}, 12), ] - self._test_metrics("system.disk.io.read", expected) + self._test_metrics("system.disk.io", expected) @mock.patch("psutil.disk_io_counters") - def test_system_disk_io_write(self, mock_disk_io_counters): + def test_system_disk_operations(self, mock_disk_io_counters): DiskIO = namedtuple( "DiskIO", [ @@ -368,13 +362,15 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult({"device": "sda"}, 4), - _SystemMetricsResult({"device": "sdb"}, 12), + _SystemMetricsResult({"device": "sda", "direction": "read"}, 1), + _SystemMetricsResult({"device": "sda", "direction": "write"}, 2), + _SystemMetricsResult({"device": "sdb", "direction": "read"}, 9), + _SystemMetricsResult({"device": "sdb", "direction": "write"}, 10), ] - self._test_metrics("system.disk.io.write", expected) + self._test_metrics("system.disk.operations", expected) @mock.patch("psutil.disk_io_counters") - def test_system_disk_operations_read(self, mock_disk_io_counters): + def test_system_disk_time(self, mock_disk_io_counters): DiskIO = namedtuple( "DiskIO", [ @@ -412,145 +408,23 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult({"device": "sda"}, 1), - _SystemMetricsResult({"device": "sdb"}, 9), + _SystemMetricsResult( + {"device": "sda", "direction": "read"}, 5 / 1000 + ), + _SystemMetricsResult( + {"device": "sda", "direction": "write"}, 6 / 1000 + ), + _SystemMetricsResult( + {"device": "sdb", "direction": "read"}, 13 / 1000 + ), + _SystemMetricsResult( + {"device": "sdb", "direction": "write"}, 14 / 1000 + ), ] - self._test_metrics("system.disk.operations.read", expected) - - @mock.patch("psutil.disk_io_counters") - def test_system_disk_operations_write(self, mock_disk_io_counters): - DiskIO = namedtuple( - "DiskIO", - [ - "read_count", - "write_count", - "read_bytes", - "write_bytes", - "read_time", - "write_time", - "read_merged_count", - "write_merged_count", - ], - ) - mock_disk_io_counters.return_value = { - "sda": DiskIO( - read_count=1, - write_count=2, - read_bytes=3, - write_bytes=4, - read_time=5, - write_time=6, - read_merged_count=7, - write_merged_count=8, - ), - "sdb": DiskIO( - read_count=9, - write_count=10, - read_bytes=11, - write_bytes=12, - read_time=13, - write_time=14, - read_merged_count=15, - write_merged_count=16, - ), - } - - expected = [ - _SystemMetricsResult({"device": "sda"}, 2), - _SystemMetricsResult({"device": "sdb"}, 10), - ] - self._test_metrics("system.disk.operations.write", expected) - - @mock.patch("psutil.disk_io_counters") - def test_system_disk_operation_time_read(self, mock_disk_io_counters): - DiskIO = namedtuple( - "DiskIO", - [ - "read_count", - "write_count", - "read_bytes", - "write_bytes", - "read_time", - "write_time", - "read_merged_count", - "write_merged_count", - ], - ) - mock_disk_io_counters.return_value = { - "sda": DiskIO( - read_count=1, - write_count=2, - read_bytes=3, - write_bytes=4, - read_time=5, - write_time=6, - read_merged_count=7, - write_merged_count=8, - ), - "sdb": DiskIO( - read_count=9, - write_count=10, - read_bytes=11, - write_bytes=12, - read_time=13, - write_time=14, - read_merged_count=15, - write_merged_count=16, - ), - } - - expected = [ - _SystemMetricsResult({"device": "sda"}, 5 / 1000), - _SystemMetricsResult({"device": "sdb"}, 13 / 1000), - ] - self._test_metrics("system.disk.operation_time.read", expected) - - @mock.patch("psutil.disk_io_counters") - def test_system_disk_operation_time_write(self, mock_disk_io_counters): - DiskIO = namedtuple( - "DiskIO", - [ - "read_count", - "write_count", - "read_bytes", - "write_bytes", - "read_time", - "write_time", - "read_merged_count", - "write_merged_count", - ], - ) - mock_disk_io_counters.return_value = { - "sda": DiskIO( - read_count=1, - write_count=2, - read_bytes=3, - write_bytes=4, - read_time=5, - write_time=6, - read_merged_count=7, - write_merged_count=8, - ), - "sdb": DiskIO( - read_count=9, - write_count=10, - read_bytes=11, - write_bytes=12, - read_time=13, - write_time=14, - read_merged_count=15, - write_merged_count=16, - ), - } - - expected = [ - _SystemMetricsResult({"device": "sda"}, 6 / 1000), - _SystemMetricsResult({"device": "sdb"}, 14 / 1000), - ] - self._test_metrics("system.disk.operation_time.write", expected) + self._test_metrics("system.disk.time", expected) @mock.patch("psutil.net_io_counters") - def test_system_network_dropped_transmit(self, mock_net_io_counters): + def test_system_network_dropped_packets(self, mock_net_io_counters): NetIO = namedtuple( "NetIO", [ @@ -588,13 +462,23 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult({"device": "eth0"}, 2), - _SystemMetricsResult({"device": "eth1"}, 10), + _SystemMetricsResult( + {"device": "eth0", "direction": "receive"}, 1 + ), + _SystemMetricsResult( + {"device": "eth0", "direction": "transmit"}, 2 + ), + _SystemMetricsResult( + {"device": "eth1", "direction": "receive"}, 9 + ), + _SystemMetricsResult( + {"device": "eth1", "direction": "transmit"}, 10 + ), ] - self._test_metrics("system.network.dropped.transmit", expected) + self._test_metrics("system.network.dropped_packets", expected) @mock.patch("psutil.net_io_counters") - def test_system_network_dropped_receive(self, mock_net_io_counters): + def test_system_network_packets(self, mock_net_io_counters): NetIO = namedtuple( "NetIO", [ @@ -632,13 +516,23 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult({"device": "eth0"}, 1), - _SystemMetricsResult({"device": "eth1"}, 9), + _SystemMetricsResult( + {"device": "eth0", "direction": "receive"}, 4 + ), + _SystemMetricsResult( + {"device": "eth0", "direction": "transmit"}, 3 + ), + _SystemMetricsResult( + {"device": "eth1", "direction": "receive"}, 12 + ), + _SystemMetricsResult( + {"device": "eth1", "direction": "transmit"}, 11 + ), ] - self._test_metrics("system.network.dropped.receive", expected) + self._test_metrics("system.network.packets", expected) @mock.patch("psutil.net_io_counters") - def test_system_network_packets_transmit(self, mock_net_io_counters): + def test_system_network_errors(self, mock_net_io_counters): NetIO = namedtuple( "NetIO", [ @@ -676,13 +570,23 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult({"device": "eth0"}, 3), - _SystemMetricsResult({"device": "eth1"}, 11), + _SystemMetricsResult( + {"device": "eth0", "direction": "receive"}, 5 + ), + _SystemMetricsResult( + {"device": "eth0", "direction": "transmit"}, 6 + ), + _SystemMetricsResult( + {"device": "eth1", "direction": "receive"}, 13 + ), + _SystemMetricsResult( + {"device": "eth1", "direction": "transmit"}, 14 + ), ] - self._test_metrics("system.network.packets.transmit", expected) + self._test_metrics("system.network.errors", expected) @mock.patch("psutil.net_io_counters") - def test_system_network_packets_receive(self, mock_net_io_counters): + def test_system_network_io(self, mock_net_io_counters): NetIO = namedtuple( "NetIO", [ @@ -720,186 +624,20 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult({"device": "eth0"}, 4), - _SystemMetricsResult({"device": "eth1"}, 12), + _SystemMetricsResult( + {"device": "eth0", "direction": "receive"}, 8 + ), + _SystemMetricsResult( + {"device": "eth0", "direction": "transmit"}, 7 + ), + _SystemMetricsResult( + {"device": "eth1", "direction": "receive"}, 16 + ), + _SystemMetricsResult( + {"device": "eth1", "direction": "transmit"}, 15 + ), ] - self._test_metrics("system.network.packets.receive", expected) - - @mock.patch("psutil.net_io_counters") - def test_system_network_errors_transmit(self, mock_net_io_counters): - NetIO = namedtuple( - "NetIO", - [ - "dropin", - "dropout", - "packets_sent", - "packets_recv", - "errin", - "errout", - "bytes_sent", - "bytes_recv", - ], - ) - mock_net_io_counters.return_value = { - "eth0": NetIO( - dropin=1, - dropout=2, - packets_sent=3, - packets_recv=4, - errin=5, - errout=6, - bytes_sent=7, - bytes_recv=8, - ), - "eth1": NetIO( - dropin=9, - dropout=10, - packets_sent=11, - packets_recv=12, - errin=13, - errout=14, - bytes_sent=15, - bytes_recv=16, - ), - } - - expected = [ - _SystemMetricsResult({"device": "eth0"}, 6), - _SystemMetricsResult({"device": "eth1"}, 14), - ] - self._test_metrics("system.network.errors.transmit", expected) - - @mock.patch("psutil.net_io_counters") - def test_system_network_errors_receive(self, mock_net_io_counters): - NetIO = namedtuple( - "NetIO", - [ - "dropin", - "dropout", - "packets_sent", - "packets_recv", - "errin", - "errout", - "bytes_sent", - "bytes_recv", - ], - ) - mock_net_io_counters.return_value = { - "eth0": NetIO( - dropin=1, - dropout=2, - packets_sent=3, - packets_recv=4, - errin=5, - errout=6, - bytes_sent=7, - bytes_recv=8, - ), - "eth1": NetIO( - dropin=9, - dropout=10, - packets_sent=11, - packets_recv=12, - errin=13, - errout=14, - bytes_sent=15, - bytes_recv=16, - ), - } - - expected = [ - _SystemMetricsResult({"device": "eth0"}, 5), - _SystemMetricsResult({"device": "eth1"}, 13), - ] - self._test_metrics("system.network.errors.receive", expected) - - @mock.patch("psutil.net_io_counters") - def test_system_network_io_transmit(self, mock_net_io_counters): - NetIO = namedtuple( - "NetIO", - [ - "dropin", - "dropout", - "packets_sent", - "packets_recv", - "errin", - "errout", - "bytes_sent", - "bytes_recv", - ], - ) - mock_net_io_counters.return_value = { - "eth0": NetIO( - dropin=1, - dropout=2, - packets_sent=3, - packets_recv=4, - errin=5, - errout=6, - bytes_sent=7, - bytes_recv=8, - ), - "eth1": NetIO( - dropin=9, - dropout=10, - packets_sent=11, - packets_recv=12, - errin=13, - errout=14, - bytes_sent=15, - bytes_recv=16, - ), - } - - expected = [ - _SystemMetricsResult({"device": "eth0"}, 7), - _SystemMetricsResult({"device": "eth1"}, 15), - ] - self._test_metrics("system.network.io.transmit", expected) - - @mock.patch("psutil.net_io_counters") - def test_system_network_io_receive(self, mock_net_io_counters): - NetIO = namedtuple( - "NetIO", - [ - "dropin", - "dropout", - "packets_sent", - "packets_recv", - "errin", - "errout", - "bytes_sent", - "bytes_recv", - ], - ) - mock_net_io_counters.return_value = { - "eth0": NetIO( - dropin=1, - dropout=2, - packets_sent=3, - packets_recv=4, - errin=5, - errout=6, - bytes_sent=7, - bytes_recv=8, - ), - "eth1": NetIO( - dropin=9, - dropout=10, - packets_sent=11, - packets_recv=12, - errin=13, - errout=14, - bytes_sent=15, - bytes_recv=16, - ), - } - - expected = [ - _SystemMetricsResult({"device": "eth0"}, 8), - _SystemMetricsResult({"device": "eth1"}, 16), - ] - self._test_metrics("system.network.io.receive", expected) + self._test_metrics("system.network.io", expected) @mock.patch("psutil.net_connections") def test_system_network_connections(self, mock_net_connections):