[elixir-sdk] Add wait-for-initialization (#249)

Author: schmit

.changeset/purple-tools-smoke.md

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

elixir-sdk/Cargo.lock

@@ -95,7 +95,8 @@ config = %EppoSdk.Client.Config{api_key: "your-api-key", assignment_logger: Your
 {:ok, _pid} = EppoSdk.Server.start_link(config)
 
 # When testing locally, wait for the client to initialize
-Process.sleep(1000)
+client = EppoSdk.Server.get_instance()
+EppoSdk.Client.wait_for_initialization(client)
 
 # Then use as normal
 client = EppoSdk.Server.get_instance()
@@ -106,7 +107,7 @@ Or you can use the client directly:
 {:ok, client} = EppoSdk.Client.new(config)
 
 # When testing locally, wait for the client to initialize
-Process.sleep(1000)
+EppoSdk.Client.wait_for_initialization(client)
 ```
 
 ## Development

elixir-sdk/README.md

@@ -115,6 +115,26 @@ defmodule EppoSdk.Client do
         {:error, Exception.message(e)}
     end
   end
+  
+  @doc """
+  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` passes.
+
+  ## Parameters
+    - timeout_seconds: Timeout in seconds (default: 1.0)
+
+  ## Usage
+  ```elixir
+  EppoSdk.Client.wait_for_initialization(client, 2.0)
+  ```
+  """
+  def wait_for_initialization(%__MODULE__{} = client, timeout_seconds \\ 1.0) do
+    EppoSdk.Core.wait_for_initialization(client.client_ref, timeout_seconds)
+    :ok
+  end
 
   @doc """
   Assigns a string variant based on the provided flag configuration.

elixir-sdk/lib/client.ex

@@ -31,6 +31,8 @@ defmodule EppoSdk.Core do
         _expected_type
       ),
       do: error()
+      
+  def wait_for_initialization(_client, _timeout_secs \\ 1.0), do: error()
 
   # Helper function for NIF not loaded errors
   defp error, do: :erlang.nif_error(:nif_not_loaded)

elixir-sdk/lib/core.ex

@@ -12,3 +12,5 @@ crate-type = ["cdylib"]
 rustler = { version = "0.36.1", features = ["serde"] }
 eppo_core = { version = "=9.1.1", path = "../../../eppo_core", features = ["rustler"] }
 serde_json = "1.0.138"
+tokio = { version = "1.44.1", default-features = false, features = ["time"] }
+log = "0.4.21"

elixir-sdk/native/sdk_core/Cargo.toml

@@ -7,14 +7,15 @@ use crate::conversion::{convert_attributes, convert_value_term, convert_event_te
 use crate::assignment::{get_assignment_inner, get_assignment_details_inner};
 use eppo_core::{
     configuration_fetcher::{ConfigurationFetcher, ConfigurationFetcherConfig},
-    configuration_poller::{start_configuration_poller, ConfigurationPollerConfig},
+    configuration_poller::{start_configuration_poller, ConfigurationPollerConfig, ConfigurationPoller},
     configuration_store::ConfigurationStore,
     eval::{Evaluator, EvaluatorConfig},
     ufc::VariationType,
     SdkMetadata,
     background::BackgroundThread,
 };
 use std::panic::{RefUnwindSafe, UnwindSafe};
+use std::time::Duration;
 
 use rustler::{Encoder, Env, NifResult, ResourceArc, Term};
 use rustler::types::atom;
@@ -27,8 +28,9 @@ const SDK_METADATA: SdkMetadata = SdkMetadata {
 };
 
 pub struct EppoClient {
-    pub evaluator: Evaluator,
-    pub background_thread: BackgroundThread,
+    evaluator: Evaluator,
+    background_thread: BackgroundThread,
+    configuration_poller: ConfigurationPoller,
 }
 
 #[rustler::resource_impl]
@@ -62,7 +64,7 @@ fn init(config: Config) -> NifResult<ResourceArc<EppoClient>> {
         ))
         .with_jitter(std::time::Duration::from_secs(config.poll_jitter_seconds));
 
-    let _poller = start_configuration_poller(
+    let poller = start_configuration_poller(
         background_thread.runtime(),
         fetcher,
         store.clone(),
@@ -78,6 +80,7 @@ fn init(config: Config) -> NifResult<ResourceArc<EppoClient>> {
     let client = ResourceArc::new(EppoClient {
         evaluator,
         background_thread,
+        configuration_poller: poller,
     });
 
     Ok(client)
@@ -151,4 +154,29 @@ fn get_assignment_details<'a>(
     }
 }
 
+#[rustler::nif]
+fn wait_for_initialization(
+    client: ResourceArc<EppoClient>,
+    timeout_secs: f64,
+) -> NifResult<()> {
+    log::info!(target: "eppo", "waiting for initialization");
+    
+    let _ = client
+        .background_thread
+        .runtime()
+        .async_runtime
+        .block_on(async {
+                tokio::time::timeout(
+                    Duration::from_secs_f64(timeout_secs),
+                    client.configuration_poller.wait_for_configuration(),
+                )
+                .await
+            })
+            .inspect_err(|err| {
+                log::warn!(target: "eppo", "failed to wait for initialization: {:?}", err);
+            });
+    
+    Ok(())
+}
+
 rustler::init!("Elixir.EppoSdk.Core"); 

elixir-sdk/native/sdk_core/src/lib.rs

@@ -0,0 +1,55 @@
+defmodule EppoSdk.ClientWaitTest do
+  use ExUnit.Case
+  doctest EppoSdk.Client
+
+  setup do
+    # Reset client singleton state before each test
+    :ok
+  end
+
+  test "wait_for_initialization succeeds with default timeout" do
+    config = %EppoSdk.Client.Config{
+      api_key: "test-api-key",
+      base_url: "http://127.0.0.1:8378/ufc/api"
+    }
+
+    {:ok, client} = EppoSdk.Client.new(config)
+    result = EppoSdk.Client.wait_for_initialization(client)
+
+    assert result == :ok
+    # We just verify that the function completed successfully
+    # The actual configuration fetching result depends on the mock server
+    # and we've already asserted that wait_for_initialization returned :ok
+  end
+
+  test "wait_for_initialization works with custom timeout" do
+    config = %EppoSdk.Client.Config{
+      api_key: "test-api-key",
+      base_url: "http://127.0.0.1:8378/ufc/api"
+    }
+
+    {:ok, client} = EppoSdk.Client.new(config)
+    result = EppoSdk.Client.wait_for_initialization(client, 0.5)
+
+    assert result == :ok
+  end
+
+  test "wait_for_initialization handles timeouts" do
+    config = %EppoSdk.Client.Config{
+      api_key: "test-api-key",
+      # Bad URL
+      base_url: "http://127.0.0.1:8378/undefined/api"
+    }
+
+    {:ok, client} = EppoSdk.Client.new(config)
+    start_time = System.monotonic_time(:millisecond)
+    result = EppoSdk.Client.wait_for_initialization(client, 0.01)
+    end_time = System.monotonic_time(:millisecond)
+
+    # Still returns :ok on timeout
+    assert result == :ok
+    # Verify timeout occurred by checking elapsed time
+    # at least 200ms elapsed
+    assert end_time - start_time >= 10
+  end
+end

elixir-sdk/test/client/client_wait_test.exs

@@ -17,9 +17,10 @@ defmodule TestHelper do
 
     start_supervised({EppoSdk.Server, config})
 
-    # Sleep to allow client to fetch config
+    # Wait for initialization to complete
     unless test_name == "offline" do
-      :timer.sleep(100)
+      client = EppoSdk.Server.get_instance()
+      EppoSdk.Client.wait_for_initialization(client)
     end
   end
 end