configcat 7.0.0 → 8.0.0

data/lib/configcat/configservice.rb

@@ -30,13 +30,12 @@ module ConfigCat
       end
     end
 
-    def get_settings
+    def get_config
       if @polling_mode.is_a?(LazyLoadingMode)
         entry, _ = fetch_if_older(Utils.get_utc_now_seconds_since_epoch - @polling_mode.cache_refresh_interval_seconds)
         return !entry.empty? ?
-          [entry.config.fetch(FEATURE_FLAGS, {}), entry.fetch_time] :
+          [entry.config, entry.fetch_time] :
           [nil, Utils::DISTANT_PAST]
-          
       elsif @polling_mode.is_a?(AutoPollingMode) && !@initialized.set?
         elapsed_time = Utils.get_utc_now_seconds_since_epoch - @start_time # Elapsed time in seconds
         if elapsed_time < @polling_mode.max_init_wait_time_seconds
@@ -46,20 +45,27 @@ module ConfigCat
           if !@initialized.set?
             set_initialized
             return !@cached_entry.empty? ?
-              [@cached_entry.config.fetch(FEATURE_FLAGS, {}), @cached_entry.fetch_time] :
+              [@cached_entry.config, @cached_entry.fetch_time] :
               [nil, Utils::DISTANT_PAST]
           end
         end
       end
 
-      entry, _ = fetch_if_older(Utils::DISTANT_PAST, prefer_cache: true)
+      # If we are initialized, we prefer the cached results
+      entry, _ = fetch_if_older(Utils::DISTANT_PAST, prefer_cache: @initialized.set?)
       return !entry.empty? ?
-        [entry.config.fetch(FEATURE_FLAGS, {}), entry.fetch_time] :
+        [entry.config, entry.fetch_time] :
         [nil, Utils::DISTANT_PAST]
     end
 
     # :return [RefreshResult]
     def refresh
+      if offline?
+        offline_warning = "Client is in offline mode, it cannot initiate HTTP calls."
+        @log.warn(3200, offline_warning)
+        return RefreshResult.new(success = false, error = offline_warning)
+      end
+
       _, error = fetch_if_older(Utils::DISTANT_FUTURE)
       return RefreshResult.new(success = error.nil?, error = error)
     end
@@ -74,7 +80,7 @@ module ConfigCat
         if @polling_mode.is_a?(AutoPollingMode)
           start_poll
         end
-        @log.info(5200, 'Switched to ONLINE mode.')
+        @log.info(5200, "Switched to ONLINE mode.")
       end
     end
 
@@ -90,7 +96,7 @@ module ConfigCat
           @thread.join
         end
 
-        @log.info(5200, 'Switched to OFFLINE mode.')
+        @log.info(5200, "Switched to OFFLINE mode.")
       end
     end
 
@@ -111,35 +117,25 @@ module ConfigCat
     end
 
     # :return [ConfigEntry, String] Returns the ConfigEntry object and error message in case of any error.
-    def fetch_if_older(time, prefer_cache: false)
+    def fetch_if_older(threshold, prefer_cache: false)
       # Sync up with the cache and use it when it's not expired.
       @lock.synchronize do
-        if @cached_entry.empty? || @cached_entry.fetch_time > time
-          entry = read_cache
-          if !entry.empty? && entry.etag != @cached_entry.etag
-            @cached_entry = entry
-            @hooks.invoke_on_config_changed(entry.config[FEATURE_FLAGS])
-          end
-
-          # Cache isn't expired
-          if @cached_entry.fetch_time > time
-            set_initialized
-            return @cached_entry, nil
-          end
+        # Sync up with the cache and use it when it's not expired.
+        from_cache = read_cache
+        if !from_cache.empty? && from_cache.etag != @cached_entry.etag
+          @cached_entry = from_cache
+          @hooks.invoke_on_config_changed(from_cache.config[FEATURE_FLAGS])
         end
 
-        # Use cache anyway (get calls on auto & manual poll must not initiate fetch).
-        # The initialized check ensures that we subscribe for the ongoing fetch during the
-        # max init wait time window in case of auto poll.
-        if prefer_cache && @initialized.set?
+        # Cache isn't expired
+        if @cached_entry.fetch_time > threshold
+          set_initialized
           return @cached_entry, nil
         end
 
-        # If we are in offline mode we are not allowed to initiate fetch.
-        if @is_offline
-          offline_warning = "Client is in offline mode, it cannot initiate HTTP calls."
-          @log.warn(3200, offline_warning)
-          return @cached_entry, offline_warning
+        # If we are in offline mode or the caller prefers cached values, do not initiate fetch.
+        if @is_offline || prefer_cache
+          return @cached_entry, nil
         end
       end
 

data/lib/configcat/evaluationcontext.rb

@@ -0,0 +1,14 @@
+module ConfigCat
+  class EvaluationContext
+    attr_accessor :key, :setting_type, :user, :visited_keys, :is_missing_user_object_logged, :is_missing_user_object_attribute_logged
+
+    def initialize(key, setting_type, user, visited_keys = nil, is_missing_user_object_logged = false, is_missing_user_object_attribute_logged = false)
+      @key = key
+      @setting_type = setting_type
+      @user = user
+      @visited_keys = visited_keys || []
+      @is_missing_user_object_logged = is_missing_user_object_logged
+      @is_missing_user_object_attribute_logged = is_missing_user_object_attribute_logged
+    end
+  end
+end

data/lib/configcat/evaluationdetails.rb

@@ -1,19 +1,37 @@
 module ConfigCat
   class EvaluationDetails
     attr_reader :key, :value, :variation_id, :fetch_time, :user, :is_default_value, :error,
-                :matched_evaluation_rule, :matched_evaluation_percentage_rule
+                :matched_targeting_rule, :matched_percentage_option
 
     def initialize(key:, value:, variation_id: nil, fetch_time: nil, user: nil, is_default_value: false, error: nil,
-                   matched_evaluation_rule: nil, matched_evaluation_percentage_rule: nil)
+                   matched_targeting_rule: nil, matched_percentage_option: nil)
+      # Key of the feature flag or setting.
       @key = key
+
+      # Evaluated value of the feature flag or setting.
       @value = value
+
+      # Variation ID of the feature flag or setting (if available).
       @variation_id = variation_id
+
+      # Time of last successful config download.
       @fetch_time = fetch_time
+
+      # The User Object used for the evaluation (if available).
       @user = user
+
+      # Indicates whether the default value passed to the setting evaluation methods like ConfigCatClient.get_value,
+      # ConfigCatClient.get_value_details, etc. is used as the result of the evaluation.
       @is_default_value = is_default_value
+
+      # Error message in case evaluation failed.
       @error = error
-      @matched_evaluation_rule = matched_evaluation_rule
-      @matched_evaluation_percentage_rule = matched_evaluation_percentage_rule
+
+      # The targeting rule (if any) that matched during the evaluation and was used to return the evaluated value.
+      @matched_targeting_rule = matched_targeting_rule
+
+      # The percentage option (if any) that was used to select the evaluated value.
+      @matched_percentage_option = matched_percentage_option
     end
 
     def self.from_error(key, value, error:, variation_id: nil)

data/lib/configcat/evaluationlogbuilder.rb

@@ -0,0 +1,81 @@
+module ConfigCat
+  class EvaluationLogBuilder
+    def initialize
+      @indent_level = 0
+      @text = ''
+    end
+
+    def self.trunc_comparison_value_if_needed(comparator, comparison_value)
+      if [
+        Comparator::IS_ONE_OF_HASHED,
+        Comparator::IS_NOT_ONE_OF_HASHED,
+        Comparator::EQUALS_HASHED,
+        Comparator::NOT_EQUALS_HASHED,
+        Comparator::STARTS_WITH_ANY_OF_HASHED,
+        Comparator::NOT_STARTS_WITH_ANY_OF_HASHED,
+        Comparator::ENDS_WITH_ANY_OF_HASHED,
+        Comparator::NOT_ENDS_WITH_ANY_OF_HASHED,
+        Comparator::ARRAY_CONTAINS_ANY_OF_HASHED,
+        Comparator::ARRAY_NOT_CONTAINS_ANY_OF_HASHED
+      ].include?(comparator)
+        if comparison_value.is_a?(Array)
+          length = comparison_value.length
+          if length > 1
+            return "[<#{length} hashed values>]"
+          end
+          return "[<#{length} hashed value>]"
+        end
+
+        return "'<hashed value>'"
+      end
+
+      if comparison_value.is_a?(Array)
+        length_limit = 10
+        length = comparison_value.length
+        if length > length_limit
+          remaining = length - length_limit
+          more_text = remaining == 1 ? "<1 more value>" : "<#{remaining} more values>"
+
+          formatted_strings = comparison_value.first(length_limit).map { |str| "'#{str}'" }.join(", ")
+          return "[#{formatted_strings}, ... #{more_text}]"
+        end
+
+        # replace '"' with "'" in the string representation of the array
+        formatted_strings = comparison_value.map { |str| "'#{str}'" }.join(", ")
+        return "[#{formatted_strings}]"
+      end
+
+      if [Comparator::BEFORE_DATETIME, Comparator::AFTER_DATETIME].include?(comparator)
+        time = Utils.get_date_time(comparison_value)
+        return "'#{comparison_value}' (#{time.strftime('%Y-%m-%dT%H:%M:%S.%L')}Z UTC)"
+      end
+
+      "'#{comparison_value.to_s}'"
+    end
+
+    def increase_indent
+      @indent_level += 1
+      self
+    end
+
+    def decrease_indent
+      @indent_level = [@indent_level - 1, 0].max
+      self
+    end
+
+    def append(text)
+      @text += text
+      self
+    end
+
+    def new_line(text = nil)
+      @text += "\n" + '  ' * @indent_level
+      @text += text if text
+      self
+    end
+
+    def to_s
+      @text
+    end
+  end
+end

data/lib/configcat/localdictionarydatasource.rb

@@ -1,5 +1,5 @@
 require 'configcat/overridedatasource'
-require 'configcat/constants'
+require 'configcat/config'
 
 
 module ConfigCat
@@ -17,14 +17,30 @@ module ConfigCat
   class LocalDictionaryDataSource < OverrideDataSource
     def initialize(source, override_behaviour)
       super(override_behaviour)
-      @_settings = {}
+      @_config = {}
       source.each do |key, value|
-        @_settings[key] = { VALUE => value }
+        value_type = case value
+                     when TrueClass, FalseClass
+                       BOOL_VALUE
+                     when String
+                       STRING_VALUE
+                     when Integer
+                       INT_VALUE
+                     when Float
+                       DOUBLE_VALUE
+                     else
+                       UNSUPPORTED_VALUE
+        end
+
+        @_config[FEATURE_FLAGS] ||= {}
+        @_config[FEATURE_FLAGS][key] = { VALUE => { value_type => value } }
+        setting_type = SettingType.from_type(value.class)
+        @_config[FEATURE_FLAGS][key][SETTING_TYPE] = setting_type.to_i unless setting_type.nil?
       end
     end
 
     def get_overrides
-      return @_settings
+      return @_config
     end
   end
 end

data/lib/configcat/localfiledatasource.rb

@@ -1,5 +1,5 @@
 require 'configcat/overridedatasource'
-require 'configcat/constants'
+require 'configcat/config'
 
 
 module ConfigCat
@@ -18,17 +18,17 @@ module ConfigCat
     def initialize(file_path, override_behaviour, log)
       super(override_behaviour)
       @log = log
-      if !File.exists?(file_path)
+      if !File.exist?(file_path)
         @log.error(1300, "Cannot find the local config file '#{file_path}'. This is a path that your application provided to the ConfigCat SDK by passing it to the `LocalFileFlagOverrides.new()` method. Read more: https://configcat.com/docs/sdk-reference/ruby/#json-file")
       end
       @_file_path = file_path
-      @_settings = nil
+      @_config = nil
       @_cached_file_stamp = 0
     end
 
     def get_overrides
       reload_file_content()
-      return @_settings
+      return @_config
     end
 
     private
@@ -41,13 +41,29 @@ module ConfigCat
           file = File.read(@_file_path)
           data = JSON.parse(file)
           if data.key?("flags")
-            @_settings = {}
+            @_config = { FEATURE_FLAGS => {} }
             source = data["flags"]
             source.each do |key, value|
-              @_settings[key] = { VALUE => value }
+              value_type = case value
+                           when true, false
+                             BOOL_VALUE
+                           when String
+                             STRING_VALUE
+                           when Integer
+                             INT_VALUE
+                           when Float
+                             DOUBLE_VALUE
+                           else
+                             UNSUPPORTED_VALUE
+              end
+
+              @_config[FEATURE_FLAGS][key] = { VALUE => { value_type => value } }
+              setting_type = SettingType.from_type(value.class)
+              @_config[FEATURE_FLAGS][key][SETTING_TYPE] = setting_type.to_i unless setting_type.nil?
             end
           else
-            @_settings = data[FEATURE_FLAGS]
+            Config.fixup_config_salt_and_segments(data)
+            @_config = data
           end
         end
       rescue JSON::ParserError => e