statsig 1.30.0 → 1.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72119a11268473774b98457f89017155813cdaab4c19b8f07e1aad370ae6dd17
-  data.tar.gz: 69cb96c04c6b9c322bb239332b8c406a6b543bb42b0cab6da9e641d44fa15371
+  metadata.gz: dd71ed81ad0f3658f5b6b480adba4a36f560357c67d6d9869b605e2d0e1e76c0
+  data.tar.gz: 59b7da08c4991da0e7b33dc08865612347442970932e71b8069bcd4518d50680
 SHA512:
-  metadata.gz: d75c0a0d9c6529843c554d05b3ae49e6d863cd01da11f932e679bddddffab4287ef036af37c3cd8fff9310c10cd6758bc6e5435f78626245c5d1f315b91e09eb
-  data.tar.gz: b9886d0b78d1491393cfacdea4c1f4cdeae1d2a993a0f5a0875011be1083bb63e4a7721fb3a007869eaa7eaf69ad300438d8038c099e88277958d4daf6d226f7
+  metadata.gz: 3775510747a856d9ae300ccad20a74de3cbe000bc3bca59c535c64cbab1bcb46a83069aa917299ee6dd7032f44206eecd39f3602c92f18c39a8ebbb57b45d9e9
+  data.tar.gz: e0a03db37029a260614a6eb8bf9edf1e2fe60f84d67fb9e027bf5fd72c3c4f969a7ab3145f55d0bd19f796b7d1733416547688e1076c69e066abd819c99b899c

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,167 +1,138 @@
-# typed: true
-
 require_relative 'hash_utils'
-require 'sorbet-runtime'
 
-$empty_eval_result = {
-  :gate_value => false,
-  :json_value => {},
-  :rule_id => "",
-  :is_experiment_group => false,
-  :secondary_exposures => []
-}
+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)
+      result = {}
+      entities.each do |name, spec|
+        hashed_name, value = to_response(name, spec, evaluator, user, client_sdk_key, hash_algo, include_exposures)
+        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)
+      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
 
-      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,
-        :group_name => eval_result.group_name,
-        :id_type => eval_result.id_type,
-        :config_delegate => eval_result.config_delegate,
-        :is_experiment_group => eval_result.is_experiment_group,
-        :secondary_exposures => filter_segments_from_secondary_exposures(eval_result.secondary_exposures),
-        :undelegated_sec_exps => eval_result.undelegated_sec_exps
-      }
-
-      category = config_spec['type']
-      entity_type = config_spec['entity']
+      eval_result = ConfigResult.new(
+        name: config_name,
+        disable_evaluation_details: true,
+        disable_exposures: !include_exposures
+      )
+      evaluator.eval_spec(user, config_spec, eval_result)
 
       result = {}
 
-      case category
-
-      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'] = safe_eval_result[:gate_value]
-        result["group_name"] = safe_eval_result[:group_name]
-        result["id_type"] = safe_eval_result[:id_type]
-      when 'dynamic_config'
-        id_type = config_spec['idType']
-        result['value'] = safe_eval_result[:json_value]
-        result["group"] = safe_eval_result[:rule_id]
-        result["group_name"] = safe_eval_result[:group_name]
-        result["id_type"] = safe_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, safe_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, safe_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" => safe_eval_result[:rule_id],
-          "secondary_exposures" => clean_exposures(safe_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)
-      delegate = eval_result[:config_delegate]
-      result["explicit_parameters"] = config_spec["explicitParameters"] || []
+    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.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,36 +1,15 @@
-# typed: true
-
-require 'sorbet-runtime'
-
 module Statsig
   class Diagnostics
-    extend T::Sig
-
-    sig { returns(String) }
-    attr_accessor :context
-
-    sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
     attr_reader :markers
 
-    sig { returns(T::Hash[String, Numeric]) }
     attr_accessor :sample_rates
 
-    def initialize(context)
-      @context = context
-      @markers = []
+    def initialize()
+      @markers = {:initialize => [], :api_call => [], :config_sync => []}
       @sample_rates = {}
     end
 
-    sig do
-      params(
-        key: String,
-        action: String,
-        step: T.any(String, NilClass),
-        tags: T::Hash[Symbol, T.untyped]
-      ).void
-    end
-
-    def mark(key, action, step, tags)
+    def mark(key, action, step, tags, context)
       marker = {
         key: key,
         action: action,
@@ -44,87 +23,59 @@ module Statsig
           marker[key] = val
         end
       end
-      @markers.push(marker)
+      if @markers[context].nil?
+        @markers[context] = []
+      end
+      @markers[context].push(marker)
     end
 
-    sig do
-      params(
-        key: String,
-        step: T.any(String, NilClass),
-        tags: T::Hash[Symbol, T.untyped]
-      ).returns(Tracker)
-    end
-    def track(key, step = nil, tags = {})
-      tracker = Tracker.new(self, key, step, tags)
+    def track(context, key, step = nil, tags = {})
+      tracker = Tracker.new(self, context, key, step, tags)
       tracker.start(**tags)
       tracker
     end
 
-    sig { returns(T::Hash[Symbol, T.untyped]) }
-
-    def serialize
-      {
-        context: @context.clone,
-        markers: @markers.clone
-      }
-    end
-
-    def serialize_with_sampling
-      marker_keys = @markers.map { |e| e[:key] }
+    def serialize_with_sampling(context)
+      marker_keys = @markers[context].map { |e| e[:key] }
       unique_marker_keys = marker_keys.uniq { |e| e }
       sampled_marker_keys = unique_marker_keys.select do |key|
         @sample_rates.key?(key) && !self.class.sample(@sample_rates[key])
       end
-      final_markers = @markers.select do |marker|
+      final_markers = @markers[context].select do |marker|
         !sampled_marker_keys.include?(marker[:key])
       end
       {
-        context: @context.clone,
-        markers: final_markers
+        context: context.clone,
+        markers: final_markers.clone
       }
     end
 
-    def clear_markers
-      @markers.clear
+    def clear_markers(context)
+      @markers[context].clear
     end
 
     def self.sample(rate_over_ten_thousand)
       rand * 10_000 < rate_over_ten_thousand
     end
 
-    class Context
-      INITIALIZE = 'initialize'.freeze
-      CONFIG_SYNC = 'config_sync'.freeze
-      API_CALL = 'api_call'.freeze
-    end
-
     API_CALL_KEYS = %w[check_gate get_config get_experiment get_layer].freeze
 
     class Tracker
-      extend T::Sig
-
-      sig do
-        params(
-          diagnostics: Diagnostics,
-          key: String,
-          step: T.any(String, NilClass),
-          tags: T::Hash[Symbol, T.untyped]
-        ).void
-      end
-      def initialize(diagnostics, key, step, tags = {})
+      def initialize(diagnostics, context, key, step, tags = {})
         @diagnostics = diagnostics
+        @context = context
         @key = key
         @step = step
         @tags = tags
       end
 
       def start(**tags)
-        @diagnostics.mark(@key, 'start', @step, tags.nil? ? {} : tags.merge(@tags))
+        @diagnostics.mark(@key, 'start', @step, tags.nil? ? {} : tags.merge(@tags), @context)
       end
 
       def end(**tags)
-        @diagnostics.mark(@key, 'end', @step, tags.nil? ? {} : tags.merge(@tags))
+        @diagnostics.mark(@key, 'end', @step, tags.nil? ? {} : tags.merge(@tags), @context)
       end
     end
   end
-end
+end