Adding summarizer unit tests

Author: cwaldren-ld

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

@@ -12,7 +12,7 @@
 #include "context_filter.hpp"
 #include "events/detail/conn_pool.hpp"
 #include "events/detail/outbox.hpp"
-#include "events/detail/summary_state.hpp"
+#include "events/detail/summarizer.hpp"
 #include "events/event_processor.hpp"
 #include "events/events.hpp"
 #include "logger.hpp"

libs/common/include/events/detail/summary_state.hpp renamed to libs/common/include/events/detail/summarizer.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <boost/container_hash/hash.hpp>
 #include <chrono>
 #include <functional>
 #include <unordered_map>
@@ -10,9 +11,17 @@ namespace launchdarkly::events::detail {
 
 class Summarizer {
    public:
-    Summarizer(std::chrono::system_clock::time_point start);
+    using Date = std::chrono::system_clock::time_point;
+    using FlagKey = std::string;
+
+    explicit Summarizer(Date start);
+    Summarizer();
     void update(client::FeatureEventParams const& event);
 
+    bool empty() const;
+
+    Date start_time() const;
+
     struct VariationSummary {
         std::size_t count;
         Value value;
@@ -21,7 +30,6 @@ class Summarizer {
     };
 
     struct VariationKey {
-        VariationKey(VariationKey const& key);
         std::optional<Version> version;
         std::optional<VariationIndex> variation;
         VariationKey(Version version, std::optional<VariationIndex> variation);
@@ -34,8 +42,10 @@ class Summarizer {
 
         struct Hash {
             auto operator()(VariationKey const& p) const -> size_t {
-                return std::hash<decltype(p.version)>{}(p.version) ^
-                       std::hash<decltype(p.variation)>{}(p.variation);
+                std::size_t seed = 0;
+                boost::hash_combine(seed, p.version);
+                boost::hash_combine(seed, p.variation);
+                return seed;
             }
         };
     };
@@ -51,10 +61,16 @@ class Summarizer {
         State(Value defaultVal);
     };
 
-    using FlagKey = std::string;
-    std::chrono::system_clock::time_point start_time_;
-    std::chrono::system_clock::time_point end_time_;
+    std::unordered_map<FlagKey, State> const& features() const;
+
+   private:
+    Date start_time_;
     std::unordered_map<FlagKey, State> features_;
 };
 
+struct Summary {
+    Summarizer const& summarizer;
+    Summarizer::Date end_time;
+};
+
 }  // namespace launchdarkly::events::detail

libs/common/include/serialization/events/json_events.hpp

@@ -2,7 +2,7 @@
 
 #include <boost/json.hpp>
 
-#include "events/detail/summary_state.hpp"
+#include "events/detail/summarizer.hpp"
 #include "events/events.hpp"
 
 namespace launchdarkly::events::client {
@@ -48,5 +48,5 @@ void tag_invoke(boost::json::value_from_tag const&,
                 Summarizer::State const& state);
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
-                Summarizer const& summarizer);
+                Summary const& summarizer);
 }  // namespace launchdarkly::events::detail

libs/common/src/CMakeLists.txt

@@ -41,11 +41,11 @@ add_library(${LIBNAME}
         events/asio_event_processor.cpp
         events/outbox.cpp
         events/conn_pool.cpp
-        events/summary_state.cpp
+        events/summarizer.cpp
         config/http_properties.cpp
         config/data_source_builder.cpp
         config/http_properties_builder.cpp)
-
+        
 
 add_library(launchdarkly::common ALIAS ${LIBNAME})
 

libs/common/src/events/asio_event_processor.cpp

@@ -75,7 +75,6 @@ void AsioEventProcessor::AsyncSend(InputEvent input_event) {
 }
 
 void AsioEventProcessor::HandleSend(InputEvent e) {
-
     std::vector<OutputEvent> output_events = Process(std::move(e));
 
     bool inserted = outbox_.PushDiscardingOverflow(std::move(output_events));
@@ -94,6 +93,7 @@ void AsioEventProcessor::Flush(FlushTrigger flush_type) {
         LD_LOG(logger_, LogLevel::kDebug)
             << "event-processor: nothing to flush";
     }
+    summary_state_ = Summarizer(std::chrono::system_clock::now());
     if (flush_type == FlushTrigger::Automatic) {
         ScheduleFlush();
     }
@@ -132,6 +132,12 @@ AsioEventProcessor::MakeRequest() {
         return std::nullopt;
     }
 
+    boost::json::value summary_event;
+    if (!summary_state_.empty()) {
+        summary_event = boost::json::value_from(
+            Summary{summary_state_, std::chrono::system_clock::now()});
+    }
+
     LD_LOG(logger_, LogLevel::kDebug)
         << "event-processor: generating http request";
     RequestType req;
@@ -144,8 +150,12 @@ AsioEventProcessor::MakeRequest() {
     req.set(kPayloadIdHeader, boost::lexical_cast<std::string>(uuids_()));
     req.target(host_ + path_);
 
-    req.body() =
-        boost::json::serialize(boost::json::value_from(outbox_.Consume()));
+    auto events = boost::json::value_from(outbox_.Consume());
+    if (!summary_event.is_null()) {
+        events.as_array().push_back(summary_event);
+    }
+
+    req.body() = boost::json::serialize(events);
     req.prepare_payload();
     return req;
 }
@@ -164,7 +174,6 @@ std::vector<OutputEvent> AsioEventProcessor::Process(InputEvent event) {
     std::visit(
         overloaded{
             [&](client::FeatureEventParams&& e) {
-
                 summary_state_.update(e);
 
                 if (!e.eval_result.track_events()) {

libs/common/src/events/summary_state.cpp renamed to libs/common/src/events/summarizer.cpp

@@ -1,15 +1,19 @@
-#include "events/detail/summary_state.hpp"
+#include "events/detail/summarizer.hpp"
 
 namespace launchdarkly::events::detail {
 
 Summarizer::Summarizer(std::chrono::system_clock::time_point start)
     : start_time_(start), features_() {}
 
-static std::unordered_set<std::string> CopyKinds(
-    std::vector<std::string_view> const& kinds) {
-    std::unordered_set<std::string> kind_set;
-    kind_set.insert(kinds.begin(), kinds.end());
-    return kind_set;
+Summarizer::Summarizer() : start_time_(), features_() {}
+
+bool Summarizer::empty() const {
+    return features_.empty();
+}
+
+std::unordered_map<Summarizer::FlagKey, Summarizer::State> const&
+Summarizer::features() const {
+    return features_;
 }
 
 static bool FlagNotFound(client::FeatureEventParams const& event) {
@@ -33,14 +37,16 @@ void Summarizer::update(client::FeatureEventParams const& event) {
     feature_state_iterator->second.context_kinds_.insert(kinds.begin(),
                                                          kinds.end());
 
-    decltype(std::begin(feature_state_iterator->second.counters_)) summary_counter;
+    decltype(std::begin(
+        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.default_)
-                      .first;
+        summary_counter =
+            feature_state_iterator->second.counters_
+                .try_emplace(std::move(key),
+                             feature_state_iterator->second.default_)
+                .first;
 
     } else {
         auto key = VariationKey(event.eval_result.version(),
@@ -53,15 +59,16 @@ void Summarizer::update(client::FeatureEventParams const& event) {
 
     summary_counter->second.Increment();
 }
+Summarizer::Date Summarizer::start_time() const {
+    return start_time_;
+}
 Summarizer::VariationKey::VariationKey(Version version,
                                        std::optional<VariationIndex> variation)
     : version(version), variation(variation) {}
 
 Summarizer::VariationKey::VariationKey()
     : version(std::nullopt), variation(std::nullopt) {}
 
-Summarizer::VariationKey::VariationKey(Summarizer::VariationKey const& key) {}
-
 Summarizer::VariationSummary::VariationSummary(Value value)
     : count(0), value(std::move(value)) {}
 

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

@@ -100,12 +100,12 @@ void tag_invoke(boost::json::value_from_tag const&,
 }
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
-                Summarizer const& summarizer) {
+                Summary const& s) {
     auto& obj = json_value.emplace_object();
     obj.emplace("kind", "summary");
     obj.emplace("startDate",
-                boost::json::value_from(Date{summarizer.start_time_}));
-    obj.emplace("endDate", boost::json::value_from(Date{summarizer.end_time_}));
-    obj.emplace("features", boost::json::value_from(summarizer.features_));
+                boost::json::value_from(Date{s.summarizer.start_time()}));
+    obj.emplace("endDate", boost::json::value_from(Date{s.end_time}));
+    obj.emplace("features", boost::json::value_from(s.summarizer.features()));
 }
 }  // namespace launchdarkly::events::detail

libs/common/tests/event_processor_test.cpp

@@ -5,14 +5,79 @@
 #include "config/client.hpp"
 #include "console_backend.hpp"
 #include "context_builder.hpp"
+#include "events/client_events.hpp"
 #include "events/detail/asio_event_processor.hpp"
+#include "events/detail/summarizer.hpp"
 
-using namespace launchdarkly;
-class EventProcessorTests : public ::testing::Test {};
+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{};
+}
+
+TEST(SummarizerTests, IsEmptyOnConstruction) {
+    Summarizer summarizer;
+    ASSERT_TRUE(summarizer.empty());
+}
+
+TEST(SummarizerTests, DefaultConstructionUsesZeroStartTime) {
+    Summarizer summarizer;
+    ASSERT_EQ(summarizer.start_time(), ZeroTime());
+}
+
+TEST(SummarizerTests, ExplicitStartTimeIsCorrect) {
+    auto start = std::chrono::system_clock::now();
+    Summarizer summarizer(start);
+    ASSERT_EQ(summarizer.start_time(), start);
+}
+
+TEST(SummarizerTests, SummaryCounterUpdates) {
+    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_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))),
+    };
+
+    auto const num_events = 10;
+    for (size_t i = 0; i < num_events; i++) {
+        summarizer.update(event);
+    }
+
+    auto const& features = summarizer.features();
+    auto const& cat_food = features.find(feature_key);
+    ASSERT_TRUE(cat_food != features.end());
+
+    auto const& counter = cat_food->second.counters_.find(
+        Summarizer::VariationKey(feature_version, feature_variation));
+    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);
+}
 
 // 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_F(EventProcessorTests, ProcessorCompiles) {
+TEST(EventProcessorTests, ProcessorCompiles) {
+    using namespace launchdarkly;
+
     Logger logger{std::make_unique<ConsoleBackend>(LogLevel::kDebug, "test")};
     boost::asio::io_context io;