statsig 1.11.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8f1e2b0340c9bbeb49888f54d13505bc7b89c8a70d33e5adaed1e4b95568798
-  data.tar.gz: f70a5060da61c965bbe7e93d0ee7a42cbb30fd0504228959aba7d5ca894278a2
+  metadata.gz: 898237740392ece6cde365fd111e6d49daacac47d39317f06435fbfe83df8821
+  data.tar.gz: 6075c3333c37aeb94fc24511cea4bb6f1a7689c23d05100c91f9a9afc8525393
 SHA512:
-  metadata.gz: cadde7dcab3590b3d9a3d44bc3856f847b5cb50e9b8f365c1287ebad6bff59a5f82aeaef74e8ab958fb6e8e489ee811df9998cf86f1c18b588389f6194f2f2c0
-  data.tar.gz: 879e6ee89157ee4e86032d0d28c6588f21236b3503955150f6e702d06feaac503a8572696c82fe40b086a1e6df17900952c7b08e35f46162df8c50938e0f1225
+  metadata.gz: ee1eb3fec70c73522532f44255ef065b2d286382645ad7988cad9d297295548a97f18a50b5f73a046e6987fadbff3184f53a91cbb9f969b805c1cb1681552454
+  data.tar.gz: d3818d3492d50cd9da8cdf2f8067140383c25b1d124d205a47303023fb64a10e1f5424fcf08e8b8270c3c7e96a88ee088fa2abc1c8a91918c550dcc280fc7778

data/lib/client_initialize_helpers.rb

@@ -0,0 +1,131 @@
+$empty_eval_result = {
+  :gate_value => false,
+  :json_value => {},
+  :rule_id => "",
+  :is_experiment_group => false,
+  :secondary_exposures => []
+}
+
+module ClientInitializeHelpers
+  class ResponseFormatter
+    def initialize(evaluator, user)
+      @evaluator = evaluator
+      @user = user
+      @specs = evaluator.spec_store.get_raw_specs
+    end
+
+    def get_responses(key)
+      @specs[key]
+        .map { |name, spec| to_response(name, spec) }
+        .delete_if { |v| v.nil? }.to_h
+    end
+
+    private
+
+    def to_response(config_name, config_spec)
+      eval_result = @evaluator.eval_spec(@user, config_spec)
+      if eval_result.nil?
+        return nil
+      end
+
+      safe_eval_result = eval_result == $fetch_from_server ? $empty_eval_result : {
+        :gate_value => eval_result.gate_value,
+        :json_value => eval_result.json_value,
+        :rule_id => eval_result.rule_id,
+        :config_delegate => eval_result.config_delegate,
+        :is_experiment_group => eval_result.is_experiment_group,
+        :secondary_exposures => eval_result.secondary_exposures,
+        :undelegated_sec_exps => eval_result.undelegated_sec_exps
+      }
+
+      category = config_spec['type']
+      entity_type = config_spec['entity']
+
+      result = {}
+
+      case category
+
+      when 'feature_gate'
+        if entity_type == 'segment' || entity_type == 'holdout'
+          return nil
+        end
+
+        result['value'] = safe_eval_result[:gate_value]
+      when 'dynamic_config'
+        id_type = config_spec['idType']
+        result['value'] = safe_eval_result[:json_value]
+        result["group"] = safe_eval_result[:rule_id]
+        result["is_device_based"] = id_type.is_a?(String) && id_type.downcase == 'stableid'
+      else
+        return nil
+      end
+
+      if entity_type == 'experiment'
+        populate_experiment_fields(config_name, config_spec, safe_eval_result, result)
+      end
+
+      if entity_type == 'layer'
+        populate_layer_fields(config_spec, safe_eval_result, result)
+      end
+
+      hashed_name = hash_name(config_name)
+      [hashed_name, result.merge(
+        {
+          "name" => hashed_name,
+          "rule_id" => safe_eval_result[:rule_id],
+          "secondary_exposures" => clean_exposures(safe_eval_result[:secondary_exposures])
+        })]
+    end
+
+    def clean_exposures(exposures)
+      seen = {}
+      exposures.reject do |exposure|
+        key = "#{exposure["gate"]}|#{exposure["gateValue"]}|#{exposure["ruleID"]}}"
+        should_reject = seen[key]
+        seen[key] = true
+        should_reject == true
+      end
+    end
+
+    def populate_experiment_fields(config_name, config_spec, eval_result, result)
+      result["is_user_in_experiment"] = eval_result[:is_experiment_group]
+      result["is_experiment_active"] = config_spec['isActive'] == true
+
+      if config_spec['hasSharedParams'] != true
+        return
+      end
+
+      result["is_in_layer"] = true
+      result["explicit_parameters"] = config_spec["explicitParameters"] || []
+
+      layer_name = @specs[:experiment_to_layer][config_name]
+      if layer_name.nil? || @specs[:layers][layer_name].nil?
+        return
+      end
+
+      layer = @specs[:layers][layer_name]
+      result["value"] = layer["defaultValue"].merge(result["value"])
+    end
+
+    def populate_layer_fields(config_spec, eval_result, result)
+      delegate = eval_result[:config_delegate]
+      result["explicit_parameters"] = config_spec["explicitParameters"] || []
+
+      if delegate.nil? == false && delegate.empty? == false
+        delegate_spec = @specs[:configs][delegate]
+        delegate_result = @evaluator.eval_spec(@user, delegate_spec)
+
+        result["allocated_experiment_name"] = hash_name(delegate)
+        result["is_user_in_experiment"] = delegate_result.is_experiment_group
+        result["is_experiment_active"] = delegate_spec['isActive'] == true
+        result["explicit_parameters"] = delegate_spec["explicitParameters"] || []
+      end
+
+      result["undelegated_secondary_exposures"] = clean_exposures(eval_result[:undelegated_sec_exps] || [])
+    end
+
+    def hash_name(name)
+      Digest::SHA256.base64digest(name)
+    end
+  end
+end

data/lib/config_result.rb

@@ -1,4 +1,3 @@
-
 module Statsig
   class ConfigResult
     attr_accessor :name
@@ -9,8 +8,20 @@ module Statsig
     attr_accessor :undelegated_sec_exps
     attr_accessor :config_delegate
     attr_accessor :explicit_parameters
+    attr_accessor :is_experiment_group
+    attr_accessor :evaluation_details
 
-    def initialize(name, gate_value = false, json_value = {}, rule_id = '', secondary_exposures = [], undelegated_sec_exps = [], config_delegate = '', explicit_parameters = [])
+    def initialize(
+      name,
+      gate_value = false,
+      json_value = {},
+      rule_id = '',
+      secondary_exposures = [],
+      undelegated_sec_exps = [],
+      config_delegate = '',
+      explicit_parameters = [],
+      is_experiment_group: false,
+      evaluation_details: nil)
       @name = name
       @gate_value = gate_value
       @json_value = json_value
@@ -19,6 +30,8 @@ module Statsig
       @undelegated_sec_exps = undelegated_sec_exps.is_a?(Array) ? undelegated_sec_exps : []
       @config_delegate = config_delegate
       @explicit_parameters = explicit_parameters
+      @is_experiment_group = is_experiment_group
+      @evaluation_details = evaluation_details
     end
   end
 end

data/lib/evaluation_details.rb

@@ -0,0 +1,40 @@
+module Statsig
+
+  module EvaluationReason
+    NETWORK = "Network"
+    LOCAL_OVERRIDE = "LocalOverride"
+    UNRECOGNIZED = "Unrecognized"
+    UNINITIALIZED = "Uninitialized"
+    BOOTSTRAP = "Bootstrap"
+  end
+
+  class EvaluationDetails
+    attr_accessor :config_sync_time
+    attr_accessor :init_time
+    attr_accessor :reason
+    attr_accessor :server_time
+
+    def initialize(config_sync_time, init_time, reason)
+      @config_sync_time = config_sync_time
+      @init_time = init_time
+      @reason = reason
+      @server_time = (Time.now.to_i * 1000).to_s
+    end
+
+    def self.unrecognized(config_sync_time, init_time)
+      EvaluationDetails.new(config_sync_time, init_time, EvaluationReason::UNRECOGNIZED)
+    end
+
+    def self.uninitialized
+      EvaluationDetails.new(0, 0, EvaluationReason::UNINITIALIZED)
+    end
+
+    def self.network(config_sync_time, init_time)
+      EvaluationDetails.new(config_sync_time, init_time, EvaluationReason::NETWORK)
+    end
+
+    def self.local_override(config_sync_time, init_time)
+      EvaluationDetails.new(config_sync_time, init_time, EvaluationReason::LOCAL_OVERRIDE)
+    end
+  end
+end

data/lib/evaluator.rb

@@ -2,9 +2,11 @@ require 'config_result'
 require 'country_lookup'
 require 'digest'
 require 'evaluation_helpers'
+require 'client_initialize_helpers'
 require 'spec_store'
 require 'time'
 require 'user_agent_parser'
+require 'evaluation_details'
 require 'user_agent_parser/operating_system'
 
 $fetch_from_server = 'fetch_from_server'
@@ -12,33 +14,116 @@ $type_dynamic_config = 'dynamic_config'
 
 module Statsig
   class Evaluator
+    attr_accessor :spec_store
+
     def initialize(network, options, error_callback)
-      @spec_store = Statsig::SpecStore.new(network, error_callback, options.rulesets_sync_interval, options.idlists_sync_interval)
+      @spec_store = Statsig::SpecStore.new(network, error_callback, options.rulesets_sync_interval, options.idlists_sync_interval, options.bootstrap_values, options.rules_updated_callback)
       @ua_parser = UserAgentParser::Parser.new
       CountryLookup.initialize
-      @initialized = true
+
+      @gate_overrides = {}
+      @config_overrides = {}
+    end
+
+    def maybe_restart_background_threads
+      @spec_store.maybe_restart_background_threads
     end
 
     def check_gate(user, gate_name)
-      return nil unless @initialized && @spec_store.has_gate?(gate_name)
+      if @gate_overrides.has_key?(gate_name)
+        return Statsig::ConfigResult.new(
+          gate_name,
+          @gate_overrides[gate_name],
+          @gate_overrides[gate_name],
+          'override',
+          [],
+          evaluation_details: EvaluationDetails.local_override(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time))
+      end
+
+      if @spec_store.init_reason == EvaluationReason::UNINITIALIZED
+        return Statsig::ConfigResult.new(gate_name, evaluation_details: EvaluationDetails.uninitialized)
+      end
+
+      unless @spec_store.has_gate?(gate_name)
+        return Statsig::ConfigResult.new(gate_name, evaluation_details: EvaluationDetails.unrecognized(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time))
+      end
+
       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)
+      if @config_overrides.has_key?(config_name)
+        return Statsig::ConfigResult.new(
+          config_name,
+          false,
+          @config_overrides[config_name],
+          'override',
+          [],
+          evaluation_details: EvaluationDetails.local_override(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time))
+      end
+
+      if @spec_store.init_reason == EvaluationReason::UNINITIALIZED
+        return Statsig::ConfigResult.new(config_name, evaluation_details: EvaluationDetails.uninitialized)
+      end
+
+      unless @spec_store.has_config?(config_name)
+        return Statsig::ConfigResult.new(config_name, evaluation_details: EvaluationDetails.unrecognized(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time))
+      end
+
       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)
+      if @spec_store.init_reason == EvaluationReason::UNINITIALIZED
+        return Statsig::ConfigResult.new(layer_name, evaluation_details: EvaluationDetails.uninitialized)
+      end
+
+      unless @spec_store.has_layer?(layer_name)
+        return Statsig::ConfigResult.new(layer_name, evaluation_details: EvaluationDetails.unrecognized(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time))
+      end
+
       eval_spec(user, @spec_store.get_layer(layer_name))
     end
 
+    def get_client_initialize_response(user)
+      if @spec_store.is_ready_for_checks == false
+        return nil
+      end
+
+      formatter = ClientInitializeHelpers::ResponseFormatter.new(self, user)
+
+      {
+        "feature_gates" => formatter.get_responses(:gates),
+        "dynamic_configs" => formatter.get_responses(:configs),
+        "layer_configs" => formatter.get_responses(:layers),
+        "sdkParams" => {},
+        "has_updates" => true,
+        "generator" => "statsig-ruby-sdk",
+        "time" => 0,
+      }
+    end
+
+    def clean_exposures(exposures)
+      seen = {}
+      exposures.reject do |exposure|
+        key = "#{exposure["gate"]}|#{exposure["gateValue"]}|#{exposure["ruleID"]}}"
+        should_reject = seen[key]
+        seen[key] = true
+        should_reject == true
+      end
+    end
+
     def shutdown
       @spec_store.shutdown
     end
 
-    private
+    def override_gate(gate, value)
+      @gate_overrides[gate] = value
+    end
+
+    def override_config(config, value)
+      @config_overrides[config] = value
+    end
 
     def eval_spec(user, config)
       default_rule_id = 'default'
@@ -62,7 +147,9 @@ module Statsig
               pass,
               pass ? result.json_value : config['defaultValue'],
               result.rule_id,
-              exposures
+              exposures,
+              evaluation_details: EvaluationDetails.new(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time, @spec_store.init_reason),
+              is_experiment_group: result.is_experiment_group,
             )
           end
 
@@ -72,9 +159,17 @@ module Statsig
         default_rule_id = 'disabled'
       end
 
-      Statsig::ConfigResult.new(config['name'], false, config['defaultValue'], default_rule_id, exposures)
+      Statsig::ConfigResult.new(
+        config['name'],
+        false,
+        config['defaultValue'],
+        default_rule_id,
+        exposures,
+        evaluation_details: EvaluationDetails.new(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time, @spec_store.init_reason))
     end
 
+    private
+
     def eval_rule(user, rule)
       exposures = []
       pass = true
@@ -94,7 +189,14 @@ module Statsig
         i += 1
       end
 
-      Statsig::ConfigResult.new('', pass, rule['returnValue'], rule['id'], exposures)
+      Statsig::ConfigResult.new(
+        '',
+        pass,
+        rule['returnValue'],
+        rule['id'],
+        exposures,
+        evaluation_details: EvaluationDetails.new(@spec_store.last_config_sync_time, @spec_store.initial_config_sync_time, @spec_store.init_reason),
+        is_experiment_group: rule["isExperimentGroup"] == true)
     end
 
     def eval_delegate(name, user, rule, exposures)
@@ -154,7 +256,7 @@ module Statsig
       when 'environment_field'
         value = get_value_from_environment(user, field)
       when 'current_time'
-        value = Time.now.to_f # epoch time in seconds
+        value = Time.now.to_i # epoch time in seconds
       when 'user_bucket'
         begin
           salt = additional_values['salt']

data/lib/network.rb

@@ -6,21 +6,23 @@ $retry_codes = [408, 500, 502, 503, 504, 522, 524, 599]
 
 module Statsig
   class Network
-    def initialize(server_secret, api, backoff_mult = 10)
+    def initialize(server_secret, api, local_mode, backoff_mult = 10)
       super()
       unless api.end_with?('/')
         api += '/'
       end
       @server_secret = server_secret
       @api = api
+      @local_mode = local_mode
       @backoff_multiplier = backoff_mult
       @session_id = SecureRandom.uuid
     end
 
     def post_helper(endpoint, body, retries = 0, backoff = 1)
+      return nil unless !@local_mode
       http = HTTP.headers(
         {"STATSIG-API-KEY" => @server_secret,
-        "STATSIG-CLIENT-TIME" => (Time.now.to_f * 1000).to_s,
+        "STATSIG-CLIENT-TIME" => (Time.now.to_f * 1000).to_i.to_s,
          "STATSIG-SERVER-SESSION-ID" => @session_id,
         "Content-Type" => "application/json; charset=UTF-8"
         }).accept(:json)

data/lib/spec_store.rb

@@ -1,63 +1,101 @@
 require 'net/http'
 require 'uri'
 
+require 'evaluation_details'
 require 'id_list'
 
 module Statsig
   class SpecStore
-    def initialize(network, error_callback = nil, rulesets_sync_interval = 10, id_lists_sync_interval = 60)
+    attr_accessor :last_config_sync_time
+    attr_accessor :initial_config_sync_time
+    attr_accessor :init_reason
+
+    def initialize(network, error_callback = nil, rulesets_sync_interval = 10, id_lists_sync_interval = 60, bootstrap_values = nil, rules_updated_callback = nil)
+      @init_reason = EvaluationReason::UNINITIALIZED
       @network = network
-      @last_sync_time = 0
+      @last_config_sync_time = 0
+      @initial_config_sync_time = 0
       @rulesets_sync_interval = rulesets_sync_interval
       @id_lists_sync_interval = id_lists_sync_interval
-      @store = {
+      @rules_updated_callback = rules_updated_callback
+      @specs = {
         :gates => {},
         :configs => {},
         :layers => {},
         :id_lists => {},
+        :experiment_to_layer => {}
       }
-      e = download_config_specs
-      error_callback.call(e) unless error_callback.nil?
+
+      unless bootstrap_values.nil?
+        begin
+          if process(JSON.parse(bootstrap_values))
+            @init_reason = EvaluationReason::BOOTSTRAP
+          end
+        rescue
+          puts 'the provided bootstrapValues is not a valid JSON string'
+        end
+      end
+
+      @error_callback = error_callback
+      download_config_specs
+      @initial_config_sync_time = @last_config_sync_time == 0 ? -1 : @last_config_sync_time
       get_id_lists
 
       @config_sync_thread = sync_config_specs
       @id_lists_sync_thread = sync_id_lists
     end
 
+    def is_ready_for_checks
+      @last_config_sync_time != 0
+    end
+
     def shutdown
       @config_sync_thread&.exit
       @id_lists_sync_thread&.exit
     end
 
     def has_gate?(gate_name)
-      @store[:gates].key?(gate_name)
+      @specs[:gates].key?(gate_name)
     end
 
     def has_config?(config_name)
-      @store[:configs].key?(config_name)
+      @specs[:configs].key?(config_name)
     end
 
     def has_layer?(layer_name)
-      @store[:layers].key?(layer_name)
+      @specs[:layers].key?(layer_name)
     end
 
     def get_gate(gate_name)
       return nil unless has_gate?(gate_name)
-      @store[:gates][gate_name]
+      @specs[:gates][gate_name]
     end
 
     def get_config(config_name)
       return nil unless has_config?(config_name)
-      @store[:configs][config_name]
+      @specs[:configs][config_name]
     end
 
     def get_layer(layer_name)
       return nil unless has_layer?(layer_name)
-      @store[:layers][layer_name]
+      @specs[:layers][layer_name]
     end
 
     def get_id_list(list_name)
-      @store[:id_lists][list_name]
+      @specs[:id_lists][list_name]
+    end
+
+    def get_raw_specs
+      @specs
+    end
+
+    def maybe_restart_background_threads
+      if @config_sync_thread.nil? or !@config_sync_thread.alive?
+        @config_sync_thread = sync_config_specs
+      end
+      if @id_lists_sync_thread.nil? or !@id_lists_sync_thread.alive?
+        @id_lists_sync_thread = sync_id_lists
+      end
     end
 
     private
@@ -81,10 +119,19 @@ module Statsig
     end
 
     def download_config_specs
+      e = get_config_specs_from_network
+      @error_callback.call(e) unless e.nil? or @error_callback.nil?
+    end
+
+    def get_config_specs_from_network
       begin
-        response, e = @network.post_helper('download_config_specs', JSON.generate({'sinceTime' => @last_sync_time}))
+        response, e = @network.post_helper('download_config_specs', JSON.generate({ 'sinceTime' => @last_config_sync_time }))
         if e.nil?
-          process(JSON.parse(response.body))
+          if process(JSON.parse(response.body))
+            @init_reason = EvaluationReason::NETWORK
+            @rules_updated_callback.call(response.body.to_s, @last_config_sync_time) unless response.body.nil? or @rules_updated_callback.nil?
+          end
+          nil
         else
           e
         end
@@ -95,36 +142,47 @@ module Statsig
 
     def process(specs_json)
       if specs_json.nil?
-        return
+        return false
       end
 
-      @last_sync_time = specs_json['time'] || @last_sync_time
-      return unless specs_json['has_updates'] == true &&
+      @last_config_sync_time = specs_json['time'] || @last_config_sync_time
+
+      return false unless specs_json['has_updates'] == true &&
         !specs_json['feature_gates'].nil? &&
         !specs_json['dynamic_configs'].nil? &&
-        !specs_json['layer_configs'].nil? 
+        !specs_json['layer_configs'].nil?
 
       new_gates = {}
       new_configs = {}
       new_layers = {}
+      new_exp_to_layer = {}
+
+      specs_json['feature_gates'].each { |gate| new_gates[gate['name']] = gate }
+      specs_json['dynamic_configs'].each { |config| new_configs[config['name']] = config }
+      specs_json['layer_configs'].each { |layer| new_layers[layer['name']] = layer }
+
+      if specs_json['layers'].is_a?(Hash)
+        specs_json['layers'].each { |layer_name, experiments|
+          experiments.each { |experiment_name| new_exp_to_layer[experiment_name] = layer_name }
+        }
+      end
 
-      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
+      @specs[:gates] = new_gates
+      @specs[:configs] = new_configs
+      @specs[:layers] = new_layers
+      @specs[:experiment_to_layer] = new_exp_to_layer
+      true
     end
 
     def get_id_lists
-      response, e = @network.post_helper('get_id_lists', JSON.generate({'statsigMetadata' => Statsig.get_statsig_metadata}))
+      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]
+        local_id_lists = @specs[:id_lists]
         if !server_id_lists.is_a?(Hash) || !local_id_lists.is_a?(Hash)
           return
         end
@@ -178,7 +236,7 @@ module Statsig
 
     def download_single_id_list(list)
       nil unless list.is_a? IDList
-      http = HTTP.headers({'Range' => "bytes=#{list&.size || 0}-"}).accept(:json)
+      http = HTTP.headers({ 'Range' => "bytes=#{list&.size || 0}-" }).accept(:json)
       begin
         res = http.get(list.url)
         nil unless res.status.success?
@@ -186,7 +244,7 @@ module Statsig
         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)
+          @specs[: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

data/lib/statsig.rb

@@ -4,6 +4,7 @@ module Statsig
   def self.initialize(secret_key, options = nil, error_callback = nil)
     unless @shared_instance.nil?
       puts 'Statsig already initialized.'
+      @shared_instance.maybe_restart_background_threads
       return @shared_instance
     end
 
@@ -42,10 +43,25 @@ module Statsig
     @shared_instance = nil
   end
 
+  def self.override_gate(gate_name, gate_value)
+    ensure_initialized
+    @shared_instance&.override_gate(gate_name, gate_value)
+  end
+
+  def self.override_config(config_name, config_value)
+    ensure_initialized
+    @shared_instance&.override_config(config_name, config_value)
+  end
+
+  def self.get_client_initialize_response(user)
+    ensure_initialized
+    @shared_instance&.get_client_initialize_response(user)
+  end
+
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '1.11.0',
+      'sdkVersion' => '1.13.0',
     }
   end
 

data/lib/statsig_driver.rb

@@ -22,7 +22,7 @@ class StatsigDriver
     @options = options || StatsigOptions.new
     @shutdown = false
     @secret_key = secret_key
-    @net = Statsig::Network.new(secret_key, @options.api_url_base)
+    @net = Statsig::Network.new(secret_key, @options.api_url_base, @options.local_mode)
     @logger = Statsig::StatsigLogger.new(@net, @options)
     @evaluator = Statsig::Evaluator.new(@net, @options, error_callback)
   end
@@ -39,7 +39,7 @@ class StatsigDriver
       res = check_gate_fallback(user, gate_name)
       # exposure logged by the server
     else
-      @logger.log_gate_exposure(user, res.name, res.gate_value, res.rule_id, res.secondary_exposures)
+      @logger.log_gate_exposure(user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details)
     end
 
     res.gate_value
@@ -98,6 +98,26 @@ class StatsigDriver
     @evaluator.shutdown
   end
 
+  def override_gate(gate_name, gate_value)
+    @evaluator.override_gate(gate_name, gate_value)
+  end
+
+  def override_config(config_name, config_value)
+    @evaluator.override_config(config_name, config_value)
+  end
+
+  # @param [StatsigUser] user
+  # @return [Hash]
+  def get_client_initialize_response(user)
+    normalize_user(user)
+    @evaluator.get_client_initialize_response(user)
+  end
+
+  def maybe_restart_background_threads
+    @evaluator.maybe_restart_background_threads
+    @logger.maybe_restart_background_threads
+  end
+
   private
 
   def verify_inputs(user, config_name, variable_name)
@@ -120,7 +140,7 @@ class StatsigDriver
       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)
+      @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details)
     end
 
     DynamicConfig.new(res.name, res.json_value, res.rule_id)
@@ -132,7 +152,7 @@ class StatsigDriver
       (
         # user_id is nil and custom_ids is not a hash with entries
         !user.user_id.is_a?(String) &&
-        (!user.custom_ids.is_a?(Hash) || user.custom_ids.size == 0)
+          (!user.custom_ids.is_a?(Hash) || user.custom_ids.size == 0)
       )
       raise 'Must provide a valid StatsigUser with a user_id or at least a custom ID. See https://docs.statsig.com/messages/serverRequiredUserID/ for more details.'
     end

data/lib/statsig_event.rb

@@ -7,7 +7,7 @@ class StatsigEvent
 
   def initialize(event_name)
     @event_name = event_name
-    @time = Time.now.to_f * 1000
+    @time = (Time.now.to_f * 1000).to_i
   end
 
   def user=(value)

data/lib/statsig_logger.rb

@@ -20,28 +20,32 @@ module Statsig
       end
     end
 
-    def log_gate_exposure(user, gate_name, value, rule_id, secondary_exposures)
+    def log_gate_exposure(user, gate_name, value, rule_id, secondary_exposures, eval_details)
       event = StatsigEvent.new($gate_exposure_event)
       event.user = user
       event.metadata = {
         'gate' => gate_name,
         'gateValue' => value.to_s,
-        'ruleID' => rule_id
+        'ruleID' => rule_id,
       }
       event.statsig_metadata = Statsig.get_statsig_metadata
       event.secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
+
+      safe_add_eval_details(eval_details, event)
       log_event(event)
     end
 
-    def log_config_exposure(user, config_name, rule_id, secondary_exposures)
+    def log_config_exposure(user, config_name, rule_id, secondary_exposures, eval_details)
       event = StatsigEvent.new($config_exposure_event)
       event.user = user
       event.metadata = {
         'config' => config_name,
-        'ruleID' => rule_id
+        'ruleID' => rule_id,
       }
       event.statsig_metadata = Statsig.get_statsig_metadata
       event.secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
+
+      safe_add_eval_details(eval_details, event)
       log_event(event)
     end
 
@@ -61,10 +65,12 @@ module Statsig
         'ruleID' => layer.rule_id,
         'allocatedExperiment' => allocated_experiment,
         'parameterName' => parameter_name,
-        'isExplicitParameter' => String(is_explicit)
+        'isExplicitParameter' => String(is_explicit),
       }
       event.statsig_metadata = Statsig.get_statsig_metadata
       event.secondary_exposures = exposures.is_a?(Array) ? exposures : []
+
+      safe_add_eval_details(config_evaluation.evaluation_details, event)
       log_event(event)
     end
 
@@ -90,5 +96,24 @@ module Statsig
 
       @network.post_logs(flush_events)
     end
+
+    def maybe_restart_background_threads
+      if @background_flush.nil? or !@background_flush.alive?
+        @background_flush = periodic_flush
+      end
+    end
+
+    private
+
+    def safe_add_eval_details(eval_details, event)
+      if eval_details.nil?
+        return
+      end
+
+      event.metadata['reason'] = eval_details.reason
+      event.metadata['configSyncTime'] = eval_details.config_sync_time
+      event.metadata['initTime'] = eval_details.init_time
+      event.metadata['serverTime'] = eval_details.server_time
+    end
   end
 end

data/lib/statsig_options.rb

@@ -1,10 +1,13 @@
 class StatsigOptions
-  attr_reader :environment
-  attr_reader :api_url_base
-  attr_reader :rulesets_sync_interval
-  attr_reader :idlists_sync_interval
-  attr_reader :logging_interval_seconds
-  attr_reader :logging_max_buffer_size
+  attr_accessor :environment
+  attr_accessor :api_url_base
+  attr_accessor :rulesets_sync_interval
+  attr_accessor :idlists_sync_interval
+  attr_accessor :logging_interval_seconds
+  attr_accessor :logging_max_buffer_size
+  attr_accessor :local_mode
+  attr_accessor :bootstrap_values
+  attr_accessor :rules_updated_callback
 
   def initialize(
     environment=nil,
@@ -12,12 +15,18 @@ class StatsigOptions
     rulesets_sync_interval: 10,
     idlists_sync_interval: 60,
     logging_interval_seconds: 60,
-    logging_max_buffer_size: 1000)
+    logging_max_buffer_size: 1000,
+    local_mode: false,
+    bootstrap_values: nil,
+    rules_updated_callback: nil)
     @environment = environment.is_a?(Hash) ? environment : nil
     @api_url_base = api_url_base
     @rulesets_sync_interval = rulesets_sync_interval
     @idlists_sync_interval = idlists_sync_interval
     @logging_interval_seconds = logging_interval_seconds
     @logging_max_buffer_size = [logging_max_buffer_size, 1000].min
+    @local_mode = local_mode
+    @bootstrap_values = bootstrap_values
+    @rules_updated_callback = rules_updated_callback
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 1.11.0
+  version: 1.13.0
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-23 00:00:00.000000000 Z
+date: 2022-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -120,8 +120,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/client_initialize_helpers.rb
 - lib/config_result.rb
 - lib/dynamic_config.rb
+- lib/evaluation_details.rb
 - lib/evaluation_helpers.rb
 - lib/evaluator.rb
 - lib/id_list.rb
@@ -153,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.11
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Statsig server SDK for Ruby