Revert "updated to remove directions from existing metrics. tests updated to … (#1213)" (#1346)

This reverts commit 270b73f55c.

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

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": ["read", "write"],
-        "system.disk.io.write": None,
+        "system.disk.operations": ["read", "write"],
-        "system.disk.operations.read": None,
+        "system.disk.time": ["read", "write"],
-        "system.disk.operations.write": None,
+        "system.network.dropped.packets": ["transmit", "receive"],
-        "system.disk.operation_time.read": None,
+        "system.network.packets": ["transmit", "receive"],
-        "system.disk.operation_time.write": None,
+        "system.network.errors": ["transmit", "receive"],
-        "system.network.dropped.transmit": None,
+        "system.network.io": ["transmit", "receive"],
-        "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
@@ -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": ["transmit", "receive"],
-        "system.network.io.receive": None,
         "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": ["read", "write"],
-    "system.disk.io.write": None,
+    "system.disk.operations": ["read", "write"],
-    "system.disk.operations.read": None,
+    "system.disk.time": ["read", "write"],
-    "system.disk.operations.write": None,
+    "system.network.dropped.packets": ["transmit", "receive"],
-    "system.disk.operation_time.read": None,
+    "system.network.packets": ["transmit", "receive"],
-    "system.disk.operation_time.write": None,
+    "system.network.errors": ["transmit", "receive"],
-    "system.network.dropped.transmit": None,
+    "system.network.io": ["transmit", "receive"],
-    "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"],
@@ -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_labels = self._labels.copy()
-        self._system_disk_io_write_labels = self._labels.copy()
+        self._system_disk_operations_labels = self._labels.copy()
-        self._system_disk_operations_read_labels = self._labels.copy()
+        self._system_disk_time_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_transmit_labels = self._labels.copy()
+        self._system_network_dropped_packets_labels = self._labels.copy()
-        self._system_network_dropped_receive_labels = self._labels.copy()
+        self._system_network_packets_labels = self._labels.copy()
-        self._system_network_packets_transmit_labels = self._labels.copy()
+        self._system_network_errors_labels = self._labels.copy()
-        self._system_network_packets_receive_labels = self._labels.copy()
+        self._system_network_io_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()
@@ -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",
+                name="system.disk.io",
-                callbacks=[self._get_system_disk_io_read],
+                callbacks=[self._get_system_disk_io],
-                description="",
+                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",
+                name="system.disk.operations",
-                callbacks=[self._get_system_disk_io_write],
+                callbacks=[self._get_system_disk_operations],
-                description="",
+                description="System disk operations",
-                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.operations.write" in self._config:
+        if "system.disk.time" in self._config:
             self._meter.create_observable_counter(
-                name="system.disk.operations.write",
+                name="system.disk.time",
-                callbacks=[self._get_system_disk_operations_write],
+                callbacks=[self._get_system_disk_time],
-                description="",
+                description="System disk time",
-                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",
             )
 
@@ -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",
+                name="system.network.dropped_packets",
-                callbacks=[self._get_system_network_dropped_transmit],
+                callbacks=[self._get_system_network_dropped_packets],
-                description="Count of packets that are dropped or discarded on transmit even though there was no error",
+                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",
+                name="system.network.packets",
-                callbacks=[self._get_system_network_dropped_receive],
+                callbacks=[self._get_system_network_packets],
-                description="Count of packets that are dropped or discarded on receive even though there was no error",
+                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",
+                name="system.network.errors",
-                callbacks=[self._get_system_network_packets_transmit],
+                callbacks=[self._get_system_network_errors],
-                description="Count of packets transmitted",
+                description="System network errors",
-                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.errors.receive" in self._config:
+        if "system.network.io" in self._config:
             self._meter.create_observable_counter(
-                name="system.network.errors.receive",
+                name="system.network.io",
-                callbacks=[self._get_system_network_errors_receive],
+                callbacks=[self._get_system_network_io],
-                description="Count of network errors detected on receive",
+                description="System network io",
-                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",
             )
 
@@ -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"):
+            for metric in self._config["system.disk.io"]:
-                self._system_disk_io_read_labels["device"] = device
+                if hasattr(counters, f"{metric}_bytes"):
-                yield Observation(
+                    self._system_disk_io_labels["device"] = device
-                    getattr(counters, "read_bytes"),
+                    self._system_disk_io_labels["direction"] = metric
-                    self._system_disk_io_read_labels.copy(),
+                    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"):
+            for metric in self._config["system.disk.operations"]:
-                self._system_disk_io_write_labels["device"] = device
+                if hasattr(counters, f"{metric}_count"):
-                yield Observation(
+                    self._system_disk_operations_labels["device"] = device
-                    getattr(counters, "write_bytes"),
+                    self._system_disk_operations_labels["direction"] = metric
-                    self._system_disk_io_write_labels.copy(),
+                    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"):
+            for metric in self._config["system.disk.time"]:
-                self._system_disk_operations_read_labels["device"] = device
+                if hasattr(counters, f"{metric}_time"):
-                yield Observation(
+                    self._system_disk_time_labels["device"] = device
-                    getattr(counters, "read_count"),
+                    self._system_disk_time_labels["direction"] = metric
-                    self._system_disk_operations_read_labels.copy(),
+                    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"):
+            for metric in self._config["system.disk.time"]:
-                self._system_disk_operations_write_labels["device"] = device
+                if hasattr(counters, f"{metric}_merged_count"):
-                yield Observation(
+                    self._system_disk_merged_labels["device"] = device
-                    getattr(counters, "write_count"),
+                    self._system_disk_merged_labels["direction"] = metric
-                    self._system_disk_operations_write_labels.copy(),
+                    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"""
+        """Observer callback for network dropped packets"""
-        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(),
-                )
 
-    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"):
+            for metric in self._config["system.network.dropped.packets"]:
-                self._system_network_dropped_transmit_labels["device"] = device
+                in_out = {"receive": "in", "transmit": "out"}[metric]
-                yield Observation(
+                if hasattr(counters, f"drop{in_out}"):
-                    getattr(counters, "dropout"),
+                    self._system_network_dropped_packets_labels[
-                    self._system_network_dropped_transmit_labels.copy(),
+                        "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"""
+        """Observer callback for network packets"""
-        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(),
-                )
 
-    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"):
+            for metric in self._config["system.network.errors"]:
-                self._system_network_packets_transmit_labels["device"] = device
+                in_out = {"receive": "in", "transmit": "out"}[metric]
-                yield Observation(
+                if hasattr(counters, f"err{in_out}"):
-                    getattr(counters, "packets_sent"),
+                    self._system_network_errors_labels["device"] = device
-                    self._system_network_packets_transmit_labels.copy(),
+                    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"""
+        """Observer callback for network IO"""
-        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"):
+            for metric in self._config["system.network.dropped.packets"]:
-                self._system_network_errors_transmit_labels["device"] = device
+                recv_sent = {"receive": "recv", "transmit": "sent"}[metric]
-                yield Observation(
+                if hasattr(counters, f"bytes_{recv_sent}"):
-                    getattr(counters, "errout"),
+                    self._system_network_io_labels["device"] = device
-                    self._system_network_errors_transmit_labels.copy(),
+                    self._system_network_io_labels["direction"] = metric
-                )
+                    yield Observation(
-
+                        getattr(counters, f"bytes_{recv_sent}"),
-    def _get_system_network_errors_receive(
+                        self._system_network_io_labels.copy(),
-        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,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",
-            "system.disk.io.write",
+            "system.disk.operations",
-            "system.disk.operations.read",
+            "system.disk.time",
-            "system.disk.operations.write",
+            "system.network.dropped_packets",
-            "system.disk.operation_time.read",
+            "system.network.packets",
-            "system.disk.operation_time.write",
+            "system.network.errors",
-            "system.network.dropped.transmit",
+            "system.network.io",
-            "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",
@@ -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": "sda", "direction": "read"}, 3),
-            _SystemMetricsResult({"device": "sdb"}, 11),
+            _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": "sda", "direction": "read"}, 1),
-            _SystemMetricsResult({"device": "sdb"}, 12),
+            _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(
-            _SystemMetricsResult({"device": "sdb"}, 9),
+                {"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)
+        self._test_metrics("system.disk.time", 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_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(
-            _SystemMetricsResult({"device": "eth1"}, 10),
+                {"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(
-            _SystemMetricsResult({"device": "eth1"}, 9),
+                {"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(
-            _SystemMetricsResult({"device": "eth1"}, 11),
+                {"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(
-            _SystemMetricsResult({"device": "eth1"}, 12),
+                {"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)
+        self._test_metrics("system.network.io", 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):