update metrics library after reviews

* use slimmer handle subclasses
* new tick abstraction
* gc unused time supplier
* rename current bucket concept to current samples
* rename TimeStamp type
* add padding making old metrics visible
* improve test, now with less debug printing.

1 files changed, 107 insertions, 37 deletions

diff --git a/staging_vespalib/src/tests/metrics/simple_metrics_test.cpp b/staging_vespalib/src/tests/metrics/simple_metrics_test.cpp
index d0a7ca4c4a9..6af03177ed8 100644
--- a/staging_vespalib/src/tests/metrics/simple_metrics_test.cpp
+++ b/staging_vespalib/src/tests/metrics/simple_metrics_test.cpp
@@ -1,9 +1,12 @@
 // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 #include <vespa/vespalib/testkit/testapp.h>
+#include <vespa/vespalib/data/slime/slime.h>
+#include <vespa/vespalib/data/slime/json_format.h>
 #include <vespa/vespalib/metrics/simple_metrics.h>
 #include <vespa/vespalib/metrics/simple_metrics_manager.h>
 #include <vespa/vespalib/metrics/stable_store.h>
 #include <vespa/vespalib/metrics/json_formatter.h>
+#include <vespa/vespalib/metrics/mock_tick.h>
 #include <stdio.h>
 #include <unistd.h>
 
@@ -67,13 +70,60 @@ TEST("require that simple metrics gauge merge works")
     EXPECT_EQUAL(a.lastValue, 1.0);
 }
 
+bool compare_json(const vespalib::string &a, const vespalib::string &b)
+{
+    using vespalib::Memory;
+    using vespalib::slime::JsonFormat;
+
+    Slime slimeA, slimeB;
+    if (! JsonFormat::decode(a, slimeA)) {
+fprintf(stderr, "bad json a:\n>>>%s\n<<<\n", a.c_str());
+        return false;
+    }
+    if (! JsonFormat::decode(b, slimeB)) {
+fprintf(stderr, "bad json b\n");
+        return false;
+    }
+    return slimeA == slimeB;
+}
+
+void check_json(const vespalib::string &actual)
+{
+    vespalib::string expect = "{"
+    "   \"snapshot\": { \"from\": 1, \"to\": 4 },"
+    "   \"values\": [ { \"name\": \"foo\","
+    "       \"values\": { \"count\": 17, \"rate\": 4.85714 }"
+    "   }, {"
+    "       \"name\": \"foo\","
+    "       \"dimensions\": { \"chain\": \"default\", \"documenttype\": \"music\", \"thread\": \"0\" },"
+    "       \"values\": { \"count\": 4, \"rate\": 1.14286 }"
+    "   }, {"
+    "       \"name\": \"bar\","
+    "       \"values\": { \"count\": 4, \"rate\": 1.14286, \"average\": 42, \"min\": 41, \"max\": 43, \"last\": 42 }"
+    "   }, {"
+    "       \"name\": \"bar\","
+    "       \"dimensions\": { \"chain\": \"vespa\", \"documenttype\": \"blogpost\", \"thread\": \"1\" },"
+    "       \"values\": { \"count\": 1, \"rate\": 0.285714, \"average\": 14, \"min\": 14, \"max\": 14, \"last\": 14 }"
+    "   }, {"
+    "       \"name\": \"bar\","
+    "       \"dimensions\": { \"chain\": \"vespa\", \"documenttype\": \"blogpost\", \"thread\": \"2\" },"
+    "       \"values\": { \"count\": 1, \"rate\": 0.285714, \"average\": 11, \"min\": 11, \"max\": 11, \"last\": 11 }"
+    "   } ]"
+    "}";
+    EXPECT_TRUE(compare_json(expect, actual));
+}
+
 
 TEST("use simple_metrics_collector")
 {
     using namespace vespalib::metrics;
     SimpleManagerConfig cf;
     cf.sliding_window_seconds = 5;
-    auto manager = SimpleMetricsManager::create(cf);
+    std::shared_ptr<MockTick> ticker = std::make_shared<MockTick>();
+    ticker->provide(TimeStamp(1.0));
+    auto manager = SimpleMetricsManager::createForTest(cf, std::make_unique<TickProxy>(ticker));
+    EXPECT_EQUAL(1.0, ticker->waitUntilBlocked().count());
+
     Counter myCounter = manager->counter("foo");
     myCounter.add();
     myCounter.add(16);
@@ -84,6 +134,25 @@ TEST("use simple_metrics_collector")
     myGauge.sample(43.0);
     myGauge.sample(42.0);
 
+    EXPECT_EQUAL(1.0, ticker->waitUntilBlocked().count());
+    ticker->provide(TimeStamp(2.0));
+    EXPECT_EQUAL(2.0, ticker->waitUntilBlocked().count());
+
+    Snapshot snap1 = manager->snapshot();
+    EXPECT_EQUAL(1.0, snap1.startTime());
+    EXPECT_EQUAL(2.0, snap1.endTime());
+
+    EXPECT_EQUAL(1u, snap1.counters().size());
+    EXPECT_EQUAL("foo", snap1.counters()[0].name());
+    EXPECT_EQUAL(17u, snap1.counters()[0].count());
+
+    EXPECT_EQUAL(1u, snap1.gauges().size());
+    EXPECT_EQUAL("bar", snap1.gauges()[0].name());
+    EXPECT_EQUAL(4u, snap1.gauges()[0].observedCount());
+    EXPECT_EQUAL(41.0, snap1.gauges()[0].minValue());
+    EXPECT_EQUAL(43.0, snap1.gauges()[0].maxValue());
+    EXPECT_EQUAL(42.0, snap1.gauges()[0].lastValue());
+
     Point one = manager->pointBuilder()
             .bind("chain", "default")
             .bind("documenttype", "music")
@@ -109,44 +178,45 @@ TEST("use simple_metrics_collector")
     myGauge.sample(14.0, two);
     myGauge.sample(11.0, three);
 
-    for (int i = 0; i < 61; ++i) {
-        ((SimpleMetricsManager &)*manager).tick();
-    }
+    EXPECT_EQUAL(2.0, ticker->waitUntilBlocked().count());
+    ticker->provide(TimeStamp(4.5));
+    EXPECT_EQUAL(4.5, ticker->waitUntilBlocked().count());
 
-    Snapshot snap = manager->totalSnapshot();
-    fprintf(stdout, "snap begin: %15f\n", snap.startTime());
-    fprintf(stdout, "snap end: %15f\n", snap.endTime());
-
- // for (const auto& entry : snap.points()) {
- //     fprintf(stdout, "snap point: %zd dimension(s)\n", entry.dimensions.size());
- //     for (const auto& dim : entry.dimensions) {
- //         fprintf(stdout, "       label: [%s] = '%s'\n",
- //                 dim.dimensionName().c_str(), dim.labelValue().c_str());
- //     }
- // }
-    for (const auto& entry : snap.counters()) {
-        fprintf(stdout, "snap counter: '%s'\n", entry.name().c_str());
-        for (const auto& dim : entry.point().dimensions) {
-            fprintf(stdout, "       label: [%s] = '%s'\n",
-                    dim.dimensionName().c_str(), dim.labelValue().c_str());
-        }
-        fprintf(stdout, "       count: %zd\n", entry.count());
-    }
-    for (const auto& entry : snap.gauges()) {
-        fprintf(stdout, "snap gauge: '%s'\n", entry.name().c_str());
-        for (const auto& dim : entry.point().dimensions) {
-            fprintf(stdout, "       label: [%s] = '%s'\n",
-                    dim.dimensionName().c_str(), dim.labelValue().c_str());
-        }
-        fprintf(stdout, "  observed: %zd\n", entry.observedCount());
-        fprintf(stdout, "       avg: %f\n", entry.averageValue());
-        fprintf(stdout, "       min: %f\n", entry.minValue());
-        fprintf(stdout, "       max: %f\n", entry.maxValue());
-        fprintf(stdout, "      last: %f\n", entry.lastValue());
-    }
+    Snapshot snap2 = manager->snapshot();
+    EXPECT_EQUAL(1.0, snap2.startTime());
+    EXPECT_EQUAL(4.5, snap2.endTime());
+    EXPECT_EQUAL(2u, snap2.counters().size());
+    EXPECT_EQUAL(3u, snap2.gauges().size());
 
-    JsonFormatter fmt(snap);
-    fprintf(stdout, "JSON format:\n>>>\n%s\n<<<\n", fmt.asString().c_str());
+    JsonFormatter fmt2(snap2);
+    check_json(fmt2.asString());
+
+    // flush sliding window
+    for (int i = 5; i <= 10; ++i) {
+        ticker->provide(TimeStamp(i));
+        ticker->waitUntilBlocked();
+    }
+    Snapshot snap3 = manager->snapshot();
+    EXPECT_EQUAL(5.0, snap3.startTime());
+    EXPECT_EQUAL(10.0, snap3.endTime());
+    EXPECT_EQUAL(2u, snap3.counters().size());
+    EXPECT_EQUAL(0u, snap3.counters()[0].count());
+    EXPECT_EQUAL(0u, snap3.counters()[1].count());
+    EXPECT_EQUAL(3u, snap3.gauges().size());
+    EXPECT_EQUAL(0u, snap3.gauges()[0].observedCount());
+    EXPECT_EQUAL(0u, snap3.gauges()[1].observedCount());
+    EXPECT_EQUAL(0u, snap3.gauges()[2].observedCount());
+
+    Snapshot snap4 = manager->totalSnapshot();
+    EXPECT_EQUAL(1.0,    snap4.startTime());
+    EXPECT_EQUAL(10.0,   snap4.endTime());
+    EXPECT_EQUAL(2u,     snap4.counters().size());
+    EXPECT_NOT_EQUAL(0u, snap4.counters()[0].count());
+    EXPECT_NOT_EQUAL(0u, snap4.counters()[1].count());
+    EXPECT_EQUAL(3u,     snap4.gauges().size());
+    EXPECT_NOT_EQUAL(0u, snap4.gauges()[0].observedCount());
+    EXPECT_NOT_EQUAL(0u, snap4.gauges()[1].observedCount());
+    EXPECT_NOT_EQUAL(0u, snap4.gauges()[2].observedCount());
 }
 
 TEST_MAIN() { TEST_RUN_ALL(); }