Fix serialization of identify event

Author: cwaldren-ld

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

@@ -14,6 +14,8 @@
 #include "events/detail/summary_state.hpp"
 #include "events/events.hpp"
 #include "logger.hpp"
+#include "context_filter.hpp"
+
 
 namespace launchdarkly::events::detail {
 
@@ -28,7 +30,7 @@ class Dispatcher {
     void request_flush();
 
     void send(InputEvent);
-    
+
     void shutdown();
 
    private:
@@ -57,6 +59,8 @@ class Dispatcher {
 
     bool full_outbox_encountered_;
 
+    launchdarkly::ContextFilter filter_;
+
     Logger& logger_;
 
     void handle_send(InputEvent e);

libs/common/include/events/events.hpp

@@ -19,7 +19,7 @@ using Value = launchdarkly::Value;
 using VariationIndex = size_t;
 using Reason = EvaluationReason;
 using Context = launchdarkly::Context;
-using Json = boost::json::value;
+using EventContext = boost::json::value;
 using Version = std::uint64_t;
 using ContextKeys = std::map<std::string, std::string>;
 
@@ -53,7 +53,12 @@ struct IdentifyEvent {
     Context context;
 };
 
-struct IndexEvent : public IdentifyEvent {};
+struct OutIdentifyEvent {
+    Date creation_date;
+    EventContext context;
+};
+
+struct IndexEvent : public OutIdentifyEvent {};
 
 struct CustomEvent {
     Date creation_date;
@@ -86,7 +91,10 @@ struct VariationKey {
 
 using InputEvent = std::variant<FeatureEvent, IdentifyEvent, CustomEvent>;
 
-using OutputEvent = std::
-    variant<IndexEvent, DebugEvent, FeatureEvent, IdentifyEvent, CustomEvent>;
+using OutputEvent = std::variant<IndexEvent,
+                                 DebugEvent,
+                                 FeatureEvent,
+                                 OutIdentifyEvent,
+                                 CustomEvent>;
 
 }  // namespace launchdarkly::events

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

@@ -24,7 +24,7 @@ void tag_invoke(boost::json::value_from_tag const&,
 
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
-                IdentifyEvent const& event);
+                OutIdentifyEvent const& event);
 
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,

libs/common/src/events/dispatcher.cpp

@@ -30,6 +30,7 @@ Dispatcher::Dispatcher(boost::asio::any_io_executor io,
       authorization_(std::move(authorization)),
       uuids_(),
       full_outbox_encountered_(false),
+      filter_(config.all_attributes_private(), config.private_attributes()),
       logger_(logger) {
     schedule_flush();
 }
@@ -126,7 +127,13 @@ std::vector<OutputEvent> Dispatcher::process(InputEvent event) {
     std::vector<OutputEvent> out;
     std::visit(
         overloaded{[&](FeatureEvent&& e) { out.emplace_back(std::move(e)); },
-                   [&](IdentifyEvent&& e) { out.emplace_back(std::move(e)); },
+                   [&](IdentifyEvent&& e) {
+                       // Contexts should already have been checked for validity
+                       // by this point.
+                       assert(e.context.valid());
+                       out.emplace_back(OutIdentifyEvent{
+                           e.creation_date, filter_.filter(e.context)});
+                   },
                    [&](CustomEvent&& e) { out.emplace_back(std::move(e)); }},
         std::move(event));
 

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

@@ -54,11 +54,11 @@ void tag_invoke(boost::json::value_from_tag const&,
 
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
-                IdentifyEvent const& event) {
+                OutIdentifyEvent const& event) {
     auto& obj = json_value.emplace_object();
     obj.emplace("kind", "identify");
     obj.emplace("creationDate", boost::json::value_from(event.creation_date));
-    obj.emplace("context", boost::json::value_from(event.context));
+    obj.emplace("context", event.context);
 }
 
 void tag_invoke(boost::json::value_from_tag const&,

libs/common/tests/event_processor_test.cpp

@@ -31,23 +31,18 @@ TEST_F(EventProcessorTests, thing) {
     std::this_thread::sleep_for(std::chrono::seconds(2));
 
     auto c = launchdarkly::ContextBuilder().kind("org", "ld").build();
-    auto ev = events::CustomEvent{
+    ASSERT_TRUE(c.valid());
+    auto ev = events::IdentifyEvent{
         std::chrono::system_clock::now(),
+        c,
     };
-    ev.data = Value({"foo", "bar", "baz"});
-    ev.metric_value = 30;
 
-    for (std::size_t i = 0; i < 10; i++) {
+    for (std::size_t i = 0; i < 3; i++) {
         ep.async_send(ev);
     }
 
     std::this_thread::sleep_for(std::chrono::seconds(2));
 
-    ev.data = Value("qux");
-    ev.metric_value = 42;
-
-    ep.async_send(ev);
-
     ep.async_close();
     t.join();
 }

libs/common/tests/event_serialization_test.cpp

@@ -5,7 +5,9 @@
 #include "context_builder.hpp"
 #include "events/events.hpp"
 
+#include "context_filter.hpp"
 #include "serialization/events/json_events.hpp"
+#include "value.hpp"
 
 namespace launchdarkly::events {
 
@@ -50,14 +52,22 @@ TEST(EventSerialization, DebugEvent) {
 
 TEST(EventSerialization, IdentifyEvent) {
     auto creation_date = std::chrono::system_clock::from_time_t({});
-    auto e = events::IdentifyEvent{creation_date,
-                                   ContextBuilder().kind("foo", "bar").build()};
+    auto attrs = AttributeReference::SetType({"/redact_me"});
+    ContextFilter filter(false, attrs);
+
+    auto e = events::OutIdentifyEvent{creation_date,
+                                      filter.filter(ContextBuilder()
+                                                        .kind("foo", "org")
+                                                        .set("bar", "baz")
+                                                        .set("redact_me", 3)
+                                                        .build())};
 
     auto event = boost::json::value_from(e);
 
     auto result = boost::json::parse(
         "{\"kind\":\"identify\",\"creationDate\":0,\"context\":{\"key\":"
-        "\"bar\",\"kind\":\"foo\"}}");
+        "\"org\",\"kind\":\"foo\",\"bar\":\"baz\",\"_meta\":{"
+        "\"redactedAttributes\":[\"/redact_me\"]}}}");
 
     ASSERT_EQ(result, event);
 }