fix summary counter JSON serialization

Author: cwaldren-ld

libs/common/include/events/client_events.hpp

@@ -19,6 +19,7 @@ struct FeatureEventParams {
     std::string key;
     Context context;
     EvaluationResult eval_result;
+    Value default_;
 };
 
 struct FeatureEventBase {

libs/common/include/events/detail/summarizer.hpp

@@ -52,11 +52,11 @@ class Summarizer {
 
     struct State {
         Value default_;
-        std::unordered_set<std::string> context_kinds_;
+        std::unordered_set<std::string> context_kinds;
         std::unordered_map<Summarizer::VariationKey,
                            Summarizer::VariationSummary,
                            Summarizer::VariationKey::Hash>
-            counters_;
+            counters;
 
         State(Value defaultVal);
     };

libs/common/src/events/summarizer.cpp

@@ -30,30 +30,28 @@ void Summarizer::update(client::FeatureEventParams const& event) {
     // TODO(cwaldren): Value::null() should be replaced with the default value
     // from the evaluation.
 
-    auto default_value = Value::null();
     auto feature_state_iterator =
-        features_.try_emplace(event.key, std::move(default_value)).first;
+        features_.try_emplace(event.key, event.default_).first;
 
-    feature_state_iterator->second.context_kinds_.insert(kinds.begin(),
-                                                         kinds.end());
+    feature_state_iterator->second.context_kinds.insert(kinds.begin(),
+                                                        kinds.end());
 
     decltype(std::begin(
-        feature_state_iterator->second.counters_)) summary_counter;
+        feature_state_iterator->second.counters)) summary_counter;
 
     if (FlagNotFound(event)) {
-        auto key = VariationKey();
         summary_counter =
-            feature_state_iterator->second.counters_
-                .try_emplace(std::move(key),
+            feature_state_iterator->second.counters
+                .try_emplace(VariationKey(),
                              feature_state_iterator->second.default_)
                 .first;
 
     } else {
         auto key = VariationKey(event.eval_result.version(),
                                 event.eval_result.detail().variation_index());
         summary_counter =
-            feature_state_iterator->second.counters_
-                .try_emplace(std::move(key), event.eval_result.detail().value())
+            feature_state_iterator->second.counters
+                .try_emplace(key, event.eval_result.detail().value())
                 .first;
     }
 
@@ -78,5 +76,5 @@ void Summarizer::VariationSummary::Increment() {
 }
 
 Summarizer::State::State(Value defaultVal)
-    : default_(std::move(defaultVal)), context_kinds_() {}
+    : default_(std::move(defaultVal)), context_kinds() {}
 }  // namespace launchdarkly::events::detail

libs/common/src/serialization/events/json_events.cpp

@@ -91,12 +91,44 @@ void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
                 Summarizer::VariationSummary const& state) {}
 
+/*
+ * version (number, optional): the value of version for the counter; if version
+has no value, this property should be omitted entirely rather than writing a
+null value.
+
+variation (number, optional): the value of variation for the counter; if
+variation has no value, this property should be omitted entirely rather than
+writing a null value.
+
+value (any JSON type): the value of value for the counter.
+
+count (number, required): the value of count for the counter.
+
+unknown (boolean, optional): this should be true if version has no value;
+otherwise it should be omitted (do not write an explicit false).
+ */
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
                 Summarizer::State const& state) {
     auto& obj = json_value.emplace_object();
     obj.emplace("default", boost::json::value_from(state.default_));
-    obj.emplace("contextKinds", boost::json::value_from(state.context_kinds_));
+    obj.emplace("contextKinds", boost::json::value_from(state.context_kinds));
+    boost::json::array counters;
+    for (auto const& kvp : state.counters) {
+        boost::json::object counter;
+        if (kvp.first.version) {
+            counter.emplace("version", *kvp.first.version);
+        } else {
+            counter.emplace("unknown", true);
+        }
+        if (kvp.first.variation) {
+            counter.emplace("variation", *kvp.first.variation);
+        }
+        counter.emplace("value", boost::json::value_from(kvp.second.value));
+        counter.emplace("count", kvp.second.count);
+        counters.push_back(std::move(counter));
+    }
+    obj.emplace("counters", std::move(counters));
 }
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,

libs/common/tests/event_processor_test.cpp

@@ -8,9 +8,9 @@
 #include "events/client_events.hpp"
 #include "events/detail/asio_event_processor.hpp"
 #include "events/detail/summarizer.hpp"
+#include "serialization/events/json_events.hpp"
 
 using namespace launchdarkly::events::detail;
-// class EventProcessorTests : public ::testing::Test {};
 
 static std::chrono::system_clock::time_point ZeroTime() {
     return std::chrono::system_clock::time_point{};
@@ -41,6 +41,7 @@ TEST(SummarizerTests, SummaryCounterUpdates) {
     auto const feature_version = 1;
     auto const context = ContextBuilder().kind("cat", "shadow").build();
     auto const feature_value = Value(3);
+    auto const feature_default = Value(1);
     auto const feature_variation = 0;
 
     auto const event = FeatureEventParams{
@@ -54,6 +55,7 @@ TEST(SummarizerTests, SummaryCounterUpdates) {
                 EvaluationReason("FALLTHROUGH", std::nullopt, std::nullopt,
                                  std::nullopt, std::nullopt, false,
                                  std::nullopt))),
+        feature_default,
     };
 
     auto const num_events = 10;
@@ -65,14 +67,51 @@ TEST(SummarizerTests, SummaryCounterUpdates) {
     auto const& cat_food = features.find(feature_key);
     ASSERT_TRUE(cat_food != features.end());
 
-    auto const& counter = cat_food->second.counters_.find(
+    auto const& counter = cat_food->second.counters.find(
         Summarizer::VariationKey(feature_version, feature_variation));
-    ASSERT_TRUE(counter != cat_food->second.counters_.end());
+    ASSERT_TRUE(counter != cat_food->second.counters.end());
 
     ASSERT_EQ(counter->second.value.as_double(), feature_value.as_double());
     ASSERT_EQ(counter->second.count, num_events);
 }
 
+TEST(SummarizerTests, JsonSerialization) {
+    using namespace launchdarkly::events::client;
+    using namespace launchdarkly;
+    Summarizer summarizer;
+
+    auto const feature_key = "cat-food-amount";
+    auto const feature_version = 1;
+    auto const context = ContextBuilder().kind("cat", "shadow").build();
+    auto const feature_value = Value(3);
+    auto const feature_default = Value(1);
+    auto const feature_variation = 0;
+
+    auto const event = FeatureEventParams{
+        ZeroTime(),
+        feature_key,
+        context,
+        EvaluationResult(
+            feature_version, std::nullopt, false, false, std::nullopt,
+            EvaluationDetailInternal(
+                feature_value, feature_variation,
+                EvaluationReason("FALLTHROUGH", std::nullopt, std::nullopt,
+                                 std::nullopt, std::nullopt, false,
+                                 std::nullopt))),
+        feature_default,
+    };
+
+    auto const num_events = 10;
+    for (size_t i = 0; i < num_events; i++) {
+        summarizer.update(event);
+    }
+
+    auto json = boost::json::value_from(Summary{summarizer, ZeroTime()});
+    auto expected = boost::json::parse(
+        R"({"kind":"summary","startDate":0,"endDate":0,"features":{"cat-food-amount":{"default":1E0,"contextKinds":["cat"],"counters":[{"version":1,"variation":0,"value":3E0,"count":10}]}}})");
+    ASSERT_EQ(json, expected);
+}
+
 // This test is a temporary test that exists only to ensure the event processor
 // compiles; it should be replaced by more robust tests (and contract tests.)
 TEST(EventProcessorTests, ProcessorCompiles) {