Restoring authorship annotation for Sergey Polovko <sergey@polovko.me>. Commit 2 of 2.

1 files changed, 116 insertions, 116 deletions

diff --git a/library/cpp/monlib/metrics/metric_registry.cpp b/library/cpp/monlib/metrics/metric_registry.cpp
index 091a7b5282..b083163a7b 100644
--- a/library/cpp/monlib/metrics/metric_registry.cpp
+++ b/library/cpp/monlib/metrics/metric_registry.cpp
@@ -1,41 +1,41 @@
-#include "metric_registry.h" 
- 
+#include "metric_registry.h"
+
 #include <memory>
 
-namespace NMonitoring { 
-    namespace { 
-        void ConsumeLabels(IMetricConsumer* consumer, const ILabels& labels) { 
-            for (auto&& label: labels) { 
-                consumer->OnLabel(label.Name(), label.Value()); 
-            } 
-        } 
- 
-        template <typename TLabelsConsumer> 
-        void ConsumeMetric(TInstant time, IMetricConsumer* consumer, IMetric* metric, TLabelsConsumer&& labelsConsumer) { 
-            consumer->OnMetricBegin(metric->Type()); 
- 
-            // (1) add labels 
-            consumer->OnLabelsBegin(); 
-            labelsConsumer(); 
-            consumer->OnLabelsEnd(); 
- 
-            // (2) add time and value 
-            metric->Accept(time, consumer); 
-            consumer->OnMetricEnd(); 
-        } 
-    } 
- 
+namespace NMonitoring {
+    namespace {
+        void ConsumeLabels(IMetricConsumer* consumer, const ILabels& labels) {
+            for (auto&& label: labels) {
+                consumer->OnLabel(label.Name(), label.Value());
+            }
+        }
+
+        template <typename TLabelsConsumer>
+        void ConsumeMetric(TInstant time, IMetricConsumer* consumer, IMetric* metric, TLabelsConsumer&& labelsConsumer) {
+            consumer->OnMetricBegin(metric->Type());
+
+            // (1) add labels
+            consumer->OnLabelsBegin();
+            labelsConsumer();
+            consumer->OnLabelsEnd();
+
+            // (2) add time and value
+            metric->Accept(time, consumer);
+            consumer->OnMetricEnd();
+        }
+    }
+
     void WriteLabels(IMetricConsumer* consumer, const ILabels& labels) {
         consumer->OnLabelsBegin();
-        ConsumeLabels(consumer, labels); 
+        ConsumeLabels(consumer, labels);
         consumer->OnLabelsEnd();
     }
 
-    TMetricRegistry::TMetricRegistry() = default; 
-    TMetricRegistry::~TMetricRegistry() = default; 
+    TMetricRegistry::TMetricRegistry() = default;
+    TMetricRegistry::~TMetricRegistry() = default;
 
-    TMetricRegistry::TMetricRegistry(const TLabels& commonLabels) 
-        : TMetricRegistry{} 
+    TMetricRegistry::TMetricRegistry(const TLabels& commonLabels)
+        : TMetricRegistry{}
     {
         CommonLabels_ = commonLabels;
     }
@@ -44,14 +44,14 @@ namespace NMonitoring {
         return Singleton<TMetricRegistry>();
     }
 
-    TGauge* TMetricRegistry::Gauge(TLabels labels) { 
-        return Metric<TGauge, EMetricType::GAUGE>(std::move(labels)); 
-    } 
- 
-    TGauge* TMetricRegistry::Gauge(ILabelsPtr labels) { 
-        return Metric<TGauge, EMetricType::GAUGE>(std::move(labels)); 
-    } 
- 
+    TGauge* TMetricRegistry::Gauge(TLabels labels) {
+        return Metric<TGauge, EMetricType::GAUGE>(std::move(labels));
+    }
+
+    TGauge* TMetricRegistry::Gauge(ILabelsPtr labels) {
+        return Metric<TGauge, EMetricType::GAUGE>(std::move(labels));
+    }
+
     TLazyGauge* TMetricRegistry::LazyGauge(TLabels labels, std::function<double()> supplier) {
         return Metric<TLazyGauge, EMetricType::GAUGE>(std::move(labels), std::move(supplier));
     }
@@ -60,14 +60,14 @@ namespace NMonitoring {
         return Metric<TLazyGauge, EMetricType::GAUGE>(std::move(labels), std::move(supplier));
     }
 
-    TIntGauge* TMetricRegistry::IntGauge(TLabels labels) { 
-        return Metric<TIntGauge, EMetricType::IGAUGE>(std::move(labels)); 
-    } 
- 
-    TIntGauge* TMetricRegistry::IntGauge(ILabelsPtr labels) { 
-        return Metric<TIntGauge, EMetricType::IGAUGE>(std::move(labels)); 
-    } 
- 
+    TIntGauge* TMetricRegistry::IntGauge(TLabels labels) {
+        return Metric<TIntGauge, EMetricType::IGAUGE>(std::move(labels));
+    }
+
+    TIntGauge* TMetricRegistry::IntGauge(ILabelsPtr labels) {
+        return Metric<TIntGauge, EMetricType::IGAUGE>(std::move(labels));
+    }
+
     TLazyIntGauge* TMetricRegistry::LazyIntGauge(TLabels labels, std::function<i64()> supplier) {
         return Metric<TLazyIntGauge, EMetricType::GAUGE>(std::move(labels), std::move(supplier));
     }
@@ -76,12 +76,12 @@ namespace NMonitoring {
         return Metric<TLazyIntGauge, EMetricType::GAUGE>(std::move(labels), std::move(supplier));
     }
 
-    TCounter* TMetricRegistry::Counter(TLabels labels) { 
-        return Metric<TCounter, EMetricType::COUNTER>(std::move(labels)); 
+    TCounter* TMetricRegistry::Counter(TLabels labels) {
+        return Metric<TCounter, EMetricType::COUNTER>(std::move(labels));
     }
 
-    TCounter* TMetricRegistry::Counter(ILabelsPtr labels) { 
-        return Metric<TCounter, EMetricType::COUNTER>(std::move(labels)); 
+    TCounter* TMetricRegistry::Counter(ILabelsPtr labels) {
+        return Metric<TCounter, EMetricType::COUNTER>(std::move(labels));
     }
 
     TLazyCounter* TMetricRegistry::LazyCounter(TLabels labels, std::function<ui64()> supplier) {
@@ -92,12 +92,12 @@ namespace NMonitoring {
         return Metric<TLazyCounter, EMetricType::COUNTER>(std::move(labels), std::move(supplier));
     }
 
-    TRate* TMetricRegistry::Rate(TLabels labels) { 
-        return Metric<TRate, EMetricType::RATE>(std::move(labels)); 
+    TRate* TMetricRegistry::Rate(TLabels labels) {
+        return Metric<TRate, EMetricType::RATE>(std::move(labels));
     }
 
-    TRate* TMetricRegistry::Rate(ILabelsPtr labels) { 
-        return Metric<TRate, EMetricType::RATE>(std::move(labels)); 
+    TRate* TMetricRegistry::Rate(ILabelsPtr labels) {
+        return Metric<TRate, EMetricType::RATE>(std::move(labels));
     }
 
     TLazyRate* TMetricRegistry::LazyRate(TLabels labels, std::function<ui64()> supplier) {
@@ -108,20 +108,20 @@ namespace NMonitoring {
         return Metric<TLazyRate, EMetricType::RATE>(std::move(labels), std::move(supplier));
     }
 
-    THistogram* TMetricRegistry::HistogramCounter(TLabels labels, IHistogramCollectorPtr collector) { 
-        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(collector), false); 
-    } 
- 
-    THistogram* TMetricRegistry::HistogramCounter(ILabelsPtr labels, IHistogramCollectorPtr collector) { 
-        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(collector), false); 
+    THistogram* TMetricRegistry::HistogramCounter(TLabels labels, IHistogramCollectorPtr collector) {
+        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(collector), false);
     }
 
-    THistogram* TMetricRegistry::HistogramRate(TLabels labels, IHistogramCollectorPtr collector) { 
-        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(collector), true); 
-    } 
- 
-    THistogram* TMetricRegistry::HistogramRate(ILabelsPtr labels, IHistogramCollectorPtr collector) { 
-        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(collector), true); 
+    THistogram* TMetricRegistry::HistogramCounter(ILabelsPtr labels, IHistogramCollectorPtr collector) {
+        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(collector), false);
+    }
+
+    THistogram* TMetricRegistry::HistogramRate(TLabels labels, IHistogramCollectorPtr collector) {
+        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(collector), true);
+    }
+
+    THistogram* TMetricRegistry::HistogramRate(ILabelsPtr labels, IHistogramCollectorPtr collector) {
+        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(collector), true);
     }
 
     void TMetricRegistry::Reset() {
@@ -157,74 +157,74 @@ namespace NMonitoring {
         Metrics_.clear();
     }
 
-    template <typename TMetric, EMetricType type, typename TLabelsType, typename... Args> 
-    TMetric* TMetricRegistry::Metric(TLabelsType&& labels, Args&&... args) { 
-        { 
+    template <typename TMetric, EMetricType type, typename TLabelsType, typename... Args>
+    TMetric* TMetricRegistry::Metric(TLabelsType&& labels, Args&&... args) {
+        {
             TReadGuard g{Lock_};
 
-            auto it = Metrics_.find(labels); 
-            if (it != Metrics_.end()) { 
-                Y_ENSURE(it->second->Type() == type, "cannot create metric " << labels 
-                        << " with type " << MetricTypeToStr(type) 
-                        << ", because registry already has same metric with type " << MetricTypeToStr(it->second->Type())); 
-                return static_cast<TMetric*>(it->second.Get()); 
-            } 
-        } 
-
-        { 
-            IMetricPtr metric = MakeHolder<TMetric>(std::forward<Args>(args)...); 
- 
+            auto it = Metrics_.find(labels);
+            if (it != Metrics_.end()) {
+                Y_ENSURE(it->second->Type() == type, "cannot create metric " << labels
+                        << " with type " << MetricTypeToStr(type)
+                        << ", because registry already has same metric with type " << MetricTypeToStr(it->second->Type()));
+                return static_cast<TMetric*>(it->second.Get());
+            }
+        }
+
+        {
+            IMetricPtr metric = MakeHolder<TMetric>(std::forward<Args>(args)...);
+
             TWriteGuard g{Lock_};
-            // decltype(Metrics_)::iterator breaks build on windows 
-            THashMap<ILabelsPtr, IMetricPtr>::iterator it; 
+            // decltype(Metrics_)::iterator breaks build on windows
+            THashMap<ILabelsPtr, IMetricPtr>::iterator it;
             if constexpr (!std::is_convertible_v<TLabelsType, ILabelsPtr>) {
-                it = Metrics_.emplace(new TLabels{std::forward<TLabelsType>(labels)}, std::move(metric)).first; 
+                it = Metrics_.emplace(new TLabels{std::forward<TLabelsType>(labels)}, std::move(metric)).first;
             } else {
-                it = Metrics_.emplace(std::forward<TLabelsType>(labels), std::move(metric)).first; 
+                it = Metrics_.emplace(std::forward<TLabelsType>(labels), std::move(metric)).first;
             }
 
-            return static_cast<TMetric*>(it->second.Get()); 
-        } 
-    } 
+            return static_cast<TMetric*>(it->second.Get());
+        }
+    }
 
-    void TMetricRegistry::RemoveMetric(const ILabels& labels) noexcept { 
+    void TMetricRegistry::RemoveMetric(const ILabels& labels) noexcept {
         TWriteGuard g{Lock_};
-        Metrics_.erase(labels); 
+        Metrics_.erase(labels);
     }
 
-    void TMetricRegistry::Accept(TInstant time, IMetricConsumer* consumer) const { 
+    void TMetricRegistry::Accept(TInstant time, IMetricConsumer* consumer) const {
         consumer->OnStreamBegin();
 
         if (!CommonLabels_.Empty()) {
-            consumer->OnLabelsBegin(); 
-            ConsumeLabels(consumer, CommonLabels_); 
-            consumer->OnLabelsEnd(); 
+            consumer->OnLabelsBegin();
+            ConsumeLabels(consumer, CommonLabels_);
+            consumer->OnLabelsEnd();
+        }
+
+        {
+            TReadGuard g{Lock_};
+            for (const auto& it: Metrics_) {
+                ILabels* labels = it.first.Get();
+                IMetric* metric = it.second.Get();
+                ConsumeMetric(time, consumer, metric, [&]() {
+                    ConsumeLabels(consumer, *labels);
+                });
+            }
         }
 
-        { 
-            TReadGuard g{Lock_}; 
-            for (const auto& it: Metrics_) { 
-                ILabels* labels = it.first.Get(); 
-                IMetric* metric = it.second.Get(); 
-                ConsumeMetric(time, consumer, metric, [&]() { 
-                    ConsumeLabels(consumer, *labels); 
-                }); 
-            } 
-        } 
- 
         consumer->OnStreamEnd();
     }
 
-    void TMetricRegistry::Append(TInstant time, IMetricConsumer* consumer) const { 
+    void TMetricRegistry::Append(TInstant time, IMetricConsumer* consumer) const {
         TReadGuard g{Lock_};
 
-        for (const auto& it: Metrics_) { 
-            ILabels* labels = it.first.Get(); 
-            IMetric* metric = it.second.Get(); 
-            ConsumeMetric(time, consumer, metric, [&]() { 
-                ConsumeLabels(consumer, CommonLabels_); 
-                ConsumeLabels(consumer, *labels); 
-            }); 
-        } 
-    } 
-} 
+        for (const auto& it: Metrics_) {
+            ILabels* labels = it.first.Get();
+            IMetric* metric = it.second.Get();
+            ConsumeMetric(time, consumer, metric, [&]() {
+                ConsumeLabels(consumer, CommonLabels_);
+                ConsumeLabels(consumer, *labels);
+            });
+        }
+    }
+}