intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029

1 files changed, 507 insertions, 0 deletions

diff --git a/library/cpp/monlib/metrics/metric_value_ut.cpp b/library/cpp/monlib/metrics/metric_value_ut.cpp
new file mode 100644
index 0000000000..49b47c4057
--- /dev/null
+++ b/library/cpp/monlib/metrics/metric_value_ut.cpp
@@ -0,0 +1,507 @@
+#include "metric_value.h"
+
+#include <library/cpp/testing/unittest/registar.h>
+
+using namespace NMonitoring;
+
+Y_UNIT_TEST_SUITE(TMetricValueTest) {
+
+    class TTestHistogram: public IHistogramSnapshot {
+    public:
+        TTestHistogram(ui32 count = 1)
+            : Count_{count}
+        {}
+
+    private:
+        ui32 Count() const override {
+            return Count_;
+        }
+
+        TBucketBound UpperBound(ui32 /*index*/) const override {
+            return 1234.56;
+        }
+
+        TBucketValue Value(ui32 /*index*/) const override {
+            return 42;
+        }
+
+        ui32 Count_{0};
+    };
+
+    IHistogramSnapshotPtr MakeHistogramSnapshot() {
+        return MakeIntrusive<TTestHistogram>();
+    }
+
+    ISummaryDoubleSnapshotPtr MakeSummarySnapshot(ui64 count = 0u) {
+        return MakeIntrusive<TSummaryDoubleSnapshot>(0.0, 0.0, 0.0, 0.0, count);
+    }
+
+    TLogHistogramSnapshotPtr MakeLogHistogram(ui64 count = 0) {
+        TVector<double> buckets;
+        for (ui64 i = 0; i < count; ++i) {
+            buckets.push_back(i);
+        }
+        return MakeIntrusive<TLogHistogramSnapshot>(1.5, 0u, 0, buckets);
+    }
+
+    Y_UNIT_TEST(Sorted) {
+        auto ts1 = TInstant::Now();
+        auto ts2 = ts1 + TDuration::Seconds(1);
+
+        TMetricTimeSeries timeSeries;
+        timeSeries.Add(ts1, 3.14159);
+        timeSeries.Add(ts1, 6.28318);
+        timeSeries.Add(ts2, 2.71828);
+
+        UNIT_ASSERT_EQUAL(timeSeries.Size(), 3);
+
+        timeSeries.SortByTs();
+        UNIT_ASSERT_EQUAL(timeSeries.Size(), 2);
+
+        UNIT_ASSERT_EQUAL(ts1, timeSeries[0].GetTime());
+        UNIT_ASSERT_DOUBLES_EQUAL(6.28318, timeSeries[0].GetValue().AsDouble(), Min<double>());
+
+        UNIT_ASSERT_EQUAL(ts2, timeSeries[1].GetTime());
+        UNIT_ASSERT_DOUBLES_EQUAL(2.71828, timeSeries[1].GetValue().AsDouble(), Min<double>());
+    }
+
+    Y_UNIT_TEST(Histograms) {
+        auto ts = TInstant::Now();
+        auto histogram = MakeIntrusive<TTestHistogram>();
+
+        UNIT_ASSERT_VALUES_EQUAL(1, histogram->RefCount());
+        {
+            TMetricTimeSeries timeSeries;
+            timeSeries.Add(ts, histogram.Get());
+            UNIT_ASSERT_VALUES_EQUAL(2, histogram->RefCount());
+        }
+        UNIT_ASSERT_VALUES_EQUAL(1, histogram->RefCount());
+    }
+
+    Y_UNIT_TEST(Summary) {
+        auto ts = TInstant::Now();
+        auto summary = MakeSummarySnapshot();
+        UNIT_ASSERT_VALUES_EQUAL(1, summary->RefCount());
+        {
+            TMetricTimeSeries timeSeries;
+            timeSeries.Add(ts, summary.Get());
+            UNIT_ASSERT_VALUES_EQUAL(2, summary->RefCount());
+        }
+        UNIT_ASSERT_VALUES_EQUAL(1, summary->RefCount());
+    }
+
+    Y_UNIT_TEST(LogHistogram) {
+        auto ts = TInstant::Now();
+        auto logHist = MakeLogHistogram();
+        UNIT_ASSERT_VALUES_EQUAL(1, logHist->RefCount());
+        {
+            TMetricTimeSeries timeSeries;
+            timeSeries.Add(ts, logHist.Get());
+            UNIT_ASSERT_VALUES_EQUAL(2, logHist->RefCount());
+        }
+        UNIT_ASSERT_VALUES_EQUAL(1, logHist->RefCount());
+    }
+
+    Y_UNIT_TEST(TimeSeriesMovable) {
+        auto ts = TInstant::Now();
+        auto histogram = MakeIntrusive<TTestHistogram>();
+
+        UNIT_ASSERT_VALUES_EQUAL(1, histogram->RefCount());
+        {
+            TMetricTimeSeries timeSeriesA;
+            timeSeriesA.Add(ts, histogram.Get());
+            UNIT_ASSERT_VALUES_EQUAL(2, histogram->RefCount());
+
+            TMetricTimeSeries timeSeriesB = std::move(timeSeriesA);
+            UNIT_ASSERT_VALUES_EQUAL(2, histogram->RefCount());
+
+            UNIT_ASSERT_VALUES_EQUAL(1, timeSeriesB.Size());
+            UNIT_ASSERT_EQUAL(EMetricValueType::HISTOGRAM, timeSeriesB.GetValueType());
+
+            UNIT_ASSERT_VALUES_EQUAL(0, timeSeriesA.Size());
+            UNIT_ASSERT_EQUAL(EMetricValueType::UNKNOWN, timeSeriesA.GetValueType());
+        }
+        UNIT_ASSERT_VALUES_EQUAL(1, histogram->RefCount());
+    }
+
+    Y_UNIT_TEST(HistogramsUnique) {
+        auto ts1 = TInstant::Now();
+        auto ts2 = ts1 + TDuration::Seconds(1);
+        auto ts3 = ts2 + TDuration::Seconds(1);
+
+        auto h1 = MakeIntrusive<TTestHistogram>();
+        auto h2 = MakeIntrusive<TTestHistogram>();
+        auto h3 = MakeIntrusive<TTestHistogram>();
+
+        UNIT_ASSERT_VALUES_EQUAL(1, h1->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h2->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h3->RefCount());
+
+        {
+            TMetricTimeSeries timeSeries;
+            timeSeries.Add(ts1, h1.Get()); // drop at the head
+            timeSeries.Add(ts1, h1.Get());
+            timeSeries.Add(ts1, h1.Get());
+
+            timeSeries.Add(ts2, h2.Get()); // drop in the middle
+            timeSeries.Add(ts2, h2.Get());
+            timeSeries.Add(ts2, h2.Get());
+
+            timeSeries.Add(ts3, h3.Get()); // drop at the end
+            timeSeries.Add(ts3, h3.Get());
+            timeSeries.Add(ts3, h3.Get());
+
+            UNIT_ASSERT_EQUAL(timeSeries.Size(), 9);
+
+            UNIT_ASSERT_VALUES_EQUAL(4, h1->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(4, h2->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(4, h3->RefCount());
+
+            timeSeries.SortByTs();
+            UNIT_ASSERT_EQUAL(timeSeries.Size(), 3);
+
+            UNIT_ASSERT_VALUES_EQUAL(2, h1->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(2, h2->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(2, h3->RefCount());
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(1, h1->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h2->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h3->RefCount());
+    }
+
+    Y_UNIT_TEST(LogHistogramsUnique) {
+        auto ts1 = TInstant::Now();
+        auto ts2 = ts1 + TDuration::Seconds(1);
+        auto ts3 = ts2 + TDuration::Seconds(1);
+
+        auto h1 = MakeLogHistogram();
+        auto h2 = MakeLogHistogram();
+        auto h3 = MakeLogHistogram();
+
+        UNIT_ASSERT_VALUES_EQUAL(1, h1->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h2->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h3->RefCount());
+
+        {
+            TMetricTimeSeries timeSeries;
+            timeSeries.Add(ts1, h1.Get()); // drop at the head
+            timeSeries.Add(ts1, h1.Get());
+            timeSeries.Add(ts1, h1.Get());
+
+            timeSeries.Add(ts2, h2.Get()); // drop in the middle
+            timeSeries.Add(ts2, h2.Get());
+            timeSeries.Add(ts2, h2.Get());
+
+            timeSeries.Add(ts3, h3.Get()); // drop at the end
+            timeSeries.Add(ts3, h3.Get());
+            timeSeries.Add(ts3, h3.Get());
+
+            UNIT_ASSERT_EQUAL(timeSeries.Size(), 9);
+
+            UNIT_ASSERT_VALUES_EQUAL(4, h1->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(4, h2->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(4, h3->RefCount());
+
+            timeSeries.SortByTs();
+            UNIT_ASSERT_EQUAL(timeSeries.Size(), 3);
+
+            UNIT_ASSERT_VALUES_EQUAL(2, h1->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(2, h2->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(2, h3->RefCount());
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(1, h1->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h2->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h3->RefCount());
+    }
+
+    Y_UNIT_TEST(SummaryUnique) {
+        auto ts1 = TInstant::Now();
+        auto ts2 = ts1 + TDuration::Seconds(1);
+        auto ts3 = ts2 + TDuration::Seconds(1);
+
+        auto h1 = MakeSummarySnapshot();
+        auto h2 = MakeSummarySnapshot();
+        auto h3 = MakeSummarySnapshot();
+
+        UNIT_ASSERT_VALUES_EQUAL(1, h1->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h2->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h3->RefCount());
+
+        {
+            TMetricTimeSeries timeSeries;
+            timeSeries.Add(ts1, h1.Get()); // drop at the head
+            timeSeries.Add(ts1, h1.Get());
+            timeSeries.Add(ts1, h1.Get());
+
+            timeSeries.Add(ts2, h2.Get()); // drop in the middle
+            timeSeries.Add(ts2, h2.Get());
+            timeSeries.Add(ts2, h2.Get());
+
+            timeSeries.Add(ts3, h3.Get()); // drop at the end
+            timeSeries.Add(ts3, h3.Get());
+            timeSeries.Add(ts3, h3.Get());
+
+            UNIT_ASSERT_EQUAL(timeSeries.Size(), 9);
+
+            UNIT_ASSERT_VALUES_EQUAL(4, h1->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(4, h2->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(4, h3->RefCount());
+
+            timeSeries.SortByTs();
+            UNIT_ASSERT_EQUAL(timeSeries.Size(), 3);
+
+            UNIT_ASSERT_VALUES_EQUAL(2, h1->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(2, h2->RefCount());
+            UNIT_ASSERT_VALUES_EQUAL(2, h3->RefCount());
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(1, h1->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h2->RefCount());
+        UNIT_ASSERT_VALUES_EQUAL(1, h3->RefCount());
+    }
+
+    Y_UNIT_TEST(HistogramsUnique2) {
+        auto ts1 = TInstant::Now();
+        auto ts2 = ts1 + TDuration::Seconds(1);
+        auto ts3 = ts2 + TDuration::Seconds(1);
+        auto ts4 = ts3 + TDuration::Seconds(1);
+        auto ts5 = ts4 + TDuration::Seconds(1);
+
+        auto h1 = MakeIntrusive<TTestHistogram>(1u);
+        auto h2 = MakeIntrusive<TTestHistogram>(2u);
+        auto h3 = MakeIntrusive<TTestHistogram>(3u);
+        auto h4 = MakeIntrusive<TTestHistogram>(4u);
+        auto h5 = MakeIntrusive<TTestHistogram>(5u);
+        auto h6 = MakeIntrusive<TTestHistogram>(6u);
+        auto h7 = MakeIntrusive<TTestHistogram>(7u);
+
+        {
+            TMetricTimeSeries timeSeries;
+            timeSeries.Add(ts1, h1.Get());
+            timeSeries.Add(ts1, h2.Get());
+
+            timeSeries.Add(ts2, h3.Get());
+
+            timeSeries.Add(ts3, h4.Get());
+            timeSeries.Add(ts3, h5.Get());
+
+            timeSeries.Add(ts4, h6.Get());
+            timeSeries.Add(ts5, h7.Get());
+
+            timeSeries.SortByTs();
+
+            UNIT_ASSERT_EQUAL(timeSeries.Size(), 5);
+            UNIT_ASSERT_EQUAL(timeSeries[0].GetValue().AsHistogram()->Count(), 2);
+            UNIT_ASSERT_EQUAL(timeSeries[1].GetValue().AsHistogram()->Count(), 3);
+            UNIT_ASSERT_EQUAL(timeSeries[2].GetValue().AsHistogram()->Count(), 5);
+            UNIT_ASSERT_EQUAL(timeSeries[3].GetValue().AsHistogram()->Count(), 6);
+            UNIT_ASSERT_EQUAL(timeSeries[4].GetValue().AsHistogram()->Count(), 7);
+        }
+    }
+
+    Y_UNIT_TEST(LogHistogramsUnique2) {
+        auto ts1 = TInstant::Now();
+        auto ts2 = ts1 + TDuration::Seconds(1);
+        auto ts3 = ts2 + TDuration::Seconds(1);
+        auto ts4 = ts3 + TDuration::Seconds(1);
+        auto ts5 = ts4 + TDuration::Seconds(1);
+
+        auto h1 = MakeLogHistogram(1u);
+        auto h2 = MakeLogHistogram(2u);
+        auto h3 = MakeLogHistogram(3u);
+        auto h4 = MakeLogHistogram(4u);
+        auto h5 = MakeLogHistogram(5u);
+        auto h6 = MakeLogHistogram(6u);
+        auto h7 = MakeLogHistogram(7u);
+
+        {
+            TMetricTimeSeries timeSeries;
+            timeSeries.Add(ts1, h1.Get());
+            timeSeries.Add(ts1, h2.Get());
+
+            timeSeries.Add(ts2, h3.Get());
+
+            timeSeries.Add(ts3, h4.Get());
+            timeSeries.Add(ts3, h5.Get());
+
+            timeSeries.Add(ts4, h6.Get());
+            timeSeries.Add(ts5, h7.Get());
+
+            timeSeries.SortByTs();
+
+            UNIT_ASSERT_EQUAL(timeSeries.Size(), 5);
+            UNIT_ASSERT_EQUAL(timeSeries[0].GetValue().AsLogHistogram()->Count(), 2);
+            UNIT_ASSERT_EQUAL(timeSeries[1].GetValue().AsLogHistogram()->Count(), 3);
+            UNIT_ASSERT_EQUAL(timeSeries[2].GetValue().AsLogHistogram()->Count(), 5);
+            UNIT_ASSERT_EQUAL(timeSeries[3].GetValue().AsLogHistogram()->Count(), 6);
+            UNIT_ASSERT_EQUAL(timeSeries[4].GetValue().AsLogHistogram()->Count(), 7);
+        }
+    }
+
+    Y_UNIT_TEST(SummaryUnique2) {
+        auto ts1 = TInstant::Now();
+        auto ts2 = ts1 + TDuration::Seconds(1);
+        auto ts3 = ts2 + TDuration::Seconds(1);
+        auto ts4 = ts3 + TDuration::Seconds(1);
+        auto ts5 = ts4 + TDuration::Seconds(1);
+
+        auto h1 = MakeSummarySnapshot(1u);
+        auto h2 = MakeSummarySnapshot(2u);
+        auto h3 = MakeSummarySnapshot(3u);
+        auto h4 = MakeSummarySnapshot(4u);
+        auto h5 = MakeSummarySnapshot(5u);
+        auto h6 = MakeSummarySnapshot(6u);
+        auto h7 = MakeSummarySnapshot(7u);
+
+        {
+            TMetricTimeSeries timeSeries;
+            timeSeries.Add(ts1, h1.Get());
+            timeSeries.Add(ts1, h2.Get());
+
+            timeSeries.Add(ts2, h3.Get());
+
+            timeSeries.Add(ts3, h4.Get());
+            timeSeries.Add(ts3, h5.Get());
+
+            timeSeries.Add(ts4, h6.Get());
+            timeSeries.Add(ts5, h7.Get());
+
+            timeSeries.SortByTs();
+
+            UNIT_ASSERT_EQUAL(timeSeries.Size(), 5);
+            UNIT_ASSERT_EQUAL(timeSeries[0].GetValue().AsSummaryDouble()->GetCount(), 2);
+            UNIT_ASSERT_EQUAL(timeSeries[1].GetValue().AsSummaryDouble()->GetCount(), 3);
+            UNIT_ASSERT_EQUAL(timeSeries[2].GetValue().AsSummaryDouble()->GetCount(), 5);
+            UNIT_ASSERT_EQUAL(timeSeries[3].GetValue().AsSummaryDouble()->GetCount(), 6);
+            UNIT_ASSERT_EQUAL(timeSeries[4].GetValue().AsSummaryDouble()->GetCount(), 7);
+        }
+    }
+
+    Y_UNIT_TEST(TMetricValueWithType) {
+        // correct usage
+        {
+            double value = 1.23;
+            TMetricValueWithType v{value};
+
+            UNIT_ASSERT_VALUES_EQUAL(v.GetType(), EMetricValueType::DOUBLE);
+            UNIT_ASSERT_VALUES_EQUAL(v.AsDouble(), value);
+        }
+        {
+            ui64 value = 12;
+            TMetricValueWithType v{value};
+
+            UNIT_ASSERT_VALUES_EQUAL(v.GetType(), EMetricValueType::UINT64);
+            UNIT_ASSERT_VALUES_EQUAL(v.AsUint64(), value);
+        }
+        {
+            i64 value = i64(-12);
+            TMetricValueWithType v{value};
+
+            UNIT_ASSERT_VALUES_EQUAL(v.GetType(), EMetricValueType::INT64);
+            UNIT_ASSERT_VALUES_EQUAL(v.AsInt64(), value);
+        }
+        {
+            auto h = MakeHistogramSnapshot();
+            UNIT_ASSERT_VALUES_EQUAL(h.RefCount(), 1);
+
+            {
+                auto value = h.Get();
+                TMetricValueWithType v{value};
+
+                UNIT_ASSERT_VALUES_EQUAL(h.RefCount(), 2);
+
+                UNIT_ASSERT_VALUES_EQUAL(v.GetType(), EMetricValueType::HISTOGRAM);
+                UNIT_ASSERT_VALUES_EQUAL(v.AsHistogram(), value);
+            }
+
+            UNIT_ASSERT_VALUES_EQUAL(h.RefCount(), 1);
+        }
+        {
+            auto s = MakeSummarySnapshot();
+            auto value = s.Get();
+
+            UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 1);
+
+            {
+                TMetricValueWithType v{value};
+
+                UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 2);
+
+                UNIT_ASSERT_VALUES_EQUAL(v.GetType(), EMetricValueType::SUMMARY);
+                UNIT_ASSERT_VALUES_EQUAL(v.AsSummaryDouble(), value);
+            }
+
+            UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 1);
+        }
+        {
+            auto s = MakeSummarySnapshot();
+            auto value = s.Get();
+
+            UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 1);
+
+            {
+                TMetricValueWithType v{value};
+
+                UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 2);
+
+                v.Clear();
+                UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 1);
+            }
+
+            UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 1);
+        }
+        {
+            auto s = MakeSummarySnapshot();
+            auto value = s.Get();
+
+            {
+                TMetricValueWithType v1{ui64{1}};
+
+                UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 1);
+
+                {
+                    TMetricValueWithType v2{value};
+                    UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 2);
+
+                    v1 = std::move(v2);
+                    UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 2);
+                    UNIT_ASSERT_VALUES_EQUAL(v1.AsSummaryDouble(), value);
+                    UNIT_ASSERT_VALUES_EQUAL(v1.GetType(), EMetricValueType::SUMMARY);
+                    UNIT_ASSERT_VALUES_EQUAL(v2.GetType(), EMetricValueType::UNKNOWN);
+                }
+
+                UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 2);
+            }
+
+            UNIT_ASSERT_VALUES_EQUAL(s.RefCount(), 1);
+        }
+
+        // incorrect usage
+        {
+            TMetricValueWithType v{1.23};
+
+            UNIT_ASSERT_EXCEPTION(v.AsHistogram(), yexception);
+            UNIT_ASSERT_EXCEPTION(v.AsSummaryDouble(), yexception);
+        }
+        {
+            auto h = MakeHistogramSnapshot();
+            TMetricValueWithType v{h.Get()};
+
+            UNIT_ASSERT_EXCEPTION(v.AsUint64(), yexception);
+            UNIT_ASSERT_EXCEPTION(v.AsInt64(), yexception);
+            UNIT_ASSERT_EXCEPTION(v.AsDouble(), yexception);
+            UNIT_ASSERT_EXCEPTION(v.AsSummaryDouble(), yexception);
+        }
+        {
+            auto s = MakeSummarySnapshot();
+            TMetricValueWithType v{s.Get()};
+
+            UNIT_ASSERT_EXCEPTION(v.AsUint64(), yexception);
+            UNIT_ASSERT_EXCEPTION(v.AsInt64(), yexception);
+            UNIT_ASSERT_EXCEPTION(v.AsDouble(), yexception);
+            UNIT_ASSERT_EXCEPTION(v.AsHistogram(), yexception);
+        }
+    }
+}