feat: server-side payload filters

contract-tests/data-model/include/data_model/data_model.hpp

@@ -3,10 +3,9 @@
 #include <optional>
 #include <string>
 #include <unordered_map>
 #include "nlohmann/json.hpp"
 
 namespace nlohmann {
-
 template <typename T>
 struct adl_serializer<std::optional<T>> {
     static void to_json(json& j, std::optional<T> const& opt) {
@@ -41,20 +40,26 @@
 struct ConfigStreamingParams {
     std::optional<std::string> baseUri;
     std::optional<uint32_t> initialRetryDelayMs;
+    std::optional<std::string> filter;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigStreamingParams,
                                                 baseUri,
-                                                initialRetryDelayMs);
+                                                initialRetryDelayMs,
+                                                filter);
 
 struct ConfigPollingParams {
     std::optional<std::string> baseUri;
     std::optional<uint32_t> pollIntervalMs;
+    std::optional<std::string> filter;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigPollingParams,
                                                 baseUri,
-                                                pollIntervalMs);
+                                                pollIntervalMs,
+                                                filter);
 
 struct ConfigEventParams {
     std::optional<std::string> baseUri;
     std::optional<uint32_t> capacity;
     std::optional<bool> enableDiagnostics;
@@ -62,28 +67,32 @@
     std::vector<std::string> globalPrivateAttributes;
     std::optional<int> flushIntervalMs;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigEventParams,
                                                 baseUri,
                                                 capacity,
                                                 enableDiagnostics,
                                                 allAttributesPrivate,
                                                 globalPrivateAttributes,
                                                 flushIntervalMs);
+
 struct ConfigServiceEndpointsParams {
     std::optional<std::string> streaming;
     std::optional<std::string> polling;
     std::optional<std::string> events;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigServiceEndpointsParams,
                                                 streaming,
                                                 polling,
                                                 events);
 
 struct ConfigClientSideParams {
     nlohmann::json initialContext;
     std::optional<bool> evaluationReasons;
     std::optional<bool> useReport;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigClientSideParams,
                                                 initialContext,
                                                 evaluationReasons,
@@ -93,6 +102,7 @@
     std::optional<std::string> applicationId;
     std::optional<std::string> applicationVersion;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigTags,
                                                 applicationId,
                                                 applicationVersion);
@@ -109,6 +119,7 @@
     std::optional<ConfigTags> tags;
     std::optional<ConfigTLSParams> tls;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ConfigParams,
                                                 credential,
                                                 startWaitTimeMs,
@@ -121,7 +132,7 @@
                                                 tags,
                                                 tls);
 
 struct ContextSingleParams {
     std::optional<std::string> kind;
     std::string key;
     std::optional<std::string> name;
@@ -141,6 +152,7 @@
     nlohmann_json_j["private"] = nlohmann_json_t._private;
     nlohmann_json_j["custom"] = nlohmann_json_t.custom;
 }
+
 inline void from_json(nlohmann::json const& nlohmann_json_j,
                       ContextSingleParams& nlohmann_json_t) {
     ContextSingleParams nlohmann_json_default_obj;
@@ -184,11 +196,13 @@
     ConfigParams configuration;
     std::string tag;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(CreateInstanceParams,
                                                 configuration,
                                                 tag);
 
 enum class ValueType { Bool = 1, Int, Double, String, Any, Unspecified };
+
 NLOHMANN_JSON_SERIALIZE_ENUM(ValueType,
                              {{ValueType::Bool, "bool"},
                               {ValueType::Int, "int"},
@@ -205,6 +219,7 @@
     bool detail;
     EvaluateFlagParams();
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(EvaluateFlagParams,
                                                 flagKey,
                                                 context,
@@ -212,30 +227,34 @@
                                                 defaultValue,
                                                 detail);
 
 struct EvaluateFlagResponse {
     nlohmann::json value;
     std::optional<uint32_t> variationIndex;
     std::optional<nlohmann::json> reason;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(EvaluateFlagResponse,
                                                 value,
                                                 variationIndex,
                                                 reason);
 
 struct EvaluateAllFlagParams {
     std::optional<nlohmann::json> context;
     std::optional<bool> withReasons;
     std::optional<bool> clientSideOnly;
     std::optional<bool> detailsOnlyForTrackedFlags;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(EvaluateAllFlagParams,
                                                 context,
                                                 withReasons,
                                                 clientSideOnly,
                                                 detailsOnlyForTrackedFlags);
+
 struct EvaluateAllFlagsResponse {
     nlohmann::json state;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(EvaluateAllFlagsResponse,
                                                 state);
 
@@ -246,6 +265,7 @@
     std::optional<bool> omitNullData;
     std::optional<double> metricValue;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(CustomEventParams,
                                                 eventKey,
                                                 context,
@@ -253,9 +273,10 @@
                                                 omitNullData,
                                                 metricValue);
 
 struct IdentifyEventParams {
     nlohmann::json context;
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(IdentifyEventParams, context);
 
 enum class Command {
@@ -268,6 +289,7 @@
     ContextBuild,
     ContextConvert
 };
+
 NLOHMANN_JSON_SERIALIZE_ENUM(Command,
                              {{Command::Unknown, nullptr},
                               {Command::EvaluateFlag, "evaluate"},
@@ -288,6 +310,7 @@
     std::optional<ContextConvertParams> contextConvert;
     CommandParams();
 };
+
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(CommandParams,
                                                 command,
                                                 evaluate,

contract-tests/server-contract-tests/src/entity_manager.cpp

@@ -1,4 +1,4 @@
 #include "entity_manager.hpp"
 
 #include <launchdarkly/context_builder.hpp>
 #include <launchdarkly/serialization/json_context.hpp>
@@ -52,12 +52,15 @@
         if (in.streaming->baseUri) {
             endpoints.StreamingBaseUrl(*in.streaming->baseUri);
         }
+        auto streaming = decltype(datasystem)::Streaming();
         if (in.streaming->initialRetryDelayMs) {
-            auto streaming = decltype(datasystem)::Streaming();
             streaming.InitialReconnectDelay(
                 std::chrono::milliseconds(*in.streaming->initialRetryDelayMs));
-            datasystem.Synchronizer(std::move(streaming));
         }
+        if (in.streaming->filter) {
+            streaming.Filter(*in.streaming->filter);
+        }
+        datasystem.Synchronizer(std::move(streaming));
     }
 
     if (in.polling) {
@@ -72,6 +75,9 @@
                         std::chrono::milliseconds(
                             *in.polling->pollIntervalMs)));
             }
+            if (in.polling->filter) {
+                method.Filter(*in.polling->filter);
+            }
             datasystem.Synchronizer(std::move(method));
         }
     }

contract-tests/server-contract-tests/src/main.cpp

@@ -1,4 +1,4 @@
 #include "server.hpp"
 
 #include <launchdarkly/logging/console_backend.hpp>
 
@@ -18,7 +18,7 @@
 using launchdarkly::LogLevel;
 
 int main(int argc, char* argv[]) {
     launchdarkly::Logger logger{
         std::make_unique<ConsoleBackend>("server-contract-tests")};
 
     std::string const default_port = "8123";
@@ -31,8 +31,8 @@
     try {
         net::io_context ioc{1};
 
-        auto p = boost::lexical_cast<unsigned short>(port);
-        server srv(ioc, "0.0.0.0", p, logger);
+        auto const p = boost::lexical_cast<unsigned short>(port);
+        server srv{ioc, "0.0.0.0", p, logger};
 
         srv.add_capability("server-side");
         srv.add_capability("strongly-typed");
@@ -45,7 +45,8 @@
         srv.add_capability("tls:verify-peer");
         srv.add_capability("tls:skip-verify-peer");
         srv.add_capability("tls:custom-ca");
-
+        srv.add_capability("filtering");
+        srv.add_capability("filtering-strict");
         net::signal_set signals{ioc, SIGINT, SIGTERM};
 
         boost::asio::spawn(ioc.get_executor(), [&](auto yield) mutable {

libs/common/include/launchdarkly/config/shared/builders/data_source_builder.hpp

@@ -4,22 +4,24 @@
 #include <launchdarkly/config/shared/defaults.hpp>
 #include <launchdarkly/config/shared/sdks.hpp>
 
-#include <launchdarkly/error.hpp>
-
-#include <tl/expected.hpp>
-
 #include <chrono>
+#include <type_traits>
 #include <variant>
 
 namespace launchdarkly::config::shared::builders {
-
 /**
  * Used to construct a DataSourceConfiguration for the specified SDK type.
  * @tparam SDK ClientSDK or ServerSDK.
  */
 template <typename SDK>
 class DataSourceBuilder;
 
+template <typename T>
+struct is_server_sdk : std::false_type {};
+
+template <>
+struct is_server_sdk<ServerSDK> : std::true_type {};
+
 /**
  * Builds a configuration for a streaming data source.
  */
@@ -43,6 +45,30 @@ class StreamingBuilder {
     StreamingBuilder& InitialReconnectDelay(
         std::chrono::milliseconds initial_reconnect_delay);
 
+    /**
+     * Sets the filter key for the streaming connection.
+     *
+     * By default, the SDK is able to evaluate all flags in an environment.
+     *
+     * If this is undesirable - for example, because the environment contains
+     * thousands of flags, but this application only needs to evaluate
+     * a smaller, known subset - then a filter may be setup in LaunchDarkly,
+     * and the filter's key specified here.
+     *
+     * Evaluations for flags that aren't part of the filtered environment will
+     * return default values.
+     * @param filter_key The filter key. If the key is malformed or nonexistent,
+     * then a full LaunchDarkly environment will be fetched. In the case of a
+     * malformed key, the SDK will additionally log a runtime error.
+     * @return Reference to this builder.
+     */
+    template <typename T = SDK>
+    std::enable_if_t<is_server_sdk<T>::value, StreamingBuilder&> Filter(
+        std::string filter_key) {
+        config_.filter_key = std::move(filter_key);
+        return *this;
+    }
+
     /**
      * Build the streaming config. Used internal to the SDK.
      * @return The built config.
@@ -68,6 +94,31 @@ class PollingBuilder {
      */
     PollingBuilder& PollInterval(std::chrono::seconds poll_interval);
 
+    /**
+     * Sets the filter key for the polling connection.
+     *
+     * By default, the SDK is able to evaluate all flags in an environment.
+     *
+     * If this is undesirable - for example, because the environment contains
+     * thousands of flags, but this application only needs to evaluate
+     * a smaller, known subset - then a filter may be setup in LaunchDarkly,
+     * and the filter's key specified here.
+     *
+     * Evaluations for flags that aren't part of the filtered environment will
+     * return default values.
+     *
+     * @param filter_key The filter key. If the key is malformed or nonexistent,
+     * then a full LaunchDarkly environment will be fetched. In the case of a
+     * malformed key, the SDK will additionally log a runtime error.
+     * @return Reference to this builder.
+     */
+    template <typename T = SDK>
+    std::enable_if_t<is_server_sdk<T>::value, PollingBuilder&> Filter(
+        std::string filter_key) {
+        config_.filter_key = std::move(filter_key);
+        return *this;
+    }
+
     /**
      * Build the polling config. Used internal to the SDK.
      * @return The built config.
@@ -100,7 +151,7 @@ class DataSourceBuilder<ClientSDK> {
     DataSourceBuilder& WithReasons(bool value);
 
     /**
-     * Whether or not to use the REPORT verb to fetch flag settings.
+     * Whether to use the REPORT verb to fetch flag settings.
      *
      * If this is true, flag settings will be fetched with a REPORT request
      * including a JSON entity body with the context object.

libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp

@@ -22,12 +22,14 @@ template <>
 struct StreamingConfig<ServerSDK> {
     std::chrono::milliseconds initial_reconnect_delay;
     std::string streaming_path;
+    std::optional<std::string> filter_key;
 };
 
 inline bool operator==(StreamingConfig<ServerSDK> const& lhs,
                        StreamingConfig<ServerSDK> const& rhs) {
     return lhs.initial_reconnect_delay == rhs.initial_reconnect_delay &&
-           lhs.streaming_path == rhs.streaming_path;
+           lhs.streaming_path == rhs.streaming_path &&
+           lhs.filter_key == rhs.filter_key;
 }
 
 template <typename SDK>
@@ -46,6 +48,7 @@ struct PollingConfig<ServerSDK> {
     std::chrono::seconds poll_interval;
     std::string polling_get_path;
     std::chrono::seconds min_polling_interval;
+    std::optional<std::string> filter_key;
 };
 
 template <typename SDK>