statsig 1.8.4.beta.pre.2 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bea35d8e01c06aa973c41af533542e10256eb12ff1b8c790affe92d28e6f762
-  data.tar.gz: 183446325403fc29ffafd0ea498557ae56c59d6959a59d5e96a1c88806b57147
+  metadata.gz: 72321b660214bc1a0c54ffd5718115ef713be11fd0f37fe9e18429539edad855
+  data.tar.gz: 3583760dd5c9ae9aab5005bc07e7673088de8af39b7cbecec032b332249b1c6a
 SHA512:
-  metadata.gz: 116a1a145265084de0877fda45b017f36eda5eed8a19c093e25588e1f4720ac10ef903dfdc9c6f13ae4989565a8b01e4e20ac2aa3efd661a34e1c16bb91d680b
-  data.tar.gz: aa0d99ff3b38ae0e73f037bf31efc4a364fe0e6831efa6347329f525e38c2148837c19e21768fece6b921fbbe6404664e30d9549aa9d4ace4544519c5830dd8b
+  metadata.gz: bf06b989ebade0705ef7ee377455b87c6b408ce38aabfae9ccc6c4f95f6b7bc0a4e3fb9393d5473b0e32f2e04f901df730666f00a27b2f0d2a709338b31ca2bc
+  data.tar.gz: 68e77d69004f9d96d82e011ad67822732c9889871eb0e39990b88c9f109b4f84d991c55a680cd5434381c285e35e725d08e7438ee5fe1bc32809f0dd9eb78141

data/lib/config_result.rb

@@ -6,13 +6,19 @@ module Statsig
     attr_accessor :json_value
     attr_accessor :rule_id
     attr_accessor :secondary_exposures
+    attr_accessor :undelegated_sec_exps
+    attr_accessor :config_delegate
+    attr_accessor :explicit_parameters
 
-    def initialize(name, gate_value = false, json_value = {}, rule_id = '', secondary_exposures = [])
+    def initialize(name, gate_value = false, json_value = {}, rule_id = '', secondary_exposures = [], undelegated_sec_exps = [], config_delegate = '', explicit_parameters = [])
       @name = name
       @gate_value = gate_value
       @json_value = json_value
       @rule_id = rule_id
       @secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
+      @undelegated_sec_exps = undelegated_sec_exps.is_a?(Array) ? undelegated_sec_exps : []
+      @config_delegate = config_delegate
+      @explicit_parameters = explicit_parameters
     end
   end
 end

data/lib/evaluator.rb

@@ -7,7 +7,7 @@ require 'time'
 require 'user_agent_parser'
 require 'user_agent_parser/operating_system'
 
-$fetch_from_server = :fetch_from_server
+$fetch_from_server = 'fetch_from_server'
 $type_dynamic_config = 'dynamic_config'
 
 module Statsig
@@ -29,6 +29,11 @@ module Statsig
       eval_spec(user, @spec_store.get_config(config_name))
     end
 
+    def get_layer(user, layer_name)
+      return nil unless @initialized && @spec_store.has_layer?(layer_name)
+      eval_spec(user, @spec_store.get_layer(layer_name))
+    end
+
     def shutdown
       @spec_store.shutdown
     end
@@ -43,15 +48,20 @@ module Statsig
         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']
+          return $fetch_from_server if result.to_s == $fetch_from_server
+          exposures = exposures + result.secondary_exposures
+          if result.gate_value
+
+            if (delegated_result = eval_delegate(config['name'], user, rule, exposures))
+              return delegated_result
+            end
+
             pass = eval_pass_percent(user, rule, config['salt'])
             return Statsig::ConfigResult.new(
               config['name'],
               pass,
-              pass ? rule['returnValue'] : config['defaultValue'],
-              rule['id'],
+              pass ? result.json_value : config['defaultValue'],
+              result.rule_id,
               exposures
             )
           end
@@ -71,7 +81,7 @@ module Statsig
       i = 0
       until i >= rule['conditions'].length do
         result = eval_condition(user, rule['conditions'][i])
-        if result == $fetch_from_server
+        if result.to_s == $fetch_from_server
           return $fetch_from_server
         end
 
@@ -83,7 +93,23 @@ module Statsig
         end
         i += 1
       end
-      { 'value' => pass, 'exposures' => exposures }
+
+      Statsig::ConfigResult.new('', pass, rule['returnValue'], rule['id'], exposures)
+    end
+
+    def eval_delegate(name, user, rule, exposures)
+      return nil unless (delegate = rule['configDelegate'])
+      return nil unless (config = @spec_store.get_config(delegate))
+
+      delegated_result = self.eval_spec(user, config)
+      return $fetch_from_server if delegated_result.to_s == $fetch_from_server
+
+      delegated_result.name = name
+      delegated_result.config_delegate = delegate
+      delegated_result.secondary_exposures = exposures + delegated_result.secondary_exposures
+      delegated_result.undelegated_sec_exps = exposures
+      delegated_result.explicit_parameters = config['explicitParameters']
+      delegated_result
     end
 
     def eval_condition(user, condition)
@@ -104,7 +130,7 @@ module Statsig
         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
+        return $fetch_from_server if other_gate_result.to_s == $fetch_from_server
 
         gate_value = other_gate_result&.gate_value == true
         new_exposure = {
@@ -119,10 +145,10 @@ module Statsig
         }
       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
+        return $fetch_from_server if value.to_s == $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
+        return $fetch_from_server if value.to_s == $fetch_from_server
       when 'user_field'
         value = get_value_from_user(user, field)
       when 'environment_field'
@@ -144,7 +170,7 @@ module Statsig
         return $fetch_from_server
       end
 
-      return $fetch_from_server if value == $fetch_from_server || !operator.is_a?(String)
+      return $fetch_from_server if value.to_s == $fetch_from_server || !operator.is_a?(String)
       operator = operator.downcase
 
       case operator
@@ -159,17 +185,24 @@ module Statsig
         return EvaluationHelpers::compare_numbers(value, target, ->(a, b) { a <= b })
 
         # version comparison
+        # need to check for nil or empty value because Version takes them as valid values
       when 'version_gt'
+        return false if value.to_s.empty?
         return (Gem::Version.new(value) > Gem::Version.new(target) rescue false)
       when 'version_gte'
+        return false if value.to_s.empty?
         return (Gem::Version.new(value) >= Gem::Version.new(target) rescue false)
       when 'version_lt'
+        return false if value.to_s.empty?
         return (Gem::Version.new(value) < Gem::Version.new(target) rescue false)
       when 'version_lte'
+        return false if value.to_s.empty?
         return (Gem::Version.new(value) <= Gem::Version.new(target) rescue false)
       when 'version_eq'
+        return false if value.to_s.empty?
         return (Gem::Version.new(value) == Gem::Version.new(target) rescue false)
       when 'version_neq'
+        return false if value.to_s.empty?
         return (Gem::Version.new(value) != Gem::Version.new(target) rescue false)
 
         # array operations
@@ -207,13 +240,15 @@ module Statsig
         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
+          is_in_list = false
+          id_list = @spec_store.get_id_list(target)
+          if id_list.is_a? IDList
+            hashed_id = Digest::SHA256.base64digest(value.to_s)[0, 8]
+            is_in_list = id_list.ids.include?(hashed_id)
+          end
+          return is_in_list if operator == 'in_segment_list'
+          return !is_in_list
+        rescue
           return false
         end
       else
@@ -287,7 +322,7 @@ module Statsig
     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']) || ''
+        unit_id = get_unit_id(user, rule['idType']) || ''
         rule_salt = rule['salt'] || rule['id'] || ''
         hash = compute_user_hash("#{config_salt}.#{rule_salt}.#{unit_id}")
         return (hash % 10000) < (rule['passPercentage'].to_f * 100)

data/lib/id_list.rb

@@ -0,0 +1,36 @@
+module Statsig
+  class IDList
+    attr_accessor :name
+    attr_accessor :size
+    attr_accessor :creation_time
+    attr_accessor :url
+    attr_accessor :file_id
+    attr_accessor :ids
+
+    def initialize(json, ids = Set.new)
+      @name = json['name'] || ''
+      @size = json['size'] || 0
+      @creation_time = json['creationTime'] || 0
+      @url = json['url']
+      @file_id = json['fileID']
+
+      @ids = ids
+    end
+
+    def self.new_empty(json)
+      self.new(json)
+      @size = 0
+    end
+
+    def ==(other)
+      return false if other.nil?
+
+      self.name == other.name &&
+        self.size == other.size &&
+        self.creation_time == other.creation_time &&
+        self.url == other.url &&
+        self.file_id == other.file_id &&
+        self.ids == other.ids
+    end
+  end
+end

data/lib/layer.rb

@@ -0,0 +1,21 @@
+class Layer
+  attr_accessor :name
+  attr_accessor :rule_id
+
+  def initialize(name, value = {}, rule_id = '', exposure_log_func = nil)
+    @name = name
+    @value = value
+    @rule_id = rule_id
+    @exposure_log_func = exposure_log_func
+  end
+
+  def get(index, default_value)
+    return default_value if @value.nil? || !@value.key?(index)
+
+    if @exposure_log_func.is_a? Proc
+      @exposure_log_func.call(self, index)
+    end
+
+    @value[index]
+  end
+end

data/lib/network.rb

@@ -1,6 +1,6 @@
 require 'http'
 require 'json'
-require 'dynamic_config'
+require 'securerandom'
 
 $retry_codes = [408, 500, 502, 503, 504, 522, 524, 599]
 
@@ -14,12 +14,14 @@ module Statsig
       @server_secret = server_secret
       @api = api
       @backoff_multiplier = backoff_mult
+      @session_id = SecureRandom.uuid
     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,
+         "STATSIG-SERVER-SESSION-ID" => @session_id,
         "Content-Type" => "application/json; charset=UTF-8"
         }).accept(:json)
       begin

data/lib/spec_store.rb

@@ -1,6 +1,8 @@
 require 'net/http'
 require 'uri'
 
+require 'id_list'
+
 module Statsig
   class SpecStore
     def initialize(network, error_callback = nil, config_sync_interval = 10, id_lists_sync_interval = 60)
@@ -11,11 +13,12 @@ module Statsig
       @store = {
         :gates => {},
         :configs => {},
+        :layers => {},
         :id_lists => {},
       }
       e = download_config_specs
       error_callback.call(e) unless error_callback.nil?
-      download_id_lists
+      get_id_lists
 
       @config_sync_thread = sync_config_specs
       @id_lists_sync_thread = sync_id_lists
@@ -34,6 +37,10 @@ module Statsig
       @store[:configs].key?(config_name)
     end
 
+    def has_layer?(layer_name)
+      @store[:layers].key?(layer_name)
+    end
+
     def get_gate(gate_name)
       return nil unless has_gate?(gate_name)
       @store[:gates][gate_name]
@@ -44,6 +51,11 @@ module Statsig
       @store[:configs][config_name]
     end
 
+    def get_layer(layer_name)
+      return nil unless has_layer?(layer_name)
+      @store[:layers][layer_name]
+    end
+
     def get_id_list(list_name)
       @store[:id_lists][list_name]
     end
@@ -63,7 +75,7 @@ module Statsig
       Thread.new do
         loop do
           sleep @id_lists_sync_interval
-          download_id_lists
+          get_id_lists
         end
       end
     end
@@ -89,62 +101,111 @@ module Statsig
       @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?
+        !specs_json['dynamic_configs'].nil? &&
+        !specs_json['layer_configs'].nil? 
 
       new_gates = {}
       new_configs = {}
+      new_layers = {}
 
       specs_json['feature_gates'].map{|gate|  new_gates[gate['name']] = gate }
       specs_json['dynamic_configs'].map{|config|  new_configs[config['name']] = config }
+      specs_json['layer_configs'].map{|layer|  new_layers[layer['name']] = layer }
       @store[:gates] = new_gates
       @store[:configs] = new_configs
+      @store[:layers] = new_layers
+    end
 
-      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
+    def get_id_lists
+      response, e = @network.post_helper('get_id_lists', JSON.generate({'statsigMetadata' => Statsig.get_statsig_metadata}))
+      if !e.nil? || response.nil?
+        return
+      end
+
+      begin
+        server_id_lists = JSON.parse(response)
+        local_id_lists = @store[:id_lists]
+        if !server_id_lists.is_a?(Hash) || !local_id_lists.is_a?(Hash)
+          return
         end
+        threads = []
 
-        @store[:id_lists].each do |list_name, _|
-          unless new_id_lists.key?(list_name)
-            @store[:id_lists].delete(list_name)
+        server_id_lists.each do |list_name, list|
+          server_list = IDList.new(list)
+          local_list = get_id_list(list_name)
+
+          unless local_list.is_a? IDList
+            local_list = IDList.new(list)
+            local_list.size = 0
+            local_id_lists[list_name] = local_list
+          end
+
+          # skip if server list is invalid
+          if server_list.url.nil? || server_list.creation_time < local_list.creation_time || server_list.file_id.nil?
+            next
+          end
+
+          # skip if server list returns a newer file
+          if server_list.file_id != local_list.file_id && server_list.creation_time >= local_list.creation_time
+            local_list = IDList.new(list)
+            local_list.size = 0
+            local_id_lists[list_name] = local_list
+          end
+
+          # skip if server list is no bigger than local list, which means nothing new to read
+          if server_list.size <= local_list.size
+            next
+          end
+
+          threads << Thread.new do
+            download_single_id_list(local_list)
           end
         end
+        threads.each(&:join)
+        delete_lists = []
+        local_id_lists.each do |list_name, list|
+          unless server_id_lists.key? list_name
+            delete_lists.push list_name
+          end
+        end
+        delete_lists.each do |list_name|
+          local_id_lists.delete list_name
+        end
+      rescue
+        # Ignored, will try again
       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
+    def download_single_id_list(list)
+      nil unless list.is_a? IDList
+      http = HTTP.headers({'Range' => "bytes=#{list&.size || 0}-"}).accept(:json)
+      begin
+        res = http.get(list.url)
+        nil unless res.status.success?
+        content_length = Integer(res['content-length'])
+        nil if content_length.nil? || content_length <= 0
+        content = res.body.to_s
+        unless content.is_a?(String) && (content[0] == '-' || content[0] == '+')
+          @store[:id_lists].delete(list.name)
+          return
+        end
+        ids_clone = list.ids # clone the list, operate on the new list, and swap out the old list, so the operation is thread-safe
+        lines = content.split(/\r?\n/)
+        lines.each do |li|
+          line = li.strip
+          next if line.length <= 1
+          op = line[0]
+          id = line[1..]
+          if op == '+'
+            ids_clone.add(id)
+          elsif op == '-'
+            ids_clone.delete(id)
           end
         end
-        threads.each(&:join)
+        list.ids = ids_clone
+        list.size = list.size + content_length
+      rescue
+        nil
       end
     end
   end

data/lib/statsig.rb

@@ -22,7 +22,12 @@ module Statsig
 
   def self.get_experiment(user, experiment_name)
     ensure_initialized
-    @shared_instance&.get_config(user, experiment_name)
+    @shared_instance&.get_experiment(user, experiment_name)
+  end
+
+  def self.get_layer(user, layer_name)
+    ensure_initialized
+    @shared_instance&.get_layer(user, layer_name)
   end
 
   def self.log_event(user, event_name, value, metadata)
@@ -40,7 +45,7 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '1.8.4.beta-2',
+      'sdkVersion' => '1.9.0',
     }
   end
 

data/lib/statsig_driver.rb

@@ -6,6 +6,8 @@ require 'statsig_logger'
 require 'statsig_options'
 require 'statsig_user'
 require 'spec_store'
+require 'dynamic_config'
+require 'layer'
 
 class StatsigDriver
   def initialize(secret_key, options = nil, error_callback = nil)
@@ -26,12 +28,7 @@ class StatsigDriver
   end
 
   def check_gate(user, gate_name)
-    validate_user(user)
-    user = normalize_user(user)
-    if !gate_name.is_a?(String) || gate_name.empty?
-      raise 'Invalid gate_name provided'
-    end
-    check_shutdown
+    user = verify_inputs(user, gate_name, "gate_name")
 
     res = @evaluator.check_gate(user, gate_name)
     if res.nil?
@@ -49,33 +46,34 @@ class StatsigDriver
   end
 
   def get_config(user, dynamic_config_name)
-    validate_user(user)
-    user = normalize_user(user)
-    if !dynamic_config_name.is_a?(String) || dynamic_config_name.empty?
-      raise "Invalid dynamic_config_name provided"
-    end
-    check_shutdown
+    user = verify_inputs(user, dynamic_config_name, "dynamic_config_name")
+    get_config_impl(user, dynamic_config_name)
+  end
 
-    res = @evaluator.get_config(user, dynamic_config_name)
+  def get_experiment(user, experiment_name)
+    user = verify_inputs(user, experiment_name, "experiment_name")
+    get_config_impl(user, experiment_name)
+  end
+
+  def get_layer(user, layer_name)
+    user = verify_inputs(user, layer_name, "layer_name")
+
+    res = @evaluator.get_layer(user, layer_name)
     if res.nil?
-      res = Statsig::ConfigResult.new(dynamic_config_name)
+      res = Statsig::ConfigResult.new(layer_name)
     end
 
     if res == $fetch_from_server
-      res = get_config_fallback(user, dynamic_config_name)
+      if res.config_delegate.empty?
+        return Layer.new(layer_name)
+      end
+      res = get_config_fallback(user, res.config_delegate)
       # exposure logged by the server
-    else
-      @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures)
     end
 
-    DynamicConfig.new(res.name, res.json_value, res.rule_id)
-  end
-
-  def get_experiment(user, experiment_name)
-    if !experiment_name.is_a?(String) || experiment_name.empty?
-      raise "Invalid experiment_name provided"
-    end
-    get_config(user, experiment_name)
+    Layer.new(res.name, res.json_value, res.rule_id, lambda { |layer, parameter_name|
+      @logger.log_layer_exposure(user, layer, parameter_name, res)
+    })
   end
 
   def log_event(user, event_name, value = nil, metadata = nil)
@@ -102,6 +100,32 @@ class StatsigDriver
 
   private
 
+  def verify_inputs(user, config_name, variable_name)
+    validate_user(user)
+    if !config_name.is_a?(String) || config_name.empty?
+      raise "Invalid #{variable_name} provided"
+    end
+
+    check_shutdown
+    normalize_user(user)
+  end
+
+  def get_config_impl(user, config_name)
+    res = @evaluator.get_config(user, config_name)
+    if res.nil?
+      res = Statsig::ConfigResult.new(config_name)
+    end
+
+    if res == $fetch_from_server
+      res = get_config_fallback(user, config_name)
+      # exposure logged by the server
+    else
+      @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures)
+    end
+
+    DynamicConfig.new(res.name, res.json_value, res.rule_id)
+  end
+
   def validate_user(user)
     if user.nil? || !user.instance_of?(StatsigUser) || !user.user_id.is_a?(String)
       raise 'Must provide a valid StatsigUser with a user_id to use the server SDK. See https://docs.statsig.com/messages/serverRequiredUserID/ for more details.'

data/lib/statsig_logger.rb

@@ -2,6 +2,7 @@ require 'statsig_event'
 
 $gate_exposure_event = 'statsig::gate_exposure'
 $config_exposure_event = 'statsig::config_exposure'
+$layer_exposure_event = 'statsig::layer_exposure'
 
 module Statsig
   class StatsigLogger
@@ -13,7 +14,6 @@ module Statsig
 
     def log_event(event)
       @events.push(event)
-      puts "Statsig:: log_event called, new count: #{@events.length.to_s}"
       if @events.length >= 500
         flush
       end
@@ -44,28 +44,45 @@ module Statsig
       log_event(event)
     end
 
+    def log_layer_exposure(user, layer, parameter_name, config_evaluation)
+      exposures = config_evaluation.undelegated_sec_exps
+      allocated_experiment = ''
+      is_explicit = config_evaluation.explicit_parameters.include? parameter_name
+      if is_explicit
+        allocated_experiment = config_evaluation.config_delegate
+        exposures = config_evaluation.secondary_exposures
+      end
+
+      event = StatsigEvent.new($layer_exposure_event)
+      event.user = user
+      event.metadata = {
+        'config' => layer.name,
+        'ruleID' => layer.rule_id,
+        'allocatedExperiment' => allocated_experiment,
+        'parameterName' => parameter_name,
+        'isExplicitParameter' => String(is_explicit)
+      }
+      event.statsig_metadata = Statsig.get_statsig_metadata
+      event.secondary_exposures = exposures.is_a?(Array) ? exposures : []
+      log_event(event)
+    end
+
     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
 
     def flush(closing = false)
-      puts "Statsig:: calling flush function, count: #{@events.length.to_s}"
       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 = []
 

data/lib/statsig_options.rb

@@ -2,7 +2,7 @@ class StatsigOptions
   attr_reader :environment
   attr_reader :api_url_base
 
-  def initialize(environment = nil, api_url_base = 'https://api.statsig.com/v1')
+  def initialize(environment = nil, api_url_base = 'https://statsigapi.net/v1')
     @environment = environment.is_a?(Hash) ? environment : nil
     @api_url_base = api_url_base
   end

data/lib/statsig_user.rb

@@ -54,7 +54,7 @@ class StatsigUser
     if for_logging
       hash.delete('privateAttributes')
     end
-    hash
+    hash.compact
   end
 
   def value_lookup

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 1.8.4.beta.pre.2
+  version: 1.9.1
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-18 00:00:00.000000000 Z
+date: 2022-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -118,6 +118,8 @@ files:
 - lib/dynamic_config.rb
 - lib/evaluation_helpers.rb
 - lib/evaluator.rb
+- lib/id_list.rb
+- lib/layer.rb
 - lib/network.rb
 - lib/spec_store.rb
 - lib/statsig.rb
@@ -141,11 +143,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Statsig server SDK for Ruby