This is an automated email from the ASF dual-hosted git repository.
jiangtian pushed a commit to branch win_metircs
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/win_metircs by this push:
new adde97373f6 Add disk & network metrics for windows
adde97373f6 is described below
commit adde97373f6b848b0e4a2b1e3d5da222182f9841
Author: Tian Jiang <[email protected]>
AuthorDate: Thu Oct 16 19:04:34 2025 +0800
Add disk & network metrics for windows
---
.../metrics/file/SystemRelatedFileMetrics.java | 8 +-
iotdb-core/metrics/core/pom.xml | 5 -
iotdb-core/metrics/interface/pom.xml | 5 +
.../disk/AbstractDiskMetricsManager.java | 111 ++++++++++++++
.../metricsets/disk/IDiskMetricsManager.java | 3 +
.../metricsets/disk/LinuxDiskMetricsManager.java | 90 +-----------
.../metricsets/disk/WindowsDiskMetricsManager.java | 160 ++++++++++++++++++++-
.../metricsets/net/WindowsNetMetricManager.java | 84 ++++++++++-
8 files changed, 369 insertions(+), 97 deletions(-)
diff --git
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/service/metrics/file/SystemRelatedFileMetrics.java
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/service/metrics/file/SystemRelatedFileMetrics.java
index 3fac0d10a16..a225dd63123 100644
---
a/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/service/metrics/file/SystemRelatedFileMetrics.java
+++
b/iotdb-core/datanode/src/main/java/org/apache/iotdb/db/service/metrics/file/SystemRelatedFileMetrics.java
@@ -31,6 +31,7 @@ import org.apache.iotdb.metrics.utils.SystemType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import oshi.SystemInfo;
import java.io.BufferedReader;
import java.io.File;
@@ -52,7 +53,9 @@ public class SystemRelatedFileMetrics implements IMetricSet {
@Override
public void bindTo(AbstractMetricService metricService) {
- if ((CONFIG.getSystemType() == SystemType.LINUX || CONFIG.getSystemType()
== SystemType.MAC)
+ if ((CONFIG.getSystemType() == SystemType.LINUX
+ || CONFIG.getSystemType() == SystemType.MAC
+ || CONFIG.getSystemType() == SystemType.WINDOWS)
&& !CONFIG.getPid().isEmpty()) {
this.getOpenFileNumberCommand =
new String[] {"/bin/sh", "-c", String.format("lsof -p %s | wc -l",
CONFIG.getPid())};
@@ -88,6 +91,9 @@ public class SystemRelatedFileMetrics implements IMetricSet {
}
}
fdCount = Long.parseLong(result.toString().trim());
+ } else if (CONFIG.getSystemType() == SystemType.WINDOWS) {
+ SystemInfo systemInfo = new SystemInfo();
+ return
systemInfo.getOperatingSystem().getCurrentProcess().getOpenFiles();
}
} catch (IOException e) {
LOGGER.warn("Failed to get open file number, because ", e);
diff --git a/iotdb-core/metrics/core/pom.xml b/iotdb-core/metrics/core/pom.xml
index e1513d5fad2..cfbd78b513e 100644
--- a/iotdb-core/metrics/core/pom.xml
+++ b/iotdb-core/metrics/core/pom.xml
@@ -46,10 +46,5 @@
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</dependency>
- <dependency>
- <groupId>com.github.oshi</groupId>
- <artifactId>oshi-core</artifactId>
- <version>6.4.0</version>
- </dependency>
</dependencies>
</project>
diff --git a/iotdb-core/metrics/interface/pom.xml
b/iotdb-core/metrics/interface/pom.xml
index f0709c62ff2..7dfeab604d8 100644
--- a/iotdb-core/metrics/interface/pom.xml
+++ b/iotdb-core/metrics/interface/pom.xml
@@ -104,6 +104,11 @@
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>com.github.oshi</groupId>
+ <artifactId>oshi-core</artifactId>
+ <version>6.4.0</version>
+ </dependency>
</dependencies>
<build>
<plugins>
diff --git
a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/AbstractDiskMetricsManager.java
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/AbstractDiskMetricsManager.java
new file mode 100644
index 00000000000..077a9743c48
--- /dev/null
+++
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/AbstractDiskMetricsManager.java
@@ -0,0 +1,111 @@
+package org.apache.iotdb.metrics.metricsets.disk;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public abstract class AbstractDiskMetricsManager implements
IDiskMetricsManager {
+
+ public static final double BYTES_PER_KB = 1024.0;
+ // Disk IO status structure
+ protected Map<String, Long> lastReadOperationCountForDisk;
+ protected Map<String, Long> lastWriteOperationCountForDisk;
+ protected Map<String, Long> lastReadSizeForDisk;
+ protected Map<String, Long> lastWriteSizeForDisk;
+ protected Map<String, Long> lastReadTimeCostForDisk;
+ protected Map<String, Long> lastWriteTimeCostForDisk;
+ protected Map<String, Long> lastMergedReadCountForDisk;
+ protected Map<String, Long> lastMergedWriteCountForDisk;
+ protected Map<String, Long> lastReadSectorCountForDisk;
+ protected Map<String, Long> lastWriteSectorCountForDisk;
+ protected Map<String, Long> lastIoBusyTimeForDisk;
+ protected Map<String, Long> lastTimeInQueueForDisk;
+ protected Map<String, Long> incrementReadOperationCountForDisk;
+ protected Map<String, Long> incrementWriteOperationCountForDisk;
+ protected Map<String, Long> incrementReadSizeForDisk;
+ protected Map<String, Long> incrementWriteSizeForDisk;
+ protected Map<String, Long> incrementMergedReadOperationCountForDisk;
+ protected Map<String, Long> incrementMergedWriteOperationCountForDisk;
+ protected Map<String, Long> incrementReadTimeCostForDisk;
+ protected Map<String, Long> incrementWriteTimeCostForDisk;
+ protected Map<String, Long> incrementReadSectorCountForDisk;
+ protected Map<String, Long> incrementWriteSectorCountForDisk;
+ protected Map<String, Long> incrementIoBusyTimeForDisk;
+ protected Map<String, Long> incrementTimeInQueueForDisk;
+ protected long lastUpdateTime = 0L;
+ protected long updateInterval = 1L;
+ protected Set<String> diskIdSet;
+
+ public AbstractDiskMetricsManager() {}
+
+ protected void init() {
+ collectDiskId();
+ lastReadOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ lastWriteOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ lastReadSizeForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ lastWriteSizeForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ lastReadTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ lastWriteTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ lastMergedReadCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ lastMergedWriteCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ lastReadSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ lastWriteSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ lastIoBusyTimeForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ lastTimeInQueueForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ incrementReadOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1,
1);
+ incrementWriteOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1,
1);
+ incrementReadSizeForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ incrementWriteSizeForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ incrementMergedReadOperationCountForDisk = new HashMap<>(diskIdSet.size()
+ 1, 1);
+ incrementMergedWriteOperationCountForDisk = new HashMap<>(diskIdSet.size()
+ 1, 1);
+ incrementReadTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ incrementWriteTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ incrementReadSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ incrementWriteSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ incrementIoBusyTimeForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ incrementTimeInQueueForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
+ }
+
+ protected void checkUpdate() {
+ if (System.currentTimeMillis() - lastUpdateTime
+ > IDiskMetricsManager.UPDATE_SMALLEST_INTERVAL) {
+ updateInfo();
+ }
+ }
+
+ @Override
+ public Map<String, Double> getIoUtilsPercentage() {
+ checkUpdate();
+ Map<String, Double> utilsMap = new
HashMap<>(incrementIoBusyTimeForDisk.size());
+ for (Map.Entry<String, Long> entry :
incrementIoBusyTimeForDisk.entrySet()) {
+ utilsMap.put(entry.getKey(), ((double) entry.getValue()) /
updateInterval);
+ }
+ return utilsMap;
+ }
+
+ protected void updateInfo() {
+ long currentTime = System.currentTimeMillis();
+ updateInterval = currentTime - lastUpdateTime;
+ lastUpdateTime = currentTime;
+ }
+
+ protected void updateSingleDiskInfo(
+ String diskId, long currentValue, Map<String, Long> lastMap, Map<String,
Long> incrementMap) {
+ if (incrementMap != null) {
+ long lastValue = lastMap.getOrDefault(diskId, 0L);
+ if (lastValue != 0) {
+ incrementMap.put(diskId, currentValue - lastValue);
+ } else {
+ incrementMap.put(diskId, 0L);
+ }
+ }
+ lastMap.put(diskId, currentValue);
+ }
+
+ @Override
+ public Set<String> getDiskIds() {
+ return diskIdSet;
+ }
+
+ protected abstract void collectDiskId();
+}
diff --git
a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/IDiskMetricsManager.java
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/IDiskMetricsManager.java
index 67c2007965e..83a9f311223 100644
---
a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/IDiskMetricsManager.java
+++
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/IDiskMetricsManager.java
@@ -27,6 +27,9 @@ import java.util.Map;
import java.util.Set;
public interface IDiskMetricsManager {
+
+ long UPDATE_SMALLEST_INTERVAL = 10000L;
+
default Map<String, Double> getReadDataSizeForDisk() {
return Collections.emptyMap();
}
diff --git
a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/LinuxDiskMetricsManager.java
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/LinuxDiskMetricsManager.java
index 730b3490d44..300dac9ecd8 100644
---
a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/LinuxDiskMetricsManager.java
+++
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/LinuxDiskMetricsManager.java
@@ -33,7 +33,6 @@ import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Scanner;
-import java.util.Set;
import java.util.stream.Collectors;
/**
@@ -49,7 +48,7 @@ import java.util.stream.Collectors;
* system call count, write system call count, byte attempt to read, byte
attempt to write,
* cancelled write byte.
*/
-public class LinuxDiskMetricsManager implements IDiskMetricsManager {
+public class LinuxDiskMetricsManager extends AbstractDiskMetricsManager {
private static final Logger LOGGER =
LoggerFactory.getLogger(LinuxDiskMetricsManager.class);
@SuppressWarnings("squid:S1075")
@@ -74,34 +73,7 @@ public class LinuxDiskMetricsManager implements
IDiskMetricsManager {
private static final int DISK_IO_TOTAL_TIME_OFFSET = 13;
private static final int DISK_TIME_IN_QUEUE_OFFSET = 14;
private static final int DEFAULT_SECTOR_SIZE = 512;
- private static final double BYTES_PER_KB = 1024.0;
- private static final long UPDATE_SMALLEST_INTERVAL = 10000L;
- private Set<String> diskIdSet;
private final Map<String, Integer> diskSectorSizeMap;
- private long lastUpdateTime = 0L;
- private long updateInterval = 1L;
-
- // Disk IO status structure
- private final Map<String, Long> lastReadOperationCountForDisk;
- private final Map<String, Long> lastWriteOperationCountForDisk;
- private final Map<String, Long> lastReadTimeCostForDisk;
- private final Map<String, Long> lastWriteTimeCostForDisk;
- private final Map<String, Long> lastMergedReadCountForDisk;
- private final Map<String, Long> lastMergedWriteCountForDisk;
- private final Map<String, Long> lastReadSectorCountForDisk;
- private final Map<String, Long> lastWriteSectorCountForDisk;
- private final Map<String, Long> lastIoBusyTimeForDisk;
- private final Map<String, Long> lastTimeInQueueForDisk;
- private final Map<String, Long> incrementReadOperationCountForDisk;
- private final Map<String, Long> incrementWriteOperationCountForDisk;
- private final Map<String, Long> incrementMergedReadOperationCountForDisk;
- private final Map<String, Long> incrementMergedWriteOperationCountForDisk;
- private final Map<String, Long> incrementReadTimeCostForDisk;
- private final Map<String, Long> incrementWriteTimeCostForDisk;
- private final Map<String, Long> incrementReadSectorCountForDisk;
- private final Map<String, Long> incrementWriteSectorCountForDisk;
- private final Map<String, Long> incrementIoBusyTimeForDisk;
- private final Map<String, Long> incrementTimeInQueueForDisk;
// Process IO status structure
private long lastReallyReadSizeForProcess = 0L;
@@ -112,33 +84,13 @@ public class LinuxDiskMetricsManager implements
IDiskMetricsManager {
private long lastWriteOpsCountForProcess = 0L;
public LinuxDiskMetricsManager() {
+ init();
processIoStatusPath =
String.format(
"/proc/%s/io",
MetricConfigDescriptor.getInstance().getMetricConfig().getPid());
- collectDiskId();
// leave one entry to avoid hashmap resizing
diskSectorSizeMap = new HashMap<>(diskIdSet.size() + 1, 1);
collectDiskInfo();
- lastReadOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- lastWriteOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- lastReadTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- lastWriteTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- lastMergedReadCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- lastMergedWriteCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- lastReadSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- lastWriteSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- lastIoBusyTimeForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- lastTimeInQueueForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- incrementReadOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1,
1);
- incrementWriteOperationCountForDisk = new HashMap<>(diskIdSet.size() + 1,
1);
- incrementMergedReadOperationCountForDisk = new HashMap<>(diskIdSet.size()
+ 1, 1);
- incrementMergedWriteOperationCountForDisk = new HashMap<>(diskIdSet.size()
+ 1, 1);
- incrementReadTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- incrementWriteTimeCostForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- incrementReadSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- incrementWriteSectorCountForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- incrementIoBusyTimeForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
- incrementTimeInQueueForDisk = new HashMap<>(diskIdSet.size() + 1, 1);
}
@Override
@@ -184,15 +136,6 @@ public class LinuxDiskMetricsManager implements
IDiskMetricsManager {
return lastWriteTimeCostForDisk;
}
- @Override
- public Map<String, Double> getIoUtilsPercentage() {
- Map<String, Double> utilsMap = new HashMap<>(diskIdSet.size());
- for (Map.Entry<String, Long> entry :
incrementIoBusyTimeForDisk.entrySet()) {
- utilsMap.put(entry.getKey(), ((double) entry.getValue()) /
updateInterval);
- }
- return utilsMap;
- }
-
@Override
public Map<String, Double> getAvgReadCostTimeOfEachOpsForDisk() {
Map<String, Double> avgReadTimeCostMap = new HashMap<>(diskIdSet.size());
@@ -318,11 +261,7 @@ public class LinuxDiskMetricsManager implements
IDiskMetricsManager {
}
@Override
- public Set<String> getDiskIds() {
- return diskIdSet;
- }
-
- private void collectDiskId() {
+ protected void collectDiskId() {
File diskIdFolder = new File(DISK_ID_PATH);
if (!diskIdFolder.exists()) {
return;
@@ -355,10 +294,9 @@ public class LinuxDiskMetricsManager implements
IDiskMetricsManager {
}
}
- private void updateInfo() {
- long currentTime = System.currentTimeMillis();
- updateInterval = currentTime - lastUpdateTime;
- lastUpdateTime = currentTime;
+ @Override
+ protected void updateInfo() {
+ super.updateInfo();
updateDiskInfo();
updateProcessInfo();
}
@@ -430,15 +368,7 @@ public class LinuxDiskMetricsManager implements
IDiskMetricsManager {
Map<String, Long> lastMap,
Map<String, Long> incrementMap) {
long currentValue = Long.parseLong(diskInfo[offset]);
- if (incrementMap != null) {
- long lastValue = lastMap.getOrDefault(diskId, 0L);
- if (lastValue != 0) {
- incrementMap.put(diskId, currentValue - lastValue);
- } else {
- incrementMap.put(diskId, 0L);
- }
- }
- lastMap.put(diskId, currentValue);
+ updateSingleDiskInfo(diskId, currentValue, lastMap, incrementMap);
}
private void updateProcessInfo() {
@@ -469,10 +399,4 @@ public class LinuxDiskMetricsManager implements
IDiskMetricsManager {
LOGGER.error("Meets error while updating process io info", e);
}
}
-
- private void checkUpdate() {
- if (System.currentTimeMillis() - lastUpdateTime >
UPDATE_SMALLEST_INTERVAL) {
- updateInfo();
- }
- }
}
diff --git
a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/WindowsDiskMetricsManager.java
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/WindowsDiskMetricsManager.java
index 651d731dc84..b8961bd9b9c 100644
---
a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/WindowsDiskMetricsManager.java
+++
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/disk/WindowsDiskMetricsManager.java
@@ -19,26 +19,172 @@
package org.apache.iotdb.metrics.metricsets.disk;
+import oshi.SystemInfo;
+import oshi.hardware.HWDiskStore;
+import oshi.software.os.OSProcess;
+
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
-import oshi.SystemInfo;
+import java.util.stream.Collectors;
/** Disk Metrics Manager for Windows system, not implemented yet. */
-public class WindowsDiskMetricsManager implements IDiskMetricsManager {
+@SuppressWarnings({"rawtypes", "unchecked"})
+public class WindowsDiskMetricsManager extends AbstractDiskMetricsManager {
- private final SystemInfo systemInfo = new SystemInfo();
+ private final SystemInfo systemInfo = new SystemInfo();
+ private final OSProcess thisProcess;
+ private List<HWDiskStore> diskStores;
+
+ public WindowsDiskMetricsManager() {
+ thisProcess = systemInfo.getOperatingSystem().getCurrentProcess();
+ diskStores = systemInfo.getHardware().getDiskStores();
+ init();
+ }
@Override
public Map<String, Double> getReadDataSizeForDisk() {
+ checkUpdate();
Map<String, Double> result = new HashMap<>();
- systemInfo.getHardware().getDiskStores().forEach(disk -> {
- result.put(disk.getName(), (double) disk.getReadBytes());
- });
+ diskStores.forEach(
+ disk -> {
+ result.put(this.getDisplayName(disk), (double) disk.getReadBytes() /
BYTES_PER_KB);
+ });
return result;
}
@Override
public Map<String, Double> getWriteDataSizeForDisk() {
- return IDiskMetricsManager.super.getWriteDataSizeForDisk();
+ checkUpdate();
+ Map<String, Double> result = new HashMap<>();
+ diskStores.forEach(
+ disk -> {
+ result.put(this.getDisplayName(disk), (double) disk.getWriteBytes()
/ BYTES_PER_KB);
+ });
+ return result;
+ }
+
+ @Override
+ public Map<String, Long> getReadOperationCountForDisk() {
+ checkUpdate();
+ Map<String, Long> result = new HashMap<>();
+ diskStores.forEach(
+ disk -> {
+ result.put(this.getDisplayName(disk), disk.getReads());
+ });
+ return result;
+ }
+
+ @Override
+ public Map<String, Long> getWriteOperationCountForDisk() {
+ checkUpdate();
+ Map<String, Long> result = new HashMap<>();
+ diskStores.forEach(
+ disk -> {
+ result.put(this.getDisplayName(disk), disk.getWrites());
+ });
+ return result;
+ }
+
+ private Map<String, Long> getTransferTimesForDisk() {
+ checkUpdate();
+ Map<String, Long> result = new HashMap<>();
+ diskStores.forEach(
+ disk -> {
+ result.put(this.getDisplayName(disk), disk.getTransferTime());
+ });
+ return result;
+ }
+
+ @Override
+ public Map<String, Double> getQueueSizeForDisk() {
+ checkUpdate();
+ Map<String, Double> result = new HashMap<>();
+ diskStores.forEach(
+ disk -> {
+ result.put(this.getDisplayName(disk), (double)
disk.getCurrentQueueLength());
+ });
+ return result;
+ }
+
+ @Override
+ public double getActualReadDataSizeForProcess() {
+ return thisProcess.getBytesRead() / BYTES_PER_KB;
+ }
+
+ @Override
+ public double getActualWriteDataSizeForProcess() {
+ return thisProcess.getBytesWritten() / BYTES_PER_KB;
+ }
+
+ @Override
+ public Map<String, Double> getAvgSizeOfEachReadForDisk() {
+ checkUpdate();
+ Map<String, Double> result = new
HashMap<>(incrementReadSizeForDisk.size());
+ for (Map.Entry<String, Long> incrementReadSize :
incrementReadSizeForDisk.entrySet()) {
+ // use Long.max to avoid NaN
+ long readOpsCount =
+ Long.max(
+
incrementReadOperationCountForDisk.getOrDefault(incrementReadSize.getKey(),
1L), 1L);
+ result.put(
+ incrementReadSize.getKey(), ((double) incrementReadSize.getValue())
/ readOpsCount);
+ }
+ return result;
+ }
+
+ @Override
+ public Map<String, Double> getAvgSizeOfEachWriteForDisk() {
+ checkUpdate();
+ Map<String, Double> result = new
HashMap<>(incrementWriteSizeForDisk.size());
+ for (Map.Entry<String, Long> incrementReadSize :
incrementWriteSizeForDisk.entrySet()) {
+ // use Long.max to avoid NaN
+ long readOpsCount =
+ Long.max(
+
incrementWriteOperationCountForDisk.getOrDefault(incrementReadSize.getKey(),
1L), 1L);
+ result.put(
+ incrementReadSize.getKey(), ((double) incrementReadSize.getValue())
/ readOpsCount);
+ }
+ return result;
+ }
+
+ protected void updateInfo() {
+ super.updateInfo();
+ updateDiskInfo();
+ }
+
+ private void updateDiskInfo() {
+ diskStores = systemInfo.getHardware().getDiskStores();
+
+ Map[] currentMapArray = {
+ getTransferTimesForDisk(), getReadDataSizeForDisk(),
getWriteDataSizeForDisk(),
+ };
+ Map[] lastMapArray = {
+ lastIoBusyTimeForDisk, lastReadSizeForDisk, lastWriteSizeForDisk,
+ };
+ Map[] incrementMapArray = {
+ incrementIoBusyTimeForDisk, incrementReadSizeForDisk,
incrementWriteSizeForDisk,
+ };
+
+ for (int i = 0; i < currentMapArray.length; i++) {
+ Map map = currentMapArray[i];
+ int finalI = i;
+ map.forEach(
+ (key, value) -> {
+ updateSingleDiskInfo(
+ (String) key,
+ ((Number) value).longValue(),
+ lastMapArray[finalI],
+ incrementMapArray[finalI]);
+ });
+ }
+ }
+
+ private String getDisplayName(HWDiskStore disk) {
+ return disk.getName() + "-" + disk.getModel();
+ }
+
+ @Override
+ protected void collectDiskId() {
+ diskIdSet =
diskStores.stream().map(this::getDisplayName).collect(Collectors.toSet());
}
}
diff --git
a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/net/WindowsNetMetricManager.java
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/net/WindowsNetMetricManager.java
index c3ecb4b8d50..b8497ec0c16 100644
---
a/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/net/WindowsNetMetricManager.java
+++
b/iotdb-core/metrics/interface/src/main/java/org/apache/iotdb/metrics/metricsets/net/WindowsNetMetricManager.java
@@ -19,4 +19,86 @@
package org.apache.iotdb.metrics.metricsets.net;
-public class WindowsNetMetricManager implements INetMetricManager {}
+import oshi.SystemInfo;
+import oshi.hardware.NetworkIF;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class WindowsNetMetricManager implements INetMetricManager {
+ private final SystemInfo systemInfo = new SystemInfo();
+ private final int pid;
+
+ public WindowsNetMetricManager() {
+ this.pid =
systemInfo.getOperatingSystem().getCurrentProcess().getProcessID();
+ }
+
+ @Override
+ public Map<String, Long> getReceivedByte() {
+ Map<String, Long> result = new HashMap<>();
+ systemInfo
+ .getHardware()
+ .getNetworkIFs()
+ .forEach(
+ (networkIF) -> {
+ result.put(networkIF.getDisplayName(), networkIF.getBytesRecv());
+ });
+ return result;
+ }
+
+ @Override
+ public Map<String, Long> getTransmittedBytes() {
+ Map<String, Long> result = new HashMap<>();
+ systemInfo
+ .getHardware()
+ .getNetworkIFs()
+ .forEach(
+ (networkIF) -> {
+ result.put(networkIF.getDisplayName(), networkIF.getBytesSent());
+ });
+ return result;
+ }
+
+ @Override
+ public Map<String, Long> getReceivedPackets() {
+ Map<String, Long> result = new HashMap<>();
+ systemInfo
+ .getHardware()
+ .getNetworkIFs()
+ .forEach(
+ (networkIF) -> {
+ result.put(networkIF.getDisplayName(),
networkIF.getPacketsRecv());
+ });
+ return result;
+ }
+
+ @Override
+ public Map<String, Long> getTransmittedPackets() {
+ Map<String, Long> result = new HashMap<>();
+ systemInfo
+ .getHardware()
+ .getNetworkIFs()
+ .forEach(
+ (networkIF) -> {
+ result.put(networkIF.getDisplayName(),
networkIF.getPacketsSent());
+ });
+ return result;
+ }
+
+ @Override
+ public Set<String> getIfaceSet() {
+ return systemInfo.getHardware().getNetworkIFs().stream()
+ .map(NetworkIF::getDisplayName)
+ .collect(Collectors.toSet());
+ }
+
+ @Override
+ public int getConnectionNum() {
+ return (int)
+
systemInfo.getOperatingSystem().getInternetProtocolStats().getConnections().stream()
+ .filter(conn -> conn.getowningProcessId() == pid)
+ .count();
+ }
+}
