configcat 5.0.2 → 6.1.0

data/lib/configcat/configcatoptions.rb

@@ -0,0 +1,153 @@
+require 'configcat/datagovernance'
+require 'configcat/pollingmode'
+
+module ConfigCat
+  class Hooks
+    #
+    #    Events fired by [ConfigCatClient].
+    #
+
+    def initialize(on_client_ready: nil, on_config_changed: nil, on_flag_evaluated: nil, on_error: nil)
+      @_on_client_ready_callbacks = on_client_ready ? [on_client_ready] : []
+      @_on_config_changed_callbacks = on_config_changed ? [on_config_changed] : []
+      @_on_flag_evaluated_callbacks = on_flag_evaluated ? [on_flag_evaluated] : []
+      @_on_error_callbacks = on_error ? [on_error] : []
+    end
+
+    def add_on_client_ready(callback)
+      @_on_client_ready_callbacks.push(callback)
+    end
+
+    def add_on_config_changed(callback)
+      @_on_config_changed_callbacks.push(callback)
+    end
+
+    def add_on_flag_evaluated(callback)
+      @_on_flag_evaluated_callbacks.push(callback)
+    end
+
+    def add_on_error(callback)
+      @_on_error_callbacks.push(callback)
+    end
+
+    def invoke_on_client_ready
+      @_on_client_ready_callbacks.each { |callback|
+        begin
+          callback.()
+        rescue Exception => e
+          error = "Exception occurred during invoke_on_client_ready callback: #{e}"
+          invoke_on_error(error)
+          ConfigCat.logger.error(error)
+        end
+      }
+    end
+
+    def invoke_on_config_changed(config)
+      @_on_config_changed_callbacks.each { |callback|
+        begin
+          callback.(config)
+        rescue Exception => e
+          error = "Exception occurred during invoke_on_config_changed callback: #{e}"
+          invoke_on_error(error)
+          ConfigCat.logger.error(error)
+        end
+      }
+    end
+
+    def invoke_on_flag_evaluated(evaluation_details)
+      @_on_flag_evaluated_callbacks.each { |callback|
+        begin
+          callback.(evaluation_details)
+        rescue Exception => e
+          error = "Exception occurred during invoke_on_flag_evaluated callback: #{e}"
+          invoke_on_error(error)
+          ConfigCat.logger.error(error)
+        end
+      }
+    end
+
+    def invoke_on_error(error)
+      @_on_error_callbacks.each { |callback|
+        begin
+          callback.(error)
+        rescue Exception => e
+          ConfigCat.logger.error("Exception occurred during invoke_on_error callback: #{e}")
+        end
+      }
+    end
+
+    def clear
+      @_on_client_ready_callbacks.clear
+      @_on_config_changed_callbacks.clear
+      @_on_flag_evaluated_callbacks.clear
+      @_on_error_callbacks.clear
+    end
+  end
+
+  class ConfigCatOptions
+    # Configuration options for ConfigCatClient.
+    attr_reader :base_url, :polling_mode, :config_cache, :proxy_address, :proxy_port, :proxy_user, :proxy_pass,
+                :open_timeout_seconds, :read_timeout_seconds, :flag_overrides, :data_governance, :default_user,
+                :hooks, :offline
+
+    def initialize(base_url: nil,
+                   polling_mode: PollingMode.auto_poll(),
+                   config_cache: nil,
+                   proxy_address: nil,
+                   proxy_port: nil,
+                   proxy_user: nil,
+                   proxy_pass: nil,
+                   open_timeout_seconds: 10,
+                   read_timeout_seconds: 30,
+                   flag_overrides: nil,
+                   data_governance: DataGovernance::GLOBAL,
+                   default_user: nil,
+                   hooks: nil,
+                   offline: false)
+      # The base ConfigCat CDN url.
+      @base_url = base_url
+
+      # The polling mode.
+      @polling_mode = polling_mode
+
+      # The cache implementation used to cache the downloaded config files.
+      @config_cache = config_cache
+
+      # Proxy address
+      @proxy_address = proxy_address
+
+      # Proxy port
+      @proxy_port = proxy_port
+
+      # username for proxy authentication
+      @proxy_user = proxy_user
+
+      # password for proxy authentication
+      @proxy_pass = proxy_pass
+
+      # The number of seconds to wait for the server to make the initial connection
+      # (i.e. completing the TCP connection handshake).
+      @open_timeout_seconds = open_timeout_seconds
+
+      # The number of seconds to wait for the server to respond before giving up.
+      @read_timeout_seconds = read_timeout_seconds
+
+      # Feature flag and setting overrides.
+      @flag_overrides = flag_overrides
+
+      # Default: `DataGovernance.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)
+      @data_governance = data_governance
+
+      # The default user to be used for evaluating feature flags and getting settings.
+      @default_user = default_user
+
+      # The Hooks instance to subscribe to events.
+      @hooks = hooks
+
+      # Indicates whether the client should work in offline mode.
+      @offline = offline
+    end
+  end
+end

data/lib/configcat/configentry.rb

@@ -0,0 +1,40 @@
+require 'configcat/utils'
+
+module ConfigCat
+  class ConfigEntry
+    CONFIG = 'config'
+    ETAG = 'etag'
+    FETCH_TIME = 'fetch_time'
+
+    attr_accessor :config, :etag, :fetch_time
+
+    def initialize(config = {}, etag = '', fetch_time = Utils::DISTANT_PAST)
+      @config = config
+      @etag = etag
+      @fetch_time = fetch_time
+    end
+
+    def self.create_from_json(json)
+      return ConfigEntry::EMPTY if json.nil?
+      return ConfigEntry.new(
+        config = json.fetch(CONFIG, {}),
+        etag = json.fetch(ETAG, ''),
+        fetch_time = json.fetch(FETCH_TIME, Utils::DISTANT_PAST)
+      )
+    end
+
+    def empty?
+      self == ConfigEntry::EMPTY
+    end
+
+    def to_json
+      {
+        CONFIG => config,
+        ETAG => etag,
+        FETCH_TIME => fetch_time
+      }
+    end
+
+    EMPTY = ConfigEntry.new(etag: 'empty')
+  end
+end

data/lib/configcat/configfetcher.rb

@@ -2,6 +2,7 @@ require 'configcat/interfaces'
 require 'configcat/version'
 require 'configcat/datagovernance'
 require 'configcat/constants'
+require 'configcat/configentry'
 require 'net/http'
 require 'uri'
 require 'json'
@@ -18,41 +19,66 @@ module ConfigCat
     FORCE_REDIRECT = 2
   end
 
+  class Status
+    FETCHED = 0,
+    NOT_MODIFIED = 1,
+    FAILURE = 2
+  end
+
   class FetchResponse
-    def initialize(response)
-      @_response = response
+    attr_reader :entry, :error, :is_transient_error
+
+    def initialize(status, entry, error = nil, is_transient_error = false)
+      @status = status
+      @entry = entry
+      @error = error
+      @is_transient_error = is_transient_error
+    end
+
+    # Gets whether a new configuration value was fetched or not.
+    # :return [Boolean] true if a new configuration value was fetched, otherwise false.
+    def is_fetched
+      @status == Status::FETCHED
+    end
+
+    # Gets whether the fetch resulted a '304 Not Modified' or not.
+    # :return [Boolean] true if the fetch resulted a '304 Not Modified' code, otherwise false.
+    def is_not_modified
+      @status == Status::NOT_MODIFIED
     end
 
-    # Returns the json-encoded content of a response, if any
-    def json()
-      return JSON.parse(@_response.body)
+    # Gets whether the fetch failed or not.
+    # :return [Boolean] true if the fetch failed, otherwise false.
+    def is_failed
+      @status == Status::FAILURE
     end
 
-    # Gets whether a new configuration value was fetched or not
-    def is_fetched()
-      code = @_response.code.to_i
-      return 200 <= code && code < 300
+    def self.success(entry)
+      FetchResponse.new(Status::FETCHED, entry)
     end
 
-    # Gets whether the fetch resulted a '304 Not Modified' or not
-    def is_not_modified()
-      return @_response.code == "304"
+    def self.not_modified
+      FetchResponse.new(Status::NOT_MODIFIED, ConfigEntry::EMPTY)
+    end
+
+    def self.failure(error, is_transient_error)
+      FetchResponse.new(Status::FAILURE, ConfigEntry::EMPTY, error, is_transient_error)
     end
   end
 
-  class CacheControlConfigFetcher < ConfigFetcher
-    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)
+  class ConfigFetcher
+    def initialize(sdk_key, log, 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
+      @log = log
       @_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"}
+      @_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("/")
@@ -66,34 +92,24 @@ module ConfigCat
       end
     end
 
-    def get_open_timeout()
+    def get_open_timeout
       return @_open_timeout
     end
 
-    def get_read_timeout()
+    def get_read_timeout
       return @_read_timeout
     end
 
-    # Returns the FetchResponse object contains configuration json Dictionary
-    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']}"
-      fetch_response = FetchResponse.new(response)
+    # Returns the FetchResponse object contains configuration entry
+    def get_configuration(etag = "", retries = 0)
+      fetch_response = _fetch(etag)
 
       # 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)
+      preferences = fetch_response.entry.config.fetch(PREFERENCES, nil)
       if preferences === nil
         return fetch_response
       end
@@ -107,7 +123,7 @@ module ConfigCat
 
       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.
+      # the SDK should not redirect the calls, and it just has to return the response.
       if @_base_url_overridden && redirect != RedirectMode::FORCE_REDIRECT
         return fetch_response
       end
@@ -124,20 +140,21 @@ module ConfigCat
       # 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.")
+        @log.warn(3002, "The `dataGovernance` parameter specified at the client initialization is not in sync with the preferences on the ConfigCat Dashboard. " \
+                        "Read more: https://configcat.com/docs/advanced/data-governance/")
       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.")
+        @log.error(1104, "Redirection loop encountered while trying to fetch config JSON. Please contact us at https://configcat.com/support/")
         return fetch_response
       end
 
       # Retry the config download with the new base_url
-      return get_configuration_json(retries + 1)
+      return get_configuration(etag, retries + 1)
     end
 
-    def close()
+    def close
       if @_http
         @_http = nil
       end
@@ -145,7 +162,49 @@ module ConfigCat
 
     private
 
-    def _create_http()
+    def _fetch(etag)
+      begin
+        @log.debug("Fetching configuration from ConfigCat")
+        uri = URI.parse((((@_base_url + ("/")) + BASE_PATH) + @_sdk_key) + BASE_EXTENSION)
+        headers = @_headers
+        headers["If-None-Match"] = etag.empty? ? nil : etag
+        _create_http()
+        request = Net::HTTP::Get.new(uri.request_uri, headers)
+        response = @_http.request(request)
+        case response
+        when Net::HTTPSuccess
+          @log.debug("ConfigCat configuration json fetch response code:#{response.code} Cached:#{response['ETag']}")
+          response_etag = response["ETag"]
+          if response_etag.nil?
+            response_etag = ""
+          end
+          config = JSON.parse(response.body)
+          return FetchResponse.success(ConfigEntry.new(config, response_etag, Utils.get_utc_now_seconds_since_epoch))
+        when Net::HTTPNotModified
+          return FetchResponse.not_modified
+        when Net::HTTPNotFound, Net::HTTPForbidden
+          error = "Your SDK Key seems to be wrong. You can find the valid SDK Key at https://app.configcat.com/sdkkey. Received unexpected response: #{response}"
+          @log.error(1100, error)
+          return FetchResponse.failure(error, false)
+        else
+          raise Net::HTTPError.new("", response)
+        end
+      rescue Net::HTTPError => e
+        error = "Unexpected HTTP response was received while trying to fetch config JSON: #{e}"
+        @log.error(1101, error)
+        return FetchResponse.failure(error, true)
+      rescue Timeout::Error => e
+        error = "Request timed out while trying to fetch config JSON. Timeout values: [connect: #{get_open_timeout()}s, read: #{get_read_timeout()}s]"
+        @log.error(1102, error)
+        return FetchResponse.failure(error, true)
+      rescue Exception => e
+        error = "Unexpected error occurred while trying to fetch config JSON: #{e}"
+        @log.error(1103, error)
+        return FetchResponse.failure(error, true)
+      end
+    end
+
+    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

data/lib/configcat/configservice.rb

@@ -0,0 +1,219 @@
+require 'concurrent'
+require 'configcat/configentry'
+require 'configcat/pollingmode'
+require 'configcat/refreshresult'
+
+
+module ConfigCat
+  class ConfigService
+    def initialize(sdk_key, polling_mode, hooks, config_fetcher, log, config_cache, is_offline)
+      @sdk_key = sdk_key
+      @cached_entry = ConfigEntry::EMPTY
+      @cached_entry_string = ''
+      @polling_mode = polling_mode
+      @log = log
+      @config_cache = config_cache
+      @hooks = hooks
+      @cache_key = Digest::SHA1.hexdigest("ruby_#{CONFIG_FILE_NAME}_#{@sdk_key}")
+      @config_fetcher = config_fetcher
+      @is_offline = is_offline
+      @response_future = nil
+      @initialized = Concurrent::Event.new
+      @lock = Mutex.new
+      @ongoing_fetch = false
+      @fetch_finished = Concurrent::Event.new
+      @start_time = Utils.get_utc_now_seconds_since_epoch
+
+      if @polling_mode.is_a?(AutoPollingMode) && !@is_offline
+        start_poll
+      else
+        set_initialized
+      end
+    end
+
+    def get_settings
+      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] :
+          [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
+          @initialized.wait(@polling_mode.max_init_wait_time_seconds - elapsed_time)
+
+          # Max wait time expired without result, notify subscribers with the cached config.
+          if !@initialized.set?
+            set_initialized
+            return !@cached_entry.empty? ?
+              [@cached_entry.config.fetch(FEATURE_FLAGS, {}), @cached_entry.fetch_time] :
+              [nil, Utils::DISTANT_PAST]
+          end
+        end
+      end
+
+      entry, _ = fetch_if_older(Utils::DISTANT_PAST, prefer_cache: true)
+      return !entry.empty? ?
+        [entry.config.fetch(FEATURE_FLAGS, {}), entry.fetch_time] :
+        [nil, Utils::DISTANT_PAST]
+    end
+
+    # :return [RefreshResult]
+    def refresh
+      _, error = fetch_if_older(Utils::DISTANT_FUTURE)
+      return RefreshResult.new(success = error.nil?, error = error)
+    end
+
+    def set_online
+      @lock.synchronize do
+        if !@is_offline
+          return
+        end
+
+        @is_offline = false
+        if @polling_mode.is_a?(AutoPollingMode)
+          start_poll
+        end
+        @log.info(5200, 'Switched to ONLINE mode.')
+      end
+    end
+
+    def set_offline
+      @lock.synchronize do
+        if @is_offline
+          return
+        end
+
+        @is_offline = true
+        if @polling_mode.is_a?(AutoPollingMode)
+          @stopped.set
+          @thread.join
+        end
+
+        @log.info(5200, 'Switched to OFFLINE mode.')
+      end
+    end
+
+    def offline?
+      return @is_offline
+    end
+
+    def close
+      if @polling_mode.is_a?(AutoPollingMode)
+        @stopped.set
+      end
+    end
+
+    private
+
+    # :return [ConfigEntry, String] Returns the ConfigEntry object and error message in case of any error.
+    def fetch_if_older(time, 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
+        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?
+          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
+        end
+      end
+
+      # No fetch is running, initiate a new one.
+      # Ensure only one fetch request is running at a time.
+      # If there's an ongoing fetch running, we will wait for the ongoing fetch.
+      if @ongoing_fetch
+        @fetch_finished.wait
+      else
+        @ongoing_fetch = true
+        @fetch_finished.reset
+        response = @config_fetcher.get_configuration(@cached_entry.etag)
+
+        @lock.synchronize do
+          if response.is_fetched
+            @cached_entry = response.entry
+            write_cache(response.entry)
+            @hooks.invoke_on_config_changed(response.entry.config[FEATURE_FLAGS])
+          elsif (response.is_not_modified || !response.is_transient_error) && !@cached_entry.empty?
+            @cached_entry.fetch_time = Utils.get_utc_now_seconds_since_epoch
+            write_cache(@cached_entry)
+          end
+
+          set_initialized
+        end
+
+        @ongoing_fetch = false
+        @fetch_finished.set
+      end
+
+      return @cached_entry, nil
+    end
+
+    def start_poll
+      @started = Concurrent::Event.new
+      @thread = Thread.new { run() }
+      @started.wait()
+    end
+
+    def run
+      @stopped = Concurrent::Event.new
+      @started.set
+      loop do
+        fetch_if_older(Utils.get_utc_now_seconds_since_epoch - @polling_mode.poll_interval_seconds)
+        @stopped.wait(@polling_mode.poll_interval_seconds)
+        break if @stopped.set?
+      end
+    end
+
+    def set_initialized
+      if !@initialized.set?
+        @initialized.set
+        @hooks.invoke_on_client_ready
+      end
+    end
+
+    def read_cache
+      begin
+        json_string = @config_cache.get(@cache_key)
+        if !json_string || json_string == @cached_entry_string
+          return ConfigEntry::EMPTY
+        end
+
+        @cached_entry_string = json_string
+        return ConfigEntry.create_from_json(JSON.parse(json_string))
+      rescue Exception => e
+        @log.error(2200, "Error occurred while reading the cache. #{e}")
+        return ConfigEntry::EMPTY
+      end
+    end
+
+    def write_cache(config_entry)
+      begin
+        @config_cache.set(@cache_key, config_entry.to_json.to_json)
+      rescue Exception => e
+        @log.error(2201, "Error occurred while writing the cache. #{e}")
+      end
+    end
+  end
+end

data/lib/configcat/evaluationdetails.rb

@@ -0,0 +1,23 @@
+module ConfigCat
+  class EvaluationDetails
+    attr_reader :key, :value, :variation_id, :fetch_time, :user, :is_default_value, :error,
+                :matched_evaluation_rule, :matched_evaluation_percentage_rule
+
+    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)
+      @key = key
+      @value = value
+      @variation_id = variation_id
+      @fetch_time = fetch_time
+      @user = user
+      @is_default_value = is_default_value
+      @error = error
+      @matched_evaluation_rule = matched_evaluation_rule
+      @matched_evaluation_percentage_rule = matched_evaluation_percentage_rule
+    end
+
+    def self.from_error(key, value, error:, variation_id: nil)
+      EvaluationDetails.new(key: key, value: value, variation_id: variation_id, is_default_value: true, error: error)
+    end
+  end
+end