statsig 1.7.0.beta.1 → 1.8.1.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf5fda9f980ecae86129f6ea0bd4052b6af45cba14c83e38062b495cd06cfeb1
-  data.tar.gz: 5b1a231a8af145fec2303fc89998f3e9acf05323cbc55d9fea3850ba841ecd1e
+  metadata.gz: 85cc5f1ff296df6832034a396c9e575cd21e54502cff95467c691289143d0067
+  data.tar.gz: a3ca082effe4a16dde1e73b700c30322db55a00e3e8f384015ae8d22640e41f8
 SHA512:
-  metadata.gz: 7f1c7cf9a5a549021f02c16bac3d1095143ee9231a3f4165db9040efbf9b16cef083b6955dc5f748dd5fcfe12953064e8c48874a1eb8f477c24f61d061a57890
-  data.tar.gz: a5f291bd14edb61286416c293eae1c14f3c519dc1c6548356fe7147667cc33ed6b327488412e2f0b5516139d71d06bacf0db3f6ee907685be9c7e8ca2cc6b119
+  metadata.gz: 182507d8e780f6d37f0f94fe5e2183ad0c1fb8f6500ea8271203df45debcfa00a9630e03670a2e82e010aa77f41abb1d3d38ca5067c7e5df88dbf697c7aa7716
+  data.tar.gz: de3029066c82f7886a55a0c0beecddd65751ebc337d3a6138ccb437c5ba506a4e238f55cca1e301530a4168dd126ea2fba833dfe8af70cc2936bbe7c72f68f3f

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/evaluation_helpers.rb

@@ -2,7 +2,7 @@ require 'time'
 
 module EvaluationHelpers
   def self.compare_numbers(a, b, func)
-    return false unless self.is_numeric(a) && self.is_numeric(b)
+    return false unless is_numeric(a) && is_numeric(b)
     func.call(a.to_f, b.to_f) rescue false
   end
 
@@ -15,8 +15,8 @@ module EvaluationHelpers
 
   def self.compare_times(a, b, func)
     begin
-      time_1 = self.get_epoch_time(a)
-      time_2 = self.get_epoch_time(b)
+      time_1 = get_epoch_time(a)
+      time_2 = get_epoch_time(b)
       func.call(time_1, time_2)
     rescue
       false
@@ -30,7 +30,7 @@ module EvaluationHelpers
   end
 
   def self.get_epoch_time(v)
-    time = self.is_numeric(v) ? Time.at(v.to_f) : Time.parse(v)
+    time = is_numeric(v) ? Time.at(v.to_f) : Time.parse(v)
     if time.year > Time.now.year + 100
       # divide by 1000 when the epoch time is in milliseconds instead of seconds
       return time.to_i / 1000

data/lib/evaluator.rb

@@ -10,273 +10,302 @@ require 'user_agent_parser/operating_system'
 $fetch_from_server = :fetch_from_server
 $type_dynamic_config = 'dynamic_config'
 
-class Evaluator
-  def initialize(store)
-    @spec_store = store
-    @initialized = true
-    @ua_parser = UserAgentParser::Parser.new
-    CountryLookup.initialize
-  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)
-    self.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)
-    self.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
 
-  private
+    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
+
+      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 = self.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 = self.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
-    elsif (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 = self.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
-
-    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 = self.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']
-        user_id = user.user_id || ''
-        # there are only 1000 user buckets as opposed to 10k for gate pass %
-        value = compute_user_hash("#{salt}.#{user_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
-    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 })
-    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
+      end
+    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 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 eval_pass_percent(user, rule, config_salt)
-    return false unless config_salt.is_a?(String) && !rule['passPercentage'].nil?
-    begin
-      user_id = user.user_id || ''
-      rule_salt = rule['salt'] || rule['id'] || ''
-      hash = compute_user_hash("#{config_salt}.#{rule_salt}.#{user_id}")
-      return (hash % 10000) < (rule['passPercentage'].to_f * 100)
-    rescue
-      return false
+    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
-  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,90 +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
-    @last_sync_time = 0
-    @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)
-    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
-    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
+      post_helper(endpoint, body, retries - 1, backoff * @backoff_multiplier)
     end
-  end
 
-  def download_config_specs
-    begin
-      response, e = post_helper('download_config_specs', JSON.generate({'sinceTime' => @last_sync_time}))
-      return nil, e if response.nil?
-      json_body = JSON.parse(response.body)
-      @last_sync_time = json_body['time']
-      return json_body, nil
-    rescue StandardError => e
-      return nil, e
+    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 poll_for_changes(callback)
-    Thread.new do
-      loop do
-        sleep 10
-        specs, _ = download_config_specs
-        unless specs.nil?
-          callback.call(specs)
-        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
       end
     end
-  end
 
-  def post_logs(events, statsig_metadata)
-    begin
-      json_body = JSON.generate({'events' => events, 'statsigMetadata' => 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,51 +1,151 @@
 require 'net/http'
 require 'uri'
 
-class SpecStore
-  def initialize(specs_json)
-    @last_sync_time = 0
-    @store = {
-      :gates => {},
-      :configs => {},
-    }
-    process(specs_json)
-  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
 
-  def process(specs_json)
-    if specs_json.nil?
-      return
+      @config_sync_thread = sync_config_specs
+      @id_lists_sync_thread = sync_id_lists
     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?
+    def shutdown
+      @config_sync_thread&.exit
+      @id_lists_sync_thread&.exit
+    end
 
-    @store = {
-      :gates => {},
-      :configs => {},
-    }
+    def has_gate?(gate_name)
+      @store[:gates].key?(gate_name)
+    end
 
-    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_config?(config_name)
+      @store[:configs].key?(config_name)
+    end
 
-  def has_gate?(gate_name)
-    return @store[:gates].key?(gate_name)
-  end
+    def get_gate(gate_name)
+      return nil unless has_gate?(gate_name)
+      @store[:gates][gate_name]
+    end
 
-  def has_config?(config_name)
-    return @store[:configs].key?(config_name)
-  end
+    def get_config(config_name)
+      return nil unless has_config?(config_name)
+      @store[:configs][config_name]
+    end
 
-  def get_gate(gate_name)
-    return nil unless has_gate?(gate_name)
-    @store[:gates][gate_name]
-  end
+    def get_id_list(list_name)
+      @store[:id_lists][list_name]
+    end
 
-  def get_config(config_name)
-    return nil unless has_config?(config_name)
-    @store[:configs][config_name]
-  end
+    private
+
+    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
+        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
+          e
+        end
+      rescue StandardError => e
+        e
+      end
+    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?
+
+      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
+
+      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
+
+        @store[:id_lists].each do |list_name, _|
+          unless new_id_lists.key?(list_name)
+            @store[:id_lists].delete(list_name)
+          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
+                  end
+                end
+                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
+            end
+          end
+        end
+        threads.each(&:join)
+      end
+    end
+  end
+end

data/lib/statsig.rb

@@ -11,22 +11,22 @@ module Statsig
   end
 
   def self.check_gate(user, gate_name)
-    self.ensure_initialized
+    ensure_initialized
     @shared_instance&.check_gate(user, gate_name)
   end
 
   def self.get_config(user, dynamic_config_name)
-    self.ensure_initialized
+    ensure_initialized
     @shared_instance&.get_config(user, dynamic_config_name)
   end
 
   def self.get_experiment(user, experiment_name)
-    self.ensure_initialized
+    ensure_initialized
     @shared_instance&.get_config(user, experiment_name)
   end
 
   def self.log_event(user, event_name, value, metadata)
-    self.ensure_initialized
+    ensure_initialized
     @shared_instance&.log_event(user, event_name, value, metadata)
   end
 
@@ -37,6 +37,13 @@ module Statsig
     @shared_instance = nil
   end
 
+  def self.get_statsig_metadata
+    {
+      'sdkType' => 'ruby-server',
+      'sdkVersion' => '1.8.1.beta.1',
+    }
+  end
+
   private
 
   def self.ensure_initialized

data/lib/statsig_driver.rb

@@ -20,24 +20,9 @@ class StatsigDriver
     @options = options || StatsigOptions.new
     @shutdown = false
     @secret_key = secret_key
-    @net = Network.new(secret_key, @options.api_url_base)
-    @statsig_metadata = {
-      'sdkType' => 'ruby-server',
-      'sdkVersion' => Gem::Specification::load('statsig.gemspec')&.version,
-    }
-    @logger = StatsigLogger.new(@net, @statsig_metadata)
-
-    downloaded_specs, e = @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) })
-
-    error_callback.call(e) unless error_callback.nil?
+    @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)
@@ -47,13 +32,10 @@ class StatsigDriver
       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)
+      res = Statsig::ConfigResult.new(gate_name)
     end
 
     if res == $fetch_from_server
@@ -73,13 +55,10 @@ class StatsigDriver
       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)
+      res = Statsig::ConfigResult.new(dynamic_config_name)
     end
 
     if res == $fetch_from_server
@@ -111,14 +90,14 @@ class StatsigDriver
     event.user = user
     event.value = value
     event.metadata = metadata
-    event.statsig_metadata = @statsig_metadata
+    event.statsig_metadata = Statsig.get_statsig_metadata
     @logger.log_event(event)
   end
 
   def shutdown
     @shutdown = true
     @logger.flush(true)
-    @polling_thread&.exit
+    @evaluator.shutdown
   end
 
   private
@@ -145,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'],
       {},
@@ -160,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,59 +3,60 @@ 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 = []
-    @background_flush = Thread.new do
-      sleep 60
-      flush
+module Statsig
+  class StatsigLogger
+    def initialize(network)
+      @network = network
+      @events = []
+      @background_flush = Thread.new do
+        sleep 60
+        flush
+      end
     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_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_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_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
-    if @events.length == 0
-      return
+
+    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
-    flush_events = @events.map { |e| e.serialize }
-    @events = []
 
-    @network.post_logs(flush_events, @statsig_metadata)
+    def flush(closing = false)
+      if closing
+        @background_flush.exit
+      end
+      if @events.length == 0
+        return
+      end
+      flush_events = @events.map { |e| e.serialize }
+      @events = []
+
+      @network.post_logs(flush_events)
+    end
   end
 end

data/lib/statsig_user.rb

@@ -7,6 +7,7 @@ class StatsigUser
   attr_accessor :locale
   attr_accessor :app_version
   attr_accessor :statsig_environment
+  attr_accessor :custom_ids
   attr_accessor :private_attributes
 
   def custom
@@ -28,9 +29,11 @@ class StatsigUser
       @country = user_hash['country']
       @locale = user_hash['locale']
       @app_version = user_hash['appVersion'] || user_hash['app_version']
-      @custom = user_hash['custom']
+      @custom = user_hash['custom'] if user_hash['custom'].is_a? Hash
       @statsig_environment = user_hash['statsigEnvironment']
-      @private_attributes = user_hash['privateAttributes']
+      @private_attributes = user_hash['privateAttributes'] if user_hash['privateAttributes'].is_a? Hash
+      custom_ids = user_hash['customIDs'] || user_hash['custom_ids']
+      @custom_ids = custom_ids if custom_ids.is_a? Hash
     end
   end
 
@@ -46,6 +49,7 @@ class StatsigUser
       'custom' => @custom,
       'statsigEnvironment' => @statsig_environment,
       'privateAttributes' => @private_attributes,
+      'customIDs' => @custom_ids,
     }
     if for_logging
       hash.delete('privateAttributes')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 1.7.0.beta.1
+  version: 1.8.1.beta.1
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-12 00:00:00.000000000 Z
+date: 2022-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler