configcat 3.1.0 → 5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b842d2ff2f62e6a6c3dbe2ddab53c561e4b1db93f3928ce805044127cd2d7819
-  data.tar.gz: 6d64d084c4a732d26d54879d914f4e9ce1722b9e73fee2aa4161cc5503e152d7
+  metadata.gz: 980bb5bf4d92b6a479a10727b25ea488461317569f3b60943642db8fa9960898
+  data.tar.gz: 9de2dc2d9fe881372f70e862bb72af396a9ea99b81defabf3c82e1b19423078e
 SHA512:
-  metadata.gz: 83a7d19dc642e492bb5443a1fc42f0f35db8f5278f02582848e8677133f4450faa41a1a30b158ccdca58bc5396cad109b914fa4851e4db74dcf03df1f5129d00
-  data.tar.gz: 2e79ed9965f3c9da2f8afd9fed4636b6d349b0bda09fdfb0d8398b6e4334a458713114d23083fc5f611878ea02801c5e8ea1e73fad54f6e580ef1c098e8f9d7c
+  metadata.gz: 7d1e19a4729ef760d686a4e47c2efd2d82464adfa652caf2782b4ebcfefc3edc7f27baddfdcdd9e66264ee0cd13d9806a51b8c171d74cdd21b6088073aff0368
+  data.tar.gz: 1640d5a7a23f9af9461ee38bfb6a789cbed6d898c582bb325f18c27b20dec7944c60dbbe9dc749800a0325be844a252225dfb769f89acd157f644bb1d1a93ef9

data/lib/configcat/autopollingcachepolicy.rb

@@ -1,9 +1,10 @@
 require 'configcat/interfaces'
+require 'configcat/constants'
 require 'concurrent'
 
 module ConfigCat
   class AutoPollingCachePolicy < CachePolicy
-    def initialize(config_fetcher, config_cache, poll_interval_seconds=60, max_init_wait_time_seconds=5, on_configuration_changed_callback=nil)
+    def initialize(config_fetcher, config_cache, cache_key, poll_interval_seconds=60, max_init_wait_time_seconds=5, on_configuration_changed_callback=nil)
       if poll_interval_seconds < 1
         poll_interval_seconds = 1
       end
@@ -12,6 +13,7 @@ module ConfigCat
       end
       @_config_fetcher = config_fetcher
       @_config_cache = config_cache
+      @_cache_key = cache_key
       @_poll_interval_seconds = poll_interval_seconds
       @_max_init_wait_time_seconds = max_init_wait_time_seconds
       @_on_configuration_changed_callback = on_configuration_changed_callback
@@ -40,7 +42,7 @@ module ConfigCat
       end
       begin
         @_lock.acquire_read_lock()
-        return @_config_cache.get()
+        return @_config_cache.get(@_cache_key)
       ensure
         @_lock.release_read_lock()
       end
@@ -52,7 +54,7 @@ module ConfigCat
 
         begin
           @_lock.acquire_read_lock()
-          old_configuration = @_config_cache.get()
+          old_configuration = @_config_cache.get(@_cache_key)
         ensure
           @_lock.release_read_lock()
         end
@@ -62,7 +64,7 @@ module ConfigCat
           if configuration != old_configuration
             begin
               @_lock.acquire_write_lock()
-              @_config_cache.set(configuration)
+              @_config_cache.set(@_cache_key, configuration)
               @_initialized = true
             ensure
               @_lock.release_write_lock()
@@ -80,6 +82,9 @@ module ConfigCat
         if !@_initialized && !old_configuration.equal?(nil)
           @_initialized = true
         end
+      rescue Timeout::Error => e
+        ConfigCat.logger.error("Request timed out. Timeout values: [open: %ss, read: %ss]" %
+                               [@_config_fetcher.get_open_timeout(), @_config_fetcher.get_read_timeout()])
       rescue Exception => e
         ConfigCat.logger.error("Double-check your SDK Key at https://app.configcat.com/sdkkey.")
         ConfigCat.logger.error "threw exception #{e.class}:'#{e}'"

data/lib/configcat/configcache.rb

@@ -3,15 +3,15 @@ require 'configcat/interfaces'
 module ConfigCat
   class InMemoryConfigCache < ConfigCache
     def initialize()
-      @_value = nil
+      @_value = {}
     end
 
-    def get()
-      return @_value
+    def get(key)
+      return @_value.fetch(key, nil)
     end
 
-    def set(value)
-      @_value = value
+    def set(key, value)
+      @_value[key] = value
     end
   end
 end

data/lib/configcat/configcatclient.rb

@@ -5,25 +5,43 @@ require 'configcat/autopollingcachepolicy'
 require 'configcat/manualpollingcachepolicy'
 require 'configcat/lazyloadingcachepolicy'
 require 'configcat/rolloutevaluator'
+require 'configcat/datagovernance'
+
 
 module ConfigCat
   KeyValue = Struct.new(:key, :value)
   class ConfigCatClient
+    @@sdk_keys = []
+
     def initialize(sdk_key,
-                   poll_interval_seconds:60,
-                   max_init_wait_time_seconds:5,
-                   on_configuration_changed_callback:nil,
-                   cache_time_to_live_seconds:60,
-                   config_cache_class:nil,
-                   base_url:nil,
-                   proxy_address:nil,
-                   proxy_port:nil,
-                   proxy_user:nil,
-                   proxy_pass:nil)
+                   poll_interval_seconds: 60,
+                   max_init_wait_time_seconds: 5,
+                   on_configuration_changed_callback: nil,
+                   cache_time_to_live_seconds: 60,
+                   config_cache_class: nil,
+                   base_url: nil,
+                   proxy_address: nil,
+                   proxy_port: nil,
+                   proxy_user: nil,
+                   proxy_pass: nil,
+                   open_timeout: 10,
+                   read_timeout: 30,
+                   flag_overrides: nil,
+                   data_governance: DataGovernance::GLOBAL)
       if sdk_key === nil
         raise ConfigCatClientException, "SDK Key is required."
       end
+
+      if @@sdk_keys.include?(sdk_key)
+        ConfigCat.logger.warn("A ConfigCat Client is already initialized with sdk_key %s. "\
+                              "We strongly recommend you to use the ConfigCat Client as "\
+                              "a Singleton object in your application." % sdk_key)
+      else
+        @@sdk_keys.push(sdk_key)
+      end
+
       @_sdk_key = sdk_key
+      @_override_data_source = flag_overrides
 
       if config_cache_class
         @_config_cache = config_cache_class.new()
@@ -31,23 +49,35 @@ module ConfigCat
         @_config_cache = InMemoryConfigCache.new()
       end
 
-      if poll_interval_seconds > 0
-        @_config_fetcher = CacheControlConfigFetcher.new(sdk_key, "p", base_url, proxy_address, proxy_port, proxy_user, proxy_pass)
-        @_cache_policy = AutoPollingCachePolicy.new(@_config_fetcher, @_config_cache, poll_interval_seconds, max_init_wait_time_seconds, on_configuration_changed_callback)
+      if !@_override_data_source.equal?(nil) && @_override_data_source.get_behaviour() == OverrideBehaviour::LOCAL_ONLY
+        @_config_fetcher = nil
+        @_cache_policy = nil
+      elsif poll_interval_seconds > 0
+        @_config_fetcher = CacheControlConfigFetcher.new(sdk_key, "p", base_url: base_url,
+                                                         proxy_address: proxy_address, proxy_port: proxy_port, proxy_user: proxy_user, proxy_pass: proxy_pass,
+                                                         open_timeout: open_timeout, read_timeout: read_timeout,
+                                                         data_governance: data_governance)
+        @_cache_policy = AutoPollingCachePolicy.new(@_config_fetcher, @_config_cache, _get_cache_key(), poll_interval_seconds, max_init_wait_time_seconds, on_configuration_changed_callback)
+      elsif cache_time_to_live_seconds > 0
+        @_config_fetcher = CacheControlConfigFetcher.new(sdk_key, "l", base_url: base_url,
+                                                         proxy_address: proxy_address, proxy_port: proxy_port, proxy_user: proxy_user, proxy_pass: proxy_pass,
+                                                         open_timeout: open_timeout, read_timeout: read_timeout,
+                                                         data_governance: data_governance)
+        @_cache_policy = LazyLoadingCachePolicy.new(@_config_fetcher, @_config_cache, _get_cache_key(), cache_time_to_live_seconds)
       else
-        if cache_time_to_live_seconds > 0
-          @_config_fetcher = CacheControlConfigFetcher.new(sdk_key, "l", base_url, proxy_address, proxy_port, proxy_user, proxy_pass)
-          @_cache_policy = LazyLoadingCachePolicy.new(@_config_fetcher, @_config_cache, cache_time_to_live_seconds)
-        else
-          @_config_fetcher = CacheControlConfigFetcher.new(sdk_key, "m", base_url, proxy_address, proxy_port, proxy_user, proxy_pass)
-          @_cache_policy = ManualPollingCachePolicy.new(@_config_fetcher, @_config_cache)
-        end
+        @_config_fetcher = CacheControlConfigFetcher.new(sdk_key, "m", base_url: base_url,
+                                                         proxy_address: proxy_address, proxy_port: proxy_port, proxy_user: proxy_user, proxy_pass: proxy_pass,
+                                                         open_timeout: open_timeout, read_timeout: read_timeout,
+                                                         data_governance: data_governance)
+        @_cache_policy = ManualPollingCachePolicy.new(@_config_fetcher, @_config_cache, _get_cache_key())
       end
     end
 
     def get_value(key, default_value, user=nil)
-      config = @_cache_policy.get()
+      config = _get_settings()
       if config === nil
+        ConfigCat.logger.warn("Evaluating get_value('%s') failed. Cache is empty. "\
+                              "Returning default_value in your get_value call: [%s]." % [key, default_value.to_s])
         return default_value
       end
       value, variation_id = RolloutEvaluator.evaluate(key, user, default_value, nil, config)
@@ -55,15 +85,19 @@ module ConfigCat
     end
 
     def get_all_keys()
-      config = @_cache_policy.get()
+      config = _get_settings()
       if config === nil
         return []
       end
-      return config.keys
+      feature_flags = config.fetch(FEATURE_FLAGS, nil)
+      if feature_flags === nil
+        return []
+      end
+      return feature_flags.keys
     end
 
     def get_variation_id(key, default_variation_id, user=nil)
-      config = @_cache_policy.get()
+      config = _get_settings()
       if config === nil
         ConfigCat.logger.warn("Evaluating get_variation_id('%s') failed. Cache is empty. "\
                               "Returning default_variation_id in your get_variation_id call: [%s]." %
@@ -87,39 +121,91 @@ module ConfigCat
     end
 
     def get_key_and_value(variation_id)
-      config = @_cache_policy.get()
+      config = _get_settings()
       if config === nil
         ConfigCat.logger.warn("Evaluating get_variation_id('%s') failed. Cache is empty. Returning nil." % variation_id)
         return nil
       end
-      for key, value in config
-        if variation_id == value.fetch(RolloutEvaluator::VARIATION_ID, nil)
-          return KeyValue.new(key, value[RolloutEvaluator::VALUE])
+
+      feature_flags = config.fetch(FEATURE_FLAGS, nil)
+      if feature_flags === nil
+        ConfigCat.logger.warn("Evaluating get_key_and_value('%s') failed. Cache is empty. Returning None." % variation_id)
+        return nil
+      end
+
+      for key, value in feature_flags
+        if variation_id == value.fetch(VARIATION_ID, nil)
+          return KeyValue.new(key, value[VALUE])
         end
 
-        rollout_rules = value.fetch(RolloutEvaluator::ROLLOUT_RULES, [])
+        rollout_rules = value.fetch(ROLLOUT_RULES, [])
         for rollout_rule in rollout_rules
-          if variation_id == rollout_rule.fetch(RolloutEvaluator::VARIATION_ID, nil)
-            return KeyValue.new(key, rollout_rule[RolloutEvaluator::VALUE])
+          if variation_id == rollout_rule.fetch(VARIATION_ID, nil)
+            return KeyValue.new(key, rollout_rule[VALUE])
           end
         end
 
-        rollout_percentage_items = value.fetch(RolloutEvaluator::ROLLOUT_PERCENTAGE_ITEMS, [])
+        rollout_percentage_items = value.fetch(ROLLOUT_PERCENTAGE_ITEMS, [])
         for rollout_percentage_item in rollout_percentage_items
-          if variation_id == rollout_percentage_item.fetch(RolloutEvaluator::VARIATION_ID, nil)
-            return KeyValue.new(key, rollout_percentage_item[RolloutEvaluator::VALUE])
+          if variation_id == rollout_percentage_item.fetch(VARIATION_ID, nil)
+            return KeyValue.new(key, rollout_percentage_item[VALUE])
           end
         end
       end
     end
 
+    def get_all_values(user: nil)
+      keys = get_all_keys()
+      all_values = {}
+      for key in keys
+        value = get_value(key, nil, user)
+        if !value.equal?(nil)
+          all_values[key] = value
+        end
+      end
+      return all_values
+    end
+
     def force_refresh()
       @_cache_policy.force_refresh()
     end
 
     def stop()
-      @_cache_policy.stop()
-      @_config_fetcher.close()
+      @_cache_policy.stop() if @_cache_policy
+      @_config_fetcher.close() if @_config_fetcher
+      @@sdk_keys.delete(@_sdk_key)
+    end
+
+    private
+
+    def _get_settings()
+      if !@_override_data_source.nil?
+        behaviour = @_override_data_source.get_behaviour()
+        if behaviour == OverrideBehaviour::LOCAL_ONLY
+          return @_override_data_source.get_overrides()
+        elsif behaviour == OverrideBehaviour::REMOTE_OVER_LOCAL
+          remote_settings = @_cache_policy.get()
+          local_settings = @_override_data_source.get_overrides()
+          result = local_settings.clone()
+          if remote_settings.key?(FEATURE_FLAGS) && local_settings.key?(FEATURE_FLAGS)
+            result[FEATURE_FLAGS] = result[FEATURE_FLAGS].merge(remote_settings[FEATURE_FLAGS])
+          end
+          return result
+        elsif behaviour == OverrideBehaviour::LOCAL_OVER_REMOTE
+          remote_settings = @_cache_policy.get()
+          local_settings = @_override_data_source.get_overrides()
+          result = remote_settings.clone()
+          if remote_settings.key?(FEATURE_FLAGS) && local_settings.key?(FEATURE_FLAGS)
+            result[FEATURE_FLAGS] = result[FEATURE_FLAGS].merge(local_settings[FEATURE_FLAGS])
+          end
+          return result
+        end
+      end
+      return @_cache_policy.get()
+    end
+
+    def _get_cache_key()
+      return Digest::SHA1.hexdigest("ruby_" + CONFIG_FILE_NAME + "_" + @_sdk_key)
     end
 
   end

data/lib/configcat/configfetcher.rb

@@ -1,13 +1,22 @@
 require 'configcat/interfaces'
 require 'configcat/version'
+require 'configcat/datagovernance'
+require 'configcat/constants'
 require 'net/http'
 require 'uri'
 require 'json'
 
 module ConfigCat
-  BASE_URL = "https://cdn.configcat.com"
+  BASE_URL_GLOBAL = "https://cdn-global.configcat.com"
+  BASE_URL_EU_ONLY = "https://cdn-eu.configcat.com"
   BASE_PATH = "configuration-files/"
-  BASE_EXTENSION = "/config_v4.json"
+  BASE_EXTENSION = "/" + CONFIG_FILE_NAME + ".json"
+
+  class RedirectMode
+    NO_REDIRECT = 0
+    SHOULD_REDIRECT = 1
+    FORCE_REDIRECT = 2
+  end
 
   class FetchResponse
     def initialize(response)
@@ -32,34 +41,100 @@ module ConfigCat
   end
 
   class CacheControlConfigFetcher < ConfigFetcher
-    def initialize(sdk_key, mode, base_url=nil, proxy_address=nil, proxy_port=nil, proxy_user=nil, proxy_pass=nil)
+    def initialize(sdk_key, mode, base_url:nil, proxy_address:nil, proxy_port:nil, proxy_user:nil, proxy_pass:nil,
+                   open_timeout:10, read_timeout:30,
+                   data_governance:DataGovernance::GLOBAL)
       @_sdk_key = sdk_key
+      @_proxy_address = proxy_address
+      @_proxy_port = proxy_port
+      @_proxy_user = proxy_user
+      @_proxy_pass = proxy_pass
+      @_open_timeout = open_timeout
+      @_read_timeout = read_timeout
       @_etag = ""
       @_headers = {"User-Agent" => ((("ConfigCat-Ruby/") + mode) + ("-")) + VERSION, "X-ConfigCat-UserAgent" => ((("ConfigCat-Ruby/") + mode) + ("-")) + VERSION, "Content-Type" => "application/json"}
       if !base_url.equal?(nil)
+        @_base_url_overridden = true
         @_base_url = base_url.chomp("/")
       else
-        @_base_url = BASE_URL
+        @_base_url_overridden = false
+        if data_governance == DataGovernance::EU_ONLY
+          @_base_url = BASE_URL_EU_ONLY
+        else
+          @_base_url = BASE_URL_GLOBAL
+        end
       end
-      uri = URI.parse(@_base_url)
-      @_http = Net::HTTP.new(uri.host, uri.port, proxy_address, proxy_port, proxy_user, proxy_pass)
-      @_http.use_ssl = true if uri.scheme == 'https'
-      @_http.open_timeout = 10 # in seconds
-      @_http.read_timeout = 30 # in seconds
+    end
+
+    def get_open_timeout()
+      return @_open_timeout
+    end
+
+    def get_read_timeout()
+      return @_read_timeout
     end
 
     # Returns the FetchResponse object contains configuration json Dictionary
-    def get_configuration_json()
+    def get_configuration_json(retries=0)
       ConfigCat.logger.debug "Fetching configuration from ConfigCat"
       uri = URI.parse((((@_base_url + ("/")) + BASE_PATH) + @_sdk_key) + BASE_EXTENSION)
       headers = @_headers
       headers["If-None-Match"] = @_etag unless @_etag.empty?
+      _create_http()
       request = Net::HTTP::Get.new(uri.request_uri, headers)
       response = @_http.request(request)
       etag = response["ETag"]
       @_etag = etag unless etag.nil? || etag.empty?
       ConfigCat.logger.debug "ConfigCat configuration json fetch response code:#{response.code} Cached:#{response['ETag']}"
-      return FetchResponse.new(response)
+      fetch_response = FetchResponse.new(response)
+
+      # If there wasn't a config change, we return the response.
+      if !fetch_response.is_fetched()
+        return fetch_response
+      end
+
+      preferences = fetch_response.json().fetch(PREFERENCES, nil)
+      if preferences === nil
+        return fetch_response
+      end
+
+      base_url = preferences.fetch(BASE_URL, nil)
+
+      # If the base_url is the same as the last called one, just return the response.
+      if base_url.equal?(nil) || @_base_url == base_url
+        return fetch_response
+      end
+
+      redirect = preferences.fetch(REDIRECT, nil)
+      # If the base_url is overridden, and the redirect parameter is not 2 (force),
+      # the SDK should not redirect the calls and it just have to return the response.
+      if @_base_url_overridden && redirect != RedirectMode::FORCE_REDIRECT
+        return fetch_response
+      end
+
+      # The next call should use the base_url provided in the config json
+      @_base_url = base_url
+
+      # If the redirect property == 0 (redirect not needed), return the response
+      if redirect == RedirectMode::NO_REDIRECT
+        # Return the response
+        return fetch_response
+      end
+
+      # Try to download again with the new url
+
+      if redirect == RedirectMode::SHOULD_REDIRECT
+        ConfigCat.logger.warn("Your data_governance parameter at ConfigCatClient initialization is not in sync with your preferences on the ConfigCat Dashboard: https://app.configcat.com/organization/data-governance. Only Organization Admins can set this preference.")
+      end
+
+      # To prevent loops we check if we retried at least 3 times with the new base_url
+      if retries >= 2
+        ConfigCat.logger.error("Redirect loop during config.json fetch. Please contact support@configcat.com.")
+        return fetch_response
+      end
+
+      # Retry the config download with the new base_url
+      return get_configuration_json(retries + 1)
     end
 
     def close()
@@ -67,5 +142,19 @@ module ConfigCat
         @_http = nil
       end
     end
+
+    private
+
+    def _create_http()
+      uri = URI.parse(@_base_url)
+      use_ssl = true if uri.scheme == 'https'
+      if @_http.equal?(nil) || @_http.address != uri.host || @_http.port != uri.port || @_http.use_ssl? != use_ssl
+        close()
+        @_http = Net::HTTP.new(uri.host, uri.port, @_proxy_address, @_proxy_port, @_proxy_user, @_proxy_pass)
+        @_http.use_ssl = use_ssl
+        @_http.open_timeout = @_open_timeout
+        @_http.read_timeout = @_read_timeout
+      end
+    end
   end
 end

data/lib/configcat/constants.rb

@@ -0,0 +1,17 @@
+module ConfigCat
+  CONFIG_FILE_NAME = "config_v5"
+
+  PREFERENCES = "p"
+  BASE_URL = "u"
+  REDIRECT = "r"
+
+  FEATURE_FLAGS = "f"
+  VALUE = "v"
+  COMPARATOR = "t"
+  COMPARISON_ATTRIBUTE = "a"
+  COMPARISON_VALUE = "c"
+  ROLLOUT_PERCENTAGE_ITEMS = "p"
+  PERCENTAGE = "p"
+  ROLLOUT_RULES = "r"
+  VARIATION_ID = "i"
+end

data/lib/configcat/datagovernance.rb

@@ -0,0 +1,10 @@
+module ConfigCat
+  class DataGovernance
+    # Control the location of the config.json files containing your feature flags
+    # and settings within the ConfigCat CDN.
+    # Global: Select this if your feature flags are published to all global CDN nodes.
+    # EuOnly: Select this if your feature flags are published to CDN nodes only in the EU.
+    GLOBAL = 0
+    EU_ONLY = 1
+  end
+end

data/lib/configcat/interfaces.rb

@@ -23,13 +23,13 @@ module ConfigCat
     #       Config cache interface
     #
 
-    def get()
+    def get(key)
       #
       #     :returns the config json object from the cache
       #
     end
 
-    def set(value)
+    def set(key, value)
       #
       #     Sets the config json cache.
       #

data/lib/configcat/lazyloadingcachepolicy.rb

@@ -1,15 +1,18 @@
 require 'configcat/interfaces'
+require 'configcat/constants'
 require 'concurrent'
 
+
 module ConfigCat
   class LazyLoadingCachePolicy < CachePolicy
 
-    def initialize(config_fetcher, config_cache, cache_time_to_live_seconds=60)
+    def initialize(config_fetcher, config_cache, cache_key, cache_time_to_live_seconds=60)
       if cache_time_to_live_seconds < 1
         cache_time_to_live_seconds = 1
       end
       @_config_fetcher = config_fetcher
       @_config_cache = config_cache
+      @_cache_key = cache_key
       @_cache_time_to_live = cache_time_to_live_seconds
       @_lock = Concurrent::ReadWriteLock.new()
       @_last_updated = nil
@@ -20,7 +23,7 @@ module ConfigCat
         @_lock.acquire_read_lock()
         utc_now = Time.now.utc
         if !@_last_updated.equal?(nil) && (@_last_updated + @_cache_time_to_live > utc_now)
-          config = @_config_cache.get()
+          config = @_config_cache.get(@_cache_key)
           if !config.equal?(nil)
             return config
           end
@@ -31,7 +34,7 @@ module ConfigCat
       force_refresh()
       begin
         @_lock.acquire_read_lock()
-        config = @_config_cache.get()
+        config = @_config_cache.get(@_cache_key)
         return config
       ensure
         @_lock.release_read_lock()
@@ -45,7 +48,7 @@ module ConfigCat
           configuration = configuration_response.json()
           begin
             @_lock.acquire_write_lock()
-            @_config_cache.set(configuration)
+            @_config_cache.set(@_cache_key, configuration)
             @_last_updated = Time.now.utc
           ensure
             @_lock.release_write_lock()

data/lib/configcat/localdictionarydatasource.rb

@@ -0,0 +1,20 @@
+require 'configcat/overridedatasource'
+require 'configcat/constants'
+
+
+module ConfigCat
+  class LocalDictionaryDataSource < OverrideDataSource
+    def initialize(source, override_behaviour)
+      super(override_behaviour)
+      dictionary = {}
+      source.each do |key, value|
+        dictionary[key] = {VALUE => value}
+      end
+      @_settings = {FEATURE_FLAGS => dictionary}
+    end
+
+    def get_overrides()
+      return @_settings
+    end
+  end
+end

data/lib/configcat/localfiledatasource.rb

@@ -0,0 +1,49 @@
+require 'configcat/overridedatasource'
+require 'configcat/constants'
+
+
+module ConfigCat
+  class LocalFileDataSource < OverrideDataSource
+    def initialize(file_path, override_behaviour)
+      super(override_behaviour)
+      if File.exists?(file_path)
+        ConfigCat.logger.error("The file '%s' does not exists." % file_path)
+      end
+      @_file_path = file_path
+      @_settings = nil
+      @_cached_file_stamp = 0
+    end
+
+    def get_overrides()
+      reload_file_content()
+      return @_settings
+    end
+
+    private
+
+    def reload_file_content()
+      begin
+        stamp = File.mtime(@_file_path)
+        if stamp != @_cached_file_stamp
+          @_cached_file_stamp = stamp
+          file = File.read(@_file_path)
+          data = JSON.parse(file)
+          if data.key?("flags")
+            dictionary = {}
+            source = data["flags"]
+            source.each do |key, value|
+              dictionary[key] = {VALUE => value}
+            end
+            @_settings = {FEATURE_FLAGS => dictionary}
+          else
+            @_settings = data
+          end
+        end
+      rescue JSON::ParserError => e
+        ConfigCat.logger.error("Could not decode json from file %s. %s" % [@_file_path, e.to_s])
+      rescue Exception => e
+        ConfigCat.logger.error("Could not read the content of the file %s. %s" % [@_file_path, e.to_s])
+      end
+    end
+  end
+end

data/lib/configcat/manualpollingcachepolicy.rb

@@ -1,18 +1,20 @@
 require 'configcat/interfaces'
+require 'configcat/constants'
 require 'concurrent'
 
 module ConfigCat
   class ManualPollingCachePolicy < CachePolicy
-    def initialize(config_fetcher, config_cache)
+    def initialize(config_fetcher, config_cache, cache_key)
       @_config_fetcher = config_fetcher
       @_config_cache = config_cache
+      @_cache_key = cache_key
       @_lock = Concurrent::ReadWriteLock.new()
     end
 
     def get()
       begin
         @_lock.acquire_read_lock()
-        config = @_config_cache.get()
+        config = @_config_cache.get(@_cache_key)
         return config
       ensure
         @_lock.release_read_lock()
@@ -26,7 +28,7 @@ module ConfigCat
           configuration = configuration_response.json()
           begin
             @_lock.acquire_write_lock()
-            @_config_cache.set(configuration)
+            @_config_cache.set(@_cache_key, configuration)
           ensure
             @_lock.release_write_lock()
           end

data/lib/configcat/overridedatasource.rb

@@ -0,0 +1,32 @@
+module ConfigCat
+  class OverrideBehaviour
+    # When evaluating values, the SDK will not use feature flags & settings from the ConfigCat CDN, but it will use
+    # all feature flags & settings that are loaded from local-override sources.
+    LOCAL_ONLY = 0
+
+    # When evaluating values, the SDK will use all feature flags & settings that are downloaded from the ConfigCat CDN,
+    # plus all feature flags & settings that are loaded from local-override sources. If a feature flag or a setting is
+    # defined both in the fetched and the local-override source then the local-override version will take precedence.
+    LOCAL_OVER_REMOTE = 1
+
+    # When evaluating values, the SDK will use all feature flags & settings that are downloaded from the ConfigCat CDN,
+    # plus all feature flags & settings that are loaded from local-override sources. If a feature flag or a setting is
+    # defined both in the fetched and the local-override source then the fetched version will take precedence.
+    REMOTE_OVER_LOCAL = 2
+  end
+
+  class OverrideDataSource
+    def initialize(override_behaviour)
+      @_override_behaviour = override_behaviour
+    end
+
+    def get_behaviour()
+      return @_override_behaviour
+    end
+
+    def get_overrides()
+      # :returns the override dictionary
+      return {}
+    end
+  end
+end

data/lib/configcat/rolloutevaluator.rb

@@ -1,4 +1,5 @@
 require 'configcat/user'
+require 'configcat/constants'
 require 'digest'
 require 'semantic'
 
@@ -6,21 +7,18 @@ module ConfigCat
   class RolloutEvaluator
     COMPARATOR_TEXTS = ["IS ONE OF", "IS NOT ONE OF", "CONTAINS", "DOES NOT CONTAIN", "IS ONE OF (SemVer)", "IS NOT ONE OF (SemVer)", "< (SemVer)", "<= (SemVer)", "> (SemVer)", ">= (SemVer)", "= (Number)", "<> (Number)", "< (Number)", "<= (Number)", "> (Number)", ">= (Number)"]
 
-    VALUE = "v"
-    COMPARATOR = "t"
-    COMPARISON_ATTRIBUTE = "a"
-    COMPARISON_VALUE = "c"
-    ROLLOUT_PERCENTAGE_ITEMS = "p"
-    PERCENTAGE = "p"
-    ROLLOUT_RULES = "r"
-    VARIATION_ID = "i"
-
     def self.evaluate(key, user, default_value, default_variation_id, config)
       ConfigCat.logger.info("Evaluating get_value('%s')." % key)
 
-      setting_descriptor = config.fetch(key, nil)
+      feature_flags = config.fetch(FEATURE_FLAGS, nil)
+      if feature_flags === nil
+        ConfigCat.logger.error("Evaluating get_value('%s') failed. Value not found for key '%s' Returning default_value: [%s]." % [key, key, default_value.to_s])
+        return default_value, default_variation_id
+      end
+
+      setting_descriptor = feature_flags.fetch(key, nil)
       if setting_descriptor === nil
-        ConfigCat.logger.error("Evaluating get_value('%s') failed. Value not found for key '%s'. Returning default_value: [%s]. Here are the available keys: %s" % [key, key, default_value.to_s, config.keys.join(", ")])
+        ConfigCat.logger.error("Evaluating get_value('%s') failed. Value not found for key '%s'. Returning default_value: [%s]. Here are the available keys: %s" % [key, key, default_value.to_s, feature_flags.keys.join(", ")])
         return default_value, default_variation_id
       end
 
@@ -41,132 +39,142 @@ module ConfigCat
         return return_value, return_variation_id
       end
 
-      ConfigCat.logger.info("User object:\n%s" % user.to_s)
+      log_entries = ["Evaluating get_value('%s')." % key, "User object:\n%s" % user.to_s]
 
-      # Evaluate targeting rules
-      for rollout_rule in rollout_rules
-        comparison_attribute = rollout_rule.fetch(COMPARISON_ATTRIBUTE)
-        comparison_value = rollout_rule.fetch(COMPARISON_VALUE, nil)
-        comparator = rollout_rule.fetch(COMPARATOR, nil)
+      begin
+        # Evaluate targeting rules
+        for rollout_rule in rollout_rules
+          comparison_attribute = rollout_rule.fetch(COMPARISON_ATTRIBUTE)
+          comparison_value = rollout_rule.fetch(COMPARISON_VALUE, nil)
+          comparator = rollout_rule.fetch(COMPARATOR, nil)
 
-        user_value = user.get_attribute(comparison_attribute)
-        if user_value === nil || !user_value
-          ConfigCat.logger.info(format_no_match_rule(comparison_attribute, user_value, comparator, comparison_value))
-          next
-        end
+          user_value = user.get_attribute(comparison_attribute)
+          if user_value === nil || !user_value
+            log_entries.push(format_no_match_rule(comparison_attribute, user_value, comparator, comparison_value))
+            next
+          end
 
-        value = rollout_rule.fetch(VALUE, nil)
-        variation_id = rollout_rule.fetch(VARIATION_ID, default_variation_id)
+          value = rollout_rule.fetch(VALUE, nil)
+          variation_id = rollout_rule.fetch(VARIATION_ID, default_variation_id)
 
-        # IS ONE OF
-        if comparator == 0
-          if comparison_value.to_s.split(",").map { |x| x.strip() }.include?(user_value.to_s)
-            ConfigCat.logger.info(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
-            return value, variation_id
-          end
-        # IS NOT ONE OF
-        elsif comparator == 1
-          if !comparison_value.to_s.split(",").map { |x| x.strip() }.include?(user_value.to_s)
-            ConfigCat.logger.info(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
-            return value, variation_id
-          end
-        # CONTAINS
-        elsif comparator == 2
-          if user_value.to_s.include?(comparison_value.to_s)
-            ConfigCat.logger.info(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
-            return value, variation_id
-          end
-        # DOES NOT CONTAIN
-        elsif comparator == 3
-          if !user_value.to_s.include?(comparison_value.to_s)
-            ConfigCat.logger.info(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
-            return value, variation_id
-          end
-        # IS ONE OF, IS NOT ONE OF (Semantic version)
-        elsif (4 <= comparator) && (comparator <= 5)
-          begin
-            match = false
-            user_value_version = Semantic::Version.new(user_value.to_s.strip())
-            ((comparison_value.to_s.split(",").map { |x| x.strip() }).reject { |c| c.empty? }).each { |x|
-              version = Semantic::Version.new(x)
-              match = (user_value_version == version) || match
-            }
-            if match && comparator == 4 || !match && comparator == 5
-              ConfigCat.logger.info(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
+          # IS ONE OF
+          if comparator == 0
+            if comparison_value.to_s.split(",").map { |x| x.strip() }.include?(user_value.to_s)
+              log_entries.push(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
               return value, variation_id
             end
-          rescue ArgumentError => e
-            ConfigCat.logger.warn(format_validation_error_rule(comparison_attribute, user_value, comparator, comparison_value, e.to_s))
-            next
-          end
-        # LESS THAN, LESS THAN OR EQUALS TO, GREATER THAN, GREATER THAN OR EQUALS TO (Semantic version)
-        elsif (6 <= comparator) && (comparator <= 9)
-          begin
-            user_value_version = Semantic::Version.new(user_value.to_s.strip())
-            comparison_value_version = Semantic::Version.new(comparison_value.to_s.strip())
-            if (comparator == 6 && user_value_version < comparison_value_version) ||
-               (comparator == 7 && user_value_version <= comparison_value_version) ||
-               (comparator == 8 && user_value_version > comparison_value_version) ||
-               (comparator == 9 && user_value_version >= comparison_value_version)
-              ConfigCat.logger.info(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
+          # IS NOT ONE OF
+          elsif comparator == 1
+            if !comparison_value.to_s.split(",").map { |x| x.strip() }.include?(user_value.to_s)
+              log_entries.push(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
               return value, variation_id
             end
-          rescue ArgumentError => e
-            ConfigCat.logger.warn(format_validation_error_rule(comparison_attribute, user_value, comparator, comparison_value, e.to_s))
-            next
-          end
-        elsif (10 <= comparator) && (comparator <= 15)
-          begin
-            user_value_float = Float(user_value.to_s.gsub(",", "."))
-            comparison_value_float = Float(comparison_value.to_s.gsub(",", "."))
-            if (comparator == 10 && user_value_float == comparison_value_float) ||
-               (comparator == 11 && user_value_float != comparison_value_float) ||
-               (comparator == 12 && user_value_float < comparison_value_float) ||
-               (comparator == 13 && user_value_float <= comparison_value_float) ||
-               (comparator == 14 && user_value_float > comparison_value_float) ||
-               (comparator == 15 && user_value_float >= comparison_value_float)
-              ConfigCat.logger.info(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
+          # CONTAINS
+          elsif comparator == 2
+            if user_value.to_s.include?(comparison_value.to_s)
+              log_entries.push(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
+              return value, variation_id
+            end
+          # DOES NOT CONTAIN
+          elsif comparator == 3
+            if !user_value.to_s.include?(comparison_value.to_s)
+              log_entries.push(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
+              return value, variation_id
+            end
+          # IS ONE OF, IS NOT ONE OF (Semantic version)
+          elsif (4 <= comparator) && (comparator <= 5)
+            begin
+              match = false
+              user_value_version = Semantic::Version.new(user_value.to_s.strip())
+              ((comparison_value.to_s.split(",").map { |x| x.strip() }).reject { |c| c.empty? }).each { |x|
+                version = Semantic::Version.new(x)
+                match = (user_value_version == version) || match
+              }
+              if match && comparator == 4 || !match && comparator == 5
+                log_entries.push(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
+                return value, variation_id
+              end
+            rescue ArgumentError => e
+              message = format_validation_error_rule(comparison_attribute, user_value, comparator, comparison_value, e.to_s)
+              ConfigCat.logger.warn(message)
+              log_entries.push(message)
+              next
+            end
+          # LESS THAN, LESS THAN OR EQUALS TO, GREATER THAN, GREATER THAN OR EQUALS TO (Semantic version)
+          elsif (6 <= comparator) && (comparator <= 9)
+            begin
+              user_value_version = Semantic::Version.new(user_value.to_s.strip())
+              comparison_value_version = Semantic::Version.new(comparison_value.to_s.strip())
+              if (comparator == 6 && user_value_version < comparison_value_version) ||
+                 (comparator == 7 && user_value_version <= comparison_value_version) ||
+                 (comparator == 8 && user_value_version > comparison_value_version) ||
+                 (comparator == 9 && user_value_version >= comparison_value_version)
+                log_entries.push(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
+                return value, variation_id
+              end
+            rescue ArgumentError => e
+              message = format_validation_error_rule(comparison_attribute, user_value, comparator, comparison_value, e.to_s)
+              ConfigCat.logger.warn(message)
+              log_entries.push(message)
+              next
+            end
+          elsif (10 <= comparator) && (comparator <= 15)
+            begin
+              user_value_float = Float(user_value.to_s.gsub(",", "."))
+              comparison_value_float = Float(comparison_value.to_s.gsub(",", "."))
+              if (comparator == 10 && user_value_float == comparison_value_float) ||
+                 (comparator == 11 && user_value_float != comparison_value_float) ||
+                 (comparator == 12 && user_value_float < comparison_value_float) ||
+                 (comparator == 13 && user_value_float <= comparison_value_float) ||
+                 (comparator == 14 && user_value_float > comparison_value_float) ||
+                 (comparator == 15 && user_value_float >= comparison_value_float)
+                log_entries.push(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
+                return value, variation_id
+              end
+            rescue Exception => e
+              message = format_validation_error_rule(comparison_attribute, user_value, comparator, comparison_value, e.to_s)
+              ConfigCat.logger.warn(message)
+              log_entries.push(message)
+              next
+            end
+          # IS ONE OF (Sensitive)
+          elsif comparator == 16
+            if comparison_value.to_s.split(",").map { |x| x.strip() }.include?(Digest::SHA1.hexdigest(user_value).to_s)
+              log_entries.push(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
+              return value, variation_id
+            end
+          # IS NOT ONE OF (Sensitive)
+          elsif comparator == 17
+            if !comparison_value.to_s.split(",").map { |x| x.strip() }.include?(Digest::SHA1.hexdigest(user_value).to_s)
+              log_entries.push(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
               return value, variation_id
             end
-          rescue Exception => e
-            ConfigCat.logger.warn(format_validation_error_rule(comparison_attribute, user_value, comparator, comparison_value, e.to_s))
-            next
-          end
-        # IS ONE OF (Sensitive)
-        elsif comparator == 16
-          if comparison_value.to_s.split(",").map { |x| x.strip() }.include?(Digest::SHA1.hexdigest(user_value).to_s)
-            ConfigCat.logger.info(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
-            return value, variation_id
-          end
-        # IS NOT ONE OF (Sensitive)
-        elsif comparator == 17
-          if !comparison_value.to_s.split(",").map { |x| x.strip() }.include?(Digest::SHA1.hexdigest(user_value).to_s)
-            ConfigCat.logger.info(format_match_rule(comparison_attribute, user_value, comparator, comparison_value, value))
-            return value, variation_id
           end
+          log_entries.push(format_no_match_rule(comparison_attribute, user_value, comparator, comparison_value))
         end
-        ConfigCat.logger.info(format_no_match_rule(comparison_attribute, user_value, comparator, comparison_value))
-      end
 
-      if rollout_percentage_items.size > 0
-        user_key = user.get_identifier()
-        hash_candidate = ("%s%s" % [key, user_key]).encode("utf-8")
-        hash_val = Digest::SHA1.hexdigest(hash_candidate)[0...7].to_i(base=16) % 100
-        bucket = 0
-        for rollout_percentage_item in rollout_percentage_items || []
-          bucket += rollout_percentage_item.fetch(PERCENTAGE, 0)
-          if hash_val < bucket
-            percentage_value = rollout_percentage_item.fetch(VALUE, nil)
-            variation_id = rollout_percentage_item.fetch(VARIATION_ID, default_variation_id)
-            ConfigCat.logger.info("Evaluating %% options. Returning %s" % percentage_value)
-            return percentage_value, variation_id
+        if rollout_percentage_items.size > 0
+          user_key = user.get_identifier()
+          hash_candidate = ("%s%s" % [key, user_key]).encode("utf-8")
+          hash_val = Digest::SHA1.hexdigest(hash_candidate)[0...7].to_i(base=16) % 100
+          bucket = 0
+          for rollout_percentage_item in rollout_percentage_items || []
+            bucket += rollout_percentage_item.fetch(PERCENTAGE, 0)
+            if hash_val < bucket
+              percentage_value = rollout_percentage_item.fetch(VALUE, nil)
+              variation_id = rollout_percentage_item.fetch(VARIATION_ID, default_variation_id)
+              log_entries.push("Evaluating %% options. Returning %s" % percentage_value)
+              return percentage_value, variation_id
+            end
           end
         end
+        return_value = setting_descriptor.fetch(VALUE, default_value)
+        return_variation_id = setting_descriptor.fetch(VARIATION_ID, default_variation_id)
+        log_entries.push("Returning %s" % return_value)
+        return return_value, return_variation_id
+      ensure
+        ConfigCat.logger.info(log_entries.join("\n"))
       end
-      return_value = setting_descriptor.fetch(VALUE, default_value)
-      return_variation_id = setting_descriptor.fetch(VARIATION_ID, default_variation_id)
-      ConfigCat.logger.info("Returning %s" % return_value)
-      return return_value, return_variation_id
     end
 
     private

data/lib/configcat/user.rb

@@ -32,6 +32,25 @@ module ConfigCat
       end
       return nil
     end
+
+    def to_s()
+      r = %Q({\n    "Identifier": "#{@__identifier}")
+      if !@__data["Email"].equal?(nil)
+        r += %Q(,\n    "Email": "#{@__data["Email"]}")
+      end
+      if !@__data["Country"].equal?(nil)
+        r += %Q(,\n    "Country": "#{@__data["Country"]}")
+      end
+      if !@__custom.equal?(nil)
+        r += %Q(,\n    "Custom": {)
+        for customField in @__custom
+          r += %Q(\n        "#{customField}": "#{@__custom[customField]}",)
+        end
+        r += "\n    }"
+      end
+      r += "\n}"
+      return r
+    end
   end
 
 end

data/lib/configcat/version.rb

@@ -1,3 +1,3 @@
 module ConfigCat
-  VERSION = "3.1.0"
+  VERSION = "5.0.1"
 end

data/lib/configcat.rb

@@ -1,4 +1,6 @@
 require 'configcat/interfaces'
+require 'configcat/localdictionarydatasource'
+require 'configcat/localfiledatasource'
 require 'configcat/configcatclient'
 require 'configcat/user'
 require 'logger'
@@ -10,13 +12,17 @@ module ConfigCat
     attr_accessor :logger
   end
 
-  def ConfigCat.create_client(sdk_key)
+  def ConfigCat.create_client(sdk_key, data_governance: DataGovernance::GLOBAL)
     #
     #   Create an instance of ConfigCatClient and setup Auto Poll mode with default options
     #
     #   :param sdk_key: ConfigCat SDK Key to access your configuration.
+    #   :param data_governance:
+    #   Default: Global. Set this parameter to be in sync with the Data Governance preference on the Dashboard:
+    #   https://app.configcat.com/organization/data-governance
+    #   (Only Organization Admins have access)
     #
-    return create_client_with_auto_poll(sdk_key)
+    return create_client_with_auto_poll(sdk_key, data_governance: data_governance)
   end
 
   def ConfigCat.create_client_with_auto_poll(sdk_key,
@@ -25,10 +31,14 @@ module ConfigCat
                                              on_configuration_changed_callback: nil,
                                              config_cache_class: nil,
                                              base_url: nil,
-                                             proxy_address:nil,
-                                             proxy_port:nil,
-                                             proxy_user:nil,
-                                             proxy_pass:nil)
+                                             proxy_address: nil,
+                                             proxy_port: nil,
+                                             proxy_user: nil,
+                                             proxy_pass: nil,
+                                             open_timeout: 10,
+                                             read_timeout: 30,
+                                             flag_overrides: nil,
+                                             data_governance: DataGovernance::GLOBAL)
     #
     #   Create an instance of ConfigCatClient and setup Auto Poll mode with custom options
     #
@@ -43,6 +53,13 @@ module ConfigCat
     #   :param proxy_port: Proxy port
     #   :param proxy_user: username for proxy authentication
     #   :param proxy_pass: password for proxy authentication
+    #   :param open_timeout: The number of seconds to wait for the server to make the initial connection. Default: 10 seconds.
+    #   :param read_timeout: The number of seconds to wait for the server to respond before giving up. Default: 30 seconds.
+    #   :param flag_overrides: An OverrideDataSource implementation used to override feature flags & settings.
+    #   :param data_governance:
+    #   Default: Global. Set this parameter to be in sync with the Data Governance preference on the Dashboard:
+    #   https://app.configcat.com/organization/data-governance
+    #   (Only Organization Admins have access)
     #
     if sdk_key === nil
       raise ConfigCatClientException, "SDK Key is required."
@@ -63,17 +80,25 @@ module ConfigCat
                                proxy_address: proxy_address,
                                proxy_port: proxy_port,
                                proxy_user: proxy_user,
-                               proxy_pass: proxy_pass)
+                               proxy_pass: proxy_pass,
+                               open_timeout: open_timeout,
+                               read_timeout: read_timeout,
+                               flag_overrides: flag_overrides,
+                               data_governance: data_governance)
   end
 
   def ConfigCat.create_client_with_lazy_load(sdk_key,
                                              cache_time_to_live_seconds: 60,
                                              config_cache_class: nil,
                                              base_url: nil,
-                                             proxy_address:nil,
-                                             proxy_port:nil,
-                                             proxy_user:nil,
-                                             proxy_pass:nil)
+                                             proxy_address: nil,
+                                             proxy_port: nil,
+                                             proxy_user: nil,
+                                             proxy_pass: nil,
+                                             open_timeout: 10,
+                                             read_timeout: 30,
+                                             flag_overrides: nil,
+                                             data_governance: DataGovernance::GLOBAL)
     #
     #   Create an instance of ConfigCatClient and setup Lazy Load mode with custom options
     #
@@ -86,6 +111,13 @@ module ConfigCat
     #   :param proxy_port: Proxy port
     #   :param proxy_user: username for proxy authentication
     #   :param proxy_pass: password for proxy authentication
+    #   :param open_timeout: The number of seconds to wait for the server to make the initial connection. Default: 10 seconds.
+    #   :param read_timeout: The number of seconds to wait for the server to respond before giving up. Default: 30 seconds.
+    #   :param flag_overrides: An OverrideDataSource implementation used to override feature flags & settings.
+    #   :param data_governance:
+    #   Default: Global. Set this parameter to be in sync with the Data Governance preference on the Dashboard:
+    #   https://app.configcat.com/organization/data-governance
+    #   (Only Organization Admins have access)
     #
     if sdk_key === nil
       raise ConfigCatClientException, "SDK Key is required."
@@ -103,16 +135,24 @@ module ConfigCat
                                proxy_address: proxy_address,
                                proxy_port: proxy_port,
                                proxy_user: proxy_user,
-                               proxy_pass: proxy_pass)
+                               proxy_pass: proxy_pass,
+                               open_timeout: open_timeout,
+                               read_timeout: read_timeout,
+                               flag_overrides: flag_overrides,
+                               data_governance: data_governance)
   end
 
   def ConfigCat.create_client_with_manual_poll(sdk_key,
                                                config_cache_class: nil,
                                                base_url: nil,
-                                               proxy_address:nil,
-                                               proxy_port:nil,
-                                               proxy_user:nil,
-                                               proxy_pass:nil)
+                                               proxy_address: nil,
+                                               proxy_port: nil,
+                                               proxy_user: nil,
+                                               proxy_pass: nil,
+                                               open_timeout: 10,
+                                               read_timeout: 30,
+                                               flag_overrides: nil,
+                                               data_governance: DataGovernance::GLOBAL)
     #
     #   Create an instance of ConfigCatClient and setup Manual Poll mode with custom options
     #
@@ -124,6 +164,13 @@ module ConfigCat
     #   :param proxy_port: Proxy port
     #   :param proxy_user: username for proxy authentication
     #   :param proxy_pass: password for proxy authentication
+    #   :param open_timeout: The number of seconds to wait for the server to make the initial connection. Default: 10 seconds.
+    #   :param read_timeout: The number of seconds to wait for the server to respond before giving up. Default: 30 seconds.
+    #   :param flag_overrides: An OverrideDataSource implementation used to override feature flags & settings.
+    #   :param data_governance:
+    #   Default: Global. Set this parameter to be in sync with the Data Governance preference on the Dashboard:
+    #   https://app.configcat.com/organization/data-governance
+    #   (Only Organization Admins have access)
     #
     if sdk_key === nil
       raise ConfigCatClientException, "SDK Key is required."
@@ -138,7 +185,11 @@ module ConfigCat
                                proxy_address: proxy_address,
                                proxy_port: proxy_port,
                                proxy_user: proxy_user,
-                               proxy_pass: proxy_pass)
+                               proxy_pass: proxy_pass,
+                               open_timeout: open_timeout,
+                               read_timeout: read_timeout,
+                               flag_overrides: flag_overrides,
+                               data_governance: data_governance)
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: configcat
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 5.0.1
 platform: ruby
 authors:
 - ConfigCat
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-14 00:00:00.000000000 Z
+date: 2022-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -67,19 +67,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '12.3'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: codecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -110,9 +110,14 @@ files:
 - lib/configcat/configcache.rb
 - lib/configcat/configcatclient.rb
 - lib/configcat/configfetcher.rb
+- lib/configcat/constants.rb
+- lib/configcat/datagovernance.rb
 - lib/configcat/interfaces.rb
 - lib/configcat/lazyloadingcachepolicy.rb
+- lib/configcat/localdictionarydatasource.rb
+- lib/configcat/localfiledatasource.rb
 - lib/configcat/manualpollingcachepolicy.rb
+- lib/configcat/overridedatasource.rb
 - lib/configcat/rolloutevaluator.rb
 - lib/configcat/user.rb
 - lib/configcat/version.rb
@@ -135,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: ConfigCat SDK for Ruby.