statsig 1.8.0 → 1.8.4.beta.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4268658d92961175796c877e357cc3cf18f40656cf8aa272034fd4953bdb641e
-  data.tar.gz: e0a62e60cdca3b8b7ef8fe0302032badb88f8b9b5d86635bf20f79dc7fc011da
+  metadata.gz: 9e0d1d1530c323ccc58ea83da7a0c305692b51defa32071ee3f842d1519bb16b
+  data.tar.gz: e0d5018bbfd6f8c3dbe4fc099039d729d270d1ea5df8d5f59dbb72e56772da30
 SHA512:
-  metadata.gz: e40a7d816b2c36ec211272bfa21e1bacb035ae7a6a9a1366eb4bae9b0af917f1694f66a1d35f146018b49be6c0df1ec07fe549612d3a49e54c69ffeeb7e3e733
-  data.tar.gz: a53f398b7574bdaa47f26b5dcda0d2e11f83fbc85401b071592198ae24b59dbaec21cc74ec04f102ad909a06aeb0f552be1a49838241b035a2153b81c3250c04
+  metadata.gz: 9aa5bcf5d281709982ab3c325043cfcea99118e36bf2d82d11fd75995ad4a1e1f8f3e3e1a087652432ae5b6d0f15ee3a1a5deebff6f8d557ede16167edf72250
+  data.tar.gz: b1d95b28521991e9a247f181b16ce7652158bf713e230aca0a2c4ebc1752c6a2e317223e50e69caaa2b1b9751d85b7e6db3de5d70e5dc1750ca41009e52ec0a8

data/lib/config_result.rb

@@ -1,15 +1,18 @@
-class ConfigResult
-  attr_accessor :name
-  attr_accessor :gate_value
-  attr_accessor :json_value
-  attr_accessor :rule_id
-  attr_accessor :secondary_exposures
 
-  def initialize(name, gate_value = false, json_value = {}, rule_id = '', secondary_exposures = [])
-    @name = name
-    @gate_value = gate_value
-    @json_value = json_value
-    @rule_id = rule_id
-    @secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
+module Statsig
+  class ConfigResult
+    attr_accessor :name
+    attr_accessor :gate_value
+    attr_accessor :json_value
+    attr_accessor :rule_id
+    attr_accessor :secondary_exposures
+
+    def initialize(name, gate_value = false, json_value = {}, rule_id = '', secondary_exposures = [])
+      @name = name
+      @gate_value = gate_value
+      @json_value = json_value
+      @rule_id = rule_id
+      @secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
+    end
   end
 end

data/lib/evaluator.rb

@@ -10,300 +10,302 @@ require 'user_agent_parser/operating_system'
 $fetch_from_server = :fetch_from_server
 $type_dynamic_config = 'dynamic_config'
 
-class Evaluator
-  def initialize(network, error_callback)
-    @spec_store = SpecStore.new(network, error_callback)
-    @ua_parser = UserAgentParser::Parser.new
-    CountryLookup.initialize
-    @initialized = true
-  end
+module Statsig
+  class Evaluator
+    def initialize(network, error_callback)
+      @spec_store = Statsig::SpecStore.new(network, error_callback)
+      @ua_parser = UserAgentParser::Parser.new
+      CountryLookup.initialize
+      @initialized = true
+    end
 
-  def check_gate(user, gate_name)
-    return nil unless @initialized && @spec_store.has_gate?(gate_name)
-    eval_spec(user, @spec_store.get_gate(gate_name))
-  end
+    def check_gate(user, gate_name)
+      return nil unless @initialized && @spec_store.has_gate?(gate_name)
+      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)
-    eval_spec(user, @spec_store.get_config(config_name))
-  end
+    def get_config(user, config_name)
+      return nil unless @initialized && @spec_store.has_config?(config_name)
+      eval_spec(user, @spec_store.get_config(config_name))
+    end
 
-  def shutdown
-    @spec_store.shutdown
-  end
+    def shutdown
+      @spec_store.shutdown
+    end
+
+    private
+
+    def eval_spec(user, config)
+      default_rule_id = 'default'
+      exposures = []
+      if config['enabled']
+        i = 0
+        until i >= config['rules'].length do
+          rule = config['rules'][i]
+          result = eval_rule(user, rule)
+          return $fetch_from_server if result == $fetch_from_server
+          exposures = exposures + result['exposures'] if result['exposures'].is_a? Array
+          if result['value']
+            pass = eval_pass_percent(user, rule, config['salt'])
+            return Statsig::ConfigResult.new(
+              config['name'],
+              pass,
+              pass ? rule['returnValue'] : config['defaultValue'],
+              rule['id'],
+              exposures
+            )
+          end
+
+          i += 1
+        end
+      else
+        default_rule_id = 'disabled'
+      end
 
-  private
+      Statsig::ConfigResult.new(config['name'], false, config['defaultValue'], default_rule_id, exposures)
+    end
 
-  def eval_spec(user, config)
-    default_rule_id = 'default'
-    exposures = []
-    if config['enabled']
+    def eval_rule(user, rule)
+      exposures = []
+      pass = true
       i = 0
-      until i >= config['rules'].length do
-        rule = config['rules'][i]
-        result = eval_rule(user, rule)
-        return $fetch_from_server if result == $fetch_from_server
-        exposures = exposures + result['exposures'] if result['exposures'].is_a? Array
-        if result['value']
-          pass = eval_pass_percent(user, rule, config['salt'])
-          return ConfigResult.new(
-            config['name'],
-            pass,
-            pass ? rule['returnValue'] : config['defaultValue'],
-            rule['id'],
-            exposures
-          )
+      until i >= rule['conditions'].length do
+        result = eval_condition(user, rule['conditions'][i])
+        if result == $fetch_from_server
+          return $fetch_from_server
         end
 
+        if result.is_a?(Hash)
+          exposures = exposures + result['exposures'] if result['exposures'].is_a? Array
+          pass = false if result['value'] == false
+        elsif result == false
+          pass = false
+        end
         i += 1
       end
-    else
-      default_rule_id = 'disabled'
+      { 'value' => pass, 'exposures' => exposures }
     end
 
-    ConfigResult.new(config['name'], false, config['defaultValue'], default_rule_id, exposures)
-  end
-
-  def eval_rule(user, rule)
-    exposures = []
-    pass = true
-    i = 0
-    until i >= rule['conditions'].length do
-      result = eval_condition(user, rule['conditions'][i])
-      if result == $fetch_from_server
+    def eval_condition(user, condition)
+      value = nil
+      field = condition['field']
+      target = condition['targetValue']
+      type = condition['type']
+      operator = condition['operator']
+      additional_values = condition['additionalValues']
+      additional_values = Hash.new unless additional_values.is_a? Hash
+      idType = condition['idType']
+
+      return $fetch_from_server unless type.is_a? String
+      type = type.downcase
+
+      case type
+      when 'public'
+        return true
+      when 'fail_gate', 'pass_gate'
+        other_gate_result = check_gate(user, target)
+        return $fetch_from_server if other_gate_result == $fetch_from_server
+
+        gate_value = other_gate_result&.gate_value == true
+        new_exposure = {
+          'gate' => target,
+          'gateValue' => gate_value ? 'true' : 'false',
+          'ruleID' => other_gate_result&.rule_id
+        }
+        exposures = other_gate_result&.secondary_exposures&.append(new_exposure)
+        return {
+          'value' => type == 'pass_gate' ? gate_value : !gate_value,
+          'exposures' => exposures
+        }
+      when 'ip_based'
+        value = get_value_from_user(user, field) || get_value_from_ip(user, 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, field)
+        return $fetch_from_server if value == $fetch_from_server
+      when 'user_field'
+        value = get_value_from_user(user, field)
+      when 'environment_field'
+        value = get_value_from_environment(user, field)
+      when 'current_time'
+        value = Time.now.to_f # epoch time in seconds
+      when 'user_bucket'
+        begin
+          salt = additional_values['salt']
+          unit_id = get_unit_id(user, idType) || ''
+          # there are only 1000 user buckets as opposed to 10k for gate pass %
+          value = compute_user_hash("#{salt}.#{unit_id}") % 1000
+        rescue
+          return false
+        end
+      when 'unit_id'
+        value = get_unit_id(user, idType)
+      else
         return $fetch_from_server
       end
 
-      if result.is_a?(Hash)
-        exposures = exposures + result['exposures'] if result['exposures'].is_a? Array
-        pass = false if result['value'] == false
-      elsif result == false
-        pass = false
-      end
-      i += 1
-    end
-    { 'value' => pass, 'exposures' => exposures }
-  end
-
-  def eval_condition(user, condition)
-    value = nil
-    field = condition['field']
-    target = condition['targetValue']
-    type = condition['type']
-    operator = condition['operator']
-    additional_values = condition['additionalValues']
-    additional_values = Hash.new unless additional_values.is_a? Hash
-    idType = condition['idType']
-
-    return $fetch_from_server unless type.is_a? String
-    type = type.downcase
-
-    case type
-    when 'public'
-      return true
-    when 'fail_gate', 'pass_gate'
-      other_gate_result = check_gate(user, target)
-      return $fetch_from_server if other_gate_result == $fetch_from_server
-
-      gate_value = other_gate_result&.gate_value == true
-      new_exposure = {
-        'gate' => target,
-        'gateValue' => gate_value ? 'true' : 'false',
-        'ruleID' => other_gate_result&.rule_id
-      }
-      exposures = other_gate_result&.secondary_exposures&.append(new_exposure)
-      return {
-        'value' => type == 'pass_gate' ? gate_value : !gate_value,
-        'exposures' => exposures
-      }
-    when 'ip_based'
-      value = get_value_from_user(user, field) || get_value_from_ip(user, 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, field)
-      return $fetch_from_server if value == $fetch_from_server
-    when 'user_field'
-      value = get_value_from_user(user, field)
-    when 'environment_field'
-      value = get_value_from_environment(user, field)
-    when 'current_time'
-      value = Time.now.to_f # epoch time in seconds
-    when 'user_bucket'
-      begin
-        salt = additional_values['salt']
-        unit_id = get_unit_id(user, idType) || ''
-        # there are only 1000 user buckets as opposed to 10k for gate pass %
-        value = compute_user_hash("#{salt}.#{unit_id}") % 1000
-      rescue
-        return false
+      return $fetch_from_server if value == $fetch_from_server || !operator.is_a?(String)
+      operator = operator.downcase
+
+      case operator
+        # numerical comparison
+      when 'gt'
+        return EvaluationHelpers::compare_numbers(value, target, ->(a, b) { a > b })
+      when 'gte'
+        return EvaluationHelpers::compare_numbers(value, target, ->(a, b) { a >= b })
+      when 'lt'
+        return EvaluationHelpers::compare_numbers(value, target, ->(a, b) { a < b })
+      when 'lte'
+        return EvaluationHelpers::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 EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a == b })
+      when 'none'
+        return !EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a == b })
+      when 'any_case_sensitive'
+        return EvaluationHelpers::match_string_in_array(target, value, false, ->(a, b) { a == b })
+      when 'none_case_sensitive'
+        return !EvaluationHelpers::match_string_in_array(target, value, false, ->(a, b) { a == b })
+
+        #string
+      when 'str_starts_with_any'
+        return EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a.start_with?(b) })
+      when 'str_ends_with_any'
+        return EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a.end_with?(b) })
+      when 'str_contains_any'
+        return EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a.include?(b) })
+      when 'str_contains_none'
+        return !EvaluationHelpers::match_string_in_array(target, value, true, ->(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'
+        return EvaluationHelpers::compare_times(value, target, ->(a, b) { a < b })
+      when 'after'
+        return EvaluationHelpers::compare_times(value, target, ->(a, b) { a > b })
+      when 'on'
+        return EvaluationHelpers::compare_times(value, target, ->(a, b) { a.year == b.year && a.month == b.month && a.day == b.day })
+      when 'in_segment_list', 'not_in_segment_list'
+        begin
+        id_list = (@spec_store.get_id_list(target) || {:ids => {}})[:ids]
+        hashed_id = Digest::SHA256.base64digest(value.to_s)[0, 8]    
+        is_in_list = id_list.is_a?(Hash) && id_list[hashed_id] == true
+        
+        return is_in_list if operator == 'in_segment_list'
+        return !is_in_list
+        rescue StandardError => e
+          return false
+        end
+      else
+        return $fetch_from_server
       end
-    when 'unit_id'
-      value = get_unit_id(user, idType)
-    else
-      return $fetch_from_server
     end
 
-    return $fetch_from_server if value == $fetch_from_server || !operator.is_a?(String)
-    operator = operator.downcase
-
-    case operator
-      # numerical comparison
-    when 'gt'
-      return EvaluationHelpers::compare_numbers(value, target, ->(a, b) { a > b })
-    when 'gte'
-      return EvaluationHelpers::compare_numbers(value, target, ->(a, b) { a >= b })
-    when 'lt'
-      return EvaluationHelpers::compare_numbers(value, target, ->(a, b) { a < b })
-    when 'lte'
-      return EvaluationHelpers::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 EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a == b })
-    when 'none'
-      return !EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a == b })
-    when 'any_case_sensitive'
-      return EvaluationHelpers::match_string_in_array(target, value, false, ->(a, b) { a == b })
-    when 'none_case_sensitive'
-      return !EvaluationHelpers::match_string_in_array(target, value, false, ->(a, b) { a == b })
-
-      #string
-    when 'str_starts_with_any'
-      return EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a.start_with?(b) })
-    when 'str_ends_with_any'
-      return EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a.end_with?(b) })
-    when 'str_contains_any'
-      return EvaluationHelpers::match_string_in_array(target, value, true, ->(a, b) { a.include?(b) })
-    when 'str_contains_none'
-      return !EvaluationHelpers::match_string_in_array(target, value, true, ->(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'
-      return EvaluationHelpers::compare_times(value, target, ->(a, b) { a < b })
-    when 'after'
-      return EvaluationHelpers::compare_times(value, target, ->(a, b) { a > b })
-    when 'on'
-      return EvaluationHelpers::compare_times(value, target, ->(a, b) { a.year == b.year && a.month == b.month && a.day == b.day })
-    when 'in_segment_list', 'not_in_segment_list'
-      begin
-      id_list = (@spec_store.get_id_list(target) || {:ids => {}})[:ids]
-      hashed_id = Digest::SHA256.base64digest(value.to_s)[0, 8]    
-      is_in_list = id_list.is_a?(Hash) && id_list[hashed_id] == true
-      
-      return is_in_list if operator == 'in_segment_list'
-      return !is_in_list
-      rescue StandardError => e
-        return false
-      end
-    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)
 
-  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_lookup_table[field.downcase].nil?
 
-    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_lookup_table[field.downcase].nil?
+      user_custom = user_lookup_table['custom']
+      if user_custom.is_a?(Hash)
+        user_custom.each do |key, value|
+          return value if key.downcase.casecmp?(field.downcase) && !value.nil?
+        end
+      end
 
-    user_custom = user_lookup_table['custom']
-    if user_custom.is_a?(Hash)
-      user_custom.each do |key, value|
-        return value if key.downcase.casecmp?(field.downcase) && !value.nil?
+      private_attributes = user_lookup_table['privateAttributes']
+      if private_attributes.is_a?(Hash)
+        private_attributes.each do |key, value|
+          return value if key.downcase.casecmp?(field.downcase) && !value.nil?
+        end
       end
+
+      nil
     end
 
-    private_attributes = user_lookup_table['privateAttributes']
-    if private_attributes.is_a?(Hash)
-      private_attributes.each do |key, value|
-        return value if key.downcase.casecmp?(field.downcase) && !value.nil?
+    def get_value_from_environment(user, field)
+      return nil unless user.instance_of?(StatsigUser) && field.is_a?(String)
+      field = field.downcase
+      return nil unless user.statsig_environment.is_a? Hash
+      user.statsig_environment.each do |key, value|
+        return value if key.downcase == (field)
       end
+      nil
     end
 
-    nil
-  end
+    def get_value_from_ip(user, field)
+      return nil unless user.is_a?(StatsigUser) && field.is_a?(String) && field.downcase == 'country'
+      ip = get_value_from_user(user, 'ip')
+      return nil unless ip.is_a?(String)
 
-  def get_value_from_environment(user, field)
-    return nil unless user.instance_of?(StatsigUser) && field.is_a?(String)
-    field = field.downcase
-    return nil unless user.statsig_environment.is_a? Hash
-    user.statsig_environment.each do |key, value|
-      return value if key.downcase == (field)
+      CountryLookup.lookup_ip_string(ip)
     end
-    nil
-  end
-
-  def get_value_from_ip(user, field)
-    return nil unless user.is_a?(StatsigUser) && field.is_a?(String) && field.downcase == 'country'
-    ip = get_value_from_user(user, 'ip')
-    return nil unless ip.is_a?(String)
 
-    CountryLookup.lookup_ip_string(ip)
-  end
-
-  def get_value_from_ua(user, field)
-    return nil unless user.is_a?(StatsigUser) && field.is_a?(String)
-    ua = get_value_from_user(user, 'userAgent')
-    return nil unless ua.is_a?(String)
-
-    parsed = @ua_parser.parse ua
-    os = parsed.os
-    case field.downcase
-    when 'os_name', 'osname'
-      return os&.family
-    when 'os_version', 'osversion'
-      return os&.version unless os&.version.nil?
-    when 'browser_name', 'browsername'
-      return parsed.family
-    when 'browser_version', 'browserversion'
-      return parsed.version.to_s
-    else
-      nil
+    def get_value_from_ua(user, field)
+      return nil unless user.is_a?(StatsigUser) && field.is_a?(String)
+      ua = get_value_from_user(user, 'userAgent')
+      return nil unless ua.is_a?(String)
+
+      parsed = @ua_parser.parse ua
+      os = parsed.os
+      case field.downcase
+      when 'os_name', 'osname'
+        return os&.family
+      when 'os_version', 'osversion'
+        return os&.version unless os&.version.nil?
+      when 'browser_name', 'browsername'
+        return parsed.family
+      when 'browser_version', 'browserversion'
+        return parsed.version.to_s
+      else
+        nil
+      end
     end
-  end
 
-  def eval_pass_percent(user, rule, config_salt)
-    return false unless config_salt.is_a?(String) && !rule['passPercentage'].nil?
-    begin
-      unit_id = get_unit_id(user, rule['id_type']) || ''
-      rule_salt = rule['salt'] || rule['id'] || ''
-      hash = compute_user_hash("#{config_salt}.#{rule_salt}.#{unit_id}")
-      return (hash % 10000) < (rule['passPercentage'].to_f * 100)
-    rescue
-      return false
+    def eval_pass_percent(user, rule, config_salt)
+      return false unless config_salt.is_a?(String) && !rule['passPercentage'].nil?
+      begin
+        unit_id = get_unit_id(user, rule['id_type']) || ''
+        rule_salt = rule['salt'] || rule['id'] || ''
+        hash = compute_user_hash("#{config_salt}.#{rule_salt}.#{unit_id}")
+        return (hash % 10000) < (rule['passPercentage'].to_f * 100)
+      rescue
+        return false
+      end
     end
-  end
 
-  def get_unit_id(user, id_type)
-    if id_type.is_a?(String) && id_type.downcase != 'userid'
-      return nil unless user&.custom_ids.is_a? Hash
-      return user.custom_ids[id_type] || user.custom_ids[id_type.downcase]
+    def get_unit_id(user, id_type)
+      if id_type.is_a?(String) && id_type.downcase != 'userid'
+        return nil unless user&.custom_ids.is_a? Hash
+        return user.custom_ids[id_type] || user.custom_ids[id_type.downcase]
+      end
+      user.user_id
     end
-    user.user_id
-  end
 
-  def compute_user_hash(user_hash)
-    Digest::SHA256.digest(user_hash).unpack('Q>')[0]
+    def compute_user_hash(user_hash)
+      Digest::SHA256.digest(user_hash).unpack('Q>')[0]
+    end
   end
 end

data/lib/network.rb

@@ -4,65 +4,67 @@ require 'dynamic_config'
 
 $retry_codes = [408, 500, 502, 503, 504, 522, 524, 599]
 
-class Network
-  def initialize(server_secret, api, backoff_mult = 10)
-    super()
-    unless api.end_with?('/')
-      api += '/'
+module Statsig
+  class Network
+    def initialize(server_secret, api, backoff_mult = 10)
+      super()
+      unless api.end_with?('/')
+        api += '/'
+      end
+      @server_secret = server_secret
+      @api = api
+      @backoff_multiplier = backoff_mult
     end
-    @server_secret = server_secret
-    @api = api
-    @backoff_multiplier = backoff_mult
-  end
 
-  def post_helper(endpoint, body, retries = 0, backoff = 1)
-    http = HTTP.headers(
-      {"STATSIG-API-KEY" => @server_secret,
-       "STATSIG-CLIENT-TIME" => (Time.now.to_f * 1000).to_s,
-       "Content-Type" => "application/json; charset=UTF-8"
-      }).accept(:json)
-    begin
-      res = http.post(@api + endpoint, body: body)
-    rescue StandardError => e
-      ## network error retry
-      return nil, e unless retries > 0
+    def post_helper(endpoint, body, retries = 0, backoff = 1)
+      http = HTTP.headers(
+        {"STATSIG-API-KEY" => @server_secret,
+        "STATSIG-CLIENT-TIME" => (Time.now.to_f * 1000).to_s,
+        "Content-Type" => "application/json; charset=UTF-8"
+        }).accept(:json)
+      begin
+        res = http.post(@api + endpoint, body: body)
+      rescue StandardError => e
+        ## network error retry
+        return nil, e unless retries > 0
+        sleep backoff
+        return post_helper(endpoint, body, retries - 1, backoff * @backoff_multiplier)
+      end
+      return res, nil unless !res.status.success?
+      return nil, StandardError.new("Got an exception when making request to #{@api + endpoint}: #{res.to_s}") unless retries > 0 && $retry_codes.include?(res.code)
+      ## status code retry
       sleep backoff
-      return post_helper(endpoint, body, retries - 1, backoff * @backoff_multiplier)
+      post_helper(endpoint, body, retries - 1, backoff * @backoff_multiplier)
     end
-    return res, nil unless !res.status.success?
-    return nil, StandardError.new("Got an exception when making request to #{@api + endpoint}: #{res.to_s}") unless retries > 0 && $retry_codes.include?(res.code)
-    ## status code retry
-    sleep backoff
-    post_helper(endpoint, body, retries - 1, backoff * @backoff_multiplier)
-  end
 
-  def check_gate(user, gate_name)
-    begin
-      request_body = JSON.generate({'user' => user&.serialize(false), 'gateName' => gate_name})
-      response, _ = post_helper('check_gate', request_body)
-      return JSON.parse(response.body) unless response.nil?
-      false
-    rescue
-      return false
+    def check_gate(user, gate_name)
+      begin
+        request_body = JSON.generate({'user' => user&.serialize(false), 'gateName' => gate_name})
+        response, _ = post_helper('check_gate', request_body)
+        return JSON.parse(response.body) unless response.nil?
+        false
+      rescue
+        return false
+      end
     end
-  end
 
-  def get_config(user, dynamic_config_name)
-    begin
-      request_body = JSON.generate({'user' => user&.serialize(false), 'configName' => dynamic_config_name})
-      response, _ = post_helper('get_config', request_body)
-      return JSON.parse(response.body) unless response.nil?
-      nil
-    rescue
-      return nil
+    def get_config(user, dynamic_config_name)
+      begin
+        request_body = JSON.generate({'user' => user&.serialize(false), 'configName' => dynamic_config_name})
+        response, _ = post_helper('get_config', request_body)
+        return JSON.parse(response.body) unless response.nil?
+        nil
+      rescue
+        return nil
+      end
     end
-  end
 
-  def post_logs(events)
-    begin
-      json_body = JSON.generate({'events' => events, 'statsigMetadata' => Statsig.get_statsig_metadata})
-      post_helper('log_event', json_body, retries: 5)
-    rescue
+    def post_logs(events)
+      begin
+        json_body = JSON.generate({'events' => events, 'statsigMetadata' => Statsig.get_statsig_metadata})
+        post_helper('log_event', json_body, retries: 5)
+      rescue
+      end
     end
   end
 end

data/lib/spec_store.rb

@@ -1,150 +1,151 @@
 require 'net/http'
 require 'uri'
 
-class SpecStore
-  def initialize(network, error_callback = nil, config_sync_interval = 10, id_lists_sync_interval = 60)
-    @network = network
-    @last_sync_time = 0
-    @config_sync_interval = config_sync_interval
-    @id_lists_sync_interval = id_lists_sync_interval
-    @store = {
-      :gates => {},
-      :configs => {},
-      :id_lists => {},
-    }
-    e = download_config_specs
-    error_callback.call(e) unless error_callback.nil?
-    download_id_lists
-
-    @config_sync_thread = sync_config_specs
-    @id_lists_sync_thread = sync_id_lists
-  end
+module Statsig
+  class SpecStore
+    def initialize(network, error_callback = nil, config_sync_interval = 10, id_lists_sync_interval = 60)
+      @network = network
+      @last_sync_time = 0
+      @config_sync_interval = config_sync_interval
+      @id_lists_sync_interval = id_lists_sync_interval
+      @store = {
+        :gates => {},
+        :configs => {},
+        :id_lists => {},
+      }
+      e = download_config_specs
+      error_callback.call(e) unless error_callback.nil?
+      download_id_lists
+
+      @config_sync_thread = sync_config_specs
+      @id_lists_sync_thread = sync_id_lists
+    end
 
-  def shutdown
-    @config_sync_thread&.exit
-    @id_lists_sync_thread&.exit
-  end
+    def shutdown
+      @config_sync_thread&.exit
+      @id_lists_sync_thread&.exit
+    end
 
-  def has_gate?(gate_name)
-    @store[:gates].key?(gate_name)
-  end
+    def has_gate?(gate_name)
+      @store[:gates].key?(gate_name)
+    end
 
-  def has_config?(config_name)
-    @store[:configs].key?(config_name)
-  end
+    def has_config?(config_name)
+      @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_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
+    def get_config(config_name)
+      return nil unless has_config?(config_name)
+      @store[:configs][config_name]
+    end
 
-  def get_id_list(list_name)
-    @store[:id_lists][list_name]
-  end
+    def get_id_list(list_name)
+      @store[:id_lists][list_name]
+    end
 
-  private
+    private
 
-  def sync_config_specs
-    Thread.new do
-      loop do
-        sleep @config_sync_interval
-        download_config_specs
+    def sync_config_specs
+      Thread.new do
+        loop do
+          sleep @config_sync_interval
+          download_config_specs
+        end
       end
     end
-  end
 
-  def sync_id_lists
-    Thread.new do
-      loop do
-        sleep @id_lists_sync_interval
-        download_id_lists
+    def sync_id_lists
+      Thread.new do
+        loop do
+          sleep @id_lists_sync_interval
+          download_id_lists
+        end
       end
     end
-  end
 
-  def download_config_specs
-    begin
-      response, e = @network.post_helper('download_config_specs', JSON.generate({'sinceTime' => @last_sync_time}))
-      if e.nil?
-        process(JSON.parse(response.body))
-      else
+    def download_config_specs
+      begin
+        response, e = @network.post_helper('download_config_specs', JSON.generate({'sinceTime' => @last_sync_time}))
+        if e.nil?
+          process(JSON.parse(response.body))
+        else
+          e
+        end
+      rescue StandardError => e
         e
       end
-    rescue StandardError => e
-      e
     end
-  end
 
-  def process(specs_json)
-    if specs_json.nil?
-      return
-    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?
+      @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?
 
-    new_gates = {}
-    new_configs = {}
+      new_gates = {}
+      new_configs = {}
 
-    specs_json['feature_gates'].map{|gate|  new_gates[gate['name']] = gate }
-    specs_json['dynamic_configs'].map{|config|  new_configs[config['name']] = config }
-    @store[:gates] = new_gates
-    @store[:configs] = new_configs
+      specs_json['feature_gates'].map{|gate|  new_gates[gate['name']] = gate }
+      specs_json['dynamic_configs'].map{|config|  new_configs[config['name']] = config }
+      @store[:gates] = new_gates
+      @store[:configs] = new_configs
 
-    new_id_lists = specs_json['id_lists']
-    if new_id_lists.is_a? Hash
-      new_id_lists.each do |list_name, _|
-        unless @store[:id_lists].key?(list_name)
-          @store[:id_lists][list_name] = { :ids => {}, :time => 0 }
+      new_id_lists = specs_json['id_lists']
+      if new_id_lists.is_a? Hash
+        new_id_lists.each do |list_name, _|
+          unless @store[:id_lists].key?(list_name)
+            @store[:id_lists][list_name] = { :ids => {}, :time => 0 }
+          end
         end
-      end
 
-      @store[:id_lists].each do |list_name, _|
-        unless new_id_lists.key?(list_name)
-          @store[:id_lists].delete(list_name)
+        @store[:id_lists].each do |list_name, _|
+          unless new_id_lists.key?(list_name)
+            @store[:id_lists].delete(list_name)
+          end
         end
       end
     end
-  end
 
-  def download_id_lists
-    if @store[:id_lists].is_a? Hash
-      threads = []
-      id_lists = @store[:id_lists]
-      id_lists.each do |list_name, list|
-        threads << Thread.new do
-          response, e = @network.post_helper('download_id_list', JSON.generate({'listName' => list_name, 'statsigMetadata' => Statsig.get_statsig_metadata, 'sinceTime' => list['time'] || 0 }))
-          if e.nil? && !response.nil?
-            begin
-              data = JSON.parse(response)
-              if data['add_ids'].is_a? Array
-                data['add_ids'].each do |id|
-                  list[:ids][id] = true
+    def download_id_lists
+      if @store[:id_lists].is_a? Hash
+        threads = []
+        id_lists = @store[:id_lists]
+        id_lists.each do |list_name, list|
+          threads << Thread.new do
+            response, e = @network.post_helper('download_id_list', JSON.generate({'listName' => list_name, 'statsigMetadata' => Statsig.get_statsig_metadata, 'sinceTime' => list['time'] || 0 }))
+            if e.nil? && !response.nil?
+              begin
+                data = JSON.parse(response)
+                if data['add_ids'].is_a? Array
+                  data['add_ids'].each do |id|
+                    list[:ids][id] = true
+                  end
                 end
-              end
-              if data['remove_ids'].is_a? Array
-                data['remove_ids'].each do |id|
-                  list[:ids]&.delete(id)
+                if data['remove_ids'].is_a? Array
+                  data['remove_ids'].each do |id|
+                    list[:ids]&.delete(id)
+                  end
                 end
+                if data['time'].is_a? Numeric
+                  list[:time] = data['time']
+                end
+              rescue
+                # Ignored
               end
-              if data['time'].is_a? Numeric
-                list[:time] = data['time']
-              end
-            rescue
-              # Ignored
             end
           end
         end
+        threads.each(&:join)
       end
-      threads.each(&:join)
     end
   end
-
-end
+end

data/lib/statsig.rb

@@ -40,7 +40,7 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '1.8.0',
+      'sdkVersion' => '1.8.4.beta-1`',
     }
   end
 

data/lib/statsig_driver.rb

@@ -20,9 +20,9 @@ class StatsigDriver
     @options = options || StatsigOptions.new
     @shutdown = false
     @secret_key = secret_key
-    @net = Network.new(secret_key, @options.api_url_base)
-    @logger = StatsigLogger.new(@net)
-    @evaluator = Evaluator.new(@net, error_callback)
+    @net = Statsig::Network.new(secret_key, @options.api_url_base)
+    @logger = Statsig::StatsigLogger.new(@net)
+    @evaluator = Statsig::Evaluator.new(@net, error_callback)
   end
 
   def check_gate(user, gate_name)
@@ -35,7 +35,7 @@ class StatsigDriver
 
     res = @evaluator.check_gate(user, gate_name)
     if res.nil?
-      res = ConfigResult.new(gate_name)
+      res = Statsig::ConfigResult.new(gate_name)
     end
 
     if res == $fetch_from_server
@@ -58,7 +58,7 @@ class StatsigDriver
 
     res = @evaluator.get_config(user, dynamic_config_name)
     if res.nil?
-      res = ConfigResult.new(dynamic_config_name)
+      res = Statsig::ConfigResult.new(dynamic_config_name)
     end
 
     if res == $fetch_from_server
@@ -124,11 +124,11 @@ class StatsigDriver
   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)
+      config_result = Statsig::ConfigResult.new(gate_name)
       return config_result
     end
 
-    ConfigResult.new(
+    Statsig::ConfigResult.new(
       network_result['name'],
       network_result['value'],
       {},
@@ -139,11 +139,11 @@ class StatsigDriver
   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)
+      config_result = Statsig::ConfigResult.new(dynamic_config_name)
       return config_result
     end
 
-    ConfigResult.new(
+    Statsig::ConfigResult.new(
       network_result['name'],
       false,
       network_result['value'],

data/lib/statsig_logger.rb

@@ -3,58 +3,71 @@ require 'statsig_event'
 $gate_exposure_event = 'statsig::gate_exposure'
 $config_exposure_event = 'statsig::config_exposure'
 
-class StatsigLogger
-  def initialize(network)
-    @network = network
-    @events = []
-    @background_flush = Thread.new do
-      sleep 60
-      flush
+module Statsig
+  class StatsigLogger
+    def initialize(network)
+      @network = network
+      @events = []
+      @background_flush = periodic_flush
     end
-  end
 
-  def log_event(event)
-    @events.push(event)
-    if @events.length >= 500
-      flush
+    def log_event(event)
+      @events.push(event)
+      if @events.length >= 500
+        flush
+      end
     end
-  end
 
-  def log_gate_exposure(user, gate_name, value, rule_id, secondary_exposures)
-    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.get_statsig_metadata
-    event.secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
-    log_event(event)
-  end
-
-  def log_config_exposure(user, config_name, rule_id, secondary_exposures)
-    event = StatsigEvent.new($config_exposure_event)
-    event.user = user
-    event.metadata = {
-      'config' => config_name,
-      'ruleID' => rule_id
-    }
-    event.statsig_metadata = Statsig.get_statsig_metadata
-    event.secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
-    log_event(event)
-  end
+    def log_gate_exposure(user, gate_name, value, rule_id, secondary_exposures)
+      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.get_statsig_metadata
+      event.secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
+      log_event(event)
+    end
 
-  def flush(closing = false)
-    if closing
-      @background_flush.exit
+    def log_config_exposure(user, config_name, rule_id, secondary_exposures)
+      event = StatsigEvent.new($config_exposure_event)
+      event.user = user
+      event.metadata = {
+        'config' => config_name,
+        'ruleID' => rule_id
+      }
+      event.statsig_metadata = Statsig.get_statsig_metadata
+      event.secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
+      log_event(event)
     end
-    if @events.length == 0
-      return
+
+    def periodic_flush
+      puts "Statsig:: starting a thread"
+      Thread.new do
+        loop do
+          puts "Statsig:: beginning to sleep for 60 seconds"
+          sleep 60
+          puts "Statsig:: finished sleeping"
+          flush
+          puts "Statsig:: flushed"
+        end
+      end
     end
-    flush_events = @events.map { |e| e.serialize }
-    @events = []
 
-    @network.post_logs(flush_events)
+    def flush(closing = false)
+      if closing
+        @background_flush&.exit
+      end
+      if @events.length == 0
+        return
+      end
+      puts "Statsig:: flushing events, count: #{@events.length.to_s}" 
+      flush_events = @events.map { |e| e.serialize }
+      @events = []
+
+      @network.post_logs(flush_events)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.8.4.beta.pre.1
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-18 00:00:00.000000000 Z
+date: 2022-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -141,9 +141,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.3
 signing_key: