From 4cf2916dc53f77561259b04316aeef4dc0dab0c9 Mon Sep 17 00:00:00 2001 From: Bee Klimt Date: Wed, 2 Sep 2026 04:11:50 +0000 Subject: [PATCH 1/9] feat: Expose FDv2 through the client SDK configuration --- libs/client-sdk/src/client_impl.cpp | 78 ++++++- libs/client-sdk/tests/fdv2_client_test.cpp | 112 ++++++++++ .../tests/fdv2_config_builder_test.cpp | 211 ++++++++++++++++++ .../include/launchdarkly/config/client.hpp | 4 + .../shared/builders/data_source_builder.hpp | 16 +- .../shared/builders/endpoints_builder.hpp | 16 +- .../config/shared/builders/fdv2_builder.hpp | 178 +++++++++++++++ .../shared/built/data_source_config.hpp | 9 +- libs/common/src/CMakeLists.txt | 1 + libs/common/src/config/config_builder.cpp | 16 ++ .../common/src/config/data_source_builder.cpp | 13 +- libs/common/src/config/endpoints_builder.cpp | 6 + libs/common/src/config/fdv2_builder.cpp | 114 ++++++++++ 13 files changed, 760 insertions(+), 14 deletions(-) create mode 100644 libs/client-sdk/tests/fdv2_client_test.cpp create mode 100644 libs/client-sdk/tests/fdv2_config_builder_test.cpp create mode 100644 libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp create mode 100644 libs/common/src/config/fdv2_builder.cpp diff --git a/libs/client-sdk/src/client_impl.cpp b/libs/client-sdk/src/client_impl.cpp index 84ea433e9..1ce9c2b9b 100644 --- a/libs/client-sdk/src/client_impl.cpp +++ b/libs/client-sdk/src/client_impl.cpp @@ -1,4 +1,6 @@ #include "client_impl.hpp" +#include "data_sources/fdv2/fdv2_data_source.hpp" +#include "data_sources/fdv2/mode_sources.hpp" #include "data_sources/null_data_source.hpp" #include "data_sources/polling_data_source.hpp" #include "data_sources/streaming_data_source.hpp" @@ -31,12 +33,58 @@ using launchdarkly::client_side::data_sources::DataSourceStatus; using launchdarkly::config::shared::built::DataSourceConfig; using launchdarkly::config::shared::built::HttpProperties; +using FDv2Config = config::shared::built::FDv2Config; + +static bool UsesFDv2(Config const& config) { + return std::holds_alternative(config.DataSourceConfig().method); +} + +static std::shared_ptr MakeFDv2DataSource( + HttpProperties const& http_properties, + Config const& config, + Context const& context, + boost::asio::any_io_executor const& executor, + flag_manager::FlagManager& flag_manager, + data_sources::DataSourceStatusManager& status_manager, + Logger& logger) { + auto const& fdv2 = std::get(config.DataSourceConfig().method); + auto const& endpoints = config.ServiceEndpoints(); + + if (config.DataSourceConfig().use_report) { + LD_LOG(logger, LogLevel::kWarn) + << "UseReport is not applicable to FDv2 and will be ignored"; + } + + data_sources::ModeSourceParams const params{ + executor, + logger, + fdv2.polling_base_url, + fdv2.streaming_base_url, + http_properties, + endpoints, + context, + config.DataSourceConfig().with_reasons, + &flag_manager.Cache()}; + + auto sources = + data_sources::BuildModeSources(fdv2, fdv2.initial_mode, params); + + return std::make_shared( + std::move(sources.initializers), std::move(sources.synchronizers), + std::make_unique( + executor, fdv2.fallback_timeout), + std::make_unique( + executor, fdv2.recovery_timeout), + executor, context, &flag_manager.Updater(), &flag_manager.Store(), + &status_manager, logger); +} + static std::shared_ptr MakeDataSource( HttpProperties const& http_properties, Config const& config, Context const& context, boost::asio::any_io_executor const& executor, - IDataSourceUpdateSink& flag_updater, + flag_manager::FlagManager& flag_manager, data_sources::DataSourceStatusManager& status_manager, Logger& logger) { if (config.Offline()) { @@ -48,18 +96,26 @@ static std::shared_ptr MakeDataSource( auto data_source_properties = builder.Build(); - if (config.DataSourceConfig().method.index() == 0) { + if (UsesFDv2(config)) { + return MakeFDv2DataSource(data_source_properties, config, context, + executor, flag_manager, status_manager, + logger); + } + + if (std::holds_alternative< + config::shared::built::StreamingConfig>( + config.DataSourceConfig().method)) { return std::make_shared< launchdarkly::client_side::data_sources::StreamingDataSource>( config.ServiceEndpoints(), config.DataSourceConfig(), - data_source_properties, executor, context, flag_updater, + data_source_properties, executor, context, flag_manager.Updater(), status_manager, logger); } return std::make_shared< launchdarkly::client_side::data_sources::PollingDataSource>( config.ServiceEndpoints(), config.DataSourceConfig(), - data_source_properties, executor, context, flag_updater, status_manager, - logger); + data_source_properties, executor, context, flag_manager.Updater(), + status_manager, logger); } static Logger MakeLogger(config::shared::built::Logging const& config) { @@ -101,13 +157,17 @@ ClientImpl::ClientImpl(Config in_cfg, MakePersistence(config_)), data_source_factory_([this]() { return MakeDataSource(http_properties_, config_, context_, - ioc_.get_executor(), flag_manager_.Updater(), + ioc_.get_executor(), flag_manager_, status_manager_, logger_); }), data_source_(nullptr), event_processor_(nullptr), eval_reasons_available_(config_.DataSourceConfig().with_reasons) { - flag_manager_.LoadCache(context_); + // Under FDv2 the cache is loaded by an initializer, so that it enters the + // store through the same path as every other source. + if (!UsesFDv2(config_)) { + flag_manager_.LoadCache(context_); + } if (auto custom_ca = http_properties_.Tls().CustomCAFile()) { LD_LOG(logger_, LogLevel::kInfo) @@ -160,7 +220,9 @@ static bool IsInitializedSuccessfully(DataSourceStatus::DataSourceState state) { std::future ClientImpl::IdentifyAsync(Context context) { UpdateContextSynchronized(context); - flag_manager_.LoadCache(context); + if (!UsesFDv2(config_)) { + flag_manager_.LoadCache(context); + } event_processor_->SendAsync(events::IdentifyEventParams{ std::chrono::system_clock::now(), std::move(context)}); diff --git a/libs/client-sdk/tests/fdv2_client_test.cpp b/libs/client-sdk/tests/fdv2_client_test.cpp new file mode 100644 index 000000000..e14b48336 --- /dev/null +++ b/libs/client-sdk/tests/fdv2_client_test.cpp @@ -0,0 +1,112 @@ +#include + +#include +#include + +#include +#include +#include +#include +#include +#include + +using namespace launchdarkly; +using namespace launchdarkly::client_side; +using namespace std::chrono_literals; + +namespace { + +class TestPersistence : public IPersistence { + public: + using StoreType = + std::map>>; + + explicit TestPersistence(StoreType store) : store_(std::move(store)) {} + + void Set(std::string storageNamespace, + std::string key, + std::string data) noexcept override { + std::lock_guard lock{mutex_}; + store_[storageNamespace][key] = data; + } + + void Remove(std::string storageNamespace, + std::string key) noexcept override { + std::lock_guard lock{mutex_}; + store_[storageNamespace].erase(key); + } + + std::optional Read(std::string storageNamespace, + std::string key) noexcept override { + std::lock_guard lock{mutex_}; + auto const ns = store_.find(storageNamespace); + if (ns == store_.end()) { + return std::nullopt; + } + auto const entry = ns->second.find(key); + if (entry == ns->second.end()) { + return std::nullopt; + } + return entry->second; + } + + private: + // The SDK reads from its own thread while the test writes from the main + // one. + std::mutex mutex_; + StoreType store_; +}; + +// Offline mode makes no requests, so the whole FDv2 path can be exercised +// without a service to talk to. +Config OfflineFDv2Config(std::shared_ptr persistence) { + auto builder = ConfigBuilder("the-key"); + builder.DataSource().Method( + DataSourceBuilder::FDv2().InitialMode(ConnectionMode::kOffline)); + builder.Events().Disable(); + if (persistence) { + builder.Persistence().Custom(std::move(persistence)); + } else { + builder.Persistence().None(); + } + return builder.Build().value(); +} + +// The namespace and context id the client derives for SDK key "the-key" and +// context user:user-key. +char const* const kEnvironment = + "LaunchDarkly_rUTcjlHPv6Vegd27YmtGYkEGkEUGaEbn5M0JYTFQUpA="; +char const* const kContextId = "CEXjZY7cHJG_ydFy7q4-YEFwVrG3_pkJwA4FAjrbfx0="; + +} // namespace + +// The cache is the only source offline mode has, so a miss still starts the +// SDK with no flags, evaluating to defaults. +TEST(FDv2ClientTest, OfflineModeStartsWithNoCachedData) { + Client client(OfflineFDv2Config(nullptr), + ContextBuilder().Kind("user", "user-key").Build()); + + auto started = client.StartAsync(); + + ASSERT_EQ(std::future_status::ready, started.wait_for(5s)); + EXPECT_TRUE(started.get()); + EXPECT_TRUE(client.Initialized()); + EXPECT_TRUE(client.AllFlags().empty()); +} + +TEST(FDv2ClientTest, OfflineModeEvaluatesAgainstTheCache) { + auto persistence = + std::make_shared(TestPersistence::StoreType{ + {kEnvironment, + {{kContextId, R"({"treat":{"version":1,"value":"fish"}})"}}}}); + + Client client(OfflineFDv2Config(persistence), + ContextBuilder().Kind("user", "user-key").Build()); + + auto started = client.StartAsync(); + + ASSERT_EQ(std::future_status::ready, started.wait_for(5s)); + EXPECT_TRUE(started.get()); + EXPECT_EQ("fish", client.StringVariation("treat", "chicken")); +} diff --git a/libs/client-sdk/tests/fdv2_config_builder_test.cpp b/libs/client-sdk/tests/fdv2_config_builder_test.cpp new file mode 100644 index 000000000..dcf8e49ad --- /dev/null +++ b/libs/client-sdk/tests/fdv2_config_builder_test.cpp @@ -0,0 +1,211 @@ +#include + +#include + +#include +#include + +using launchdarkly::client_side::ConfigBuilder; +using launchdarkly::client_side::ConnectionMode; +using launchdarkly::client_side::DataSourceBuilder; +using launchdarkly::client_side::Defaults; +using launchdarkly::client_side::FDv2Builder; +using launchdarkly::config::shared::ClientSDK; + +using FDv2Config = launchdarkly::config::shared::built::FDv2Config; +using PollingConfig = + launchdarkly::config::shared::built::PollingConfig; +using StreamingConfig = + launchdarkly::config::shared::built::StreamingConfig; + +using namespace std::chrono_literals; + +namespace { + +FDv2Config BuildFDv2(FDv2Builder fdv2) { + auto config = + ConfigBuilder("sdk-key").DataSource().Method(std::move(fdv2)).Build(); + return std::get(config.method); +} + +} // namespace + +// The streaming and polling methods speak FDv1. FDv2 replaces them. +TEST(FDv2ConfigBuilderTest, TheDefaultDataSourceIsStillFDv1Streaming) { + auto config = ConfigBuilder("sdk-key").Build(); + + ASSERT_TRUE(config.has_value()); + EXPECT_TRUE(std::holds_alternative( + config->DataSourceConfig().method)); +} + +TEST(FDv2ConfigBuilderTest, SelectingFDv2ReplacesTheFDv1Method) { + auto builder = ConfigBuilder("sdk-key"); + builder.DataSource().Method(DataSourceBuilder::FDv2()); + + auto config = builder.Build(); + + ASSERT_TRUE(config.has_value()); + EXPECT_TRUE( + std::holds_alternative(config->DataSourceConfig().method)); +} + +// What those defaults are is pinned down where they are defined. This is +// about the builder starting from them. +TEST(FDv2ConfigBuilderTest, AnUncustomizedBuilderYieldsTheSDKDefaults) { + auto const config = BuildFDv2(FDv2Builder()); + auto const defaults = Defaults::FDv2Config(); + + EXPECT_EQ(defaults.initial_mode, config.initial_mode); + EXPECT_EQ(defaults.modes.size(), config.modes.size()); + EXPECT_EQ(defaults.fallback_timeout, config.fallback_timeout); + EXPECT_EQ(defaults.recovery_timeout, config.recovery_timeout); +} + +TEST(FDv2ConfigBuilderTest, DefaultsSendTheContextInTheRequestPath) { + auto const config = BuildFDv2(FDv2Builder()); + + EXPECT_FALSE(config.use_post); +} + +TEST(FDv2ConfigBuilderTest, InitialModeIsSelectable) { + auto const config = + BuildFDv2(FDv2Builder().InitialMode(ConnectionMode::kPolling)); + + EXPECT_EQ(ConnectionMode::kPolling, config.initial_mode); +} + +TEST(FDv2ConfigBuilderTest, UsePostIsSettable) { + auto const config = BuildFDv2(FDv2Builder().UsePost(true)); + + EXPECT_TRUE(config.use_post); +} + +TEST(FDv2ConfigBuilderTest, CustomizingAModeReplacesItsPipeline) { + FDv2Builder builder; + builder.CustomizeMode( + ConnectionMode::kStreaming, + FDv2Builder::Mode() + .Initializer(FDv2Builder::Cache()) + .Synchronizer(FDv2Builder::Streaming().InitialReconnectDelay(2s)) + .DisableFDv1Fallback()); + + auto const config = BuildFDv2(std::move(builder)); + auto const& mode = config.modes.at(ConnectionMode::kStreaming); + + ASSERT_EQ(1u, mode.initializers.size()); + EXPECT_TRUE( + std::holds_alternative(mode.initializers[0])); + ASSERT_EQ(1u, mode.synchronizers.size()); + auto const* streaming = + std::get_if(&mode.synchronizers[0]); + ASSERT_NE(nullptr, streaming); + EXPECT_EQ(2s, streaming->initial_reconnect_delay); + EXPECT_FALSE(mode.fdv1_fallback.has_value()); +} + +TEST(FDv2ConfigBuilderTest, CustomizingOneModeLeavesTheOthersAlone) { + FDv2Builder builder; + builder.CustomizeMode(ConnectionMode::kPolling, + FDv2Builder::Mode().Synchronizer( + FDv2Builder::Polling().PollInterval(60s))); + + auto const config = BuildFDv2(std::move(builder)); + + EXPECT_EQ(3u, config.modes.size()); + EXPECT_EQ(2u, + config.modes.at(ConnectionMode::kStreaming).initializers.size()); +} + +TEST(FDv2ConfigBuilderTest, SourcesCanOverrideTheirOwnBaseUrl) { + FDv2Builder builder; + builder.CustomizeMode( + ConnectionMode::kStreaming, + FDv2Builder::Mode().Synchronizer( + FDv2Builder::Polling().BaseUrl("https://relay.example.com"))); + + auto const config = BuildFDv2(std::move(builder)); + auto const* polling = std::get_if( + &config.modes.at(ConnectionMode::kStreaming).synchronizers[0]); + + ASSERT_NE(nullptr, polling); + ASSERT_TRUE(polling->base_url_override.has_value()); + EXPECT_EQ("https://relay.example.com", *polling->base_url_override); +} + +TEST(FDv2ConfigBuilderTest, TheFDv1FallbackIsConfigurable) { + FDv2Builder builder; + builder.CustomizeMode( + ConnectionMode::kStreaming, + FDv2Builder::Mode() + .Synchronizer(FDv2Builder::Streaming()) + .FallbackToFDv1( + FDv2Builder::FDv1Fallback().PollInterval(600s).BaseUrl( + "https://relay.example.com"))); + + auto const config = BuildFDv2(std::move(builder)); + auto const& fallback = + config.modes.at(ConnectionMode::kStreaming).fdv1_fallback; + + ASSERT_TRUE(fallback.has_value()); + EXPECT_EQ(600s, fallback->poll_interval); + ASSERT_TRUE(fallback->base_url_override.has_value()); + EXPECT_EQ("https://relay.example.com", *fallback->base_url_override); +} + +// ============================================================================ +// Endpoint defaults +// ============================================================================ + +namespace { + +FDv2Config BuiltFDv2(ConfigBuilder& builder) { + auto config = builder.Build(); + EXPECT_TRUE(config.has_value()); + return std::get(config->DataSourceConfig().method); +} + +} // namespace + +// FDv2 polls a different endpoint than FDv1 does, so an application that +// configured nothing polls there rather than where FDv1 would. +TEST(FDv2ConfigBuilderTest, FDv2KeepsItsOwnDefaultEndpoints) { + auto builder = ConfigBuilder("sdk-key"); + builder.DataSource().Method(DataSourceBuilder::FDv2()); + + auto const fdv2 = BuiltFDv2(builder); + + EXPECT_EQ("https://sdk.launchdarkly.com", fdv2.polling_base_url); + EXPECT_EQ("https://clientstream.launchdarkly.com", fdv2.streaming_base_url); + EXPECT_NE(Defaults::ServiceEndpoints().PollingBaseUrl(), + fdv2.polling_base_url); +} + +// An application that pointed the SDK somewhere else — a Relay Proxy, say — +// has FDv2 follow it there. +TEST(FDv2ConfigBuilderTest, ConfiguredEndpointsRedirectFDv2) { + auto builder = ConfigBuilder("sdk-key"); + builder.DataSource().Method(DataSourceBuilder::FDv2()); + builder.ServiceEndpoints().RelayProxyBaseURL("https://relay.example.com"); + + auto const fdv2 = BuiltFDv2(builder); + + EXPECT_EQ("https://relay.example.com", fdv2.polling_base_url); + EXPECT_EQ("https://relay.example.com", fdv2.streaming_base_url); +} + +// Endpoints set to the SDK's own values are still the application's choice, +// and redirect FDv2 like any other. +TEST(FDv2ConfigBuilderTest, ConfiguringOnlyTheEventsUrlStillRedirectsFDv2) { + auto defaults = Defaults::ServiceEndpoints(); + auto builder = ConfigBuilder("sdk-key"); + builder.DataSource().Method(DataSourceBuilder::FDv2()); + builder.ServiceEndpoints() + .EventsBaseUrl("https://events.example.com") + .PollingBaseUrl(defaults.PollingBaseUrl()) + .StreamingBaseUrl(defaults.StreamingBaseUrl()); + + auto const fdv2 = BuiltFDv2(builder); + + EXPECT_EQ(defaults.PollingBaseUrl(), fdv2.polling_base_url); +} diff --git a/libs/common/include/launchdarkly/config/client.hpp b/libs/common/include/launchdarkly/config/client.hpp index dd288a82a..f18c013bd 100644 --- a/libs/common/include/launchdarkly/config/client.hpp +++ b/libs/common/include/launchdarkly/config/client.hpp @@ -4,7 +4,9 @@ #include #include #include +#include #include +#include #include #include @@ -20,6 +22,8 @@ using EventsBuilder = config::shared::builders::EventsBuilder; using HttpPropertiesBuilder = config::shared::builders::HttpPropertiesBuilder; using DataSourceBuilder = config::shared::builders::DataSourceBuilder; +using FDv2Builder = config::shared::builders::FDv2Builder; +using ConnectionMode = config::shared::ConnectionMode; using LoggingBuilder = config::shared::builders::LoggingBuilder; using PersistenceBuilder = config::shared::builders::PersistenceBuilder; using TlsBuilder = config::shared::builders::TlsBuilder; diff --git a/libs/common/include/launchdarkly/config/shared/builders/data_source_builder.hpp b/libs/common/include/launchdarkly/config/shared/builders/data_source_builder.hpp index a69bac6e1..e2e6ce93f 100644 --- a/libs/common/include/launchdarkly/config/shared/builders/data_source_builder.hpp +++ b/libs/common/include/launchdarkly/config/shared/builders/data_source_builder.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -134,6 +135,7 @@ class DataSourceBuilder { public: using Streaming = StreamingBuilder; using Polling = PollingBuilder; + using FDv2 = FDv2Builder; DataSourceBuilder(); @@ -189,6 +191,18 @@ class DataSourceBuilder { */ DataSourceBuilder& Method(Polling polling_builder); + /** + * Set the FDv2 configuration for the builder. + * + * FDv2 is the current flag delivery protocol. It supersedes the + * streaming and polling methods above, which speak FDv1, and configures + * both transports itself through named connection modes. + * + * @param fdv2_builder The FDv2 builder. + * @return Reference to this builder. + */ + DataSourceBuilder& Method(FDv2 fdv2_builder); + /** * Build a data source config. This is used internal to the SDK. * @@ -197,7 +211,7 @@ class DataSourceBuilder { [[nodiscard]] built::DataSourceConfig Build() const; private: - std::variant method_; + std::variant method_; bool with_reasons_; bool use_report_; }; diff --git a/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp b/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp index 166822cbb..d3bc73a3e 100644 --- a/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp +++ b/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp @@ -14,6 +14,9 @@ namespace launchdarkly::config::shared::builders { template class EndpointsBuilder; +template +class ConfigBuilder; + template bool operator==(EndpointsBuilder const& lhs, EndpointsBuilder const& rhs); @@ -27,8 +30,8 @@ bool operator==(EndpointsBuilder const& lhs, template class EndpointsBuilder { public: - friend bool operator==(EndpointsBuilder const& lhs, - EndpointsBuilder const& rhs); + friend bool operator== (EndpointsBuilder const& lhs, + EndpointsBuilder const& rhs); /** * Constructs an EndpointsBuilder. */ @@ -72,6 +75,15 @@ class EndpointsBuilder { [[nodiscard]] tl::expected Build() const; private: + friend class ConfigBuilder; + + /** + * Whether the application set any of these URLs, as opposed to accepting + * the SDK's defaults. Read when resolving a data source whose own default + * endpoint differs from the SDK-wide one. + */ + [[nodiscard]] bool IsCustom() const; + std::optional polling_base_url_; std::optional streaming_base_url_; std::optional events_base_url_; diff --git a/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp b/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp new file mode 100644 index 000000000..21feb982b --- /dev/null +++ b/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp @@ -0,0 +1,178 @@ +#pragma once + +#include +#include +#include + +#include +#include +#include + +namespace launchdarkly::config::shared::builders { + +/** + * Configures the FDv2 data system: how the SDK obtains flag data, and how it + * keeps that data current. + * + * A default-constructed builder is the configuration the SDK uses when the + * application customizes nothing. It starts in streaming mode, and provides + * streaming, polling, and offline modes. + */ +class FDv2Builder { + public: + using Config = built::FDv2Config; + + /** + * Configures the local cache as a source. Reading persisted flag data + * lets evaluation begin before the network answers. It has no options. + */ + class Cache { + public: + [[nodiscard]] Config::CacheConfig Build() const; + }; + + /** + * Configures a streaming source, which receives updates as the service + * publishes them. + */ + class Streaming { + public: + /** + * Sets where the reconnection backoff starts. The delay for the + * first reconnection starts near this value and grows exponentially + * for subsequent failures. + */ + Streaming& InitialReconnectDelay(std::chrono::milliseconds delay); + + /** + * Sends this source's requests to the given URL instead of the + * streaming URL the rest of the SDK uses. Useful for routing one tier + * to different infrastructure, such as a Relay Proxy used only as a + * fallback. + */ + Streaming& BaseUrl(std::string base_url); + + [[nodiscard]] Config::StreamingConfig Build() const; + + private: + std::chrono::milliseconds initial_reconnect_delay_{1000}; + std::optional base_url_override_; + }; + + /** + * Configures a polling source, which asks the service for updates on an + * interval. + */ + class Polling { + public: + /** + * Sets how long to wait between polls. Intervals shorter than the + * minimum the SDK permits are raised to it. + */ + Polling& PollInterval(std::chrono::seconds interval); + + /** + * Sends this source's requests to the given URL instead of the + * polling URL the rest of the SDK uses. + */ + Polling& BaseUrl(std::string base_url); + + [[nodiscard]] Config::PollingConfig Build() const; + + private: + std::chrono::seconds poll_interval_{std::chrono::minutes(5)}; + std::optional base_url_override_; + }; + + /** + * Configures the FDv1 polling source the SDK uses while the service has + * directed it away from FDv2. The SDK returns to FDv2 on its own once the + * service's fallback period has elapsed. + */ + class FDv1Fallback { + public: + /** Sets how long to wait between polls while on FDv1. */ + FDv1Fallback& PollInterval(std::chrono::seconds interval); + + /** + * Sends the fallback's requests to the given URL instead of the + * polling URL the rest of the SDK uses. + */ + FDv1Fallback& BaseUrl(std::string base_url); + + [[nodiscard]] Config::FDv1FallbackConfig Build() const; + + private: + std::chrono::seconds poll_interval_{std::chrono::minutes(5)}; + std::optional base_url_override_; + }; + + /** + * Configures what one connection mode does: which sources load flag data, + * and which keep it current. + * + * A mode built this way replaces the SDK's built-in definition entirely, + * so it should list every source the mode needs, cache included. + */ + class Mode { + public: + /** + * Appends a source to the list that runs, in order, until one loads a + * complete data set. + */ + Mode& Initializer(Cache source); + Mode& Initializer(Polling source); + + /** + * Appends a source to the list that keeps data current. Order is + * preference. The first entry is the primary, and the SDK falls back + * to later entries when it cannot keep the primary running. + */ + Mode& Synchronizer(Streaming source); + Mode& Synchronizer(Polling source); + + /** Sets the FDv1 source to use if the service directs the SDK to it. */ + Mode& FallbackToFDv1(FDv1Fallback source); + + /** + * Leaves the mode with no FDv1 source. A fallback directive then + * stops the mode's synchronizer until the SDK returns to FDv2. + */ + Mode& DisableFDv1Fallback(); + + [[nodiscard]] Config::ModeDefinition Build() const; + + private: + Config::ModeDefinition definition_; + }; + + FDv2Builder(); + + /** + * Sets the mode the SDK starts in. Defaults to streaming. + */ + FDv2Builder& InitialMode(ConnectionMode mode); + + /** + * Replaces what the given mode does. Modes left uncustomized keep their + * built-in definitions. + */ + FDv2Builder& CustomizeMode(ConnectionMode mode, Mode definition); + + /** + * Sends the evaluation context in a request body rather than encoded into + * the request path. This keeps the context out of URL-based request logs + * and CDN logs, at the cost of CDN caching. + */ + FDv2Builder& UsePost(bool use_post); + + /** + * Builds the FDv2 config. Used internal to the SDK. + */ + [[nodiscard]] Config Build() const; + + private: + Config config_; +}; + +} // namespace launchdarkly::config::shared::builders diff --git a/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp b/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp index 32b9cc5b2..8c913ac05 100644 --- a/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp +++ b/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp @@ -56,9 +56,16 @@ struct DataSourceConfig; template <> struct DataSourceConfig { - std::variant, PollingConfig> method; + std::variant, + PollingConfig, + FDv2Config> + method; bool with_reasons; + /** + * Ignored when the method is FDv2, which supersedes the REPORT + * transport with its own choice of GET or POST. + */ bool use_report; }; diff --git a/libs/common/src/CMakeLists.txt b/libs/common/src/CMakeLists.txt index c39644fd0..f78a7691a 100644 --- a/libs/common/src/CMakeLists.txt +++ b/libs/common/src/CMakeLists.txt @@ -41,6 +41,7 @@ add_library(${LIBNAME} OBJECT config/app_info_builder.cpp config/http_properties.cpp config/data_source_builder.cpp + config/fdv2_builder.cpp config/http_properties_builder.cpp bindings/c/value.cpp bindings/c/array_builder.cpp diff --git a/libs/common/src/config/config_builder.cpp b/libs/common/src/config/config_builder.cpp index 0c306cb1f..10da1ba23 100644 --- a/libs/common/src/config/config_builder.cpp +++ b/libs/common/src/config/config_builder.cpp @@ -1,6 +1,9 @@ #include #include +#include +#include + namespace launchdarkly::config::shared::builders { template @@ -72,6 +75,19 @@ ConfigBuilder::Build() const { auto data_source_config = data_source_builder_.Build(); + if constexpr (std::is_same_v) { + // FDv2 polls a different endpoint than FDv1 does, so it keeps its own + // default until the application configures its own endpoints. Once it + // has, FDv2 follows them, so that pointing the SDK at a Relay Proxy + // redirects FDv2 too. + if (auto* fdv2 = + std::get_if>(&data_source_config.method); + fdv2 != nullptr && service_endpoints_builder_.IsCustom()) { + fdv2->polling_base_url = endpoints_config->PollingBaseUrl(); + fdv2->streaming_base_url = endpoints_config->StreamingBaseUrl(); + } + } + auto http_properties = http_properties_builder_.Build(); auto logging = logging_config_builder_.Build(); diff --git a/libs/common/src/config/data_source_builder.cpp b/libs/common/src/config/data_source_builder.cpp index e19a9417e..4d1e846c6 100644 --- a/libs/common/src/config/data_source_builder.cpp +++ b/libs/common/src/config/data_source_builder.cpp @@ -8,8 +8,9 @@ struct MethodVisitor {}; template <> struct MethodVisitor { using SDK = ClientSDK; - using Result = - std::variant, built::PollingConfig>; + using Result = std::variant, + built::PollingConfig, + built::FDv2Config>; Result operator()(StreamingBuilder const& streaming) const { return streaming.Build(); @@ -18,6 +19,8 @@ struct MethodVisitor { Result operator()(PollingBuilder const& polling) const { return polling.Build(); } + + Result operator()(FDv2Builder const& fdv2) const { return fdv2.Build(); } }; template @@ -79,6 +82,12 @@ DataSourceBuilder& DataSourceBuilder::Method( return *this; } +DataSourceBuilder& DataSourceBuilder::Method( + FDv2Builder builder) { + method_ = std::move(builder); + return *this; +} + built::DataSourceConfig DataSourceBuilder::Build() const { return {std::visit(MethodVisitor(), method_), with_reasons_, use_report_}; diff --git a/libs/common/src/config/endpoints_builder.cpp b/libs/common/src/config/endpoints_builder.cpp index 9701b195e..1b80cdad1 100644 --- a/libs/common/src/config/endpoints_builder.cpp +++ b/libs/common/src/config/endpoints_builder.cpp @@ -42,6 +42,12 @@ bool empty_string(std::optional const& opt_string) { return opt_string.has_value() && opt_string->empty(); } +template +bool EndpointsBuilder::IsCustom() const { + return polling_base_url_.has_value() || streaming_base_url_.has_value() || + events_base_url_.has_value(); +} + template tl::expected EndpointsBuilder::Build() const { diff --git a/libs/common/src/config/fdv2_builder.cpp b/libs/common/src/config/fdv2_builder.cpp new file mode 100644 index 000000000..46cfa3432 --- /dev/null +++ b/libs/common/src/config/fdv2_builder.cpp @@ -0,0 +1,114 @@ +#include +#include + +#include + +namespace launchdarkly::config::shared::builders { + +FDv2Builder::Config::CacheConfig FDv2Builder::Cache::Build() const { + return {}; +} + +FDv2Builder::Streaming& FDv2Builder::Streaming::InitialReconnectDelay( + std::chrono::milliseconds delay) { + initial_reconnect_delay_ = delay; + return *this; +} + +FDv2Builder::Streaming& FDv2Builder::Streaming::BaseUrl(std::string base_url) { + base_url_override_ = std::move(base_url); + return *this; +} + +FDv2Builder::Config::StreamingConfig FDv2Builder::Streaming::Build() const { + return {initial_reconnect_delay_, base_url_override_}; +} + +FDv2Builder::Polling& FDv2Builder::Polling::PollInterval( + std::chrono::seconds interval) { + poll_interval_ = interval; + return *this; +} + +FDv2Builder::Polling& FDv2Builder::Polling::BaseUrl(std::string base_url) { + base_url_override_ = std::move(base_url); + return *this; +} + +FDv2Builder::Config::PollingConfig FDv2Builder::Polling::Build() const { + return {poll_interval_, base_url_override_}; +} + +FDv2Builder::FDv1Fallback& FDv2Builder::FDv1Fallback::PollInterval( + std::chrono::seconds interval) { + poll_interval_ = interval; + return *this; +} + +FDv2Builder::FDv1Fallback& FDv2Builder::FDv1Fallback::BaseUrl( + std::string base_url) { + base_url_override_ = std::move(base_url); + return *this; +} + +FDv2Builder::Config::FDv1FallbackConfig FDv2Builder::FDv1Fallback::Build() + const { + return {poll_interval_, base_url_override_}; +} + +FDv2Builder::Mode& FDv2Builder::Mode::Initializer(Cache source) { + definition_.initializers.emplace_back(source.Build()); + return *this; +} + +FDv2Builder::Mode& FDv2Builder::Mode::Initializer(Polling source) { + definition_.initializers.emplace_back(source.Build()); + return *this; +} + +FDv2Builder::Mode& FDv2Builder::Mode::Synchronizer(Streaming source) { + definition_.synchronizers.emplace_back(source.Build()); + return *this; +} + +FDv2Builder::Mode& FDv2Builder::Mode::Synchronizer(Polling source) { + definition_.synchronizers.emplace_back(source.Build()); + return *this; +} + +FDv2Builder::Mode& FDv2Builder::Mode::FallbackToFDv1(FDv1Fallback source) { + definition_.fdv1_fallback = source.Build(); + return *this; +} + +FDv2Builder::Mode& FDv2Builder::Mode::DisableFDv1Fallback() { + definition_.fdv1_fallback = std::nullopt; + return *this; +} + +FDv2Builder::Config::ModeDefinition FDv2Builder::Mode::Build() const { + return definition_; +} + +FDv2Builder::FDv2Builder() : config_(Defaults::FDv2Config()) {} + +FDv2Builder& FDv2Builder::InitialMode(ConnectionMode mode) { + config_.initial_mode = mode; + return *this; +} + +FDv2Builder& FDv2Builder::CustomizeMode(ConnectionMode mode, Mode definition) { + config_.modes[mode] = definition.Build(); + return *this; +} + +FDv2Builder& FDv2Builder::UsePost(bool use_post) { + config_.use_post = use_post; + return *this; +} + +FDv2Builder::Config FDv2Builder::Build() const { + return config_; +} + +} // namespace launchdarkly::config::shared::builders From fe8e5290ceea54d0580ddc1f549358b5e32f5d88 Mon Sep 17 00:00:00 2001 From: Bee Klimt Date: Tue, 6 Oct 2026 11:02:04 -0700 Subject: [PATCH 2/9] refactor: Align the FDv2 builder with the server API and doc conventions --- .../tests/fdv2_config_builder_test.cpp | 10 +- .../shared/builders/endpoints_builder.hpp | 3 +- .../config/shared/builders/fdv2_builder.hpp | 190 ++++++++++++++---- libs/common/src/config/config_builder.cpp | 6 +- libs/common/src/config/fdv2_builder.cpp | 8 +- 5 files changed, 159 insertions(+), 58 deletions(-) diff --git a/libs/client-sdk/tests/fdv2_config_builder_test.cpp b/libs/client-sdk/tests/fdv2_config_builder_test.cpp index dcf8e49ad..925f6b2c5 100644 --- a/libs/client-sdk/tests/fdv2_config_builder_test.cpp +++ b/libs/client-sdk/tests/fdv2_config_builder_test.cpp @@ -50,8 +50,7 @@ TEST(FDv2ConfigBuilderTest, SelectingFDv2ReplacesTheFDv1Method) { std::holds_alternative(config->DataSourceConfig().method)); } -// What those defaults are is pinned down where they are defined. This is -// about the builder starting from them. +// The builder starts from the SDK's defaults, whatever they are. TEST(FDv2ConfigBuilderTest, AnUncustomizedBuilderYieldsTheSDKDefaults) { auto const config = BuildFDv2(FDv2Builder()); auto const defaults = Defaults::FDv2Config(); @@ -139,9 +138,8 @@ TEST(FDv2ConfigBuilderTest, TheFDv1FallbackIsConfigurable) { ConnectionMode::kStreaming, FDv2Builder::Mode() .Synchronizer(FDv2Builder::Streaming()) - .FallbackToFDv1( - FDv2Builder::FDv1Fallback().PollInterval(600s).BaseUrl( - "https://relay.example.com"))); + .FDv1Fallback(FDv2Builder::FDv1Polling().PollInterval(600s).BaseUrl( + "https://relay.example.com"))); auto const config = BuildFDv2(std::move(builder)); auto const& fallback = @@ -181,7 +179,7 @@ TEST(FDv2ConfigBuilderTest, FDv2KeepsItsOwnDefaultEndpoints) { fdv2.polling_base_url); } -// An application that pointed the SDK somewhere else — a Relay Proxy, say — +// An application that pointed the SDK somewhere else -- a Relay Proxy, say -- // has FDv2 follow it there. TEST(FDv2ConfigBuilderTest, ConfiguredEndpointsRedirectFDv2) { auto builder = ConfigBuilder("sdk-key"); diff --git a/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp b/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp index d3bc73a3e..08ed386f6 100644 --- a/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp +++ b/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp @@ -79,8 +79,7 @@ class EndpointsBuilder { /** * Whether the application set any of these URLs, as opposed to accepting - * the SDK's defaults. Read when resolving a data source whose own default - * endpoint differs from the SDK-wide one. + * the SDK's defaults. */ [[nodiscard]] bool IsCustom() const; diff --git a/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp b/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp index 21feb982b..d86494bde 100644 --- a/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp +++ b/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp @@ -11,8 +11,8 @@ namespace launchdarkly::config::shared::builders { /** - * Configures the FDv2 data system: how the SDK obtains flag data, and how it - * keeps that data current. + * Contains methods for configuring the FDv2 data system, which determines how + * the SDK obtains flag data and how it keeps that data current. * * A default-constructed builder is the configuration the SDK uses when the * application customizes nothing. It starts in streaming mode, and provides @@ -23,35 +23,55 @@ class FDv2Builder { using Config = built::FDv2Config; /** - * Configures the local cache as a source. Reading persisted flag data - * lets evaluation begin before the network answers. It has no options. + * Configures the local cache as a source. It has no options. + * + * Reading persisted flag data lets evaluation begin before the network + * answers. */ class Cache { public: + /** + * Build the cache config. Used internal to the SDK. + * @return The built config. + */ [[nodiscard]] Config::CacheConfig Build() const; }; /** - * Configures a streaming source, which receives updates as the service - * publishes them. + * Contains methods for configuring a streaming source, which receives + * updates as the service publishes them. */ class Streaming { public: /** - * Sets where the reconnection backoff starts. The delay for the - * first reconnection starts near this value and grows exponentially - * for subsequent failures. + * Sets the initial reconnect delay for the streaming connection. + * + * The delay for the first reconnection will start near this value, + * and then increase exponentially for any subsequent connection + * failures. + * + * @param delay The initial delay for a reconnection attempt. + * @return Reference to this builder. */ Streaming& InitialReconnectDelay(std::chrono::milliseconds delay); /** - * Sends this source's requests to the given URL instead of the - * streaming URL the rest of the SDK uses. Useful for routing one tier - * to different infrastructure, such as a Relay Proxy used only as a - * fallback. + * Sets the base URL for this source alone. + * + * Requests from this source are sent to the given URL instead of the + * streaming URL the rest of the SDK uses. This is useful for routing + * one tier to different infrastructure, such as a Relay Proxy used + * only as a fallback. + * + * @param base_url The base URL for this source. + * @return Reference to this builder. */ Streaming& BaseUrl(std::string base_url); + /** + * Build the streaming config. Used internal to the SDK. + * @return The built config. + */ [[nodiscard]] Config::StreamingConfig Build() const; private: @@ -60,23 +80,38 @@ class FDv2Builder { }; /** - * Configures a polling source, which asks the service for updates on an - * interval. + * Contains methods for configuring a polling source, which asks the + * service for updates on an interval. */ class Polling { public: /** - * Sets how long to wait between polls. Intervals shorter than the - * minimum the SDK permits are raised to it. + * Sets the interval at which the SDK will poll for feature flag + * updates. + * + * Intervals shorter than the minimum the SDK permits are raised to + * it. + * + * @param interval The polling interval. + * @return Reference to this builder. */ Polling& PollInterval(std::chrono::seconds interval); /** - * Sends this source's requests to the given URL instead of the + * Sets the base URL for this source alone. + * + * Requests from this source are sent to the given URL instead of the * polling URL the rest of the SDK uses. + * + * @param base_url The base URL for this source. + * @return Reference to this builder. */ Polling& BaseUrl(std::string base_url); + /** + * Build the polling config. Used internal to the SDK. + * @return The built config. + */ [[nodiscard]] Config::PollingConfig Build() const; private: @@ -85,21 +120,36 @@ class FDv2Builder { }; /** - * Configures the FDv1 polling source the SDK uses while the service has - * directed it away from FDv2. The SDK returns to FDv2 on its own once the - * service's fallback period has elapsed. + * Contains methods for configuring the FDv1 polling source the SDK uses + * while the service has directed it away from FDv2. + * + * The SDK returns to FDv2 on its own once the service's fallback period + * has elapsed. */ - class FDv1Fallback { + class FDv1Polling { public: - /** Sets how long to wait between polls while on FDv1. */ - FDv1Fallback& PollInterval(std::chrono::seconds interval); + /** + * Sets the interval at which the SDK will poll while on FDv1. + * @param interval The polling interval. + * @return Reference to this builder. + */ + FDv1Polling& PollInterval(std::chrono::seconds interval); /** - * Sends the fallback's requests to the given URL instead of the + * Sets the base URL for the fallback alone. + * + * Requests from the fallback are sent to the given URL instead of the * polling URL the rest of the SDK uses. + * + * @param base_url The base URL for the fallback. + * @return Reference to this builder. */ - FDv1Fallback& BaseUrl(std::string base_url); + FDv1Polling& BaseUrl(std::string base_url); + /** + * Build the FDv1 fallback config. Used internal to the SDK. + * @return The built config. + */ [[nodiscard]] Config::FDv1FallbackConfig Build() const; private: @@ -108,8 +158,8 @@ class FDv2Builder { }; /** - * Configures what one connection mode does: which sources load flag data, - * and which keep it current. + * Contains methods for configuring what one connection mode does, meaning + * which sources load flag data and which keep it current. * * A mode built this way replaces the SDK's built-in definition entirely, * so it should list every source the mode needs, cache included. @@ -117,29 +167,70 @@ class FDv2Builder { class Mode { public: /** - * Appends a source to the list that runs, in order, until one loads a - * complete data set. + * Appends a source to the list that loads flag data. + * + * The sources run in order until one loads a complete data set. + * + * @param source The cache source. + * @return Reference to this builder. */ Mode& Initializer(Cache source); + + /** + * Appends a source to the list that loads flag data. + * + * The sources run in order until one loads a complete data set. + * + * @param source The polling source. + * @return Reference to this builder. + */ Mode& Initializer(Polling source); /** - * Appends a source to the list that keeps data current. Order is - * preference. The first entry is the primary, and the SDK falls back - * to later entries when it cannot keep the primary running. + * Appends a source to the list that keeps flag data current. + * + * Order is preference. The first entry is the primary, and the SDK + * falls back to later entries when it cannot keep the primary + * running. + * + * @param source The streaming source. + * @return Reference to this builder. */ Mode& Synchronizer(Streaming source); + + /** + * Appends a source to the list that keeps flag data current. + * + * Order is preference. The first entry is the primary, and the SDK + * falls back to later entries when it cannot keep the primary + * running. + * + * @param source The polling source. + * @return Reference to this builder. + */ Mode& Synchronizer(Polling source); - /** Sets the FDv1 source to use if the service directs the SDK to it. */ - Mode& FallbackToFDv1(FDv1Fallback source); + /** + * Sets the FDv1 source to use if the service directs the SDK to it. + * @param source The FDv1 fallback source. + * @return Reference to this builder. + */ + Mode& FDv1Fallback(FDv1Polling source); /** - * Leaves the mode with no FDv1 source. A fallback directive then - * stops the mode's synchronizer until the SDK returns to FDv2. + * Leaves the mode with no FDv1 source. + * + * A fallback directive then stops the mode's synchronizer until the + * SDK returns to FDv2. + * + * @return Reference to this builder. */ Mode& DisableFDv1Fallback(); + /** + * Build the mode definition. Used internal to the SDK. + * @return The built config. + */ [[nodiscard]] Config::ModeDefinition Build() const; private: @@ -150,24 +241,37 @@ class FDv2Builder { /** * Sets the mode the SDK starts in. Defaults to streaming. + * @param mode The initial connection mode. + * @return Reference to this builder. */ FDv2Builder& InitialMode(ConnectionMode mode); /** - * Replaces what the given mode does. Modes left uncustomized keep their - * built-in definitions. + * Replaces what the given mode does. + * + * Modes left uncustomized keep their built-in definitions. + * + * @param mode The connection mode to replace. + * @param definition What the mode does. + * @return Reference to this builder. */ FDv2Builder& CustomizeMode(ConnectionMode mode, Mode definition); /** - * Sends the evaluation context in a request body rather than encoded into - * the request path. This keeps the context out of URL-based request logs - * and CDN logs, at the cost of CDN caching. + * Whether to send the evaluation context in a request body rather than + * encoded into the request path. + * + * This keeps the context out of URL-based request logs and CDN logs, at + * the cost of CDN caching. + * + * @param use_post True to send the context in a request body. + * @return Reference to this builder. */ FDv2Builder& UsePost(bool use_post); /** - * Builds the FDv2 config. Used internal to the SDK. + * Build the FDv2 config. Used internal to the SDK. + * @return The built config. */ [[nodiscard]] Config Build() const; diff --git a/libs/common/src/config/config_builder.cpp b/libs/common/src/config/config_builder.cpp index 10da1ba23..f59528c56 100644 --- a/libs/common/src/config/config_builder.cpp +++ b/libs/common/src/config/config_builder.cpp @@ -80,9 +80,9 @@ ConfigBuilder::Build() const { // default until the application configures its own endpoints. Once it // has, FDv2 follows them, so that pointing the SDK at a Relay Proxy // redirects FDv2 too. - if (auto* fdv2 = - std::get_if>(&data_source_config.method); - fdv2 != nullptr && service_endpoints_builder_.IsCustom()) { + auto* fdv2 = + std::get_if>(&data_source_config.method); + if (fdv2 != nullptr && service_endpoints_builder_.IsCustom()) { fdv2->polling_base_url = endpoints_config->PollingBaseUrl(); fdv2->streaming_base_url = endpoints_config->StreamingBaseUrl(); } diff --git a/libs/common/src/config/fdv2_builder.cpp b/libs/common/src/config/fdv2_builder.cpp index 46cfa3432..92ddbe899 100644 --- a/libs/common/src/config/fdv2_builder.cpp +++ b/libs/common/src/config/fdv2_builder.cpp @@ -39,19 +39,19 @@ FDv2Builder::Config::PollingConfig FDv2Builder::Polling::Build() const { return {poll_interval_, base_url_override_}; } -FDv2Builder::FDv1Fallback& FDv2Builder::FDv1Fallback::PollInterval( +FDv2Builder::FDv1Polling& FDv2Builder::FDv1Polling::PollInterval( std::chrono::seconds interval) { poll_interval_ = interval; return *this; } -FDv2Builder::FDv1Fallback& FDv2Builder::FDv1Fallback::BaseUrl( +FDv2Builder::FDv1Polling& FDv2Builder::FDv1Polling::BaseUrl( std::string base_url) { base_url_override_ = std::move(base_url); return *this; } -FDv2Builder::Config::FDv1FallbackConfig FDv2Builder::FDv1Fallback::Build() +FDv2Builder::Config::FDv1FallbackConfig FDv2Builder::FDv1Polling::Build() const { return {poll_interval_, base_url_override_}; } @@ -76,7 +76,7 @@ FDv2Builder::Mode& FDv2Builder::Mode::Synchronizer(Polling source) { return *this; } -FDv2Builder::Mode& FDv2Builder::Mode::FallbackToFDv1(FDv1Fallback source) { +FDv2Builder::Mode& FDv2Builder::Mode::FDv1Fallback(FDv1Polling source) { definition_.fdv1_fallback = source.Build(); return *this; } From 5af58d1f817b1edcbcb88230b7fe3269aa8ff074 Mon Sep 17 00:00:00 2001 From: Bee Klimt Date: Tue, 6 Oct 2026 15:26:12 -0700 Subject: [PATCH 3/9] fix: Restore the FDv2 config include in the data source config --- .../launchdarkly/config/shared/built/data_source_config.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp b/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp index 8c913ac05..560e08eea 100644 --- a/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp +++ b/libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include From 2f63ff05ef19045bcd922cc6f053c5c2a18b1f57 Mon Sep 17 00:00:00 2001 From: Bee Klimt Date: Tue, 17 Nov 2026 11:05:49 -0800 Subject: [PATCH 4/9] test: Check that identify does not send the previous context's basis --- libs/client-sdk/tests/fdv2_client_test.cpp | 119 +++++++++++++++++++++ 1 file changed, 119 insertions(+) diff --git a/libs/client-sdk/tests/fdv2_client_test.cpp b/libs/client-sdk/tests/fdv2_client_test.cpp index e14b48336..03a3a32b6 100644 --- a/libs/client-sdk/tests/fdv2_client_test.cpp +++ b/libs/client-sdk/tests/fdv2_client_test.cpp @@ -4,11 +4,16 @@ #include #include +#include +#include #include #include #include #include #include +#include + +#include "../../server-sent-events/tests/mock_sse_server.hpp" using namespace launchdarkly; using namespace launchdarkly::client_side; @@ -110,3 +115,117 @@ TEST(FDv2ClientTest, OfflineModeEvaluatesAgainstTheCache) { EXPECT_TRUE(started.get()); EXPECT_EQ("fish", client.StringVariation("treat", "chicken")); } + +// During identify, the old stream can deliver one more update. The first +// request for the new context must not contain the selector from that update. +TEST(FDv2ClientTest, IdentifyDoesNotSendThePreviousContextsBasis) { + namespace http = boost::beast::http; + + std::mutex mutex; + std::vector targets; + std::function send_to_first; + std::promise second_connected; + std::once_flag applied_once; + std::promise applied; + std::once_flag pushed_once; + bool late_update_applied = false; + + sse::test::MockSSEServer server; + server.start([&](http::request const& req, + std::function)> + send_response, + std::function send_sse_event, + std::function /* close_connection */) { + http::response res{http::status::ok, req.version()}; + res.set(http::field::content_type, "text/event-stream"); + res.chunked(true); + send_response(res); + + std::lock_guard lock{mutex}; + // Record the target of each request. + targets.emplace_back(req.target()); + if (targets.size() == 1) { + send_to_first = send_sse_event; + // Send a full data set on the first stream. + send_sse_event( + "event: server-intent\n" + R"(data: {"payloads":[{"id":"p1","target":1,)" + R"("intentCode":"xfer-full"}]})" + "\n\n" + "event: put-object\n" + R"(data: {"version":1,"kind":"flag-eval","key":"flagA",)" + R"("object":{"value":"a-1","variation":0}})" + "\n\n" + "event: payload-transferred\n" + R"(data: {"state":"a-1","version":1})" + "\n\n"); + } else if (targets.size() == 2) { + second_connected.set_value(); + } + }); + + auto builder = ConfigBuilder("the-key"); + builder.DataSource().Method( + DataSourceBuilder::FDv2() + .InitialMode(ConnectionMode::kStreaming) + .CustomizeMode(ConnectionMode::kStreaming, + FDv2Builder::Mode() + .Initializer(FDv2Builder::Cache()) + .Synchronizer(FDv2Builder::Streaming().BaseUrl( + server.url())))); + builder.Events().Disable(); + builder.Persistence().None(); + + Client client(builder.Build().value(), + ContextBuilder().Kind("user", "first").Build()); + auto started = client.StartAsync(); + ASSERT_EQ(std::future_status::ready, started.wait_for(5s)); + ASSERT_TRUE(started.get()); + + // A change to flagA shows that the SDK applied the update. + auto flag_connection = client.FlagNotifier().OnFlagChange( + "flagA", [&](std::shared_ptr) { + std::call_once(applied_once, [&] { applied.set_value(); }); + }); + + auto status_connection = client.DataSourceStatus().OnDataSourceStatusChange( + [&](data_sources::DataSourceStatus status) { + // Identify sets this status before the old source closes. + if (status.State() != data_sources::DataSourceStatus:: + DataSourceState::kInitializing) { + return; + } + std::call_once(pushed_once, [&] { + std::function send; + { + std::lock_guard lock{mutex}; + send = send_to_first; + } + // Send an update on the old stream. + send( + "event: put-object\n" + R"(data: {"version":2,"kind":"flag-eval","key":"flagA",)" + R"("object":{"value":"a-2","variation":1}})" + "\n\n" + "event: payload-transferred\n" + R"(data: {"state":"a-2","version":2})" + "\n\n"); + // Wait until the SDK applies the update. + late_update_applied = applied.get_future().wait_for(5s) == + std::future_status::ready; + }); + }); + + // Identify the second context. + client.IdentifyAsync(ContextBuilder().Kind("user", "second").Build()); + + // The SDK applied the update from the old stream. + ASSERT_TRUE(late_update_applied); + // The SDK opened a stream for the second context. + ASSERT_EQ(std::future_status::ready, + second_connected.get_future().wait_for(5s)); + std::lock_guard lock{mutex}; + // The first request for the second context has no basis. + EXPECT_EQ(std::string::npos, targets[1].find("basis=")) + << "The second context requested " << targets[1]; +} From 1a9b9d699060b0fd3cdae0e6dab75291fe910532 Mon Sep 17 00:00:00 2001 From: Bee Klimt Date: Tue, 17 Nov 2026 14:24:24 -0800 Subject: [PATCH 5/9] test: Check that a customized mode keeps its FDv1 fallback, using async promises --- libs/client-sdk/tests/fdv2_client_test.cpp | 82 +++++++++++++++++++--- 1 file changed, 73 insertions(+), 9 deletions(-) diff --git a/libs/client-sdk/tests/fdv2_client_test.cpp b/libs/client-sdk/tests/fdv2_client_test.cpp index 03a3a32b6..47f35afeb 100644 --- a/libs/client-sdk/tests/fdv2_client_test.cpp +++ b/libs/client-sdk/tests/fdv2_client_test.cpp @@ -1,5 +1,6 @@ #include +#include #include #include @@ -11,6 +12,7 @@ #include #include #include +#include #include #include "../../server-sent-events/tests/mock_sse_server.hpp" @@ -124,9 +126,10 @@ TEST(FDv2ClientTest, IdentifyDoesNotSendThePreviousContextsBasis) { std::mutex mutex; std::vector targets; std::function send_to_first; - std::promise second_connected; - std::once_flag applied_once; - std::promise applied; + async::Promise second_connected; + auto second_connected_future = second_connected.GetFuture(); + async::Promise applied; + auto applied_future = applied.GetFuture(); std::once_flag pushed_once; bool late_update_applied = false; @@ -160,7 +163,7 @@ TEST(FDv2ClientTest, IdentifyDoesNotSendThePreviousContextsBasis) { R"(data: {"state":"a-1","version":1})" "\n\n"); } else if (targets.size() == 2) { - second_connected.set_value(); + second_connected.Resolve(std::monostate{}); } }); @@ -185,7 +188,7 @@ TEST(FDv2ClientTest, IdentifyDoesNotSendThePreviousContextsBasis) { // A change to flagA shows that the SDK applied the update. auto flag_connection = client.FlagNotifier().OnFlagChange( "flagA", [&](std::shared_ptr) { - std::call_once(applied_once, [&] { applied.set_value(); }); + applied.Resolve(std::monostate{}); }); auto status_connection = client.DataSourceStatus().OnDataSourceStatusChange( @@ -211,8 +214,8 @@ TEST(FDv2ClientTest, IdentifyDoesNotSendThePreviousContextsBasis) { R"(data: {"state":"a-2","version":2})" "\n\n"); // Wait until the SDK applies the update. - late_update_applied = applied.get_future().wait_for(5s) == - std::future_status::ready; + late_update_applied = + applied_future.WaitForResult(5s).has_value(); }); }); @@ -222,10 +225,71 @@ TEST(FDv2ClientTest, IdentifyDoesNotSendThePreviousContextsBasis) { // The SDK applied the update from the old stream. ASSERT_TRUE(late_update_applied); // The SDK opened a stream for the second context. - ASSERT_EQ(std::future_status::ready, - second_connected.get_future().wait_for(5s)); + ASSERT_TRUE(second_connected_future.WaitForResult(5s).has_value()); std::lock_guard lock{mutex}; // The first request for the second context has no basis. EXPECT_EQ(std::string::npos, targets[1].find("basis=")) << "The second context requested " << targets[1]; } + +// A customized mode that sets no FDv1 fallback still falls back to FDv1. +TEST(FDv2ClientTest, CustomizedModeKeepsTheBuiltInFDv1Fallback) { + namespace http = boost::beast::http; + + async::Promise polled; + auto polled_future = polled.GetFuture(); + + sse::test::MockSSEServer server; + server.start([&](http::request const& req, + std::function)> + send_response, + std::function send_sse_event, + std::function /* close_connection */) { + std::string const target(req.target()); + // Answer FDv1 polls with no flags. + if (target.rfind("/msdk/evalx/contexts", 0) == 0) { + http::response res{http::status::ok, + req.version()}; + res.set(http::field::content_type, "application/json"); + res.body() = "{}"; + res.prepare_payload(); + send_response(res); + // Record the FDv1 poll. + polled.Resolve(std::monostate{}); + return; + } + + http::response res{http::status::ok, req.version()}; + res.set(http::field::content_type, "text/event-stream"); + res.chunked(true); + send_response(res); + // Direct the SDK to FDv1. + send_sse_event( + "event: goodbye\n" + R"(data: {"reason":"fallback","protocolFallbackTTL":60})" + "\n\n"); + }); + + auto builder = ConfigBuilder("the-key"); + builder.ServiceEndpoints() + .PollingBaseUrl(server.url()) + .StreamingBaseUrl(server.url()) + .EventsBaseUrl(server.url()); + builder.DataSource().Method( + DataSourceBuilder::FDv2() + .InitialMode(ConnectionMode::kStreaming) + .CustomizeMode( + ConnectionMode::kStreaming, + FDv2Builder::Mode().Synchronizer(FDv2Builder::Streaming()))); + builder.Events().Disable(); + builder.Persistence().None(); + + Client client(builder.Build().value(), + ContextBuilder().Kind("user", "user-key").Build()); + + // Start the SDK in the customized streaming mode. + client.StartAsync(); + + // The SDK polls the FDv1 endpoint. + EXPECT_TRUE(polled_future.WaitForResult(5s).has_value()); +} From 9949a468f844fdc12f61db513aac3e357319cec7 Mon Sep 17 00:00:00 2001 From: Bee Klimt Date: Tue, 17 Nov 2026 15:53:38 -0800 Subject: [PATCH 6/9] fix: Keep the built-in FDv1 fallback when customizing a mode --- libs/client-sdk/tests/fdv2_config_builder_test.cpp | 9 +++++---- .../launchdarkly/config/shared/builders/fdv2_builder.hpp | 7 +++++-- libs/common/src/config/fdv2_builder.cpp | 2 +- 3 files changed, 11 insertions(+), 7 deletions(-) diff --git a/libs/client-sdk/tests/fdv2_config_builder_test.cpp b/libs/client-sdk/tests/fdv2_config_builder_test.cpp index 925f6b2c5..dc5ad1a34 100644 --- a/libs/client-sdk/tests/fdv2_config_builder_test.cpp +++ b/libs/client-sdk/tests/fdv2_config_builder_test.cpp @@ -100,7 +100,8 @@ TEST(FDv2ConfigBuilderTest, CustomizingAModeReplacesItsPipeline) { std::get_if(&mode.synchronizers[0]); ASSERT_NE(nullptr, streaming); EXPECT_EQ(2s, streaming->initial_reconnect_delay); - EXPECT_FALSE(mode.fdv1_fallback.has_value()); + EXPECT_TRUE( + std::holds_alternative(mode.fdv1_fallback)); } TEST(FDv2ConfigBuilderTest, CustomizingOneModeLeavesTheOthersAlone) { @@ -142,10 +143,10 @@ TEST(FDv2ConfigBuilderTest, TheFDv1FallbackIsConfigurable) { "https://relay.example.com"))); auto const config = BuildFDv2(std::move(builder)); - auto const& fallback = - config.modes.at(ConnectionMode::kStreaming).fdv1_fallback; + auto const* fallback = std::get_if( + &config.modes.at(ConnectionMode::kStreaming).fdv1_fallback); - ASSERT_TRUE(fallback.has_value()); + ASSERT_NE(nullptr, fallback); EXPECT_EQ(600s, fallback->poll_interval); ASSERT_TRUE(fallback->base_url_override.has_value()); EXPECT_EQ("https://relay.example.com", *fallback->base_url_override); diff --git a/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp b/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp index d86494bde..abd417748 100644 --- a/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp +++ b/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp @@ -161,8 +161,11 @@ class FDv2Builder { * Contains methods for configuring what one connection mode does, meaning * which sources load flag data and which keep it current. * - * A mode built this way replaces the SDK's built-in definition entirely, - * so it should list every source the mode needs, cache included. + * A mode built this way replaces the built-in initializers and + * synchronizers, so it should list every source it needs, cache included. + * + * The mode keeps the built-in FDv1 fallback. Call FDv1Fallback() to + * replace it, or DisableFDv1Fallback() to remove it. */ class Mode { public: diff --git a/libs/common/src/config/fdv2_builder.cpp b/libs/common/src/config/fdv2_builder.cpp index 92ddbe899..d39d23360 100644 --- a/libs/common/src/config/fdv2_builder.cpp +++ b/libs/common/src/config/fdv2_builder.cpp @@ -82,7 +82,7 @@ FDv2Builder::Mode& FDv2Builder::Mode::FDv1Fallback(FDv1Polling source) { } FDv2Builder::Mode& FDv2Builder::Mode::DisableFDv1Fallback() { - definition_.fdv1_fallback = std::nullopt; + definition_.fdv1_fallback = Config::NoFDv1Fallback{}; return *this; } From a36458ab454cd9d7bff36d488b81cad0d8a12870 Mon Sep 17 00:00:00 2001 From: Bee Klimt Date: Tue, 17 Nov 2026 18:54:12 -0800 Subject: [PATCH 7/9] refactor: Use the service endpoints for FDv2 instead of separate base URLs --- libs/client-sdk/src/client_impl.cpp | 2 - .../tests/fdv2_config_builder_test.cpp | 57 ------------------- .../shared/builders/endpoints_builder.hpp | 11 ---- libs/common/src/config/config_builder.cpp | 16 ------ libs/common/src/config/endpoints_builder.cpp | 6 -- 5 files changed, 92 deletions(-) diff --git a/libs/client-sdk/src/client_impl.cpp b/libs/client-sdk/src/client_impl.cpp index 1ce9c2b9b..eef022b7d 100644 --- a/libs/client-sdk/src/client_impl.cpp +++ b/libs/client-sdk/src/client_impl.cpp @@ -58,8 +58,6 @@ static std::shared_ptr MakeFDv2DataSource( data_sources::ModeSourceParams const params{ executor, logger, - fdv2.polling_base_url, - fdv2.streaming_base_url, http_properties, endpoints, context, diff --git a/libs/client-sdk/tests/fdv2_config_builder_test.cpp b/libs/client-sdk/tests/fdv2_config_builder_test.cpp index dc5ad1a34..f2e33058e 100644 --- a/libs/client-sdk/tests/fdv2_config_builder_test.cpp +++ b/libs/client-sdk/tests/fdv2_config_builder_test.cpp @@ -151,60 +151,3 @@ TEST(FDv2ConfigBuilderTest, TheFDv1FallbackIsConfigurable) { ASSERT_TRUE(fallback->base_url_override.has_value()); EXPECT_EQ("https://relay.example.com", *fallback->base_url_override); } - -// ============================================================================ -// Endpoint defaults -// ============================================================================ - -namespace { - -FDv2Config BuiltFDv2(ConfigBuilder& builder) { - auto config = builder.Build(); - EXPECT_TRUE(config.has_value()); - return std::get(config->DataSourceConfig().method); -} - -} // namespace - -// FDv2 polls a different endpoint than FDv1 does, so an application that -// configured nothing polls there rather than where FDv1 would. -TEST(FDv2ConfigBuilderTest, FDv2KeepsItsOwnDefaultEndpoints) { - auto builder = ConfigBuilder("sdk-key"); - builder.DataSource().Method(DataSourceBuilder::FDv2()); - - auto const fdv2 = BuiltFDv2(builder); - - EXPECT_EQ("https://sdk.launchdarkly.com", fdv2.polling_base_url); - EXPECT_EQ("https://clientstream.launchdarkly.com", fdv2.streaming_base_url); - EXPECT_NE(Defaults::ServiceEndpoints().PollingBaseUrl(), - fdv2.polling_base_url); -} - -// An application that pointed the SDK somewhere else -- a Relay Proxy, say -- -// has FDv2 follow it there. -TEST(FDv2ConfigBuilderTest, ConfiguredEndpointsRedirectFDv2) { - auto builder = ConfigBuilder("sdk-key"); - builder.DataSource().Method(DataSourceBuilder::FDv2()); - builder.ServiceEndpoints().RelayProxyBaseURL("https://relay.example.com"); - - auto const fdv2 = BuiltFDv2(builder); - - EXPECT_EQ("https://relay.example.com", fdv2.polling_base_url); - EXPECT_EQ("https://relay.example.com", fdv2.streaming_base_url); -} - -// Endpoints set to the SDK's own values are still the application's choice, -// and redirect FDv2 like any other. -TEST(FDv2ConfigBuilderTest, ConfiguringOnlyTheEventsUrlStillRedirectsFDv2) { - auto defaults = Defaults::ServiceEndpoints(); - auto builder = ConfigBuilder("sdk-key"); - builder.DataSource().Method(DataSourceBuilder::FDv2()); - builder.ServiceEndpoints() - .EventsBaseUrl("https://events.example.com") - .PollingBaseUrl(defaults.PollingBaseUrl()) - .StreamingBaseUrl(defaults.StreamingBaseUrl()); - - auto const fdv2 = BuiltFDv2(builder); - - EXPECT_EQ(defaults.PollingBaseUrl(), fdv2.polling_base_url); -} diff --git a/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp b/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp index 08ed386f6..d2e818f42 100644 --- a/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp +++ b/libs/common/include/launchdarkly/config/shared/builders/endpoints_builder.hpp @@ -14,9 +14,6 @@ namespace launchdarkly::config::shared::builders { template class EndpointsBuilder; -template -class ConfigBuilder; - template bool operator==(EndpointsBuilder const& lhs, EndpointsBuilder const& rhs); @@ -75,14 +72,6 @@ class EndpointsBuilder { [[nodiscard]] tl::expected Build() const; private: - friend class ConfigBuilder; - - /** - * Whether the application set any of these URLs, as opposed to accepting - * the SDK's defaults. - */ - [[nodiscard]] bool IsCustom() const; - std::optional polling_base_url_; std::optional streaming_base_url_; std::optional events_base_url_; diff --git a/libs/common/src/config/config_builder.cpp b/libs/common/src/config/config_builder.cpp index f59528c56..0c306cb1f 100644 --- a/libs/common/src/config/config_builder.cpp +++ b/libs/common/src/config/config_builder.cpp @@ -1,9 +1,6 @@ #include #include -#include -#include - namespace launchdarkly::config::shared::builders { template @@ -75,19 +72,6 @@ ConfigBuilder::Build() const { auto data_source_config = data_source_builder_.Build(); - if constexpr (std::is_same_v) { - // FDv2 polls a different endpoint than FDv1 does, so it keeps its own - // default until the application configures its own endpoints. Once it - // has, FDv2 follows them, so that pointing the SDK at a Relay Proxy - // redirects FDv2 too. - auto* fdv2 = - std::get_if>(&data_source_config.method); - if (fdv2 != nullptr && service_endpoints_builder_.IsCustom()) { - fdv2->polling_base_url = endpoints_config->PollingBaseUrl(); - fdv2->streaming_base_url = endpoints_config->StreamingBaseUrl(); - } - } - auto http_properties = http_properties_builder_.Build(); auto logging = logging_config_builder_.Build(); diff --git a/libs/common/src/config/endpoints_builder.cpp b/libs/common/src/config/endpoints_builder.cpp index 1b80cdad1..9701b195e 100644 --- a/libs/common/src/config/endpoints_builder.cpp +++ b/libs/common/src/config/endpoints_builder.cpp @@ -42,12 +42,6 @@ bool empty_string(std::optional const& opt_string) { return opt_string.has_value() && opt_string->empty(); } -template -bool EndpointsBuilder::IsCustom() const { - return polling_base_url_.has_value() || streaming_base_url_.has_value() || - events_base_url_.has_value(); -} - template tl::expected EndpointsBuilder::Build() const { From ff7c5a668a03cc817de142762d0bb0a34024b0d4 Mon Sep 17 00:00:00 2001 From: Bee Klimt Date: Tue, 17 Nov 2026 22:44:42 -0800 Subject: [PATCH 8/9] refactor: Select the client data source with std::visit, like the server --- libs/client-sdk/src/client_impl.cpp | 57 ++++++++++++++++++----------- 1 file changed, 36 insertions(+), 21 deletions(-) diff --git a/libs/client-sdk/src/client_impl.cpp b/libs/client-sdk/src/client_impl.cpp index eef022b7d..72942b70e 100644 --- a/libs/client-sdk/src/client_impl.cpp +++ b/libs/client-sdk/src/client_impl.cpp @@ -35,6 +35,17 @@ using launchdarkly::config::shared::built::HttpProperties; using FDv2Config = config::shared::built::FDv2Config; +namespace { + +template +struct overloaded : Ts... { + using Ts::operator()...; +}; +template +overloaded(Ts...) -> overloaded; + +} // namespace + static bool UsesFDv2(Config const& config) { return std::holds_alternative(config.DataSourceConfig().method); } @@ -42,12 +53,12 @@ static bool UsesFDv2(Config const& config) { static std::shared_ptr MakeFDv2DataSource( HttpProperties const& http_properties, Config const& config, + FDv2Config const& fdv2, Context const& context, boost::asio::any_io_executor const& executor, flag_manager::FlagManager& flag_manager, data_sources::DataSourceStatusManager& status_manager, Logger& logger) { - auto const& fdv2 = std::get(config.DataSourceConfig().method); auto const& endpoints = config.ServiceEndpoints(); if (config.DataSourceConfig().use_report) { @@ -94,26 +105,30 @@ static std::shared_ptr MakeDataSource( auto data_source_properties = builder.Build(); - if (UsesFDv2(config)) { - return MakeFDv2DataSource(data_source_properties, config, context, - executor, flag_manager, status_manager, - logger); - } - - if (std::holds_alternative< - config::shared::built::StreamingConfig>( - config.DataSourceConfig().method)) { - return std::make_shared< - launchdarkly::client_side::data_sources::StreamingDataSource>( - config.ServiceEndpoints(), config.DataSourceConfig(), - data_source_properties, executor, context, flag_manager.Updater(), - status_manager, logger); - } - return std::make_shared< - launchdarkly::client_side::data_sources::PollingDataSource>( - config.ServiceEndpoints(), config.DataSourceConfig(), - data_source_properties, executor, context, flag_manager.Updater(), - status_manager, logger); + return std::visit( + overloaded{ + [&](config::shared::built::StreamingConfig const&) + -> std::shared_ptr { + return std::make_shared( + config.ServiceEndpoints(), config.DataSourceConfig(), + data_source_properties, executor, context, + flag_manager.Updater(), status_manager, logger); + }, + [&](config::shared::built::PollingConfig const&) + -> std::shared_ptr { + return std::make_shared( + config.ServiceEndpoints(), config.DataSourceConfig(), + data_source_properties, executor, context, + flag_manager.Updater(), status_manager, logger); + }, + [&](FDv2Config const& fdv2) + -> std::shared_ptr { + return MakeFDv2DataSource(data_source_properties, config, fdv2, + context, executor, flag_manager, + status_manager, logger); + }, + }, + config.DataSourceConfig().method); } static Logger MakeLogger(config::shared::built::Logging const& config) { From 89b5562ab28cce5745b604344802b50b112da9cd Mon Sep 17 00:00:00 2001 From: Bee Klimt Date: Tue, 17 Nov 2026 23:02:45 -0800 Subject: [PATCH 9/9] refactor: Make the FDv2 builder a client specialization of a shared template --- .../include/launchdarkly/config/client.hpp | 2 +- .../shared/builders/data_source_builder.hpp | 2 +- .../config/shared/builders/fdv2_builder.hpp | 6 +- .../common/src/config/data_source_builder.cpp | 6 +- libs/common/src/config/fdv2_builder.cpp | 67 ++++++++++++------- 5 files changed, 53 insertions(+), 30 deletions(-) diff --git a/libs/common/include/launchdarkly/config/client.hpp b/libs/common/include/launchdarkly/config/client.hpp index f18c013bd..5fa1ffb6b 100644 --- a/libs/common/include/launchdarkly/config/client.hpp +++ b/libs/common/include/launchdarkly/config/client.hpp @@ -22,7 +22,7 @@ using EventsBuilder = config::shared::builders::EventsBuilder; using HttpPropertiesBuilder = config::shared::builders::HttpPropertiesBuilder; using DataSourceBuilder = config::shared::builders::DataSourceBuilder; -using FDv2Builder = config::shared::builders::FDv2Builder; +using FDv2Builder = config::shared::builders::FDv2Builder; using ConnectionMode = config::shared::ConnectionMode; using LoggingBuilder = config::shared::builders::LoggingBuilder; using PersistenceBuilder = config::shared::builders::PersistenceBuilder; diff --git a/libs/common/include/launchdarkly/config/shared/builders/data_source_builder.hpp b/libs/common/include/launchdarkly/config/shared/builders/data_source_builder.hpp index e2e6ce93f..dbcbd3d0c 100644 --- a/libs/common/include/launchdarkly/config/shared/builders/data_source_builder.hpp +++ b/libs/common/include/launchdarkly/config/shared/builders/data_source_builder.hpp @@ -135,7 +135,7 @@ class DataSourceBuilder { public: using Streaming = StreamingBuilder; using Polling = PollingBuilder; - using FDv2 = FDv2Builder; + using FDv2 = FDv2Builder; DataSourceBuilder(); diff --git a/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp b/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp index abd417748..a9a98b954 100644 --- a/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp +++ b/libs/common/include/launchdarkly/config/shared/builders/fdv2_builder.hpp @@ -10,6 +10,9 @@ namespace launchdarkly::config::shared::builders { +template +class FDv2Builder; + /** * Contains methods for configuring the FDv2 data system, which determines how * the SDK obtains flag data and how it keeps that data current. @@ -18,7 +21,8 @@ namespace launchdarkly::config::shared::builders { * application customizes nothing. It starts in streaming mode, and provides * streaming, polling, and offline modes. */ -class FDv2Builder { +template <> +class FDv2Builder { public: using Config = built::FDv2Config; diff --git a/libs/common/src/config/data_source_builder.cpp b/libs/common/src/config/data_source_builder.cpp index 4d1e846c6..79a60091d 100644 --- a/libs/common/src/config/data_source_builder.cpp +++ b/libs/common/src/config/data_source_builder.cpp @@ -20,7 +20,9 @@ struct MethodVisitor { return polling.Build(); } - Result operator()(FDv2Builder const& fdv2) const { return fdv2.Build(); } + Result operator()(FDv2Builder const& fdv2) const { + return fdv2.Build(); + } }; template @@ -83,7 +85,7 @@ DataSourceBuilder& DataSourceBuilder::Method( } DataSourceBuilder& DataSourceBuilder::Method( - FDv2Builder builder) { + FDv2Builder builder) { method_ = std::move(builder); return *this; } diff --git a/libs/common/src/config/fdv2_builder.cpp b/libs/common/src/config/fdv2_builder.cpp index d39d23360..ba21c158d 100644 --- a/libs/common/src/config/fdv2_builder.cpp +++ b/libs/common/src/config/fdv2_builder.cpp @@ -5,109 +5,126 @@ namespace launchdarkly::config::shared::builders { -FDv2Builder::Config::CacheConfig FDv2Builder::Cache::Build() const { +FDv2Builder::Config::CacheConfig +FDv2Builder::Cache::Build() const { return {}; } -FDv2Builder::Streaming& FDv2Builder::Streaming::InitialReconnectDelay( +FDv2Builder::Streaming& +FDv2Builder::Streaming::InitialReconnectDelay( std::chrono::milliseconds delay) { initial_reconnect_delay_ = delay; return *this; } -FDv2Builder::Streaming& FDv2Builder::Streaming::BaseUrl(std::string base_url) { +FDv2Builder::Streaming& FDv2Builder::Streaming::BaseUrl( + std::string base_url) { base_url_override_ = std::move(base_url); return *this; } -FDv2Builder::Config::StreamingConfig FDv2Builder::Streaming::Build() const { +FDv2Builder::Config::StreamingConfig +FDv2Builder::Streaming::Build() const { return {initial_reconnect_delay_, base_url_override_}; } -FDv2Builder::Polling& FDv2Builder::Polling::PollInterval( +FDv2Builder::Polling& FDv2Builder::Polling::PollInterval( std::chrono::seconds interval) { poll_interval_ = interval; return *this; } -FDv2Builder::Polling& FDv2Builder::Polling::BaseUrl(std::string base_url) { +FDv2Builder::Polling& FDv2Builder::Polling::BaseUrl( + std::string base_url) { base_url_override_ = std::move(base_url); return *this; } -FDv2Builder::Config::PollingConfig FDv2Builder::Polling::Build() const { +FDv2Builder::Config::PollingConfig +FDv2Builder::Polling::Build() const { return {poll_interval_, base_url_override_}; } -FDv2Builder::FDv1Polling& FDv2Builder::FDv1Polling::PollInterval( - std::chrono::seconds interval) { +FDv2Builder::FDv1Polling& FDv2Builder< + ClientSDK>::FDv1Polling::PollInterval(std::chrono::seconds interval) { poll_interval_ = interval; return *this; } -FDv2Builder::FDv1Polling& FDv2Builder::FDv1Polling::BaseUrl( - std::string base_url) { +FDv2Builder::FDv1Polling& +FDv2Builder::FDv1Polling::BaseUrl(std::string base_url) { base_url_override_ = std::move(base_url); return *this; } -FDv2Builder::Config::FDv1FallbackConfig FDv2Builder::FDv1Polling::Build() - const { +FDv2Builder::Config::FDv1FallbackConfig +FDv2Builder::FDv1Polling::Build() const { return {poll_interval_, base_url_override_}; } -FDv2Builder::Mode& FDv2Builder::Mode::Initializer(Cache source) { +FDv2Builder::Mode& FDv2Builder::Mode::Initializer( + Cache source) { definition_.initializers.emplace_back(source.Build()); return *this; } -FDv2Builder::Mode& FDv2Builder::Mode::Initializer(Polling source) { +FDv2Builder::Mode& FDv2Builder::Mode::Initializer( + Polling source) { definition_.initializers.emplace_back(source.Build()); return *this; } -FDv2Builder::Mode& FDv2Builder::Mode::Synchronizer(Streaming source) { +FDv2Builder::Mode& FDv2Builder::Mode::Synchronizer( + Streaming source) { definition_.synchronizers.emplace_back(source.Build()); return *this; } -FDv2Builder::Mode& FDv2Builder::Mode::Synchronizer(Polling source) { +FDv2Builder::Mode& FDv2Builder::Mode::Synchronizer( + Polling source) { definition_.synchronizers.emplace_back(source.Build()); return *this; } -FDv2Builder::Mode& FDv2Builder::Mode::FDv1Fallback(FDv1Polling source) { +FDv2Builder::Mode& FDv2Builder::Mode::FDv1Fallback( + FDv1Polling source) { definition_.fdv1_fallback = source.Build(); return *this; } -FDv2Builder::Mode& FDv2Builder::Mode::DisableFDv1Fallback() { +FDv2Builder::Mode& +FDv2Builder::Mode::DisableFDv1Fallback() { definition_.fdv1_fallback = Config::NoFDv1Fallback{}; return *this; } -FDv2Builder::Config::ModeDefinition FDv2Builder::Mode::Build() const { +FDv2Builder::Config::ModeDefinition +FDv2Builder::Mode::Build() const { return definition_; } -FDv2Builder::FDv2Builder() : config_(Defaults::FDv2Config()) {} +FDv2Builder::FDv2Builder() + : config_(Defaults::FDv2Config()) {} -FDv2Builder& FDv2Builder::InitialMode(ConnectionMode mode) { +FDv2Builder& FDv2Builder::InitialMode( + ConnectionMode mode) { config_.initial_mode = mode; return *this; } -FDv2Builder& FDv2Builder::CustomizeMode(ConnectionMode mode, Mode definition) { +FDv2Builder& FDv2Builder::CustomizeMode( + ConnectionMode mode, + Mode definition) { config_.modes[mode] = definition.Build(); return *this; } -FDv2Builder& FDv2Builder::UsePost(bool use_post) { +FDv2Builder& FDv2Builder::UsePost(bool use_post) { config_.use_post = use_post; return *this; } -FDv2Builder::Config FDv2Builder::Build() const { +FDv2Builder::Config FDv2Builder::Build() const { return config_; }