updated to remove directions from existing metrics. tests updated to … (#1214)

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

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.io.read": None,
-        "system.disk.operations": ["read", "write"],
+        "system.disk.io.write": None,
-        "system.disk.time": ["read", "write"],
+        "system.disk.operations.read": None,
-        "system.network.dropped.packets": ["transmit", "receive"],
+        "system.disk.operations.write": None,
-        "system.network.packets": ["transmit", "receive"],
+        "system.disk.operation_time.read": None,
-        "system.network.errors": ["transmit", "receive"],
+        "system.disk.operation_time.write": None,
-        "system.network.io": ["transmit", "receive"],
+        "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.io.read": None,
-    "system.disk.operations": ["read", "write"],
+    "system.disk.io.write": None,
-    "system.disk.time": ["read", "write"],
+    "system.disk.operations.read": None,
-    "system.network.dropped.packets": ["transmit", "receive"],
+    "system.disk.operations.write": None,
-    "system.network.packets": ["transmit", "receive"],
+    "system.disk.operation_time.read": None,
-    "system.network.errors": ["transmit", "receive"],
+    "system.disk.operation_time.write": None,
-    "system.network.io": ["transmit", "receive"],
+    "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_io_read_labels = self._labels.copy()
-        self._system_disk_operations_labels = self._labels.copy()
+        self._system_disk_io_write_labels = self._labels.copy()
-        self._system_disk_time_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_dropped_transmit_labels = self._labels.copy()
-        self._system_network_packets_labels = self._labels.copy()
+        self._system_network_dropped_receive_labels = self._labels.copy()
-        self._system_network_errors_labels = self._labels.copy()
+        self._system_network_packets_transmit_labels = self._labels.copy()
-        self._system_network_io_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",
+                name="system.disk.io.read",
-                callbacks=[self._get_system_disk_io],
+                callbacks=[self._get_system_disk_io_read],
-                description="System disk IO",
+                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",
+                name="system.disk.io.write",
-                callbacks=[self._get_system_disk_operations],
+                callbacks=[self._get_system_disk_io_write],
-                description="System disk operations",
+                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",
+                name="system.disk.operations.write",
-                callbacks=[self._get_system_disk_time],
+                callbacks=[self._get_system_disk_operations_write],
-                description="System disk time",
+                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",
+                name="system.network.dropped.transmit",
-                callbacks=[self._get_system_network_dropped_packets],
+                callbacks=[self._get_system_network_dropped_transmit],
-                description="System network dropped_packets",
+                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",
+                name="system.network.dropped.receive",
-                callbacks=[self._get_system_network_packets],
+                callbacks=[self._get_system_network_dropped_receive],
-                description="System network packets",
+                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",
+                name="system.network.packets.transmit",
-                callbacks=[self._get_system_network_errors],
+                callbacks=[self._get_system_network_packets_transmit],
-                description="System network errors",
+                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",
+                name="system.network.errors.receive",
-                callbacks=[self._get_system_network_io],
+                callbacks=[self._get_system_network_errors_receive],
-                description="System network io",
+                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, "read_bytes"):
-                if hasattr(counters, f"{metric}_bytes"):
+                self._system_disk_io_read_labels["device"] = device
-                    self._system_disk_io_labels["device"] = device
+                yield Observation(
-                    self._system_disk_io_labels["direction"] = metric
+                    getattr(counters, "read_bytes"),
-                    yield Observation(
+                    self._system_disk_io_read_labels.copy(),
-                        getattr(counters, f"{metric}_bytes"),
+                )
-                        self._system_disk_io_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, "write_bytes"):
-                if hasattr(counters, f"{metric}_count"):
+                self._system_disk_io_write_labels["device"] = device
-                    self._system_disk_operations_labels["device"] = device
+                yield Observation(
-                    self._system_disk_operations_labels["direction"] = metric
+                    getattr(counters, "write_bytes"),
-                    yield Observation(
+                    self._system_disk_io_write_labels.copy(),
-                        getattr(counters, f"{metric}_count"),
+                )
-                        self._system_disk_operations_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, "read_count"):
-                if hasattr(counters, f"{metric}_time"):
+                self._system_disk_operations_read_labels["device"] = device
-                    self._system_disk_time_labels["device"] = device
+                yield Observation(
-                    self._system_disk_time_labels["direction"] = metric
+                    getattr(counters, "read_count"),
-                    yield Observation(
+                    self._system_disk_operations_read_labels.copy(),
-                        getattr(counters, f"{metric}_time") / 1000,
+                )
-                        self._system_disk_time_labels.copy(),
-                    )
 
-    def _get_system_disk_merged(
+    def _get_system_disk_operations_write(
         self, options: CallbackOptions
     ) -> Iterable[Observation]:
-        """Observer callback for disk merged operations"""
+        """Observer callback for disk operations write"""
-
-        # 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():
-            for metric in self._config["system.disk.time"]:
+            if hasattr(counters, "write_count"):
-                if hasattr(counters, f"{metric}_merged_count"):
+                self._system_disk_operations_write_labels["device"] = device
-                    self._system_disk_merged_labels["device"] = device
+                yield Observation(
-                    self._system_disk_merged_labels["direction"] = metric
+                    getattr(counters, "write_count"),
-                    yield Observation(
+                    self._system_disk_operations_write_labels.copy(),
-                        getattr(counters, f"{metric}_merged_count"),
+                )
-                        self._system_disk_merged_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():
+    def _get_system_disk_operation_time_write(
-            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(
         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():
+    def _get_system_network_dropped_transmit(
-            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 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"]:
+            if hasattr(counters, "dropout"):
-                in_out = {"receive": "in", "transmit": "out"}[metric]
+                self._system_network_dropped_transmit_labels["device"] = device
-                if hasattr(counters, f"err{in_out}"):
+                yield Observation(
-                    self._system_network_errors_labels["device"] = device
+                    getattr(counters, "dropout"),
-                    self._system_network_errors_labels["direction"] = metric
+                    self._system_network_dropped_transmit_labels.copy(),
-                    yield Observation(
+                )
-                        getattr(counters, f"err{in_out}"),
-                        self._system_network_errors_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"]:
+            if hasattr(counters, "dropin"):
-                recv_sent = {"receive": "recv", "transmit": "sent"}[metric]
+                self._system_network_dropped_receive_labels["device"] = device
-                if hasattr(counters, f"bytes_{recv_sent}"):
+                yield Observation(
-                    self._system_network_io_labels["device"] = device
+                    getattr(counters, "dropin"),
-                    self._system_network_io_labels["direction"] = metric
+                    self._system_network_dropped_receive_labels.copy(),
-                    yield Observation(
+                )
-                        getattr(counters, f"bytes_{recv_sent}"),
+
-                        self._system_network_io_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

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.io.read",
-            "system.disk.operations",
+            "system.disk.io.write",
-            "system.disk.time",
+            "system.disk.operations.read",
-            "system.network.dropped_packets",
+            "system.disk.operations.write",
-            "system.network.packets",
+            "system.disk.operation_time.read",
-            "system.network.errors",
+            "system.disk.operation_time.write",
-            "system.network.io",
+            "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"}, 3),
-            _SystemMetricsResult({"device": "sda", "direction": "write"}, 4),
+            _SystemMetricsResult({"device": "sdb"}, 11),
-            _SystemMetricsResult({"device": "sdb", "direction": "read"}, 11),
-            _SystemMetricsResult({"device": "sdb", "direction": "write"}, 12),
         ]
-        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"}, 4),
-            _SystemMetricsResult({"device": "sda", "direction": "write"}, 2),
+            _SystemMetricsResult({"device": "sdb"}, 12),
-            _SystemMetricsResult({"device": "sdb", "direction": "read"}, 9),
-            _SystemMetricsResult({"device": "sdb", "direction": "write"}, 10),
         ]
-        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(
+            _SystemMetricsResult({"device": "sda"}, 1),
-                {"device": "sda", "direction": "read"}, 5 / 1000
+            _SystemMetricsResult({"device": "sdb"}, 9),
-            ),
-            _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.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(
+            _SystemMetricsResult({"device": "eth0"}, 2),
-                {"device": "eth0", "direction": "receive"}, 1
+            _SystemMetricsResult({"device": "eth1"}, 10),
-            ),
-            _SystemMetricsResult(
-                {"device": "eth0", "direction": "transmit"}, 2
-            ),
-            _SystemMetricsResult(
-                {"device": "eth1", "direction": "receive"}, 9
-            ),
-            _SystemMetricsResult(
-                {"device": "eth1", "direction": "transmit"}, 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(
+            _SystemMetricsResult({"device": "eth0"}, 1),
-                {"device": "eth0", "direction": "receive"}, 4
+            _SystemMetricsResult({"device": "eth1"}, 9),
-            ),
-            _SystemMetricsResult(
-                {"device": "eth0", "direction": "transmit"}, 3
-            ),
-            _SystemMetricsResult(
-                {"device": "eth1", "direction": "receive"}, 12
-            ),
-            _SystemMetricsResult(
-                {"device": "eth1", "direction": "transmit"}, 11
-            ),
         ]
-        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(
+            _SystemMetricsResult({"device": "eth0"}, 3),
-                {"device": "eth0", "direction": "receive"}, 5
+            _SystemMetricsResult({"device": "eth1"}, 11),
-            ),
-            _SystemMetricsResult(
-                {"device": "eth0", "direction": "transmit"}, 6
-            ),
-            _SystemMetricsResult(
-                {"device": "eth1", "direction": "receive"}, 13
-            ),
-            _SystemMetricsResult(
-                {"device": "eth1", "direction": "transmit"}, 14
-            ),
         ]
-        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(
+            _SystemMetricsResult({"device": "eth0"}, 4),
-                {"device": "eth0", "direction": "receive"}, 8
+            _SystemMetricsResult({"device": "eth1"}, 12),
-            ),
-            _SystemMetricsResult(
-                {"device": "eth0", "direction": "transmit"}, 7
-            ),
-            _SystemMetricsResult(
-                {"device": "eth1", "direction": "receive"}, 16
-            ),
-            _SystemMetricsResult(
-                {"device": "eth1", "direction": "transmit"}, 15
-            ),
         ]
-        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):