fix: allow lazy load evaluations when $inited key is not set

In lazy load / daemon mode, the SDK's Initialized() check was blocking
all flag evaluations when the $inited key was not found in the
persistent store. This is problematic because in daemon mode, an
external process (like Relay Proxy) populates the store, and the
$inited key may not always be present.

The fix changes LazyLoad::Initialized() to always return true,
allowing evaluations to proceed using available data. When the
underlying source reports not initialized ($inited key not found),
a warning is logged to alert operators that a Relay Proxy or other
SDK should set this key.

This aligns with the Go SDK behavior where daemon mode
(ExternalUpdatesOnly) always considers the data source initialized.

Updated unit tests to reflect the new behavior and added tests
verifying the warning is logged appropriately.

Co-Authored-By: rlamb@launchdarkly.com <kingdewman@gmail.com>

Author: devin-ai-integration[bot]

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

@@ -79,9 +79,12 @@ std::string const& LazyLoad::Identity() const {
 
 void LazyLoad::Initialize() {
     status_manager_.SetState(DataSourceState::kInitializing);
-    if (Initialized()) {
-        status_manager_.SetState(DataSourceState::kValid);
-    }
+    // In lazy load mode, we always consider the system ready for
+    // evaluations. The Initialized() call here will log a warning if
+    // the underlying source reports not initialized (e.g. $inited key
+    // not found), but we proceed regardless.
+    Initialized();
+    status_manager_.SetState(DataSourceState::kValid);
 }
 
 std::shared_ptr<data_model::FlagDescriptor> LazyLoad::GetFlag(
@@ -121,25 +124,35 @@ LazyLoad::AllSegments() const {
 }
 
 bool LazyLoad::Initialized() const {
-    /* Since the memory store isn't provisioned with an initial SDKDataSet
-     * like in the Background Sync system, we can't forward this call to
-     * MemoryStore::Initialized(). Instead, we need to check the state of the
-     * underlying source. */
+    /* In lazy load mode, the system is always considered initialized for
+     * the purpose of flag evaluations. Data is fetched on-demand from the
+     * underlying source regardless of the $inited key state.
+     *
+     * However, we still check the underlying source's initialized state
+     * so we can warn if $inited is not set. A properly configured
+     * Relay Proxy or other SDK populating the store should set the
+     * $inited key. */
 
     auto const state = tracker_.State(Keys::kInitialized, time_());
     if (initialized_.has_value()) {
-        /* Once initialized, we can always return true. */
         if (initialized_.value()) {
             return true;
         }
-        /* If not yet initialized, then we can return false only if the state is
-         * fresh - otherwise we should make an attempt to refresh. */
         if (data_components::ExpirationTracker::TrackState::kFresh == state) {
-            return false;
+            return true;
         }
     }
     RefreshInitState();
-    return initialized_.value_or(false);
+    if (!initialized_.value_or(false) && !logged_init_warning_) {
+        LD_LOG(logger_, LogLevel::kWarn)
+            << "LazyLoad: data source reports not initialized "
+               "(the $inited key was not found in the store). "
+               "Evaluations will proceed using available data. "
+               "Typically a Relay Proxy or other SDK should set this "
+               "key; verify your configuration if this is unexpected.";
+        logged_init_warning_ = true;
+    }
+    return true;
 }
 
 void LazyLoad::RefreshAllFlags() const {

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

@@ -187,6 +187,7 @@ class LazyLoad final : public data_interfaces::IDataSystem {
     mutable data_components::ExpirationTracker tracker_;
     TimeFn time_;
     mutable std::optional<bool> initialized_;
+    mutable bool logged_init_warning_{false};
 
     ClockType::duration fresh_duration_;
 

libs/server-sdk/tests/lazy_load_system_test.cpp

@@ -283,7 +283,7 @@ TEST_F(LazyLoadTest, AllSegmentsRefreshesIndividualSegment) {
     ASSERT_EQ(segment2->version, 2);
 }
 
-TEST_F(LazyLoadTest, InitializeNotQueriedRepeatedly) {
+TEST_F(LazyLoadTest, InitializedReturnsTrueEvenWhenSourceNotInitialized) {
     built::LazyLoadConfig const config{
         built::LazyLoadConfig::EvictionPolicy::Disabled,
         std::chrono::seconds(10), mock_reader};
@@ -292,8 +292,10 @@ TEST_F(LazyLoadTest, InitializeNotQueriedRepeatedly) {
 
     data_systems::LazyLoad const lazy_load(logger, config, status_manager);
 
+    // In lazy load mode, Initialized() always returns true even when the
+    // underlying source reports not initialized ($inited key not found).
     for (std::size_t i = 0; i < 10; i++) {
-        ASSERT_FALSE(lazy_load.Initialized());
+        ASSERT_TRUE(lazy_load.Initialized());
     }
 }
 
@@ -329,12 +331,46 @@ TEST_F(LazyLoadTest, InitializeCalledAgainAfterTTL) {
     data_systems::LazyLoad const lazy_load(logger, config, status_manager,
                                            [&]() { return now; });
 
+    // Always returns true even when source reports not initialized.
     for (std::size_t i = 0; i < 10; i++) {
-        ASSERT_FALSE(lazy_load.Initialized());
+        ASSERT_TRUE(lazy_load.Initialized());
         now += std::chrono::seconds(1);
     }
 
+    // Still true after TTL when source now reports initialized.
     for (std::size_t i = 0; i < 10; i++) {
         ASSERT_TRUE(lazy_load.Initialized());
     }
 }
+
+TEST_F(LazyLoadTest, InitializedLogsWarningWhenSourceNotInitialized) {
+    built::LazyLoadConfig const config{
+        built::LazyLoadConfig::EvictionPolicy::Disabled,
+        std::chrono::seconds(10), mock_reader};
+
+    EXPECT_CALL(*mock_reader, Initialized).WillOnce(Return(false));
+
+    data_systems::LazyLoad const lazy_load(logger, config, status_manager);
+
+    ASSERT_TRUE(lazy_load.Initialized());
+
+    // A warning should have been logged about $inited not being found.
+    ASSERT_TRUE(spy_logger_backend->Contains(
+        0, LogLevel::kWarn, "$inited"));
+}
+
+TEST_F(LazyLoadTest, InitializedDoesNotLogWarningWhenSourceIsInitialized) {
+    built::LazyLoadConfig const config{
+        built::LazyLoadConfig::EvictionPolicy::Disabled,
+        std::chrono::seconds(10), mock_reader};
+
+    EXPECT_CALL(*mock_reader, Initialized).WillOnce(Return(true));
+
+    data_systems::LazyLoad const lazy_load(logger, config, status_manager);
+
+    ASSERT_TRUE(lazy_load.Initialized());
+
+    // No warning should be logged when source is properly initialized.
+    // Only debug-level messages should be present (or none at all).
+    ASSERT_TRUE(spy_logger_backend->Count(0));
+}