statsig 1.10.0 → 1.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd12cded3010fd966063f91670f1a8f0531196afb96d81f4470311a8d978606d
-  data.tar.gz: f5e3f6715c245263cc1702172da20ad164d20e76dc69a285bcfafe72f7e809ef
+  metadata.gz: 31a3f19ad19ba6b7ce4ebd18e2632ee04a85d3a2176b2c914e75fcd8f326f578
+  data.tar.gz: b3d6905b985889b60a0e713231d7bb5576cb9638972d331243bf93c881557130
 SHA512:
-  metadata.gz: 1dde66bd943e314af8359a243eab9251c2b6bff7a11cb7d988f9ce02d5608b740f0aeb82030e751b553fe355b2a65a41ecc6ac7a23f84dc64c382926a73c72da
-  data.tar.gz: b3d22016c1753ba81daab0039b67a51109fcd240d38514458701c73fb1af0c2cd6a7ac219cd9ef5a34ff2bbac760fe595d17cc4410297799fecfff8a0211bb4f
+  metadata.gz: 4a15075766b794eeefdc187cd225edac10a35810a8066ffab521db2228466a5687007a58077a9c788b668b5ed25cddc0c125f5f74fbf4bdea0488318159e9c00
+  data.tar.gz: 74e4ded54a6dc0198ca99cca62d12517109957316a45b562c26df5eca6f154db9a2f1cb59f4a1c6575035a6863f5a7055ee7d4d7e38c6f8eeaa7930eb487cebd

data/lib/client_initialize_helpers.rb

@@ -0,0 +1,132 @@
+# typed: true
+$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,4 @@
-
+# typed: true
 module Statsig
   class ConfigResult
     attr_accessor :name
@@ -9,16 +9,29 @@ 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 = [],
+      config_delegate = '',
+      explicit_parameters = [],
+      is_experiment_group: false,
+      evaluation_details: nil)
       @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 : []
+      @undelegated_sec_exps = @secondary_exposures
       @config_delegate = config_delegate
       @explicit_parameters = explicit_parameters
+      @is_experiment_group = is_experiment_group
+      @evaluation_details = evaluation_details
     end
   end
 end

data/lib/diagnostics.rb

@@ -0,0 +1,44 @@
+# typed: true
+
+require 'sorbet-runtime'
+
+module Statsig
+  class Diagnostics
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :context
+
+    sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
+    attr_reader :markers
+
+    sig { params(context: String).void }
+
+    def initialize(context)
+      @context = context
+      @markers = []
+    end
+
+    sig { params(key: String, action: String, step: T.any(String, NilClass), value: T.any(String, Integer, T::Boolean, NilClass)).void }
+
+    def mark(key, action, step = nil, value = nil)
+      @markers.push({
+                      key: key,
+                      step: step,
+                      action: action,
+                      value: value,
+                      timestamp: (Time.now.to_f * 1000).to_i
+                    })
+    end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+
+    def serialize
+      {
+        context: @context,
+        markers: @markers
+      }
+    end
+  end
+
+end

data/lib/dynamic_config.rb

@@ -1,16 +1,53 @@
+# typed: false
+
+require 'sorbet-runtime'
+
+##
+# Contains the current experiment/dynamic config values from Statsig
+#
+#  Dynamic Config Documentation: https://docs.statsig.com/dynamic-config
+#
+#  Experiments Documentation: https://docs.statsig.com/experiments-plus
 class DynamicConfig
+  extend T::Sig
+
+  sig { returns(String) }
   attr_accessor :name
+
+  sig { returns(T::Hash[String, T.untyped]) }
   attr_accessor :value
+
+  sig { returns(String) }
   attr_accessor :rule_id
 
+  sig { params(name: String, value: T::Hash[String, T.untyped], rule_id: String).void }
   def initialize(name, value = {}, rule_id = '')
     @name = name
     @value = value
     @rule_id = rule_id
   end
 
+  sig { params(index: String, default_value: T.untyped).returns(T.untyped) }
+  ##
+  # Get the value for the given key (index), falling back to the default_value if it cannot be found.
+  #
+  # @param index The name of parameter being fetched
+  # @param default_value The fallback value if the name cannot be found
   def get(index, default_value)
     return default_value if @value.nil? || !@value.key?(index)
     @value[index]
   end
+
+  sig { params(index: String, default_value: T.untyped).returns(T.untyped) }
+  ##
+  # Get the value for the given key (index), falling back to the default_value if it cannot be found
+  # or is found to have a different type from the default_value.
+  #
+  # @param index The name of parameter being fetched
+  # @param default_value The fallback value if the name cannot be found
+  def get_typed(index, default_value)
+    return default_value if @value.nil? || !@value.key?(index)
+    return default_value if @value[index].class != default_value.class and default_value.class != TrueClass and default_value.class != FalseClass
+    @value[index]
+  end
 end

data/lib/error_boundary.rb

@@ -0,0 +1,57 @@
+require "statsig_errors"
+
+$endpoint = 'https://statsigapi.net/v1/sdk_exception'
+
+module Statsig
+  class ErrorBoundary
+    def initialize(sdk_key)
+      @sdk_key = sdk_key
+      @seen = Set.new
+    end
+
+    def capture(task, recover = -> {})
+      begin
+        return task.call
+      rescue StandardError => e
+        if e.is_a?(Statsig::UninitializedError) or e.is_a?(Statsig::ValueError)
+          raise e
+        end
+        puts "[Statsig]: An unexpected exception occurred."
+        log_exception(e)
+        return recover.call
+      end
+    end
+
+    private
+
+    def log_exception(exception)
+      begin
+        name = exception.class.name
+        if @seen.include?(name)
+          return
+        end
+
+        @seen << name
+        meta = Statsig.get_statsig_metadata
+        http = HTTP.headers(
+          {
+            "STATSIG-API-KEY" => @sdk_key,
+            "STATSIG-SDK-TYPE" => meta['sdkType'],
+            "STATSIG-SDK-VERSION" => meta['sdkVersion'],
+            "Content-Type" => "application/json; charset=UTF-8"
+          }).accept(:json)
+        body = {
+          "exception" => name,
+          "info" => {
+            "trace" => exception.backtrace.to_s,
+            "message" => exception.message
+          }.to_s,
+          "statsigMetadata" => meta
+        }
+        http.post($endpoint, body: JSON.generate(body))
+      rescue
+        return
+      end
+    end
+  end
+end

data/lib/evaluation_details.rb

@@ -0,0 +1,42 @@
+# typed: true
+module Statsig
+
+  module EvaluationReason
+    NETWORK = "Network"
+    LOCAL_OVERRIDE = "LocalOverride"
+    UNRECOGNIZED = "Unrecognized"
+    UNINITIALIZED = "Uninitialized"
+    BOOTSTRAP = "Bootstrap"
+    DATA_ADAPTER = "DataAdapter"
+  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/evaluation_helpers.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'time'
 
 module EvaluationHelpers

data/lib/evaluator.rb

@@ -1,10 +1,13 @@
+# typed: false
 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 +15,126 @@ $type_dynamic_config = 'dynamic_config'
 
 module Statsig
   class Evaluator
-    def initialize(network, options, error_callback)
-      @spec_store = Statsig::SpecStore.new(network, error_callback, options.rulesets_sync_interval, options.idlists_sync_interval)
+    attr_accessor :spec_store
+
+    def initialize(network, options, error_callback, init_diagnostics = nil)
+      @spec_store = Statsig::SpecStore.new(network, options, error_callback, init_diagnostics)
       @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)
+
+      evaluated_keys = {}
+      if user.user_id.nil? == false
+        evaluated_keys['userID'] = user.user_id
+      end
+
+      if user.custom_ids.nil? == false
+        evaluated_keys['customIDs'] = user.custom_ids
+      end
+
+      {
+        "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",
+        "evaluated_keys" => evaluated_keys,
+        "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 +158,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 +170,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 +200,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 +267,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']
@@ -266,14 +379,14 @@ module Statsig
       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?
+          return value if key.to_s.downcase.casecmp?(field.downcase) && !value.nil?
         end
       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?
+          return value if key.to_s.downcase.casecmp?(field.downcase) && !value.nil?
         end
       end
 
@@ -285,7 +398,7 @@ module Statsig
       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)
+        return value if key.to_s.downcase == (field)
       end
       nil
     end

data/lib/id_list.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Statsig
   class IDList
     attr_accessor :name

data/lib/interfaces/data_store.rb

@@ -0,0 +1,19 @@
+# typed: true
+module Statsig
+  module Interfaces
+    class IDataStore
+      def init
+      end
+
+      def get(key)
+        nil
+      end
+
+      def set(key, value)
+      end
+
+      def shutdown
+      end
+    end
+  end
+end