Add CPU saturation-pct min/max ODS metrics for allotment monitoring

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,69 @@ std::optional<double> CPUTimeMonitor::getCpuBreakdownMax(
   return getCpuBreakdownMinOrMax(gran, seconds_ago, breakdown, targetId, false);
 }
 
+// Min/max for overall CPU cores usage (saturation). Honors the same
+// readCgroupStat_ fallback as getAvg/Quantile: if cgroup stat collection is
+// disabled, a CGROUP_STAT request falls back to PROC_STAT data.
+std::optional<double> CPUTimeMonitor::getMinCPUCoresUsage(
+    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_);
+
+  auto levelOpt = granularityToLevel(gran);
+  if (!levelOpt.has_value()) {
+    return std::nullopt;
+  }
+  int level = *levelOpt;
+
+  auto& frame = (readCgroupStat_ && dataSource == DataSource::CGROUP_STAT)
+      ? cgroupUsageMetricFrames_[level]
+      : procUsageMetricFrames_[level];
+  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();
+  return *std::min_element(data.begin(), data.end());
+}
+
+std::optional<double> CPUTimeMonitor::getMaxCPUCoresUsage(
+    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_);
+
+  auto levelOpt = granularityToLevel(gran);
+  if (!levelOpt.has_value()) {
+    return std::nullopt;
+  }
+  int level = *levelOpt;
+
+  auto& frame = (readCgroupStat_ && dataSource == DataSource::CGROUP_STAT)
+      ? cgroupUsageMetricFrames_[level]
+      : procUsageMetricFrames_[level];
+  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();
+  return *std::max_element(data.begin(), data.end());
+}
+
 void CPUTimeMonitor::tick(TMask mask) {
   TimePoint tickTime = std::chrono::steady_clock::now();
   bool readPerCore = false;

dynolog/src/CPUTimeMonitor.h

@@ -117,6 +117,18 @@ 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);
+
  private:
   std::optional<double> getCpuBreakdownMinOrMax(
       Granularity gran,

dynolog/tests/CPUTimeMonitorTest.cpp

@@ -1095,6 +1095,50 @@ TEST_F(CPUTimeMonitorTest, testBreakdownMinMax) {
   monitor->deRegisterTarget("minmax_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_F(CPUTimeMonitorTest, testMinMaxCgroupStatFallback) {
+  monitor->tick(major_tick_60s);
+  monitor->tick(major_tick_60s);
+
+  auto minProc = monitor->getMinCPUCoresUsage(
+      CPUTimeMonitor::Granularity::MINUTE,
+      60,
+      std::nullopt,
+      CPUTimeMonitor::DataSource::PROC_STAT);
+  auto minCgroup = monitor->getMinCPUCoresUsage(
+      CPUTimeMonitor::Granularity::MINUTE,
+      60,
+      std::nullopt,
+      CPUTimeMonitor::DataSource::CGROUP_STAT);
+
+  ASSERT_TRUE(minProc.has_value());
+  ASSERT_TRUE(minCgroup.has_value());
+}
+
 TEST_F(CPUTimeMonitorTest, testBreakdownMinMaxNulloptAfterDeregister) {
   monitor->registerTarget("dereg_test", {0, 1});
   monitor->tick(major_tick_60s);