use allocator to configure event tracker instead of admin

Summary:
Add eventTrackerConfigFactory to CacheAllocatorConfig — a factory function (std::function<EventTracker::Config()>) that creates a fresh
 EventTracker::Config on demand.

 EventTracker::Config contains unique_ptr members (EventSink, SamplerInterface) for dependency injection of abstract interfaces. This makes the config move-only, so it can only be consumed once. During warm roll recovery, CacheAllocatorConfig is reused to re-initialize the allocator, which means a directly-stored config would be invalid after the first use.

The factory pattern solves this by producing a new EventTracker::Config with fresh unique_ptr instances each time the allocator initializes. This moves event tracker setup from the admin server into the allocator config, keeping configuration self-contained.

Reviewed By: rlyerly

Differential Revision: D95624875

fbshipit-source-id: 2d78dfc522daa281e24aa32d727e21f5568c3772

Author: pbhandar2

cachelib/allocator/CacheAllocator.h

@@ -2673,6 +2673,9 @@ void CacheAllocator<CacheTrait>::initCommon(bool dramCacheAttached) {
   }
   initStats();
   initNvmCache(dramCacheAttached);
+  if (config_.eventTrackerConfigFactory) {
+    setEventTracker(config_.eventTrackerConfigFactory());
+  }
 
   if (!config_.delayCacheWorkersStart) {
     initWorkers();

cachelib/allocator/CacheAllocatorConfig.h

@@ -41,6 +41,7 @@
 #include "cachelib/allocator/RebalanceStrategy.h"
 #include "cachelib/allocator/Util.h"
 #include "cachelib/common/EventInterface.h"
+#include "cachelib/common/EventTracker.h"
 #include "cachelib/common/Throttler.h"
 
 namespace facebook {
@@ -343,6 +344,12 @@ class CacheAllocatorConfig {
   // starts
   CacheAllocatorConfig& setEventTracker(LegacyEventTrackerSharedPtr&&);
 
+  // Set a factory function to create EventTracker::Config on demand.
+  // Creates a fresh config each time, avoiding issues when
+  // CacheAllocatorConfig is reused (e.g., during warm roll recovery).
+  CacheAllocatorConfig& setEventTrackerConfigFactory(
+      std::function<EventTracker::Config()> factory);
+
   // Set the minimum TTL for an item to be admitted into NVM cache.
   // If nvmAdmissionMinTTL is set to be positive, any item with configured TTL
   // smaller than this will always be rejected by NvmAdmissionPolicy.
@@ -577,6 +584,11 @@ class CacheAllocatorConfig {
   // construction.
   LegacyEventTrackerSharedPtr legacyEventTracker{nullptr};
 
+  // Factory function to create EventTracker::Config on demand.
+  // Creates a fresh config each time, avoiding issues when
+  // CacheAllocatorConfig is reused (e.g., during warm roll recovery).
+  std::function<EventTracker::Config()> eventTrackerConfigFactory{nullptr};
+
   // whether to allow tracking tail hits in MM2Q
   bool trackTailHits{false};
 
@@ -1164,6 +1176,13 @@ CacheAllocatorConfig<T>& CacheAllocatorConfig<T>::setEventTracker(
   return *this;
 }
 
+template <typename T>
+CacheAllocatorConfig<T>& CacheAllocatorConfig<T>::setEventTrackerConfigFactory(
+    std::function<EventTracker::Config()> factory) {
+  eventTrackerConfigFactory = std::move(factory);
+  return *this;
+}
+
 template <typename T>
 CacheAllocatorConfig<T>& CacheAllocatorConfig<T>::setNvmAdmissionMinTTL(
     uint64_t ttl) {
@@ -1353,6 +1372,8 @@ std::map<std::string, std::string> CacheAllocatorConfig<T>::serialize() const {
   configMap["defaultPoolRebalanceStrategy"] =
       stringifyRebalanceStrategy(defaultPoolRebalanceStrategy);
   configMap["eventTracker"] = legacyEventTracker ? "set" : "empty";
+  configMap["eventTrackerConfigFactory"] =
+      eventTrackerConfigFactory ? "set" : "empty";
   configMap["nvmAdmissionMinTTL"] = std::to_string(nvmAdmissionMinTTL);
   configMap["delayCacheWorkersStart"] =
       delayCacheWorkersStart ? "true" : "false";

cachelib/allocator/tests/CacheAllocatorConfigTest.cpp

@@ -17,6 +17,8 @@
 #include "cachelib/allocator/CacheAllocatorConfig.h"
 #include "cachelib/allocator/MemoryTierCacheConfig.h"
 #include "cachelib/allocator/tests/TestBase.h"
+#include "cachelib/common/EventSink.h"
+#include "cachelib/common/EventTracker.h"
 
 namespace facebook {
 namespace cachelib {
@@ -91,6 +93,62 @@ TEST_F(CacheAllocatorConfigTest, SerializeEvictionPolicyWTinyLFU) {
   EXPECT_EQ(serialized["evictionPolicy"], "MMWTinyLFU");
 }
 
+TEST_F(CacheAllocatorConfigTest, SetEventTrackerConfigFactory) {
+  AllocatorT::Config config;
+  int factoryCallCount = 0;
+  config.setEventTrackerConfigFactory([&factoryCallCount]() {
+    ++factoryCallCount;
+    EventTracker::Config trackerConfig;
+    trackerConfig.queueSize = 100;
+    trackerConfig.eventSink = std::make_unique<InMemoryEventSink>();
+    trackerConfig.sampler = std::make_unique<FurcHashSampler>(1);
+    return trackerConfig;
+  });
+  EXPECT_TRUE(config.eventTrackerConfigFactory != nullptr);
+  EXPECT_EQ(factoryCallCount, 0);
+
+  // Invoke the factory and verify it produces a valid config.
+  auto trackerConfig = config.eventTrackerConfigFactory();
+  EXPECT_EQ(factoryCallCount, 1);
+  EXPECT_EQ(trackerConfig.queueSize, 100);
+  EXPECT_NE(trackerConfig.eventSink, nullptr);
+  EXPECT_NE(trackerConfig.sampler, nullptr);
+}
+
+TEST_F(CacheAllocatorConfigTest, EventTrackerConfigFactoryProducesFreshConfig) {
+  AllocatorT::Config config;
+  config.setEventTrackerConfigFactory([]() {
+    EventTracker::Config trackerConfig;
+    trackerConfig.queueSize = 50;
+    trackerConfig.eventSink = std::make_unique<InMemoryEventSink>();
+    return trackerConfig;
+  });
+
+  // Call factory twice and verify each produces independent, valid configs.
+  auto config1 = config.eventTrackerConfigFactory();
+  auto config2 = config.eventTrackerConfigFactory();
+  EXPECT_NE(config1.eventSink, nullptr);
+  EXPECT_NE(config2.eventSink, nullptr);
+  // The two sinks must be distinct objects.
+  EXPECT_NE(config1.eventSink.get(), config2.eventSink.get());
+}
+
+TEST_F(CacheAllocatorConfigTest, SerializeEventTrackerConfigFactory) {
+  AllocatorT::Config config;
+  // Before setting, serialization should show "empty".
+  auto serialized = config.serialize();
+  EXPECT_EQ(serialized["eventTrackerConfigFactory"], "empty");
+
+  config.setEventTrackerConfigFactory([]() {
+    EventTracker::Config trackerConfig;
+    trackerConfig.queueSize = 10;
+    trackerConfig.eventSink = std::make_unique<InMemoryEventSink>();
+    return trackerConfig;
+  });
+  serialized = config.serialize();
+  EXPECT_EQ(serialized["eventTrackerConfigFactory"], "set");
+}
+
 } // namespace tests
 } // namespace cachelib
 } // namespace facebook