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

1 files changed, 247 insertions, 247 deletions

diff --git a/library/cpp/monlib/encode/json/json_encoder.cpp b/library/cpp/monlib/encode/json/json_encoder.cpp
index 20d2bb6283..639177b5d1 100644
--- a/library/cpp/monlib/encode/json/json_encoder.cpp
+++ b/library/cpp/monlib/encode/json/json_encoder.cpp
@@ -1,39 +1,39 @@
-#include "json.h"
-#include "typed_point.h"
-
-#include <library/cpp/monlib/encode/buffered/buffered_encoder_base.h>
-#include <library/cpp/monlib/encode/encoder_state.h>
-#include <library/cpp/monlib/metrics/metric.h>
-#include <library/cpp/monlib/metrics/metric_value.h>
-#include <library/cpp/monlib/metrics/labels.h>
-
+#include "json.h" 
+#include "typed_point.h" 
+ 
+#include <library/cpp/monlib/encode/buffered/buffered_encoder_base.h> 
+#include <library/cpp/monlib/encode/encoder_state.h> 
+#include <library/cpp/monlib/metrics/metric.h> 
+#include <library/cpp/monlib/metrics/metric_value.h> 
+#include <library/cpp/monlib/metrics/labels.h> 
+ 
 #include <library/cpp/json/writer/json.h>
-
+ 
 #include <util/charset/utf8.h>
 #include <util/generic/algorithm.h>
 
-namespace NMonitoring {
-    namespace {
+namespace NMonitoring { 
+    namespace { 
         enum class EJsonStyle {
             Solomon,
             Cloud
         };
 
-        ///////////////////////////////////////////////////////////////////////
-        // TJsonWriter
-        ///////////////////////////////////////////////////////////////////////
+        /////////////////////////////////////////////////////////////////////// 
+        // TJsonWriter 
+        /////////////////////////////////////////////////////////////////////// 
         class TJsonWriter {
-        public:
+        public: 
             TJsonWriter(IOutputStream* out, int indentation, EJsonStyle style, TStringBuf metricNameLabel)
-                : Buf_(NJsonWriter::HEM_UNSAFE, out)
+                : Buf_(NJsonWriter::HEM_UNSAFE, out) 
                 , Style_(style)
                 , MetricNameLabel_(metricNameLabel)
                 , CurrentMetricName_()
-            {
-                Buf_.SetIndentSpaces(indentation);
-                Buf_.SetWriteNanAsString();
-            }
-
+            { 
+                Buf_.SetIndentSpaces(indentation); 
+                Buf_.SetWriteNanAsString(); 
+            } 
+ 
             void WriteTime(TInstant time) {
                 if (time != TInstant::Zero()) {
                     Buf_.WriteKey(TStringBuf("ts"));
@@ -50,49 +50,49 @@ namespace NMonitoring {
                 Buf_.WriteDouble(value);
             }
 
-            void WriteValue(i64 value) {
+            void WriteValue(i64 value) { 
                 Buf_.WriteKey(TStringBuf("value"));
-                Buf_.WriteLongLong(value);
-            }
-
+                Buf_.WriteLongLong(value); 
+            } 
+ 
             void WriteValue(ui64 value) {
                 Buf_.WriteKey(TStringBuf("value"));
                 Buf_.WriteULongLong(value);
             }
 
-            void WriteValue(IHistogramSnapshot* s) {
+            void WriteValue(IHistogramSnapshot* s) { 
                 Y_ENSURE(Style_ == EJsonStyle::Solomon);
 
                 Buf_.WriteKey(TStringBuf("hist"));
-                Buf_.BeginObject();
-                if (ui32 count = s->Count()) {
-                    bool hasInf = (s->UpperBound(count - 1) == Max<double>());
-                    if (hasInf) {
-                        count--;
-                    }
-
+                Buf_.BeginObject(); 
+                if (ui32 count = s->Count()) { 
+                    bool hasInf = (s->UpperBound(count - 1) == Max<double>()); 
+                    if (hasInf) { 
+                        count--; 
+                    } 
+ 
                     Buf_.WriteKey(TStringBuf("bounds"));
-                    Buf_.BeginList();
-                    for (ui32 i = 0; i < count; i++) {
-                        Buf_.WriteDouble(s->UpperBound(i));
-                    }
-                    Buf_.EndList();
-
+                    Buf_.BeginList(); 
+                    for (ui32 i = 0; i < count; i++) { 
+                        Buf_.WriteDouble(s->UpperBound(i)); 
+                    } 
+                    Buf_.EndList(); 
+ 
                     Buf_.WriteKey(TStringBuf("buckets"));
-                    Buf_.BeginList();
-                    for (ui32 i = 0; i < count; i++) {
-                        Buf_.WriteULongLong(s->Value(i));
-                    }
-                    Buf_.EndList();
-
-                    if (hasInf) {
+                    Buf_.BeginList(); 
+                    for (ui32 i = 0; i < count; i++) { 
+                        Buf_.WriteULongLong(s->Value(i)); 
+                    } 
+                    Buf_.EndList(); 
+ 
+                    if (hasInf) { 
                         Buf_.WriteKey(TStringBuf("inf"));
-                        Buf_.WriteULongLong(s->Value(count));
-                    }
-                }
-                Buf_.EndObject();
-            }
-
+                        Buf_.WriteULongLong(s->Value(count)); 
+                    } 
+                } 
+                Buf_.EndObject(); 
+            } 
+ 
             void WriteValue(ISummaryDoubleSnapshot* s) {
                 Y_ENSURE(Style_ == EJsonStyle::Solomon);
 
@@ -142,25 +142,25 @@ namespace NMonitoring {
                 Buf_.EndObject();
             }
 
-            void WriteValue(EMetricValueType type, TMetricValue value) {
+            void WriteValue(EMetricValueType type, TMetricValue value) { 
                 switch (type) {
-                    case EMetricValueType::DOUBLE:
-                        WriteValue(value.AsDouble());
-                        break;
-
-                    case EMetricValueType::INT64:
-                        WriteValue(value.AsInt64());
-                        break;
-
-                    case EMetricValueType::UINT64:
-                        WriteValue(value.AsUint64());
+                    case EMetricValueType::DOUBLE: 
+                        WriteValue(value.AsDouble()); 
                         break;
 
-                    case EMetricValueType::HISTOGRAM:
-                        WriteValue(value.AsHistogram());
+                    case EMetricValueType::INT64: 
+                        WriteValue(value.AsInt64()); 
+                        break; 
+ 
+                    case EMetricValueType::UINT64: 
+                        WriteValue(value.AsUint64()); 
                         break;
 
-                    case EMetricValueType::SUMMARY:
+                    case EMetricValueType::HISTOGRAM: 
+                        WriteValue(value.AsHistogram()); 
+                        break; 
+ 
+                    case EMetricValueType::SUMMARY: 
                         WriteValue(value.AsSummaryDouble());
                         break;
 
@@ -168,7 +168,7 @@ namespace NMonitoring {
                         WriteValue(value.AsLogHistogram());
                         break;
 
-                    case EMetricValueType::UNKNOWN:
+                    case EMetricValueType::UNKNOWN: 
                         ythrow yexception() << "unknown metric value type";
                 }
             }
@@ -229,10 +229,10 @@ namespace NMonitoring {
             TString CurrentMetricName_;
         };
 
-        ///////////////////////////////////////////////////////////////////////
-        // TEncoderJson
-        ///////////////////////////////////////////////////////////////////////
-        class TEncoderJson final: public IMetricEncoder, public TJsonWriter {
+        /////////////////////////////////////////////////////////////////////// 
+        // TEncoderJson 
+        /////////////////////////////////////////////////////////////////////// 
+        class TEncoderJson final: public IMetricEncoder, public TJsonWriter { 
         public:
             TEncoderJson(IOutputStream* out, int indentation, EJsonStyle style, TStringBuf metricNameLabel)
                 : TJsonWriter{out, indentation, style, metricNameLabel}
@@ -240,202 +240,202 @@ namespace NMonitoring {
             }
 
             ~TEncoderJson() override {
-                Close();
-            }
-
-        private:
-            void OnStreamBegin() override {
+                Close(); 
+            } 
+ 
+        private: 
+            void OnStreamBegin() override { 
                 State_.Expect(TEncoderState::EState::ROOT);
-                Buf_.BeginObject();
-            }
-
-            void OnStreamEnd() override {
+                Buf_.BeginObject(); 
+            } 
+ 
+            void OnStreamEnd() override { 
                 State_.Expect(TEncoderState::EState::ROOT);
-                if (!Buf_.KeyExpected()) {
-                    // not closed metrics array
-                    Buf_.EndList();
-                }
-                Buf_.EndObject();
-            }
-
-            void OnCommonTime(TInstant time) override {
+                if (!Buf_.KeyExpected()) { 
+                    // not closed metrics array 
+                    Buf_.EndList(); 
+                } 
+                Buf_.EndObject(); 
+            } 
+ 
+            void OnCommonTime(TInstant time) override { 
                 State_.Expect(TEncoderState::EState::ROOT);
-                WriteTime(time);
-            }
-
-            void OnMetricBegin(EMetricType type) override {
-                State_.Switch(TEncoderState::EState::ROOT, TEncoderState::EState::METRIC);
-                if (Buf_.KeyExpected()) {
-                    // first metric, so open metrics array
+                WriteTime(time); 
+            } 
+ 
+            void OnMetricBegin(EMetricType type) override { 
+                State_.Switch(TEncoderState::EState::ROOT, TEncoderState::EState::METRIC); 
+                if (Buf_.KeyExpected()) { 
+                    // first metric, so open metrics array 
                     Buf_.WriteKey(TStringBuf(Style_ == EJsonStyle::Solomon ? "sensors" : "metrics"));
-                    Buf_.BeginList();
-                }
-                Buf_.BeginObject();
+                    Buf_.BeginList(); 
+                } 
+                Buf_.BeginObject(); 
                 WriteMetricType(type);
-            }
-
-            void OnMetricEnd() override {
-                State_.Switch(TEncoderState::EState::METRIC, TEncoderState::EState::ROOT);
-                if (!Buf_.KeyExpected()) {
-                    // not closed timeseries array
-                    Buf_.EndList();
-                }
-
-                if (!TimeSeries_ && LastPoint_.HasValue()) {
-                    // we have seen only one point between OnMetricBegin() and
-                    // OnMetricEnd() calls
-                    WriteTime(LastPoint_.GetTime());
-                    WriteValue(LastPoint_.GetValueType(), LastPoint_.GetValue());
-                }
-                Buf_.EndObject();
-
-                LastPoint_ = {};
-                TimeSeries_ = false;
-            }
-
-            void OnLabelsBegin() override {
-                if (!Buf_.KeyExpected()) {
-                    // not closed metrics or timeseries array if labels go after values
-                    Buf_.EndList();
-                }
+            } 
+ 
+            void OnMetricEnd() override { 
+                State_.Switch(TEncoderState::EState::METRIC, TEncoderState::EState::ROOT); 
+                if (!Buf_.KeyExpected()) { 
+                    // not closed timeseries array 
+                    Buf_.EndList(); 
+                } 
+ 
+                if (!TimeSeries_ && LastPoint_.HasValue()) { 
+                    // we have seen only one point between OnMetricBegin() and 
+                    // OnMetricEnd() calls 
+                    WriteTime(LastPoint_.GetTime()); 
+                    WriteValue(LastPoint_.GetValueType(), LastPoint_.GetValue()); 
+                } 
+                Buf_.EndObject(); 
+ 
+                LastPoint_ = {}; 
+                TimeSeries_ = false; 
+            } 
+ 
+            void OnLabelsBegin() override { 
+                if (!Buf_.KeyExpected()) { 
+                    // not closed metrics or timeseries array if labels go after values 
+                    Buf_.EndList(); 
+                } 
                 if (State_ == TEncoderState::EState::ROOT) {
                     State_ = TEncoderState::EState::COMMON_LABELS;
                     Buf_.WriteKey(TStringBuf(Style_ == EJsonStyle::Solomon ? "commonLabels" : "labels"));
-                } else if (State_ == TEncoderState::EState::METRIC) {
-                    State_ = TEncoderState::EState::METRIC_LABELS;
+                } else if (State_ == TEncoderState::EState::METRIC) { 
+                    State_ = TEncoderState::EState::METRIC_LABELS; 
                     Buf_.WriteKey(TStringBuf("labels"));
-                } else {
-                    State_.ThrowInvalid("expected METRIC or ROOT");
-                }
-                Buf_.BeginObject();
+                } else { 
+                    State_.ThrowInvalid("expected METRIC or ROOT"); 
+                } 
+                Buf_.BeginObject(); 
 
                 EmptyLabels_ = true;
-            }
-
-            void OnLabelsEnd() override {
-                if (State_ == TEncoderState::EState::METRIC_LABELS) {
-                    State_ = TEncoderState::EState::METRIC;
+            } 
+ 
+            void OnLabelsEnd() override { 
+                if (State_ == TEncoderState::EState::METRIC_LABELS) { 
+                    State_ = TEncoderState::EState::METRIC; 
                 } else if (State_ == TEncoderState::EState::COMMON_LABELS) {
                     State_ = TEncoderState::EState::ROOT;
-                } else {
-                    State_.ThrowInvalid("expected LABELS or COMMON_LABELS");
-                }
+                } else { 
+                    State_.ThrowInvalid("expected LABELS or COMMON_LABELS"); 
+                } 
 
                 Y_ENSURE(!EmptyLabels_, "Labels cannot be empty");
-                Buf_.EndObject();
+                Buf_.EndObject(); 
                 if (State_ == TEncoderState::EState::METRIC) {
                     WriteName();
                 }
-            }
-
-            void OnLabel(TStringBuf name, TStringBuf value) override {
-                if (State_ == TEncoderState::EState::METRIC_LABELS || State_ == TEncoderState::EState::COMMON_LABELS) {
+            } 
+ 
+            void OnLabel(TStringBuf name, TStringBuf value) override { 
+                if (State_ == TEncoderState::EState::METRIC_LABELS || State_ == TEncoderState::EState::COMMON_LABELS) { 
                     WriteLabel(name, value);
-                } else {
-                    State_.ThrowInvalid("expected LABELS or COMMON_LABELS");
-                }
+                } else { 
+                    State_.ThrowInvalid("expected LABELS or COMMON_LABELS"); 
+                } 
 
                 EmptyLabels_ = false;
-            }
-
-            void OnDouble(TInstant time, double value) override {
-                State_.Expect(TEncoderState::EState::METRIC);
-                Write<double>(time, value);
-            }
-
-            void OnInt64(TInstant time, i64 value) override {
-                State_.Expect(TEncoderState::EState::METRIC);
-                Write<i64>(time, value);
-            }
-
-            void OnUint64(TInstant time, ui64 value) override {
-                State_.Expect(TEncoderState::EState::METRIC);
-                Write<ui64>(time, value);
-            }
-
-            void OnHistogram(TInstant time, IHistogramSnapshotPtr snapshot) override {
-                State_.Expect(TEncoderState::EState::METRIC);
-                Write<IHistogramSnapshot*>(time, snapshot.Get());
-            }
-
+            } 
+ 
+            void OnDouble(TInstant time, double value) override { 
+                State_.Expect(TEncoderState::EState::METRIC); 
+                Write<double>(time, value); 
+            } 
+ 
+            void OnInt64(TInstant time, i64 value) override { 
+                State_.Expect(TEncoderState::EState::METRIC); 
+                Write<i64>(time, value); 
+            } 
+ 
+            void OnUint64(TInstant time, ui64 value) override { 
+                State_.Expect(TEncoderState::EState::METRIC); 
+                Write<ui64>(time, value); 
+            } 
+ 
+            void OnHistogram(TInstant time, IHistogramSnapshotPtr snapshot) override { 
+                State_.Expect(TEncoderState::EState::METRIC); 
+                Write<IHistogramSnapshot*>(time, snapshot.Get()); 
+            } 
+ 
             void OnSummaryDouble(TInstant time, ISummaryDoubleSnapshotPtr snapshot) override {
-                State_.Expect(TEncoderState::EState::METRIC);
+                State_.Expect(TEncoderState::EState::METRIC); 
                 Write<ISummaryDoubleSnapshot*>(time, snapshot.Get());
             }
 
             void OnLogHistogram(TInstant time, TLogHistogramSnapshotPtr snapshot) override {
-                State_.Expect(TEncoderState::EState::METRIC);
+                State_.Expect(TEncoderState::EState::METRIC); 
                 Write<TLogHistogramSnapshot*>(time, snapshot.Get());
             }
 
-            template <typename T>
-            void Write(TInstant time, T value) {
-                State_.Expect(TEncoderState::EState::METRIC);
-
-                if (!LastPoint_.HasValue()) {
-                    LastPoint_ = {time, value};
-                } else {
-                    // second point
-                    // TODO: output types
-                    Y_ENSURE(LastPoint_.GetValueType() == TValueType<T>::Type,
-                             "mixed metric value types in one metric");
-
-                    if (!TimeSeries_) {
+            template <typename T> 
+            void Write(TInstant time, T value) { 
+                State_.Expect(TEncoderState::EState::METRIC); 
+ 
+                if (!LastPoint_.HasValue()) { 
+                    LastPoint_ = {time, value}; 
+                } else { 
+                    // second point 
+                    // TODO: output types 
+                    Y_ENSURE(LastPoint_.GetValueType() == TValueType<T>::Type, 
+                             "mixed metric value types in one metric"); 
+ 
+                    if (!TimeSeries_) { 
                         Buf_.WriteKey(TStringBuf("timeseries"));
-                        Buf_.BeginList();
-                        Buf_.BeginObject();
-                        Y_ENSURE(LastPoint_.GetTime() != TInstant::Zero(),
+                        Buf_.BeginList(); 
+                        Buf_.BeginObject(); 
+                        Y_ENSURE(LastPoint_.GetTime() != TInstant::Zero(), 
                             "time cannot be empty or zero in a timeseries point");
-                        WriteTime(LastPoint_.GetTime());
-                        WriteValue(LastPoint_.GetValueType(), LastPoint_.GetValue());
-                        Buf_.EndObject();
-                        TimeSeries_ = true;
-                    }
-
-                    if (TimeSeries_) {
-                        Buf_.BeginObject();
+                        WriteTime(LastPoint_.GetTime()); 
+                        WriteValue(LastPoint_.GetValueType(), LastPoint_.GetValue()); 
+                        Buf_.EndObject(); 
+                        TimeSeries_ = true; 
+                    } 
+ 
+                    if (TimeSeries_) { 
+                        Buf_.BeginObject(); 
                         Y_ENSURE(time != TInstant::Zero(),
                             "time cannot be empty or zero in a timeseries point");
-
-                        WriteTime(time);
-                        WriteValue(value);
-                        Buf_.EndObject();
-                    }
-                }
-            }
-
-            void Close() override {
-                LastPoint_ = {};
-            }
-
+ 
+                        WriteTime(time); 
+                        WriteValue(value); 
+                        Buf_.EndObject(); 
+                    } 
+                } 
+            } 
+ 
+            void Close() override { 
+                LastPoint_ = {}; 
+            } 
+ 
         private:
             TEncoderState State_;
-            TTypedPoint LastPoint_;
+            TTypedPoint LastPoint_; 
             bool TimeSeries_ = false;
             bool EmptyLabels_ = false;
         };
 
-        ///////////////////////////////////////////////////////////////////////
-        // TBufferedJsonEncoder
-        ///////////////////////////////////////////////////////////////////////
+        /////////////////////////////////////////////////////////////////////// 
+        // TBufferedJsonEncoder 
+        /////////////////////////////////////////////////////////////////////// 
         class TBufferedJsonEncoder : public TBufferedEncoderBase, public TJsonWriter {
         public:
             TBufferedJsonEncoder(IOutputStream* out, int indentation, EJsonStyle style, TStringBuf metricNameLabel)
                 : TJsonWriter{out, indentation, style, metricNameLabel}
             {
-                MetricsMergingMode_ = EMetricsMergingMode::MERGE_METRICS;
-            }
-
+                MetricsMergingMode_ = EMetricsMergingMode::MERGE_METRICS; 
+            } 
+ 
             ~TBufferedJsonEncoder() override {
                 Close();
-            }
-
+            } 
+ 
             void OnLabelsBegin() override {
                 TBufferedEncoderBase::OnLabelsBegin();
                 EmptyLabels_ = true;
             }
 
-            void OnLabel(TStringBuf name, TStringBuf value) override {
+            void OnLabel(TStringBuf name, TStringBuf value) override { 
                 TBufferedEncoderBase::OnLabel(name, value);
                 EmptyLabels_ = false;
             }
@@ -456,36 +456,36 @@ namespace NMonitoring {
                 }
 
                 Closed_ = true;
-
+ 
                 LabelValuesPool_.Build();
                 LabelNamesPool_.Build();
-
+ 
                 Buf_.BeginObject();
-
+ 
                 WriteTime(CommonTime_);
                 if (CommonLabels_.size() > 0) {
                     Buf_.WriteKey(TStringBuf(Style_ == EJsonStyle::Solomon ? "commonLabels": "labels"));
                     WriteLabels(CommonLabels_, true);
-                }
+                } 
 
-                if (Metrics_.size() > 0) {
+                if (Metrics_.size() > 0) { 
                     Buf_.WriteKey(TStringBuf(Style_ == EJsonStyle::Solomon ? "sensors" : "metrics"));
-                    WriteMetrics();
+                    WriteMetrics(); 
                 }
 
                 Buf_.EndObject();
-            }
-
-        private:
-            void WriteMetrics() {
+            } 
+ 
+        private: 
+            void WriteMetrics() { 
                 Buf_.BeginList();
-                for (auto&& metric : Metrics_) {
-                    WriteMetric(metric);
+                for (auto&& metric : Metrics_) { 
+                    WriteMetric(metric); 
                 }
                 Buf_.EndList();
             }
 
-            void WriteMetric(TMetric& metric) {
+            void WriteMetric(TMetric& metric) { 
                 Buf_.BeginObject();
 
                 WriteMetricType(metric.MetricType);
@@ -493,19 +493,19 @@ namespace NMonitoring {
                 Buf_.WriteKey(TStringBuf("labels"));
                 WriteLabels(metric.Labels, false);
 
-                metric.TimeSeries.SortByTs();
-                if (metric.TimeSeries.Size() == 1) {
-                    const auto& point = metric.TimeSeries[0];
-                    WriteTime(point.GetTime());
-                    WriteValue(metric.TimeSeries.GetValueType(), point.GetValue());
-                } else if (metric.TimeSeries.Size() > 1) {
+                metric.TimeSeries.SortByTs(); 
+                if (metric.TimeSeries.Size() == 1) { 
+                    const auto& point = metric.TimeSeries[0]; 
+                    WriteTime(point.GetTime()); 
+                    WriteValue(metric.TimeSeries.GetValueType(), point.GetValue()); 
+                } else if (metric.TimeSeries.Size() > 1) { 
                     Buf_.WriteKey(TStringBuf("timeseries"));
                     Buf_.BeginList();
-                    metric.TimeSeries.ForEach([this](TInstant time, EMetricValueType type, TMetricValue value) {
+                    metric.TimeSeries.ForEach([this](TInstant time, EMetricValueType type, TMetricValue value) { 
                         Buf_.BeginObject();
                         // make gcc 6.1 happy https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61636
-                        this->WriteTime(time);
-                        this->WriteValue(type, value);
+                        this->WriteTime(time); 
+                        this->WriteValue(type, value); 
                         Buf_.EndObject();
                     });
 
@@ -535,14 +535,14 @@ namespace NMonitoring {
         private:
             bool Closed_{false};
             bool EmptyLabels_ = false;
-        };
-    }
-
-    IMetricEncoderPtr EncoderJson(IOutputStream* out, int indentation) {
+        }; 
+    } 
+ 
+    IMetricEncoderPtr EncoderJson(IOutputStream* out, int indentation) { 
         return MakeHolder<TEncoderJson>(out, indentation, EJsonStyle::Solomon, "");
-    }
-
-    IMetricEncoderPtr BufferedEncoderJson(IOutputStream* out, int indentation) {
+    } 
+ 
+    IMetricEncoderPtr BufferedEncoderJson(IOutputStream* out, int indentation) { 
         return MakeHolder<TBufferedJsonEncoder>(out, indentation, EJsonStyle::Solomon, "");
     }
 
@@ -553,4 +553,4 @@ namespace NMonitoring {
     IMetricEncoderPtr BufferedEncoderCloudJson(IOutputStream* out, int indentation, TStringBuf metricNameLabel) {
         return MakeHolder<TBufferedJsonEncoder>(out, indentation, EJsonStyle::Cloud, metricNameLabel);
     }
-}
+}