feat: Discard the FDv2 selector when the evaluation context changes

libs/client-sdk/src/client_impl.cpp

@@ -160,6 +160,7 @@
 
 std::future<bool> ClientImpl::IdentifyAsync(Context context) {
     UpdateContextSynchronized(context);
+    flag_manager_.ClearSelector();
     flag_manager_.LoadCache(context);
     event_processor_->SendAsync(events::IdentifyEventParams{
         std::chrono::system_clock::now(), std::move(context)});
@@ -211,7 +212,7 @@
     std::unordered_map<Client::FlagKey, Value> result;
     for (auto& [key, descriptor] : flag_manager_.Store().GetAll()) {
         if (descriptor->item) {
             result.try_emplace(key, descriptor->item->Detail().Value());
         }
     }
     return result;
@@ -244,11 +245,12 @@
 }
 
 template <typename T>
-EvaluationDetail<T> ClientImpl::VariationInternal(FlagKey const& key,
-                                                  Value default_value,
-                                                  bool check_type,
-                                                  bool detailed,
-                                                  std::unordered_set<std::string>* visited) {
+EvaluationDetail<T> ClientImpl::VariationInternal(
+    FlagKey const& key,
+    Value default_value,
+    bool check_type,
+    bool detailed,
+    std::unordered_set<std::string>* visited) {
     auto desc = flag_manager_.Store().Get(key);
 
     events::FeatureEventParams event = {
@@ -301,7 +303,7 @@
 
     LD_ASSERT(desc->item);
 
     auto const& flag = *(desc->item);
     auto const& detail = flag.Detail();
 
     // The Prerequisites vector represents the evaluated prerequisites of

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

@@ -8,7 +8,7 @@
 FlagManager::FlagManager(std::string const& sdk_key,
                          Logger& logger,
                          std::size_t max_cached_contexts,
                          std::shared_ptr<IPersistence> persistence)
     : flag_updater_(flag_store_),
       persistence_updater_(sdk_key,
                            flag_updater_,
@@ -37,4 +37,8 @@
     persistence_updater_.LoadCached(context);
 }
 
+void FlagManager::ClearSelector() {
+    flag_store_.ClearSelector();
+}
+
 }  // namespace launchdarkly::client_side::flag_manager

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

@@ -28,6 +28,9 @@ class FlagManager {
 
     void LoadCache(Context const& context);
 
+    /** Forgets the selector, leaving the stored flag data in place. */
+    void ClearSelector();
+
    private:
     FlagStore flag_store_;
     FlagUpdater flag_updater_;

libs/client-sdk/tests/fdv2_cache_initializer_test.cpp

@@ -21,7 +21,7 @@
 
 namespace {
 
 class TestPersistence : public IPersistence {
    public:
     using StoreType =
         std::map<std::string,
@@ -63,7 +63,7 @@
         std::make_shared<TestPersistence>(TestPersistence::StoreType{
             {kEnvironment,
              {{kContextId, R"({"flagA":{"version":1,"value":"test"}})"}}}});
     FlagManager flag_manager("the-key", logger, 5, persistence);
 
     FDv2CacheInitializer initializer(&flag_manager.Cache(), context, logger);
     auto future = initializer.Run();
@@ -71,13 +71,13 @@
     auto result = future.GetResult();
 
     // The result is a full change set carrying the cached flag.
     auto* change_set = std::get_if<FDv2SourceResult::ChangeSet>(&result->value);
     ASSERT_NE(nullptr, change_set);
     EXPECT_EQ(ChangeSetType::kFull, change_set->change_set.type);
     ASSERT_EQ(1u, change_set->change_set.data.size());
     EXPECT_EQ("flagA", change_set->change_set.data[0].key);
     EXPECT_EQ(Value("test"),
               change_set->change_set.data[0].item.item->Detail().Value());
 
     // A delta against unverified cached data could silently corrupt the store,
     // so the cache supplies no selector.
@@ -120,6 +120,44 @@
     EXPECT_EQ(ChangeSetType::kNone, change_set->change_set.type);
 }
 
+TEST(FDv2CacheInitializerTest, ReadsTheContextItWasBuiltFor) {
+    auto first = ContextBuilder().Kind("user", "first").Build();
+    auto second = ContextBuilder().Kind("user", "second").Build();
+    auto logger = launchdarkly::logging::NullLogger();
+    auto persistence =
+        std::make_shared<TestPersistence>(TestPersistence::StoreType{
+            {kEnvironment,
+             {{PersistenceEncodeKey(first.CanonicalKey()),
+               R"({"flagA":{"version":1,"value":"first-value"}})"}}}});
+    FlagManager flag_manager("the-key", logger, 5, persistence);
+
+    // Initialize for the context that has nothing cached.
+    FDv2CacheInitializer second_initializer(&flag_manager.Cache(), second,
+                                            logger);
+    auto second_future = second_initializer.Run();
+    ASSERT_TRUE(second_future.IsFinished());
+    auto second_result = second_future.GetResult();
+
+    // Another context's data in the same cache is not a hit.
+    auto* second_change_set =
+        std::get_if<FDv2SourceResult::ChangeSet>(&second_result->value);
+    ASSERT_NE(nullptr, second_change_set);
+    EXPECT_EQ(ChangeSetType::kNone, second_change_set->change_set.type);
+
+    // Initialize for the context whose data is cached.
+    FDv2CacheInitializer first_initializer(&flag_manager.Cache(), first,
+                                           logger);
+    auto first_future = first_initializer.Run();
+    ASSERT_TRUE(first_future.IsFinished());
+    auto first_result = first_future.GetResult();
+
+    // That context's cached data comes back as a full data set.
+    auto* first_change_set =
+        std::get_if<FDv2SourceResult::ChangeSet>(&first_result->value);
+    ASSERT_NE(nullptr, first_change_set);
+    EXPECT_EQ(ChangeSetType::kFull, first_change_set->change_set.type);
+}
+
 // The orchestrator needs to tell cache initializers apart from network ones,
 // so that a miss with nothing else configured still starts the SDK.
 TEST(FDv2CacheInitializerTest, FactoryIdentifiesItselfAsReadingTheCache) {

libs/client-sdk/tests/flag_persistence_test.cpp

@@ -115,6 +115,80 @@ TEST(FlagPersistenceTests, CanLoadCache) {
     EXPECT_EQ("test", store.Get("flagA")->item->Detail().Value().AsString());
 }
 
+TEST(FlagPersistenceTests, LoadingACacheMissRetainsTheExistingData) {
+    auto first = ContextBuilder().Kind("user", "first").Build();
+    auto second = ContextBuilder().Kind("user", "second").Build();
+    auto store = FlagStore();
+    auto updater = FlagUpdater(store);
+    auto persistence =
+        std::make_shared<TestPersistence>(TestPersistence::StoreType());
+    auto logger = launchdarkly::logging::NullLogger();
+
+    FlagPersistence flag_persistence("the-key", updater, store, persistence,
+                                     logger, 5);
+
+    // Put the first context's flag data in the store.
+    flag_persistence.Apply(
+        first,
+        FlagChangeSet{
+            ChangeSetType::kFull,
+            {FlagChange{
+                "flagA",
+                ItemDescriptor{EvaluationResult{
+                    1, std::nullopt, false, false, std::nullopt,
+                    EvaluationDetailInternal{Value("first-value"), std::nullopt,
+                                             std::nullopt}}}}},
+            Selector{}},
+        /* from_cache= */ false);
+
+    // Load a context that has nothing cached.
+    flag_persistence.LoadCached(second);
+
+    // The flag data already in the store stays there.
+    ASSERT_TRUE(store.Get("flagA"));
+    EXPECT_EQ(Value("first-value"), store.Get("flagA")->item->Detail().Value());
+}
+
+TEST(FlagPersistenceTests, LoadingACacheHitReplacesTheExistingData) {
+    auto first = ContextBuilder().Kind("user", "first").Build();
+    auto second = ContextBuilder().Kind("user", "second").Build();
+    auto store = FlagStore();
+    auto updater = FlagUpdater(store);
+    auto logger = launchdarkly::logging::NullLogger();
+
+    auto persistence =
+        std::make_shared<TestPersistence>(TestPersistence::StoreType{
+            {"LaunchDarkly_rUTcjlHPv6Vegd27YmtGYkEGkEUGaEbn5M0JYTFQUpA=",
+             {{PersistenceEncodeKey(second.CanonicalKey()),
+               R"({"flagB":{"version":1,"value":"second-value"}})"}}}});
+
+    FlagPersistence flag_persistence("the-key", updater, store, persistence,
+                                     logger, 5);
+
+    // Put the first context's flag data in the store.
+    flag_persistence.Apply(
+        first,
+        FlagChangeSet{
+            ChangeSetType::kFull,
+            {FlagChange{
+                "flagA",
+                ItemDescriptor{EvaluationResult{
+                    1, std::nullopt, false, false, std::nullopt,
+                    EvaluationDetailInternal{Value("first-value"), std::nullopt,
+                                             std::nullopt}}}}},
+            Selector{}},
+        /* from_cache= */ false);
+
+    // Load a context that has cached data.
+    flag_persistence.LoadCached(second);
+
+    // The cached data takes the place of what the store held.
+    EXPECT_FALSE(store.Get("flagA"));
+    ASSERT_TRUE(store.Get("flagB"));
+    EXPECT_EQ(Value("second-value"),
+              store.Get("flagB")->item->Detail().Value());
+}
+
 TEST(FlagPersistenceTests, EvictsContextsBeyondMax) {
     auto store = FlagStore();
     auto updater = FlagUpdater(store);