statsig 1.25.2 → 1.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7f3c8522d7d8062daf248fd667fd0d8152a4194339fde799814a5da44812eda
-  data.tar.gz: 1fd5e67d4a75ab3b5b6c92c780841252a4610e18bc13310f9b11dbb583aaf16a
+  metadata.gz: 56f4bfc568fa70750a5dc1376ffffacd1163344c63750492e0e0ff841fd73d18
+  data.tar.gz: 6e41d012096437a58a9ceea49c0aa5d71532d06d273b37593afcd7cb9bc07297
 SHA512:
-  metadata.gz: 8f516ca6d221c9d789f1f358b550edeedf4203c01ead45374b97a3b81f4205d09f1c7c3e0214516cdcad314bacbdbde39a5df2053779679fe4df593c974c8300
-  data.tar.gz: a90846ef3c050c7c0b8bddbabd19ed7bff6236a15ed941f55d1a305f4c9cb5ff35f595a3d7ea4ab1560d7f7bae11c669c29d17f8041da9125524669703dc5370
+  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,132 +1,160 @@
-# typed: true
-$empty_eval_result = {
-  :gate_value => false,
-  :json_value => {},
-  :rule_id => "",
-  :is_experiment_group => false,
-  :secondary_exposures => []
-}
-
-module ClientInitializeHelpers
+require_relative 'hash_utils'
+
+require 'constants'
+
+module Statsig
   class ResponseFormatter
-    def initialize(evaluator, user)
-      @evaluator = evaluator
-      @user = user
-      @specs = evaluator.spec_store.get_raw_specs
-    end
+    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
 
-    def get_responses(key)
-      @specs[key]
-        .map { |name, spec| to_response(name, spec) }
-        .delete_if { |v| v.nil? }.to_h
+      result
     end
 
-    private
+    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
 
-    def to_response(config_name, config_spec)
-      eval_result = @evaluator.eval_spec(@user, config_spec)
-      if eval_result.nil?
+      unless target_app_id.nil? || (!config_target_apps.nil? && config_target_apps.include?(target_app_id))
         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
+      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'] = 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'
+      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, eval_result, result, evaluator, hash_algo, include_exposures)
+        result.delete(:id_type) # not exposed for layer configs in /initialize
       end
 
-      if entity_type == 'layer'
-        populate_layer_fields(config_spec, safe_eval_result, result)
+      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 = 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])
-        })]
+      [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)
-      Digest::SHA256.base64digest(name)
+    def self.hash_name(name, hash_algo)
+      case hash_algo
+      when Statsig::Const::NONE
+        return name
+      when Statsig::Const::DJB2
+        return Statsig::HashUtils.djb2(name)
+      else
+        return Statsig::HashUtils.sha256(name)
+      end
     end
   end
-end
+end

data/lib/config_result.rb

@@ -1,6 +1,6 @@
-# typed: true
 module Statsig
   class ConfigResult
+
     attr_accessor :name
     attr_accessor :gate_value
     attr_accessor :json_value
@@ -13,24 +13,31 @@ module Statsig
     attr_accessor :evaluation_details
     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 = '',
-      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: '')
+      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
@@ -38,6 +45,30 @@ module Statsig
       @evaluation_details = evaluation_details
       @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
+
+    def self.from_user_persisted_values(config_name, user_persisted_values)
+      sticky_values = user_persisted_values[config_name]
+      return nil if sticky_values.nil?
+
+      from_hash(config_name, sticky_values)
+    end
+
+    def to_hash
+      {
+        json_value: @json_value,
+        gate_value: @gate_value,
+        rule_id: @rule_id,
+        secondary_exposures: @secondary_exposures,
+        config_sync_time: @evaluation_details.config_sync_time,
+        init_time: @init_time,
+        group_name: @group_name,
+        id_type: @id_type,
+        target_app_ids: @target_app_ids
+      }
     end
   end
-end
+end

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,103 +1,81 @@
-# 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
 
-    def initialize(context)
-      @context = context
-      @markers = []
-    end
+    attr_accessor :sample_rates
 
-    sig do
-      params(
-        key: String,
-        action: String,
-        step: T.any(String, NilClass),
-        value: T.any(String, Integer, T::Boolean, NilClass),
-        metadata: T.any(T::Hash[Symbol, T.untyped], NilClass)
-      ).void
+    def initialize()
+      @markers = {:initialize => [], :api_call => [], :config_sync => []}
+      @sample_rates = {}
     end
 
-    def mark(key, action, step = nil, value = nil, metadata = nil)
-      @markers.push({
-                      key: key,
-                      step: step,
-                      action: action,
-                      value: value,
-                      metadata: metadata,
-                      timestamp: (Time.now.to_f * 1000).to_i
-                    })
+    def mark(key, action, step, tags, context)
+      marker = {
+        key: key,
+        action: action,
+        timestamp: (Time.now.to_f * 1000).to_i
+      }
+      if !step.nil?
+        marker[:step] = step
+      end
+      tags.each do |key, val|
+        unless val.nil?
+          marker[key] = val
+        end
+      end
+      if @markers[context].nil?
+        @markers[context] = []
+      end
+      @markers[context].push(marker)
     end
 
-    sig do
-      params(
-        key: String,
-        step: T.any(String, NilClass),
-        value: T.any(String, Integer, T::Boolean, NilClass),
-        metadata: T.any(T::Hash[Symbol, T.untyped], NilClass)
-      ).returns(Tracker)
-    end
-    def track(key, step = nil, value = nil, metadata = nil)
-      tracker = Tracker.new(self, key, step, metadata)
-      tracker.start(value)
+    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
+    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[context].select do |marker|
+        !sampled_marker_keys.include?(marker[:key])
+      end
       {
-        context: @context.clone,
-        markers: @markers.clone
+        context: context.clone,
+        markers: final_markers.clone
       }
     end
 
-    def clear_markers
-      @markers.clear
+    def clear_markers(context)
+      @markers[context].clear
     end
 
-    class Context
-      INITIALIZE = 'initialize'.freeze
-      CONFIG_SYNC = 'config_sync'.freeze
-      API_CALL = 'api_call'.freeze
+    def self.sample(rate_over_ten_thousand)
+      rand * 10_000 < rate_over_ten_thousand
     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),
-          metadata: T.any(T::Hash[Symbol, T.untyped], NilClass)
-        ).void
-      end
-      def initialize(diagnostics, key, step, metadata)
+      def initialize(diagnostics, context, key, step, tags = {})
         @diagnostics = diagnostics
+        @context = context
         @key = key
         @step = step
-        @metadata = metadata
+        @tags = tags
       end
 
-      def start(value = nil)
-        @diagnostics.mark(@key, 'start', @step, value, @metadata)
+      def start(**tags)
+        @diagnostics.mark(@key, 'start', @step, tags.nil? ? {} : tags.merge(@tags), @context)
       end
 
-      def end(value = nil)
-        @diagnostics.mark(@key, 'end', @step, value, @metadata)
+      def end(**tags)
+        @diagnostics.mark(@key, 'end', @step, tags.nil? ? {} : tags.merge(@tags), @context)
       end
     end
   end
-end
+end