eppo-server-sdk 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ce6db52c824656217a079b75231b2749b10bbbd656bda249e2f103666b173acb
+  data.tar.gz: 4629ce299c56cbcbfe342e7572803c935266172b376ef1c8aa1eac8f0bb8074b
+SHA512:
+  metadata.gz: 29de3064e5d780257e0e883295a6101b86e321ba6203dcbcc21e46192cc853156faab52031782b323be2cf37fe6e045345a5099acdb3ead7f6383fbcf5396f2c
+  data.tar.gz: c3a669f35584ecac1b4f12e4796b61de972bb2f117cfd95e5cd3c693fb9f53af3bf232d9800a3a519245408576978037371394ff4b9931655850f38b80e8f0bb

data/lib/assignment_logger.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require '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')
+    end
+  end
+end

data/lib/client.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'time'
+
+require 'validation'
+require 'rules'
+require 'shard'
+require 'sdk_logger'
+require 'custom_errors'
+
+module EppoClient
+  # The main client singleton
+  class Client
+    include Singleton
+    attr_accessor :config_requestor, :assignment_logger, :poller
+
+    def instance
+      Client.instance
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def get_assignment(subject_key, flag_or_experiment_key, subject_attributes = {})
+      EppoClient.validate_not_blank('subject_key', subject_key)
+      EppoClient.validate_not_blank('flag_or_experiment_key', flag_or_experiment_key)
+      experiment_config = @config_requestor.get_configuration(flag_or_experiment_key)
+      override = get_subject_variation_override(experiment_config, subject_key)
+      return override unless override.nil?
+
+      if experiment_config.nil? || experiment_config.enabled == false
+        EppoClient.logger('out').info(
+          "[Eppo SDK] No assigned variation. No active experiment or flag for key: #{flag_or_experiment_key}"
+        )
+        return nil
+      end
+
+      matched_rule = EppoClient.find_matching_rule(subject_attributes, experiment_config.rules)
+      if matched_rule.nil?
+        EppoClient.logger('out').info(
+          "[Eppo SDK] No assigned variation. Subject attributes do not match targeting rules: #{subject_attributes}"
+        )
+        return nil
+      end
+
+      allocation = experiment_config.allocations[matched_rule.allocation_key]
+      unless in_experiment_sample?(
+        subject_key,
+        flag_or_experiment_key,
+        experiment_config.subject_shards,
+        allocation.percent_exposure
+      )
+        EppoClient.logger('out').info(
+          '[Eppo SDK] No assigned variation. Subject is not part of experiment sample population'
+        )
+        return nil
+      end
+
+      shard = EppoClient.get_shard("assignment-#{subject_key}-#{flag_or_experiment_key}", experiment_config.subject_shards)
+      assigned_variation = allocation.variations.find { |var| var.shard_range.shard_in_range?(shard) }.value
+
+      assignment_event = {
+        "experiment": flag_or_experiment_key,
+        "variation": assigned_variation,
+        "subject": subject_key,
+        "timestamp": Time.now.utc.iso8601,
+        "subjectAttributes": subject_attributes
+      }
+
+      begin
+        @assignment_logger.log_assignment(assignment_event)
+      rescue EppoClient::AssignmentLoggerError => e
+        # This error means that log_assignment was not set up. This is okay to ignore.
+      rescue StandardError => e
+        EppoClient.logger('err').info("[Eppo SDK] Error logging assignment event: #{e}")
+      end
+
+      assigned_variation
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+    def shutdown
+      @poller.stop
+    end
+
+    def get_subject_variation_override(experiment_config, subject)
+      subject_hash = Digest::MD5.hexdigest(subject.to_s)
+      experiment_config&.overrides && experiment_config.overrides[subject_hash]
+    end
+
+    def in_experiment_sample?(subject, experiment_key, subject_shards, percent_exposure)
+      shard = EppoClient.get_shard("exposure-#{subject}-#{experiment_key}", subject_shards)
+      shard <= percent_exposure * subject_shards
+    end
+  end
+end

data/lib/config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'validation'
+require 'assignment_logger'
+
+module EppoClient
+  # The class for configuring the Eppo client singleton
+  class Config
+    attr_reader :api_key, :assignment_logger, :base_url
+
+    def initialize(api_key, assignment_logger: AssignmentLogger.new, base_url: 'https://eppo.cloud/api')
+      @api_key = api_key
+      @assignment_logger = assignment_logger
+      @base_url = base_url
+    end
+
+    def validate
+      EppoClient.validate_not_blank('api_key', @api_key)
+    end
+
+    # Hide instance variables (specifically api_key) from logs
+    def inspect
+      "#<EppoClient::Config:#{object_id}>"
+    end
+  end
+end

data/lib/configuration_requestor.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'sdk_logger'
+require 'custom_errors'
+require 'constants'
+
+module EppoClient
+  # A class for the variation object
+  class VariationDto
+    attr_reader :name, :value, :shard_range
+
+    def initialize(name, value, shard_range)
+      @name = name
+      @value = value
+      @shard_range = shard_range
+    end
+  end
+
+  # A class for the allocation object
+  class AllocationDto
+    attr_reader :percent_exposure, :variations
+
+    def initialize(percent_exposure, variations)
+      @percent_exposure = percent_exposure
+      @variations = variations
+    end
+  end
+
+  # A class for the experiment configuration object
+  class ExperimentConfigurationDto
+    attr_reader :subject_shards, :enabled, :name, :overrides, :rules, :allocations
+
+    def initialize(exp_config)
+      @subject_shards = exp_config['subjectShards']
+      @enabled = exp_config['enabled']
+      @name = exp_config['name'] || nil
+      @overrides = exp_config['overrides'] || {}
+      @rules = exp_config['rules'] || []
+      @allocations = exp_config['allocations']
+    end
+  end
+
+  # A class for getting exp configs from the local cache or API
+  class ExperimentConfigurationRequestor
+
+    attr_reader :config_store
+
+    def initialize(http_client, config_store)
+      @http_client = http_client
+      @config_store = config_store
+    end
+
+    def get_configuration(experiment_key)
+      @http_client.is_unauthorized && raise(EppoClient::UnauthorizedError, 'please check your API key')
+      @config_store.retrieve_configuration(experiment_key)
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def fetch_and_store_configurations
+      configs = {}
+      begin
+        exp_configs = @http_client.get(EppoClient::RAC_ENDPOINT).fetch('flags', {})
+        exp_configs.each do |exp_key, exp_config|
+          exp_config['allocations'].each do |k, v|
+            exp_config['allocations'][k] = EppoClient::AllocationDto.new(
+              v['percentExposure'],
+              v['variations'].map do |var|
+                EppoClient::VariationDto.new(
+                  var['name'],
+                  var['value'],
+                  EppoClient::ShardRange.new(var['shardRange']['start'], var['shardRange']['end'])
+                )
+              end
+            )
+          end
+          exp_config['rules'] = exp_config['rules'].map do |rule|
+            EppoClient::Rule.new(
+              conditions: rule['conditions'].map do |condition|
+                EppoClient::Condition.new(
+                  value: condition['value'],
+                  operator: condition['operator'],
+                  attribute: condition['attribute']
+                )
+              end,
+              allocation_key: rule['allocationKey']
+            )
+          end
+          configs[exp_key] = EppoClient::ExperimentConfigurationDto.new(exp_config)
+        end
+        @config_store.assign_configurations(configs)
+      rescue EppoClient::HttpRequestError => e
+        EppoClient.logger('err').error("Error retrieving assignment configurations: #{e}")
+      end
+      configs
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+  end
+end

data/lib/configuration_store.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'concurrent/atomic/read_write_lock'
+
+require 'lru_cache'
+
+module EppoClient
+  # A thread safe store for the configurations to ensure that retrievals pull from a single source of truth
+  class ConfigurationStore
+    attr_reader :lock, :cache
+
+    def initialize(max_size)
+      @cache = EppoClient::LRUCache.new(max_size)
+      @lock = Concurrent::ReadWriteLock.new
+    end
+
+    def retrieve_configuration(key)
+      @lock.with_read_lock { @cache[key] }
+    end
+
+    def assign_configurations(configs)
+      @lock.with_write_lock do
+        configs.each do |key, config|
+          @cache[key] = config
+        end
+      end
+    end
+  end
+end

data/lib/constants.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module EppoClient
+  # configuration cache constants
+  MAX_CACHE_ENTRIES = 1000 # arbitrary; the caching library requires a max limit
+
+  # poller constants
+  SECOND_MILLIS = 1000
+  MINUTE_MILLIS = 60 * SECOND_MILLIS
+  POLL_JITTER_MILLIS = 30 * SECOND_MILLIS
+  POLL_INTERVAL_MILLIS = 5 * MINUTE_MILLIS
+
+  # the configs endpoint
+  RAC_ENDPOINT = 'randomized_assignment/v2/config'
+end

data/lib/custom_errors.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module EppoClient
+  # A custom error class for AssignmentLogger
+  class AssignmentLoggerError < StandardError
+    def initialize(message)
+      super("AssignmentLoggerError: #{message}")
+    end
+  end
+
+  # A custom error class for unauthorized requests
+  class UnauthorizedError < StandardError
+    def initialize(message)
+      super("Unauthorized: #{message}")
+    end
+  end
+
+  # A custom error class for HTTP requests
+  class HttpRequestError < StandardError
+    attr_reader :status_code
+
+    def initialize(message, status_code)
+      @status_code = status_code
+      super("HttpRequestError: #{message}")
+    end
+  end
+
+  # A custom error class for invalid values
+  class InvalidValueError < StandardError
+    def initialize(message)
+      super("InvalidValueError: #{message}")
+    end
+  end
+end

data/lib/eppo_client.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'assignment_logger'
+require 'http_client'
+require 'poller'
+require 'config'
+require 'client'
+require 'constants'
+require 'configuration_requestor'
+require 'configuration_store'
+
+# This module scopes all the client SDK's classes and functions
+module EppoClient
+  @sdk_version = '1.1.1'
+
+  # rubocop:disable Metrics/MethodLength
+  def initialize_client(config_requestor, assignment_logger)
+    client = EppoClient::Client.instance
+    !client.poller.nil? && client.shutdown
+    client.config_requestor = config_requestor
+    client.assignment_logger = assignment_logger
+    client.poller = EppoClient::Poller.new(
+      EppoClient::POLL_INTERVAL_MILLIS,
+      EppoClient::POLL_JITTER_MILLIS,
+      proc { client.config_requestor.fetch_and_store_configurations }
+    )
+    client.poller.start
+    client
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def init(config)
+    config.validate
+    sdk_params = EppoClient::SdkParams.new(config.api_key, 'ruby', @sdk_version)
+    http_client = EppoClient::HttpClient.new(config.base_url, sdk_params.formatted)
+    config_store = EppoClient::ConfigurationStore.new(EppoClient::MAX_CACHE_ENTRIES)
+    config_store.lock.with_write_lock do
+      EppoClient.initialize_client(
+        EppoClient::ExperimentConfigurationRequestor.new(http_client, config_store),
+        config.assignment_logger
+      )
+    end
+  end
+
+  module_function :init, :initialize_client
+end

data/lib/http_client.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/retry'
+
+require '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/lru_cache.rb

@@ -0,0 +1,28 @@
+# 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
+
+    # 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/poller.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'concurrent/atom'
+require 'sdk_logger'
+
+# 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
+          EppoClient.logger('err').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/rules.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# 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/CyclomaticComplexity, 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
+      subject_value.is_a?(Numeric) && evaluate_numeric_condition(subject_value, condition)
+    end
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, 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
+
+  module_function :find_matching_rule, :matches_rule, :evaluate_condition, :evaluate_numeric_condition
+end

data/lib/sdk_logger.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+# The helper module for logging
+module EppoClient
+  @stdout_logger = Logger.new($stdout)
+  @stderr_logger = Logger.new($stderr)
+
+  def self.logger(type)
+    case type
+    when 'out'
+      @stdout_logger
+    when 'err'
+      @stderr_logger
+    else
+      @stderr_logger.error("[Eppo SDK] Invalid logger type: #{type}")
+    end
+  end
+end

data/lib/shard.rb

@@ -0,0 +1,30 @@
+# 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
+
+  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
+
+  module_function :get_shard
+end

data/lib/validation.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'custom_errors'
+
+# The helper module to validate keys
+module EppoClient
+  def validate_not_blank(field_name, field_value)
+    (field_value.nil? || field_value == '') && raise(EppoClient::InvalidValueError, "#{field_name} cannot be blank")
+  end
+
+  module_function :validate_not_blank
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: eppo-server-sdk
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Eppo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.1
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.6
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.12.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.41'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.41'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.18.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.18.1
+description:
+email: eppo-team@geteppo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/assignment_logger.rb
+- lib/client.rb
+- lib/config.rb
+- lib/configuration_requestor.rb
+- lib/configuration_store.rb
+- lib/constants.rb
+- lib/custom_errors.rb
+- lib/eppo_client.rb
+- lib/http_client.rb
+- lib/lru_cache.rb
+- lib/poller.rb
+- lib/rules.rb
+- lib/sdk_logger.rb
+- lib/shard.rb
+- lib/validation.rb
+homepage: https://github.com/Eppo-exp/ruby-sdk
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Eppo SDK for Ruby
+test_files: []