Restoring authorship annotation for Sergey Polovko <sergey@polovko.me>. Commit 1 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 b083163a7b..091a7b5282 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(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(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);
+    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();
-        }
-
-        {
-            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->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); 
+                }); 
+            } 
+        } 
+ 
         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); 
+            }); 
+        } 
+    } 
+}