eppo-server-sdk 0.3.0 → 3.1.0

data/Cargo.toml

@@ -0,0 +1,7 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions dependencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["./ext/eppo_client"]
+resolver = "2"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Eppo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,22 @@
+# Eppo SDK for Ruby
+
+## Getting Started
+
+Refer to our [SDK documentation](https://docs.geteppo.com/feature-flags/sdks/ruby) for how to install and use the SDK.
+
+## Supported Ruby Versions
+This version of the SDK is compatible with Ruby 3.0.6 and above.
+
+# Contributing
+
+## Testing with local version of `eppo_core`
+
+To run build and tests against a local version of `eppo_core`, you should instruct Cargo to look for it at the local path.
+
+Add the following to `.cargo/config.toml` file (relative to `ruby-sdk`):
+```toml
+[patch.crates-io]
+eppo_core = { path = '../eppo_core' }
+```
+
+Make sure you remove the override before updating `Cargo.lock`. Otherwise, the lock file will be missing `eppo_core` checksum and will be unsuitable for release. (CI will warn you if you do this accidentally.)

data/Rakefile

@@ -0,0 +1,53 @@
+# 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
+
+GEMSPEC = Gem::Specification.load("eppo-server-sdk.gemspec")
+
+RbSys::ExtensionTask.new("eppo_client", GEMSPEC) do |ext|
+  ext.lib_dir = "lib/eppo_client"
+end
+
+task build: :compile do
+  system "gem build #{GEM_NAME}.gemspec"
+end
+
+task install: :build do
+  system "gem install #{GEM_NAME}-#{GEM_VERSION}.gem"
+end
+
+task devinstall: :build do
+  system "gem install #{GEM_NAME}-#{GEM_VERSION}.gem --dev"
+end
+
+task publish: :build do
+  system "gem push #{GEM_NAME}-#{GEM_VERSION}.gem"
+end
+
+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/Steepfile

@@ -0,0 +1,27 @@
+# D = Steep::Diagnostic
+#
+target :lib do
+  signature "sig"
+
+  check "lib"                       # Directory name
+
+  library "singleton"
+  library "logger"
+
+  # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+  # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+  # configure_code_diagnostics do |hash|             # You can setup everything yourself
+  #   hash[D::Ruby::NoMethod] = :information
+  # end
+end
+
+target :test do
+  signature "sig", "sig-private"
+
+  check "test"
+
+  library "singleton"
+  library "logger"
+end

data/ext/eppo_client/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "eppo_client"
+version = "3.1.0"
+edition = "2021"
+license = "MIT"
+publish = false
+rust-version = "1.71.1"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+env_logger = { version = "0.11.3", features = ["unstable-kv"] }
+eppo_core = { version = "2.0.0" }
+log = { version = "0.4.21", features = ["kv_serde"] }
+magnus = { version = "0.6.2" }
+serde = { version = "1.0.203", features = ["derive"] }
+serde_magnus = "0.8.1"
+rb-sys = "0.9"

data/ext/eppo_client/build.rs

@@ -0,0 +1,5 @@
+fn main() {
+    // Without this flag, building via `cargo build` fails with undefined references to ruby
+    // library. This is fine as `eppo_client` is going to be loaded as an extension by the host Ruby.
+    println!("cargo:rustc-link-arg=-Wl,-undefined,dynamic_lookup");
+}

data/ext/eppo_client/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("eppo_client")

data/ext/eppo_client/src/client.rs

@@ -0,0 +1,178 @@
+use std::{cell::RefCell, sync::Arc};
+
+use eppo_core::{
+    configuration_fetcher::ConfigurationFetcher,
+    configuration_store::ConfigurationStore,
+    eval::{get_assignment, get_assignment_details, get_bandit_action, get_bandit_action_details},
+    poller_thread::PollerThread,
+    ufc::VariationType,
+    Attributes, ContextAttributes,
+};
+use magnus::{error::Result, exception, prelude::*, Error, TryConvert, Value};
+
+#[derive(Debug)]
+#[magnus::wrap(class = "EppoClient::Core::Config", size, free_immediately)]
+pub struct Config {
+    api_key: String,
+    base_url: String,
+}
+
+impl TryConvert for Config {
+    // `val` is expected to be of type EppoClient::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 })
+    }
+}
+
+#[magnus::wrap(class = "EppoClient::Core::Client")]
+pub struct Client {
+    configuration_store: Arc<ConfigurationStore>,
+    // Magnus only allows sharing aliased references (&T) through the API, so we need to use RefCell
+    // to get interior mutability.
+    //
+    // This should be safe as Ruby only uses a single OS thread, and `Client` lives in the Ruby
+    // world.
+    poller_thread: RefCell<Option<PollerThread>>,
+}
+
+impl Client {
+    pub fn new(config: Config) -> Client {
+        let configuration_store = Arc::new(ConfigurationStore::new());
+
+        let poller_thread = PollerThread::start(
+            ConfigurationFetcher::new(
+                eppo_core::configuration_fetcher::ConfigurationFetcherConfig {
+                    base_url: config.base_url,
+                    api_key: config.api_key,
+                    sdk_name: "ruby".to_owned(),
+                    sdk_version: env!("CARGO_PKG_VERSION").to_owned(),
+                },
+            ),
+            configuration_store.clone(),
+        )
+        .expect("should be able to start poller thread");
+
+        Client {
+            configuration_store,
+            poller_thread: RefCell::new(Some(poller_thread)),
+        }
+    }
+
+    pub fn get_assignment(
+        &self,
+        flag_key: String,
+        subject_key: String,
+        subject_attributes: Value,
+        expected_type: Value,
+    ) -> Result<Value> {
+        let expected_type: VariationType = serde_magnus::deserialize(expected_type)?;
+        let subject_attributes: Attributes = serde_magnus::deserialize(subject_attributes)?;
+
+        let config = self.configuration_store.get_configuration();
+        let result = get_assignment(
+            config.as_ref().map(AsRef::as_ref),
+            &flag_key,
+            &subject_key,
+            &subject_attributes,
+            Some(expected_type),
+        )
+        // TODO: maybe expose possible errors individually.
+        .map_err(|err| Error::new(exception::runtime_error(), err.to_string()))?;
+
+        Ok(serde_magnus::serialize(&result).expect("assignment value should be serializable"))
+    }
+
+    pub fn get_assignment_details(
+        &self,
+        flag_key: String,
+        subject_key: String,
+        subject_attributes: Value,
+        expected_type: Value,
+    ) -> Result<Value> {
+        let expected_type: VariationType = serde_magnus::deserialize(expected_type)?;
+        let subject_attributes: Attributes = serde_magnus::deserialize(subject_attributes)?;
+
+        let config = self.configuration_store.get_configuration();
+        let result = get_assignment_details(
+            config.as_ref().map(AsRef::as_ref),
+            &flag_key,
+            &subject_key,
+            &subject_attributes,
+            Some(expected_type),
+        );
+
+        Ok(serde_magnus::serialize(&result).expect("assignment value should be serializable"))
+    }
+
+    pub fn get_bandit_action(
+        &self,
+        flag_key: String,
+        subject_key: String,
+        subject_attributes: Value,
+        actions: Value,
+        default_variation: String,
+    ) -> Result<Value> {
+        let subject_attributes = serde_magnus::deserialize::<_, ContextAttributes>(
+            subject_attributes,
+        )
+        .map_err(|err| {
+            Error::new(
+                exception::runtime_error(),
+                format!("enexpected value for subject_attributes: {err}"),
+            )
+        })?;
+        let actions = serde_magnus::deserialize(actions)?;
+
+        let config = self.configuration_store.get_configuration();
+        let result = get_bandit_action(
+            config.as_ref().map(AsRef::as_ref),
+            &flag_key,
+            &subject_key,
+            &subject_attributes,
+            &actions,
+            &default_variation,
+        );
+
+        serde_magnus::serialize(&result)
+    }
+
+    pub fn get_bandit_action_details(
+        &self,
+        flag_key: String,
+        subject_key: String,
+        subject_attributes: Value,
+        actions: Value,
+        default_variation: String,
+    ) -> Result<Value> {
+        let subject_attributes = serde_magnus::deserialize::<_, ContextAttributes>(
+            subject_attributes,
+        )
+        .map_err(|err| {
+            Error::new(
+                exception::runtime_error(),
+                format!("enexpected value for subject_attributes: {err}"),
+            )
+        })?;
+        let actions = serde_magnus::deserialize(actions)?;
+
+        let config = self.configuration_store.get_configuration();
+        let result = get_bandit_action_details(
+            config.as_ref().map(AsRef::as_ref),
+            &flag_key,
+            &subject_key,
+            &subject_attributes,
+            &actions,
+            &default_variation,
+        );
+
+        serde_magnus::serialize(&result)
+    }
+
+    pub fn shutdown(&self) {
+        if let Some(t) = self.poller_thread.take() {
+            let _ = t.shutdown();
+        }
+    }
+}

data/ext/eppo_client/src/lib.rs

@@ -0,0 +1,34 @@
+mod client;
+
+use magnus::{function, method, prelude::*, Error, Object, Ruby};
+
+use crate::client::Client;
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    env_logger::Builder::from_env(env_logger::Env::new().default_filter_or("eppo")).init();
+
+    let eppo_client = ruby.define_module("EppoClient")?;
+    let core = eppo_client.define_module("Core")?;
+
+    let core_client = core.define_class("Client", magnus::class::object())?;
+    core_client.define_singleton_method("new", function!(Client::new, 1))?;
+    core_client.define_method("get_assignment", method!(Client::get_assignment, 4))?;
+    core_client.define_method(
+        "get_assignment_details",
+        method!(Client::get_assignment_details, 4),
+    )?;
+    core_client.define_method("get_bandit_action", method!(Client::get_bandit_action, 5))?;
+    core_client.define_method(
+        "get_bandit_action_details",
+        method!(Client::get_bandit_action_details, 5),
+    )?;
+    core_client.define_method("shutdown", method!(Client::shutdown, 0))?;
+
+    core.const_set(
+        "DEFAULT_BASE_URL",
+        eppo_core::configuration_fetcher::DEFAULT_BASE_URL,
+    )?;
+
+    Ok(())
+}

data/lib/eppo_client/assignment_logger.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'custom_errors'
+require_relative "custom_errors"
 
 module EppoClient
   # The base assignment logger class to override
   class AssignmentLogger
-    def log_assignment(_assignment)
-      raise(EppoClient::AssignmentLoggerError, 'log_assignment has not been set up')
+    def log_assignment(_assignment_event)
+      raise(EppoClient::AssignmentLoggerError, "log_assignment has not been set up")
+    end
+
+    def log_bandit_action(_assignment_event)
+      raise(EppoClient::AssignmentLoggerError, "log_bandit_action has not been set up")
     end
   end
 end