eppo-server-sdk 0.3.0 → 3.0.0

data/lib/eppo_client/http_client.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-require 'faraday/retry'
-
-require_relative 'custom_errors'
-
-REQUEST_TIMEOUT_SECONDS = 2
-# This applies only to failed DNS lookups and connection timeouts,
-# never to requests where data has made it to the server.
-MAX_RETRIES = 3
-
-module EppoClient
-  # The SDK params object
-  class SdkParams
-    attr_reader :api_key, :sdk_name, :sdk_version
-
-    def initialize(api_key, sdk_name, sdk_version)
-      @api_key = api_key
-      @sdk_name = sdk_name
-      @sdk_version = sdk_version
-    end
-
-    # attributes are camelCase because that's what the backend endpoint expects
-    def formatted
-      {
-        'apiKey' => api_key,
-        'sdkName' => sdk_name,
-        'sdkVersion' => sdk_version
-      }
-    end
-
-    # Hide instance variables (specifically api_key) from logs
-    def inspect
-      "#<EppoClient::SdkParams:#{object_id}>"
-    end
-  end
-
-  # The http request client with retry/timeout behavior
-  class HttpClient
-    attr_reader :is_unauthorized
-
-    @retry_options = {
-      max: MAX_RETRIES,
-      interval: 0.05,
-      interval_randomness: 0.5,
-      backoff_factor: 2,
-      exceptions: ['Timeout::Error']
-    }
-
-    def initialize(base_url, sdk_params)
-      @base_url = base_url
-      @sdk_params = sdk_params
-      @is_unauthorized = false
-    end
-
-    def get(resource)
-      conn = Faraday::Connection.new(@base_url, params: @sdk_params) do |f|
-        f.request :retry, @retry_options
-      end
-      conn.options.timeout = REQUEST_TIMEOUT_SECONDS
-      response = conn.get(resource)
-      @is_unauthorized = response.status == 401
-      raise get_http_error(response.status, resource) if response.status != 200
-
-      JSON.parse(response.body)
-    end
-
-    private
-
-    def get_http_error(status_code, resource)
-      EppoClient::HttpRequestError.new("HTTP #{status_code} error while requesting resource #{resource}", status_code)
-    end
-  end
-end

data/lib/eppo_client/lru_cache.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module EppoClient
-  # The LRU cache relies on the fact that Ruby's Hash class maintains insertion order. So deleting
-  # and re-inserting a key-value pair on access moves the key to the last position. When an
-  # entry is added and the cache is full, the first entry is removed.
-  class LRUCache
-    attr_reader :cache, :size
-
-    # Creates a new LRUCache that can hold +size+ entries.
-    def initialize(size)
-      @size = size
-      @cache = {}
-    end
-
-    # Returns the stored value for +key+ or +nil+ if no value was stored under the key.
-    def [](key)
-      (val = @cache.delete(key)).nil? ? nil : @cache[key] = val
-    end
-
-    # Stores the +value+ under the +key+.
-    def []=(key, value)
-      @cache.delete(key)
-      @cache[key] = value
-      @cache.shift if @cache.length > @size
-    end
-  end
-end

data/lib/eppo_client/poller.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'concurrent/atom'
-
-# The poller
-module EppoClient
-  # The poller class invokes a callback and waits on repeat on a separate thread
-  class Poller
-    def initialize(interval_millis, jitter_millis, callback)
-      @jitter_millis = jitter_millis
-      @interval = interval_millis
-      @stopped = Concurrent::Atom.new(false)
-      @callback = callback
-      @thread = nil
-    end
-
-    def start
-      @stopped.reset(false)
-      @thread = Thread.new { poll }
-    end
-
-    def stop
-      @stopped.reset(true)
-      Thread.kill(@thread)
-    end
-
-    def stopped?
-      @stopped.value
-    end
-
-    def poll
-      until stopped?
-        begin
-          @callback.call
-        rescue StandardError => e
-          Logger.new($stdout).error("Unexpected error running poll task: #{e}")
-          break
-        end
-        _wait_for_interval
-      end
-    end
-
-    def _wait_for_interval
-      interval_with_jitter = @interval - rand(@jitter_millis)
-      sleep interval_with_jitter / 1000
-    end
-  end
-end

data/lib/eppo_client/rules.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require 'semver'
-
-# The helper module for rules
-module EppoClient
-  module OperatorType
-    MATCHES = 'MATCHES'
-    GTE = 'GTE'
-    GT = 'GT'
-    LTE = 'LTE'
-    LT = 'LT'
-    ONE_OF = 'ONE_OF'
-    NOT_ONE_OF = 'NOT_ONE_OF'
-  end
-
-  # A class for the Condition object
-  class Condition
-    attr_accessor :operator, :attribute, :value
-
-    def initialize(operator:, attribute:, value:)
-      @operator = operator
-      @attribute = attribute
-      @value = value
-    end
-  end
-
-  # A class for the Rule object
-  class Rule
-    attr_accessor :allocation_key, :conditions
-
-    def initialize(allocation_key:, conditions:)
-      @allocation_key = allocation_key
-      @conditions = conditions
-    end
-  end
-
-  def find_matching_rule(subject_attributes, rules)
-    rules.each do |rule|
-      return rule if matches_rule(subject_attributes, rule)
-    end
-    nil
-  end
-
-  def matches_rule(subject_attributes, rule)
-    rule.conditions.each do |condition|
-      return false unless evaluate_condition(subject_attributes, condition)
-    end
-    true
-  end
-
-  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-  def evaluate_condition(subject_attributes, condition)
-    subject_value = subject_attributes[condition.attribute]
-    return false if subject_value.nil?
-
-    case condition.operator
-    when OperatorType::MATCHES
-      !!(Regexp.new(condition.value) =~ subject_value.to_s)
-    when OperatorType::ONE_OF
-      condition.value.map(&:downcase).include?(subject_value.to_s.downcase)
-    when OperatorType::NOT_ONE_OF
-      !condition.value.map(&:downcase).include?(subject_value.to_s.downcase)
-    else
-      # Numeric operator: value could be numeric or semver.
-      if subject_value.is_a?(Numeric)
-        evaluate_numeric_condition(subject_value, condition)
-      elsif valid_semver?(subject_value)
-        compare_semver(subject_value, condition.value, condition.operator)
-      end
-    end
-  end
-  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-
-  # rubocop:disable Metrics/MethodLength
-  def evaluate_numeric_condition(subject_value, condition)
-    case condition.operator
-    when OperatorType::GT
-      subject_value > condition.value
-    when OperatorType::GTE
-      subject_value >= condition.value
-    when OperatorType::LT
-      subject_value < condition.value
-    when OperatorType::LTE
-      subject_value <= condition.value
-    else
-      false
-    end
-  end
-  # rubocop:enable Metrics/MethodLength
-
-  # rubocop:disable Metrics/MethodLength
-  def compare_semver(attribute_value, condition_value, operator)
-    unless valid_semver?(attribute_value) && valid_semver?(condition_value)
-      return false
-    end
-
-    case operator
-    when OperatorType::GT
-      SemVer.parse(attribute_value) > SemVer.parse(condition_value)
-    when OperatorType::GTE
-      SemVer.parse(attribute_value) >= SemVer.parse(condition_value)
-    when OperatorType::LT
-      SemVer.parse(attribute_value) < SemVer.parse(condition_value)
-    when OperatorType::LTE
-      SemVer.parse(attribute_value) <= SemVer.parse(condition_value)
-    else
-      false
-    end
-  end
-  # rubocop:enable Metrics/MethodLength
-
-  def valid_semver?(string)
-    !SemVer.parse(string).nil?
-  end
-
-  module_function :find_matching_rule, :matches_rule, :evaluate_condition,
-                  :evaluate_numeric_condition, :valid_semver?, :compare_semver
-end

data/lib/eppo_client/shard.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest'
-
-# The helper module for shard logic
-module EppoClient
-  # A class for checking if a shard is in a range
-  class ShardRange
-    attr_reader :start, :end
-
-    def initialize(range_start, range_end)
-      @start = range_start
-      @end = range_end
-    end
-
-    def shard_in_range?(shard)
-      shard >= @start && shard < @end
-    end
-  end
-
-  module_function
-
-  def get_shard(input, subject_shards)
-    hash_output = Digest::MD5.hexdigest(input)
-    # get the first 4 bytes of the md5 hex string and parse it using base 16
-    # (8 hex characters represent 4 bytes, e.g. 0xffffffff represents the max 4-byte integer)
-    int_from_hash = hash_output[0...8].to_i(16)
-    int_from_hash % subject_shards
-  end
-end

data/lib/eppo_client/variation_type.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module EppoClient
-  # The class for configuring the Eppo client singleton
-  module VariationType
-    STRING_TYPE = 'string'
-    NUMERIC_TYPE = 'numeric'
-    BOOLEAN_TYPE = 'boolean'
-    JSON_TYPE = 'json'
-
-    module_function
-
-    # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
-    def expected_type?(assigned_variation, expected_variation_type)
-      case expected_variation_type
-      when STRING_TYPE
-        assigned_variation.typed_value.is_a?(String)
-      when NUMERIC_TYPE
-        assigned_variation.typed_value.is_a?(Numeric)
-      when BOOLEAN_TYPE
-        assigned_variation.typed_value.is_a?(TrueClass) ||
-          assigned_variation.typed_value.is_a?(FalseClass)
-      when JSON_TYPE
-        begin
-          parsed_json = JSON.parse(assigned_variation.value)
-          JSON.dump(assigned_variation.typed_value)
-          parsed_json == assigned_variation.typed_value
-        rescue JSON::JSONError
-          false
-        end
-      else
-        false
-      end
-    end
-    # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
-  end
-end