feat(ruby): add wait_for_initialization() method (#247)

Author: rasendubi

.changeset/odd-eyes-deny.md

@@ -0,0 +1,5 @@
+---
+"ruby-sdk": minor
+---
+
+Add `wait_for_initialization()` method.

ruby-sdk/Cargo.lock

@@ -19,3 +19,4 @@ serde = { version = "1.0.203", features = ["derive"] }
 serde_magnus = "0.9.0"
 rb-sys = "0.9.102"
 serde_json = "1.0.128"
+tokio = { version = "1.44.1", default-features = false, features = ["time"] }

ruby-sdk/ext/eppo_client/Cargo.toml

@@ -238,6 +238,33 @@ impl Client {
         serde_magnus::serialize(&result)
     }
 
+    pub fn wait_for_initialization(&self, timeout_secs: f64) {
+        log::info!(target: "eppo", "waiting for initialization");
+        let thread = self.background_thread.borrow();
+        let Some(thread) = thread.as_ref() else {
+            log::warn!(target: "eppo", "failed to wait for initialization: background thread is not running");
+            return;
+        };
+        let Some(poller) = &self.configuration_poller else {
+            log::warn!(target: "eppo", "failed to wait for initialization: configuration poller has not been started");
+            return;
+        };
+
+        let _ = thread
+            .runtime()
+            .async_runtime
+            .block_on(async {
+                tokio::time::timeout(
+                    Duration::from_secs_f64(timeout_secs),
+                    poller.wait_for_configuration(),
+                )
+                .await
+            })
+            .inspect_err(|err| {
+                log::warn!(target: "eppo", "failed to wait for initialization: {err:?}");
+            });
+    }
+
     pub fn get_configuration(&self) -> Option<Configuration> {
         self.configuration_store
             .get_configuration()

ruby-sdk/ext/eppo_client/src/client.rs

@@ -29,6 +29,10 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
         method!(Client::get_bandit_action_details, 5),
     )?;
     core_client.define_method("track", method!(Client::track, 2))?;
+    core_client.define_method(
+        "wait_for_initialization",
+        method!(Client::wait_for_initialization, 1),
+    )?;
     core_client.define_method("configuration", method!(Client::get_configuration, 0))?;
     core_client.define_method("configuration=", method!(Client::set_configuration, 1))?;
     core_client.define_method("shutdown", method!(Client::shutdown, 0))?;

ruby-sdk/ext/eppo_client/src/lib.rs

@@ -31,6 +31,20 @@ def init(config)
       @core = EppoClient::Core::Client.new(config)
     end
 
+    ##
+    # Waits for client to fetch configuration and get ready to serve
+    # assignments.
+    #
+    # This method blocks the current thread until configuration is
+    # successfully fetched or +timeout+ seconds passed.
+    #
+    # Note: this method returns immediately if configuration poller
+    # has been disabled.
+    def wait_for_initialization(timeout=1)
+      return unless @core
+      @core.wait_for_initialization(timeout)
+    end
+
     def configuration
       @core.configuration
     end

ruby-sdk/lib/eppo_client/client.rb

@@ -7,6 +7,46 @@
     expect(EppoClient::VERSION).not_to be nil
   end
 
+  describe "wait_for_initialization()" do
+    before :each do
+      EppoClient::Client.instance.init(EppoClient::Config.new("test-api-key", base_url: "http://127.0.0.1:8378/ufc/api"))
+      @client = EppoClient::Client.instance
+    end
+
+    it "has default timeout" do
+      @client.wait_for_initialization()
+
+      expect(@client.configuration).not_to be_nil
+    end
+
+    it "allows 0 timeout" do
+      @client.wait_for_initialization(0)
+
+      # Local configuration fetching is so fast that sometimes it
+      # succeeds before we call wait_for_initialization(). Therefore,
+      # we treat absense of errors as a sign of success here.
+    end
+
+    it "allows fractional timeout" do
+      @client.wait_for_initialization(0.5)
+
+      expect(@client.configuration).not_to be_nil
+    end
+
+    it "timeouts with bad URL" do
+      EppoClient::Client.instance.init(EppoClient::Config.new("test-api-key", base_url: "http://127.0.0.1:8378/undefined/api"))
+      @client = EppoClient::Client.instance
+
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @client.wait_for_initialization(0.2)
+      stop = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      expect(@client.configuration).to be_nil
+      # shall wait at least for timeout
+      expect(stop - start).to be >= 0.2
+    end
+  end
+
   describe "configuration()" do
     it "allows getting configuration" do
       init_client_for "ufc"

ruby-sdk/spec/eppo_client_spec.rb

@@ -8,9 +8,7 @@ def init_client_for(test_name)
   else
     config = EppoClient::Config.new("test-api-key", base_url: "http://127.0.0.1:8378/#{test_name}/api")
     EppoClient::Client.instance.init(config)
-
-    # Sleep to allow the client to fetch config
-    sleep(0.050)
+    EppoClient::Client.instance.wait_for_initialization()
   end
 end