statsig 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 60035280630edb2172623545efa323cc6b3ec0374b8ebc99ba7f28312a227b21
+  data.tar.gz: af799a2649633d8cc364d6e69fed72f3a30ff96673212d348f20b5fa0ef83f30
+SHA512:
+  metadata.gz: f69cf4534af68927136ec9d9bf1900ea206e3c86c7bdcdd294e03c0109071449adc44db0d5026f98cae2ff281985022e19ddb6e9a8cc9a275c0f53513c292e0a
+  data.tar.gz: 39269a606a0291a83c5f486535b7a075ccde3a82a50436598aed93732cd95b27c765220c56de6b50e1e515f7346ec107081dc71ea23be2ee83e33a3e88b745eb

data/lib/config_result.rb

@@ -0,0 +1,13 @@
+class ConfigResult
+  attr_accessor :name
+  attr_accessor :gate_value
+  attr_accessor :json_value
+  attr_accessor :rule_id
+
+  def initialize(name, gate_value = false, json_value = {}, rule_id = '')
+    @name = name
+    @gate_value = gate_value
+    @json_value = json_value
+    @rule_id = rule_id
+  end
+end

data/lib/dynamic_config.rb

@@ -0,0 +1,16 @@
+class DynamicConfig
+  attr_accessor :name
+  attr_accessor :value
+  attr_accessor :rule_id
+
+  def initialize(name, value = {}, rule_id = '')
+    @name = name
+    @value = value
+    @rule_id = rule_id
+  end
+
+  def get(index)
+    return nil if @value.nil?
+    value[index]
+  end
+end

data/lib/evaluation_helpers.rb

@@ -0,0 +1,25 @@
+module EvaluationHelpers
+  def self.compare_numbers(a, b, func)
+    return false unless self.is_numeric(a) && self.is_numeric(b)
+    func.call(a.to_f, b.to_f) rescue false
+  end
+
+  # returns true if array contains value, ignoring case when comparing strings
+  def self.array_contains(array, value)
+    return false unless array.is_a?(Array) && !value.nil?
+    return array.include?(value) unless value.is_a?(String)
+    array.any?{ |s| s.is_a?(String) && s.casecmp(value) == 0 } rescue false
+  end
+
+  # returns true if array has any element that evaluates to true with value using func lambda, ignoring case
+  def self.match_string_in_array(array, value, func)
+    return false unless array.is_a?(Array) && value.is_a?(String)
+    array.any?{ |s| s.is_a?(String) && func.call(value.downcase, s.downcase) } rescue false
+  end
+
+  private
+
+  def self.is_numeric(v)
+    !(v.to_s =~ /\A[-+]?\d*\.?\d+\z/).nil?
+  end
+end

data/lib/evaluator.rb

@@ -0,0 +1,212 @@
+require 'browser'
+require 'config_result'
+require 'digest'
+require 'evaluation_helpers'
+require 'spec_store'
+
+$fetch_from_server = :fetch_from_server
+$type_dynamic_config = 'dynamic_config'
+
+class Evaluator
+  include EvaluationHelpers
+
+  def initialize(store)
+    @spec_store = store
+    @initialized = true
+  end
+
+  def check_gate(user, gate_name)
+    return nil unless @initialized && @spec_store.has_gate?(gate_name)
+    self.eval_spec(user, @spec_store.get_gate(gate_name))
+  end
+
+  def get_config(user, config_name)
+    return nil unless @initialized && @spec_store.has_config?(config_name)
+    self.eval_spec(user, @spec_store.get_config(config_name))
+  end
+
+  private
+
+  def eval_spec(user, config)
+    if config['enabled']
+      i = 0
+      until i >= config['rules'].length do
+        rule = config['rules'][i]
+        result = self.eval_rule(user, rule)
+        return $fetch_from_server if result == $fetch_from_server
+        if result
+          pass = self.eval_pass_percent(user, rule, config['salt'])
+          return ConfigResult.new(
+            config['name'],
+            pass,
+            pass ? rule['returnValue'] : config['defaultValue'],
+            rule['id'],
+          )
+        end
+
+        i += 1
+      end
+    end
+
+    ConfigResult.new(config['name'], false, config['defaultValue'], 'default')
+  end
+
+  def eval_rule(user, rule)
+    i = 0
+    until i >= rule['conditions'].length do
+      result = self.eval_condition(user, rule['conditions'][i])
+      return result unless result == true
+      i += 1
+    end
+    true
+  end
+
+  def eval_condition(user, condition)
+    value = nil
+    field = condition['field']
+    target = condition['targetValue']
+    type = condition['type']
+    operator = condition['operator']
+
+    return $fetch_from_server unless type.is_a?(String)
+    type = type.downcase
+
+    case type
+    when 'public'
+      return true
+    when 'fail_gate'
+    when 'pass_gate'
+      other_gate_result = self.check_gate(user, target)
+      return $fetch_from_server if other_gate_result == $fetch_from_server
+      return type == 'pass_gate' ? other_gate_result[:gate_value] : !other_gate_result[:gate_value]
+    when 'ip_based'
+      value = get_value_from_user(user, field) || get_value_from_ip(user['ip'], field)
+      return $fetch_from_server if value == $fetch_from_server
+    when 'ua_based'
+      value = get_value_from_user(user, field) || get_value_from_ua(user['userAgent'], field)
+      return $fetch_from_server if value == $fetch_from_server
+    when 'user_field'
+      value = get_value_from_user(user, field)
+    when 'current_time'
+      value = Time.now.to_f # epoch time in seconds
+    else
+      return $fetch_from_server
+    end
+
+    return $fetch_from_server if value == $fetch_from_server
+    return false if value.nil?
+
+    return $fetch_from_server unless operator.is_a?(String)
+    operator = operator.downcase
+
+    case operator
+      # numerical comparison
+    when 'gt'
+      return compare_numbers(value, target, ->(a, b) { a > b })
+    when 'gte'
+      return compare_numbers(value, target, ->(a, b) { a >= b })
+    when 'lt'
+      return compare_numbers(value, target, ->(a, b) { a < b })
+    when 'lte'
+      return compare_numbers(value, target, ->(a, b) { a <= b })
+
+      # version comparison
+    when 'version_gt'
+      return (Gem::Version.new(value) > Gem::Version.new(target) rescue false)
+    when 'version_gte'
+      return (Gem::Version.new(value) >= Gem::Version.new(target) rescue false)
+    when 'version_lt'
+      return (Gem::Version.new(value) < Gem::Version.new(target) rescue false)
+    when 'version_lte'
+      return (Gem::Version.new(value) <= Gem::Version.new(target) rescue false)
+    when 'version_eq'
+      return (Gem::Version.new(value) == Gem::Version.new(target) rescue false)
+    when 'version_neq'
+      return (Gem::Version.new(value) != Gem::Version.new(target) rescue false)
+
+      # array operations
+    when 'any'
+      return array_contains(target, value)
+    when 'none'
+      return !array_contains(target, value)
+
+      #string
+    when 'str_starts_with_any'
+      return match_string_in_array(target, value, ->(a, b) { a.start_with?(b) })
+    when 'str_ends_with_any'
+      return match_string_in_array(target, value, ->(a, b) { a.end_with?(b) })
+    when 'str_contains_any'
+      return match_string_in_array(target, value, ->(a, b) { a.include?(b) })
+    when 'str_matches'
+      return (value.is_a?(String) && !(value =~ Regexp.new(target)).nil? rescue false)
+    when 'eq'
+      return value == target
+    when 'neq'
+      return value != target
+
+      # dates
+    when 'before'
+      # TODO - planned future conditions
+    when 'after'
+      # TODO - planned future conditions
+    when 'on'
+      # TODO - planned future conditions
+    else
+      return $fetch_from_server
+    end
+  end
+
+  def get_value_from_user(user, field)
+    return nil unless user.instance_of?(StatsigUser) && field.is_a?(String)
+
+    user_lookup_table = user&.value_lookup
+    return nil unless user_lookup_table.is_a?(Hash)
+    return user_lookup_table[field.downcase] if user_lookup_table.has_key?(field.downcase)
+
+    user_custom = user_lookup_table['custom']
+    return nil unless user_custom.is_a?(Hash)
+    user_custom.each do |key, value|
+      return value if key.downcase.casecmp(field.downcase)
+    end
+  end
+
+  def get_value_from_ip(ip, field)
+    return nil unless ip.is_a?(String) && field.is_a?(String)
+    # TODO
+    $fetch_from_server
+  end
+
+  def get_value_from_ua(ua, field)
+    return nil unless ua.is_a?(String) && field.is_a?(String)
+    b = Browser.new(ua)
+    case field.downcase
+    when 'os_name'
+      os_name = b.platform.name
+      # special case for iOS because value is 'iOS (iPhone)'
+      if os_name.include?('iOS') || os_name.include?('ios')
+        return 'iOS'
+      else
+        return os_name
+      end
+    when 'os_version'
+      return b.platform.version
+    when 'browser_name'
+      return b.name
+    when 'browser_version'
+      return b.full_version
+    else
+      nil
+    end
+  end
+
+  def eval_pass_percent(user, rule, salt)
+    return false unless salt.is_a?(String) && !rule['passPercentage'].nil?
+    begin
+      user_id = user.user_id || ''
+      hash = Digest::SHA256.digest("#{salt}.#{rule['name']}.#{user_id}").unpack('Q>')[0]
+      return hash % 10000 < rule['passPercentage'].to_f * 100
+    rescue
+      return false
+    end
+  end
+end

data/lib/network.rb

@@ -0,0 +1,72 @@
+require 'concurrent'
+require 'http'
+require 'json'
+require 'dynamic_config'
+
+class Network
+  include Concurrent::Async
+
+  def initialize(server_secret, api)
+    super()
+    unless api.end_with?('/')
+      api += '/'
+    end
+    @http = HTTP
+        .headers({"STATSIG-API-KEY" => server_secret, "Content-Type" => "application/json; charset=UTF-8"})
+        .accept(:json)
+    @api = api
+    @last_sync_time = 0
+  end
+
+  def check_gate(user, gate_name)
+    begin
+      request_body = JSON.generate({'user' => user&.serialize(), 'gateName' => gate_name})
+      response = @http.post(@api + 'check_gate', body: request_body)
+      return JSON.parse(response.body)
+    rescue
+      return false
+    end
+  end
+
+  def get_config(user, dynamic_config_name)
+    begin
+      request_body = JSON.generate({'user' => user&.serialize(), 'configName' => dynamic_config_name})
+      response = @http.post(@api + 'get_config', body: request_body)
+      return JSON.parse(response.body)
+    rescue
+      return nil
+    end
+  end
+
+  def download_config_specs
+    begin
+      response = @http.post(@api + 'download_config_specs', body: JSON.generate({'sinceTime' => @last_sync_time}))
+      json_body = JSON.parse(response.body)
+      @last_sync_time = json_body['time']
+      return json_body
+    rescue
+      return nil
+    end
+  end
+
+  def poll_for_changes(callback)
+    Thread.new do
+      loop do
+        sleep 10
+        specs = download_config_specs
+        unless specs.nil?
+          callback.call(specs)
+        end
+      end
+    end
+  end
+
+  def post_logs(events, statsig_metadata)
+    begin
+      json_body = JSON.generate({'events' => events, 'statsigMetadata' => statsig_metadata})
+      @http.post(@api + 'log_event', body: json_body)
+    rescue
+      # TODO: retries
+    end
+  end
+end

data/lib/spec_store.rb

@@ -0,0 +1,51 @@
+require 'net/http'
+require 'uri'
+
+class SpecStore
+  def initialize(specs_json)
+    @last_sync_time = 0
+    @store = {
+      :gates => {},
+      :configs => {},
+    }
+    process(specs_json)
+  end
+
+  def process(specs_json)
+    if specs_json.nil?
+      return
+    end
+
+    @last_sync_time = specs_json['time'] || @last_sync_time
+    return unless specs_json['has_updates'] == true &&
+      !specs_json['feature_gates'].nil? &&
+      !specs_json['dynamic_configs'].nil?
+
+    @store = {
+      :gates => {},
+      :configs => {},
+    }
+
+    specs_json['feature_gates'].map{|gate|  @store[:gates][gate['name']] = gate }
+    specs_json['dynamic_configs'].map{|config|  @store[:configs][config['name']] = config }
+  end
+
+  def has_gate?(gate_name)
+    return @store[:gates].key?(gate_name)
+  end
+
+  def has_config?(config_name)
+    return @store[:configs].key?(config_name)
+  end
+
+  def get_gate(gate_name)
+    return nil unless has_gate?(gate_name)
+    @store[:gates][gate_name]
+  end
+
+  def get_config(config_name)
+    return nil unless has_config?(config_name)
+    @store[:configs][config_name]
+  end
+
+end

data/lib/statsig.rb

@@ -0,0 +1,42 @@
+require 'statsig_driver'
+
+module Statsig
+  def self.initialize(secret_key)
+    unless @shared_instance.nil?
+      puts 'Statsig already initialized.'
+      return @shared_instance
+    end
+
+    @shared_instance = StatsigDriver.new(secret_key)
+  end
+
+  def self.check_gate(user, gate_name)
+    self.ensure_initialized
+    @shared_instance.check_gate(user, gate_name)
+  end
+
+  def self.get_config(user, dynamic_config_name)
+    self.ensure_initialized
+    @shared_instance.get_config(user, dynamic_config_name)
+  end
+
+  def self.log_event(user, event_name, value, metadata)
+    self.ensure_initialized
+    @shared_instance.log_event(user, event_name, value, metadata)
+  end
+
+  def self.shutdown
+    unless @shared_instance.nil?
+      @shared_instance.shutdown
+    end
+    @shared_instance = nil
+  end
+
+  private
+
+  def self.ensure_initialized
+    if @shared_instance.nil?
+      raise 'Must call initialize first.'
+    end
+  end
+end

data/lib/statsig_driver.rb

@@ -0,0 +1,146 @@
+require 'concurrent'
+require 'config_result'
+require 'evaluator'
+require 'network'
+require 'statsig_event'
+require 'statsig_logger'
+require 'statsig_user'
+require 'spec_store'
+
+class StatsigDriver
+    include Concurrent::Async
+
+    def initialize(secret_key)
+        super()
+        if !secret_key.is_a?(String) || !secret_key.start_with?('secret-')
+          raise 'Invalid secret key provided. Provide your project secret key from the Statsig console'
+        end
+        @shutdown = false
+        @secret_key = secret_key
+        @net = Network.new(secret_key, 'https://api.statsig.com/v1/')
+        @statsig_metadata = {
+          'sdkType' => 'ruby-server',
+          'sdkVersion' => Gem::Specification::load('statsig.gemspec')&.version,
+        }
+        @logger = StatsigLogger.new(@net, @statsig_metadata)
+
+        downloaded_specs = @net.download_config_specs
+        unless downloaded_specs.nil?
+          @initialized = true
+        end
+
+        @store = SpecStore.new(downloaded_specs)
+        @evaluator = Evaluator.new(@store)
+
+        @polling_thread = @net.poll_for_changes(-> (config_specs) { @store.process(config_specs) })
+    end
+  
+    def check_gate(user, gate_name)
+      if !user.nil? && !user.instance_of?(StatsigUser)
+        raise 'Must provide a valid StatsigUser'
+      end
+      if !gate_name.is_a?(String) || gate_name.empty?
+        raise 'Invalid gate_name provided'
+      end
+      check_shutdown
+      unless @initialized
+        return false
+      end
+
+      res = @evaluator.check_gate(user, gate_name)
+      if res.nil?
+        res = ConfigResult.new(gate_name)
+      end
+
+      if res == $fetch_from_server
+        res = check_gate_fallback(user, gate_name)
+      end
+
+      @logger.logGateExposure(user, res.name, res.gate_value, res.rule_id)
+      res.gate_value
+    end
+
+    def get_config(user, dynamic_config_name)
+      if !user.nil? && !user.instance_of?(StatsigUser)
+        raise 'Must provide a valid StatsigUser or nil'
+      end
+      if !dynamic_config_name.is_a?(String) || dynamic_config_name.empty?
+        raise "Invalid dynamic_config_name provided"
+      end
+      check_shutdown
+      unless @initialized
+        return DynamicConfig.new(dynamic_config_name)
+      end
+
+      res = @evaluator.get_config(user, dynamic_config_name)
+      if res.nil?
+        res = ConfigResult.new(dynamic_config_name)
+      end
+
+      if res == $fetch_from_server
+        res = get_config_fallback(user, dynamic_config_name)
+      end
+
+      result_config = DynamicConfig.new(res.name, res.json_value, res.rule_id)
+      @logger.logConfigExposure(user, result_config.name, result_config.rule_id)
+      result_config
+    end
+
+    def log_event(user, event_name, value = nil, metadata = nil)
+      if !user.nil? && !user.instance_of?(StatsigUser)
+        raise 'Must provide a valid StatsigUser or nil'
+      end
+      check_shutdown
+
+      event = StatsigEvent.new(event_name)
+      event.user = user&.serialize
+      event.value = value
+      event.metadata = metadata
+      event.statsig_metadata = @statsig_metadata
+      @logger.log_event(event)
+    end
+
+    def shutdown
+      @shutdown = true
+      @logger.flush
+      @polling_thread&.exit
+    end
+
+    private
+
+    def check_shutdown
+      if @shutdown
+        puts 'SDK has been shutdown.  Updates in the Statsig Console will no longer reflect.'
+      end
+    end
+
+    def check_gate_fallback(user, gate_name)
+      network_result = @net.check_gate(user, gate_name)
+      if network_result.nil?
+        config_result = ConfigResult.new(gate_name)
+        return config_result
+      end
+
+      ConfigResult.new(
+        network_result['name'],
+        network_result['value'],
+        {},
+        network_result['rule_id'],
+      )
+    end
+
+    def get_config_fallback(user, dynamic_config_name)
+      network_result = @net.get_config(user, dynamic_config_name)
+      if network_result.nil?
+        config_result = ConfigResult.new(dynamic_config_name)
+        return config_result
+      end
+
+      ConfigResult.new(
+        network_result['name'],
+        false,
+        network_result['value'],
+        network_result['rule_id'],
+      )
+    end
+  end

data/lib/statsig_event.rb

@@ -0,0 +1,21 @@
+class StatsigEvent
+  attr_accessor :value
+  attr_accessor :user
+  attr_accessor :metadata
+  attr_accessor :statsig_metadata
+  def initialize(event_name)
+    @event_name = event_name
+    @time = Time.now.to_i * 1000
+  end
+
+  def serialize
+    return {
+      'eventName' => @event_name,
+      'metadata' => @metadata,
+      'value' => @value,
+      'user' => @user,
+      'time' => @time,
+      'statsigMetadata' => @statsig_metadata,
+    }
+  end
+end

data/lib/statsig_logger.rb

@@ -0,0 +1,52 @@
+require 'statsig_event'
+
+$gate_exposure_event = 'statsig::gate_exposure'
+$config_exposure_event = 'statsig::config_exposure'
+
+class StatsigLogger
+  def initialize(network, statsig_metadata)
+    @network = network
+    @statsig_metadata = statsig_metadata
+    @events = []
+  end
+
+  def log_event(event)
+    @events.push(event)
+    if @events.length >= 500
+      flush()
+    end
+  end
+
+  def logGateExposure(user, gate_name, value, rule_id)
+    event = StatsigEvent.new($gate_exposure_event)
+    event.user = user
+    event.metadata = {
+      'gate' => gate_name,
+      'gateValue' => value.to_s,
+      'ruleID' => rule_id
+    }
+    event.statsig_metadata = @statsig_metadata
+    log_event(event)
+  end
+
+  def logConfigExposure(user, config_name, rule_id)
+    event = StatsigEvent.new($config_exposure_event)
+    event.user = user
+    event.metadata = {
+      'config' => config_name,
+      'ruleID' => rule_id
+    }
+    event.statsig_metadata = @statsig_metadata
+    log_event(event)
+  end
+
+  def flush
+    if @events.length == 0
+      return
+    end
+    flush_events = @events.map { |e| e.serialize() }
+    @events = []
+
+    @network.post_logs(flush_events, @statsig_metadata)
+  end
+end

data/lib/statsig_user.rb

@@ -0,0 +1,49 @@
+class StatsigUser
+  attr_accessor :user_id
+  attr_accessor :email
+  attr_accessor :ip
+  attr_accessor :user_agent
+  attr_accessor :country
+  attr_accessor :locale
+  attr_accessor :client_version
+
+  def custom
+    @custom
+  end
+
+  def custom=(value)
+    @custom = value.is_a?(Hash) ? value : Hash.new
+  end
+
+  def serialize
+    {
+      'userID' => @user_id,
+      'email' => @email,
+      'ip' => @ip,
+      'userAgent' => @user_agent,
+      'country' => @country,
+      'locale' => @locale,
+      'clientVersion' => @client_version,
+      'custom' => @custom,
+    }
+  end
+
+  def value_lookup
+    {
+      'userID' => @user_id,
+      'userid' => @user_id,
+      'user_id' => @user_id,
+      'email' => @email,
+      'ip' => @ip,
+      'userAgent' => @user_agent,
+      'useragent' => @user_agent,
+      'user_agent' => @user_agent,
+      'country' => @country,
+      'locale' => @locale,
+      'clientVersion' => @client_version,
+      'clientversion' => @client_version,
+      'client_version' => @client_version,
+      'custom' => @custom,
+    }
+  end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: statsig
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Statsig, Inc
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-01 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.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.1
+- !ruby/object:Gem::Dependency
+  name: browser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.3.1
+- !ruby/object:Gem::Dependency
+  name: browser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.3.1
+- !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.0
+  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.0
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.1
+description: Statsig server SDK for feature gates and experimentation in Ruby
+email: support@statsig.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/config_result.rb
+- lib/dynamic_config.rb
+- lib/evaluation_helpers.rb
+- lib/evaluator.rb
+- lib/network.rb
+- lib/spec_store.rb
+- lib/statsig.rb
+- lib/statsig_driver.rb
+- lib/statsig_event.rb
+- lib/statsig_logger.rb
+- lib/statsig_user.rb
+homepage: https://rubygems.org/gems/statsig
+licenses:
+- ISC
+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: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Statsig server SDK for Ruby
+test_files: []