Schematized Monitor part1 - Create MetricInfo in MetricFrameBase

Summary:
create metricInfo class that contains the following information of metrics:
```
MetricInfo {
    metricName: cpu_time
    handler:
            TwTaskMetricHanlder.getCPUTime()
    validation:
            cpu_time >=0,
            cpu_time <= cpu_time_limit
    granularity: 
            second,
            minute
    aggregation: 
            p99, 
            p90    
    inclusion:
            LST/LSST
            / cpu_architacture(e.g. COOPER LAKE)
            / cpu_model(e.g. AMD)
            / kernel_version
    exclusion:
            (same as inclusion)
    criticality:
            high/low
} 

*criticality: if high criticality, means when data is missing to a certain level,
it should trigger a sev
```
the goal is to optimize data consumability workflow as:
 {F1983199684}

Differential Revision: D85995164

Author: cmgrace

dynolog/src/metric_frame/MetricFrameBase.cpp

@@ -119,4 +119,131 @@ MetricFrameSlice::MetricFrameSlice(
     MetricFrameRange range)
     : frame_{frame}, range_{range} {}
 
+// validation rule constructor and methods
+ValidationRule::ValidationRule(Type type, double targetValue)
+    : type_(type), targetValue_(targetValue) {}
+
+ValidationRule ValidationRule::min(double minValue) {
+  return ValidationRule(Type::MIN, minValue);
+}
+
+ValidationRule ValidationRule::max(double maxValue) {
+  return ValidationRule(Type::MAX, maxValue);
+}
+
+ValidationRule ValidationRule::lessThan(double targetValue) {
+  return ValidationRule(Type::LESS_THAN, targetValue);
+}
+
+ValidationRule ValidationRule::greaterThan(double targetValue) {
+  return ValidationRule(Type::GREATER_THAN, targetValue);
+}
+
+bool ValidationRule::validate(double value, ValidationRule validationRule)
+    const {
+  auto& type = validationRule.type_;
+  auto& targetValue = validationRule.targetValue_;
+  switch (type) {
+    case Type::MIN:
+      return value >= targetValue;
+
+    case Type::MAX:
+      return value <= targetValue;
+
+    case Type::LESS_THAN:
+      return value < targetValue;
+
+    case Type::GREATER_THAN:
+      return value > targetValue;
+
+    default:
+      return false;
+  }
+}
+
+// MetricInfo constructor and methods
+MetricInfo::MetricInfo(
+    MetricName metricName,
+    std::vector<MGranularity> granularities,
+    std::vector<Aggregation> aggregations,
+    Aggregation defaultAggregation,
+    HandlerFunc handler,
+    std::vector<ValidationRule> validationRules,
+    std::map<Category, std::vector<std::string>> inclusion,
+    std::map<Category, std::vector<std::string>> exclusion,
+    Criticality criticality)
+    : metricName_(metricName),
+      granularities_(std::move(granularities)),
+      aggregations_(std::move(aggregations)),
+      defaultAggregation_(defaultAggregation),
+      handler_(std::move(handler)),
+      validationRules_(std::move(validationRules)),
+      inclusion_(std::move(inclusion)),
+      exclusion_(std::move(exclusion)),
+      criticality_(criticality) {}
+
+const MetricName& MetricInfo::metricName() const {
+  return metricName_;
+}
+
+const std::vector<MGranularity>& MetricInfo::granularities() const {
+  return granularities_;
+}
+
+const std::vector<Aggregation>& MetricInfo::aggregations() const {
+  return aggregations_;
+}
+
+const Aggregation& MetricInfo::defaultAggregation() const {
+  return defaultAggregation_;
+}
+
+HandlerFunc MetricInfo::handler() const {
+  return handler_;
+}
+
+const std::vector<ValidationRule>& MetricInfo::validationRules() const {
+  return validationRules_;
+}
+
+const std::map<Category, std::vector<std::string>>& MetricInfo::inclusion()
+    const {
+  return inclusion_;
+}
+
+const std::map<Category, std::vector<std::string>>& MetricInfo::exclusion()
+    const {
+  return exclusion_;
+}
+
+Criticality MetricInfo::criticality() const {
+  return criticality_;
+}
+
+// MetricInfoMap constructor and methods
+MetricInfoMap::MetricInfoMap(std::map<MetricName, MetricInfo> metricInfoMap)
+    : metricInfoMap_(std::move(metricInfoMap)) {}
+
+std::optional<MetricInfo> MetricInfoMap::getMetricInfo(
+    MetricName metricName) const {
+  auto it = metricInfoMap_.find(metricName);
+  if (it != metricInfoMap_.end()) {
+    return it->second;
+  }
+  return std::nullopt;
+}
+
+bool MetricInfoMap::contains(MetricName metricName) const {
+  return metricInfoMap_.find(metricName) != metricInfoMap_.end();
+}
+
+const std::map<MetricName, MetricInfo>& MetricInfoMap::getMetricInfoMap()
+    const {
+  return metricInfoMap_;
+}
+
+void MetricInfoMap::add(MetricName metricName, MetricInfo metricInfo) {
+  metricInfoMap_.insert_or_assign(metricName, std::move(metricInfo));
+}
+
 } // namespace facebook::dynolog

dynolog/src/metric_frame/MetricFrameBase.h

@@ -7,17 +7,30 @@
 
 #pragma once
 
-#include "dynolog/src/metric_frame/MetricFrameTsUnitInterface.h"
-#include "dynolog/src/metric_frame/MetricSeries.h"
-#include "dynolog/src/metric_frame/TextTable.h"
-
 #include <chrono>
+#include <functional>
 #include <memory>
+#include <optional>
+#include <ostream>
 #include <string>
 #include <variant>
+#include <vector>
+
+#include "dyno/if/gen-cpp2/dynolog_schematized_types.h"
+#include "dynolog/src/metric_frame/ExtraTypes.h"
+#include "dynolog/src/metric_frame/MetricFrameTsUnitInterface.h"
+#include "dynolog/src/metric_frame/MetricSeries.h"
+#include "dynolog/src/metric_frame/TextTable.h"
 
 namespace facebook::dynolog {
 
+using ::facebook::dynolog_schematized::Aggregation;
+using ::facebook::dynolog_schematized::DynoLogSchematizedResponse;
+using MGranularity = facebook::dynolog_schematized::Granularity;
+using ::facebook::dynolog_schematized::Identifier;
+using ::facebook::dynolog_schematized::MetricName;
+using ::facebook::dynolog_schematized::Scope;
+
 using SampleVarT = std::variant<int64_t, uint64_t, double, PerfReadValues>;
 using MetricSeriesInt64Ptr = std::shared_ptr<MetricSeries<int64_t>>;
 using MetricSeriesUint64Ptr = std::shared_ptr<MetricSeries<uint64_t>>;
@@ -216,4 +229,108 @@ class MetricFrameSlice {
 
 std::ostream& operator<<(std::ostream& s, const MetricFrameBase& frame);
 
+// validation rule types
+enum class Type {
+  MIN, // value >= min
+  MAX, // value <= max
+  LESS_THAN, // value < target_value
+  GREATER_THAN, // value > target_value
+};
+
+class ValidationRule {
+ public:
+  // Validation rule types
+  explicit ValidationRule(Type type, double targetValue);
+
+  // generate a validation rule with min/max range
+  static ValidationRule min(double minValue);
+  static ValidationRule max(double maxValue);
+  static ValidationRule lessThan(double targetValue);
+  static ValidationRule greaterThan(double targetValue);
+
+  // Validate a value against its validation rule
+  bool validate(double value, ValidationRule validationRule) const;
+
+ private:
+  Type type_;
+  double targetValue_;
+};
+
+using HandlerFunc = std::function<void(
+    DynoLogSchematizedResponse&,
+    Identifier&,
+    Scope,
+    MGranularity,
+    Aggregation,
+    uint64_t)>;
+
+// Criticality levels for metrics
+enum class Criticality {
+  LOW,
+  HIGH,
+};
+
+// Include/exclude category for metrics
+enum class Category {
+  LST,
+  LSST,
+  CPU_ARCH,
+  CPU_MODEL,
+  KERNEL_VERSION,
+};
+class MetricInfo {
+ public:
+  MetricInfo(
+      MetricName metricName,
+      std::vector<MGranularity> granularities,
+      std::vector<Aggregation> aggregations,
+      Aggregation defaultAggregation,
+      HandlerFunc handler,
+      std::vector<ValidationRule> validationRules,
+      std::map<Category, std::vector<std::string>> inclusion,
+      std::map<Category, std::vector<std::string>> exclusion,
+      Criticality criticality);
+  virtual ~MetricInfo() = default;
+  const MetricName& metricName() const;
+  const std::vector<MGranularity>& granularities() const;
+  const std::vector<Aggregation>& aggregations() const;
+  const Aggregation& defaultAggregation() const;
+  HandlerFunc handler() const;
+  const std::vector<ValidationRule>& validationRules() const;
+  const std::map<Category, std::vector<std::string>>& inclusion() const;
+  const std::map<Category, std::vector<std::string>>& exclusion() const;
+  Criticality criticality() const;
+
+ private:
+  MetricName metricName_;
+  std::vector<MGranularity> granularities_;
+  std::vector<Aggregation> aggregations_;
+  Aggregation defaultAggregation_;
+  HandlerFunc handler_;
+  std::vector<ValidationRule> validationRules_;
+  std::map<Category, std::vector<std::string>> inclusion_;
+  std::map<Category, std::vector<std::string>> exclusion_;
+  Criticality criticality_;
+};
+
+class MetricInfoMap {
+ public:
+  explicit MetricInfoMap(std::map<MetricName, MetricInfo> metricInfoMap);
+
+  // Get the entire map
+  const std::map<MetricName, MetricInfo>& getMetricInfoMap() const;
+
+  // Get MetricInfo for a specific metric name
+  std::optional<MetricInfo> getMetricInfo(MetricName metricName) const;
+
+  // Check if a metric is registered
+  bool contains(MetricName metricName) const;
+
+  // Add or update a MetricInfo
+  void add(MetricName metricName, MetricInfo metricInfo);
+
+ private:
+  std::map<MetricName, MetricInfo> metricInfoMap_;
+};
+
 } // namespace facebook::dynolog