diff --git a/CHANGELOG.md b/CHANGELOG.md index 9a2b30615..d9b9b09a8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -26,6 +26,8 @@ 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 1c7c90a3d..d0cd10739 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,16 +25,24 @@ following metrics are configured: "system.memory.utilization": ["used", "free", "cached"], "system.swap.usage": ["used", "free"], "system.swap.utilization": ["used", "free"], - "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.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.network.connections": ["family", "type"], "runtime.memory": ["rss", "vms"], "runtime.cpu.time": ["user", "system"], + "runtime.gc_count": None } Usage @@ -59,7 +67,8 @@ Usage configuration = { "system.memory.usage": ["used", "free", "cached"], "system.cpu.time": ["idle", "user", "system", "irq"], - "system.network.io": ["transmit", "receive"], + "system.network.io.transmit": None, + "system.network.io.receive": None, "runtime.memory": ["rss", "vms"], "runtime.cpu.time": ["user", "system"], } @@ -91,13 +100,20 @@ _DEFAULT_CONFIG = { "system.memory.utilization": ["used", "free", "cached"], "system.swap.usage": ["used", "free"], "system.swap.utilization": ["used", "free"], - "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.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.network.connections": ["family", "type"], "runtime.memory": ["rss", "vms"], "runtime.cpu.time": ["user", "system"], @@ -131,15 +147,22 @@ class SystemMetricsInstrumentor(BaseInstrumentor): self._system_swap_usage_labels = self._labels.copy() self._system_swap_utilization_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_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_merged_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_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_connections_labels = self._labels.copy() self._runtime_memory_labels = self._labels.copy() @@ -149,6 +172,7 @@ 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") @@ -225,27 +249,51 @@ class SystemMetricsInstrumentor(BaseInstrumentor): # value_type=int, # ) - if "system.disk.io" in self._config: + if "system.disk.io.read" in self._config: self._meter.create_observable_counter( - name="system.disk.io", - callbacks=[self._get_system_disk_io], - description="System disk IO", + name="system.disk.io.read", + callbacks=[self._get_system_disk_io_read], + description="", unit="bytes", ) - if "system.disk.operations" in self._config: + if "system.disk.io.write" in self._config: self._meter.create_observable_counter( - name="system.disk.operations", - callbacks=[self._get_system_disk_operations], - description="System disk operations", + 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="", unit="operations", ) - if "system.disk.time" in self._config: + if "system.disk.operations.write" in self._config: self._meter.create_observable_counter( - name="system.disk.time", - callbacks=[self._get_system_disk_time], - description="System disk time", + 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", unit="seconds", ) @@ -271,35 +319,67 @@ 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.packets" in self._config: + if "system.network.dropped.transmit" in self._config: self._meter.create_observable_counter( - name="system.network.dropped_packets", - callbacks=[self._get_system_network_dropped_packets], - description="System network dropped_packets", + 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", unit="packets", ) - if "system.network.packets" in self._config: + if "system.network.dropped.receive" in self._config: self._meter.create_observable_counter( - name="system.network.packets", - callbacks=[self._get_system_network_packets], - description="System network packets", + 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", unit="packets", ) - if "system.network.errors" in self._config: + if "system.network.packets.transmit" in self._config: self._meter.create_observable_counter( - name="system.network.errors", - callbacks=[self._get_system_network_errors], - description="System network errors", + 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", unit="errors", ) - if "system.network.io" in self._config: + if "system.network.errors.receive" in self._config: self._meter.create_observable_counter( - name="system.network.io", - callbacks=[self._get_system_network_io], - description="System network io", + 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", unit="bytes", ) @@ -424,132 +504,175 @@ class SystemMetricsInstrumentor(BaseInstrumentor): self._system_swap_utilization_labels.copy(), ) - def _get_system_disk_io( + def _get_system_disk_io_read( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for disk IO""" + """Observer callback for disk IO read""" for device, counters in psutil.disk_io_counters(perdisk=True).items(): - 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(), - ) + 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(), + ) - def _get_system_disk_operations( + def _get_system_disk_io_write( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for disk operations""" + """Observer callback for disk IO write""" for device, counters in psutil.disk_io_counters(perdisk=True).items(): - 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(), - ) + 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(), + ) - def _get_system_disk_time( + def _get_system_disk_operations_read( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for disk time""" + """Observer callback for disk operations read""" for device, counters in psutil.disk_io_counters(perdisk=True).items(): - 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(), - ) + 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(), + ) - def _get_system_disk_merged( + def _get_system_disk_operations_write( self, options: CallbackOptions ) -> Iterable[Observation]: - """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 - + """Observer callback for disk operations write""" for device, counters in psutil.disk_io_counters(perdisk=True).items(): - 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(), - ) + 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(), + ) - def _get_system_network_dropped_packets( + def _get_system_disk_operation_time_read( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for network dropped packets""" + """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(), + ) - for device, counters in psutil.net_io_counters(pernic=True).items(): - 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_packets( + def _get_system_disk_operation_time_write( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for network packets""" + """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(), + ) - 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( + def _get_system_network_dropped_transmit( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for network errors""" + """Observer callback for network dropped packets transmit""" for device, counters in psutil.net_io_counters(pernic=True).items(): - 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(), - ) + if hasattr(counters, "dropout"): + self._system_network_dropped_transmit_labels["device"] = device + yield Observation( + getattr(counters, "dropout"), + self._system_network_dropped_transmit_labels.copy(), + ) - def _get_system_network_io( + def _get_system_network_dropped_receive( self, options: CallbackOptions ) -> Iterable[Observation]: - """Observer callback for network IO""" - + """Observer callback for network dropped packets receive""" 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"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(), - ) + if hasattr(counters, "dropin"): + self._system_network_dropped_receive_labels["device"] = device + yield Observation( + getattr(counters, "dropin"), + self._system_network_dropped_receive_labels.copy(), + ) + + def _get_system_network_packets_transmit( + self, options: CallbackOptions + ) -> Iterable[Observation]: + """Observer callback for network packets transmit""" + 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(), + ) + + def _get_system_network_packets_receive( + 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(), + ) + + 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(), + ) 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 04d7674db..dd1ede0b0 100644 --- a/instrumentation/opentelemetry-instrumentation-system-metrics/tests/test_system_metrics.py +++ b/instrumentation/opentelemetry-instrumentation-system-metrics/tests/test_system_metrics.py @@ -51,6 +51,7 @@ class _SystemMetricsResult: self.value = value +# pylint: disable=too-many-public-methods class TestSystemMetrics(TestBase): def setUp(self): super().setUp() @@ -75,7 +76,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), 17) + self.assertEqual(len(metric_names), 24) observer_names = [ "system.cpu.time", @@ -84,13 +85,20 @@ class TestSystemMetrics(TestBase): "system.memory.utilization", "system.swap.usage", "system.swap.utilization", - "system.disk.io", - "system.disk.operations", - "system.disk.time", - "system.network.dropped_packets", - "system.network.packets", - "system.network.errors", - "system.network.io", + "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.network.connections", f"runtime.{self.implementation}.memory", f"runtime.{self.implementation}.cpu_time", @@ -278,7 +286,7 @@ class TestSystemMetrics(TestBase): self._test_metrics("system.swap.utilization", expected) @mock.patch("psutil.disk_io_counters") - def test_system_disk_io(self, mock_disk_io_counters): + def test_system_disk_io_read(self, mock_disk_io_counters): DiskIO = namedtuple( "DiskIO", [ @@ -316,15 +324,13 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult({"device": "sda", "direction": "read"}, 3), - _SystemMetricsResult({"device": "sda", "direction": "write"}, 4), - _SystemMetricsResult({"device": "sdb", "direction": "read"}, 11), - _SystemMetricsResult({"device": "sdb", "direction": "write"}, 12), + _SystemMetricsResult({"device": "sda"}, 3), + _SystemMetricsResult({"device": "sdb"}, 11), ] - self._test_metrics("system.disk.io", expected) + self._test_metrics("system.disk.io.read", expected) @mock.patch("psutil.disk_io_counters") - def test_system_disk_operations(self, mock_disk_io_counters): + def test_system_disk_io_write(self, mock_disk_io_counters): DiskIO = namedtuple( "DiskIO", [ @@ -362,15 +368,13 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult({"device": "sda", "direction": "read"}, 1), - _SystemMetricsResult({"device": "sda", "direction": "write"}, 2), - _SystemMetricsResult({"device": "sdb", "direction": "read"}, 9), - _SystemMetricsResult({"device": "sdb", "direction": "write"}, 10), + _SystemMetricsResult({"device": "sda"}, 4), + _SystemMetricsResult({"device": "sdb"}, 12), ] - self._test_metrics("system.disk.operations", expected) + self._test_metrics("system.disk.io.write", expected) @mock.patch("psutil.disk_io_counters") - def test_system_disk_time(self, mock_disk_io_counters): + def test_system_disk_operations_read(self, mock_disk_io_counters): DiskIO = namedtuple( "DiskIO", [ @@ -408,23 +412,145 @@ class TestSystemMetrics(TestBase): } expected = [ - _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 - ), + _SystemMetricsResult({"device": "sda"}, 1), + _SystemMetricsResult({"device": "sdb"}, 9), ] - self._test_metrics("system.disk.time", expected) + 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) @mock.patch("psutil.net_io_counters") - def test_system_network_dropped_packets(self, mock_net_io_counters): + def test_system_network_dropped_transmit(self, mock_net_io_counters): NetIO = namedtuple( "NetIO", [ @@ -462,23 +588,13 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult( - {"device": "eth0", "direction": "receive"}, 1 - ), - _SystemMetricsResult( - {"device": "eth0", "direction": "transmit"}, 2 - ), - _SystemMetricsResult( - {"device": "eth1", "direction": "receive"}, 9 - ), - _SystemMetricsResult( - {"device": "eth1", "direction": "transmit"}, 10 - ), + _SystemMetricsResult({"device": "eth0"}, 2), + _SystemMetricsResult({"device": "eth1"}, 10), ] - self._test_metrics("system.network.dropped_packets", expected) + self._test_metrics("system.network.dropped.transmit", expected) @mock.patch("psutil.net_io_counters") - def test_system_network_packets(self, mock_net_io_counters): + def test_system_network_dropped_receive(self, mock_net_io_counters): NetIO = namedtuple( "NetIO", [ @@ -516,23 +632,13 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult( - {"device": "eth0", "direction": "receive"}, 4 - ), - _SystemMetricsResult( - {"device": "eth0", "direction": "transmit"}, 3 - ), - _SystemMetricsResult( - {"device": "eth1", "direction": "receive"}, 12 - ), - _SystemMetricsResult( - {"device": "eth1", "direction": "transmit"}, 11 - ), + _SystemMetricsResult({"device": "eth0"}, 1), + _SystemMetricsResult({"device": "eth1"}, 9), ] - self._test_metrics("system.network.packets", expected) + self._test_metrics("system.network.dropped.receive", expected) @mock.patch("psutil.net_io_counters") - def test_system_network_errors(self, mock_net_io_counters): + def test_system_network_packets_transmit(self, mock_net_io_counters): NetIO = namedtuple( "NetIO", [ @@ -570,23 +676,13 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult( - {"device": "eth0", "direction": "receive"}, 5 - ), - _SystemMetricsResult( - {"device": "eth0", "direction": "transmit"}, 6 - ), - _SystemMetricsResult( - {"device": "eth1", "direction": "receive"}, 13 - ), - _SystemMetricsResult( - {"device": "eth1", "direction": "transmit"}, 14 - ), + _SystemMetricsResult({"device": "eth0"}, 3), + _SystemMetricsResult({"device": "eth1"}, 11), ] - self._test_metrics("system.network.errors", expected) + self._test_metrics("system.network.packets.transmit", expected) @mock.patch("psutil.net_io_counters") - def test_system_network_io(self, mock_net_io_counters): + def test_system_network_packets_receive(self, mock_net_io_counters): NetIO = namedtuple( "NetIO", [ @@ -624,20 +720,186 @@ class TestSystemMetrics(TestBase): } expected = [ - _SystemMetricsResult( - {"device": "eth0", "direction": "receive"}, 8 - ), - _SystemMetricsResult( - {"device": "eth0", "direction": "transmit"}, 7 - ), - _SystemMetricsResult( - {"device": "eth1", "direction": "receive"}, 16 - ), - _SystemMetricsResult( - {"device": "eth1", "direction": "transmit"}, 15 - ), + _SystemMetricsResult({"device": "eth0"}, 4), + _SystemMetricsResult({"device": "eth1"}, 12), ] - self._test_metrics("system.network.io", expected) + 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) @mock.patch("psutil.net_connections") def test_system_network_connections(self, mock_net_connections):