Add CPU saturation-pct min/max ODS metrics for allotment monitoring (#558)

Summary:

Adds min.60/max.60 aggregations for cpu.saturation-pct, extracted from D104745222 for a cleaner diff stack.

New ODS keys (gated with TargetedOdsFilter defaultPublish=false):
- dyno.allotment.cpu.saturation-pct.min.60
- dyno.allotment.cpu.saturation-pct.max.60

These use the same /proc/stat PROC_STAT data source as the existing saturation-pct avg and percentile metrics, with the readCgroupStat_ fallback honored. Values are normalized to percentage of the allotment cpuSaturationLimit.

Adds getMinCPUCoresUsage() and getMaxCPUCoresUsage() to CPUTimeMonitor using raw() + std::min/max_element since MetricSeries lacks built-in min/max.

Design doc: https://docs.google.com/document/d/16ea49QzoL60PTtFQ0DXss4Bmq7aCnSGh4MuG9phMmO0/edit

Differential Revision: D105619438

Author: cmgrace

dynolog/src/CPUTimeMonitor.cpp

@@ -306,6 +306,50 @@ std::optional<double> CPUTimeMonitor::getCpuBreakdownMax(
   return result ? std::optional(result->second) : std::nullopt;
 }
 
+std::optional<std::pair<double, double>> CPUTimeMonitor::getMinMaxCPUCoresUsage(
+    Granularity gran,
+    uint64_t seconds_ago,
+    const std::optional<std::string>& targetId,
+    DataSource dataSource) {
+  TimePoint now = std::chrono::steady_clock::now();
+  std::shared_lock lock(dataLock_);
+
+  const auto* frame = getMetricFrame(gran, dataSource);
+  if (frame == nullptr) {
+    return std::nullopt;
+  }
+  auto slice = frame->slice(now - std::chrono::seconds(seconds_ago), now);
+  if (slice == std::nullopt) {
+    return std::nullopt;
+  }
+  std::string key = targetId.value_or("host");
+  auto series = slice->series<double>(key);
+  if (series == std::nullopt || series->size() == 0) {
+    return std::nullopt;
+  }
+  auto data = series->raw();
+  auto [minIt, maxIt] = std::minmax_element(data.begin(), data.end());
+  return std::make_pair(*minIt, *maxIt);
+}
+
+std::optional<double> CPUTimeMonitor::getMinCPUCoresUsage(
+    Granularity gran,
+    uint64_t seconds_ago,
+    const std::optional<std::string>& targetId,
+    DataSource dataSource) {
+  auto result = getMinMaxCPUCoresUsage(gran, seconds_ago, targetId, dataSource);
+  return result ? std::optional(result->first) : std::nullopt;
+}
+
+std::optional<double> CPUTimeMonitor::getMaxCPUCoresUsage(
+    Granularity gran,
+    uint64_t seconds_ago,
+    const std::optional<std::string>& targetId,
+    DataSource dataSource) {
+  auto result = getMinMaxCPUCoresUsage(gran, seconds_ago, targetId, dataSource);
+  return result ? std::optional(result->second) : std::nullopt;
+}
+
 void CPUTimeMonitor::tick(TMask mask) {
   TimePoint tickTime = std::chrono::steady_clock::now();
   bool readPerCore = false;

dynolog/src/CPUTimeMonitor.h

@@ -124,6 +124,24 @@ class CPUTimeMonitor : MonitorBase<Ticker<60000, 1000, 10, 3>> {
       CpuBreakdown breakdown,
       const std::optional<std::string>& targetId = std::nullopt);
 
+  std::optional<double> getMinCPUCoresUsage(
+      Granularity gran,
+      uint64_t seconds_ago,
+      const std::optional<std::string>& targetId = std::nullopt,
+      DataSource dataSource = DataSource::PROC_STAT);
+
+  std::optional<double> getMaxCPUCoresUsage(
+      Granularity gran,
+      uint64_t seconds_ago,
+      const std::optional<std::string>& targetId = std::nullopt,
+      DataSource dataSource = DataSource::PROC_STAT);
+
+  std::optional<std::pair<double, double>> getMinMaxCPUCoresUsage(
+      Granularity gran,
+      uint64_t seconds_ago,
+      const std::optional<std::string>& targetId = std::nullopt,
+      DataSource dataSource = DataSource::PROC_STAT);
+
  private:
   enum class Statistic { AVG, QUANTILE };
 

dynolog/tests/CPUTimeMonitorTest.cpp

@@ -1124,6 +1124,55 @@ TEST_F(CPUTimeMonitorTest, testBreakdownMinMaxCombined) {
   monitor->deRegisterTarget("combined_test");
 }
 
+TEST_F(CPUTimeMonitorTest, testMinMaxCPUCoresUsage) {
+  monitor->registerTarget("cores_test", {0, 1, 2, 3});
+  monitor->tick(major_tick_60s);
+  monitor->tick(major_tick_60s);
+
+  for (const auto& gran :
+       {CPUTimeMonitor::Granularity::MINUTE,
+        CPUTimeMonitor::Granularity::SECOND}) {
+    auto minVal = monitor->getMinCPUCoresUsage(
+        gran, 60, "cores_test", CPUTimeMonitor::DataSource::PROC_STAT);
+    auto maxVal = monitor->getMaxCPUCoresUsage(
+        gran, 60, "cores_test", CPUTimeMonitor::DataSource::PROC_STAT);
+    auto avgVal = monitor->getAvgCPUCoresUsage(
+        gran, 60, "cores_test", CPUTimeMonitor::DataSource::PROC_STAT);
+
+    ASSERT_TRUE(minVal.has_value());
+    ASSERT_TRUE(maxVal.has_value());
+    ASSERT_TRUE(avgVal.has_value());
+    EXPECT_LE(minVal.value(), avgVal.value());
+    EXPECT_LE(avgVal.value(), maxVal.value());
+  }
+
+  monitor->deRegisterTarget("cores_test");
+}
+
+TEST(CPUTimeMonitorFallbackTest, testMinMaxCgroupStatFallback) {
+  // readCgroupStat=false: CGROUP_STAT requests fall back to PROC_STAT data
+  auto ticker = std::make_shared<CPUTimeMonitor::TTicker>();
+  auto mon = std::make_shared<CPUTimeMonitor>(
+      ticker, false, coreCount, getenv("TESTROOT"), true);
+  mon->tick(major_tick_60s);
+  mon->tick(major_tick_60s);
+
+  auto minProc = mon->getMinCPUCoresUsage(
+      CPUTimeMonitor::Granularity::MINUTE,
+      60,
+      std::nullopt,
+      CPUTimeMonitor::DataSource::PROC_STAT);
+  auto minCgroup = mon->getMinCPUCoresUsage(
+      CPUTimeMonitor::Granularity::MINUTE,
+      60,
+      std::nullopt,
+      CPUTimeMonitor::DataSource::CGROUP_STAT);
+
+  ASSERT_TRUE(minProc.has_value());
+  ASSERT_TRUE(minCgroup.has_value());
+  EXPECT_DOUBLE_EQ(minProc.value(), minCgroup.value());
+}
+
 TEST_F(CPUTimeMonitorTest, testBreakdownMinMaxNulloptAfterDeregister) {
   monitor->registerTarget("dereg_test", {0, 1});
   monitor->tick(major_tick_60s);