yggdrasil-engine 0.0.5.beta.19-universal-java-21

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ccce3b3e3107ce29e23caf7a912897e22aafc23399ea9c66913791b5e51e03b3
+  data.tar.gz: 7b7687b3f9ed21091459aeadbf5072d99dbcfb4826a2103b4e8ed93c25d6f882
+SHA512:
+  metadata.gz: 8c1bc8d32ed21d1ed663394fd3a4e0f807edcd03bfa22e05d9137f0d3fdea02650436abaf5dca5a1e039741cdf8fb86d4eb508cf0b98492f4046ee19eb2287a0
+  data.tar.gz: 919eda38482431332707273ca6193d8e2b24754137684cf8a5ecd7025be9bc79ad36b705dca81b5721d2f00a4de3d241462c7b043b5f1e911abb9e357e789ee9

data/README.md

@@ -0,0 +1,36 @@
+# Ruby Bindings to Yggdrasil
+
+## Running the tests
+
+First make sure that you have built the native FFI code and it's located in the right place. This can be done with the build script in `build.sh`:
+
+
+```bash
+./build.sh
+```
+
+Then you can run the tests with:
+
+```bash
+rspec
+```
+
+There's also a `mem_check.rb` in the scripts folder. This is not a bullet proof test, but it can be helpful for detecting large leaks. This requires human interaction - you need to read the output and understand what it's telling you, so it's not run as part of the test suite.
+
+```bash
+ruby scripts/mem_check.rb
+```
+
+## Build
+
+You can build the gem with:
+
+```bash
+gem build yggdrasil-engine.gemspec
+```
+
+Then you can install the gem for local development with:
+
+```
+gem install yggdrasil-engine-0.0.1.gem
+```

data/lib/custom_strategy.rb

@@ -0,0 +1,60 @@
+STANDARD_STRATEGIES = [
+  "default",
+  "userWithId",
+  "gradualRolloutUserId",
+  "gradualRolloutSessionId",
+  "gradualRolloutRandom",
+  "flexibleRollout",
+  "remoteAddress",
+].freeze
+
+class CustomStrategyHandler
+  def initialize
+    @custom_strategies_definitions = {}
+    @custom_strategy_implementations = {}
+  end
+
+  def update_strategies(json_str)
+    custom_strategies = {}
+    parsed_json = JSON.parse(json_str)
+
+    parsed_json["features"].each do |feature|
+      toggle_name = feature["name"]
+      strategies = feature["strategies"]
+
+      custom_strategies_for_toggle = strategies.select do |strategy|
+        !STANDARD_STRATEGIES.include?(strategy["name"])
+      end
+
+      unless custom_strategies_for_toggle.empty?
+        custom_strategies[toggle_name] = custom_strategies_for_toggle
+      end
+    end
+
+    @custom_strategies_definitions = custom_strategies
+  end
+
+  def register_custom_strategies(strategies)
+    strategies.each do |strategy|
+      if strategy.respond_to?(:name) && strategy.name.is_a?(String) &&
+         strategy.respond_to?(:enabled?)
+        @custom_strategy_implementations[strategy.name] = strategy
+      else
+        raise "Invalid strategy object. Must have a name method that returns a String and an enabled? method."
+      end
+    end
+  end
+
+  def evaluate_custom_strategies(toggle_name, context)
+    results = {}
+
+    @custom_strategies_definitions[toggle_name]&.each_with_index do |strategy, index|
+      key = "customStrategy#{index + 1}"
+      strategy_impl = @custom_strategy_implementations[strategy["name"]]
+      result = strategy_impl&.enabled?(strategy["parameters"], context) || false
+      results[key] = result
+    end
+
+    results
+  end
+end

data/lib/yggdrasil_engine.rb

@@ -0,0 +1,129 @@
+require 'ffi'
+require 'json'
+require 'custom_strategy'
+
+TOGGLE_MISSING_RESPONSE = 'NotFound'.freeze
+ERROR_RESPONSE = 'Error'.freeze
+OK_RESPONSE = 'Ok'.freeze
+
+def platform_specific_lib
+  os = RbConfig::CONFIG['host_os']
+  cpu = RbConfig::CONFIG['host_cpu']
+
+  extension = case os
+  when /darwin|mac os/
+    'dylib'
+  when /linux/
+    'so'
+  when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+    'dll'
+  else
+    raise "unsupported platform #{os}"
+  end
+
+  arch_suffix = case cpu
+  when /x86_64/
+    'x86_64'
+  when /arm|aarch64/
+    'arm64'
+  else
+    raise "unsupported architecture #{cpu}"
+  end
+
+  "libyggdrasilffi_#{arch_suffix}.#{extension}"
+end
+
+def to_variant(raw_variant)
+  payload = raw_variant[:payload] && raw_variant[:payload].transform_keys(&:to_s)
+  {
+    name: raw_variant[:name],
+    enabled: raw_variant[:enabled],
+    feature_enabled: raw_variant[:featureEnabled],
+    payload: payload,
+  }
+end
+
+class YggdrasilEngine
+  extend FFI::Library
+  ffi_lib File.expand_path(platform_specific_lib, __dir__)
+
+  attach_function :new_engine, [], :pointer
+  attach_function :free_engine, [:pointer], :void
+
+  attach_function :take_state, %i[pointer string], :pointer
+  attach_function :check_enabled, %i[pointer string string string], :pointer
+  attach_function :check_variant, %i[pointer string string string], :pointer
+  attach_function :get_metrics, [:pointer], :pointer
+  attach_function :free_response, [:pointer], :void
+
+  attach_function :count_toggle, %i[pointer string bool], :void
+  attach_function :count_variant, %i[pointer string string], :void
+
+  def initialize
+    @engine = YggdrasilEngine.new_engine
+    @custom_strategy_handler = CustomStrategyHandler.new
+    ObjectSpace.define_finalizer(self, self.class.finalize(@engine))
+  end
+
+  def self.finalize(engine)
+    proc { YggdrasilEngine.free_engine(engine) }
+  end
+
+  def take_state(toggles)
+    @custom_strategy_handler.update_strategies(toggles)
+    response_ptr = YggdrasilEngine.take_state(@engine, toggles)
+    take_toggles_response = JSON.parse(response_ptr.read_string, symbolize_names: true)
+    YggdrasilEngine.free_response(response_ptr)
+  end
+
+  def get_variant(name, context)
+    context_json = (context || {}).to_json
+    custom_strategy_results = @custom_strategy_handler.evaluate_custom_strategies(name, context).to_json
+
+    variant_def_json_ptr = YggdrasilEngine.check_variant(@engine, name, context_json, custom_strategy_results)
+    variant_def_json = variant_def_json_ptr.read_string
+    YggdrasilEngine.free_response(variant_def_json_ptr)
+    variant_response = JSON.parse(variant_def_json, symbolize_names: true)
+
+    return nil if variant_response[:status_code] == TOGGLE_MISSING_RESPONSE
+    variant = variant_response[:value]
+
+    return to_variant(variant) if variant_response[:status_code] == OK_RESPONSE
+  end
+
+  def enabled?(toggle_name, context)
+    context_json = (context || {}).to_json
+    custom_strategy_results = @custom_strategy_handler.evaluate_custom_strategies(toggle_name, context).to_json
+
+    response_ptr = YggdrasilEngine.check_enabled(@engine, toggle_name, context_json, custom_strategy_results)
+    response_json = response_ptr.read_string
+    YggdrasilEngine.free_response(response_ptr)
+    response = JSON.parse(response_json, symbolize_names: true)
+
+    raise "Error: #{response[:error_message]}" if response[:status_code] == ERROR_RESPONSE
+    return nil if response[:status_code] == TOGGLE_MISSING_RESPONSE
+
+    return response[:value] == true
+  end
+
+  def count_toggle(toggle_name, enabled)
+    response_ptr = YggdrasilEngine.count_toggle(@engine, toggle_name, enabled)
+    YggdrasilEngine.free_response(response_ptr)
+  end
+
+  def count_variant(toggle_name, variant_name)
+    response_ptr = YggdrasilEngine.count_variant(@engine, toggle_name, variant_name)
+    YggdrasilEngine.free_response(response_ptr)
+  end
+
+  def get_metrics
+    metrics_ptr = YggdrasilEngine.get_metrics(@engine)
+    metrics = JSON.parse(metrics_ptr.read_string, symbolize_names: true)
+    YggdrasilEngine.free_response(metrics_ptr)
+    metrics[:value]
+  end
+
+  def register_custom_strategies(strategies)
+    @custom_strategy_handler.register_custom_strategies(strategies)
+  end
+end

data/spec/custom_strategy_spec.rb

@@ -0,0 +1,136 @@
+require_relative '../lib/custom_strategy'
+
+RSpec.describe "custom strategies" do
+  let(:raw_state) do
+    {
+      "version": 1,
+      "features": [
+        {
+          "name": "Feature.A",
+          "enabled": true,
+          "strategies": [
+            {
+              "name": "default",
+              "parameters": {}
+            },
+            {
+              "name": "custom",
+              "parameters": {
+                "gerkhins": "yes"
+              }
+            },
+            {
+              "name": "some-other-custom",
+              "parameters": {
+                "gerkhins": "yes"
+              }
+            },
+          ]
+        }
+      ]
+    }
+  end
+
+  let(:handler) { CustomStrategyHandler.new }
+
+  before do
+    handler.update_strategies(raw_state.to_json)
+  end
+
+  describe 'computing custom strategies' do
+    it 'respects the logic contained in the enabled function' do
+      class TestStrategy
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def enabled?(params, context)
+          params["gerkhins"] == "yes"
+        end
+      end
+
+      handler.register_custom_strategies([TestStrategy.new("custom")])
+      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
+      expect(strategy_results.length).to eq(2)
+      expect(strategy_results["customStrategy1"]).to eq(true)
+      expect(strategy_results["customStrategy2"]).to eq(false)
+    end
+
+    it 'creates a strategy result for every custom strategy thats implemented and defined' do
+      class TestStrategy
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def enabled?(params, context)
+          params["gerkhins"] == "yes"
+        end
+      end
+
+      handler.register_custom_strategies([TestStrategy.new("custom"), TestStrategy.new("some-other-custom")])
+      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
+      expect(strategy_results.length).to eq(2)
+      expect(strategy_results["customStrategy1"]).to eq(true)
+      expect(strategy_results["customStrategy2"]).to eq(true)
+    end
+
+    it 'returns false for missing implementations' do
+      handler.register_custom_strategies([])
+      strategy_results = handler.evaluate_custom_strategies("Feature.A", {})
+      expect(strategy_results.length).to eq(2)
+      expect(strategy_results["customStrategy1"]).to eq(false)
+    end
+
+    it "should calculate custom strategies e2e" do
+      class TestStrategy
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def enabled?(params, context)
+          context[:userId] == "123"
+        end
+      end
+
+      state = {
+        "version": 1,
+        "features": [
+          {
+            "name": "Feature.A",
+            "enabled": true,
+            "strategies": [
+              {
+                "name": "custom",
+                "parameters": {
+                  "gerkhins": "yes"
+                }
+              }
+            ]
+          }
+        ]
+      }
+
+      engine = YggdrasilEngine.new
+      engine.register_custom_strategies([TestStrategy.new("custom")])
+
+      engine.take_state(state.to_json)
+
+      should_be_enabled = engine.enabled?("Feature.A", {
+                                            userId: "123"
+                                          })
+
+      should_not_be_enabled = engine.enabled?("Feature.A", {
+                                                userId: "456"
+                                              })
+
+      expect(should_be_enabled).to eq(true)
+      expect(should_not_be_enabled).to eq(false)
+    end
+  end
+end

data/spec/yggdrasil_engine_spec.rb

@@ -0,0 +1,151 @@
+require 'rspec'
+require 'json'
+require_relative '../lib/yggdrasil_engine'
+
+index_file_path = '../client-specification/specifications/index.json'
+test_suites = JSON.parse(File.read(index_file_path))
+
+def test_suite_variant(base_variant)
+  payload = base_variant[:payload] && base_variant[:payload].transform_keys(&:to_s)
+  {
+    name: base_variant[:name],
+    enabled: base_variant[:enabled],
+    feature_enabled: base_variant[:feature_enabled],
+    payload: payload,
+  }
+end
+
+RSpec.describe YggdrasilEngine do
+  let(:yggdrasil_engine) { YggdrasilEngine.new }
+
+  describe '#checking a toggle' do
+    it 'that does not exist should yield a not found' do
+      is_enabled = yggdrasil_engine.enabled?('missing-toggle', {})
+      expect(is_enabled).to be_nil
+    end
+  end
+
+  describe '#metrics' do
+    it 'should clear metrics when get_metrics is called' do
+      feature_name = 'Feature.A'
+
+      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
+      suite_data = JSON.parse(File.read(suite_path))
+
+      yggdrasil_engine.take_state(suite_data['state'].to_json)
+
+      yggdrasil_engine.count_toggle(feature_name, true)
+      yggdrasil_engine.count_toggle(feature_name, false)
+
+      metrics = yggdrasil_engine.get_metrics() # This should clear the metrics buffer
+
+      metric = metrics[:toggles][feature_name.to_sym]
+      expect(metric[:yes]).to eq(1)
+      expect(metric[:no]).to eq(1)
+
+      metrics = yggdrasil_engine.get_metrics()
+      expect(metrics).to be_nil
+    end
+
+    it 'should increment toggle count when it exists' do
+      toggle_name = 'Feature.A'
+
+      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
+      suite_data = JSON.parse(File.read(suite_path))
+
+      yggdrasil_engine.take_state(suite_data['state'].to_json)
+
+      yggdrasil_engine.count_toggle(toggle_name, true)
+      yggdrasil_engine.count_toggle(toggle_name, false)
+
+      metrics = yggdrasil_engine.get_metrics()
+      metric = metrics[:toggles][toggle_name.to_sym]
+
+      expect(metric[:yes]).to eq(1)
+      expect(metric[:no]).to eq(1)
+    end
+
+    it 'should increment toggle count when the toggle does not exist' do
+      toggle_name = 'Feature.X'
+
+      yggdrasil_engine.count_toggle(toggle_name, true)
+      yggdrasil_engine.count_toggle(toggle_name, false)
+
+      metrics = yggdrasil_engine.get_metrics()
+      metric = metrics[:toggles][toggle_name.to_sym]
+
+      expect(metric[:yes]).to eq(1)
+      expect(metric[:no]).to eq(1)
+    end
+
+    it 'should increment variant' do
+      toggle_name = 'Feature.Q'
+
+      suite_path = File.join('../client-specification/specifications', '01-simple-examples.json')
+      suite_data = JSON.parse(File.read(suite_path))
+
+      yggdrasil_engine.take_state(suite_data['state'].to_json)
+
+      yggdrasil_engine.count_variant(toggle_name, 'disabled')
+
+      metrics = yggdrasil_engine.get_metrics()
+      metric = metrics[:toggles][toggle_name.to_sym]
+
+      expect(metric[:variants][:disabled]).to eq(1)
+    end
+  end
+end
+
+RSpec.describe 'Client Specification' do
+  let(:yggdrasil_engine) { YggdrasilEngine.new }
+
+  test_suites.each do |suite|
+    suite_path = File.join('../client-specification/specifications', suite)
+    suite_data = JSON.parse(File.read(suite_path), symbolize_names: true)
+
+    describe "Suite '#{suite}'" do
+      before(:each) do
+        yggdrasil_engine.take_state(suite_data[:state].to_json)
+      end
+
+      suite_data.fetch(:tests, []).each do |test|
+        describe "Test '#{test[:description]}'" do
+          let(:context) { test[:context] }
+          let(:toggle_name) { test[:toggleName] }
+          let(:expected_result) { test[:expectedResult] }
+
+          it 'returns correct result for `is_enabled?` method' do
+            result = yggdrasil_engine.enabled?(toggle_name, context) || false
+
+            expect(result).to eq(expected_result),
+                              "Failed test '#{test['description']}': expected #{expected_result}, got #{result}"
+          end
+        end
+      end
+
+      suite_data.fetch(:variantTests, []).each do |test|
+        next unless test[:expectedResult]
+
+        describe "Variant Test '#{test[:description]}'" do
+          let(:context) { test[:context] }
+          let(:toggle_name) { test[:toggleName] }
+          let(:expected_result) { test_suite_variant(test[:expectedResult]) }
+
+          it 'returns correct result for `get_variant` method' do
+            result = yggdrasil_engine.get_variant(toggle_name, context) || {
+              :name => 'disabled',
+              :payload => nil,
+              :enabled => false,
+              :feature_enabled => false
+            }
+
+            expect(result[:name]).to eq(expected_result[:name])
+            expect(result[:payload]).to eq(expected_result[:payload])
+            expect(result[:enabled]).to eq(expected_result[:enabled])
+            expect(result[:feature_enabled]).to eq(expected_result[:feature_enabled])
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: yggdrasil-engine
+version: !ruby/object:Gem::Version
+  version: 0.0.5.beta.19
+platform: universal-java-21
+authors:
+- Unleash
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-06-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.15.5
+  name: ffi
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.15.5
+description: "..."
+email: liquidwicked64@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/custom_strategy.rb
+- lib/libyggdrasilffi_arm64.dylib
+- lib/libyggdrasilffi_x86_64.dll
+- lib/libyggdrasilffi_x86_64.dylib
+- lib/libyggdrasilffi_x86_64.so
+- lib/yggdrasil_engine.rb
+- spec/custom_strategy_spec.rb
+- spec/yggdrasil_engine_spec.rb
+homepage: http://github.com/username/my_gem
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Unleash engine for evaluating feature toggles
+test_files: []