tablets with disabled metrics ignore metric-related balancers (#4052)

vporyadke · web-flow · commit 8a1ba16ffaa0 · 2024-04-25T09:58:27.000+02:00
diff --git a/ydb/core/mind/hive/balancer.cpp b/ydb/core/mind/hive/balancer.cpp
@@ -243,7 +243,9 @@ class THiveBalancer : public NActors::TActorBootstrapped<THiveBalancer>, public
             std::vector<TTabletInfo*> tablets;
             tablets.reserve(nodeTablets.size());
             for (TTabletInfo* tablet : nodeTablets) {
-                if (tablet->IsGoodForBalancer(now) && (!Settings.FilterObjectId || tablet->GetObjectId() == *Settings.FilterObjectId)) {
+                if (tablet->IsGoodForBalancer(now) && 
+                    (!Settings.FilterObjectId || tablet->GetObjectId() == *Settings.FilterObjectId) &&
+                    tablet->HasAllowedMetric(Settings.ResourceToBalance)) {
                     tablet->UpdateWeight();
                     tablets.emplace_back(tablet);
                 }
diff --git a/ydb/core/mind/hive/hive.h b/ydb/core/mind/hive/hive.h
@@ -98,7 +98,7 @@ constexpr std::size_t EBalancerTypeSize = static_cast<std::size_t>(EBalancerType
 TString EBalancerTypeName(EBalancerType value);
 
 enum class EResourceToBalance {
-    Dominant,
+    ComputeResources,
     Counter,
     CPU,
     Memory,
@@ -296,7 +296,7 @@ struct TBalancerSettings {
     bool RecheckOnFinish = false;
     ui64 MaxInFlight = 1;
     const std::vector<TNodeId> FilterNodeIds = {};
-    EResourceToBalance ResourceToBalance = EResourceToBalance::Dominant;
+    EResourceToBalance ResourceToBalance = EResourceToBalance::ComputeResources;
     std::optional<TFullObjectId> FilterObjectId;
 };
 
diff --git a/ydb/core/mind/hive/hive_impl.cpp b/ydb/core/mind/hive/hive_impl.cpp
@@ -2373,7 +2373,7 @@ void THive::Handle(TEvPrivate::TEvProcessTabletBalancer::TPtr&) {
             case EResourceToBalance::Network:
                 balancerType = EBalancerType::ScatterNetwork;
                 break;
-            case EResourceToBalance::Dominant:
+            case EResourceToBalance::ComputeResources:
                 balancerType = EBalancerType::Scatter;
                 break;
         }
diff --git a/ydb/core/mind/hive/node_info.cpp b/ydb/core/mind/hive/node_info.cpp
@@ -222,7 +222,7 @@ i32 TNodeInfo::GetPriorityForTablet(const TTabletInfo& tablet) const {
 
 bool TNodeInfo::IsAbleToRunTablet(const TTabletInfo& tablet, TTabletDebugState* debugState) const {
     if (tablet.IsAliveOnLocal(Local)) {
-        return !IsOverloaded();
+        return !(IsOverloaded() && tablet.HasAllowedMetric(EResourceToBalance::ComputeResources));
     }
     if (tablet.IsLeader()) {
         const TLeaderTabletInfo& leader = tablet.AsLeader();
@@ -280,7 +280,7 @@ bool TNodeInfo::IsAbleToRunTablet(const TTabletInfo& tablet, TTabletDebugState*
         }
     }
 
-    if (tablet.IsAlive() && IsOverloaded()) {
+    if (tablet.IsAlive() && IsOverloaded() && tablet.HasAllowedMetric(EResourceToBalance::ComputeResources)) {
         // we don't move already running tablet to another overloaded node
         if (debugState) {
             debugState->NodesWithoutResources++;
@@ -434,7 +434,7 @@ double TNodeInfo::GetNodeUsageForTablet(const TTabletInfo& tablet) const {
 
 double TNodeInfo::GetNodeUsage(const TResourceNormalizedValues& normValues, EResourceToBalance resource) const {
     double usage = TTabletInfo::ExtractResourceUsage(normValues, resource);
-    if (resource == EResourceToBalance::Dominant && AveragedNodeTotalUsage.IsValueStable()) {
+    if (resource == EResourceToBalance::ComputeResources && AveragedNodeTotalUsage.IsValueStable()) {
         usage = std::max(usage, AveragedNodeTotalUsage.GetValue());
     }
     return usage;
diff --git a/ydb/core/mind/hive/node_info.h b/ydb/core/mind/hive/node_info.h
@@ -243,9 +243,9 @@ struct TNodeInfo {
     }
 
     double GetNodeUsageForTablet(const TTabletInfo& tablet) const;
-    double GetNodeUsage(EResourceToBalance resource = EResourceToBalance::Dominant) const;
+    double GetNodeUsage(EResourceToBalance resource = EResourceToBalance::ComputeResources) const;
     double GetNodeUsage(const TResourceNormalizedValues& normValues,
-                        EResourceToBalance resource = EResourceToBalance::Dominant) const;
+                        EResourceToBalance resource = EResourceToBalance::ComputeResources) const;
 
     ui64 GetTabletsRunningByType(TTabletTypes::EType tabletType) const;
 
diff --git a/ydb/core/mind/hive/tablet_info.cpp b/ydb/core/mind/hive/tablet_info.cpp
@@ -310,12 +310,37 @@ const TVector<i64>& TTabletInfo::GetTabletAllowedMetricIds() const {
     return Hive.GetTabletTypeAllowedMetricIds(GetLeader().Type);
 }
 
+bool TTabletInfo::HasAllowedMetric(const TVector<i64>& allowedMetricIds, EResourceToBalance resource) {
+    switch (resource) {
+        case EResourceToBalance::ComputeResources: { 
+            auto isComputeMetric = [](i64 metricId) {
+                return metricId == NKikimrTabletBase::TMetrics::kCPUFieldNumber ||
+                       metricId == NKikimrTabletBase::TMetrics::kMemoryFieldNumber ||
+                       metricId == NKikimrTabletBase::TMetrics::kNetworkFieldNumber;
+            };
+            return AnyOf(allowedMetricIds.begin(), allowedMetricIds.end(), isComputeMetric);
+        }
+        case EResourceToBalance::Counter:
+            return true;
+        case EResourceToBalance::CPU:
+            return Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kCPUFieldNumber) != allowedMetricIds.end();
+        case EResourceToBalance::Memory:
+            return Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kMemoryFieldNumber) != allowedMetricIds.end();
+        case EResourceToBalance::Network:
+            return Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kNetworkFieldNumber) != allowedMetricIds.end();
+    }
+}
+
+bool TTabletInfo::HasAllowedMetric(EResourceToBalance resource) const {
+    return HasAllowedMetric(GetTabletAllowedMetricIds(), resource);
+}
+
 void TTabletInfo::UpdateResourceUsage(const NKikimrTabletBase::TMetrics& metrics) {
     TInstant now = TActivationContext::Now();
     const TVector<i64>& allowedMetricIds(GetTabletAllowedMetricIds());
     auto before = ResourceValues;
     auto maximum = GetResourceMaximumValues();
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kCPUFieldNumber) != allowedMetricIds.end()) {
+    if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::CPU)) {
         if (metrics.HasCPU()) {
             if (metrics.GetCPU() > static_cast<ui64>(std::get<NMetrics::EResource::CPU>(maximum))) {
                 BLOG_W("Ignoring too high CPU metric (" << metrics.GetCPU() << ") for tablet " << ToString());
@@ -325,7 +350,7 @@ void TTabletInfo::UpdateResourceUsage(const NKikimrTabletBase::TMetrics& metrics
             }
         }
     }
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kMemoryFieldNumber) != allowedMetricIds.end()) {
+    if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::Memory)) {
         if (metrics.HasMemory()) {
             if (metrics.GetMemory() > static_cast<ui64>(std::get<NMetrics::EResource::Memory>(maximum))) {
                 BLOG_W("Ignoring too high Memory metric (" << metrics.GetMemory() << ") for tablet " << ToString());
@@ -335,7 +360,7 @@ void TTabletInfo::UpdateResourceUsage(const NKikimrTabletBase::TMetrics& metrics
             }
         }
     }
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kNetworkFieldNumber) != allowedMetricIds.end()) {
+    if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::Network)) {
         if (metrics.HasNetwork()) {
             if (metrics.GetNetwork() > static_cast<ui64>(std::get<NMetrics::EResource::Network>(maximum))) {
                 BLOG_W("Ignoring too high Network metric (" << metrics.GetNetwork() << ") for tablet " << ToString());
@@ -396,13 +421,13 @@ TResourceRawValues TTabletInfo::GetResourceMaximumValues() const {
 }
 
 i64 TTabletInfo::GetCounterValue(const NKikimrTabletBase::TMetrics& metrics, const TVector<i64>& allowedMetricIds) {
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kCPUFieldNumber) != allowedMetricIds.end() && THive::IsValidMetricsCPU(metrics)) {
+    if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::CPU) && THive::IsValidMetricsCPU(metrics)) {
         return 0;
     }
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kMemoryFieldNumber) != allowedMetricIds.end() && THive::IsValidMetricsMemory(metrics)) {
+    if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::Memory) && THive::IsValidMetricsMemory(metrics)) {
         return 0;
     }
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kNetworkFieldNumber) != allowedMetricIds.end() && THive::IsValidMetricsNetwork(metrics)) {
+    if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::Network) && THive::IsValidMetricsNetwork(metrics)) {
         return 0;
     }
     return 1;
@@ -414,13 +439,13 @@ void TTabletInfo::FilterRawValues(TResourceRawValues& values) const {
     if (metrics.GetCounter() == 0) {
         std::get<NMetrics::EResource::Counter>(values) = 0;
     }
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kCPUFieldNumber) == allowedMetricIds.end() || !THive::IsValidMetricsCPU(metrics)) {
+    if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::CPU) || !THive::IsValidMetricsCPU(metrics)) {
         std::get<NMetrics::EResource::CPU>(values) = 0;
     }
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kMemoryFieldNumber) == allowedMetricIds.end() || !THive::IsValidMetricsMemory(metrics)) {
+    if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::Memory) || !THive::IsValidMetricsMemory(metrics)) {
         std::get<NMetrics::EResource::Memory>(values) = 0;
     }
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kNetworkFieldNumber) == allowedMetricIds.end() || !THive::IsValidMetricsNetwork(metrics)) {
+    if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::Network) || !THive::IsValidMetricsNetwork(metrics)) {
         std::get<NMetrics::EResource::Network>(values) = 0;
     }
 }
@@ -431,13 +456,13 @@ void TTabletInfo::FilterRawValues(TResourceNormalizedValues& values) const {
     if (metrics.GetCounter() == 0) {
         std::get<NMetrics::EResource::Counter>(values) = 0;
     }
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kCPUFieldNumber) == allowedMetricIds.end() || !THive::IsValidMetricsCPU(metrics)) {
+    if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::CPU) || !THive::IsValidMetricsCPU(metrics)) {
         std::get<NMetrics::EResource::CPU>(values) = 0;
     }
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kMemoryFieldNumber) == allowedMetricIds.end() || !THive::IsValidMetricsMemory(metrics)) {
+    if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::Memory) || !THive::IsValidMetricsMemory(metrics)) {
         std::get<NMetrics::EResource::Memory>(values) = 0;
     }
-    if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kNetworkFieldNumber) == allowedMetricIds.end() || !THive::IsValidMetricsNetwork(metrics)) {
+    if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::Network) || !THive::IsValidMetricsNetwork(metrics)) {
         std::get<NMetrics::EResource::Network>(values) = 0;
     }
 }
diff --git a/ydb/core/mind/hive/tablet_info.h b/ydb/core/mind/hive/tablet_info.h
@@ -227,6 +227,8 @@ struct TTabletInfo {
     void BecomeUnknown(TNodeInfo* node);
     bool Kick();
     const TVector<i64>& GetTabletAllowedMetricIds() const;
+    static bool HasAllowedMetric(const TVector<i64>& allowedMetricIds, EResourceToBalance resource);
+    bool HasAllowedMetric(EResourceToBalance resource) const;
 
     void UpdateResourceUsage(const NKikimrTabletBase::TMetrics& metrics);
     TResourceRawValues GetResourceCurrentValues() const;
@@ -237,18 +239,18 @@ struct TTabletInfo {
     void ActualizeCounter();
 
     template <typename ResourcesType>
-    static double GetUsage(const ResourcesType& current, const ResourcesType& maximum, EResourceToBalance resource = EResourceToBalance::Dominant) {
+    static double GetUsage(const ResourcesType& current, const ResourcesType& maximum, EResourceToBalance resource = EResourceToBalance::ComputeResources) {
         auto normValues = NormalizeRawValues(current, maximum);
         return ExtractResourceUsage(normValues, resource);
     }
 
-    static double ExtractResourceUsage(const TResourceNormalizedValues& normValues, EResourceToBalance resource = EResourceToBalance::Dominant) {
+    static double ExtractResourceUsage(const TResourceNormalizedValues& normValues, EResourceToBalance resource = EResourceToBalance::ComputeResources) {
         switch (resource) {
         case EResourceToBalance::CPU: return std::get<NMetrics::EResource::CPU>(normValues);
         case EResourceToBalance::Memory: return std::get<NMetrics::EResource::Memory>(normValues);
         case EResourceToBalance::Network: return std::get<NMetrics::EResource::Network>(normValues);
         case EResourceToBalance::Counter: return std::get<NMetrics::EResource::Counter>(normValues);
-        case EResourceToBalance::Dominant: return max(normValues);
+        case EResourceToBalance::ComputeResources: return max(normValues);
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -2373,7 +2373,7 @@ void THive::Handle(TEvPrivate::TEvProcessTabletBalancer::TPtr&) {`
`2373`	`2373`	`case EResourceToBalance::Network:`
`2374`	`2374`	`balancerType = EBalancerType::ScatterNetwork;`
`2375`	`2375`	`break;`
`2376`		`- case EResourceToBalance::Dominant:`
	`2376`	`+ case EResourceToBalance::ComputeResources:`
`2377`	`2377`	`balancerType = EBalancerType::Scatter;`
`2378`	`2378`	`break;`
`2379`	`2379`	`}`
Original file line number	Diff line number	Diff line change
`@@ -222,7 +222,7 @@ i32 TNodeInfo::GetPriorityForTablet(const TTabletInfo& tablet) const {`
`222`	`222`
`223`	`223`	`bool TNodeInfo::IsAbleToRunTablet(const TTabletInfo& tablet, TTabletDebugState* debugState) const {`
`224`	`224`	`if (tablet.IsAliveOnLocal(Local)) {`
`225`		`- return !IsOverloaded();`
	`225`	`+ return !(IsOverloaded() && tablet.HasAllowedMetric(EResourceToBalance::ComputeResources));`
`226`	`226`	`}`
`227`	`227`	`if (tablet.IsLeader()) {`
`228`	`228`	`const TLeaderTabletInfo& leader = tablet.AsLeader();`
`@@ -280,7 +280,7 @@ bool TNodeInfo::IsAbleToRunTablet(const TTabletInfo& tablet, TTabletDebugState*`
`280`	`280`	`}`
`281`	`281`	`}`
`282`	`282`
`283`		`- if (tablet.IsAlive() && IsOverloaded()) {`
	`283`	`+ if (tablet.IsAlive() && IsOverloaded() && tablet.HasAllowedMetric(EResourceToBalance::ComputeResources)) {`
`284`	`284`	`// we don't move already running tablet to another overloaded node`
`285`	`285`	`if (debugState) {`
`286`	`286`	`debugState->NodesWithoutResources++;`
`@@ -434,7 +434,7 @@ double TNodeInfo::GetNodeUsageForTablet(const TTabletInfo& tablet) const {`
`434`	`434`
`435`	`435`	`double TNodeInfo::GetNodeUsage(const TResourceNormalizedValues& normValues, EResourceToBalance resource) const {`
`436`	`436`	`double usage = TTabletInfo::ExtractResourceUsage(normValues, resource);`
`437`		`- if (resource == EResourceToBalance::Dominant && AveragedNodeTotalUsage.IsValueStable()) {`
	`437`	`+ if (resource == EResourceToBalance::ComputeResources && AveragedNodeTotalUsage.IsValueStable()) {`
`438`	`438`	`usage = std::max(usage, AveragedNodeTotalUsage.GetValue());`
`439`	`439`	`}`
`440`	`440`	`return usage;`
Original file line number	Diff line number	Diff line change
`@@ -243,9 +243,9 @@ struct TNodeInfo {`
`243`	`243`	`}`
`244`	`244`
`245`	`245`	`double GetNodeUsageForTablet(const TTabletInfo& tablet) const;`
`246`		`- double GetNodeUsage(EResourceToBalance resource = EResourceToBalance::Dominant) const;`
	`246`	`+ double GetNodeUsage(EResourceToBalance resource = EResourceToBalance::ComputeResources) const;`
`247`	`247`	`double GetNodeUsage(const TResourceNormalizedValues& normValues,`
`248`		`- EResourceToBalance resource = EResourceToBalance::Dominant) const;`
	`248`	`+ EResourceToBalance resource = EResourceToBalance::ComputeResources) const;`
`249`	`249`
`250`	`250`	`ui64 GetTabletsRunningByType(TTabletTypes::EType tabletType) const;`
`251`	`251`
Original file line number	Diff line number	Diff line change
`@@ -310,12 +310,37 @@ const TVector<i64>& TTabletInfo::GetTabletAllowedMetricIds() const {`
`310`	`310`	`return Hive.GetTabletTypeAllowedMetricIds(GetLeader().Type);`
`311`	`311`	`}`
`312`	`312`
	`313`	`+bool TTabletInfo::HasAllowedMetric(const TVector<i64>& allowedMetricIds, EResourceToBalance resource) {`
	`314`	`+ switch (resource) {`
	`315`	`+ case EResourceToBalance::ComputeResources: {`
	`316`	`+ auto isComputeMetric = [](i64 metricId) {`
	`317`	`+ return metricId == NKikimrTabletBase::TMetrics::kCPUFieldNumber \|\|`
	`318`	`+ metricId == NKikimrTabletBase::TMetrics::kMemoryFieldNumber \|\|`
	`319`	`+ metricId == NKikimrTabletBase::TMetrics::kNetworkFieldNumber;`
	`320`	`+ };`
	`321`	`+ return AnyOf(allowedMetricIds.begin(), allowedMetricIds.end(), isComputeMetric);`
	`322`	`+ }`
	`323`	`+ case EResourceToBalance::Counter:`
	`324`	`+ return true;`
	`325`	`+ case EResourceToBalance::CPU:`
	`326`	`+ return Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kCPUFieldNumber) != allowedMetricIds.end();`
	`327`	`+ case EResourceToBalance::Memory:`
	`328`	`+ return Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kMemoryFieldNumber) != allowedMetricIds.end();`
	`329`	`+ case EResourceToBalance::Network:`
	`330`	`+ return Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kNetworkFieldNumber) != allowedMetricIds.end();`
	`331`	`+ }`
	`332`	`+}`
	`333`	`+`
	`334`	`+bool TTabletInfo::HasAllowedMetric(EResourceToBalance resource) const {`
	`335`	`+ return HasAllowedMetric(GetTabletAllowedMetricIds(), resource);`
	`336`	`+}`
	`337`	`+`
`313`	`338`	`void TTabletInfo::UpdateResourceUsage(const NKikimrTabletBase::TMetrics& metrics) {`
`314`	`339`	`TInstant now = TActivationContext::Now();`
`315`	`340`	`const TVector<i64>& allowedMetricIds(GetTabletAllowedMetricIds());`
`316`	`341`	`auto before = ResourceValues;`
`317`	`342`	`auto maximum = GetResourceMaximumValues();`
`318`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kCPUFieldNumber) != allowedMetricIds.end()) {`
	`343`	`+ if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::CPU)) {`
`319`	`344`	`if (metrics.HasCPU()) {`
`320`	`345`	`if (metrics.GetCPU() > static_cast<ui64>(std::get<NMetrics::EResource::CPU>(maximum))) {`
`321`	`346`	`BLOG_W("Ignoring too high CPU metric (" << metrics.GetCPU() << ") for tablet " << ToString());`
`@@ -325,7 +350,7 @@ void TTabletInfo::UpdateResourceUsage(const NKikimrTabletBase::TMetrics& metrics`
`325`	`350`	`}`
`326`	`351`	`}`
`327`	`352`	`}`
`328`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kMemoryFieldNumber) != allowedMetricIds.end()) {`
	`353`	`+ if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::Memory)) {`
`329`	`354`	`if (metrics.HasMemory()) {`
`330`	`355`	`if (metrics.GetMemory() > static_cast<ui64>(std::get<NMetrics::EResource::Memory>(maximum))) {`
`331`	`356`	`BLOG_W("Ignoring too high Memory metric (" << metrics.GetMemory() << ") for tablet " << ToString());`
`@@ -335,7 +360,7 @@ void TTabletInfo::UpdateResourceUsage(const NKikimrTabletBase::TMetrics& metrics`
`335`	`360`	`}`
`336`	`361`	`}`
`337`	`362`	`}`
`338`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kNetworkFieldNumber) != allowedMetricIds.end()) {`
	`363`	`+ if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::Network)) {`
`339`	`364`	`if (metrics.HasNetwork()) {`
`340`	`365`	`if (metrics.GetNetwork() > static_cast<ui64>(std::get<NMetrics::EResource::Network>(maximum))) {`
`341`	`366`	`BLOG_W("Ignoring too high Network metric (" << metrics.GetNetwork() << ") for tablet " << ToString());`
`@@ -396,13 +421,13 @@ TResourceRawValues TTabletInfo::GetResourceMaximumValues() const {`
`396`	`421`	`}`
`397`	`422`
`398`	`423`	`i64 TTabletInfo::GetCounterValue(const NKikimrTabletBase::TMetrics& metrics, const TVector<i64>& allowedMetricIds) {`
`399`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kCPUFieldNumber) != allowedMetricIds.end() && THive::IsValidMetricsCPU(metrics)) {`
	`424`	`+ if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::CPU) && THive::IsValidMetricsCPU(metrics)) {`
`400`	`425`	`return 0;`
`401`	`426`	`}`
`402`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kMemoryFieldNumber) != allowedMetricIds.end() && THive::IsValidMetricsMemory(metrics)) {`
	`427`	`+ if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::Memory) && THive::IsValidMetricsMemory(metrics)) {`
`403`	`428`	`return 0;`
`404`	`429`	`}`
`405`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kNetworkFieldNumber) != allowedMetricIds.end() && THive::IsValidMetricsNetwork(metrics)) {`
	`430`	`+ if (HasAllowedMetric(allowedMetricIds, EResourceToBalance::Network) && THive::IsValidMetricsNetwork(metrics)) {`
`406`	`431`	`return 0;`
`407`	`432`	`}`
`408`	`433`	`return 1;`
`@@ -414,13 +439,13 @@ void TTabletInfo::FilterRawValues(TResourceRawValues& values) const {`
`414`	`439`	`if (metrics.GetCounter() == 0) {`
`415`	`440`	`std::get<NMetrics::EResource::Counter>(values) = 0;`
`416`	`441`	`}`
`417`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kCPUFieldNumber) == allowedMetricIds.end() \|\| !THive::IsValidMetricsCPU(metrics)) {`
	`442`	`+ if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::CPU) \|\| !THive::IsValidMetricsCPU(metrics)) {`
`418`	`443`	`std::get<NMetrics::EResource::CPU>(values) = 0;`
`419`	`444`	`}`
`420`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kMemoryFieldNumber) == allowedMetricIds.end() \|\| !THive::IsValidMetricsMemory(metrics)) {`
	`445`	`+ if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::Memory) \|\| !THive::IsValidMetricsMemory(metrics)) {`
`421`	`446`	`std::get<NMetrics::EResource::Memory>(values) = 0;`
`422`	`447`	`}`
`423`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kNetworkFieldNumber) == allowedMetricIds.end() \|\| !THive::IsValidMetricsNetwork(metrics)) {`
	`448`	`+ if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::Network) \|\| !THive::IsValidMetricsNetwork(metrics)) {`
`424`	`449`	`std::get<NMetrics::EResource::Network>(values) = 0;`
`425`	`450`	`}`
`426`	`451`	`}`
`@@ -431,13 +456,13 @@ void TTabletInfo::FilterRawValues(TResourceNormalizedValues& values) const {`
`431`	`456`	`if (metrics.GetCounter() == 0) {`
`432`	`457`	`std::get<NMetrics::EResource::Counter>(values) = 0;`
`433`	`458`	`}`
`434`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kCPUFieldNumber) == allowedMetricIds.end() \|\| !THive::IsValidMetricsCPU(metrics)) {`
	`459`	`+ if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::CPU) \|\| !THive::IsValidMetricsCPU(metrics)) {`
`435`	`460`	`std::get<NMetrics::EResource::CPU>(values) = 0;`
`436`	`461`	`}`
`437`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kMemoryFieldNumber) == allowedMetricIds.end() \|\| !THive::IsValidMetricsMemory(metrics)) {`
	`462`	`+ if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::Memory) \|\| !THive::IsValidMetricsMemory(metrics)) {`
`438`	`463`	`std::get<NMetrics::EResource::Memory>(values) = 0;`
`439`	`464`	`}`
`440`		`- if (Find(allowedMetricIds, NKikimrTabletBase::TMetrics::kNetworkFieldNumber) == allowedMetricIds.end() \|\| !THive::IsValidMetricsNetwork(metrics)) {`
	`465`	`+ if (!HasAllowedMetric(allowedMetricIds, EResourceToBalance::Network) \|\| !THive::IsValidMetricsNetwork(metrics)) {`
`441`	`466`	`std::get<NMetrics::EResource::Network>(values) = 0;`
`442`	`467`	`}`
`443`	`468`	`}`