refactor event classes into common and client namespaces

Author: cwaldren-ld

libs/common/include/data/evaluation_result.hpp

@@ -35,7 +35,7 @@ class EvaluationResult {
 
     /**
      * A timestamp, which if the current time is before, a client SDK
-     * should send debug events for the flag.
+     * should AsyncSend debug events for the flag.
      * @return
      */
     [[nodiscard]] std::optional<

libs/common/include/events/client_events.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "events/common_events.hpp"
+
+namespace launchdarkly::events::client {
+
+struct IdentifyEventParams {
+    Date creation_date;
+    Context context;
+};
+
+struct IdentifyEvent {
+    Date creation_date;
+    EventContext context;
+};
+
+struct FeatureEventParams {
+    Date creation_date;
+    std::string key;
+    Context context;
+    EvaluationResult eval_result;
+};
+
+struct FeatureEventBase {
+    Date creation_date;
+    std::string key;
+    Version version;
+    std::optional<VariationIndex> variation;
+    Value value;
+    std::optional<Reason> reason;
+    Value default_;
+};
+
+struct FeatureEvent {
+    FeatureEventBase base;
+    ContextKeys context_keys;
+};
+
+struct DebugEvent {
+    FeatureEventBase base;
+    EventContext context;
+};
+
+}  // namespace launchdarkly::events::client

libs/common/include/events/common_events.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <chrono>
+#include <cstdint>
+#include <variant>
+
+#include <boost/json/value.hpp>
+#include "context.hpp"
+#include "data/evaluation_reason.hpp"
+#include "data/evaluation_result.hpp"
+
+namespace launchdarkly::events {
+
+using Value = launchdarkly::Value;
+using VariationIndex = size_t;
+using Reason = EvaluationReason;
+using Result = EvaluationResult;
+using Context = launchdarkly::Context;
+using EventContext = boost::json::value;
+using Version = std::uint64_t;
+using ContextKeys = std::map<std::string, std::string>;
+
+struct Date {
+    std::chrono::system_clock::time_point t;
+};
+
+struct VariationSummary {
+    std::size_t count;
+    Value value;
+};
+
+struct VariationKey {
+    Version version;
+    std::optional<VariationIndex> variation;
+
+    struct Hash {
+        auto operator()(VariationKey const& p) const -> size_t {
+            if (p.variation) {
+                return std::hash<Version>{}(p.version) ^
+                       std::hash<VariationIndex>{}(*p.variation);
+            } else {
+                return std::hash<Version>{}(p.version);
+            }
+        }
+    };
+};
+
+struct TrackEventParams {
+    Date creation_date;
+    std::string key;
+    ContextKeys context_keys;
+    std::optional<Value> data;
+    std::optional<double> metric_value;
+};
+
+// Track (custom) events are directly serialized from their parameters.
+using TrackEvent = TrackEventParams;
+
+}  // namespace launchdarkly::events

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

@@ -20,9 +20,9 @@ class AsioEventProcessor : public IEventProcessor {
                        config::ServiceHosts const& endpoints,
                        Logger& logger);
 
-    void async_send(InputEvent event) override;
-    void async_flush() override;
-    void async_close() override;
+    void AsyncSend(InputEvent event) override;
+    void AsyncFlush() override;
+    void AsyncClose() override;
 
    private:
     Logger& logger_;

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

@@ -9,13 +9,12 @@
 #include <optional>
 #include "config/detail/events.hpp"
 #include "config/detail/service_hosts.hpp"
+#include "context_filter.hpp"
 #include "events/detail/conn_pool.hpp"
 #include "events/detail/outbox.hpp"
 #include "events/detail/summary_state.hpp"
 #include "events/events.hpp"
 #include "logger.hpp"
-#include "context_filter.hpp"
-
 
 namespace launchdarkly::events::detail {
 
@@ -27,11 +26,11 @@ class Dispatcher {
                std::string authorization,
                Logger& logger);
 
-    void request_flush();
+    void AsyncFlush();
 
-    void send(InputEvent);
+    void AsyncSend(InputEvent);
 
-    void shutdown();
+    void AsyncClose();
 
    private:
     enum class FlushTrigger {
@@ -63,15 +62,15 @@ class Dispatcher {
 
     Logger& logger_;
 
-    void handle_send(InputEvent e);
+    void HandleSend(InputEvent e);
 
-    std::optional<RequestType> make_request();
+    std::optional<RequestType> MakeRequest();
 
-    void flush(FlushTrigger flush_type);
+    void Flush(FlushTrigger flush_type);
 
-    void schedule_flush();
+    void ScheduleFlush();
 
-    std::vector<OutputEvent> process(InputEvent e);
+    std::vector<OutputEvent> Process(InputEvent e);
 };
 
 }  // namespace launchdarkly::events::detail

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

@@ -7,8 +7,8 @@ namespace launchdarkly::events::detail {
 class NullEventProcessor : public IEventProcessor {
    public:
     NullEventProcessor() = default;
-    void async_send(InputEvent event) override;
-    void async_flush() override;
-    void async_close() override;
+    void AsyncSend(InputEvent event) override;
+    void AsyncFlush() override;
+    void AsyncClose() override;
 };
 }  // namespace launchdarkly::events::detail

libs/common/include/events/event_processor.hpp

@@ -12,18 +12,18 @@ class IEventProcessor {
      * soon as possible. The event may be dropped if the inbox lacks capacity.
      * @param event InputEvent to deliver.
      */
-    virtual void async_send(InputEvent event) = 0;
+    virtual void AsyncSend(InputEvent event) = 0;
     /**
      * Asynchronously on_flush the processor's outbox, returning as soon as
      * possible. Flushing may be a no-op if a on_flush is already in progress.
      */
-    virtual void async_flush() = 0;
+    virtual void AsyncFlush() = 0;
     /**
      * Synchronously close the processor. The processor should attempt to
      * on_flush all events in the outbox before shutting down. All asynchronous
      * operations MUST be completed before sync_close returns.
      */
-    virtual void async_close() = 0;
+    virtual void AsyncClose() = 0;
 };
 
 }  // namespace launchdarkly::events

libs/common/include/events/events.hpp

@@ -1,100 +1,18 @@
 #pragma once
 
-#include <boost/json/value.hpp>
-#include <map>
-#include <unordered_map>
-#include <unordered_set>
-#include <variant>
-#include "attribute_reference.hpp"
-#include "context.hpp"
-#include "data/evaluation_reason.hpp"
-#include "value.hpp"
-
-#include <cstdint>
+#include "events/client_events.hpp"
+// #include "events/server_events.hpp"
+// Server-side events would be added to the Input/Output event variants.
 
 namespace launchdarkly::events {
 
-// TODO: Replace with actual types when available.
-using Value = launchdarkly::Value;
-using VariationIndex = size_t;
-using Reason = EvaluationReason;
-using Context = launchdarkly::Context;
-using EventContext = boost::json::value;
-using Version = std::uint64_t;
-using ContextKeys = std::map<std::string, std::string>;
-
-struct Date {
-    std::chrono::system_clock::time_point t;
-};
-
-struct FeatureEventFields {
-    std::string key;
-    Date creation_date;
-    Value value;
-    std::optional<VariationIndex> variation;
-    Value default_;
-    std::optional<Reason> reason;
-    Version version;
-    std::optional<std::string> prereq_of;
-};
-
-struct FeatureEvent {
-    FeatureEventFields base;
-    ContextKeys context_keys;
-};
-
-struct DebugEvent {
-    FeatureEventFields base;
-    Context context;
-};
-
-struct IdentifyEvent {
-    Date creation_date;
-    Context context;
-};
-
-struct OutIdentifyEvent {
-    Date creation_date;
-    EventContext context;
-};
-
-struct IndexEvent : public OutIdentifyEvent {};
-
-struct CustomEvent {
-    Date creation_date;
-    std::string key;
-    ContextKeys context_keys;
-    std::optional<Value> data;
-    std::optional<double> metric_value;
-};
-
-struct VariationSummary {
-    std::size_t count;
-    Value value;
-};
-
-struct VariationKey {
-    Version version;
-    std::optional<VariationIndex> variation;
-
-    struct Hash {
-        auto operator()(VariationKey const& p) const -> size_t {
-            if (p.variation) {
-                return std::hash<Version>{}(p.version) ^
-                       std::hash<VariationIndex>{}(*p.variation);
-            } else {
-                return std::hash<Version>{}(p.version);
-            }
-        }
-    };
-};
-
-using InputEvent = std::variant<FeatureEvent, IdentifyEvent, CustomEvent>;
+using InputEvent = std::variant<client::FeatureEventParams,
+                                client::IdentifyEventParams,
+                                TrackEventParams>;
 
-using OutputEvent = std::variant<IndexEvent,
-                                 DebugEvent,
-                                 FeatureEvent,
-                                 OutIdentifyEvent,
-                                 CustomEvent>;
+using OutputEvent = std::variant<client::FeatureEvent,
+                                 client::DebugEvent,
+                                 client::IdentifyEvent,
+                                 TrackEvent>;
 
 }  // namespace launchdarkly::events

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

@@ -4,35 +4,33 @@
 
 #include "events/events.hpp"
 
-namespace launchdarkly::events {
-
+namespace launchdarkly::events::client {
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
-                Date const& date);
+                FeatureEvent const& event);
 
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
-                IndexEvent const& date);
+                FeatureEventBase const& event);
 
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
-                FeatureEvent const& event);
+                IdentifyEvent const& event);
 
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
-                FeatureEventFields const& event);
+                DebugEvent const& event);
+}  // namespace launchdarkly::events::client
 
-void tag_invoke(boost::json::value_from_tag const&,
-                boost::json::value& json_value,
-                OutIdentifyEvent const& event);
+namespace launchdarkly::events {
 
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
-                DebugEvent const& event);
+                Date const& date);
 
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,
-                CustomEvent const& event);
+                TrackEvent const& event);
 
 void tag_invoke(boost::json::value_from_tag const&,
                 boost::json::value& json_value,

libs/common/src/attribute_reference.cpp

@@ -112,8 +112,8 @@ bool ParseRef(std::string str, std::vector<std::string>& components) {
     auto p_state = ParseState::kBegin;
 
     std::string tmp_token;
-    // The loop here extends to the size of the string, so we can send a null
-    // into the parsing logic to terminate the parsing.
+    // The loop here extends to the size of the string, so we can AsyncSend a
+    // null into the parsing logic to terminate the parsing.
     for (auto index = 0; index <= str.size(); index++) {
         // The character in the string, or null if we go out of bounds of the
         // string.