statsig 1.31.1 → 1.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1afc6737d00e614429706bdcac895ecd61ef3f858fe152bc21c407470ec8168f
-  data.tar.gz: cbdb4311dd2505d47ada5f78105ec0203e24edd6274161d16b67b196aa68596b
+  metadata.gz: 56f4bfc568fa70750a5dc1376ffffacd1163344c63750492e0e0ff841fd73d18
+  data.tar.gz: 6e41d012096437a58a9ceea49c0aa5d71532d06d273b37593afcd7cb9bc07297
 SHA512:
-  metadata.gz: 113b3cbc430583fd2144ab7f6dc9188e3e2c87079fb188bc931c954ffe51c18c849373ed53fee2b71c87f6abb76a54f66519475eb5bfd95bf00c29cc21f2e4c0
-  data.tar.gz: a4f7632a2af82ea4052ed1c94b9b651e7fd7b6ac88010d4d18b77038d374d2833e25443768152f54ab68f6710f48a6c5ada634199d6b4d55f7501074674d3a82
+  metadata.gz: 7060859db57bed3e98e372c1b3808f53802bb1c7e4e76f70b366e138c022d1aef522605457d8e69f8eb029394c8bb8c32e1aa1eb0933d4fcd8746f60452afac3
+  data.tar.gz: a0857b56731a9fab6d53748700a932fc3d6a3c7b065dd8ce54d03bf89274002f215e6ae39fa0b72d49c60cb4c7cc11307f7e4d3b1f965f7f4f5a721545712978

data/lib/api_config.rb

@@ -0,0 +1,128 @@
+require 'constants'
+
+class UnsupportedConfigException < StandardError
+end
+
+module Statsig
+  class APIConfig
+    attr_accessor :name, :type, :is_active, :salt, :default_value, :enabled,
+                  :rules, :id_type, :entity, :explicit_parameters, :has_shared_params, :target_app_ids
+
+    def initialize(name:, type:, is_active:, salt:, default_value:, enabled:, rules:, id_type:, entity:,
+                   explicit_parameters: nil, has_shared_params: nil, target_app_ids: nil)
+      @name = name
+      @type = type.to_sym unless entity.nil?
+      @is_active = is_active
+      @salt = salt
+      @default_value = JSON.parse(JSON.generate(default_value))
+      @enabled = enabled
+      @rules = rules
+      @id_type = id_type
+      @entity = entity.to_sym unless entity.nil?
+      @explicit_parameters = explicit_parameters
+      @has_shared_params = has_shared_params
+      @target_app_ids = target_app_ids
+    end
+
+    def self.from_json(json)
+      new(
+        name: json[:name],
+        type: json[:type],
+        is_active: json[:isActive],
+        salt: json[:salt],
+        default_value: json[:defaultValue] || {},
+        enabled: json[:enabled],
+        rules: json[:rules]&.map do |rule|
+          APIRule.from_json(rule)
+        end,
+        id_type: json[:idType],
+        entity: json[:entity],
+        explicit_parameters: json[:explicitParameters],
+        has_shared_params: json[:hasSharedParams],
+        target_app_ids: json[:targetAppIDs]
+      )
+    end
+  end
+end
+
+module Statsig
+  class APIRule
+
+    attr_accessor :name, :pass_percentage, :return_value, :id, :salt,
+                  :conditions, :id_type, :group_name, :config_delegate, :is_experiment_group
+
+    def initialize(name:, pass_percentage:, return_value:, id:, salt:, conditions:, id_type:,
+                   group_name: nil, config_delegate: nil, is_experiment_group: nil)
+      @name = name
+      @pass_percentage = pass_percentage.to_f
+      @return_value = JSON.parse(JSON.generate(return_value))
+      @id = id
+      @salt = salt
+      @conditions = conditions
+      @id_type = id_type
+      @group_name = group_name
+      @config_delegate = config_delegate
+      @is_experiment_group = is_experiment_group
+    end
+
+    def self.from_json(json)
+      new(
+        name: json[:name],
+        pass_percentage: json[:passPercentage],
+        return_value: json[:returnValue] || {},
+        id: json[:id],
+        salt: json[:salt],
+        conditions: json[:conditions]&.map do |condition|
+          APICondition.from_json(condition)
+        end,
+        id_type: json[:idType],
+        group_name: json[:groupName],
+        config_delegate: json[:configDelegate],
+        is_experiment_group: json[:isExperimentGroup]
+      )
+    end
+  end
+end
+
+module Statsig
+  class APICondition
+
+    attr_accessor :type, :target_value, :operator, :field, :additional_values, :id_type
+
+    def initialize(type:, target_value:, operator:, field:, additional_values:, id_type:)
+      @type = type.to_sym unless type.nil?
+      @target_value = target_value
+      @operator = operator.to_sym unless operator.nil?
+      @field = field
+      @additional_values = additional_values || {}
+      @id_type = id_type
+    end
+
+    def self.from_json(json)
+      operator = json[:operator]
+      unless operator.nil?
+        operator = operator&.downcase&.to_sym
+        unless Const::SUPPORTED_OPERATORS.include?(operator)
+          raise UnsupportedConfigException
+        end
+      end
+
+      type = json[:type]
+      unless type.nil?
+        type = type&.downcase&.to_sym
+        unless Const::SUPPORTED_CONDITION_TYPES.include?(type)
+          raise UnsupportedConfigException
+        end
+      end
+
+      new(
+        type: json[:type],
+        target_value: json[:targetValue],
+        operator: json[:operator],
+        field: json[:field],
+        additional_values: json[:additionalValues],
+        id_type: json[:idType]
+      )
+    end
+  end
+end

data/lib/client_initialize_helpers.rb

@@ -1,148 +1,159 @@
-# typed: true
-
 require_relative 'hash_utils'
-require 'sorbet-runtime'
 
+require 'constants'
 
-module ClientInitializeHelpers
+module Statsig
   class ResponseFormatter
-    extend T::Sig
-
-    def initialize(evaluator, user, hash, client_sdk_key)
-      @evaluator = evaluator
-      @user = user
-      @specs = evaluator.spec_store.get_raw_specs
-      @hash = hash
-      @client_sdk_key = client_sdk_key
-    end
-
-    def get_responses(key)
-      @specs[key]
-        .map { |name, spec| to_response(name, spec) }
-        .delete_if { |v| v.nil? }.to_h
-    end
-
-    private
-
-    sig { params(secondary_exposures: T::Array[T::Hash[String, String]]).returns(T::Array[T::Hash[String, String]]) }
-    def filter_segments_from_secondary_exposures(secondary_exposures)
-      secondary_exposures.reject do |exposure|
-        exposure['gate'].to_s.start_with?('segment:')
+    def self.get_responses(
+      entities,
+      evaluator,
+      user,
+      client_sdk_key,
+      hash_algo,
+      include_exposures: true,
+      include_local_overrides: false
+    )
+      result = {}
+      entities.each do |name, spec|
+        hashed_name, value = to_response(name, spec, evaluator, user, client_sdk_key, hash_algo, include_exposures, include_local_overrides)
+        if !hashed_name.nil? && !value.nil?
+          result[hashed_name] = value
+        end
       end
+
+      result
     end
 
-    def to_response(config_name, config_spec)
-      target_app_id = @evaluator.spec_store.get_app_id_for_sdk_key(@client_sdk_key)
-      config_target_apps = config_spec['targetAppIDs']
+    def self.to_response(config_name, config_spec, evaluator, user, client_sdk_key, hash_algo, include_exposures, include_local_overrides)
+      target_app_id = evaluator.spec_store.get_app_id_for_sdk_key(client_sdk_key)
+      config_target_apps = config_spec.target_app_ids
 
       unless target_app_id.nil? || (!config_target_apps.nil? && config_target_apps.include?(target_app_id))
         return nil
       end
 
-      eval_result = @evaluator.eval_spec(@user, config_spec)
-      if eval_result.nil?
+      category = config_spec.type
+      entity_type = config_spec.entity
+      if entity_type == :segment || entity_type == :holdout
         return nil
       end
 
-      category = config_spec['type']
-      entity_type = config_spec['entity']
+      if include_local_overrides
+        case category
+        when :feature_gate
+          local_override = evaluator.lookup_gate_override(config_name)
+        when :dynamic_config
+          local_override = evaluator.lookup_config_override(config_name)
+        end
+      end
 
-      result = {}
+      if local_override.nil?
+        eval_result = ConfigResult.new(
+          name: config_name,
+          disable_evaluation_details: true,
+          disable_exposures: !include_exposures
+        )
+        evaluator.eval_spec(user, config_spec, eval_result)
+      else
+        eval_result = local_override
+      end
 
-      case category
+      result = {}
 
-      when 'feature_gate'
-        if entity_type == 'segment' || entity_type == 'holdout'
-          return nil
-        end
+      result[:id_type] = eval_result.id_type
+      unless eval_result.group_name.nil?
+        result[:group_name] = eval_result.group_name
+      end
 
-        result['value'] = eval_result.gate_value
-        result["group_name"] = eval_result.group_name
-        result["id_type"] = eval_result.id_type
-      when 'dynamic_config'
-        id_type = config_spec['idType']
-        result['value'] = eval_result.json_value
-        result["group"] = eval_result.rule_id
-        result["group_name"] = eval_result.group_name
-        result["id_type"] = eval_result.id_type
-        result["is_device_based"] = id_type.is_a?(String) && id_type.downcase == 'stableid'
+      case category
+      when :feature_gate
+        result[:value] = eval_result.gate_value
+      when :dynamic_config
+        id_type = config_spec.id_type
+        result[:value] = eval_result.json_value
+        result[:group] = eval_result.rule_id
+        result[:is_device_based] = id_type.is_a?(String) && id_type.downcase == Statsig::Const::STABLEID
       else
         return nil
       end
 
-      if entity_type == 'experiment'
-        populate_experiment_fields(config_name, config_spec, eval_result, result)
+      if entity_type == :experiment
+        populate_experiment_fields(name, config_spec, eval_result, result, evaluator)
       end
 
-      if entity_type == 'layer'
-        populate_layer_fields(config_spec, eval_result, result)
-        result.delete('id_type') # not exposed for layer configs in /initialize
+      if entity_type == :layer
+        populate_layer_fields(config_spec, eval_result, result, evaluator, hash_algo, include_exposures)
+        result.delete(:id_type) # not exposed for layer configs in /initialize
       end
 
-      hashed_name = hash_name(config_name)
-      [hashed_name, result.merge(
-        {
-          "name" => hashed_name,
-          "rule_id" => eval_result.rule_id,
-          "secondary_exposures" => clean_exposures(eval_result.secondary_exposures)
-        }).compact]
+      hashed_name = hash_name(config_name, hash_algo)
+
+      result[:name] = hashed_name
+      result[:rule_id] = eval_result.rule_id
+
+      if include_exposures
+        result[:secondary_exposures] = clean_exposures(eval_result.secondary_exposures)
+      end
+
+      [hashed_name, result]
     end
 
-    def clean_exposures(exposures)
+    def self.clean_exposures(exposures)
       seen = {}
       exposures.reject do |exposure|
-        key = "#{exposure["gate"]}|#{exposure["gateValue"]}|#{exposure["ruleID"]}}"
+        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
+    def self.populate_experiment_fields(config_name, config_spec, eval_result, result, evaluator)
+      result[:is_user_in_experiment] = eval_result.is_experiment_group
+      result[:is_experiment_active] = config_spec.is_active == true
 
-      if config_spec['hasSharedParams'] != true
+      if config_spec.has_shared_params != true
         return
       end
 
-      result["is_in_layer"] = true
-      result["explicit_parameters"] = config_spec["explicitParameters"] || []
+      result[:is_in_layer] = true
+      result[:explicit_parameters] = config_spec.explicit_parameters || []
 
-      layer_name = @specs[:experiment_to_layer][config_name]
-      if layer_name.nil? || @specs[:layers][layer_name].nil?
+      layer_name = evaluator.spec_store.experiment_to_layer[config_name]
+      if layer_name.nil? || evaluator.spec_store.layers[layer_name].nil?
         return
       end
 
-      layer = @specs[:layers][layer_name]
-      result["value"] = layer["defaultValue"].merge(result["value"])
+      layer = evaluator.spec_store.layers[layer_name]
+      result[:value] = layer[:defaultValue].merge(result[:value])
     end
 
-    def populate_layer_fields(config_spec, eval_result, result)
+    def self.populate_layer_fields(config_spec, eval_result, result, evaluator, hash_algo, include_exposures)
       delegate = eval_result.config_delegate
-      result["explicit_parameters"] = config_spec["explicitParameters"] || []
+      result[:explicit_parameters] = config_spec.explicit_parameters || []
 
       if delegate.nil? == false && delegate.empty? == false
-        delegate_spec = @specs[:configs][delegate]
-        delegate_result = @evaluator.eval_spec(@user, delegate_spec)
+        delegate_spec = evaluator.spec_store.configs[delegate]
 
-        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"] || []
+        result[:allocated_experiment_name] = hash_name(delegate, hash_algo)
+        result[:is_user_in_experiment] = eval_result.is_experiment_group
+        result[:is_experiment_active] = delegate_spec.is_active == true
+        result[:explicit_parameters] = delegate_spec.explicit_parameters || []
       end
 
-      result["undelegated_secondary_exposures"] = clean_exposures(eval_result.undelegated_sec_exps || [])
+      if include_exposures
+        result[:undelegated_secondary_exposures] = clean_exposures(eval_result.undelegated_sec_exps || [])
+      end
     end
 
-    def hash_name(name)
-      case @hash
-      when 'none'
+    def self.hash_name(name, hash_algo)
+      case hash_algo
+      when Statsig::Const::NONE
         return name
-      when 'sha256'
-        return Statsig::HashUtils.sha256(name)
-      when 'djb2'
+      when Statsig::Const::DJB2
         return Statsig::HashUtils.djb2(name)
+      else
+        return Statsig::HashUtils.sha256(name)
       end
     end
   end

data/lib/config_result.rb

@@ -1,10 +1,5 @@
-# typed: true
-
-require 'sorbet-runtime'
-
 module Statsig
   class ConfigResult
-    extend T::Sig
 
     attr_accessor :name
     attr_accessor :gate_value
@@ -19,25 +14,30 @@ module Statsig
     attr_accessor :group_name
     attr_accessor :id_type
     attr_accessor :target_app_ids
+    attr_accessor :disable_evaluation_details
+    attr_accessor :disable_exposures
 
     def initialize(
-      name,
-      gate_value = false,
-      json_value = {},
-      rule_id = '',
-      secondary_exposures = [],
-      config_delegate = nil,
-      explicit_parameters = [],
+      name:,
+      gate_value: false,
+      json_value: nil,
+      rule_id: nil,
+      secondary_exposures: [],
+      config_delegate: nil,
+      explicit_parameters: nil,
       is_experiment_group: false,
       evaluation_details: nil,
       group_name: nil,
-      id_type: '',
-      target_app_ids: nil)
+      id_type: nil,
+      target_app_ids: nil,
+      disable_evaluation_details: false,
+      disable_exposures: false
+    )
       @name = name
       @gate_value = gate_value
       @json_value = json_value
       @rule_id = rule_id
-      @secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
+      @secondary_exposures = secondary_exposures
       @undelegated_sec_exps = @secondary_exposures
       @config_delegate = config_delegate
       @explicit_parameters = explicit_parameters
@@ -46,9 +46,10 @@ module Statsig
       @group_name = group_name
       @id_type = id_type
       @target_app_ids = target_app_ids
+      @disable_evaluation_details = disable_evaluation_details
+      @disable_exposures = disable_exposures
     end
 
-    sig { params(config_name: String, user_persisted_values: UserPersistedValues).returns(T.nilable(ConfigResult)) }
     def self.from_user_persisted_values(config_name, user_persisted_values)
       sticky_values = user_persisted_values[config_name]
       return nil if sticky_values.nil?
@@ -56,22 +57,6 @@ module Statsig
       from_hash(config_name, sticky_values)
     end
 
-    sig { params(config_name: String, hash: Hash).returns(ConfigResult) }
-    def self.from_hash(config_name, hash)
-      new(
-        config_name,
-        hash['gate_value'],
-        hash['json_value'],
-        hash['rule_id'],
-        hash['secondary_exposures'],
-        evaluation_details: EvaluationDetails.persisted(hash['config_sync_time'], hash['init_time']),
-        group_name: hash['group_name'],
-        id_type: hash['id_type'],
-        target_app_ids: hash['target_app_ids']
-      )
-    end
-
-    sig { returns(Hash) }
     def to_hash
       {
         json_value: @json_value,

data/lib/constants.rb

@@ -0,0 +1,60 @@
+module Statsig
+  module Const
+    EMPTY_STR = ''.freeze
+
+    SUPPORTED_CONDITION_TYPES = Set.new(%i[
+                                          public fail_gate pass_gate ip_based ua_based user_field
+                                          environment_field current_time user_bucket unit_id
+                                        ]).freeze
+
+    SUPPORTED_OPERATORS = Set.new(%i[
+                                    gt gte lt lte version_gt version_gte version_lt version_lte
+                                    version_eq version_neq any none any_case_sensitive none_case_sensitive
+                                    str_starts_with_any str_ends_with_any str_contains_any str_contains_none
+                                    str_matches eq neq before after on in_segment_list not_in_segment_list
+                                  ]).freeze
+
+    APP_VERSION = 'app_version'.freeze
+    APPVERSION = 'appversion'.freeze
+    BROWSER_NAME = 'browser_name'.freeze
+    BROWSER_VERSION = 'browser_version'.freeze
+    BROWSERNAME = 'browsername'.freeze
+    BROWSERVERSION = 'browserversion'.freeze
+    CML_SHA_256 = 'sha256'.freeze
+    CML_USER_ID = 'userID'.freeze
+    COUNTRY = 'country'.freeze
+    DEFAULT = 'default'.freeze
+    DISABLED = 'disabled'.freeze
+    DJB2 = 'djb2'.freeze
+    EMAIL = 'email'.freeze
+    FALSE = 'false'.freeze
+    IP = 'ip'.freeze
+    LAYER = :layer
+    LOCALE = 'locale'.freeze
+    NONE = 'none'.freeze
+    OS_NAME = 'os_name'.freeze
+    OS_VERSION = 'os_version'.freeze
+    OSNAME = 'osname'.freeze
+    OSVERSION = 'osversion'.freeze
+    OVERRIDE = 'override'.freeze
+    Q_RIGHT_CHEVRON = 'Q>'.freeze
+    STABLEID = 'stableid'.freeze
+    STATSIG_RUBY_SDK = 'statsig-ruby-sdk'.freeze
+    TRUE = 'true'.freeze
+    USER_AGENT = 'user_agent'.freeze
+    USER_ID = 'user_id'.freeze
+    USERAGENT = 'useragent'.freeze
+    USERID = 'userid'.freeze
+
+    # Persisted Evaluations
+    GATE_VALUE = 'gate_value'.freeze
+    JSON_VALUE = 'json_value'.freeze
+    RULE_ID = 'rule_id'.freeze
+    SECONDARY_EXPOSURES = 'secondary_exposures'.freeze
+    GROUP_NAME = 'group_name'.freeze
+    ID_TYPE = 'id_type'.freeze
+    TARGET_APP_IDS = 'target_app_ids'.freeze
+    CONFIG_SYNC_TIME = 'config_sync_time'.freeze
+    INIT_TIME = 'init_time'.freeze
+  end
+end

data/lib/diagnostics.rb

@@ -1,15 +1,7 @@
-# typed: true
-
-require 'sorbet-runtime'
-
 module Statsig
   class Diagnostics
-    extend T::Sig
-
-    sig { returns(T::Hash[String, T::Array[T::Hash[Symbol, T.untyped]]]) }
     attr_reader :markers
 
-    sig { returns(T::Hash[String, Numeric]) }
     attr_accessor :sample_rates
 
     def initialize()
@@ -17,16 +9,6 @@ module Statsig
       @sample_rates = {}
     end
 
-    sig do
-      params(
-        key: String,
-        action: String,
-        step: T.any(String, NilClass),
-        tags: T::Hash[Symbol, T.untyped],
-        context: String
-      ).void
-    end
-
     def mark(key, action, step, tags, context)
       marker = {
         key: key,
@@ -47,14 +29,6 @@ module Statsig
       @markers[context].push(marker)
     end
 
-    sig do
-      params(
-        context: String,
-        key: String,
-        step: T.any(String, NilClass),
-        tags: T::Hash[Symbol, T.untyped]
-      ).returns(Tracker)
-    end
     def track(context, key, step = nil, tags = {})
       tracker = Tracker.new(self, context, key, step, tags)
       tracker.start(**tags)
@@ -87,17 +61,6 @@ module Statsig
     API_CALL_KEYS = %w[check_gate get_config get_experiment get_layer].freeze
 
     class Tracker
-      extend T::Sig
-
-      sig do
-        params(
-          diagnostics: Diagnostics,
-          context: String,
-          key: String,
-          step: T.any(String, NilClass),
-          tags: T::Hash[Symbol, T.untyped]
-        ).void
-      end
       def initialize(diagnostics, context, key, step, tags = {})
         @diagnostics = diagnostics
         @context = context
@@ -115,4 +78,4 @@ module Statsig
       end
     end
   end
-end
+end

data/lib/dynamic_config.rb

@@ -1,7 +1,3 @@
-# typed: false
-
-require 'sorbet-runtime'
-
 ##
 # Contains the current experiment/dynamic config values from Statsig
 #
@@ -9,46 +5,28 @@ require 'sorbet-runtime'
 #
 #  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 { returns(T.nilable(String)) }
   attr_accessor :group_name
 
-  sig { returns(String) }
   attr_accessor :id_type
 
-  sig { returns(T.nilable(Statsig::EvaluationDetails)) }
   attr_accessor :evaluation_details
 
-  sig do
-    params(
-      name: String,
-      value: T::Hash[String, T.untyped],
-      rule_id: String,
-      group_name: T.nilable(String),
-      id_type: String,
-      evaluation_details: T.nilable(Statsig::EvaluationDetails)
-    ).void
-  end
   def initialize(name, value = {}, rule_id = '', group_name = nil, id_type = '', evaluation_details = nil)
     @name = name
-    @value = value
+    @value = value || {}
     @rule_id = rule_id
     @group_name = group_name
     @id_type = id_type
     @evaluation_details = evaluation_details
   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.
   #
@@ -59,7 +37,6 @@ class DynamicConfig
     @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.

data/lib/error_boundary.rb

@@ -1,15 +1,10 @@
-# typed: true
-
 require 'statsig_errors'
-require 'sorbet-runtime'
 
 $endpoint = 'https://statsigapi.net/v1/sdk_exception'
 
 module Statsig
   class ErrorBoundary
-    extend T::Sig
 
-    sig { params(sdk_key: String).void }
     def initialize(sdk_key)
       @sdk_key = sdk_key
       @seen = Set.new