configcat 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f268b80ad6cfa72c12ca3a438d6fc8a896be9dcd324d5f7743274ea1b93935b8
-  data.tar.gz: e9889a6887f63823adacfa9be12f1ede457f0f94d17a2920d6800b6c816a4f23
+  metadata.gz: dada53197ffe2d00bf8f4349bd643312f65d72b970e4de9bb774a490bf2f12c4
+  data.tar.gz: 0e656c1c42d3def92aa47013f8c22a555f0268b2dff5b8df37b79a0ac3952425
 SHA512:
-  metadata.gz: 248a015959119f3629c42df5b6bb9d1b5105a452ea5d3d8054d0110b73fff508f2e551cf7e3ed591330f0037748adf487b7c6678a0385c47e5869613ca8b6d66
-  data.tar.gz: 055ac0dd698e4bd3173ba64c299c9856ad8e2821bd92fd5b0a6e2f25197054ba1ff15bb0c931b6a1bd78ed6eb6ea369d2b08e637db5743154fd73a243b6f3876
+  metadata.gz: ace75c4e4f36cfb62447beca19786287026fa8be4409506fa54b58a693f4b996a9526acad14b9552012377a6c5e75b5fcd0073118e7cd2af403b1585eecc6e07
+  data.tar.gz: bd98ab5c116d6a4daf2d1f07a214e585bcc630d9f81b268febe9b0fead8f4fdc1cb86e7af4042f5d568c46e8692d8599db2f4e9b83a74fbec80312612c091c46

data/lib/configcat.rb

@@ -5,7 +5,7 @@ require 'logger'
 
 module ConfigCat
 
-  @logger = Logger.new(STDOUT, level: Logger::INFO)
+  @logger = Logger.new(STDOUT, level: Logger::WARN)
   class << self
     attr_accessor :logger
   end
@@ -19,7 +19,16 @@ module ConfigCat
     return create_client_with_auto_poll(api_key)
   end
 
-  def ConfigCat.create_client_with_auto_poll(api_key, poll_interval_seconds: 60, max_init_wait_time_seconds: 5, on_configuration_changed_callback: nil, config_cache_class: nil, base_url: nil)
+  def ConfigCat.create_client_with_auto_poll(api_key,
+                                             poll_interval_seconds: 60,
+                                             max_init_wait_time_seconds: 5,
+                                             on_configuration_changed_callback: nil,
+                                             config_cache_class: nil,
+                                             base_url: nil,
+                                             proxy_address:nil,
+                                             proxy_port:nil,
+                                             proxy_user:nil,
+                                             proxy_pass:nil)
     #
     #   Create an instance of ConfigCatClient and setup Auto Poll mode with custom options
     #
@@ -30,6 +39,10 @@ module ConfigCat
     #   :param config_cache_class: If you want to use custom caching instead of the client's default InMemoryConfigCache,
     #   You can provide an implementation of ConfigCache.
     #   :param base_url: You can set a base_url if you want to use a proxy server between your application and ConfigCat
+    #   :param proxy_address: Proxy address
+    #   :param proxy_port: Proxy port
+    #   :param proxy_user: username for proxy authentication
+    #   :param proxy_pass: password for proxy authentication
     #
     if api_key === nil
       raise ConfigCatClientException, "API Key is required."
@@ -46,10 +59,21 @@ module ConfigCat
                                on_configuration_changed_callback: on_configuration_changed_callback,
                                cache_time_to_live_seconds: 0,
                                config_cache_class: config_cache_class,
-                               base_url: base_url)
+                               base_url: base_url,
+                               proxy_address: proxy_address,
+                               proxy_port: proxy_port,
+                               proxy_user: proxy_user,
+                               proxy_pass: proxy_pass)
   end
 
-  def ConfigCat.create_client_with_lazy_load(api_key, cache_time_to_live_seconds: 60, config_cache_class: nil, base_url: nil)
+  def ConfigCat.create_client_with_lazy_load(api_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)
     #
     #   Create an instance of ConfigCatClient and setup Lazy Load mode with custom options
     #
@@ -58,6 +82,10 @@ module ConfigCat
     #   :param config_cache_class: If you want to use custom caching instead of the client's default InMemoryConfigCache,
     #   You can provide an implementation of ConfigCache.
     #   :param base_url: You can set a base_url if you want to use a proxy server between your application and ConfigCat
+    #   :param proxy_address: Proxy address
+    #   :param proxy_port: Proxy port
+    #   :param proxy_user: username for proxy authentication
+    #   :param proxy_pass: password for proxy authentication
     #
     if api_key === nil
       raise ConfigCatClientException, "API Key is required."
@@ -71,10 +99,20 @@ module ConfigCat
                                on_configuration_changed_callback: nil,
                                cache_time_to_live_seconds: cache_time_to_live_seconds,
                                config_cache_class: config_cache_class,
-                               base_url: base_url)
+                               base_url: base_url,
+                               proxy_address: proxy_address,
+                               proxy_port: proxy_port,
+                               proxy_user: proxy_user,
+                               proxy_pass: proxy_pass)
   end
 
-  def ConfigCat.create_client_with_manual_poll(api_key, config_cache_class: nil, base_url: nil)
+  def ConfigCat.create_client_with_manual_poll(api_key,
+                                               config_cache_class: nil,
+                                               base_url: nil,
+                                               proxy_address:nil,
+                                               proxy_port:nil,
+                                               proxy_user:nil,
+                                               proxy_pass:nil)
     #
     #   Create an instance of ConfigCatClient and setup Manual Poll mode with custom options
     #
@@ -82,6 +120,10 @@ module ConfigCat
     #   :param config_cache_class: If you want to use custom caching instead of the client's default InMemoryConfigCache,
     #   You can provide an implementation of ConfigCache.
     #   :param base_url: You can set a base_url if you want to use a proxy server between your application and ConfigCat
+    #   :param proxy_address: Proxy address
+    #   :param proxy_port: Proxy port
+    #   :param proxy_user: username for proxy authentication
+    #   :param proxy_pass: password for proxy authentication
     #
     if api_key === nil
       raise ConfigCatClientException, "API Key is required."
@@ -92,7 +134,11 @@ module ConfigCat
                                on_configuration_changed_callback: nil,
                                cache_time_to_live_seconds: 0,
                                config_cache_class: config_cache_class,
-                               base_url: base_url)
+                               base_url: base_url,
+                               proxy_address: proxy_address,
+                               proxy_port: proxy_port,
+                               proxy_user: proxy_user,
+                               proxy_pass: proxy_pass)
   end
 
 end

data/lib/configcat/autopollingcachepolicy.rb

@@ -47,30 +47,38 @@ module ConfigCat
     end
 
     def force_refresh()
-      begin
-        @_lock.acquire_read_lock()
-        old_configuration = @_config_cache.get()
-      ensure
-        @_lock.release_read_lock()
-      end
       begin
         configuration = @_config_fetcher.get_configuration_json()
+
         begin
-          @_lock.acquire_write_lock()
-          @_config_cache.set(configuration)
-          @_initialized = true
+          @_lock.acquire_read_lock()
+          old_configuration = @_config_cache.get()
         ensure
-          @_lock.release_write_lock()
+          @_lock.release_read_lock()
         end
-        begin
-          if !@_on_configuration_changed_callback.equal?(nil) && configuration != old_configuration
-            @_on_configuration_changed_callback.call()
+
+        if configuration != old_configuration
+          begin
+            @_lock.acquire_write_lock()
+            @_config_cache.set(configuration)
+            @_initialized = true
+          ensure
+            @_lock.release_write_lock()
+          end
+          begin
+            if !@_on_configuration_changed_callback.equal?(nil)
+              @_on_configuration_changed_callback.()
+            end
+          rescue Exception => e
+            ConfigCat.logger.error("Exception in on_configuration_changed_callback: #{e.class}:'#{e}'")
           end
-        rescue Exception => e
-          ConfigCat.logger.error "threw exception #{e.class}:'#{e}'"
-          ConfigCat.logger.error "stacktrace: #{e.backtrace}"
         end
-      rescue StandardError => e
+
+        if !@_initialized && !old_configuration.equal?(nil)
+          @_initialized = true
+        end
+      rescue Exception => e
+        ConfigCat.logger.error("Double-check your API KEY at https://app.configcat.com/apikey.")
         ConfigCat.logger.error "threw exception #{e.class}:'#{e}'"
         ConfigCat.logger.error "stacktrace: #{e.backtrace}"
       end

data/lib/configcat/configcatclient.rb

@@ -14,7 +14,11 @@ module ConfigCat
                    on_configuration_changed_callback:nil,
                    cache_time_to_live_seconds:60,
                    config_cache_class:nil,
-                   base_url:nil)
+                   base_url:nil,
+                   proxy_address:nil,
+                   proxy_port:nil,
+                   proxy_user:nil,
+                   proxy_pass:nil)
       if api_key === nil
         raise ConfigCatClientException, "API Key is required."
       end
@@ -27,14 +31,14 @@ module ConfigCat
       end
 
       if poll_interval_seconds > 0
-        @_config_fetcher = CacheControlConfigFetcher.new(api_key, "p", base_url)
+        @_config_fetcher = CacheControlConfigFetcher.new(api_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)
       else
         if cache_time_to_live_seconds > 0
-          @_config_fetcher = CacheControlConfigFetcher.new(api_key, "l", base_url)
+          @_config_fetcher = CacheControlConfigFetcher.new(api_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(api_key, "m", base_url)
+          @_config_fetcher = CacheControlConfigFetcher.new(api_key, "m", base_url, proxy_address, proxy_port, proxy_user, proxy_pass)
           @_cache_policy = ManualPollingCachePolicy.new(@_config_fetcher, @_config_cache)
         end
       end

data/lib/configcat/configfetcher.rb

@@ -7,10 +7,10 @@ require 'json'
 module ConfigCat
   BASE_URL = "https://cdn.configcat.com"
   BASE_PATH = "configuration-files/"
-  BASE_EXTENSION = "/config_v2.json"
+  BASE_EXTENSION = "/config_v3.json"
 
   class CacheControlConfigFetcher < ConfigFetcher
-    def initialize(api_key, mode, base_url=nil)
+    def initialize(api_key, mode, base_url=nil, proxy_address=nil, proxy_port=nil, proxy_user=nil, proxy_pass=nil)
       @_api_key = api_key
       @_etag = nil
       @_headers = {"User-Agent" => ((("ConfigCat-Ruby/") + mode) + ("-")) + VERSION, "X-ConfigCat-UserAgent" => ((("ConfigCat-Ruby/") + mode) + ("-")) + VERSION, "Content-Type" => "application/json"}
@@ -20,7 +20,7 @@ module ConfigCat
         @_base_url = BASE_URL
       end
       uri = URI.parse(@_base_url)
-      @_http = Net::HTTP.new(uri.host, uri.port)
+      @_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

data/lib/configcat/lazyloadingcachepolicy.rb

@@ -49,6 +49,7 @@ module ConfigCat
           @_lock.release_write_lock()
         end
       rescue StandardError => e
+        ConfigCat.logger.error("Double-check your API KEY at https://app.configcat.com/apikey.")
         ConfigCat.logger.error "threw exception #{e.class}:'#{e}'"
         ConfigCat.logger.error "stacktrace: #{e.backtrace}"
       end

data/lib/configcat/manualpollingcachepolicy.rb

@@ -29,6 +29,7 @@ module ConfigCat
           @_lock.release_write_lock()
         end
       rescue StandardError => e
+        ConfigCat.logger.error("Double-check your API KEY at https://app.configcat.com/apikey.")
         ConfigCat.logger.error "threw exception #{e.class}:'#{e}'"
         ConfigCat.logger.error "stacktrace: #{e.backtrace}"
       end

data/lib/configcat/rolloutevaluator.rb

@@ -1,71 +1,172 @@
 require 'configcat/user'
 require 'digest'
+require 'semantic'
 
 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"
 
     def self.evaluate(key, user, default_value, config)
-      if !user.equal?(nil) && !user.class.equal?(User)
-        ConfigCat.logger.warn "User parameter is not an instance of User type."
-        user = nil
-      end
+      ConfigCat.logger.info("Evaluating get_value('%s')." % key)
+
       setting_descriptor = config.fetch(key, nil)
       if setting_descriptor === nil
-        ConfigCat.logger.warn "Could not find setting by key, returning default value. Key: #{key}"
+        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.to_a.join(", ")])
         return default_value
       end
+
+      rollout_rules = setting_descriptor.fetch(ROLLOUT_RULES, [])
+      rollout_percentage_items = setting_descriptor.fetch(ROLLOUT_PERCENTAGE_ITEMS, [])
+
+      if !user.equal?(nil) && !user.class.equal?(User)
+        ConfigCat.logger.warn("Evaluating get_value('%s'). User Object is not an instance of User type." % key)
+        user = nil
+      end
       if user === nil
-        return setting_descriptor.fetch("Value", default_value)
+        if rollout_rules.size > 0 || rollout_percentage_items.size > 0
+          ConfigCat.logger.warn("Evaluating get_value('%s'). UserObject missing! You should pass a UserObject to get_value(), in order to make targeting work properly. Read more: https://configcat.com/docs/advanced/user-object/" % key)
+        end
+        return_value = setting_descriptor.fetch(VALUE, default_value)
+        ConfigCat.logger.info("Returning [%s]" % return_value.to_s)
+        return return_value
       end
-      rollout_rules = setting_descriptor.fetch("RolloutRules", [])
+
+      ConfigCat.logger.info("User object:\n%s" % user.to_s)
+
+      # Evaluate targeting rules
       for rollout_rule in rollout_rules
-        comparison_attribute = rollout_rule.fetch("ComparisonAttribute")
+        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, comparator, comparison_value))
           next
         end
-        comparison_value = rollout_rule.fetch("ComparisonValue", nil)
-        comparator = rollout_rule.fetch("Comparator", nil)
-        value = rollout_rule.fetch("Value", nil)
+
+        value = rollout_rule.fetch(VALUE, nil)
+
+        # 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, comparator, comparison_value, value))
+            return value
+          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, comparator, comparison_value, value))
             return value
           end
-        else
-          if comparator == 1
-            if !comparison_value.to_s.split(",").map { |x| x.strip() }.include?(user_value.to_s)
+        # CONTAINS
+        elsif comparator == 2
+          if user_value.to_s.include?(comparison_value.to_s)
+            ConfigCat.logger.info(format_match_rule(comparison_attribute, comparator, comparison_value, value))
+            return value
+          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, comparator, comparison_value, value))
+            return value
+          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, comparator, comparison_value, value))
               return value
             end
-          else
-            if comparator == 2
-              if user_value.to_s.include?(comparison_value.to_s)
-                return value
-              end
-            else
-              if comparator == 3
-                if !user_value.to_s.include?(comparison_value.to_s)
-                  return value
-                end
-              end
+          rescue ArgumentError => e
+            ConfigCat.logger.warn(format_validation_error_rule(comparison_attribute, 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, comparator, comparison_value, value))
+              return value
             end
+          rescue ArgumentError => e
+            ConfigCat.logger.warn(format_validation_error_rule(comparison_attribute, 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, comparator, comparison_value, value))
+              return value
+            end
+          rescue Exception => e
+            ConfigCat.logger.warn(format_validation_error_rule(comparison_attribute, comparator, comparison_value, e.to_s))
+            next
           end
         end
+
+        ConfigCat.logger.info(format_no_match_rule(comparison_attribute, comparator, comparison_value))
       end
-      rollout_percentage_items = setting_descriptor.fetch("RolloutPercentageItems", [])
+
       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)
+          bucket += rollout_percentage_item.fetch(PERCENTAGE, 0)
           if hash_val < bucket
-            return rollout_percentage_item.fetch("Value", nil)
+            percentage_value = rollout_percentage_item.fetch(VALUE, nil)
+            ConfigCat.logger.info("Evaluating %% options. Returning %s" % percentage_value)
+            return percentage_value
           end
         end
       end
-      return setting_descriptor.fetch("Value", default_value)
+      def_value = setting_descriptor.fetch(VALUE, default_value)
+      ConfigCat.logger.info("Returning %s" % def_value)
+      return def_value
     end
+
+    private
+
+    def self.format_match_rule(comparison_attribute, comparator, comparison_value, value)
+      return "Evaluating rule: [%s] [%s] [%s] => match, returning: %s" % [comparison_attribute, COMPARATOR_TEXTS[comparator], comparison_value, value]
+    end
+
+    def self.format_no_match_rule(comparison_attribute, comparator, comparison_value)
+      return "Evaluating rule: [%s] [%s] [%s] => no match" % [comparison_attribute, COMPARATOR_TEXTS[comparator], comparison_value]
+    end
+
+    def self.format_validation_error_rule(comparison_attribute, comparator, comparison_value, error)
+      return "Evaluating rule: [%s] [%s] [%s] => SKIP rule. Validation error: %s" % [comparison_attribute, COMPARATOR_TEXTS[comparator], comparison_value, error]
+    end
+
   end
 
 end

data/lib/configcat/version.rb

@@ -1,3 +1,3 @@
 module ConfigCat
-  VERSION = "1.0.1"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: configcat
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
 platform: ruby
 authors:
 - ConfigCat
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-14 00:00:00.000000000 Z
+date: 2019-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: semantic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ConfigCat is a configuration as a service that lets you manage your features
   and configurations without actually deploying new code.
 email: