feat: consolidate metadata implementations, improve de-/serialization

metadata/src/main/java/io/github/metacosm/power/SensorMetadata.java

@@ -1,16 +1,43 @@
 package io.github.metacosm.power;
 
+import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 
+import java.util.Collections;
 import java.util.Map;
 
-public interface SensorMetadata {
-    record ComponentMetadata(String name, int index, String description, boolean isAttributed, String unit){};
+public class SensorMetadata {
+    public record ComponentMetadata(String name, int index, String description, boolean isAttributed, String unit){}
 
-    ComponentMetadata metadataFor(String component);
-
-    int componentCardinality();
+    @JsonCreator
+    public SensorMetadata(Map<String, ComponentMetadata> components, String documentation) {
+        this.components = components;
+        this.documentation = documentation;
+    }
 
     @JsonProperty("metadata")
-    Map<String, ComponentMetadata> getComponents();
+    private final Map<String, ComponentMetadata> components;
+
+    @JsonProperty("documentation")
+    private final String documentation;
+
+    public ComponentMetadata metadataFor(String component) {
+        final var componentMetadata = components.get(component);
+        if (componentMetadata == null) {
+            throw new IllegalArgumentException("Unknown component: " + component);
+        }
+        return componentMetadata;
+    }
+
+    public int componentCardinality() {
+        return components.size();
+    }
+
+    public Map<String, ComponentMetadata> components() {
+        return Collections.unmodifiableMap(components);
+    }
+
+    public String documentation() {
+        return documentation;
+    }
 }

server/src/main/java/io/github/metacosm/power/sensors/linux/rapl/IntelRAPLSensor.java

@@ -35,27 +35,7 @@ public IntelRAPLSensor() {
         for (String name : files.keySet()) {
             metadata.put(name, new SensorMetadata.ComponentMetadata(name, fileNb++, name, false, "µJ"));
         }
-        this.metadata = new SensorMetadata() {
-
-            @Override
-            public ComponentMetadata metadataFor(String component) {
-                final var componentMetadata = metadata.get(component);
-                if (componentMetadata == null) {
-                    throw new IllegalArgumentException("Unknown component: " + component);
-                }
-                return componentMetadata;
-            }
-
-            @Override
-            public int componentCardinality() {
-                return metadata.size();
-            }
-
-            @Override
-            public Map<String, ComponentMetadata> getComponents() {
-                return metadata;
-            }
-        };
+        this.metadata = new SensorMetadata(metadata, "Linux RAPL derived information, see https://www.kernel.org/doc/html/latest/power/powercap/powercap.html");
         lastMeasuredSensorValues = new double[raplFiles.length];
     }
 

server/src/main/java/io/github/metacosm/power/sensors/macos/powermetrics/MacOSPowermetricsSensor.java

@@ -5,47 +5,98 @@
 import io.github.metacosm.power.sensors.RegisteredPID;
 
 import java.io.BufferedReader;
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
 
 public class MacOSPowermetricsSensor implements PowerSensor {
-    public static final String CPU = "cpu";
-    public static final String GPU = "gpu";
-    public static final String ANE = "ane";
+    public static final String CPU = "CPU";
+    public static final String GPU = "GPU";
+    public static final String ANE = "ANE";
+    public static final String DRAM = "DRAM";
+    public static final String DCS = "DCS";
+    public static final String PACKAGE = "Package";
+    private static final String COMBINED = "Combined";
     public static final String CPU_SHARE = "cpuShare";
     private Process powermetrics;
-    private final SensorMetadata.ComponentMetadata cpu = new SensorMetadata.ComponentMetadata(CPU, 0, "CPU power", true, "mW");
-    private final SensorMetadata.ComponentMetadata gpu = new SensorMetadata.ComponentMetadata(GPU, 1, "GPU power", true, "mW");
-    private final SensorMetadata.ComponentMetadata ane = new SensorMetadata.ComponentMetadata(ANE, 2, "Apple Neural Engine power", false, "mW");
-    private final SensorMetadata.ComponentMetadata cpuShare = new SensorMetadata.ComponentMetadata(CPU_SHARE, 3, "Computed share of CPU", false, "decimal percentage");
+    private static final SensorMetadata.ComponentMetadata cpu = new SensorMetadata.ComponentMetadata(CPU, 0, "CPU power", true, "mW");
+    private static final SensorMetadata.ComponentMetadata gpu = new SensorMetadata.ComponentMetadata(GPU, 1, "GPU power", true, "mW");
+    private static final SensorMetadata.ComponentMetadata ane = new SensorMetadata.ComponentMetadata(ANE, 2, "Apple Neural Engine power", false, "mW");
+    private static final SensorMetadata.ComponentMetadata cpuShare = new SensorMetadata.ComponentMetadata(CPU_SHARE, 3, "Computed share of CPU", false, "decimal percentage");
     private final Map<String, RegisteredPID> trackedPIDs = new ConcurrentHashMap<>();
 
-    private final SensorMetadata metadata = new SensorMetadata() {
-        @Override
-        public ComponentMetadata metadataFor(String component) {
-            return switch (component) {
-                case CPU -> cpu;
-                case GPU -> gpu;
-                case ANE -> ane;
-                case CPU_SHARE -> cpuShare;
-                default -> throw new IllegalArgumentException("Unknown component: '" + component + "'");
-            };
+    private final SensorMetadata metadata;
+
+    public MacOSPowermetricsSensor() {
+        // extract metadata
+        try {
+            final var exec = Runtime.getRuntime().exec("sudo powermetrics --samplers cpu_power -i 10 -n 1");
+            exec.waitFor(20, TimeUnit.MILLISECONDS);
+            this.metadata = initMetadata(exec.getInputStream());
+        } catch (Exception e) {
+            throw new RuntimeException(e);
         }
+    }
+
+    MacOSPowermetricsSensor(InputStream inputStream) {
+        this.metadata = initMetadata(inputStream);
+    }
+
+    SensorMetadata initMetadata(InputStream inputStream) {
+        // init map with known components
+        Map<String, SensorMetadata.ComponentMetadata> components = new HashMap<>();
+        components.put(CPU, cpu);
+        components.put(GPU, gpu);
+        components.put(ANE, ane);
+        components.put(CPU_SHARE, cpuShare);
+
+        int headerLinesToSkip = 10;
+        try (BufferedReader input = new BufferedReader(new InputStreamReader(inputStream))) {
+            String line;
+            while ((line = input.readLine()) != null) {
+                if (headerLinesToSkip != 0) {
+                    headerLinesToSkip--;
+                    continue;
+                }
+
+                // skip empty / header lines
+                if (line.isEmpty() || line.startsWith("*")) {
+                    continue;
+                }
+
+                // looking for line fitting the: "<name> Power: xxx mW" pattern, where "name" will be a considered metadata component
+                final var powerIndex = line.indexOf(" Power");
+                // lines with `-` as the second char are disregarded as of the form: "E-Cluster Power: 6 mW" which fits the metadata pattern but shouldn't be considered
+                if (powerIndex >= 0 && '-' != line.charAt(1)) {
+                    addComponentTo(line.substring(0, powerIndex), components);
+                }
+            }
 
-        @Override
-        public int componentCardinality() {
-            return 4;
+        } catch (IOException e) {
+            throw new RuntimeException(e);
         }
 
-        @Override
-        public Map<String, ComponentMetadata> getComponents() {
-            return Map.of(cpu.name(), cpu, gpu.name(), gpu, ane.name(), ane, cpuShare.name(), cpuShare);
+        return new SensorMetadata(components, "macOS powermetrics derived information, see https://firefox-source-docs.mozilla.org/performance/powermetrics.html");
+    }
+
+
+    private static void addComponentTo(String name, Map<String, SensorMetadata.ComponentMetadata> components) {
+        switch (name) {
+            case CPU, GPU, ANE:
+                // already pre-added
+                break;
+            case COMBINED:
+                // should be ignored
+                break;
+            default:
+                components.put(name, new SensorMetadata.ComponentMetadata(name, components.size(), name, false, "mW"));
         }
-    };
+    }
 
     @Override
     public SensorMetadata metadata() {

server/src/test/java/io/github/metacosm/PowerResourceTest.java

@@ -1,20 +1,62 @@
 package io.github.metacosm;
 
+import io.github.metacosm.power.SensorMetadata;
 import io.quarkus.test.junit.QuarkusTest;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledOnOs;
+import org.junit.jupiter.api.condition.OS;
+
+import java.util.Set;
 
 import static io.restassured.RestAssured.given;
+import static org.junit.jupiter.api.Assertions.*;
 
 @QuarkusTest
 public class PowerResourceTest {
 
     @Test
-    public void testHelloEndpoint() {
+    public void testPowerEndpoint() {
         final var pid = ProcessHandle.current().pid();
         given()
                 .when().get("/power/" + pid)
                 .then()
                 .statusCode(200);
     }
 
+    @Test
+    @EnabledOnOs(OS.MAC)
+    public void testMacOSMetadataEndpoint() {
+        final var metadata = given()
+                .when().get("/power/metadata")
+                .then()
+                .statusCode(200)
+                .extract().body().as(SensorMetadata.class);
+        assertEquals(4, metadata.componentCardinality());
+        assertTrue(metadata.documentation().contains("powermetrics"));
+        assertTrue(metadata.components().keySet().containsAll(Set.of("CPU", "GPU", "ANE", "cpuShare")));
+
+        final var cpu = metadata.metadataFor("CPU");
+        assertEquals(0, cpu.index());
+        assertEquals("CPU", cpu.name());
+        assertEquals("mW", cpu.unit());
+        assertTrue(cpu.isAttributed());
+
+        final var cpuShare = metadata.metadataFor("cpuShare");
+        assertEquals(3, cpuShare.index());
+        assertEquals("cpuShare", cpuShare.name());
+        assertEquals("decimal percentage", cpuShare.unit());
+        assertFalse(cpuShare.isAttributed());
+    }
+
+    @Test
+    @EnabledOnOs(OS.LINUX)
+    public void testLinuxMetadataEndpoint() {
+        final var metadata = given()
+                .when().get("/power/metadata")
+                .then()
+                .statusCode(200)
+                .extract().body().as(SensorMetadata.class);
+        assertTrue(metadata.documentation().contains("RAPL"));
+    }
+
 }

server/src/test/java/io/github/metacosm/power/sensors/macos/powermetrics/MacOSPowermetricsSensorTest.java

@@ -1,26 +1,64 @@
 package io.github.metacosm.power.sensors.macos.powermetrics;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
+import io.github.metacosm.power.SensorMetadata;
 import org.junit.jupiter.api.Test;
 
+import java.io.IOException;
+import java.io.InputStream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 class MacOSPowermetricsSensorTest {
 
     @Test
-    void checkMetadata() {
-        final var sensor = new MacOSPowermetricsSensor();
-        final var metadata = sensor.metadata();
-        assertEquals("cpu", metadata.metadataFor(MacOSPowermetricsSensor.CPU).name());
+    void checkMetadata() throws IOException {
+        var metadata = loadMetadata("sonoma-m1max.txt");
+        assertEquals(4, metadata.componentCardinality());
+        checkComponent(metadata, "CPU", 0);
+        checkComponent(metadata, "GPU", 1);
+        checkComponent(metadata, "ANE", 2);
+        checkComponent(metadata, "cpuShare", 3);
+
+        metadata = loadMetadata("monterey-m2.txt");
+        assertEquals(7, metadata.componentCardinality());
+        checkComponent(metadata, "CPU", 0);
+        checkComponent(metadata, "GPU", 1);
+        checkComponent(metadata, "ANE", 2);
+        checkComponent(metadata, "cpuShare", 3);
+        checkComponent(metadata, "DRAM", 4);
+        checkComponent(metadata, "DCS", 5);
+        checkComponent(metadata, "Package", 6);
+    }
+
+    private static SensorMetadata loadMetadata(String fileName) throws IOException {
+        try (var in = Thread.currentThread().getContextClassLoader().getResourceAsStream(fileName)) {
+            return loadMetadata(in);
+        }
+    }
+
+    private static SensorMetadata loadMetadata(InputStream in) {
+        final var sensor = new MacOSPowermetricsSensor(in);
+        return sensor.metadata();
+    }
+
+    private static void checkComponent(SensorMetadata metadata, String name, int index) {
+        // check string instead of constants to ensure "API" compatibility as these keys will be published
+        final var component = metadata.metadataFor(name);
+        assertEquals(name, component.name());
+        assertEquals(index, component.index());
     }
 
     @Test
     void extractPowerMeasure() {
-        final var sensor = new MacOSPowermetricsSensor();
+        var in = Thread.currentThread().getContextClassLoader().getResourceAsStream("sonoma-m1max.txt");
+        final var sensor = new MacOSPowermetricsSensor(in);
+        final var metadata = sensor.metadata();
         final var pid1 = sensor.register(29419);
         final var pid2 = sensor.register(391);
-        final var measure = sensor
-                .extractPowerMeasure(Thread.currentThread().getContextClassLoader().getResourceAsStream("foo.txt"));
-        final var metadata = sensor.metadata();
+
+        // re-open the stream to read the measure this time
+        in = Thread.currentThread().getContextClassLoader().getResourceAsStream("sonoma-m1max.txt");
+        final var measure = sensor.extractPowerMeasure(in);
         assertEquals(((23.88 / 1222.65) * 211), measure.get(pid1)[metadata.metadataFor(MacOSPowermetricsSensor.CPU).index()]);
         assertEquals(((283.25 / 1222.65) * 211), measure.get(pid2)[metadata.metadataFor(MacOSPowermetricsSensor.CPU).index()]);
     }