statsig 1.34.2 → 2.0.0

data/lib/network.rb

@@ -3,7 +3,6 @@ require 'json'
 require 'securerandom'
 require 'zlib'
 
-require 'uri_helper'
 require 'connection_pool'
 
 RETRY_CODES = [408, 500, 502, 503, 504, 522, 524, 599].freeze
@@ -22,7 +21,7 @@ module Statsig
 
     def initialize(server_secret, options, backoff_mult = 10)
       super()
-      URIHelper.initialize(options)
+      @options = options
       @server_secret = server_secret
       @local_mode = options.local_mode
       @timeout = options.network_timeout
@@ -43,6 +42,7 @@ module Statsig
             'Accept-Encoding' => 'gzip'
           }
         ).accept(:json)
+
         if @timeout
           client = client.timeout(@timeout)
         end
@@ -52,18 +52,42 @@ module Statsig
     end
 
     def download_config_specs(since_time)
-      get("download_config_specs/#{@server_secret}.json?sinceTime=#{since_time}")
+      url = @options.download_config_specs_url
+      get("#{url}#{@server_secret}.json?sinceTime=#{since_time}")
+    end
+
+    def post_logs(events, error_boundary)
+      url = @options.log_event_url
+      event_count = events.length
+      json_body = JSON.generate({ events: events, statsigMetadata: Statsig.get_statsig_metadata })
+      gzip = Zlib::GzipWriter.new(StringIO.new)
+      gzip << json_body
+
+      response, e = post(url, gzip.close.string, @post_logs_retry_limit, 1, true, event_count)
+      unless e == nil
+        message = "Failed to log #{event_count} events after #{@post_logs_retry_limit} retries"
+        puts "[Statsig]: #{message}"
+        error_boundary.log_exception(e, tag: 'statsig::log_event_failed', extra: { eventCount: event_count, error: message }, force: true)
+        return
+      end
+    rescue StandardError
+
+    end
+
+    def get_id_lists
+      url = @options.get_id_lists_url
+      post(url, JSON.generate({ 'statsigMetadata' => Statsig.get_statsig_metadata }))
     end
 
-    def get(endpoint, retries = 0, backoff = 1)
-      request(:GET, endpoint, nil, retries, backoff)
+    def get(url, retries = 0, backoff = 1)
+      request(:GET, url, nil, retries, backoff)
     end
 
-    def post(endpoint, body, retries = 0, backoff = 1, zipped = false, event_count = 0)
-      request(:POST, endpoint, body, retries, backoff, zipped, event_count)
+    def post(url, body, retries = 0, backoff = 1, zipped = false, event_count = 0)
+      request(:POST, url, body, retries, backoff, zipped, event_count)
     end
 
-    def request(method, endpoint, body, retries = 0, backoff = 1, zipped = false, event_count = 0)
+    def request(method, url, body, retries = 0, backoff = 1, zipped = false, event_count = 0)
       if @local_mode
         return nil, nil
       end
@@ -75,10 +99,15 @@ module Statsig
           backoff_adjusted = @post_logs_retry_backoff.call(retries)
         end
       end
-      url = URIHelper.build_url(endpoint)
+
       begin
         res = @connection_pool.with do |conn|
-          request = conn.headers('STATSIG-CLIENT-TIME' => (Time.now.to_f * 1000).to_i.to_s, 'CONTENT-ENCODING' => zipped ? 'gzip' : nil, 'STATSIG-EVENT-COUNT' => event_count == 0 ? nil : event_count.to_s)
+          request = conn.headers(
+            'STATSIG-CLIENT-TIME' => (Time.now.to_f * 1000).to_i.to_s,
+            'CONTENT-ENCODING' => zipped ? 'gzip' : nil,
+            'STATSIG-EVENT-COUNT' => event_count == 0 ? nil : event_count.to_s
+          )
+
           case method
           when :GET
             request.get(url)
@@ -91,7 +120,7 @@ module Statsig
         return nil, e unless retries.positive?
 
         sleep backoff_adjusted
-        return request(method, endpoint, body, retries - 1, backoff * @backoff_multiplier, zipped, event_count)
+        return request(method, url, body, retries - 1, backoff * @backoff_multiplier, zipped, event_count)
       end
       return res, nil if res.status.success?
 
@@ -102,23 +131,7 @@ module Statsig
 
       ## status code retry
       sleep backoff_adjusted
-      request(method, endpoint, body, retries - 1, backoff * @backoff_multiplier, zipped, event_count)
-    end
-
-    def post_logs(events, error_boundary)
-      event_count = events.length
-      json_body = JSON.generate({ events: events, statsigMetadata: Statsig.get_statsig_metadata })
-      gzip = Zlib::GzipWriter.new(StringIO.new)
-      gzip << json_body
-      response, e = post('log_event', gzip.close.string, @post_logs_retry_limit, 1, true, event_count)
-      unless e == nil
-        message = "Failed to log #{event_count} events after #{@post_logs_retry_limit} retries"
-        puts "[Statsig]: #{message}"
-        error_boundary.log_exception(e, tag: 'statsig::log_event_failed', extra: { eventCount: event_count, error: message }, force: true)
-        return
-      end
-    rescue StandardError
-
+      request(method, url, body, retries - 1, backoff * @backoff_multiplier, zipped, event_count)
     end
   end
 end

data/lib/spec_store.rb

@@ -33,6 +33,7 @@ module Statsig
       @gates = {}
       @configs = {}
       @layers = {}
+      @condition_map = {}
       @id_lists = {}
       @experiment_to_layer = {}
       @sdk_keys_to_app_ids = {}
@@ -102,33 +103,39 @@ module Statsig
     end
 
     def has_gate?(gate_name)
-      @gates.key?(gate_name)
+      @gates.key?(gate_name.to_sym)
     end
 
     def has_config?(config_name)
-      @configs.key?(config_name)
+      @configs.key?(config_name.to_sym)
     end
 
     def has_layer?(layer_name)
-      @layers.key?(layer_name)
+      @layers.key?(layer_name.to_sym)
     end
 
     def get_gate(gate_name)
-      return nil unless has_gate?(gate_name)
-
-      @gates[gate_name]
+      gate_sym = gate_name.to_sym
+      return nil unless has_gate?(gate_sym)
+      @gates[gate_sym]
     end
 
     def get_config(config_name)
-      return nil unless has_config?(config_name)
+      config_sym = config_name.to_sym
+      return nil unless has_config?(config_sym)
 
-      @configs[config_name]
+      @configs[config_sym]
     end
 
     def get_layer(layer_name)
-      return nil unless has_layer?(layer_name)
+      layer_sym = layer_name.to_sym
+      return nil unless has_layer?(layer_sym)
+
+      @layers[layer_sym]
+    end
 
-      @layers[layer_name]
+    def get_condition(condition_hash)
+      @condition_map[condition_hash.to_sym]
     end
 
     def get_id_list(list_name)
@@ -169,7 +176,7 @@ module Statsig
     end
 
     def sync_config_specs
-      if @options.data_store&.should_be_used_for_querying_updates(Interfaces::IDataStore::CONFIG_SPECS_KEY)
+      if @options.data_store&.should_be_used_for_querying_updates(Interfaces::IDataStore::CONFIG_SPECS_V2_KEY)
         load_config_specs_from_storage_adapter('config_sync')
       else
         download_config_specs('config_sync')
@@ -190,7 +197,7 @@ module Statsig
 
     def load_config_specs_from_storage_adapter(context)
       tracker = @diagnostics.track(context, 'data_store_config_specs', 'fetch')
-      cached_values = @options.data_store.get(Interfaces::IDataStore::CONFIG_SPECS_KEY)
+      cached_values = @options.data_store.get(Interfaces::IDataStore::CONFIG_SPECS_V2_KEY)
       tracker.end(success: true)
       return if cached_values.nil?
 
@@ -204,12 +211,12 @@ module Statsig
       download_config_specs(context)
     end
 
-    def save_config_specs_to_storage_adapter(specs_string)
+    def save_rulesets_to_storage_adapter(rulesets_string)
       if @options.data_store.nil?
         return
       end
 
-      @options.data_store.set(Interfaces::IDataStore::CONFIG_SPECS_KEY, specs_string)
+      @options.data_store.set(Interfaces::IDataStore::CONFIG_SPECS_V2_KEY, rulesets_string)
     end
 
     def spawn_sync_config_specs_thread
@@ -293,50 +300,35 @@ module Statsig
         return false
       end
 
-      @last_config_sync_time = specs_json[:time] || @last_config_sync_time
-      return false unless specs_json[:has_updates] == true &&
-                          !specs_json[:feature_gates].nil? &&
-                          !specs_json[:dynamic_configs].nil? &&
-                          !specs_json[:layer_configs].nil?
+      new_specs_sync_time = specs_json[:time]
+      if new_specs_sync_time.nil? \
+        || new_specs_sync_time < @last_config_sync_time \
+        || specs_json[:has_updates] != true \
+        || specs_json[:feature_gates].nil? \
+        || specs_json[:dynamic_configs].nil? \
+        || specs_json[:layer_configs].nil?
+        return false
+      end
 
-      @unsupported_configs.clear()
-      new_gates = process_configs(specs_json[:feature_gates])
-      new_configs = process_configs(specs_json[:dynamic_configs])
-      new_layers = process_configs(specs_json[:layer_configs])
+      @last_config_sync_time = new_specs_sync_time
+      @unsupported_configs.clear
 
-      new_exp_to_layer = {}
       specs_json[:diagnostics]&.each { |key, value| @diagnostics.sample_rates[key.to_s] = value }
 
-      if specs_json[:layers].is_a?(Hash)
-        specs_json[:layers].each do |layer_name, experiments|
-          experiments.each { |experiment_name| new_exp_to_layer[experiment_name] = layer_name }
-        end
-      end
-
-      @gates = new_gates
-      @configs = new_configs
-      @layers = new_layers
-      @experiment_to_layer = new_exp_to_layer
+      @gates = specs_json[:feature_gates]
+      @configs = specs_json[:dynamic_configs]
+      @layers = specs_json[:layer_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] || {}
       @hashed_sdk_keys_to_app_ids = specs_json[:hashed_sdk_keys_to_app_ids] || {}
 
       unless from_adapter
-        save_config_specs_to_storage_adapter(specs_string)
+        save_rulesets_to_storage_adapter(specs_string)
       end
       true
     end
 
-    def process_configs(configs)
-      configs.each_with_object({}) do |config, new_configs|
-        begin
-          new_configs[config[:name]] = APIConfig.from_json(config)
-        rescue UnsupportedConfigException => e
-          @unsupported_configs.add(config[:name])
-          nil
-        end
-      end
-    end
-
     def get_id_lists_from_adapter(context)
       tracker = @diagnostics.track(context, 'data_store_id_lists', 'fetch')
       cached_values = @options.data_store.get(Interfaces::IDataStore::ID_LISTS_KEY)
@@ -361,7 +353,7 @@ module Statsig
 
     def get_id_lists_from_network(context)
       tracker = @diagnostics.track(context, 'get_id_list_sources', 'network_request')
-      response, e = @network.post('get_id_lists', JSON.generate({ 'statsigMetadata' => Statsig.get_statsig_metadata }))
+      response, e = @network.get_id_lists
       code = response&.status.to_i
       if e.is_a? NetworkError
         code = e.http_code

data/lib/statsig.rb

@@ -363,7 +363,7 @@ module Statsig
   def self.get_statsig_metadata
     {
       'sdkType' => 'ruby-server',
-      'sdkVersion' => '1.34.2',
+      'sdkVersion' => '2.0.0',
       'languageVersion' => RUBY_VERSION
     }
   end

data/lib/statsig_driver.rb

@@ -54,20 +54,25 @@ class StatsigDriver
     if skip_evaluation
       gate = @store.get_gate(gate_name)
       return FeatureGate.new(gate_name) if gate.nil?
-      return FeatureGate.new(gate.name, target_app_ids: gate.target_app_ids)
+      return FeatureGate.new(gate_name, target_app_ids: gate[:targetAppIDs])
     end
 
     user = verify_inputs(user, gate_name, 'gate_name')
-    return Statsig::Memo.for(user.get_memo(), :get_gate_impl, gate_name) do
 
-      res = Statsig::ConfigResult.new(name: gate_name, disable_exposures: disable_log_exposure, disable_evaluation_details: disable_evaluation_details)
+    Statsig::Memo.for(user.get_memo, :get_gate_impl, gate_name) do
+      res = Statsig::ConfigResult.new(
+        name: gate_name,
+        disable_exposures: disable_log_exposure,
+        disable_evaluation_details: disable_evaluation_details
+      )
       @evaluator.check_gate(user, gate_name, res, ignore_local_overrides: ignore_local_overrides)
 
       unless disable_log_exposure
-      @logger.log_gate_exposure(
+        @logger.log_gate_exposure(
           user, res.name, res.gate_value, res.rule_id, res.secondary_exposures, res.evaluation_details
         )
       end
+
       FeatureGate.from_config_result(res)
     end
   end
@@ -162,7 +167,7 @@ class StatsigDriver
     @err_boundary.capture(caller: __method__, recover: -> { Layer.new(layer_name) }) do
       run_with_diagnostics(caller: :get_layer) do
         user = verify_inputs(user, layer_name, "layer_name")
-        Statsig::Memo.for(user.get_memo(), :get_layer, layer_name) do
+        Statsig::Memo.for(user.get_memo, :get_layer, layer_name) do
           exposures_disabled = options&.disable_log_exposure == true
           res = Statsig::ConfigResult.new(
             name: layer_name,
@@ -367,7 +372,7 @@ class StatsigDriver
   end
 
   def get_config_impl(user, config_name, disable_log_exposure, user_persisted_values: nil, disable_evaluation_details: false, ignore_local_overrides: false)
-    return Statsig::Memo.for(user.get_memo(), :get_config_impl, config_name) do
+    Statsig::Memo.for(user.get_memo, :get_config_impl, config_name) do
       res = Statsig::ConfigResult.new(
         name: config_name,
         disable_exposures: disable_log_exposure,

data/lib/statsig_options.rb

@@ -10,13 +10,14 @@ class StatsigOptions
   # eg. { "tier" => "development" }
   attr_accessor :environment
 
-  # The base url used to make network calls to Statsig.
-  # default: https://statsigapi.net/v1
-  attr_accessor :api_url_base
+  # The url used specifically to call download_config_specs.
+  attr_accessor :download_config_specs_url
 
-  # The base url used specifically to call download_config_specs.
-  # Takes precedence over api_url_base
-  attr_accessor :api_url_download_config_specs
+  # The url used specifically to call log_event.
+  attr_accessor :log_event_url
+
+  # The url used specifically to call get_id_lists.
+  attr_accessor :get_id_lists_url
 
   # The interval (in seconds) to poll for changes to your Statsig configuration
   # default: 10s
@@ -89,8 +90,9 @@ class StatsigOptions
 
   def initialize(
     environment = nil,
-    api_url_base = nil,
-    api_url_download_config_specs: nil,
+    download_config_specs_url: nil,
+    log_event_url: nil,
+    get_id_lists_url: nil,
     rulesets_sync_interval: 10,
     idlists_sync_interval: 60,
     disable_rulesets_sync: false,
@@ -111,8 +113,15 @@ class StatsigOptions
     user_persistent_storage: nil
   )
     @environment = environment.is_a?(Hash) ? environment : nil
-    @api_url_base = api_url_base || 'https://statsigapi.net/v1'
-    @api_url_download_config_specs = api_url_download_config_specs || api_url_base || 'https://api.statsigcdn.com/v1'
+
+    dcs_url = download_config_specs_url || 'https://api.statsigcdn.com/v2/download_config_specs/'
+    unless dcs_url.end_with?('/')
+      dcs_url += '/'
+    end
+    @download_config_specs_url = dcs_url
+
+    @log_event_url = log_event_url || 'https://statsigapi.net/v1/log_event'
+    @get_id_lists_url = get_id_lists_url || 'https://statsigapi.net/v1/get_id_lists'
     @rulesets_sync_interval = rulesets_sync_interval
     @idlists_sync_interval = idlists_sync_interval
     @disable_rulesets_sync = disable_rulesets_sync

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statsig
 version: !ruby/object:Gem::Version
-  version: 1.34.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Statsig, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-06-24 00:00:00.000000000 Z
+date: 2024-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: tapioca
   requirement: !ruby/object:Gem::Requirement
@@ -335,7 +349,6 @@ files:
 - lib/statsig_options.rb
 - lib/statsig_user.rb
 - lib/ua_parser.rb
-- lib/uri_helper.rb
 - lib/user_persistent_storage_utils.rb
 homepage: https://rubygems.org/gems/statsig
 licenses:

data/lib/uri_helper.rb

@@ -1,29 +0,0 @@
-class URIHelper
-  class URIBuilder
-
-    attr_accessor :options
-
-    def initialize(options)
-      @options = options
-    end
-
-    def build_url(endpoint)
-      api = @options.api_url_base
-      if endpoint.include?('download_config_specs')
-        api = @options.api_url_download_config_specs
-      end
-      unless api.end_with?('/')
-        api += '/'
-      end
-      "#{api}#{endpoint}"
-    end
-  end
-
-  def self.initialize(options)
-    @uri_builder = URIBuilder.new(options)
-  end
-
-  def self.build_url(endpoint)
-    @uri_builder.build_url(endpoint)
-  end
-end