amplitude-experiment 1.5.0 → 1.7.0

data/lib/experiment/evaluation/semantic_version.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class SemanticVersion
+  include Comparable
+
+  attr_reader :major, :minor, :patch, :pre_release
+
+  MAJOR_MINOR_REGEX = '(\d+)\.(\d+)'
+  PATCH_REGEX = '(\d+)'
+  PRERELEASE_REGEX = '(-(([-\w]+\.?)*))?'
+  VERSION_PATTERN = /^#{MAJOR_MINOR_REGEX}(\.#{PATCH_REGEX}#{PRERELEASE_REGEX})?$/.freeze
+
+  def initialize(major, minor, patch, pre_release = nil)
+    @major = major
+    @minor = minor
+    @patch = patch
+    @pre_release = pre_release
+  end
+
+  def self.parse(version)
+    return nil if version.nil?
+
+    match = VERSION_PATTERN.match(version)
+    return nil unless match
+
+    major = match[1].to_i
+    minor = match[2].to_i
+    patch = match[4]&.to_i || 0
+    pre_release = match[5]
+
+    new(major, minor, patch, pre_release)
+  end
+
+  def <=>(other)
+    return nil unless other.is_a?(SemanticVersion)
+
+    result = major <=> other.major
+    return result unless result.zero?
+
+    result = minor <=> other.minor
+    return result unless result.zero?
+
+    result = patch <=> other.patch
+    return result unless result.zero?
+
+    return 1 if !pre_release && other.pre_release
+    return -1 if pre_release && !other.pre_release
+    return 0 if !pre_release && !other.pre_release
+
+    pre_release <=> other.pre_release
+  end
+end

data/lib/experiment/evaluation/topological_sort.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class CycleError < StandardError
+  attr_accessor :path
+
+  def initialize(path)
+    super("Detected a cycle between flags #{path}")
+    self.path = path
+  end
+end
+
+# Performs topological sorting of feature flags based on their dependencies
+class TopologicalSort
+  # Sort flags topologically based on their dependencies
+  def self.sort(flags, flag_keys = nil)
+    available = flags.clone
+    result = []
+    starting_keys = flag_keys.nil? || flag_keys.empty? ? flags.keys : flag_keys
+
+    starting_keys.each do |flag_key|
+      traversal = parent_traversal(flag_key, available)
+      result.concat(traversal) if traversal
+    end
+
+    result
+  end
+
+  # Perform depth-first traversal of flag dependencies
+  def self.parent_traversal(flag_key, available, path = [])
+    flag = available[flag_key]
+    return nil unless flag
+
+    # No dependencies - return flag and remove from available
+    if !flag.dependencies || flag.dependencies.empty?
+      available.delete(flag.key)
+      return [flag]
+    end
+
+    # Check for cycles
+    path.push(flag.key)
+    result = []
+
+    flag.dependencies.each do |parent_key|
+      raise CycleError, path if path.any? { |p| p == parent_key }
+
+      traversal = parent_traversal(parent_key, available, path)
+      result.concat(traversal) if traversal
+    end
+
+    result.push(flag)
+    path.pop
+    available.delete(flag.key)
+
+    result
+  end
+end

data/lib/experiment/flag/flag_config_fetcher.rb

@@ -44,7 +44,7 @@ module AmplitudeExperiment
       raise "flagConfigs - received error response: #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPOK)
 
       @logger.debug("[Experiment] Fetch flag configs: #{response.body}")
-      JSON.parse(response.body)
+      JSON.parse(response.body).map { |f| Evaluation::Flag.from_hash(f) }
     end
 
     # Fetch local evaluation mode flag configs from the Experiment API server.

data/lib/experiment/flag/flag_config_storage.rb

@@ -40,7 +40,7 @@ module AmplitudeExperiment
 
     def put_flag_config(flag_config)
       @flag_configs_lock.synchronize do
-        @flag_configs[flag_config['key']] = flag_config
+        @flag_configs[flag_config.key] = flag_config
       end
     end
 

data/lib/experiment/local/client.rb

@@ -12,19 +12,15 @@ module AmplitudeExperiment
     # @param [LocalEvaluationConfig] config The config object
 
     def initialize(api_key, config = nil)
-      require 'experiment/local/evaluation/evaluation'
       @api_key = api_key
       @config = config || LocalEvaluationConfig.new
+      @logger = @config.logger
       @flags = nil
       @flags_mutex = Mutex.new
-      @logger = Logger.new($stdout)
-      @logger.level = if @config.debug
-                        Logger::DEBUG
-                      else
-                        Logger::INFO
-                      end
       raise ArgumentError, 'Experiment API key is empty' if @api_key.nil? || @api_key.empty?
 
+      @engine = Evaluation::Engine.new
+
       @assignment_service = nil
       @assignment_service = AssignmentService.new(AmplitudeAnalytics::Amplitude.new(config.assignment_config.api_key, configuration: config.assignment_config), AssignmentFilter.new(config.assignment_config.cache_capacity)) if config&.assignment_config
 
@@ -67,15 +63,13 @@ module AmplitudeExperiment
       flags = @flag_config_storage.flag_configs
       return {} if flags.nil?
 
-      sorted_flags = AmplitudeExperiment.topological_sort(flags, flag_keys.to_set)
+      sorted_flags = TopologicalSort.sort(flags, flag_keys)
       required_cohorts_in_storage(sorted_flags)
-      flags_json = sorted_flags.to_json
       user = enrich_user_with_cohorts(user, flags) if @config.cohort_sync_config
       context = AmplitudeExperiment.user_to_evaluation_context(user)
-      context_json = context.to_json
 
-      @logger.debug("[Experiment] Evaluate: User: #{context_json} - Rules: #{flags}") if @config.debug
-      result = evaluation(flags_json, context_json)
+      @logger.debug("[Experiment] Evaluate: User: #{context} - Rules: #{flags}") if @config.debug
+      result = @engine.evaluate(context, sorted_flags)
       @logger.debug("[Experiment] evaluate - result: #{result}") if @config.debug
       variants = AmplitudeExperiment.evaluation_variants_json_to_variants(result)
       @assignment_service&.track(Assignment.new(user, variants))
@@ -113,9 +107,9 @@ module AmplitudeExperiment
         missing_cohorts_str = "[#{missing_cohorts.map(&:to_s).join(', ')}]"
 
         message = if @config.cohort_sync_config
-                    "Evaluating flag #{flag['key']} dependent on cohorts #{cohort_ids_str} without #{missing_cohorts_str} in storage"
+                    "Evaluating flag #{flag.key} dependent on cohorts #{cohort_ids_str} without #{missing_cohorts_str} in storage"
                   else
-                    "Evaluating flag #{flag['key']} dependent on cohorts #{cohort_ids_str} without cohort syncing configured"
+                    "Evaluating flag #{flag.key} dependent on cohorts #{cohort_ids_str} without cohort syncing configured"
                   end
 
         @logger.warn(message)

data/lib/experiment/local/config.rb

@@ -1,3 +1,5 @@
+require 'logger'
+
 module AmplitudeExperiment
   module ServerZone
     US = 'US'.freeze
@@ -9,11 +11,17 @@ module AmplitudeExperiment
     # Default server url
     DEFAULT_SERVER_URL = 'https://api.lab.amplitude.com'.freeze
     EU_SERVER_URL = 'https://flag.lab.eu.amplitude.com'.freeze
+    DEFAULT_LOGDEV = $stdout
+    DEFAULT_LOG_LEVEL = Logger::ERROR
 
     # Set to true to log some extra information to the console.
     # @return [Boolean] the value of debug
     attr_accessor :debug
 
+    # Set the client logger to a user defined [Logger]
+    # @return [Logger] the logger instance of the client
+    attr_accessor :logger
+
     # The server endpoint from which to request variants.
     # @return [String] the value of server url
     attr_accessor :server_url
@@ -35,16 +43,26 @@ module AmplitudeExperiment
     attr_accessor :cohort_sync_config
 
     # @param [Boolean] debug Set to true to log some extra information to the console.
+    # @param [Logger] logger instance to be used for all client logging behavior
     # @param [String] server_url The server endpoint from which to request variants.
     # @param [String] server_zone Location of the Amplitude data center to get flags and cohorts from, US or EU
     # @param [Hash] bootstrap The value of bootstrap.
     # @param [long] flag_config_polling_interval_millis The value of flag config polling interval in million seconds.
     # @param [AssignmentConfig] assignment_config Configuration for automatically tracking assignment events after an evaluation.
     # @param [CohortSyncConfig] cohort_sync_config Configuration for downloading cohorts required for flag evaluation
-    def initialize(server_url: DEFAULT_SERVER_URL, server_zone: ServerZone::US, bootstrap: {},
-                   flag_config_polling_interval_millis: 30_000, debug: false, assignment_config: nil,
+    def initialize(server_url: DEFAULT_SERVER_URL,
+                   server_zone: ServerZone::US,
+                   bootstrap: {},
+                   flag_config_polling_interval_millis: 30_000,
+                   debug: false,
+                   logger: nil,
+                   assignment_config: nil,
                    cohort_sync_config: nil)
-      @debug = debug || false
+      @logger = logger
+      if logger.nil?
+        @logger = Logger.new(DEFAULT_LOGDEV)
+        @logger.level = debug ? Logger::DEBUG : DEFAULT_LOG_LEVEL
+      end
       @server_url = server_url
       @server_zone = server_zone
       @cohort_sync_config = cohort_sync_config

data/lib/experiment/persistent_http_client.rb

@@ -5,7 +5,7 @@ module AmplitudeExperiment
   # WARNING: these connections are not safe for concurrent requests. Callers
   # must synchronize requests per connection.
   class PersistentHttpClient
-    DEFAULT_OPTIONS = { read_timeout: 80 }.freeze
+    DEFAULT_OPTIONS = { open_timeout: 60, read_timeout: 80 }.freeze
 
     class << self
       # url: URI / String

data/lib/experiment/remote/client.rb

@@ -13,12 +13,7 @@ module AmplitudeExperiment
     def initialize(api_key, config = nil)
       @api_key = api_key
       @config = config || RemoteEvaluationConfig.new
-      @logger = Logger.new($stdout)
-      @logger.level = if @config.debug
-                        Logger::DEBUG
-                      else
-                        Logger::INFO
-                      end
+      @logger = @config.logger
       endpoint = "#{@config.server_url}/sdk/v2/vardata?v=0"
       @uri = URI(endpoint)
       raise ArgumentError, 'Experiment API key is empty' if @api_key.nil? || @api_key.empty?
@@ -89,7 +84,7 @@ module AmplitudeExperiment
     # @param [User] user
     def fetch_internal(user)
       @logger.debug("[Experiment] Fetching variants for user: #{user.as_json}")
-      do_fetch(user, @config.fetch_timeout_millis)
+      do_fetch(user, @config.connect_timeout_millis, @config.fetch_timeout_millis)
     rescue StandardError => e
       @logger.error("[Experiment] Fetch failed: #{e.message}")
       if should_retry_fetch?(e)
@@ -112,7 +107,7 @@ module AmplitudeExperiment
       @config.fetch_retries.times do
         sleep(delay_millis.to_f / 1000.0)
         begin
-          return do_fetch(user, @config.fetch_retry_timeout_millis)
+          return do_fetch(user, @config.connect_timeout_millis, @config.fetch_retry_timeout_millis)
         rescue StandardError => e
           @logger.error("[Experiment] Retry failed: #{e.message}")
           err = e
@@ -123,16 +118,18 @@ module AmplitudeExperiment
     end
 
     # @param [User] user
-    # @param [Integer] timeout_millis
-    def do_fetch(user, timeout_millis)
+    # @param [Integer] connect_timeout_millis
+    # @param [Integer] fetch_timeout_millis
+    def do_fetch(user, connect_timeout_millis, fetch_timeout_millis)
       start_time = Time.now
       user_context = add_context(user)
       headers = {
         'Authorization' => "Api-Key #{@api_key}",
         'Content-Type' => 'application/json;charset=utf-8'
       }
-      read_timeout = timeout_millis.to_f / 1000 if (timeout_millis.to_f / 1000) > 0
-      http = PersistentHttpClient.get(@uri, { read_timeout: read_timeout }, @api_key)
+      connect_timeout = connect_timeout_millis.to_f / 1000 if (connect_timeout_millis.to_f / 1000) > 0
+      read_timeout = fetch_timeout_millis.to_f / 1000 if (fetch_timeout_millis.to_f / 1000) > 0
+      http = PersistentHttpClient.get(@uri, { open_timeout: connect_timeout, read_timeout: read_timeout }, @api_key)
       request = Net::HTTP::Post.new(@uri, headers)
       request.body = user_context.to_json
       @logger.warn("[Experiment] encoded user object length #{request.body.length} cannot be cached by CDN; must be < 8KB") if request.body.length > 8000

data/lib/experiment/remote/config.rb

@@ -1,17 +1,29 @@
+require 'logger'
+
 module AmplitudeExperiment
   # Configuration
   class RemoteEvaluationConfig
     # Default server url
     DEFAULT_SERVER_URL = 'https://api.lab.amplitude.com'.freeze
+    DEFAULT_LOGDEV = $stdout
+    DEFAULT_LOG_LEVEL = Logger::ERROR
 
     # Set to true to log some extra information to the console.
     # @return [Boolean] the value of debug
     attr_accessor :debug
 
+    # Set the client logger to a user defined [Logger]
+    # @return [Logger] the logger instance of the client
+    attr_accessor :logger
+
     # The server endpoint from which to request variants.
     # @return [Boolean] the value of server url
     attr_accessor :server_url
 
+    # The request connection open timeout, in milliseconds, used when fetching variants triggered by calling start() or setUser().
+    # @return [Integer] the value of connect_timeout_millis
+    attr_accessor :connect_timeout_millis
+
     # The request timeout, in milliseconds, used when fetching variants triggered by calling start() or setUser().
     # @return [Integer] the value of fetch_timeout_millis
     attr_accessor :fetch_timeout_millis
@@ -39,7 +51,10 @@ module AmplitudeExperiment
     attr_accessor :fetch_retry_timeout_millis
 
     # @param [Boolean] debug Set to true to log some extra information to the console.
+    # @param [Logger] logger instance to be used for all client logging behavior
     # @param [String] server_url The server endpoint from which to request variants.
+    # @param [Integer] connect_timeout_millis The request connection open timeout, in milliseconds, used when
+    #  fetching variants triggered by calling start() or setUser().
     # @param [Integer] fetch_timeout_millis The request timeout, in milliseconds, used when fetching variants
     #  triggered by calling start() or setUser().
     # @param [Integer] fetch_retries The number of retries to attempt before failing.
@@ -49,11 +64,23 @@ module AmplitudeExperiment
     #  greater than the max, the max is used for all subsequent retries.
     # @param [Float] fetch_retry_backoff_scalar Scales the minimum backoff exponentially.
     # @param [Integer] fetch_retry_timeout_millis The request timeout for retrying fetch requests.
-    def initialize(debug: false, server_url: DEFAULT_SERVER_URL, fetch_timeout_millis: 10_000, fetch_retries: 0,
-                   fetch_retry_backoff_min_millis: 500, fetch_retry_backoff_max_millis: 10_000,
-                   fetch_retry_backoff_scalar: 1.5, fetch_retry_timeout_millis: 10_000)
-      @debug = debug
+    def initialize(debug: false,
+                   logger: nil,
+                   server_url: DEFAULT_SERVER_URL,
+                   connect_timeout_millis: 60_000,
+                   fetch_timeout_millis: 10_000,
+                   fetch_retries: 0,
+                   fetch_retry_backoff_min_millis: 500,
+                   fetch_retry_backoff_max_millis: 10_000,
+                   fetch_retry_backoff_scalar: 1.5,
+                   fetch_retry_timeout_millis: 10_000)
+      @logger = logger
+      if logger.nil?
+        @logger = Logger.new(DEFAULT_LOGDEV)
+        @logger.level = debug ? Logger::DEBUG : DEFAULT_LOG_LEVEL
+      end
       @server_url = server_url
+      @connect_timeout_millis = connect_timeout_millis
       @fetch_timeout_millis = fetch_timeout_millis
       @fetch_retries = fetch_retries
       @fetch_retry_backoff_min_millis = fetch_retry_backoff_min_millis

data/lib/experiment/util/flag_config.rb

@@ -1,35 +1,35 @@
 module AmplitudeExperiment
   def self.cohort_filter?(condition)
-    ['set contains any', 'set does not contain any'].include?(condition['op']) &&
-      condition['selector'] &&
-      condition['selector'][-1] == 'cohort_ids'
+    ['set contains any', 'set does not contain any'].include?(condition.op) &&
+      condition.selector &&
+      condition.selector[-1] == 'cohort_ids'
   end
 
   def self.get_grouped_cohort_condition_ids(segment)
     cohort_ids = {}
-    conditions = segment['conditions'] || []
+    conditions = segment.conditions || []
     conditions.each do |condition|
       condition = condition[0]
-      next unless cohort_filter?(condition) && (condition['selector'][1].length > 2)
+      next unless cohort_filter?(condition) && (condition.selector[1].length > 2)
 
-      context_subtype = condition['selector'][1]
+      context_subtype = condition.selector[1]
       group_type =
         if context_subtype == 'user'
           USER_GROUP_TYPE
-        elsif condition['selector'].include?('groups')
-          condition['selector'][2]
+        elsif condition.selector.include?('groups')
+          condition.selector[2]
         else
           next
         end
       cohort_ids[group_type] ||= Set.new
-      cohort_ids[group_type].merge(condition['values'])
+      cohort_ids[group_type].merge(condition.values)
     end
     cohort_ids
   end
 
   def self.get_grouped_cohort_ids_from_flag(flag)
     cohort_ids = {}
-    segments = flag['segments'] || []
+    segments = flag.segments || []
     segments.each do |segment|
       get_grouped_cohort_condition_ids(segment).each do |key, values|
         cohort_ids[key] ||= Set.new

data/lib/experiment/version.rb

@@ -1,3 +1,3 @@
 module AmplitudeExperiment
-  VERSION = '1.5.0'.freeze
+  VERSION = '1.7.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: amplitude-experiment
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Amplitude
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-27 00:00:00.000000000 Z
+date: 2025-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -17,7 +17,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.2.2
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '6.4'
+        version: '6.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '6.4'
+        version: '6.10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -151,19 +151,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.8.1
 - !ruby/object:Gem::Dependency
-  name: ffi
+  name: jar-dependencies
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.15'
-  type: :runtime
+        version: 0.4.1
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: 0.4.1
 description: Amplitude Experiment Ruby Server SDK
 email:
 - sdk@amplitude.com
@@ -197,6 +197,12 @@ files:
 - lib/experiment/cookie.rb
 - lib/experiment/deployment/deployment_runner.rb
 - lib/experiment/error.rb
+- lib/experiment/evaluation/evaluation.rb
+- lib/experiment/evaluation/flag.rb
+- lib/experiment/evaluation/murmur3.rb
+- lib/experiment/evaluation/select.rb
+- lib/experiment/evaluation/semantic_version.rb
+- lib/experiment/evaluation/topological_sort.rb
 - lib/experiment/factory.rb
 - lib/experiment/flag/flag_config_fetcher.rb
 - lib/experiment/flag/flag_config_storage.rb
@@ -206,15 +212,6 @@ files:
 - lib/experiment/local/assignment/assignment_service.rb
 - lib/experiment/local/client.rb
 - lib/experiment/local/config.rb
-- lib/experiment/local/evaluation/evaluation.rb
-- lib/experiment/local/evaluation/lib/linuxArm64/libevaluation_interop.so
-- lib/experiment/local/evaluation/lib/linuxArm64/libevaluation_interop_api.h
-- lib/experiment/local/evaluation/lib/linuxX64/libevaluation_interop.so
-- lib/experiment/local/evaluation/lib/linuxX64/libevaluation_interop_api.h
-- lib/experiment/local/evaluation/lib/macosArm64/libevaluation_interop.dylib
-- lib/experiment/local/evaluation/lib/macosArm64/libevaluation_interop_api.h
-- lib/experiment/local/evaluation/lib/macosX64/libevaluation_interop.dylib
-- lib/experiment/local/evaluation/lib/macosX64/libevaluation_interop_api.h
 - lib/experiment/persistent_http_client.rb
 - lib/experiment/remote/client.rb
 - lib/experiment/remote/config.rb
@@ -223,7 +220,6 @@ files:
 - lib/experiment/util/hash.rb
 - lib/experiment/util/lru_cache.rb
 - lib/experiment/util/poller.rb
-- lib/experiment/util/topological_sort.rb
 - lib/experiment/util/user.rb
 - lib/experiment/util/variant.rb
 - lib/experiment/variant.rb
@@ -233,7 +229,7 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'false'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -249,7 +245,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Amplitude Experiment Ruby Server SDK
 test_files: []

data/lib/experiment/local/evaluation/evaluation.rb

@@ -1,76 +0,0 @@
-# rubocop:disable all
-require 'ffi'
-require 'json'
-
-# The evaluation wrapper
-module EvaluationInterop
-  extend FFI::Library
-  host_os = RbConfig::CONFIG['host_os']
-  cpu = RbConfig::CONFIG['host_cpu']
-  evaluation_dir = File.dirname(__FILE__)
-  ffi_lib ["#{evaluation_dir}/lib/macosX64/libevaluation_interop.dylib"] if host_os =~ /darwin|mac os/ && cpu =~ /x86_64/
-  ffi_lib ["#{evaluation_dir}/lib/macosArm64/libevaluation_interop.dylib"] if host_os =~ /darwin|mac os/ && cpu =~ /arm64/
-  ffi_lib ["#{evaluation_dir}/lib/linuxX64/libevaluation_interop.so"] if host_os =~ /linux/ && cpu =~ /x86_64/
-  ffi_lib ["#{evaluation_dir}/lib/linuxArm64/libevaluation_interop.so"] if host_os =~ /linux/ && cpu =~ /arm64|aarch64/
-
-  class Root < FFI::Struct
-    layout :evaluate, callback([:string, :string], :pointer)
-  end
-
-  class Kotlin < FFI::Struct
-    layout :root, Root
-  end
-
-  class Libevaluation_interop_ExportedSymbols < FFI::Struct
-    layout :DisposeStablePointer, callback([:pointer], :void),
-           :DisposeString, callback([:pointer], :void),
-           :IsInstance, callback([:pointer, :string], :pointer),
-           :createNullableByte, callback([:string], :pointer),
-           :getNonNullValueOfByte, callback([:pointer], :pointer),
-           :createNullableShort, callback([:pointer], :pointer),
-           :getNonNullValueOfShort, callback([:pointer], :pointer),
-           :createNullableInt, callback([:pointer], :pointer),
-           :getNonNullValueOfInt, callback([:pointer], :pointer),
-           :createNullableLong, callback([:pointer], :pointer),
-           :getNonNullValueOfLong, callback([:pointer], :pointer),
-           :createNullableFloat, callback([:pointer], :pointer),
-           :getNonNullValueOfFloat, callback([:pointer], :pointer),
-           :createNullableDouble, callback([:pointer], :pointer),
-           :getNonNullValueOfDouble, callback([:pointer], :pointer),
-           :createNullableChar, callback([:pointer], :pointer),
-           :getNonNullValueOfChar, callback([:pointer], :pointer),
-           :createNullableBoolean, callback([:pointer], :pointer),
-           :getNonNullValueOfBoolean, callback([:pointer], :pointer),
-           :createNullableUnit, callback([], :pointer),
-           :createNullableUByte, callback([:pointer], :pointer),
-           :getNonNullValueOfUByte, callback([:pointer], :pointer),
-           :createNullableUShort, callback([:pointer], :pointer),
-           :getNonNullValueOfUShort, callback([:pointer], :pointer),
-           :createNullableUInt, callback([:pointer], :pointer),
-           :getNonNullValueOfUInt, callback([:pointer], :pointer),
-           :createNullableULong, callback([:pointer], :pointer),
-           :getNonNullValueOfULong, callback([:pointer], :pointer),
-
-           :kotlin, Kotlin
-  end
-
-  attach_function :libevaluation_interop_symbols, [], Libevaluation_interop_ExportedSymbols.by_ref
-end
-
-def evaluation(rule_json, context_json)
-  lib = EvaluationInterop.libevaluation_interop_symbols()
-  evaluate = lib[:kotlin][:root][:evaluate]
-  dispose = lib[:DisposeString]
-  result_raw = evaluate.call(rule_json, context_json)
-  result_json = result_raw.read_string
-  result = JSON.parse(result_json)
-  dispose.call(result_raw)
-
-  if result["error"] != nil
-    raise "#{result["error"]}"
-  elsif result["result"] == nil
-    raise "Evaluation result is nil."
-  end
-  result["result"]
-end
-# rubocop:disable all