ff-ruby-server-sdk 1.0.6 → 1.1.1

data/lib/ff/ruby/server/sdk/api/inner_client.rb

@@ -12,14 +12,14 @@ require_relative "inner_client_repository_callback"
 require_relative "inner_client_flag_evaluate_callback"
 
 require_relative "../connector/harness_connector"
+require_relative "../common/sdk_codes"
 
 class InnerClient < ClientCallback
 
   def initialize(api_key = nil, config = nil, connector = nil)
 
     if api_key == nil || api_key == ""
-
-      raise "SDK key is not provided"
+      SdkCodes::raise_missing_sdk_key config.logger
     end
 
     if config == nil
@@ -87,7 +87,7 @@ class InnerClient < ClientCallback
 
   def on_auth_success
 
-    @config.logger.info "SDK successfully logged in"
+    SdkCodes::info_sdk_auth_ok @config.logger
 
     if @closing
 
@@ -97,17 +97,20 @@ class InnerClient < ClientCallback
     @poll_processor.start
 
     if @config.stream_enabled
-
       @update_processor.start
     end
 
     if @config.analytics_enabled
-
       @metrics_processor.start
     end
 
   end
 
+  def on_auth_failed
+    SdkCodes::warn_auth_failed_srv_defaults @config.logger
+    @initialized = true
+  end
+
   def close
 
     @config.logger.info "Closing the client: " + self.to_s
@@ -201,19 +204,19 @@ class InnerClient < ClientCallback
     if processor == @poll_processor
 
       @poller_ready = true
-      @config.logger.info "PollingProcessor ready"
+      @config.logger.debug "PollingProcessor ready"
     end
 
     if processor == @update_processor
 
       @stream_ready = true
-      @config.logger.info "Updater ready"
+      @config.logger.debug "Updater ready"
     end
 
     if processor == @metrics_processor
 
       @metrics_ready = true
-      @config.logger.info "Metrics ready"
+      @config.logger.debug "Metrics ready"
     end
 
     if (@config.stream_enabled && !@stream_ready) ||
@@ -223,21 +226,16 @@ class InnerClient < ClientCallback
       return
     end
 
-    @config.logger.info "All processors now ready"
+    SdkCodes.info_sdk_init_ok @config.logger
 
     @initialized = true
-
-    # TODO: notify - Reactivity support
-    # TODO: notify_consumers - Reactivity support
-
-    @config.logger.info "Initialization is completed"
   end
 
   def wait_for_initialization
 
     synchronize do
 
-      @config.logger.info "Waiting for the initialization to finish"
+      @config.logger.debug "Waiting for initialization to finish"
 
       until @initialized
 
@@ -249,7 +247,7 @@ class InnerClient < ClientCallback
         raise "Initialization failed"
       end
 
-      @config.logger.info "Waiting for the initialization completed"
+      @config.logger.debug "Waiting for initialization has completed"
     end
   end
 
@@ -257,10 +255,6 @@ class InnerClient < ClientCallback
 
   def setup
 
-    @config.logger.info "SDK is not initialized yet! If store is used then values will be loaded from store" +
-           " otherwise default values will be used in meantime. You can use waitForInitialization method for SDK" +
-           " to be ready."
-
     @repository = StorageRepository.new(@config.cache, @repository_callback, @config.store, @config.logger)
 
     @metrics_callback = InnerClientMetricsCallback.new(self, @config.logger)
@@ -268,12 +262,13 @@ class InnerClient < ClientCallback
     @metrics_processor.init(@connector, @config, @metrics_callback)
 
     @evaluator = Evaluator.new(@repository, logger = @config.logger)
-    @evaluator_callback = InnerClientFlagEvaluateCallback.new(@metrics_processor, logger = @config.logger)
 
-    @auth_service = AuthService.new(
+    if @config.analytics_enabled
+      @evaluator_callback = InnerClientFlagEvaluateCallback.new(@metrics_processor, logger = @config.logger)
+    end
 
+    @auth_service = AuthService.new(
       connector = @connector,
-      poll_interval_in_sec = @config.poll_interval_in_seconds,
       callback = self,
       logger = @config.logger
     )
@@ -312,4 +307,5 @@ class InnerClient < ClientCallback
 
     @my_mutex.synchronize(&block)
   end
+
 end

data/lib/ff/ruby/server/sdk/api/inner_client_flag_evaluate_callback.rb

@@ -25,6 +25,6 @@ class InnerClientFlagEvaluateCallback < FlagEvaluateCallback
 
     @logger.debug "Processing evaluation: " + feature_config.feature.to_s + ", " + target.identifier.to_s
 
-    @metrics_processor.push_to_queue(target, feature_config, variation)
+    @metrics_processor.register_evaluation(target, feature_config, variation)
   end
 end

data/lib/ff/ruby/server/sdk/api/inner_client_updater.rb

@@ -53,7 +53,7 @@ class InnerClientUpdater < Updater
 
   def on_error
 
-    @logger.error "Error occurred"
+    @logger.error "InnerClientUpdater error occurred"
   end
 
   def update(message)

data/lib/ff/ruby/server/sdk/api/metrics_event.rb

@@ -2,15 +2,27 @@ class MetricsEvent
 
   attr_accessor :feature_config, :target, :variation
 
-  def initialize(
-
-    feature_config,
-    target,
-    variation
-  )
+  def initialize(feature_config, target, variation)
 
     @target = target
     @variation = variation
     @feature_config = feature_config
+    freeze
+  end
+
+  def ==(other)
+    eql?(other)
+  end
+
+  def eql?(other)
+    feature_config.feature == other.feature_config.feature and
+      variation.identifier == other.variation.identifier and
+      target.identifier == other.target.identifier
   end
+
+  def hash
+    feature_config.feature.hash | variation.identifier.hash | target.identifier.hash
+  end
+
+
 end

data/lib/ff/ruby/server/sdk/api/metrics_processor.rb

@@ -4,30 +4,53 @@ require "concurrent-ruby"
 require_relative "../dto/target"
 require_relative "../../sdk/version"
 require_relative "../common/closeable"
+require_relative "../common/sdk_codes"
 require_relative "../api/metrics_event"
 require_relative "../api/summary_metrics"
 
 class MetricsProcessor < Closeable
 
-  def init(
+  class FrequencyMap < Concurrent::Map
+    def initialize(options = nil, &block)
+      super
+    end
 
-    connector,
-    config,
-    callback
-  )
+    def increment(key)
+      compute(key) do |old_value|
+        if old_value == nil; 1 else old_value + 1 end
+      end
+    end
 
-    unless connector.kind_of?(Connector)
+    def get(key)
+      self[key]
+    end
+
+    def drain_to_map
+      result = {}
+      each_key do |key|
+        result[key] = 0
+      end
+      result.each_key do |key|
+        value = get_and_set(key, 0)
+        result[key] = value
+        delete_pair(key, 0)
+      end
+      result
+    end
+  end
 
+
+  def init(connector, config, callback)
+
+    unless connector.kind_of?(Connector)
       raise "The 'connector' must be of '" + Connector.to_s + "' data type"
     end
 
     unless callback.kind_of?(MetricsCallback)
-
       raise "The 'callback' must be of '" + MetricsCallback.to_s + "' data type"
     end
 
     unless config.kind_of?(Config)
-
       raise "The 'config' must be of '" + Config.to_s + "' data type"
     end
 
@@ -51,247 +74,151 @@ class MetricsProcessor < Closeable
     @feature_name_attribute = "featureName"
     @variation_identifier_attribute = "variationIdentifier"
 
-    @queue = SizedQueue.new(@config.buffer_size)
-    @executor = Concurrent::FixedThreadPool.new(100)
+    @executor = Concurrent::FixedThreadPool.new(10)
+
+    @frequency_map = FrequencyMap.new
+
+    @max_buffer_size = config.buffer_size - 1
 
     @callback.on_metrics_ready
   end
 
   def start
-
-    @config.logger.info "Starting metrics processor with request interval: " + @config.frequency.to_s
+    @config.logger.debug "Starting metrics processor with request interval: " + @config.frequency.to_s
     start_async
   end
 
   def stop
-
-    @config.logger.info "Stopping metrics processor"
+    @config.logger.debug "Stopping metrics processor"
     stop_async
   end
 
   def close
-
     stop
-    @config.logger.info "Closing metrics processor"
-  end
-
-  def push_to_queue(
-
-    target,
-    feature_config,
-    variation
-  )
-
-    @executor.post do
-
-      @config.logger.debug "Pushing to the metrics queue: START"
-
-      event = MetricsEvent.new(feature_config, target, variation)
-      @queue.push(event)
-
-      @config.logger.debug "Pushing to the metrics queue: END, queue size: " + @queue.size.to_s
-
-    end
+    @config.logger.debug "Closing metrics processor"
   end
 
-  def send_data_and_reset_cache(data)
-
-    @config.logger.debug "Reading from queue and building cache"
-
-    @jar_version = get_version
-
-    unless data.empty?
-
-      map = {}
+  def register_evaluation(target, feature_config, variation)
 
-      data.each do |event|
-
-        new_value = 1
-        current = map[event]
-
-        if current != nil
-
-          new_value = current + 1
-        end
-
-        map[event] = new_value
-      end
-
-      metrics = prepare_summary_metrics_body(map)
-
-      if !metrics.metrics_data.empty? && !metrics.target_data.empty?
-
-        start_time = (Time.now.to_f * 1000).to_i
-
-        @connector.post_metrics(metrics)
-
-        end_time = (Time.now.to_f * 1000).to_i
-
-        if end_time - start_time > @config.metrics_service_acceptable_duration
-
-          @config.logger.debug "Metrics service API duration=[" + (end_time - start_time).to_s + "]"
-        end
+    if @frequency_map.size > @max_buffer_size
+      @config.logger.warn "metrics buffer is full #{@frequency_map.size} - flushing metrics"
+      @executor.post do
+        run_one_iteration
       end
-
-      @global_target_set.merge(@staging_target_set)
-      @staging_target_set.clear
     end
+
+    event = MetricsEvent.new(feature_config, target, variation)
+    @frequency_map.increment event
   end
 
-  protected
+  private
 
   def run_one_iteration
+    send_data_and_reset_cache @frequency_map.drain_to_map
 
-    @config.logger.debug "Async metrics iteration: " + @thread.to_s
-
-    data = []
+    @config.logger.debug "metrics: frequency map size #{@frequency_map.size}. global target size #{@global_target_set.size}"
+  end
 
-    until @queue.empty?
+  def send_data_and_reset_cache(map)
+    metrics = prepare_summary_metrics_body(map)
 
-      item = @queue.pop
-      data.push(item)
+    if !metrics.metrics_data.empty? && !metrics.target_data.empty?
+      start_time = (Time.now.to_f * 1000).to_i
+      @connector.post_metrics(metrics)
+      end_time = (Time.now.to_f * 1000).to_i
+      if end_time - start_time > @config.metrics_service_acceptable_duration
+        @config.logger.debug "Metrics service API duration=[" + (end_time - start_time).to_s + "]"
+      end
     end
 
-    send_data_and_reset_cache(data)
-  end
+    @global_target_set.merge(@staging_target_set)
+    @staging_target_set.clear
 
-  def prepare_summary_metrics_body(data)
+  end
 
-    summary_metrics_data = {}
+  def prepare_summary_metrics_body(freq_map)
     metrics = OpenapiClient::Metrics.new({ :target_data => [], :metrics_data => [] })
-
-    add_target_data(
-
-      metrics,
-      Target.new(
-
-        name = @global_target_name,
-        identifier = @global_target
-      )
-    )
-
-    data.each do |key, value|
-
-      target = key.target
-
-      add_target_data(metrics, target)
-
-      summary_metrics = prepare_summary_metrics_key(key)
-
-      summary_metrics_data[summary_metrics] = value
+    add_target_data(metrics, Target.new(name = @global_target_name, identifier = @global_target))
+    freq_map.each_key do |key|
+      add_target_data(metrics, key.target)
     end
-
-    summary_metrics_data.each do |key, value|
-
+    total_count = 0
+    freq_map.each do |key, value|
+      total_count += value
       metrics_data = OpenapiClient::MetricsData.new({ :attributes => [] })
       metrics_data.timestamp = (Time.now.to_f * 1000).to_i
       metrics_data.count = value
       metrics_data.metrics_type = "FFMETRICS"
-      metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @feature_name_attribute, :value => key.feature_name }))
-      metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @variation_identifier_attribute, :value => key.variation_identifier }))
+      metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @feature_name_attribute, :value => key.feature_config.feature }))
+      metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @variation_identifier_attribute, :value => key.variation.identifier }))
       metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @target_attribute, :value => @global_target }))
       metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @sdk_type, :value => @server }))
       metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @sdk_language, :value => "ruby" }))
       metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @sdk_version, :value => @jar_version }))
-
       metrics.metrics_data.push(metrics_data)
     end
+    @config.logger.debug "Pushed #{total_count} metric evaluations to server. metrics_data count is #{freq_map.size}"
 
     metrics
   end
 
-  private
-
-  def start_async
-
-    @config.logger.debug "Async starting: " + self.to_s
-
-    @ready = true
-
-    @thread = Thread.new do
-
-      @config.logger.debug "Async started: " + self.to_s
-
-      while @ready do
-
-        unless @initialized
-
-          @initialized = true
-          @config.logger.info "Metrics processor initialized"
-        end
-
-        sleep(@config.frequency)
-
-        run_one_iteration
-      end
-    end
-
-    @thread.run
-  end
-
-  def stop_async
-
-    @queue.clear
-
-    @ready = false
-    @initialized = false
-  end
-
-  def prepare_summary_metrics_key(key)
-
-    SummaryMetrics.new(
-
-      feature_name = key.feature_config.feature,
-      variation_identifier = key.variation.identifier,
-      variation_value = key.variation.value
-    )
-  end
-
   def add_target_data(metrics, target)
 
     target_data = OpenapiClient::TargetData.new({ :attributes => [] })
     private_attributes = target.private_attributes
 
     if !@staging_target_set.include?(target) && !@global_target_set.include?(target) && !target.is_private
-
       @staging_target_set.add(target)
-
       attributes = target.attributes
-
       attributes.each do |k, v|
-
         key_value = OpenapiClient::KeyValue.new
-
         if !private_attributes.empty?
-
           unless private_attributes.include?(k)
-
             key_value = OpenapiClient::KeyValue.new({ :key => k, :value => v.to_s })
           end
         else
-
           key_value = OpenapiClient::KeyValue.new({ :key => k, :value => v.to_s })
         end
-
         target_data.attributes.push(key_value)
       end
-
       target_data.identifier = target.identifier
-
       if target.name == nil || target.name == ""
-
         target_data.name = target.identifier
       else
-
         target_data.name = target.name
       end
-
       metrics.target_data.push(target_data)
     end
   end
 
-  def get_version
+  def start_async
+    @config.logger.debug "Async starting: " + self.to_s
+    @ready = true
+    @thread = Thread.new do
+      @config.logger.debug "Async started: " + self.to_s
+      while @ready do
+        unless @initialized
+          @initialized = true
+          SdkCodes::info_metrics_thread_started @config.logger
+        end
+        sleep(@config.frequency)
+        run_one_iteration
+      end
+    end
+    @thread.run
+  end
 
+  def stop_async
+    @ready = false
+    @initialized = false
+  end
+
+  def get_version
     Ff::Ruby::Server::Sdk::VERSION
   end
+
+  def get_frequency_map
+    @frequency_map
+  end
+
 end

data/lib/ff/ruby/server/sdk/api/polling_processor.rb

@@ -29,13 +29,13 @@ class PollingProcessor < Closeable
 
     flags = []
 
-    @logger.info "Fetching flags started"
+    @logger.debug "Fetching flags started"
 
     result = @connector.get_flags
 
     if result != nil
 
-      @logger.info "Flags are fetched"
+      @logger.debug "Flags are fetched"
 
       result.each { |fc|
 
@@ -47,7 +47,7 @@ class PollingProcessor < Closeable
       }
     end
 
-    @logger.info "Fetching flags finished"
+    @logger.debug "Fetching flags finished"
 
     flags
   end
@@ -56,13 +56,13 @@ class PollingProcessor < Closeable
 
     segments = []
 
-    @logger.info "Fetching segments started"
+    @logger.debug "Fetching segments started"
 
     result = @connector.get_segments
 
     if result != nil
 
-      @logger.info "Segments are fetched"
+      @logger.debug "Segments are fetched"
 
       result.each { |s|
 
@@ -74,7 +74,7 @@ class PollingProcessor < Closeable
       }
     end
 
-    @logger.info "Fetching segments finished"
+    @logger.debug "Fetching segments finished"
 
     segments
   end
@@ -106,7 +106,7 @@ class PollingProcessor < Closeable
           unless @initialized
 
             @initialized = true
-            @logger.info "PollingProcessor initialized"
+            SdkCodes::info_poll_started(@logger, @poll_interval_in_sec)
 
             if @callback != nil
 
@@ -137,17 +137,16 @@ class PollingProcessor < Closeable
 
   def start
 
-    @logger.info "Starting PollingProcessor with request interval: " + @poll_interval_in_sec.to_s
+    @logger.debug "Starting PollingProcessor with request interval: " + @poll_interval_in_sec.to_s
     start_async
   end
 
   def stop
 
-    @logger.info "Stopping PollingProcessor"
+    @logger.debug "Stopping PollingProcessor"
     stop_async
     unless @ready
-
-      @logger.info "PollingProcessor stopped"
+      SdkCodes::info_polling_stopped @logger
     end
   end
 

data/lib/ff/ruby/server/sdk/api/update_processor.rb

@@ -28,7 +28,7 @@ class UpdateProcessor < Closeable
 
   def start
 
-    @logger.info "Starting updater (EventSource)"
+    @logger.debug "Starting updater (EventSource)"
 
     if @updater != nil
 
@@ -105,8 +105,6 @@ class UpdateProcessor < Closeable
 
   def process_flag(message)
 
-    @logger.info "Processing flag message: " + message.to_s
-
     config = @connector.get_flag(message["identifier"])
 
     if config != nil