eppo-server-sdk 3.1.2 → 3.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e157a64d8d72757a3bd049d7e40db5589fb7b16d6ff466ea4a1015dbb54fa066
-  data.tar.gz: 9a4d5cd6edec77d1b8bf8103debe2b096816b6e9957a1c2308747a5182b5a703
+  metadata.gz: 58a6e5ef2e00c9c830661f2571eab4f6817e2ceaf40de3dd541b7f2421fb24c0
+  data.tar.gz: 8616534de1a08cd7c9d02570da27b15c64e4df0e2c805301bd3f4e54f1b6d3d0
 SHA512:
-  metadata.gz: 1b98a6ee8aefd1b833f83ddae8141f42798f825a30f0a54d257f390aa24efc9d8e8a2f1c5b9ff1542db9c11700b7d5fac513c0fa1632aca2f5d22b1eb1a4a9b2
-  data.tar.gz: abc686a5a7e46bf85ba655157de3b7ae9b9367e53603d962741d52edac3f42da1e24301a67145b6719663583a89083dbe0e5df757ebf0a6decc8a570f8f64edf
+  metadata.gz: 23fe167a77c13f00137469b6bf078cb27e907dc1a5b4d18cc6f9bcfbda0a60f9620425d92eca98f3a4d2034796cd5b7f09bf9d08f6a61e0c9fa66b14c5f3730b
+  data.tar.gz: 9722bfdd197f648bcfd82b9f93f232c834d8c17a43b73b221bcfe47927b2dc2ed81cf3a95ad856b6497479861f82093b7127e9bbaa814d39bca48c2fd6662977

data/Cargo.lock

@@ -304,7 +304,7 @@ dependencies = [
 
 [[package]]
 name = "eppo_client"
-version = "3.1.2"
+version = "3.2.2"
 dependencies = [
  "env_logger",
  "eppo_core",
@@ -312,14 +312,15 @@ dependencies = [
  "magnus",
  "rb-sys",
  "serde",
+ "serde_json",
  "serde_magnus",
 ]
 
 [[package]]
 name = "eppo_core"
-version = "4.0.0"
+version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b071fed21065318dcd6a91a443bd9f6b39796d727297b03d092e2e8dc9e02414"
+checksum = "626df025f5b474b42ead14953310e31e81e4b88ce52a993573bf87bc9def12d4"
 dependencies = [
  "chrono",
  "derive_more",
@@ -906,6 +907,15 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 
+[[package]]
+name = "openssl-src"
+version = "300.3.1+3.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7259953d42a81bf137fbbd73bd30a8e1914d6dce43c2b90ed575783a22608b91"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "openssl-sys"
 version = "0.9.103"
@@ -914,6 +924,7 @@ checksum = "7f9e8deee91df40a943c71b917e5874b951d32a802526c85721ce3b776c929d6"
 dependencies = [
  "cc",
  "libc",
+ "openssl-src",
  "pkg-config",
  "vcpkg",
 ]
@@ -1021,18 +1032,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.100"
+version = "0.9.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87f2ba20be84b32fad6b0ce397764bcdd0f2dca4431cf7035f6a6721e5747565"
+checksum = "df4dec4b1d304c3b308a2cd86b1216ea45dd4361f4e9fa056f108332d0a450c1"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.100"
+version = "0.9.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ecae2bdcb118ee721d9a3929f89e8578237fade298dfcf8c928609aa88abc48"
+checksum = "1d71de3e29d174b8fb17b5d4470f27d7aa2605f8a9d05fda0d3aeff30e05a570"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -1295,9 +1306,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.124"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66ad62847a56b3dba58cc891acd13884b9c61138d330c0d7b6181713d4fce38d"
+checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
 dependencies = [
  "itoa",
  "memchr",

data/Rakefile

@@ -1,18 +1,11 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
 require_relative 'lib/eppo_client/version'
 
 GEM_NAME = 'eppo-server-sdk'
 GEM_VERSION = EppoClient::VERSION
 
-RSpec::Core::RakeTask.new(:spec)
-
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
 require "rb_sys/extensiontask"
 
 task default: :build
@@ -21,6 +14,8 @@ GEMSPEC = Gem::Specification.load("eppo-server-sdk.gemspec")
 
 RbSys::ExtensionTask.new("eppo_client", GEMSPEC) do |ext|
   ext.lib_dir = "lib/eppo_client"
+
+  ext.cross_compile = true
 end
 
 task build: :compile do
@@ -43,11 +38,5 @@ task :clean do
   system 'rm *.gem'
 end
 
-RSpec::Core::RakeTask.new(:test) do |task|
-  root_dir = Rake.application.original_dir
-  task.pattern = "#{root_dir}/spec/*_spec.rb"
-  task.verbose = false
-end
-
 task test: :devinstall
 task test_refreshed_data: [:devinstall, 'test-data']

data/build/x86-64_linux-setup.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+## From:
+## https://github.com/BoundaryML/baml/blob/canary/engine/language_client_ruby/x86-64_linux-setup.sh
+##
+
+set -euxo pipefail
+
+# from https://serverfault.com/questions/1161816/mirrorlist-centos-org-no-longer-resolve
+sudo sed -i 's/mirror.centos.org/vault.centos.org/g' /etc/yum.repos.d/*.repo
+sudo sed -i 's/^#.*baseurl=http/baseurl=http/g'      /etc/yum.repos.d/*.repo
+sudo sed -i 's/^mirrorlist=http/#mirrorlist=http/g'  /etc/yum.repos.d/*.repo
+
+ls /etc/yum.repos.d/
+
+# We need this to build engine/, since it's needed for OpenSSL
+sudo yum install -y perl-IPC-Cmd

data/ext/eppo_client/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "eppo_client"
 # TODO: this version and lib/eppo_client/version.rb should be in sync
-version = "3.1.2"
+version = "3.2.2"
 edition = "2021"
 license = "MIT"
 publish = false
@@ -12,9 +12,10 @@ crate-type = ["cdylib"]
 
 [dependencies]
 env_logger = { version = "0.11.3", features = ["unstable-kv"] }
-eppo_core = { version = "4.0.0" }
+eppo_core = { version = "4.1.0", features = ["vendored"] }
 log = { version = "0.4.21", features = ["kv_serde"] }
-magnus = { version = "0.6.2" }
+magnus = { version = "0.6.4" }
 serde = { version = "1.0.203", features = ["derive"] }
 serde_magnus = "0.8.1"
-rb-sys = "0.9"
+rb-sys = "0.9.102"
+serde_json = "1.0.128"

data/ext/eppo_client/src/client.rs

@@ -1,20 +1,24 @@
-use std::{cell::RefCell, sync::Arc};
+use std::{cell::RefCell, sync::Arc, time::Duration};
 
 use eppo_core::{
     configuration_fetcher::{ConfigurationFetcher, ConfigurationFetcherConfig},
     configuration_store::ConfigurationStore,
     eval::{Evaluator, EvaluatorConfig},
-    poller_thread::PollerThread,
+    poller_thread::{PollerThread, PollerThreadConfig},
     ufc::VariationType,
-    Attributes, ContextAttributes, SdkMetadata,
+    Attributes, ContextAttributes,
 };
 use magnus::{error::Result, exception, prelude::*, Error, TryConvert, Value};
 
+use crate::{configuration::Configuration, SDK_METADATA};
+
 #[derive(Debug)]
 #[magnus::wrap(class = "EppoClient::Core::Config", size, free_immediately)]
 pub struct Config {
     api_key: String,
     base_url: String,
+    poll_interval: Option<Duration>,
+    poll_jitter: Duration,
 }
 
 impl TryConvert for Config {
@@ -22,12 +26,21 @@ impl TryConvert for Config {
     fn try_convert(val: magnus::Value) -> Result<Self> {
         let api_key = String::try_convert(val.funcall("api_key", ())?)?;
         let base_url = String::try_convert(val.funcall("base_url", ())?)?;
-        Ok(Config { api_key, base_url })
+        let poll_interval_seconds =
+            Option::<u64>::try_convert(val.funcall("poll_interval_seconds", ())?)?;
+        let poll_jitter_seconds = u64::try_convert(val.funcall("poll_jitter_seconds", ())?)?;
+        Ok(Config {
+            api_key,
+            base_url,
+            poll_interval: poll_interval_seconds.map(Duration::from_secs),
+            poll_jitter: Duration::from_secs(poll_jitter_seconds),
+        })
     }
 }
 
 #[magnus::wrap(class = "EppoClient::Core::Client")]
 pub struct Client {
+    configuration_store: Arc<ConfigurationStore>,
     evaluator: Evaluator,
     // Magnus only allows sharing aliased references (&T) through the API, so we need to use RefCell
     // to get interior mutability.
@@ -41,29 +54,35 @@ impl Client {
     pub fn new(config: Config) -> Client {
         let configuration_store = Arc::new(ConfigurationStore::new());
 
-        let sdk_metadata = SdkMetadata {
-            name: "ruby",
-            version: env!("CARGO_PKG_VERSION"),
+        let poller_thread = if let Some(poll_interval) = config.poll_interval {
+            Some(
+                PollerThread::start_with_config(
+                    ConfigurationFetcher::new(ConfigurationFetcherConfig {
+                        base_url: config.base_url,
+                        api_key: config.api_key,
+                        sdk_metadata: SDK_METADATA,
+                    }),
+                    configuration_store.clone(),
+                    PollerThreadConfig {
+                        interval: poll_interval,
+                        jitter: config.poll_jitter,
+                    },
+                )
+                .expect("should be able to start poller thread"),
+            )
+        } else {
+            None
         };
 
-        let poller_thread = PollerThread::start(
-            ConfigurationFetcher::new(ConfigurationFetcherConfig {
-                base_url: config.base_url,
-                api_key: config.api_key,
-                sdk_metadata: sdk_metadata.clone(),
-            }),
-            configuration_store.clone(),
-        )
-        .expect("should be able to start poller thread");
-
         let evaluator = Evaluator::new(EvaluatorConfig {
-            configuration_store,
-            sdk_metadata,
+            configuration_store: configuration_store.clone(),
+            sdk_metadata: SDK_METADATA,
         });
 
         Client {
+            configuration_store,
             evaluator,
-            poller_thread: RefCell::new(Some(poller_thread)),
+            poller_thread: RefCell::new(poller_thread),
         }
     }
 
@@ -171,6 +190,17 @@ impl Client {
         serde_magnus::serialize(&result)
     }
 
+    pub fn get_configuration(&self) -> Option<Configuration> {
+        self.configuration_store
+            .get_configuration()
+            .map(|it| it.into())
+    }
+
+    pub fn set_configuration(&self, configuration: &Configuration) {
+        self.configuration_store
+            .set_configuration(configuration.clone().into())
+    }
+
     pub fn shutdown(&self) {
         if let Some(t) = self.poller_thread.take() {
             let _ = t.shutdown();

data/ext/eppo_client/src/configuration.rs

@@ -0,0 +1,113 @@
+use std::sync::Arc;
+
+use magnus::{function, method, prelude::*, scan_args::get_kwargs, Error, RHash, RString, Ruby};
+
+use eppo_core::{ufc::UniversalFlagConfig, Configuration as CoreConfiguration};
+
+use crate::{gc_lock::GcLock, SDK_METADATA};
+
+pub(crate) fn init(ruby: &Ruby) -> Result<(), Error> {
+    let eppo_client = ruby.define_module("EppoClient")?;
+
+    let configuration = eppo_client.define_class("Configuration", magnus::class::object())?;
+    configuration.define_singleton_method("new", function!(Configuration::new, 1))?;
+    configuration.define_method(
+        "flags_configuration",
+        method!(Configuration::flags_configuration, 0),
+    )?;
+    configuration.define_method(
+        "bandits_configuration",
+        method!(Configuration::bandits_configuration, 0),
+    )?;
+
+    Ok(())
+}
+
+#[derive(Debug, Clone)]
+#[magnus::wrap(class = "EppoClient::Configuration", free_immediately)]
+pub struct Configuration {
+    inner: Arc<CoreConfiguration>,
+}
+
+impl Configuration {
+    fn new(ruby: &Ruby, kw: RHash) -> Result<Configuration, Error> {
+        let args = get_kwargs(kw, &["flags_configuration"], &["bandits_configuration"])?;
+        let (flags_configuration,): (RString,) = args.required;
+        let (bandits_configuration,): (Option<Option<RString>>,) = args.optional;
+        let rest: RHash = args.splat;
+        if !rest.is_empty() {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                format!("unexpected keyword arguments: {:?}", rest),
+            ));
+        }
+
+        let inner = {
+            let _gc_lock = GcLock::new(ruby);
+
+            Arc::new(CoreConfiguration::from_server_response(
+                UniversalFlagConfig::from_json(
+                    SDK_METADATA,
+                    unsafe {
+                        // SAFETY: we have disabled GC, so the memory can't be modified concurrently.
+                        flags_configuration.as_slice()
+                    }
+                    .to_vec(),
+                )
+                .map_err(|err| {
+                    Error::new(
+                        ruby.exception_arg_error(),
+                        format!("failed to parse flags_configuration: {err:?}"),
+                    )
+                })?,
+                bandits_configuration
+                    .flatten()
+                    .map(|bandits| {
+                        serde_json::from_slice(unsafe {
+                            // SAFETY: we have disabled GC, so the memory can't be modified concurrently.
+                            bandits.as_slice()
+                        })
+                    })
+                    .transpose()
+                    .map_err(|err| {
+                        Error::new(
+                            ruby.exception_arg_error(),
+                            format!("failed to parse bandits_configuration: {err:?}"),
+                        )
+                    })?,
+            ))
+        };
+
+        Ok(Configuration { inner })
+    }
+
+    fn flags_configuration(ruby: &Ruby, rb_self: &Self) -> Result<RString, Error> {
+        Ok(ruby.str_from_slice(rb_self.inner.flags.to_json()))
+    }
+
+    fn bandits_configuration(ruby: &Ruby, rb_self: &Self) -> Result<Option<RString>, Error> {
+        let Some(bandits) = &rb_self.inner.bandits else {
+            return Ok(None)
+        };
+        let vec = serde_json::to_vec(bandits).map_err(|err| {
+            // this should never happen
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("failed to serialize bandits configuration: {err:?}"),
+            )
+        })?;
+        Ok(Some(ruby.str_from_slice(&vec)))
+    }
+}
+
+impl From<Arc<CoreConfiguration>> for Configuration {
+    fn from(inner: Arc<CoreConfiguration>) -> Configuration {
+        Configuration { inner }
+    }
+}
+
+impl From<Configuration> for Arc<CoreConfiguration> {
+    fn from(value: Configuration) -> Arc<CoreConfiguration> {
+        value.inner
+    }
+}

data/ext/eppo_client/src/gc_lock.rs

@@ -0,0 +1,25 @@
+use magnus::Ruby;
+
+pub struct GcLock<'a> {
+    ruby: &'a Ruby,
+    /// Holds `true` if GC was already disabled before acquiring the lock (so it doesn't need to be
+    /// re-enabled).
+    gc_was_disabled: bool,
+}
+
+impl<'a> GcLock<'a> {
+    pub fn new(ruby: &'a Ruby) -> GcLock<'a> {
+        GcLock {
+            ruby,
+            gc_was_disabled: ruby.gc_disable(),
+        }
+    }
+}
+
+impl<'a> Drop for GcLock<'a> {
+    fn drop(&mut self) {
+        if !self.gc_was_disabled {
+            self.ruby.gc_enable();
+        }
+    }
+}

data/ext/eppo_client/src/lib.rs

@@ -1,12 +1,20 @@
 mod client;
+mod configuration;
+mod gc_lock;
 
+use eppo_core::SdkMetadata;
 use magnus::{function, method, prelude::*, Error, Object, Ruby};
 
 use crate::client::Client;
 
+pub(crate) const SDK_METADATA: SdkMetadata = SdkMetadata {
+    name: "ruby",
+    version: env!("CARGO_PKG_VERSION"),
+};
+
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
-    env_logger::Builder::from_env(env_logger::Env::new().default_filter_or("eppo")).init();
+    env_logger::Builder::from_env(env_logger::Env::new().default_filter_or("eppo=debug")).init();
 
     let eppo_client = ruby.define_module("EppoClient")?;
     let core = eppo_client.define_module("Core")?;
@@ -23,12 +31,24 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
         "get_bandit_action_details",
         method!(Client::get_bandit_action_details, 5),
     )?;
+    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))?;
 
     core.const_set(
         "DEFAULT_BASE_URL",
         eppo_core::configuration_fetcher::DEFAULT_BASE_URL,
     )?;
+    core.const_set(
+        "DEFAULT_POLL_INTERVAL_SECONDS",
+        eppo_core::poller_thread::PollerThreadConfig::DEFAULT_POLL_INTERVAL.as_secs(),
+    )?;
+    core.const_set(
+        "DEFAULT_POLL_JITTER_SECONDS",
+        eppo_core::poller_thread::PollerThreadConfig::DEFAULT_POLL_JITTER.as_secs(),
+    )?;
+
+    configuration::init(ruby)?;
 
     Ok(())
 }

data/lib/eppo_client/client.rb

@@ -24,6 +24,14 @@ module EppoClient
       @core = EppoClient::Core::Client.new(config)
     end
 
+    def configuration
+      @core.configuration
+    end
+
+    def configuration=(configuration)
+      @core.configuration = configuration
+    end
+
     def shutdown
       @core.shutdown
     end

data/lib/eppo_client/config.rb

@@ -6,12 +6,14 @@ require_relative "assignment_logger"
 module EppoClient
   # The class for configuring the Eppo client singleton
   class Config
-    attr_reader :api_key, :assignment_logger, :base_url
+    attr_reader :api_key, :assignment_logger, :base_url, :poll_interval_seconds, :poll_jitter_seconds
 
-    def initialize(api_key, assignment_logger: AssignmentLogger.new, base_url: EppoClient::Core::DEFAULT_BASE_URL)
+    def initialize(api_key, assignment_logger: AssignmentLogger.new, base_url: EppoClient::Core::DEFAULT_BASE_URL, poll_interval_seconds: EppoClient::Core::DEFAULT_POLL_INTERVAL_SECONDS, poll_jitter_seconds: EppoClient::Core::DEFAULT_POLL_JITTER_SECONDS, initial_configuration: nil)
       @api_key = api_key
       @assignment_logger = assignment_logger
       @base_url = base_url
+      @poll_interval_seconds = poll_interval_seconds
+      @poll_jitter_seconds = poll_jitter_seconds
     end
 
     def validate

data/lib/eppo_client/version.rb

@@ -2,5 +2,5 @@
 
 # TODO: this version and ext/eppo_client/Cargo.toml should be in sync
 module EppoClient
-  VERSION = "3.1.2"
+  VERSION = "3.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eppo-server-sdk
 version: !ruby/object:Gem::Version
-  version: 3.1.2
+  version: 3.2.2
 platform: ruby
 authors:
 - Eppo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-10-08 00:00:00.000000000 Z
+date: 2024-10-17 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -27,10 +27,13 @@ files:
 - README.md
 - Rakefile
 - Steepfile
+- build/x86-64_linux-setup.sh
 - ext/eppo_client/Cargo.toml
 - ext/eppo_client/build.rs
 - ext/eppo_client/extconf.rb
 - ext/eppo_client/src/client.rs
+- ext/eppo_client/src/configuration.rs
+- ext/eppo_client/src/gc_lock.rs
 - ext/eppo_client/src/lib.rs
 - lib/eppo_client.rb
 - lib/eppo_client/assignment_logger.rb