Restoring authorship annotation for Sergey Polovko <[email protected]>. Commit 2 of 2.

1 files changed, 452 insertions, 452 deletions

diff --git a/library/cpp/monlib/encode/json/json_ut.cpp b/library/cpp/monlib/encode/json/json_ut.cpp
index f80105795b8..09e79092890 100644
--- a/library/cpp/monlib/encode/json/json_ut.cpp
+++ b/library/cpp/monlib/encode/json/json_ut.cpp
@@ -1,19 +1,19 @@
-#include "json.h" 
- 
-#include <library/cpp/monlib/encode/protobuf/protobuf.h> 
-#include <library/cpp/monlib/metrics/labels.h> 
- 
+#include "json.h"
+
+#include <library/cpp/monlib/encode/protobuf/protobuf.h>
+#include <library/cpp/monlib/metrics/labels.h>
+
 #include <library/cpp/json/json_reader.h>
 #include <library/cpp/resource/resource.h>
 #include <library/cpp/testing/unittest/registar.h>
- 
-#include <util/stream/str.h> 
+
+#include <util/stream/str.h>
 #include <util/string/builder.h>
- 
-#include <limits> 
- 
-using namespace NMonitoring; 
- 
+
+#include <limits>
+
+using namespace NMonitoring;
+
 namespace NMonitoring {
     bool operator<(const TLabel& lhs, const TLabel& rhs) {
         return lhs.Name() < rhs.Name() ||
@@ -134,7 +134,7 @@ namespace {
 
 Y_UNIT_TEST_SUITE(TJsonTest) {
     const TInstant now = TInstant::ParseIso8601Deprecated("2017-11-05T01:02:03Z");
- 
+
     Y_UNIT_TEST(Encode) {
         auto check = [](bool cloud, bool buffered, TStringBuf expectedResourceKey) {
             TString json;
@@ -145,12 +145,12 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
             e->OnStreamBegin();
             { // common time
                 e->OnCommonTime(TInstant::Seconds(1500000000));
-            } 
+            }
             { // common labels
-                e->OnLabelsBegin(); 
+                e->OnLabelsBegin();
                 e->OnLabel("project", "solomon");
-                e->OnLabelsEnd(); 
-            } 
+                e->OnLabelsEnd();
+            }
             { // metric #1
                 e->OnMetricBegin(EMetricType::COUNTER);
                 {
@@ -161,7 +161,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
                 }
                 e->OnUint64(now, 17);
                 e->OnMetricEnd();
-            } 
+            }
             { // metric #2
                 e->OnMetricBegin(EMetricType::RATE);
                 {
@@ -172,7 +172,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
                 }
                 e->OnUint64(now, 17);
                 e->OnMetricEnd();
-            } 
+            }
             { // metric #3
                 e->OnMetricBegin(EMetricType::GAUGE);
                 e->OnDouble(now, 3.14);
@@ -251,7 +251,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
 
         auto emit = [&](IMetricEncoder* encoder, EMetricType metricType) {
             encoder->OnStreamBegin();
-            { 
+            {
                 encoder->OnMetricBegin(metricType);
                 {
                     encoder->OnLabelsBegin();
@@ -280,11 +280,11 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
                 }
 
                 encoder->OnMetricEnd();
-            } 
+            }
             encoder->OnStreamEnd();
             encoder->Close();
         };
- 
+
         auto doTest = [&](bool buffered, EMetricType metricType) {
             TString json;
             TStringOutput out(json);
@@ -301,107 +301,107 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         doTest(true, EMetricType::HIST);
         doTest(true, EMetricType::LOGHIST);
         doTest(true, EMetricType::DSUMMARY);
-    } 
- 
-    Y_UNIT_TEST(MetricsWithDifferentLabelOrderGetMerged) { 
+    }
+
+    Y_UNIT_TEST(MetricsWithDifferentLabelOrderGetMerged) {
         TString json;
         TStringOutput out(json);
         auto e = BufferedEncoderJson(&out, 2);
- 
+
         e->OnStreamBegin();
         {
-            e->OnMetricBegin(EMetricType::RATE); 
+            e->OnMetricBegin(EMetricType::RATE);
             {
                 e->OnLabelsBegin();
-                e->OnLabel("metric", "hello"); 
+                e->OnLabel("metric", "hello");
                 e->OnLabel("label", "world");
                 e->OnLabelsEnd();
             }
             e->OnUint64(TInstant::Zero(), 0);
-            e->OnMetricEnd(); 
-        } 
+            e->OnMetricEnd();
+        }
         {
-            e->OnMetricBegin(EMetricType::RATE); 
+            e->OnMetricBegin(EMetricType::RATE);
             {
                 e->OnLabelsBegin();
                 e->OnLabel("label", "world");
-                e->OnLabel("metric", "hello"); 
+                e->OnLabel("metric", "hello");
                 e->OnLabelsEnd();
             }
             e->OnUint64(TInstant::Zero(), 1);
-            e->OnMetricEnd(); 
+            e->OnMetricEnd();
         }
         e->OnStreamEnd();
         e->Close();
         json += "\n";
- 
+
         TString expectedJson = NResource::Find("/merged.json");
         // we cannot be sure regarding the label order in the result,
         // so we'll have to parse the expected value and then compare it with actual
- 
+
         NProto::TMultiSamplesList samples;
-        IMetricEncoderPtr d = EncoderProtobuf(&samples); 
+        IMetricEncoderPtr d = EncoderProtobuf(&samples);
         DecodeJson(expectedJson, d.Get());
- 
+
         UNIT_ASSERT_VALUES_EQUAL(samples.SamplesSize(), 1);
         {
             const NProto::TMultiSample& s = samples.GetSamples(0);
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::RATE); 
-            AssertLabels(s, TLabels{{"metric", "hello"}, {"label", "world"}}); 
- 
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::RATE);
+            AssertLabels(s, TLabels{{"metric", "hello"}, {"label", "world"}});
+
             UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
             AssertPointEqual(s.GetPoints(0), TInstant::Zero(), ui64(1));
-        } 
-    } 
+        }
+    }
     Y_UNIT_TEST(Decode1) {
-        NProto::TMultiSamplesList samples; 
-        { 
-            IMetricEncoderPtr e = EncoderProtobuf(&samples); 
- 
-            TString testJson = NResource::Find("/expected.json"); 
-            DecodeJson(testJson, e.Get()); 
-        } 
- 
-        UNIT_ASSERT_VALUES_EQUAL( 
-            TInstant::MilliSeconds(samples.GetCommonTime()), 
-            TInstant::Seconds(1500000000)); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(samples.CommonLabelsSize(), 1); 
-        AssertLabelEqual(samples.GetCommonLabels(0), "project", "solomon"); 
- 
+        NProto::TMultiSamplesList samples;
+        {
+            IMetricEncoderPtr e = EncoderProtobuf(&samples);
+
+            TString testJson = NResource::Find("/expected.json");
+            DecodeJson(testJson, e.Get());
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(
+            TInstant::MilliSeconds(samples.GetCommonTime()),
+            TInstant::Seconds(1500000000));
+
+        UNIT_ASSERT_VALUES_EQUAL(samples.CommonLabelsSize(), 1);
+        AssertLabelEqual(samples.GetCommonLabels(0), "project", "solomon");
+
         UNIT_ASSERT_VALUES_EQUAL(samples.SamplesSize(), 6);
-        { 
-            const NProto::TMultiSample& s = samples.GetSamples(0); 
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::COUNTER); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2); 
-            AssertLabelEqual(s.GetLabels(0), "metric", "single"); 
+        {
+            const NProto::TMultiSample& s = samples.GetSamples(0);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::COUNTER);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2);
+            AssertLabelEqual(s.GetLabels(0), "metric", "single");
             AssertLabelEqual(s.GetLabels(1), "labels", "l1");
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1); 
-            AssertPointEqual(s.GetPoints(0), now, ui64(17)); 
-        } 
-        { 
-            const NProto::TMultiSample& s = samples.GetSamples(1); 
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::RATE); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2); 
-            AssertLabelEqual(s.GetLabels(0), "metric", "single"); 
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), now, ui64(17));
+        }
+        {
+            const NProto::TMultiSample& s = samples.GetSamples(1);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::RATE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2);
+            AssertLabelEqual(s.GetLabels(0), "metric", "single");
             AssertLabelEqual(s.GetLabels(1), "labels", "l2");
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1); 
-            AssertPointEqual(s.GetPoints(0), now, ui64(17)); 
-        } 
-        { 
-            const NProto::TMultiSample& s = samples.GetSamples(2); 
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2); 
-            AssertLabelEqual(s.GetLabels(0), "metric", "single"); 
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), now, ui64(17));
+        }
+        {
+            const NProto::TMultiSample& s = samples.GetSamples(2);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2);
+            AssertLabelEqual(s.GetLabels(0), "metric", "single");
             AssertLabelEqual(s.GetLabels(1), "labels", "l3");
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1); 
-            AssertPointEqual(s.GetPoints(0), now, 3.14); 
-        } 
-        { 
-            const NProto::TMultiSample& s = samples.GetSamples(3); 
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), now, 3.14);
+        }
+        {
+            const NProto::TMultiSample& s = samples.GetSamples(3);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::IGAUGE);
             UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2);
             AssertLabelEqual(s.GetLabels(0), "metric", "single_igauge");
@@ -412,152 +412,152 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         }
         {
             const NProto::TMultiSample& s = samples.GetSamples(4);
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2); 
-            AssertLabelEqual(s.GetLabels(0), "metric", "multiple"); 
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2);
+            AssertLabelEqual(s.GetLabels(0), "metric", "multiple");
             AssertLabelEqual(s.GetLabels(1), "labels", "l5");
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 3); 
-            AssertPointEqualNan(s.GetPoints(0), now); 
-            AssertPointEqualInf(s.GetPoints(1), now + TDuration::Seconds(15), 1); 
-            AssertPointEqualInf(s.GetPoints(2), now + TDuration::Seconds(30), -11); 
-        } 
-        { 
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 3);
+            AssertPointEqualNan(s.GetPoints(0), now);
+            AssertPointEqualInf(s.GetPoints(1), now + TDuration::Seconds(15), 1);
+            AssertPointEqualInf(s.GetPoints(2), now + TDuration::Seconds(30), -11);
+        }
+        {
             const NProto::TMultiSample& s = samples.GetSamples(5);
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::COUNTER); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2); 
-            AssertLabelEqual(s.GetLabels(0), "metric", "multiple"); 
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::COUNTER);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2);
+            AssertLabelEqual(s.GetLabels(0), "metric", "multiple");
             AssertLabelEqual(s.GetLabels(1), "labels", "l6");
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2); 
-            AssertPointEqual(s.GetPoints(0), now, ui64(1337)); 
-            AssertPointEqual(s.GetPoints(1), now + TDuration::Seconds(15), ui64(1338)); 
-        } 
-    } 
- 
-    Y_UNIT_TEST(DecodeMetrics) { 
-        NProto::TMultiSamplesList samples; 
-        { 
-            IMetricEncoderPtr e = EncoderProtobuf(&samples); 
- 
-            TString metricsJson = NResource::Find("/metrics.json"); 
-            DecodeJson(metricsJson, e.Get()); 
-        } 
- 
-        UNIT_ASSERT_VALUES_EQUAL( 
-            TInstant::MilliSeconds(samples.GetCommonTime()), 
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2);
+            AssertPointEqual(s.GetPoints(0), now, ui64(1337));
+            AssertPointEqual(s.GetPoints(1), now + TDuration::Seconds(15), ui64(1338));
+        }
+    }
+
+    Y_UNIT_TEST(DecodeMetrics) {
+        NProto::TMultiSamplesList samples;
+        {
+            IMetricEncoderPtr e = EncoderProtobuf(&samples);
+
+            TString metricsJson = NResource::Find("/metrics.json");
+            DecodeJson(metricsJson, e.Get());
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(
+            TInstant::MilliSeconds(samples.GetCommonTime()),
             TInstant::ParseIso8601Deprecated("2017-08-27T12:34:56Z"));
- 
-        UNIT_ASSERT_VALUES_EQUAL(samples.CommonLabelsSize(), 3); 
-        AssertLabelEqual(samples.GetCommonLabels(0), "project", "solomon"); 
-        AssertLabelEqual(samples.GetCommonLabels(1), "cluster", "man"); 
-        AssertLabelEqual(samples.GetCommonLabels(2), "service", "stockpile"); 
- 
+
+        UNIT_ASSERT_VALUES_EQUAL(samples.CommonLabelsSize(), 3);
+        AssertLabelEqual(samples.GetCommonLabels(0), "project", "solomon");
+        AssertLabelEqual(samples.GetCommonLabels(1), "cluster", "man");
+        AssertLabelEqual(samples.GetCommonLabels(2), "service", "stockpile");
+
         UNIT_ASSERT_VALUES_EQUAL(samples.SamplesSize(), 4);
-        { 
-            const NProto::TMultiSample& s = samples.GetSamples(0); 
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1); 
-            AssertLabelEqual(s.GetLabels(0), "metric", "Memory"); 
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1); 
-            AssertPointEqual(s.GetPoints(0), TInstant::Zero(), 10.0); 
-        } 
-        { 
-            const NProto::TMultiSample& s = samples.GetSamples(1); 
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::RATE); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1); 
-            AssertLabelEqual(s.GetLabels(0), "metric", "UserTime"); 
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1); 
-            AssertPointEqual(s.GetPoints(0), TInstant::Zero(), ui64(1)); 
-        } 
-        { 
-            const NProto::TMultiSample& s = samples.GetSamples(2); 
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2); 
-            AssertLabelEqual(s.GetLabels(0), "export", "Oxygen"); 
-            AssertLabelEqual(s.GetLabels(1), "metric", "QueueSize"); 
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1); 
+        {
+            const NProto::TMultiSample& s = samples.GetSamples(0);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "metric", "Memory");
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), TInstant::Zero(), 10.0);
+        }
+        {
+            const NProto::TMultiSample& s = samples.GetSamples(1);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::RATE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "metric", "UserTime");
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), TInstant::Zero(), ui64(1));
+        }
+        {
+            const NProto::TMultiSample& s = samples.GetSamples(2);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2);
+            AssertLabelEqual(s.GetLabels(0), "export", "Oxygen");
+            AssertLabelEqual(s.GetLabels(1), "metric", "QueueSize");
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
             auto ts = TInstant::ParseIso8601Deprecated("2017-11-05T12:34:56.000Z");
-            AssertPointEqual(s.GetPoints(0), ts, 3.14159); 
-        } 
-        { 
+            AssertPointEqual(s.GetPoints(0), ts, 3.14159);
+        }
+        {
             const NProto::TMultiSample& s = samples.GetSamples(3);
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1); 
-            AssertLabelEqual(s.GetLabels(0), "metric", "Writes"); 
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2); 
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "metric", "Writes");
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2);
             auto ts1 = TInstant::ParseIso8601Deprecated("2017-08-28T12:32:11Z");
-            AssertPointEqual(s.GetPoints(0), ts1, -10.0); 
-            auto ts2 = TInstant::Seconds(1503923187); 
-            AssertPointEqual(s.GetPoints(1), ts2, 20.0); 
-        } 
-    } 
- 
-    Y_UNIT_TEST(DecodeSensors) { 
-        NProto::TMultiSamplesList samples; 
-        { 
-            IMetricEncoderPtr e = EncoderProtobuf(&samples); 
- 
-            TString sensorsJson = NResource::Find("/sensors.json"); 
-            DecodeJson(sensorsJson, e.Get()); 
-        } 
- 
-        UNIT_ASSERT_VALUES_EQUAL( 
-            TInstant::MilliSeconds(samples.GetCommonTime()), 
-            TInstant::ParseIso8601Deprecated("2017-08-27T12:34:56Z")); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(samples.CommonLabelsSize(), 3); 
-        AssertLabelEqual(samples.GetCommonLabels(0), "project", "solomon"); 
-        AssertLabelEqual(samples.GetCommonLabels(1), "cluster", "man"); 
-        AssertLabelEqual(samples.GetCommonLabels(2), "service", "stockpile"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(samples.SamplesSize(), 4); 
-        { 
-            const NProto::TMultiSample& s = samples.GetSamples(0); 
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1); 
-            AssertLabelEqual(s.GetLabels(0), "metric", "Memory"); 
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1); 
-            AssertPointEqual(s.GetPoints(0), TInstant::Zero(), 10.0); 
-        } 
-        { 
-            const NProto::TMultiSample& s = samples.GetSamples(1); 
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::RATE); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1); 
-            AssertLabelEqual(s.GetLabels(0), "metric", "UserTime"); 
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1); 
-            AssertPointEqual(s.GetPoints(0), TInstant::Zero(), ui64(1)); 
-        } 
-        { 
-            const NProto::TMultiSample& s = samples.GetSamples(2); 
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2); 
-            AssertLabelEqual(s.GetLabels(0), "export", "Oxygen"); 
-            AssertLabelEqual(s.GetLabels(1), "metric", "QueueSize"); 
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1); 
-            auto ts = TInstant::ParseIso8601Deprecated("2017-11-05T12:34:56.000Z"); 
-            AssertPointEqual(s.GetPoints(0), ts, 3.14159); 
-        } 
-        { 
-            const NProto::TMultiSample& s = samples.GetSamples(3); 
-            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE); 
-            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1); 
-            AssertLabelEqual(s.GetLabels(0), "metric", "Writes"); 
- 
-            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2); 
-            auto ts1 = TInstant::ParseIso8601Deprecated("2017-08-28T12:32:11Z"); 
-            AssertPointEqual(s.GetPoints(0), ts1, -10.0); 
-            auto ts2 = TInstant::Seconds(1503923187); 
-            AssertPointEqual(s.GetPoints(1), ts2, 20.0); 
-        } 
-    } 
+            AssertPointEqual(s.GetPoints(0), ts1, -10.0);
+            auto ts2 = TInstant::Seconds(1503923187);
+            AssertPointEqual(s.GetPoints(1), ts2, 20.0);
+        }
+    }
+
+    Y_UNIT_TEST(DecodeSensors) {
+        NProto::TMultiSamplesList samples;
+        {
+            IMetricEncoderPtr e = EncoderProtobuf(&samples);
+
+            TString sensorsJson = NResource::Find("/sensors.json");
+            DecodeJson(sensorsJson, e.Get());
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(
+            TInstant::MilliSeconds(samples.GetCommonTime()),
+            TInstant::ParseIso8601Deprecated("2017-08-27T12:34:56Z"));
+
+        UNIT_ASSERT_VALUES_EQUAL(samples.CommonLabelsSize(), 3);
+        AssertLabelEqual(samples.GetCommonLabels(0), "project", "solomon");
+        AssertLabelEqual(samples.GetCommonLabels(1), "cluster", "man");
+        AssertLabelEqual(samples.GetCommonLabels(2), "service", "stockpile");
+
+        UNIT_ASSERT_VALUES_EQUAL(samples.SamplesSize(), 4);
+        {
+            const NProto::TMultiSample& s = samples.GetSamples(0);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "metric", "Memory");
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), TInstant::Zero(), 10.0);
+        }
+        {
+            const NProto::TMultiSample& s = samples.GetSamples(1);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::RATE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "metric", "UserTime");
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), TInstant::Zero(), ui64(1));
+        }
+        {
+            const NProto::TMultiSample& s = samples.GetSamples(2);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2);
+            AssertLabelEqual(s.GetLabels(0), "export", "Oxygen");
+            AssertLabelEqual(s.GetLabels(1), "metric", "QueueSize");
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            auto ts = TInstant::ParseIso8601Deprecated("2017-11-05T12:34:56.000Z");
+            AssertPointEqual(s.GetPoints(0), ts, 3.14159);
+        }
+        {
+            const NProto::TMultiSample& s = samples.GetSamples(3);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "metric", "Writes");
+
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2);
+            auto ts1 = TInstant::ParseIso8601Deprecated("2017-08-28T12:32:11Z");
+            AssertPointEqual(s.GetPoints(0), ts1, -10.0);
+            auto ts2 = TInstant::Seconds(1503923187);
+            AssertPointEqual(s.GetPoints(1), ts2, 20.0);
+        }
+    }
 
     Y_UNIT_TEST(DecodeToEncoder) {
         auto testJson = NResource::Find("/test_decode_to_encode.json");
@@ -574,16 +574,16 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         UNIT_ASSERT_VALUES_EQUAL(val1, val2);
     }
 
-    void WriteEmptySeries(const IMetricEncoderPtr& e) { 
+    void WriteEmptySeries(const IMetricEncoderPtr& e) {
         e->OnStreamBegin();
         {
-            e->OnMetricBegin(EMetricType::COUNTER); 
+            e->OnMetricBegin(EMetricType::COUNTER);
             {
                 e->OnLabelsBegin();
                 e->OnLabel("foo", "bar");
                 e->OnLabelsEnd();
             }
-            e->OnMetricEnd(); 
+            e->OnMetricEnd();
         }
 
         e->OnStreamEnd();
@@ -602,9 +602,9 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         UNIT_ASSERT_NO_DIFF(json, expectedJson);
     }
 
-    void WriteEmptyLabels(IMetricEncoderPtr& e) { 
+    void WriteEmptyLabels(IMetricEncoderPtr& e) {
         e->OnStreamBegin();
-        e->OnMetricBegin(EMetricType::COUNTER); 
+        e->OnMetricBegin(EMetricType::COUNTER);
 
         e->OnLabelsBegin();
         UNIT_ASSERT_EXCEPTION(e->OnLabelsEnd(), yexception);
@@ -638,29 +638,29 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         UNIT_ASSERT_NO_DIFF(json, expectedJson);
     }
 
-    Y_UNIT_TEST(BufferedEncoderMergesMetrics) { 
+    Y_UNIT_TEST(BufferedEncoderMergesMetrics) {
         TString json;
         TStringOutput out(json);
 
         auto e = BufferedEncoderJson(&out, 2);
         auto ts = 1;
 
-        auto writeMetric = [&] (const TString& val) { 
-            e->OnMetricBegin(EMetricType::COUNTER); 
+        auto writeMetric = [&] (const TString& val) {
+            e->OnMetricBegin(EMetricType::COUNTER);
 
             e->OnLabelsBegin();
             e->OnLabel("foo", val);
             e->OnLabelsEnd();
             e->OnUint64(TInstant::Seconds(ts++), 42);
 
-            e->OnMetricEnd(); 
+            e->OnMetricEnd();
         };
 
         e->OnStreamBegin();
-        writeMetric("bar"); 
-        writeMetric("bar"); 
-        writeMetric("baz"); 
-        writeMetric("bar"); 
+        writeMetric("bar");
+        writeMetric("bar");
+        writeMetric("baz");
+        writeMetric("bar");
         e->OnStreamEnd();
         e->Close();
 
@@ -676,13 +676,13 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         auto e = EncoderJson(&out);
         auto writePreamble = [&] {
             e->OnStreamBegin();
-            e->OnMetricBegin(EMetricType::COUNTER); 
+            e->OnMetricBegin(EMetricType::COUNTER);
             e->OnLabelsBegin();
             e->OnLabel("foo", "bar");
             e->OnLabelsEnd();
         };
 
-        // writing two values for a metric in a row will trigger 
+        // writing two values for a metric in a row will trigger
         // timeseries object construction
         writePreamble();
         e->OnUint64(TInstant::Zero(), 42);
@@ -705,7 +705,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         {
             auto e = BufferedEncoderJson(&out, 2);
             e->OnStreamBegin();
-            e->OnMetricBegin(EMetricType::COUNTER); 
+            e->OnMetricBegin(EMetricType::COUNTER);
             e->OnLabelsBegin();
             e->OnLabel("foo", "bar");
             e->OnLabelsEnd();
@@ -715,38 +715,38 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
             e->OnUint64(TInstant::Zero(), 43);
             e->OnUint64(TInstant::Zero(), 44);
             e->OnUint64(TInstant::Zero(), 45);
-            e->OnMetricEnd(); 
+            e->OnMetricEnd();
             e->OnStreamEnd();
         }
 
         out << "\n";
         UNIT_ASSERT_NO_DIFF(out.Str(), NResource::Find("/buffered_ts_merge.json"));
-    } 
-
-    template <typename TFactory, typename TConsumer> 
-    TString EncodeToString(TFactory factory, TConsumer consumer) { 
-        TStringStream out; 
-        { 
-            IMetricEncoderPtr e = factory(&out, 2); 
-            consumer(e.Get()); 
-        } 
-        out << '\n'; 
-        return out.Str(); 
     }
- 
+
+    template <typename TFactory, typename TConsumer>
+    TString EncodeToString(TFactory factory, TConsumer consumer) {
+        TStringStream out;
+        {
+            IMetricEncoderPtr e = factory(&out, 2);
+            consumer(e.Get());
+        }
+        out << '\n';
+        return out.Str();
+    }
+
     Y_UNIT_TEST(SummaryValueEncode) {
-        auto writeDocument = [](IMetricEncoder* e) { 
+        auto writeDocument = [](IMetricEncoder* e) {
             e->OnStreamBegin();
             {
-                e->OnMetricBegin(EMetricType::DSUMMARY); 
+                e->OnMetricBegin(EMetricType::DSUMMARY);
                 {
                     e->OnLabelsBegin();
-                    e->OnLabel("metric", "temperature"); 
+                    e->OnLabel("metric", "temperature");
                     e->OnLabelsEnd();
                 }
 
                 e->OnSummaryDouble(now, MakeIntrusive<TSummaryDoubleSnapshot>(10., -0.5, 0.5, 0.3, 30u));
-                e->OnMetricEnd(); 
+                e->OnMetricEnd();
             }
             e->OnStreamEnd();
         };
@@ -768,18 +768,18 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
     }
 
     Y_UNIT_TEST(SummaryInfEncode) {
-        auto writeDocument = [](IMetricEncoder* e) { 
+        auto writeDocument = [](IMetricEncoder* e) {
             e->OnStreamBegin();
             {
-                e->OnMetricBegin(EMetricType::DSUMMARY); 
+                e->OnMetricBegin(EMetricType::DSUMMARY);
                 {
                     e->OnLabelsBegin();
-                    e->OnLabel("metric", "temperature"); 
+                    e->OnLabel("metric", "temperature");
                     e->OnLabelsEnd();
                 }
 
                 e->OnSummaryDouble(now, TestInfSummary());
-                e->OnMetricEnd(); 
+                e->OnMetricEnd();
             }
             e->OnStreamEnd();
         };
@@ -794,7 +794,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
     Y_UNIT_TEST(SummaryInfDecode) {
         NProto::TMultiSamplesList samples;
         {
-            IMetricEncoderPtr e = EncoderProtobuf(&samples); 
+            IMetricEncoderPtr e = EncoderProtobuf(&samples);
 
             TString testJson = NResource::Find("/summary_inf.json");
             DecodeJson(testJson, e.Get());
@@ -803,9 +803,9 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         UNIT_ASSERT_VALUES_EQUAL(1, samples.SamplesSize());
         const NProto::TMultiSample& s = samples.GetSamples(0);
 
-        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::DSUMMARY); 
+        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::DSUMMARY);
         UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
-        AssertLabelEqual(s.GetLabels(0), "metric", "temperature"); 
+        AssertLabelEqual(s.GetLabels(0), "metric", "temperature");
 
         UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
 
@@ -820,7 +820,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
     Y_UNIT_TEST(SummaryValueDecode) {
         NProto::TMultiSamplesList samples;
         {
-            IMetricEncoderPtr e = EncoderProtobuf(&samples); 
+            IMetricEncoderPtr e = EncoderProtobuf(&samples);
 
             TString testJson = NResource::Find("/summary_value.json");
             DecodeJson(testJson, e.Get());
@@ -829,9 +829,9 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         UNIT_ASSERT_VALUES_EQUAL(1, samples.SamplesSize());
         const NProto::TMultiSample& s = samples.GetSamples(0);
 
-        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::DSUMMARY); 
+        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::DSUMMARY);
         UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
-        AssertLabelEqual(s.GetLabels(0), "metric", "temperature"); 
+        AssertLabelEqual(s.GetLabels(0), "metric", "temperature");
 
         UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
 
@@ -840,13 +840,13 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
     }
 
     Y_UNIT_TEST(SummaryTimeSeriesEncode) {
-        auto writeDocument = [](IMetricEncoder* e) { 
+        auto writeDocument = [](IMetricEncoder* e) {
             e->OnStreamBegin();
             {
-                e->OnMetricBegin(EMetricType::DSUMMARY); 
+                e->OnMetricBegin(EMetricType::DSUMMARY);
                 {
                     e->OnLabelsBegin();
-                    e->OnLabel("metric", "temperature"); 
+                    e->OnLabel("metric", "temperature");
                     e->OnLabelsEnd();
                 }
 
@@ -862,7 +862,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
 
                 e->OnSummaryDouble(now + TDuration::Seconds(15), summary.Snapshot());
 
-                e->OnMetricEnd(); 
+                e->OnMetricEnd();
             }
             e->OnStreamEnd();
         };
@@ -877,7 +877,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
     Y_UNIT_TEST(SummaryTimeSeriesDecode) {
         NProto::TMultiSamplesList samples;
         {
-            IMetricEncoderPtr e = EncoderProtobuf(&samples); 
+            IMetricEncoderPtr e = EncoderProtobuf(&samples);
 
             TString testJson = NResource::Find("/summary_timeseries.json");
             DecodeJson(testJson, e.Get());
@@ -886,9 +886,9 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         UNIT_ASSERT_VALUES_EQUAL(1, samples.SamplesSize());
         const NProto::TMultiSample& s = samples.GetSamples(0);
 
-        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::DSUMMARY); 
+        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::DSUMMARY);
         UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
-        AssertLabelEqual(s.GetLabels(0), "metric", "temperature"); 
+        AssertLabelEqual(s.GetLabels(0), "metric", "temperature");
 
         UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2);
 
@@ -912,7 +912,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
                 e->OnMetricBegin(EMetricType::LOGHIST);
                 {
                     e->OnLabelsBegin();
-                    e->OnLabel("metric", "ms"); 
+                    e->OnLabel("metric", "ms");
                     e->OnLabelsEnd();
                 }
 
@@ -943,7 +943,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
 
         UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::LOGHISTOGRAM);
         UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
-        AssertLabelEqual(s.GetLabels(0), "metric", "ms"); 
+        AssertLabelEqual(s.GetLabels(0), "metric", "ms");
 
         UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
 
@@ -951,36 +951,36 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         AssertPointEqual(s.GetPoints(0), now, *snapshot);
     }
 
-    Y_UNIT_TEST(HistogramValueEncode) { 
-        auto writeDocument = [](IMetricEncoder* e) { 
-            e->OnStreamBegin(); 
-            { 
-                e->OnMetricBegin(EMetricType::HIST); 
-                { 
-                    e->OnLabelsBegin(); 
-                    e->OnLabel("metric", "responseTimeMillis"); 
-                    e->OnLabelsEnd(); 
-                } 
- 
-                // {1: 1, 2: 1, 4: 2, 8: 4, 16: 8, inf: 83} 
-                auto h = ExponentialHistogram(6, 2); 
-                for (i64 i = 1; i < 100; i++) { 
-                    h->Collect(i); 
-                } 
- 
-                e->OnHistogram(now, h->Snapshot()); 
-                e->OnMetricEnd(); 
-            } 
-            e->OnStreamEnd(); 
-        }; 
- 
-        TString result1 = EncodeToString(EncoderJson, writeDocument); 
-        UNIT_ASSERT_NO_DIFF(result1, NResource::Find("/histogram_value.json")); 
- 
-        TString result2 = EncodeToString(BufferedEncoderJson, writeDocument); 
-        UNIT_ASSERT_NO_DIFF(result2, NResource::Find("/histogram_value.json")); 
-    } 
- 
+    Y_UNIT_TEST(HistogramValueEncode) {
+        auto writeDocument = [](IMetricEncoder* e) {
+            e->OnStreamBegin();
+            {
+                e->OnMetricBegin(EMetricType::HIST);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("metric", "responseTimeMillis");
+                    e->OnLabelsEnd();
+                }
+
+                // {1: 1, 2: 1, 4: 2, 8: 4, 16: 8, inf: 83}
+                auto h = ExponentialHistogram(6, 2);
+                for (i64 i = 1; i < 100; i++) {
+                    h->Collect(i);
+                }
+
+                e->OnHistogram(now, h->Snapshot());
+                e->OnMetricEnd();
+            }
+            e->OnStreamEnd();
+        };
+
+        TString result1 = EncodeToString(EncoderJson, writeDocument);
+        UNIT_ASSERT_NO_DIFF(result1, NResource::Find("/histogram_value.json"));
+
+        TString result2 = EncodeToString(BufferedEncoderJson, writeDocument);
+        UNIT_ASSERT_NO_DIFF(result2, NResource::Find("/histogram_value.json"));
+    }
+
     Y_UNIT_TEST(LogHistogramTimeSeriesEncode) {
         auto writeDocument = [](IMetricEncoder* e) {
             e->OnStreamBegin();
@@ -988,7 +988,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
                 e->OnMetricBegin(EMetricType::LOGHIST);
                 {
                     e->OnLabelsBegin();
-                    e->OnLabel("metric", "ms"); 
+                    e->OnLabel("metric", "ms");
                     e->OnLabelsEnd();
                 }
 
@@ -1022,7 +1022,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
 
         UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::LOGHISTOGRAM);
         UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
-        AssertLabelEqual(s.GetLabels(0), "metric", "ms"); 
+        AssertLabelEqual(s.GetLabels(0), "metric", "ms");
 
         UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2);
 
@@ -1034,130 +1034,130 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
     }
 
     void HistogramValueDecode(const TString& filePath) {
-        NProto::TMultiSamplesList samples; 
-        { 
-            IMetricEncoderPtr e = EncoderProtobuf(&samples); 
- 
+        NProto::TMultiSamplesList samples;
+        {
+            IMetricEncoderPtr e = EncoderProtobuf(&samples);
+
             TString testJson = NResource::Find(filePath);
-            DecodeJson(testJson, e.Get()); 
-        } 
- 
-        UNIT_ASSERT_VALUES_EQUAL(1, samples.SamplesSize()); 
-        const NProto::TMultiSample& s = samples.GetSamples(0); 
- 
-        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::HISTOGRAM); 
-        UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1); 
-        AssertLabelEqual(s.GetLabels(0), "metric", "responseTimeMillis"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1); 
- 
-        auto h = ExponentialHistogram(6, 2); 
-        for (i64 i = 1; i < 100; i++) { 
-            h->Collect(i); 
-        } 
- 
-        AssertPointEqual(s.GetPoints(0), now, *h->Snapshot()); 
-    } 
- 
+            DecodeJson(testJson, e.Get());
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(1, samples.SamplesSize());
+        const NProto::TMultiSample& s = samples.GetSamples(0);
+
+        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::HISTOGRAM);
+        UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+        AssertLabelEqual(s.GetLabels(0), "metric", "responseTimeMillis");
+
+        UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+
+        auto h = ExponentialHistogram(6, 2);
+        for (i64 i = 1; i < 100; i++) {
+            h->Collect(i);
+        }
+
+        AssertPointEqual(s.GetPoints(0), now, *h->Snapshot());
+    }
+
     Y_UNIT_TEST(HistogramValueDecode) {
         HistogramValueDecode("/histogram_value.json");
         HistogramValueDecode("/histogram_value_inf_before_bounds.json");
     }
 
-    Y_UNIT_TEST(HistogramTimeSeriesEncode) { 
-        auto writeDocument = [](IMetricEncoder* e) { 
-            e->OnStreamBegin(); 
-            { 
-                e->OnMetricBegin(EMetricType::HIST_RATE); 
-                { 
-                    e->OnLabelsBegin(); 
-                    e->OnLabel("metric", "responseTimeMillis"); 
-                    e->OnLabelsEnd(); 
-                } 
- 
-                // {1: 1, 2: 1, 4: 2, 8: 4, 16: 8, inf: 83} 
-                auto h = ExponentialHistogram(6, 2); 
-                for (i64 i = 1; i < 100; i++) { 
-                    h->Collect(i); 
-                } 
-                e->OnHistogram(now, h->Snapshot()); 
- 
-                // {1: 2, 2: 2, 4: 4, 8: 8, 16: 16, inf: 166} 
-                for (i64 i = 1; i < 100; i++) { 
-                    h->Collect(i); 
-                } 
-                e->OnHistogram(now + TDuration::Seconds(15), h->Snapshot()); 
- 
-                e->OnMetricEnd(); 
-            } 
-            e->OnStreamEnd(); 
-        }; 
- 
-        TString result1 = EncodeToString(EncoderJson, writeDocument); 
-        UNIT_ASSERT_NO_DIFF(result1, NResource::Find("/histogram_timeseries.json")); 
- 
-        TString result2 = EncodeToString(BufferedEncoderJson, writeDocument); 
-        UNIT_ASSERT_NO_DIFF(result2, NResource::Find("/histogram_timeseries.json")); 
-    } 
- 
-    Y_UNIT_TEST(HistogramTimeSeriesDecode) { 
-        NProto::TMultiSamplesList samples; 
-        { 
-            IMetricEncoderPtr e = EncoderProtobuf(&samples); 
- 
-            TString testJson = NResource::Find("/histogram_timeseries.json"); 
-            DecodeJson(testJson, e.Get()); 
-        } 
- 
-        UNIT_ASSERT_VALUES_EQUAL(1, samples.SamplesSize()); 
-        const NProto::TMultiSample& s = samples.GetSamples(0); 
- 
-        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::HIST_RATE); 
-        UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1); 
-        AssertLabelEqual(s.GetLabels(0), "metric", "responseTimeMillis"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2); 
- 
-        auto h = ExponentialHistogram(6, 2); 
-        for (i64 i = 1; i < 100; i++) { 
-            h->Collect(i); 
-        } 
- 
-        AssertPointEqual(s.GetPoints(0), now, *h->Snapshot()); 
- 
-        for (i64 i = 1; i < 100; i++) { 
-            h->Collect(i); 
-        } 
- 
-        AssertPointEqual(s.GetPoints(1), now + TDuration::Seconds(15), *h->Snapshot()); 
-    } 
- 
-    Y_UNIT_TEST(IntGaugeEncode) { 
-        auto writeDocument = [](IMetricEncoder* e) { 
-            e->OnStreamBegin(); 
-            { 
-                e->OnMetricBegin(EMetricType::IGAUGE); 
-                { 
-                    e->OnLabelsBegin(); 
-                    e->OnLabel("metric", "a"); 
-                    e->OnLabelsEnd(); 
-                } 
-                e->OnInt64(now, Min<i64>()); 
-                e->OnInt64(now + TDuration::Seconds(1), -1); 
-                e->OnInt64(now + TDuration::Seconds(2), 0); 
-                e->OnInt64(now + TDuration::Seconds(3), Max<i64>()); 
-                e->OnMetricEnd(); 
-            } 
-            e->OnStreamEnd(); 
-        }; 
- 
-        TString result1 = EncodeToString(EncoderJson, writeDocument); 
-        UNIT_ASSERT_NO_DIFF(result1, NResource::Find("/int_gauge.json")); 
- 
-        TString result2 = EncodeToString(BufferedEncoderJson, writeDocument); 
-        UNIT_ASSERT_NO_DIFF(result2, NResource::Find("/int_gauge.json")); 
-    } 
- 
+    Y_UNIT_TEST(HistogramTimeSeriesEncode) {
+        auto writeDocument = [](IMetricEncoder* e) {
+            e->OnStreamBegin();
+            {
+                e->OnMetricBegin(EMetricType::HIST_RATE);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("metric", "responseTimeMillis");
+                    e->OnLabelsEnd();
+                }
+
+                // {1: 1, 2: 1, 4: 2, 8: 4, 16: 8, inf: 83}
+                auto h = ExponentialHistogram(6, 2);
+                for (i64 i = 1; i < 100; i++) {
+                    h->Collect(i);
+                }
+                e->OnHistogram(now, h->Snapshot());
+
+                // {1: 2, 2: 2, 4: 4, 8: 8, 16: 16, inf: 166}
+                for (i64 i = 1; i < 100; i++) {
+                    h->Collect(i);
+                }
+                e->OnHistogram(now + TDuration::Seconds(15), h->Snapshot());
+
+                e->OnMetricEnd();
+            }
+            e->OnStreamEnd();
+        };
+
+        TString result1 = EncodeToString(EncoderJson, writeDocument);
+        UNIT_ASSERT_NO_DIFF(result1, NResource::Find("/histogram_timeseries.json"));
+
+        TString result2 = EncodeToString(BufferedEncoderJson, writeDocument);
+        UNIT_ASSERT_NO_DIFF(result2, NResource::Find("/histogram_timeseries.json"));
+    }
+
+    Y_UNIT_TEST(HistogramTimeSeriesDecode) {
+        NProto::TMultiSamplesList samples;
+        {
+            IMetricEncoderPtr e = EncoderProtobuf(&samples);
+
+            TString testJson = NResource::Find("/histogram_timeseries.json");
+            DecodeJson(testJson, e.Get());
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(1, samples.SamplesSize());
+        const NProto::TMultiSample& s = samples.GetSamples(0);
+
+        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::HIST_RATE);
+        UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+        AssertLabelEqual(s.GetLabels(0), "metric", "responseTimeMillis");
+
+        UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2);
+
+        auto h = ExponentialHistogram(6, 2);
+        for (i64 i = 1; i < 100; i++) {
+            h->Collect(i);
+        }
+
+        AssertPointEqual(s.GetPoints(0), now, *h->Snapshot());
+
+        for (i64 i = 1; i < 100; i++) {
+            h->Collect(i);
+        }
+
+        AssertPointEqual(s.GetPoints(1), now + TDuration::Seconds(15), *h->Snapshot());
+    }
+
+    Y_UNIT_TEST(IntGaugeEncode) {
+        auto writeDocument = [](IMetricEncoder* e) {
+            e->OnStreamBegin();
+            {
+                e->OnMetricBegin(EMetricType::IGAUGE);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("metric", "a");
+                    e->OnLabelsEnd();
+                }
+                e->OnInt64(now, Min<i64>());
+                e->OnInt64(now + TDuration::Seconds(1), -1);
+                e->OnInt64(now + TDuration::Seconds(2), 0);
+                e->OnInt64(now + TDuration::Seconds(3), Max<i64>());
+                e->OnMetricEnd();
+            }
+            e->OnStreamEnd();
+        };
+
+        TString result1 = EncodeToString(EncoderJson, writeDocument);
+        UNIT_ASSERT_NO_DIFF(result1, NResource::Find("/int_gauge.json"));
+
+        TString result2 = EncodeToString(BufferedEncoderJson, writeDocument);
+        UNIT_ASSERT_NO_DIFF(result2, NResource::Find("/int_gauge.json"));
+    }
+
     Y_UNIT_TEST(InconsistentMetricTypes) {
         auto emitMetrics = [](IMetricEncoder& encoder, const TString& expectedError) {
             encoder.OnMetricBegin(EMetricType::GAUGE);
@@ -1213,33 +1213,33 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         }
     }
 
-    Y_UNIT_TEST(IntGaugeDecode) { 
-        NProto::TMultiSamplesList samples; 
-        { 
-            IMetricEncoderPtr e = EncoderProtobuf(&samples); 
- 
-            TString testJson = NResource::Find("/int_gauge.json"); 
-            DecodeJson(testJson, e.Get()); 
-        } 
- 
-        UNIT_ASSERT_VALUES_EQUAL(1, samples.SamplesSize()); 
-        const NProto::TMultiSample& s = samples.GetSamples(0); 
- 
-        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::IGAUGE); 
-        UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1); 
-        AssertLabelEqual(s.GetLabels(0), "metric", "a"); 
- 
-        UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 4); 
-        AssertPointEqual(s.GetPoints(0), now, Min<i64>()); 
-        AssertPointEqual(s.GetPoints(1), now + TDuration::Seconds(1), i64(-1)); 
-        AssertPointEqual(s.GetPoints(2), now + TDuration::Seconds(2), i64(0)); 
-        AssertPointEqual(s.GetPoints(3), now + TDuration::Seconds(3), Max<i64>()); 
-    } 
+    Y_UNIT_TEST(IntGaugeDecode) {
+        NProto::TMultiSamplesList samples;
+        {
+            IMetricEncoderPtr e = EncoderProtobuf(&samples);
+
+            TString testJson = NResource::Find("/int_gauge.json");
+            DecodeJson(testJson, e.Get());
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(1, samples.SamplesSize());
+        const NProto::TMultiSample& s = samples.GetSamples(0);
+
+        UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::IGAUGE);
+        UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+        AssertLabelEqual(s.GetLabels(0), "metric", "a");
+
+        UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 4);
+        AssertPointEqual(s.GetPoints(0), now, Min<i64>());
+        AssertPointEqual(s.GetPoints(1), now + TDuration::Seconds(1), i64(-1));
+        AssertPointEqual(s.GetPoints(2), now + TDuration::Seconds(2), i64(0));
+        AssertPointEqual(s.GetPoints(3), now + TDuration::Seconds(3), Max<i64>());
+    }
 
     Y_UNIT_TEST(FuzzerRegression) {
         NProto::TMultiSamplesList samples;
         {
-            IMetricEncoderPtr e = EncoderProtobuf(&samples); 
+            IMetricEncoderPtr e = EncoderProtobuf(&samples);
 
             for (auto f : { "/hist_crash.json", "/crash.json" }) {
                 TString testJson = NResource::Find(f);
@@ -1254,13 +1254,13 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
                 {
                   "mode": "deriv",
                   "value": -1,
-                  "labels": { "metric": "SystemTime" } 
+                  "labels": { "metric": "SystemTime" }
                 },
             }
             ]}")";
 
         NProto::TMultiSamplesList samples;
-        IMetricEncoderPtr e = EncoderProtobuf(&samples); 
+        IMetricEncoderPtr e = EncoderProtobuf(&samples);
         UNIT_ASSERT_EXCEPTION(DecodeJson(input, e.Get()), yexception);
     }
 
@@ -1287,4 +1287,4 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
         }
     }
 
-} 
+}