statsig 2.3.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1591515ecdce353516857952fae0e460997315f7c764f680a30df065821d36c4
-  data.tar.gz: 4818db100a200ade728aa7b3db42008313b975ed951e37ff9d72f46fe269580d
+  metadata.gz: 0d28e21a68fc183ea6273a6785854c6203da158f7c531c9aed09eabef40aaa85
+  data.tar.gz: fa40131ef5bb4136caf4abce626606bf241d856bc4122c46e2c1b6314e17b54c
 SHA512:
-  metadata.gz: fe639606633dce22ad66d8216149c2f3db9136c1c2a33799320671df9dc839e06554a91688bc0baf0a638bd29a0258822cc169cc5e01ce8630c5a108d8e883f9
-  data.tar.gz: 31912d0a1c2113ce74716987a666695cda53b5532ed154677135332fe17983b145c39d182cc193a510e857083f0290491dfea90df6efe5850935071b3f3dbb64
+  metadata.gz: 74a843bea3b005c2bea0356e38228a0ac93e70c2d0cc67e89ceaca04df5952b0f601a30edec517963c09f10b1dca02889273b8cc541d18391d05926cc9bc4bb7
+  data.tar.gz: f22a12cfb6a10a3c85375ce5998d83dd97d129f99a06e599b40322f41d198a9e57ec55a7b228ad558b2acdddbd425f7c9d0074fc4052316941e268378d26d966

data/lib/constants.rb

@@ -29,6 +29,8 @@ module Statsig
     DISABLED = 'disabled'.freeze
     DJB2 = 'djb2'.freeze
     EMAIL = 'email'.freeze
+    EXPLORE = ':explore'.freeze
+    FAILS_TARGETING = 'inlineTargetingRules'.freeze
     FALSE = 'false'.freeze
     IP = 'ip'.freeze
     LAYER = :layer
@@ -39,6 +41,7 @@ module Statsig
     OSNAME = 'osname'.freeze
     OSVERSION = 'osversion'.freeze
     OVERRIDE = 'override'.freeze
+    PRESTART = 'prestart'.freeze
     Q_RIGHT_CHEVRON = 'Q>'.freeze
     STABLEID = 'stableid'.freeze
     STATSIG_RUBY_SDK = 'statsig-ruby-sdk'.freeze

data/lib/evaluator.rb

@@ -122,6 +122,10 @@ module Statsig
         return
       end
 
+      if eval_cmab(config_name, user, end_result)
+        return
+      end
+
       unless @spec_store.has_config?(config_name)
         unsupported_or_unrecognized(config_name, end_result)
         return
@@ -163,6 +167,149 @@ module Statsig
       end
     end
 
+    def eval_cmab(config_name, user, end_result)
+      return false unless @spec_store.has_cmab_config?(config_name)
+
+      cmab = @spec_store.get_cmab_config(config_name)
+
+      if !cmab[:enabled] || cmab[:groups].length.zero?
+        end_result.rule_id = Const::PRESTART
+        end_result.json_value = cmab[:defaultValue]
+        finalize_cmab_eval_result(cmab, end_result, did_pass: false)
+        return true
+      end
+
+      targeting_gate = cmab[:targetingGateName]
+      unless targeting_gate.nil?
+        check_gate(user, targeting_gate, end_result, is_nested: true)
+
+        gate_value = end_result.gate_value
+
+        unless end_result.disable_exposures
+          new_exposure = {
+            gate: targeting_gate,
+            gateValue: gate_value ? Const::TRUE : Const::FALSE,
+            ruleID: end_result.rule_id
+          }
+          end_result.secondary_exposures.append(new_exposure)
+        end
+
+        if gate_value == false
+          end_result.rule_id = Const::FAILS_TARGETING
+          end_result.json_value = cmab[:defaultValue]
+          finalize_cmab_eval_result(cmab, end_result, did_pass: false)
+          return true
+        end
+      end
+
+      cmab_config = cmab[:config]
+      unit_id = user.get_unit_id(cmab[:idType]) || Const::EMPTY_STR
+      salt = cmab[:salt] || config_name
+      hash = compute_user_hash("#{salt}.#{unit_id}")
+
+      # If there is no config assign the user to a random group
+      if cmab_config.nil?
+        group_size = 10_000.0 / cmab[:groups].length
+        group = cmab[:groups][(hash % 10_000) / group_size]
+        end_result.json_value = group[:parameterValues]
+        end_result.rule_id = group[:id]
+        end_result.group_name = group[:name]
+        end_result.is_experiment_group = true
+        finalize_cmab_eval_result(cmab, end_result, did_pass: true)
+        return true
+      end
+
+      should_sample = (hash % 10_000) < cmab[:sampleRate] * 10_000
+      if should_sample && apply_cmab_sampling(cmab, cmab_config, end_result)
+        finalize_cmab_eval_result(cmab, end_result, did_pass: true)
+        return true
+      end
+      apply_cmab_best_group(cmab, cmab_config, user, end_result)
+      finalize_cmab_eval_result(cmab, end_result, did_pass: true)
+      true
+    end
+
+    def apply_cmab_best_group(cmab, cmab_config, user, end_result)
+      higher_better = cmab[:higherIsBetter]
+      best_score = higher_better ? -1_000_000_000 : 1_000_000_000
+      has_score = false
+      best_group = nil
+      cmab[:groups].each do |group|
+        group_id = group[:id]
+        config = cmab_config[group_id.to_sym]
+        next if config.nil?
+
+        weights_numerical = config[:weightsNumerical]
+        weights_categorical = config[:weightsCategorical]
+
+        next if weights_numerical.length.zero? && weights_categorical.length.zero?
+
+        score = 0
+        score += config[:alpha] + config[:intercept]
+
+        weights_categorical.each do |key, weights|
+          value = get_value_from_user(user, key.to_s)
+          next if value.nil?
+
+          if weights.key?(value.to_sym)
+            score += weights[value.to_sym]
+          end
+        end
+
+        weights_numerical.each do |key, weight|
+          value = get_value_from_user(user, key.to_s)
+          if value.is_a?(Numeric)
+            score += weight * value
+          end
+        end
+        if !has_score || (higher_better && score > best_score) || (!higher_better && score < best_score)
+          best_score = score
+          best_group = group
+        end
+        has_score = true
+      end
+      if best_group.nil?
+        best_group = cmab[:groups][Random.rand(cmab[:groups].length)]
+      end
+      end_result.json_value = best_group[:parameterValues]
+      end_result.rule_id = best_group[:id]
+      end_result.group_name = best_group[:name]
+      end_result.is_experiment_group = true
+    end
+
+    def apply_cmab_sampling(cmab, cmab_config, end_result)
+      total_records = 0.0
+      cmab[:groups].each do |group|
+        group_id = group[:id]
+        config = cmab_config[group_id.to_sym]
+        cur_count = 1.0
+        unless config.nil?
+          cur_count += config[:records]
+        end
+        total_records += 1.0 / cur_count
+      end
+
+      sum = 0.0
+      value = Random.rand
+      cmab[:groups].each do |group|
+        group_id = group[:id]
+        config = cmab_config[group_id.to_sym]
+        cur_count = 1.0
+        unless config.nil?
+          cur_count += config[:records]
+        end
+        sum += 1.0 / (cur_count / total_records)
+        next unless value < sum
+
+        end_result.json_value = group[:parameterValues]
+        end_result.rule_id = group[:id] + Const::EXPLORE
+        end_result.group_name = group[:name]
+        end_result.is_experiment_group = true
+        return true
+      end
+      false
+    end
+
     def get_layer(user, layer_name, end_result)
       if @spec_store.init_reason == EvaluationReason::UNINITIALIZED
         unless end_result.disable_evaluation_details
@@ -358,6 +505,21 @@ module Statsig
       end
     end
 
+    def finalize_cmab_eval_result(config, end_result, did_pass:)
+      end_result.id_type = config[:idType]
+      end_result.target_app_ids = config[:targetAppIDs]
+      end_result.gate_value = did_pass
+
+      unless end_result.disable_evaluation_details
+        end_result.evaluation_details = EvaluationDetails.new(
+          @spec_store.last_config_sync_time,
+          @spec_store.initial_config_sync_time,
+          @spec_store.init_reason
+        )
+      end
+      end_result.config_version = config[:version]
+    end
+
     def finalize_secondary_exposures(end_result)
       end_result.secondary_exposures = clean_exposures(end_result.secondary_exposures)
       end_result.undelegated_sec_exps = clean_exposures(end_result.undelegated_sec_exps)

data/lib/spec_store.rb

@@ -19,6 +19,7 @@ module Statsig
     attr_accessor :sdk_keys_to_app_ids
     attr_accessor :hashed_sdk_keys_to_app_ids
     attr_accessor :unsupported_configs
+    attr_accessor :cmab_configs
 
     def initialize(network, options, error_callback, diagnostics, error_boundary, logger, secret_key, sdk_config)
       @init_reason = EvaluationReason::UNINITIALIZED
@@ -33,6 +34,7 @@ module Statsig
       @gates = {}
       @configs = {}
       @layers = {}
+      @cmab_configs = {}
       @condition_map = {}
       @id_lists = {}
       @experiment_to_layer = {}
@@ -125,6 +127,13 @@ module Statsig
       @layers.key?(layer_name.to_sym)
     end
 
+    def has_cmab_config?(config_name)
+      if @cmab_configs.nil?
+        return false
+      end
+      @cmab_configs.key?(config_name.to_sym)
+    end
+
     def get_gate(gate_name)
       gate_sym = gate_name.to_sym
       return nil unless has_gate?(gate_sym)
@@ -145,6 +154,12 @@ module Statsig
       @layers[layer_sym]
     end
 
+    def get_cmab_config(config_name)
+      config_sym = config_name.to_sym
+      return nil unless has_cmab_config?(config_sym)
+      @cmab_configs[config_sym]
+    end
+
     def get_condition(condition_hash)
       @condition_map[condition_hash.to_sym]
     end
@@ -339,6 +354,7 @@ module Statsig
         @gates = specs_json[:feature_gates]
         @configs = specs_json[:dynamic_configs]
         @layers = specs_json[:layer_configs]
+        @cmab_configs = specs_json[:cmab_configs]
         @condition_map = specs_json[:condition_map]
         @experiment_to_layer = specs_json[:experiment_to_layer]
         @sdk_keys_to_app_ids = specs_json[:sdk_keys_to_app_ids] || {}

data/lib/statsig.rb

@@ -370,7 +370,7 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '2.3.1',
+      'sdkVersion' => '2.4.0',
       'languageVersion' => RUBY_VERSION
     }
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-06 00:00:00.000000000 Z
+date: 2025-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler