Merge branch 'devin/1773359647-lazy-load-initialized-warning' into rlamb/persistence-contract-tests

Author: devin-ai-integration[bot]

.github/actions/install-boost/action.yml

@@ -43,8 +43,8 @@ runs:
       if: runner.os == 'macOS'
       shell: bash
       run: |
-        brew install boost@1.85
-        echo "BOOST_ROOT=$(brew --prefix boost@1.85)" >> $GITHUB_OUTPUT
+        brew install boost
+        echo "BOOST_ROOT=$(brew --prefix boost)" >> $GITHUB_OUTPUT
 
     - name: Determine root
       id: determine-root

libs/server-sdk/src/client_impl.cpp

@@ -186,11 +186,19 @@ AllFlagsState ClientImpl::AllFlagsState(Context const& context,
     std::unordered_map<Client::FlagKey, Value> result;
 
     if (!Initialized()) {
-        LD_LOG(logger_, LogLevel::kWarn)
-            << "AllFlagsState() called before client has finished "
-               "initializing. Data source not available. Returning empty state";
+        if (data_system_->CanEvaluateWhenNotInitialized()) {
+            LD_LOG(logger_, LogLevel::kWarn)
+                << "AllFlagsState() called before LaunchDarkly client "
+                   "initialization completed; using last known values "
+                   "from data store";
+        } else {
+            LD_LOG(logger_, LogLevel::kWarn)
+                << "AllFlagsState() called before client has finished "
+                   "initializing. Data source not available. Returning "
+                   "empty state";
 
-        return {};
+            return {};
+        }
     }
 
     AllFlagsStateBuilder builder{options};
@@ -418,7 +426,16 @@ EvaluationDetail<Value> ClientImpl::VariationInternal(
 std::optional<enum EvaluationReason::ErrorKind> ClientImpl::PreEvaluationChecks(
     Context const& context) const {
     if (!Initialized()) {
-        return EvaluationReason::ErrorKind::kClientNotReady;
+        if (data_system_->CanEvaluateWhenNotInitialized()) {
+            LD_LOG(logger_, LogLevel::kWarn)
+                << "Evaluation called before LaunchDarkly client "
+                   "initialization completed; using last known values "
+                   "from data store. The $inited key was not found in "
+                   "the store; typically a Relay Proxy or other SDK "
+                   "should set this key.";
+        } else {
+            return EvaluationReason::ErrorKind::kClientNotReady;
+        }
     }
     if (!context.Valid()) {
         return EvaluationReason::ErrorKind::kUserNotSpecified;

libs/server-sdk/src/data_interfaces/system/idata_system.hpp

@@ -21,6 +21,22 @@ class IDataSystem : public IStore {
      */
     virtual void Initialize() = 0;
 
+    /**
+     * @brief Returns true if the data system is capable of serving
+     * flag evaluations even when Initialized() returns false.
+     *
+     * This is the case for Lazy Load (daemon mode), where data can be
+     * fetched on-demand from the persistent store regardless of whether
+     * the $inited key has been set. In contrast, Background Sync
+     * cannot serve evaluations until initial data is received.
+     *
+     * When this returns true, the evaluation path should log a warning
+     * (rather than returning CLIENT_NOT_READY) if Initialized() is false.
+     */
+    [[nodiscard]] virtual bool CanEvaluateWhenNotInitialized() const {
+        return false;
+    }
+
     virtual ~IDataSystem() override = default;
     IDataSystem(IDataSystem const& item) = delete;
     IDataSystem(IDataSystem&& item) = delete;

libs/server-sdk/src/data_systems/lazy_load/lazy_load_system.hpp

@@ -58,6 +58,10 @@ class LazyLoad final : public data_interfaces::IDataSystem {
 
     bool Initialized() const override;
 
+    [[nodiscard]] bool CanEvaluateWhenNotInitialized() const override {
+        return true;
+    }
+
     // Public for usage in tests.
     struct Kinds {
         static integrations::FlagKind const Flag;

libs/server-sdk/tests/lazy_load_system_test.cpp

@@ -338,3 +338,15 @@ TEST_F(LazyLoadTest, InitializeCalledAgainAfterTTL) {
         ASSERT_TRUE(lazy_load.Initialized());
     }
 }
+
+TEST_F(LazyLoadTest, CanEvaluateWhenNotInitialized) {
+    built::LazyLoadConfig const config{
+        built::LazyLoadConfig::EvictionPolicy::Disabled,
+        std::chrono::seconds(10), mock_reader};
+
+    data_systems::LazyLoad const lazy_load(logger, config, status_manager);
+
+    // LazyLoad can always serve evaluations on demand, even if not
+    // initialized (i.e. $inited key not found in store).
+    ASSERT_TRUE(lazy_load.CanEvaluateWhenNotInitialized());
+}

vendor/foxy/include/foxy/detail/export_connect_fields.hpp

@@ -18,6 +18,7 @@
 
 #include <boost/utility/string_view.hpp>
 #include <boost/range/algorithm.hpp>
+#include <boost/version.hpp>
 
 #include <type_traits>
 #include <array>
@@ -88,6 +89,18 @@ launchdarkly::foxy::detail::export_connect_fields(boost::beast::http::basic_fiel
   // iterate the `src` fields, moving any connect headers and the corresponding tokens to the `dst`
   // fields
   //
+  // Boost 1.90 removed proxy_authentication_info, proxy_features, and
+  // proxy_instruction from boost::beast::http::field.
+#if BOOST_VERSION >= 109000
+  auto const hop_by_hops = std::array<http::field, 8>{http::field::connection,
+                                                      http::field::keep_alive,
+                                                      http::field::proxy_authenticate,
+                                                      http::field::proxy_authorization,
+                                                      http::field::proxy_connection,
+                                                      http::field::te,
+                                                      http::field::trailer,
+                                                      http::field::transfer_encoding};
+#else
   auto const hop_by_hops = std::array<http::field, 11>{http::field::connection,
                                                        http::field::keep_alive,
                                                        http::field::proxy_authenticate,
@@ -99,6 +112,7 @@ launchdarkly::foxy::detail::export_connect_fields(boost::beast::http::basic_fiel
                                                        http::field::te,
                                                        http::field::trailer,
                                                        http::field::transfer_encoding};
+#endif
 
   auto const is_connect_opt =
     [&connect_opts,