Add all core temperatures

src/metrics/Collector.cpp

@@ -101,10 +101,10 @@ namespace metrics
         return out;
     }
 
-    std::vector<float> Collector::readCpuCoreTemps()
+    std::vector<CpuTemperature> Collector::readCpuCoreTemps()
     {
-        std::vector<float> physTemps;
-        std::vector<float> logicTemps(logicalToPhysical.size());
+        std::vector<CpuTemperature> physical;
+        std::vector<CpuTemperature> logical(logicalToPhysical.size());
 
         for (const auto &hwmon : std::filesystem::directory_iterator("/sys/class/hwmon"))
         {
@@ -121,25 +121,41 @@ namespace metrics
             for (const auto &f : std::filesystem::directory_iterator(hwmon))
             {
                 std::string fname = f.path().filename();
+                CpuTemperature temperature;
                 if (fname.find("temp") == 0 && fname.find("_input") != std::string::npos)
                 {
                     int millideg = 0;
                     std::ifstream tempFile(f.path());
                     tempFile >> millideg;
-                    physTemps.push_back(millideg / 1000.0f); // °C
+                    temperature.current = millideg / 1000.0f; // °C
                 }
+                if (fname.find("temp") == 0 && fname.find("_max") != std::string::npos)
+                {
+                    int millideg = 0;
+                    std::ifstream tempFile(f.path());
+                    tempFile >> millideg;
+                    temperature.max = millideg / 1000.0f; // °C
+                }
+                if (fname.find("temp") == 0 && fname.find("_crit") != std::string::npos)
+                {
+                    int millideg = 0;
+                    std::ifstream tempFile(f.path());
+                    tempFile >> millideg;
+                    temperature.critical = millideg / 1000.0f; // °C
+                }
+                physical.push_back(temperature);
             }
 
             for (size_t i = 0; i < logicalToPhysical.size(); ++i)
             {
                 int phys = logicalToPhysical[i];
-                if (phys >= static_cast<int>(physTemps.size()))
-                    phys = physTemps.size() - 1; // safety
-                logicTemps[i] = physTemps[phys];
+                if (phys >= static_cast<int>(physical.size()))
+                    phys = physical.size() - 1; // safety
+                logical[i] = physical[phys];
             }
         }
 
-        return logicTemps;
+        return logical;
     }
 
     float Collector::cpuLoad(const Collector::CpuTimes &prev,

src/metrics/Collector.h

@@ -2,6 +2,7 @@
 #include <vector>
 #include <string>
 #include "metrics/Host.h"
+#include "metrics/CpuTemperature.h"
 
 namespace metrics
 {
@@ -27,7 +28,7 @@ namespace metrics
         std::pair<CpuTimes, std::vector<CpuTimes>> readCpuTimes();
         const std::vector<std::vector<std::string>> disks;
         float cpuLoad(const CpuTimes &prev, const CpuTimes &cur);
-        std::vector<float> readCpuCoreTemps();
+        std::vector<CpuTemperature> readCpuCoreTemps();
         Memory readMemory();
         Disk readDisk(const std::vector<std::string> &disk = {"R", "/"});
         void readLoad(float &l1, float &l5, float &l15);

src/metrics/Cpu.h

@@ -1,12 +1,14 @@
 #pragma once
 #include <vector>
 
+#include "metrics/CpuTemperature.h"
+
 namespace metrics
 {
     struct Cpu
     {
         float totalLoad;
         std::vector<float> coreLoads; // длина = num_cores
-        std::vector<float> coreTemps;
+        std::vector<CpuTemperature> coreTemps;
     };
 } // namespace metrics

src/metrics/CpuTemperature.h

@@ -0,0 +1,12 @@
+#pragma once
+#include <vector>
+
+namespace metrics
+{
+    struct CpuTemperature
+    {
+        float current;
+        float max;
+        float critical;
+    };
+} // namespace metrics

src/metrics/Host.cpp

@@ -39,8 +39,12 @@ namespace metrics
         buf.writeUint8(static_cast<uint8_t>(cpu.coreLoads.size()));
         for (float f : cpu.coreLoads)
             buf.writeFloat(f);
-        for (float f : cpu.coreTemps)
-            buf.writeFloat(f);
+        for (const auto &f : cpu.coreTemps)
+        {
+            buf.writeFloat(f.current);
+            buf.writeFloat(f.max);
+            buf.writeFloat(f.critical);
+        }
 
         // Memory
         buf.writeUint64(memory.memory.used);
@@ -86,7 +90,7 @@ namespace metrics
         h.cpu.coreTemps.clear();
         h.cpu.coreTemps.reserve(numCpu);
         for (uint8_t i = 0; i < numCpu; ++i)
-            h.cpu.coreTemps.push_back(buf.readFloat());
+            h.cpu.coreTemps.push_back({buf.readFloat(), buf.readFloat(), buf.readFloat()});
 
         // Memory
         h.memory.memory.used = buf.readUint64();