Add private attributes builders to event processor config

Author: cwaldren-ld

libs/common/include/config/detail/defaults.hpp

@@ -28,11 +28,8 @@ struct Defaults<ClientSDK> {
     }
     static Events events() {
         return {
-            100,
-            std::chrono::seconds(30),
-            "/mobile",
-            AttributePolicy::Default,
-            TransportSecurity::TLS,
+            100,   std::chrono::seconds(30),      "/mobile",
+            false, AttributeReference::SetType(), TransportSecurity::TLS,
         };
     }
 };
@@ -45,11 +42,8 @@ struct Defaults<ServerSDK> {
     }
     static Events events() {
         return {
-            10000,
-            std::chrono::seconds(5),
-            "/bulk",
-            AttributePolicy::Default,
-            TransportSecurity::TLS,
+            10000, std::chrono::seconds(5),       "/bulk",
+            false, AttributeReference::SetType(), TransportSecurity::TLS,
         };
     }
 };

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

@@ -3,13 +3,10 @@
 #include <chrono>
 #include <cstddef>
 #include <string>
+#include <unordered_map>
+#include "attribute_reference.hpp"
 namespace launchdarkly::config::detail {
 
-enum class AttributePolicy {
-    Default = 0,
-    AllPrivate = 1,
-};
-
 enum class TransportSecurity {
     None = 0,
     TLS = 1,
@@ -22,19 +19,23 @@ struct Events {
     Events(std::size_t capacity,
            std::chrono::milliseconds flush_interval,
            std::string path,
-           AttributePolicy policy,
+           bool all_attributes_private,
+           AttributeReference::SetType private_attrs,
            TransportSecurity security);
     std::size_t capacity() const;
     std::chrono::milliseconds flush_interval() const;
     std::string const& path() const;
-    AttributePolicy attribute_policy() const;
+    bool all_attributes_private() const;
+    AttributeReference::SetType const& private_attributes() const;
     TransportSecurity transport_security() const;
 
    private:
     std::size_t capacity_;
     std::chrono::milliseconds flush_interval_;
     std::string path_;
-    AttributePolicy attribute_policy_;
+    bool all_attributes_private_;
+    AttributeReference::SetType private_attributes_;
+
     TransportSecurity transport_security_;
 };
 

libs/common/include/config/detail/events_builder.hpp

@@ -1,13 +1,14 @@
 #pragma once
 
+#include <tl/expected.hpp>
+#include "attribute_reference.hpp"
 #include "config/detail/events.hpp"
 #include "error.hpp"
 
-#include <tl/expected.hpp>
-
 #include <memory>
 #include <optional>
 #include <string>
+#include <unordered_map>
 
 namespace launchdarkly::config::detail {
 
@@ -51,6 +52,39 @@ class EventsBuilder {
      */
     EventsBuilder& flush_interval(std::chrono::milliseconds interval);
 
+    /**
+     * Attribute privacy indicates whether or not attributes should be
+     * retained by LaunchDarkly after being sent upon initialization,
+     * and if attributes should later be sent in events.
+     *
+     * Attribute privacy may be specified in 3 ways:
+     *
+     * (1) To specify that all attributes should be considered private - not
+     * just those designated private on a per-context basis - call this method
+     * with true as the parameter.
+     *
+     * (2) To specify that a specific set of attributes should be considered
+     * private
+     * - in addition to those designated private on a per-context basis -
+     * call @ref private_attributes.
+     *
+     * (3) To specify private attributes on a per-context basis, it is not
+     * necessary to call either of these methods, as the default behavior is to
+     * treat all attributes as non-private unless otherwise specified.
+     *
+     * @param value True for behavior of (1), false for default behavior of (2)
+     * or (3).
+     * @return Reference to this builder.
+     */
+    EventsBuilder& all_attributes_private(bool);
+
+    /**
+     * Specify an AttributePolicy for individual attributes.
+     * @return
+     */
+    EventsBuilder& private_attributes(
+        AttributeReference::SetType private_attrs);
+
     /**
      * Builds Events configuration, if the configuration is valid. If not,
      * returns an error.

libs/common/src/config/events.cpp

@@ -5,12 +5,14 @@ namespace launchdarkly::config::detail {
 Events::Events(std::size_t capacity,
                std::chrono::milliseconds flush_interval,
                std::string path,
-               AttributePolicy policy,
+               bool all_attributes_private,
+               AttributeReference::SetType private_attrs,
                TransportSecurity transport_security)
     : capacity_(capacity),
       flush_interval_(flush_interval),
       path_(std::move(path)),
-      attribute_policy_(policy),
+      all_attributes_private_(all_attributes_private),
+      private_attributes_(std::move(private_attrs)),
       transport_security_(transport_security) {}
 
 std::size_t Events::capacity() const {
@@ -22,8 +24,13 @@ std::chrono::milliseconds Events::flush_interval() const {
 std::string const& Events::path() const {
     return path_;
 }
-AttributePolicy Events::attribute_policy() const {
-    return attribute_policy_;
+
+bool Events::all_attributes_private() const {
+    return all_attributes_private_;
+}
+
+AttributeReference::SetType const& Events::private_attributes() const {
+    return private_attributes_;
 }
 
 TransportSecurity Events::transport_security() const {
@@ -34,6 +41,7 @@ bool operator==(Events const& lhs, Events const& rhs) {
     return lhs.path() == rhs.path() &&
            lhs.flush_interval() == rhs.flush_interval() &&
            lhs.capacity() == rhs.capacity() &&
-           lhs.attribute_policy() == rhs.attribute_policy();
+           lhs.all_attributes_private() == rhs.all_attributes_private() &&
+           lhs.private_attributes() == rhs.private_attributes();
 }
 }  // namespace launchdarkly::config::detail

libs/common/src/config/events_builder.cpp

@@ -20,6 +20,19 @@ EventsBuilder<SDK>& EventsBuilder<SDK>::flush_interval(
     return *this;
 }
 
+template <typename SDK>
+EventsBuilder<SDK>& EventsBuilder<SDK>::all_attributes_private(bool value) {
+    config_.all_attributes_private_ = value;
+    return *this;
+}
+
+template <typename SDK>
+EventsBuilder<SDK>& EventsBuilder<SDK>::private_attributes(
+    AttributeReference::SetType attributes) {
+    config_.private_attributes_ = std::move(attributes);
+    return *this;
+}
+
 template <typename SDK>
 tl::expected<Events, Error> EventsBuilder<SDK>::build() {
     if (config_.capacity() == 0) {

libs/common/src/events/dispatcher.cpp

@@ -112,7 +112,8 @@ std::optional<Dispatcher::RequestType> Dispatcher::make_request() {
     req.prepare_payload();
     return req;
 }
-// helper type for the visitor #4
+
+// These helpers are for the std::visit within Dispatcher::process.
 template <class... Ts>
 struct overloaded : Ts... {
     using Ts::operator()...;

libs/common/tests/event_processor_test.cpp

@@ -16,7 +16,7 @@ TEST_F(EventProcessorTests, thing) {
 
     auto config = client::EventsBuilder()
                       .capacity(10)
-                      .flush_interval(std::chrono::seconds(1))
+                      .flush_interval(std::chrono::seconds(3))
                       .build();
 
     auto endpoints = client::HostsBuilder().build();
@@ -37,7 +37,9 @@ TEST_F(EventProcessorTests, thing) {
     ev.data = Value({"foo", "bar", "baz"});
     ev.metric_value = 30;
 
-    ep.async_send(ev);
+    for (std::size_t i = 0; i < 10; i++) {
+        ep.async_send(ev);
+    }
 
     std::this_thread::sleep_for(std::chrono::seconds(2));