feat: Include version in user-agent. (#98)

Author: kinyoklion

libs/client-sdk/src/client.cpp

@@ -6,7 +6,8 @@ namespace launchdarkly::client_side {
 
 Client::Client(Config config, Context context)
     : client(std::make_unique<ClientImpl>(std::move(config),
-                                          std::move(context))) {}
+                                          std::move(context),
+                                          kVersion)) {}
 bool Client::Initialized() const {
     return false;
 }

libs/client-sdk/src/client_impl.cpp

@@ -19,16 +19,22 @@
 namespace launchdarkly::client_side {
 
 // The ASIO implementation assumes that the io_context will be run from a
-// single thread, and applies several optimisations based on this assumption.
+// single thread, and applies several optimisations based on this
+// assumption.
 auto const kAsioConcurrencyHint = 1;
 
 // Client's destructor attempts to gracefully shut down the datasource
 // connection in this amount of time.
 auto const kDataSourceShutdownWait = std::chrono::milliseconds(100);
 
+using config::shared::ClientSDK;
 using launchdarkly::client_side::data_sources::DataSourceStatus;
+using launchdarkly::config::shared::built::DataSourceConfig;
+using launchdarkly::config::shared::built::HttpProperties;
 
 static std::shared_ptr<IDataSource> MakeDataSource(
+    HttpProperties const& http_properties,
+    std::optional<std::string> app_tags,
     Config const& config,
     Context const& context,
     boost::asio::any_io_executor const& executor,
@@ -39,15 +45,29 @@ static std::shared_ptr<IDataSource> MakeDataSource(
         return std::make_shared<data_sources::NullDataSource>(executor,
                                                               status_manager);
     }
+
+    auto builder = HttpPropertiesBuilder(http_properties);
+
+    // Event sources should include application tags.
+    if (app_tags) {
+        builder.Header("x-launchdarkly-tags", *app_tags);
+    }
+
+    auto data_source_properties = builder.Build();
+
     if (config.DataSourceConfig().method.index() == 0) {
         // TODO: use initial reconnect delay.
         return std::make_shared<
             launchdarkly::client_side::data_sources::StreamingDataSource>(
-            config, executor, context, flag_updater, status_manager, logger);
+            config.ServiceEndpoints(), config.DataSourceConfig(),
+            data_source_properties, executor, context, flag_updater,
+            status_manager, logger);
     }
     return std::make_shared<
         launchdarkly::client_side::data_sources::PollingDataSource>(
-        config, executor, context, flag_updater, status_manager, logger);
+        config.ServiceEndpoints(), config.DataSourceConfig(),
+        data_source_properties, executor, context, flag_updater, status_manager,
+        logger);
 }
 
 static Logger MakeLogger(config::shared::built::Logging const& config) {
@@ -69,8 +89,14 @@ static std::shared_ptr<IPersistence> MakePersistence(Config const& config) {
     return persistence.implementation;
 }
 
-ClientImpl::ClientImpl(Config config, Context context)
+ClientImpl::ClientImpl(Config config,
+                       Context context,
+                       std::string const& version)
     : config_(config),
+      http_properties_(HttpPropertiesBuilder(config.HttpProperties())
+                           .Header("user-agent", "CPPClient/" + version)
+                           .Header("authorization", config.SdkKey())
+                           .Build()),
       logger_(MakeLogger(config.Logging())),
       ioc_(kAsioConcurrencyHint),
       context_(std::move(context)),
@@ -79,7 +105,8 @@ ClientImpl::ClientImpl(Config config, Context context)
                     config.Persistence().max_contexts_,
                     MakePersistence(config)),
       data_source_factory_([this]() {
-          return MakeDataSource(config_, context_, ioc_.get_executor(),
+          return MakeDataSource(http_properties_, config_.ApplicationTag(),
+                                config_, context_, ioc_.get_executor(),
                                 flag_manager_.Updater(), status_manager_,
                                 logger_);
       }),
@@ -90,8 +117,9 @@ ClientImpl::ClientImpl(Config config, Context context)
     flag_manager_.LoadCache(context_);
 
     if (config.Events().Enabled() && !config.Offline()) {
-        event_processor_ = std::make_unique<EventProcessor>(ioc_.get_executor(),
-                                                            config, logger_);
+        event_processor_ = std::make_unique<EventProcessor>(
+            ioc_.get_executor(), config.ServiceEndpoints(), config.Events(),
+            http_properties_, logger_);
     } else {
         event_processor_ = std::make_unique<NullEventProcessor>();
     }
@@ -181,8 +209,8 @@ std::future<void> ClientImpl::IdentifyAsync(Context context) {
     return fut;
 }
 
-// TODO(cwaldren): refactor VariationInternal so it isn't so long and mixing up
-// multiple concerns.
+// TODO(cwaldren): refactor VariationInternal so it isn't so long and mixing
+// up multiple concerns.
 template <typename T>
 EvaluationDetail<T> ClientImpl::VariationInternal(FlagKey const& key,
                                                   Value default_value,

libs/client-sdk/src/client_impl.hpp

@@ -29,7 +29,7 @@
 namespace launchdarkly::client_side {
 class ClientImpl : public IClient {
    public:
-    ClientImpl(Config config, Context context);
+    ClientImpl(Config config, Context context, std::string const& version);
 
     ClientImpl(ClientImpl&&) = delete;
     ClientImpl(ClientImpl const&) = delete;
@@ -87,7 +87,7 @@ class ClientImpl : public IClient {
 
     void WaitForReadySync(std::chrono::milliseconds timeout) override;
 
-    ~ClientImpl();
+    ~ClientImpl() override;
 
    private:
     template <typename T>
@@ -110,6 +110,7 @@ class ClientImpl : public IClient {
 
     Logger logger_;
     Config config_;
+    launchdarkly::config::shared::built::HttpProperties http_properties_;
 
     boost::asio::io_context ioc_;
 

libs/client-sdk/src/data_sources/polling_data_source.cpp

@@ -15,15 +15,17 @@ namespace launchdarkly::client_side::data_sources {
 static char const* const kCouldNotParseEndpoint =
     "Could not parse polling endpoint URL.";
 
-static network::HttpRequest MakeRequest(Config const& config,
-                                        Context const& context) {
-    auto url = std::make_optional(config.ServiceEndpoints().PollingBaseUrl());
-
-    auto const& data_source_config = config.DataSourceConfig();
+static network::HttpRequest MakeRequest(
+    config::shared::built::ServiceEndpoints const& endpoints,
+    config::shared::built::DataSourceConfig<config::shared::ClientSDK>
+        data_source_config,
+    config::shared::built::HttpProperties const& http_properties,
+    Context const& context) {
+    auto url = std::make_optional(endpoints.PollingBaseUrl());
 
     auto const& polling_config = std::get<
         config::shared::built::PollingConfig<config::shared::ClientSDK>>(
-        config.DataSourceConfig().method);
+        data_source_config.method);
 
     auto string_context =
         boost::json::serialize(boost::json::value_from(context));
@@ -54,24 +56,22 @@ static network::HttpRequest MakeRequest(Config const& config,
     }
 
     config::shared::builders::HttpPropertiesBuilder<config::shared::ClientSDK>
-        builder(config.HttpProperties());
-
-    builder.Header("authorization", config.SdkKey());
-
-    if (auto app_tag = config.ApplicationTag()) {
-        builder.Header("x-launchdarkly-tags", *app_tag);
-    }
+        builder(http_properties);
 
     // If no URL is set, then we will fail the request.
     return {url.value_or(""), method, builder.Build(), body};
 }
 
-PollingDataSource::PollingDataSource(Config const& config,
-                                     boost::asio::any_io_executor ioc,
-                                     Context const& context,
-                                     IDataSourceUpdateSink& handler,
-                                     DataSourceStatusManager& status_manager,
-                                     Logger const& logger)
+PollingDataSource::PollingDataSource(
+    config::shared::built::ServiceEndpoints const& endpoints,
+    config::shared::built::DataSourceConfig<config::shared::ClientSDK> const&
+        data_source_config,
+    config::shared::built::HttpProperties const& http_properties,
+    boost::asio::any_io_executor ioc,
+    Context const& context,
+    IDataSourceUpdateSink& handler,
+    DataSourceStatusManager& status_manager,
+    Logger const& logger)
     : ioc_(ioc),
       logger_(logger),
       status_manager_(status_manager),
@@ -82,12 +82,15 @@ PollingDataSource::PollingDataSource(Config const& config,
       polling_interval_(
           std::get<
               config::shared::built::PollingConfig<config::shared::ClientSDK>>(
-              config.DataSourceConfig().method)
+              data_source_config.method)
               .poll_interval),
-      request_(MakeRequest(config, context)) {
+      request_(MakeRequest(endpoints,
+                           data_source_config,
+                           http_properties,
+                           context)) {
     auto const& polling_config = std::get<
         config::shared::built::PollingConfig<config::shared::ClientSDK>>(
-        config.DataSourceConfig().method);
+        data_source_config.method);
     if (polling_interval_ < polling_config.min_polling_interval) {
         LD_LOG(logger_, LogLevel::kWarn)
             << "Polling interval specified under minimum, defaulting to 30 "

libs/client-sdk/src/data_sources/polling_data_source.hpp

@@ -9,8 +9,9 @@
 #include "data_source_status_manager.hpp"
 #include "data_source_update_sink.hpp"
 
-#include <launchdarkly/config/client.hpp>
+#include <launchdarkly/config/shared/built/data_source_config.hpp>
 #include <launchdarkly/config/shared/built/http_properties.hpp>
+#include <launchdarkly/config/shared/built/service_endpoints.hpp>
 #include <launchdarkly/logging/logger.hpp>
 #include <launchdarkly/network/asio_requester.hpp>
 
@@ -20,12 +21,16 @@ class PollingDataSource
     : public IDataSource,
       public std::enable_shared_from_this<PollingDataSource> {
    public:
-    PollingDataSource(Config const& config,
-                      boost::asio::any_io_executor ioc,
-                      Context const& context,
-                      IDataSourceUpdateSink& handler,
-                      DataSourceStatusManager& status_manager,
-                      Logger const& logger);
+    PollingDataSource(
+        config::shared::built::ServiceEndpoints const& endpoints,
+        config::shared::built::DataSourceConfig<
+            config::shared::ClientSDK> const& data_source_config,
+        config::shared::built::HttpProperties const& http_properties,
+        boost::asio::any_io_executor ioc,
+        Context const& context,
+        IDataSourceUpdateSink& handler,
+        DataSourceStatusManager& status_manager,
+        Logger const& logger);
 
     void Start() override;
     void ShutdownAsync(std::function<void()>) override;

libs/client-sdk/src/data_sources/streaming_data_source.cpp

@@ -19,7 +19,10 @@ static char const* const kCouldNotParseEndpoint =
     "Could not parse streaming endpoint URL.";
 
 StreamingDataSource::StreamingDataSource(
-    Config const& config,
+    config::shared::built::ServiceEndpoints const& endpoints,
+    config::shared::built::DataSourceConfig<config::shared::ClientSDK> const&
+        data_source_config,
+    config::shared::built::HttpProperties const& http_properties,
     boost::asio::any_io_executor ioc,
     Context context,
     IDataSourceUpdateSink& handler,
@@ -31,11 +34,9 @@ StreamingDataSource::StreamingDataSource(
       status_manager_(status_manager),
       data_source_handler_(
           DataSourceEventHandler(context_, handler, logger, status_manager_)),
-      http_config_(config.HttpProperties()),
-      data_source_config_(config.DataSourceConfig()),
-      app_tags_(config.ApplicationTag()),
-      sdk_key_(config.SdkKey()),
-      streaming_endpoint_(config.ServiceEndpoints().StreamingBaseUrl()) {}
+      http_config_(http_properties),
+      data_source_config_(data_source_config),
+      streaming_endpoint_(endpoints.StreamingBaseUrl()) {}
 
 void StreamingDataSource::Start() {
     status_manager_.SetState(DataSourceStatus::DataSourceState::kInitializing);
@@ -104,15 +105,9 @@ void StreamingDataSource::Start() {
 
     client_builder.connect_timeout(http_config_.ConnectTimeout());
 
-    client_builder.header("authorization", sdk_key_);
     for (auto const& header : http_config_.BaseHeaders()) {
         client_builder.header(header.first, header.second);
     }
-    client_builder.header("user-agent", http_config_.UserAgent());
-
-    if (app_tags_) {
-        client_builder.header("x-launchdarkly-tags", *app_tags_);
-    }
 
     // TODO: Handle proxy support.
 

libs/client-sdk/src/data_sources/streaming_data_source.hpp

@@ -9,8 +9,9 @@ using namespace std::chrono_literals;
 #include "data_source_event_handler.hpp"
 #include "data_source_status_manager.hpp"
 #include "data_source_update_sink.hpp"
+#include "launchdarkly/config/shared/sdks.hpp"
 
-#include <launchdarkly/config/client.hpp>
+#include <launchdarkly/config/shared/built/data_source_config.hpp>
 #include <launchdarkly/config/shared/built/http_properties.hpp>
 #include <launchdarkly/config/shared/built/service_endpoints.hpp>
 #include <launchdarkly/context.hpp>
@@ -24,12 +25,16 @@ class StreamingDataSource final
     : public IDataSource,
       public std::enable_shared_from_this<StreamingDataSource> {
    public:
-    StreamingDataSource(Config const& config,
-                        boost::asio::any_io_executor ioc,
-                        Context context,
-                        IDataSourceUpdateSink& handler,
-                        DataSourceStatusManager& status_manager,
-                        Logger const& logger);
+    StreamingDataSource(
+        config::shared::built::ServiceEndpoints const& endpoints,
+        config::shared::built::DataSourceConfig<
+            config::shared::ClientSDK> const& data_source_config,
+        config::shared::built::HttpProperties const& http_properties,
+        boost::asio::any_io_executor ioc,
+        Context context,
+        IDataSourceUpdateSink& handler,
+        DataSourceStatusManager& status_manager,
+        Logger const& logger);
 
     void Start() override;
     void ShutdownAsync(std::function<void()>) override;
@@ -47,10 +52,6 @@ class StreamingDataSource final
 
     config::shared::built::HttpProperties http_config_;
 
-    std::optional<std::string> app_tags_;
-
-    std::string sdk_key_;
-
     Logger const& logger_;
     std::shared_ptr<launchdarkly::sse::Client> client_;
 };

libs/client-sdk/src/event_processor/event_processor.cpp

@@ -2,10 +2,13 @@
 
 namespace launchdarkly::client_side {
 
-EventProcessor::EventProcessor(boost::asio::any_io_executor const& io,
-                               Config const& config,
-                               Logger& logger)
-    : impl_(io, config, logger) {}
+EventProcessor::EventProcessor(
+    boost::asio::any_io_executor const& io,
+    config::shared::built::ServiceEndpoints const& endpoints,
+    config::shared::built::Events const& events_config,
+    config::shared::built::HttpProperties const& http_properties,
+    Logger& logger)
+    : impl_(io, endpoints, events_config, http_properties, logger) {}
 
 void EventProcessor::SendAsync(events::InputEvent event) {
     impl_.AsyncSend(std::move(event));

libs/client-sdk/src/event_processor/event_processor.hpp

@@ -14,7 +14,9 @@ namespace launchdarkly::client_side {
 class EventProcessor : public IEventProcessor {
    public:
     EventProcessor(boost::asio::any_io_executor const& io,
-                   Config const& config,
+                   config::shared::built::ServiceEndpoints const& endpoints,
+                   config::shared::built::Events const& events_config,
+                   config::shared::built::HttpProperties const& http_properties,
                    Logger& logger);
     void SendAsync(events::InputEvent event) override;
     void FlushAsync() override;

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

@@ -129,7 +129,6 @@ class HttpPropertiesBuilder {
     std::string wrapper_name_;
     std::string wrapper_version_;
     std::map<std::string, std::string> base_headers_;
-    std::string user_agent_;
 };
 
 }  // namespace launchdarkly::config::shared::builders