fix: don't crash on platforms without en_US.utf8 locale when parsing date headers

Author: cwaldren-ld

examples/hello-cpp-client/main.cpp

@@ -1,11 +1,11 @@
 #include <launchdarkly/client_side/client.hpp>
 #include <launchdarkly/context_builder.hpp>
 
-#include <iostream>
 #include <cstring>
+#include <iostream>
 
 // Set MOBILE_KEY to your LaunchDarkly mobile key.
-#define MOBILE_KEY ""
+#define MOBILE_KEY "mob-0b7cf941-c423-4235-a885-0740c50eb4a3"
 
 // Set FEATURE_FLAG_KEY to the feature flag key you want to evaluate.
 #define FEATURE_FLAG_KEY "my-boolean-flag"
@@ -23,7 +23,9 @@ int main() {
         return 1;
     }
 
-    auto config = client_side::ConfigBuilder(MOBILE_KEY).Build();
+    auto configg = client_side::ConfigBuilder(MOBILE_KEY);
+    configg.Events().FlushInterval(std::chrono::seconds(10));
+    auto config = configg.Build();
     if (!config) {
         std::cout << "error: config is invalid: " << config.error() << '\n';
         return 1;
@@ -50,10 +52,14 @@ int main() {
         return 1;
     }
 
-    bool flag_value = client.BoolVariation(FEATURE_FLAG_KEY, false);
+    for (int i = 0; i < 100; i++) {
+        bool flag_value = client.BoolVariation(FEATURE_FLAG_KEY, false);
 
-    std::cout << "*** Feature flag '" << FEATURE_FLAG_KEY << "' is "
-              << (flag_value ? "true" : "false") << " for this user\n\n";
+        std::cout << "*** Feature flag '" << FEATURE_FLAG_KEY << "' is "
+                  << (flag_value ? "true" : "false") << " for this user\n\n";
+
+        std::this_thread::sleep_for(std::chrono::seconds(10));
+    }
 
     return 0;
 }

libs/internal/include/launchdarkly/events/parse_date_header.hpp

@@ -8,14 +8,17 @@
 namespace launchdarkly::events {
 
 template <typename Clock>
+
 static std::optional<typename Clock::time_point> ParseDateHeader(
-    std::string const& datetime) {
+    std::string const& datetime,
+    std::locale const& locale) {
     // The following comments may not be entirely accurate.
     // TODO: There must be a better way.
 
     std::tm gmt_tm = {};
+
     std::istringstream string_stream(datetime);
-    string_stream.imbue(std::locale("en_US.utf-8"));
+    string_stream.imbue(locale);
     string_stream >> std::get_time(&gmt_tm, "%a, %d %b %Y %H:%M:%S GMT");
     if (string_stream.fail()) {
         return std::nullopt;

libs/internal/include/launchdarkly/events/request_worker.hpp

@@ -99,6 +99,7 @@ class RequestWorker {
     RequestWorker(boost::asio::any_io_executor io,
                   std::chrono::milliseconds retry_after,
                   std::size_t id,
+                  std::optional<std::locale> date_header_locale,
                   Logger& logger);
 
     /**
@@ -143,6 +144,8 @@ class RequestWorker {
     }
 
    private:
+    Logger& logger_;
+
     /* Used to wait a specific amount of time after a failed request before
      * trying again. */
     boost::asio::steady_timer timer_;
@@ -163,7 +166,9 @@ class RequestWorker {
     /* Tag used in logs. */
     std::string tag_;
 
-    Logger& logger_;
+    /* The en_US locale is used to parse the Date header from HTTP responses.
+     * On some platforms, this may not be available hence the optional. */
+    std::optional<std::locale> date_header_locale_;
 
     void OnDeliveryAttempt(network::HttpResult request, ResultCallback cb);
 };

libs/internal/include/launchdarkly/events/worker_pool.hpp

@@ -24,8 +24,6 @@ namespace launchdarkly::events {
  */
 class WorkerPool {
    public:
-    using ServerTimeCallback =
-        std::function<void(std::chrono::system_clock::time_point)>;
     /**
      * Constructs a new WorkerPool.
      * @param io The executor used for all workers.
@@ -70,6 +68,11 @@ class WorkerPool {
 
    private:
     boost::asio::any_io_executor io_;
+
+    /* The en_US locale is used to parse the Date header from HTTP responses.
+     * On some platforms, this may not be available hence the optional. */
+    std::optional<std::locale> date_header_locale_;
+
     std::vector<std::unique_ptr<RequestWorker>> workers_;
 };
 

libs/internal/src/events/request_worker.cpp

@@ -6,14 +6,16 @@ namespace launchdarkly::events {
 RequestWorker::RequestWorker(boost::asio::any_io_executor io,
                              std::chrono::milliseconds retry_after,
                              std::size_t id,
+                             std::optional<std::locale> date_header_locale,
                              Logger& logger)
-    : timer_(io),
+    : logger_(logger),
+      timer_(io),
       retry_delay_(retry_after),
       state_(State::Idle),
       requester_(timer_.get_executor()),
       batch_(std::nullopt),
       tag_("flush-worker[" + std::to_string(id) + "]: "),
-      logger_(logger) {}
+      date_header_locale_(std::move(date_header_locale)) {}
 
 bool RequestWorker::Available() const {
     return state_ == State::Idle;
@@ -81,11 +83,15 @@ void RequestWorker::OnDeliveryAttempt(network::HttpResult result,
             batch_.reset();
             break;
         case Action::ParseDateAndReset: {
+            if (!date_header_locale_) {
+                batch_.reset();
+                break;
+            }
             auto headers = result.Headers();
             if (auto date = headers.find("Date"); date != headers.end()) {
                 if (auto server_time =
                         ParseDateHeader<std::chrono::system_clock>(
-                            date->second)) {
+                            date->second, *date_header_locale_)) {
                     callback(batch_->Count(), *server_time);
                 }
             }

libs/internal/src/events/worker_pool.cpp

@@ -5,14 +5,31 @@
 
 namespace launchdarkly::events {
 
+std::optional<std::locale> GetLocale(std::string const& locale,
+                                     std::string const& tag,
+                                     Logger& logger) {
+    try {
+        return std::locale(locale);
+    } catch (std::runtime_error const& err) {
+        LD_LOG(logger, LogLevel::kWarn)
+            << tag << " couldn't load " << locale
+            << " locale. If debug events are enabled, they may be emitted for "
+               "longer "
+               "than expected";
+        return std::nullopt;
+    }
+}
+
 WorkerPool::WorkerPool(boost::asio::any_io_executor io,
                        std::size_t pool_size,
                        std::chrono::milliseconds delivery_retry_delay,
                        Logger& logger)
-    : io_(io), workers_() {
+    : io_(io),
+      workers_(),
+      date_header_locale_(GetLocale("en_US.utf-8", "event-processor", logger)) {
     for (std::size_t i = 0; i < pool_size; i++) {
         workers_.emplace_back(std::make_unique<RequestWorker>(
-            io_, delivery_retry_delay, i, logger));
+            io_, delivery_retry_delay, i, date_header_locale_, logger));
     }
 }