statsig 1.18.0 → 1.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 475c2e56b1f53dbc642adff47dd6a1de3a3c324ce9a0145fcaf7c6ebb2b412c1
-  data.tar.gz: a37bbef25c2ce1b818fafe25252bcf076964b16acdb484d41ebe2c705b6042b1
+  metadata.gz: 768ca65c5f2e54afdc7896eedc8ceb095b44f99ebb861f56ecb10d82c965c9db
+  data.tar.gz: 9b644e6659565eb44d266fee5d37374f1feee076d789d57c32d744cab6530bb9
 SHA512:
-  metadata.gz: 32ba1629776babb0f4d437e551a251e5bea38b42b916c067c0009705ef59b71db5989a6942e009994ab5956e10ca61cf7ee4a14f9302312094e2b2cc479568c5
-  data.tar.gz: d8d6f082a647a6b6ba7d6adf8954c17d845b44b55dfd7b17ce4fff0aa858cbce96d6308e2ec0e0f15209275d5e8520f0b5697d1caf64cdac7e40e0d7dc46b4da
+  metadata.gz: fca05aceecc4389eec081e98159bcaef3aa1ca91447c99770c62cad3e5e16f5ebf500edf257081b051462028c47cfee060fe41ab362db4468429faea88516872
+  data.tar.gz: 64755e9303545ba9915e241460c4468a508dcad79057bc4475ba68d6e8edd3fa874e89f1d0709557121bffd037c11ab0d7d229c0da0fb61369a5b0f75e4ec6ee

data/lib/statsig.rb

@@ -35,6 +35,28 @@ module Statsig
     @shared_instance&.check_gate(user, gate_name)
   end
 
+  sig { params(user: StatsigUser, gate_name: String).returns(T::Boolean) }
+  ##
+  # Gets the boolean result of a gate, evaluated against the given user.
+  #
+  # @param user A StatsigUser object used for the evaluation
+  # @param gate_name The name of the gate being checked
+  def self.check_gate_with_exposure_logging_disabled(user, gate_name)
+    ensure_initialized
+    @shared_instance&.check_gate(user, gate_name, StatsigDriver::CheckGateOptions.new(log_exposure: false))
+  end
+
+  sig { params(user: StatsigUser, gate_name: String).void }
+  ##
+  # Logs an exposure event for the gate
+  #
+  # @param user A StatsigUser object used for the evaluation
+  # @param gate_name The name of the gate being checked
+  def self.manually_log_gate_exposure(user, gate_name)
+    ensure_initialized
+    @shared_instance&.manually_log_gate_exposure(user, gate_name)
+  end
+
   sig { params(user: StatsigUser, dynamic_config_name: String).returns(DynamicConfig) }
   ##
   # Get the values of a dynamic config, evaluated against the given user. An exposure event will automatically be logged for the dynamic config.
@@ -46,6 +68,28 @@ module Statsig
     @shared_instance&.get_config(user, dynamic_config_name)
   end
 
+  sig { params(user: StatsigUser, dynamic_config_name: String).returns(DynamicConfig) }
+  ##
+  # Get the values of a dynamic config, evaluated against the given user.
+  #
+  # @param user A StatsigUser object used for the evaluation
+  # @param dynamic_config_name The name of the dynamic config
+  def self.get_config_with_exposure_logging_disabled(user, dynamic_config_name)
+    ensure_initialized
+    @shared_instance&.get_config(user, dynamic_config_name, StatsigDriver::GetConfigOptions.new(log_exposure: false))
+  end
+
+  sig { params(user: StatsigUser, dynamic_config: String).void }
+  ##
+  # Logs an exposure event for the dynamic config
+  #
+  # @param user A StatsigUser object used for the evaluation
+  # @param dynamic_config_name The name of the dynamic config
+  def self.manually_log_config_exposure(user, dynamic_config)
+    ensure_initialized
+    @shared_instance&.manually_log_config_exposure(user, dynamic_config)
+  end
+
   sig { params(user: StatsigUser, experiment_name: String).returns(DynamicConfig) }
   ##
   # Get the values of an experiment, evaluated against the given user. An exposure event will automatically be logged for the experiment.
@@ -57,6 +101,28 @@ module Statsig
     @shared_instance&.get_experiment(user, experiment_name)
   end
 
+  sig { params(user: StatsigUser, experiment_name: String).returns(DynamicConfig) }
+  ##
+  # Get the values of an experiment, evaluated against the given user.
+  #
+  # @param user A StatsigUser object used for the evaluation
+  # @param experiment_name The name of the experiment
+  def self.get_experiment_with_exposure_logging_disabled(user, experiment_name)
+    ensure_initialized
+    @shared_instance&.get_experiment(user, experiment_name, StatsigDriver::GetExperimentOptions.new(log_exposure: false))
+  end
+
+  sig { params(user: StatsigUser, experiment_name: String).void }
+  ##
+  # Logs an exposure event for the experiment
+  #
+  # @param user A StatsigUser object used for the evaluation
+  # @param experiment_name The name of the experiment
+  def self.manually_log_experiment_exposure(user, experiment_name)
+    ensure_initialized
+    @shared_instance&.manually_log_config_exposure(user, experiment_name)
+  end
+
   sig { params(user: StatsigUser, layer_name: String).returns(Layer) }
   ##
   # Get the values of a layer, evaluated against the given user.
@@ -69,6 +135,29 @@ module Statsig
     @shared_instance&.get_layer(user, layer_name)
   end
 
+  sig { params(user: StatsigUser, layer_name: String).returns(Layer) }
+  ##
+  # Get the values of a layer, evaluated against the given user.
+  #
+  # @param user A StatsigUser object used for the evaluation
+  # @param layer_name The name of the layer
+  def self.get_layer_with_exposure_logging_disabled(user, layer_name)
+    ensure_initialized
+    @shared_instance&.get_layer(user, layer_name, StatsigDriver::GetLayerOptions.new(log_exposure: false))
+  end
+
+  sig { params(user: StatsigUser, layer_name: String, parameter_name: String).returns(Layer) }
+  ##
+  # Logs an exposure event for the parameter in the given layer
+  #
+  # @param user A StatsigUser object used for the evaluation
+  # @param layer_name The name of the layer
+  # @param parameter_name The name of the parameter in the layer
+  def self.manually_log_layer_parameter_exposure(user, layer_name, parameter_name)
+    ensure_initialized
+    @shared_instance&.manually_log_layer_parameter_exposure(user, layer_name, parameter_name)
+  end
+
   sig { params(user: StatsigUser,
                event_name: String,
                value: T.any(String, Integer, Float, NilClass),
@@ -136,7 +225,7 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '1.18.0',
+      'sdkVersion' => '1.19.1',
     }
   end
 

data/lib/statsig_driver.rb

@@ -45,9 +45,13 @@ class StatsigDriver
     })
   end
 
-  sig { params(user: StatsigUser, gate_name: String).returns(T::Boolean) }
+  class CheckGateOptions < T::Struct
+    prop :log_exposure, T::Boolean, default: true
+  end
+
+  sig { params(user: StatsigUser, gate_name: String, options: CheckGateOptions).returns(T::Boolean) }
 
-  def check_gate(user, gate_name)
+  def check_gate(user, gate_name, options = CheckGateOptions.new)
     @err_boundary.capture(-> {
       user = verify_inputs(user, gate_name, "gate_name")
 
@@ -60,7 +64,9 @@ class StatsigDriver
         res = check_gate_fallback(user, gate_name)
         # exposure logged by the server
       else
-        @logger.log_gate_exposure(user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details)
+        if options.log_exposure
+          @logger.log_gate_exposure(user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details)
+        end
       end
 
       res.gate_value
@@ -68,27 +74,55 @@ class StatsigDriver
 
   end
 
-  sig { params(user: StatsigUser, dynamic_config_name: String).returns(DynamicConfig) }
+  sig { params(user: StatsigUser, gate_name: String).void }
 
-  def get_config(user, dynamic_config_name)
+  def manually_log_gate_exposure(user, gate_name)
+    res = @evaluator.check_gate(user, gate_name)
+    context = {'is_manual_exposure' => true}
+    @logger.log_gate_exposure(user, gate_name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details, context)
+  end
+
+  class GetConfigOptions < T::Struct
+    prop :log_exposure, T::Boolean, default: true
+  end
+
+  sig { params(user: StatsigUser, dynamic_config_name: String, options: GetConfigOptions).returns(DynamicConfig) }
+
+  def get_config(user, dynamic_config_name, options = GetConfigOptions.new)
     @err_boundary.capture(-> {
       user = verify_inputs(user, dynamic_config_name, "dynamic_config_name")
-      get_config_impl(user, dynamic_config_name)
+      get_config_impl(user, dynamic_config_name, options)
     }, -> { DynamicConfig.new(dynamic_config_name) })
   end
 
-  sig { params(user: StatsigUser, experiment_name: String).returns(DynamicConfig) }
+  class GetExperimentOptions < T::Struct
+    prop :log_exposure, T::Boolean, default: true
+  end
 
-  def get_experiment(user, experiment_name)
+  sig { params(user: StatsigUser, experiment_name: String, options: GetExperimentOptions).returns(DynamicConfig) }
+
+  def get_experiment(user, experiment_name, options = GetExperimentOptions.new)
     @err_boundary.capture(-> {
       user = verify_inputs(user, experiment_name, "experiment_name")
-      get_config_impl(user, experiment_name)
+      get_config_impl(user, experiment_name, options)
     }, -> { DynamicConfig.new(experiment_name) })
   end
 
-  sig { params(user: StatsigUser, layer_name: String).returns(Layer) }
+  sig { params(user: StatsigUser, config_name: String).void }
 
-  def get_layer(user, layer_name)
+  def manually_log_config_exposure(user, config_name)
+    res = @evaluator.get_config(user, config_name)
+    context = {'is_manual_exposure' => true}
+    @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details, context)
+  end
+
+  class GetLayerOptions < T::Struct
+    prop :log_exposure, T::Boolean, default: true
+  end
+
+  sig { params(user: StatsigUser, layer_name: String, options: GetLayerOptions).returns(Layer) }
+
+  def get_layer(user, layer_name, options = GetLayerOptions.new)
     @err_boundary.capture(-> {
       user = verify_inputs(user, layer_name, "layer_name")
 
@@ -104,15 +138,25 @@ class StatsigDriver
         res = get_config_fallback(user, res.config_delegate)
         # exposure logged by the server
       end
-
-      Layer.new(res.name, res.json_value, res.rule_id, lambda { |layer, parameter_name|
+      
+      exposure_log_func = options.log_exposure ? lambda { |layer, parameter_name|
         @logger.log_layer_exposure(user, layer, parameter_name, res)
-      })
+      } : nil
+      Layer.new(res.name, res.json_value, res.rule_id, exposure_log_func)
     }, -> {
       Layer.new(layer_name)
     })
   end
 
+  sig { params(user: StatsigUser, layer_name: String, parameter_name: String).void }
+
+  def manually_log_layer_parameter_exposure(user, layer_name, parameter_name)
+    res = @evaluator.get_layer(user, layer_name)
+    layer = Layer.new(layer_name, res.json_value, res.rule_id)
+    context = {'is_manual_exposure' => true}
+    @logger.log_layer_exposure(user, layer, parameter_name, res, context)
+  end
+
   def log_event(user, event_name, value = nil, metadata = nil)
     @err_boundary.capture(-> {
       if !user.nil? && !user.instance_of?(StatsigUser)
@@ -186,7 +230,7 @@ class StatsigDriver
     normalize_user(user)
   end
 
-  def get_config_impl(user, config_name)
+  def get_config_impl(user, config_name, options)
     res = @evaluator.get_config(user, config_name)
     if res.nil?
       res = Statsig::ConfigResult.new(config_name)
@@ -196,7 +240,9 @@ class StatsigDriver
       res = get_config_fallback(user, config_name)
       # exposure logged by the server
     else
-      @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details)
+      if options.log_exposure
+        @logger.log_config_exposure(user, res.name, res.rule_id, res.secondary_exposures, res.evaluation_details)
+      end
     end
 
     DynamicConfig.new(res.name, res.json_value, res.rule_id)

data/lib/statsig_logger.rb

@@ -32,7 +32,7 @@ module Statsig
       end
     end
 
-    def log_gate_exposure(user, gate_name, value, rule_id, secondary_exposures, eval_details)
+    def log_gate_exposure(user, gate_name, value, rule_id, secondary_exposures, eval_details, context = nil)
       event = StatsigEvent.new($gate_exposure_event)
       event.user = user
       event.metadata = {
@@ -44,10 +44,11 @@ module Statsig
       event.secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
 
       safe_add_eval_details(eval_details, event)
+      safe_add_exposure_context(context, event)
       log_event(event)
     end
 
-    def log_config_exposure(user, config_name, rule_id, secondary_exposures, eval_details)
+    def log_config_exposure(user, config_name, rule_id, secondary_exposures, eval_details, context = nil)
       event = StatsigEvent.new($config_exposure_event)
       event.user = user
       event.metadata = {
@@ -58,10 +59,11 @@ module Statsig
       event.secondary_exposures = secondary_exposures.is_a?(Array) ? secondary_exposures : []
 
       safe_add_eval_details(eval_details, event)
+      safe_add_exposure_context(context, event)
       log_event(event)
     end
 
-    def log_layer_exposure(user, layer, parameter_name, config_evaluation)
+    def log_layer_exposure(user, layer, parameter_name, config_evaluation, context = nil)
       exposures = config_evaluation.undelegated_sec_exps
       allocated_experiment = ''
       is_explicit = (config_evaluation.explicit_parameters&.include? parameter_name) || false
@@ -83,6 +85,7 @@ module Statsig
       event.secondary_exposures = exposures.is_a?(Array) ? exposures : []
 
       safe_add_eval_details(config_evaluation.evaluation_details, event)
+      safe_add_exposure_context(context, event)
       log_event(event)
     end
 
@@ -144,5 +147,15 @@ module Statsig
       event.metadata['initTime'] = eval_details.init_time
       event.metadata['serverTime'] = eval_details.server_time
     end
+
+    def safe_add_exposure_context(context, event)
+      if context.nil?
+        return
+      end
+
+      if context['is_manual_exposure']
+        event.metadata['isManualExposure'] = 'true'
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 1.18.0
+  version: 1.19.1
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-28 00:00:00.000000000 Z
+date: 2023-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,14 +84,14 @@ dependencies:
   name: tapioca
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.4.27
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.4.27
 - !ruby/object:Gem::Dependency
@@ -146,14 +146,14 @@ dependencies:
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.5.10461
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.5.10461
 - !ruby/object:Gem::Dependency
@@ -215,7 +215,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.11
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Statsig server SDK for Ruby