ff-ruby-server-sdk 1.2.1 → 1.3.1

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

@@ -10,15 +10,12 @@ class Evaluator < Evaluation
   def initialize(repository, logger = nil)
 
     unless repository.kind_of?(Repository)
-
       raise "The 'repository' parameter must be of '" + Repository.to_s + "' data type"
     end
 
     if logger != nil
-
       @logger = logger
     else
-
       @logger = Logger.new(STDOUT)
     end
 
@@ -30,7 +27,6 @@ class Evaluator < Evaluation
     variation = evaluate(identifier, target, "boolean", callback)
 
     if variation != nil
-
       return variation.value == "true"
     end
 
@@ -43,7 +39,6 @@ class Evaluator < Evaluation
     variation = evaluate(identifier, target, "string", callback)
 
     if variation != nil
-
       return variation.value
     end
 
@@ -56,7 +51,6 @@ class Evaluator < Evaluation
     variation = evaluate(identifier, target, "int", callback)
 
     if variation != nil
-
       return variation.value.to_i
     end
 
@@ -68,7 +62,6 @@ class Evaluator < Evaluation
     variation = evaluate(identifier, target, "int", callback)
 
     if variation != nil
-
       return variation.value.to_f
     end
 
@@ -81,7 +74,6 @@ class Evaluator < Evaluation
     variation = evaluate(identifier, target, "json", callback)
 
     if variation != nil
-
       return JSON.parse(variation.value)
     end
 
@@ -92,9 +84,7 @@ class Evaluator < Evaluation
   def evaluate(identifier, target, expected, callback)
 
     if callback != nil
-
       unless callback.kind_of?(FlagEvaluateCallback)
-
         raise "The 'callback' parameter must be of '" + FlagEvaluateCallback.to_s + "' data type"
       end
     end
@@ -102,13 +92,9 @@ class Evaluator < Evaluation
     flag = @repository.get_flag(identifier)
 
     if flag != nil && flag.kind == expected
-
       unless flag.prerequisites.empty?
-
         pre_req = check_pre_requisite(flag, target)
-
         unless pre_req
-
           return find_variation(flag.variations, flag.off_variation)
         end
       end
@@ -116,12 +102,9 @@ class Evaluator < Evaluation
       variation = evaluate_flag(flag, target)
 
       if variation != nil
-
         if callback != nil
-
           callback.process_evaluation(flag, target, variation)
         end
-
         return variation
       end
     end
@@ -134,24 +117,16 @@ class Evaluator < Evaluation
   def get_attr_value(target, attribute)
 
     if attribute != nil && !attribute.empty?
-
       if target.respond_to?(attribute, :include_private)
-
         @logger.debug "The attribute " + attribute.to_s + " exists (1)"
-
         return target.send(attribute)
       else
 
         @logger.debug "target attrs: " + target.attributes.to_s
-
         result = target.attributes[attribute.to_sym]
-
         if result == nil
-
           @logger.debug "The attribute " + attribute.to_s + " does not exist"
-
         else
-
           @logger.debug "The attribute " + attribute.to_s + " exists (2)"
         end
 
@@ -167,11 +142,8 @@ class Evaluator < Evaluation
   def find_variation(variations, identifier)
 
     if identifier != nil && !identifier.empty?
-
       variations.each do |v|
-
         if v.identifier == identifier
-
           return v
         end
       end
@@ -225,12 +197,26 @@ class Evaluator < Evaluation
     nil
   end
 
+
+  def evaluate_clauses_v2(clauses, target)
+    if clauses.empty?
+      return false
+    end
+
+    # New style rules require that all clauses are true
+    clauses.each do |clause|
+      if !evaluate_clause(clause, target)
+        return false
+      end
+    end
+    true
+  end
+
   def evaluate_clauses(clauses, target)
 
     clauses.each do |clause|
 
       if evaluate_clause(clause, target)
-
         return true
       end
     end
@@ -241,24 +227,20 @@ class Evaluator < Evaluation
   def evaluate_clause(clause, target)
 
     if clause == nil
-
       return false
     end
 
     operator = clause.op
 
     if operator == nil || operator.empty?
-
       return false
     end
 
     if operator == "segmentMatch"
-
       return is_target_included_or_excluded_in_segment(clause.values, target)
     end
 
     if clause.values.empty?
-
       return false
     end
 
@@ -266,50 +248,41 @@ class Evaluator < Evaluation
     attr_value = get_attr_value(target, clause.attribute)
 
     if attr_value == nil
-
       return false
     end
 
     object = attr_value.to_s
 
     if operator == "starts_with"
-
       return object.start_with?(value)
     end
 
     if operator == "ends_with"
-
       return object.end_with?(value)
     end
 
     if operator == "match"
-
       match = object.match?(value)
       return match != nil && !match.empty?
     end
 
     if operator == "contains"
-
       return object.include?(value)
     end
 
     if operator == "equal"
-
       return object.casecmp?(value)
     end
 
     if operator == "equal_sensitive"
-
       return object == value
     end
 
     if operator == "in"
-
       return clause.values.include?(object)
     end
 
     if operator == "segmentMatch"
-
       return is_target_included_or_excluded_in_segment(clause.values, target)
     end
 
@@ -325,27 +298,34 @@ class Evaluator < Evaluation
       if segment != nil
 
         if is_target_in_list(target, segment.excluded)
-
           @logger.debug "Target " + target.name.to_s + " excluded from segment " + segment.name.to_s + " via exclude list"
-
           return false
         end
 
         if is_target_in_list(target, segment.included)
-
           @logger.debug "Target " + target.name.to_s + " included in segment " + segment.name.to_s + " via include list"
-
           return true
         end
 
-        rules = segment.rules
-
-        if rules != nil && !rules.empty? && evaluate_clauses(rules, target)
+        new_serving_rules = segment.serving_rules
+        if new_serving_rules != nil && !new_serving_rules.empty?
+          # Use enhanced rules first if they're available
 
-          @logger.debug "Target " + target.name.to_s + " included in segment " + segment.name.to_s + " via rules"
+          new_serving_rules.each do |serving_rule|
+            if evaluate_clauses_v2(serving_rule.clauses, target)
+              return true
+            end
+          end
 
-          return true
+        else
+          # Fall back to old rules
+          rules = segment.rules
+          if rules != nil && !rules.empty? && evaluate_clauses(rules, target)
+            @logger.debug "Target " + target.name.to_s + " included in segment " + segment.name.to_s + " via rules"
+            return true
+          end
         end
+
       end
     end
 
@@ -355,26 +335,17 @@ class Evaluator < Evaluation
   def evaluate_rules(serving_rules, target)
 
     if target == nil || serving_rules == nil
-
       return nil
     end
 
-    sorted = serving_rules.sort do |a, b|
-
-      b.priority <=> a.priority
-    end
-
-    sorted.each do |rule|
-
+    serving_rules.each do |rule|
       next unless evaluate_rule(rule, target)
 
       if rule.serve.distribution != nil
-
         return evaluate_distribution(rule.serve.distribution, target)
       end
 
       if rule.serve.variation != nil
-
         return rule.serve.variation
       end
     end
@@ -383,14 +354,12 @@ class Evaluator < Evaluation
   end
 
   def evaluate_rule(serving_rule, target)
-
     evaluate_clauses(serving_rule.clauses, target)
   end
 
   def evaluate_variation_map(variation_maps, target)
 
     if target == nil
-
       return nil
     end
 
@@ -399,20 +368,15 @@ class Evaluator < Evaluation
       targets = variation_map.targets
 
       if targets != nil
-
         found = nil
-
         targets.each do |t|
-
           if t.identifier != nil && t.identifier == target.identifier
-
             found = t
             break
           end
         end
 
         if found != nil
-
           return variation_map.variation
         end
       end
@@ -420,7 +384,6 @@ class Evaluator < Evaluation
       segment_identifiers = variation_map.target_segments
 
       if segment_identifiers != nil && is_target_included_or_excluded_in_segment(segment_identifiers, target)
-
         return variation_map.variation
       end
     end
@@ -433,32 +396,26 @@ class Evaluator < Evaluation
     variation = feature_config.off_variation
 
     if feature_config.state == OpenapiClient::FeatureState::ON
-
       variation = nil
 
       if feature_config.variation_to_target_map != nil
-
         variation = evaluate_variation_map(feature_config.variation_to_target_map, target)
       end
 
       if variation == nil
-
         variation = evaluate_rules(feature_config.rules, target)
       end
 
       if variation == nil
-
         variation = evaluate_distribution(feature_config.default_serve.distribution, target)
       end
 
       if variation == nil
-
         variation = feature_config.default_serve.variation
       end
     end
 
     if variation != nil
-
       return find_variation(feature_config.variations, variation)
     end
 
@@ -519,11 +476,8 @@ class Evaluator < Evaluation
   def is_target_in_list(target, list_of_targets)
 
     if list_of_targets != nil
-
       list_of_targets.each do |included_target|
-
         if included_target.identifier.include?(target.identifier)
-
           return true
         end
       end

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

@@ -17,7 +17,11 @@ class MetricsProcessor < Closeable
 
     def increment(key)
       compute(key) do |old_value|
-        if old_value == nil; 1 else old_value + 1 end
+        if old_value == nil;
+          1
+        else
+          old_value + 1
+        end
       end
     end
 
@@ -39,7 +43,6 @@ class MetricsProcessor < Closeable
     end
   end
 
-
   def init(connector, config, callback)
 
     unless connector.kind_of?(Connector)
@@ -59,14 +62,12 @@ class MetricsProcessor < Closeable
     @connector = connector
 
     @sdk_type = "SDK_TYPE"
-    @global_target_set = Set[]
-    @staging_target_set = Set[]
     @target_attribute = "target"
-    @global_target = "__global__cf_target" # <--- This target identifier is used to aggregate and send data for all
+    @global_target_identifier = "__global__cf_target" # <--- This target identifier is used to aggregate and send data for all
     #                                             targets as a summary
-
+    @global_target = Target.new("RubySDK1", identifier = @global_target_identifier, name = @global_target_name)
     @ready = false
-    @jar_version = ""
+    @jar_version = Ff::Ruby::Server::Sdk::VERSION
     @server = "server"
     @sdk_version = "SDK_VERSION"
     @sdk_language = "SDK_LANGUAGE"
@@ -76,10 +77,20 @@ class MetricsProcessor < Closeable
 
     @executor = Concurrent::FixedThreadPool.new(10)
 
-    @frequency_map = FrequencyMap.new
+    @evaluation_metrics = FrequencyMap.new
+    @target_metrics = Concurrent::Map.new
+
+    # Keep track of targets that have already been sent to avoid sending them again
+    @seen_targets = Concurrent::Map.new
 
     @max_buffer_size = config.buffer_size - 1
 
+    # Max 100k targets per interval
+    @max_targets_buffer_size = 100000
+
+    @evaluation_warning_issued = Concurrent::AtomicBoolean.new
+    @target_warning_issued = Concurrent::AtomicBoolean.new
+
     @callback.on_metrics_ready
   end
 
@@ -99,30 +110,70 @@ class MetricsProcessor < Closeable
   end
 
   def register_evaluation(target, feature_config, variation)
+    register_evaluation_metric(feature_config, variation)
+    register_target_metric(target)
+  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
+  private
+
+  def register_evaluation_metric(feature_config, variation)
+    if @evaluation_metrics.size > @max_buffer_size
+      unless @evaluation_warning_issued.true?
+        SdkCodes.warn_metrics_evaluations_max_size_exceeded(@config.logger)
+        @evaluation_warning_issued.make_true
       end
+      return
     end
 
-    event = MetricsEvent.new(feature_config, target, variation)
-    @frequency_map.increment event
+    event = MetricsEvent.new(feature_config, @global_target, variation)
+    @evaluation_metrics.increment event
   end
 
-  private
+  def register_target_metric(target)
+    if @target_metrics.size > @max_targets_buffer_size
+      unless @target_warning_issued.true?
+        SdkCodes.warn_metrics_targets_max_size_exceeded(@config.logger)
+        @target_warning_issued.make_true
+      end
+      return
+    end
+
+    if target.is_private
+      return
+    end
+
+    already_seen = @seen_targets.put_if_absent(target.identifier, true)
+
+    if already_seen
+      return
+    end
+
+    @target_metrics.put(target.identifier, target)
+  end
 
   def run_one_iteration
-    send_data_and_reset_cache @frequency_map.drain_to_map
+    send_data_and_reset_cache(@evaluation_metrics, @target_metrics)
 
-    @config.logger.debug "metrics: frequency map size #{@frequency_map.size}. global target size #{@global_target_set.size}"
+    @config.logger.debug "metrics: frequency map size #{@evaluation_metrics.size}. targets map size #{@target_metrics.size} global target size #{@seen_targets.size}"
   end
 
-  def send_data_and_reset_cache(map)
-    metrics = prepare_summary_metrics_body(map)
+  def send_data_and_reset_cache(evaluation_metrics_map, target_metrics_map)
+    evaluation_metrics_map_clone = evaluation_metrics_map.drain_to_map
+
+    target_metrics_map_clone = Concurrent::Map.new
+
+    target_metrics_map.each_pair do |key, value|
+      target_metrics_map_clone[key] = value
+    end
+
+    target_metrics_map.clear
+
+    @evaluation_warning_issued.make_false
+    @target_warning_issued.make_false
+
+    metrics = prepare_summary_metrics_body(evaluation_metrics_map_clone, target_metrics_map_clone)
 
-    if !metrics.metrics_data.empty? && !metrics.target_data.empty?
+    unless metrics.metrics_data.empty?
       start_time = (Time.now.to_f * 1000).to_i
       @connector.post_metrics(metrics)
       end_time = (Time.now.to_f * 1000).to_i
@@ -130,20 +181,13 @@ class MetricsProcessor < Closeable
         @config.logger.debug "Metrics service API duration=[" + (end_time - start_time).to_s + "]"
       end
     end
-
-    @global_target_set.merge(@staging_target_set)
-    @staging_target_set.clear
-
   end
 
-  def prepare_summary_metrics_body(freq_map)
+  def prepare_summary_metrics_body(evaluation_metrics_map, target_metrics_map)
     metrics = OpenapiClient::Metrics.new({ :target_data => [], :metrics_data => [] })
-    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
+
     total_count = 0
-    freq_map.each do |key, value|
+    evaluation_metrics_map.each do |key, value|
       total_count += value
       metrics_data = OpenapiClient::MetricsData.new({ :attributes => [] })
       metrics_data.timestamp = (Time.now.to_f * 1000).to_i
@@ -151,13 +195,17 @@ class MetricsProcessor < Closeable
       metrics_data.metrics_type = "FFMETRICS"
       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 => @target_attribute, :value => @global_target_identifier }))
       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}"
+    @config.logger.debug "Pushed #{total_count} metric evaluations to server. metrics_data count is #{evaluation_metrics_map.size}.  target_data count is #{target_metrics_map.size}"
+
+    target_metrics_map.each_pair do |_, value|
+      add_target_data(metrics, value)
+    end
 
     metrics
   end
@@ -167,28 +215,25 @@ class MetricsProcessor < Closeable
     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
+    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
-        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
+        key_value = OpenapiClient::KeyValue.new({ :key => k, :value => v.to_s })
       end
-      metrics.target_data.push(target_data)
+      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
 
   def start_async
@@ -218,7 +263,7 @@ class MetricsProcessor < Closeable
   end
 
   def get_frequency_map
-    @frequency_map
+    @evaluation_metrics
   end
 
 end

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

@@ -107,6 +107,7 @@ class StorageRepository < Repository
       return
     end
 
+    sort_flag_rules(feature_config)
     flag_key = format_flag_key(identifier)
 
     if @store != nil
@@ -141,6 +142,7 @@ class StorageRepository < Repository
       return
     end
 
+    sort_segment_serving_rules(segment)
     segment_key = format_segment_key(identifier)
 
     if @store != nil
@@ -240,6 +242,18 @@ class StorageRepository < Repository
     false
   end
 
+  def sort_flag_rules(flag)
+    if flag.rules && flag.rules.length > 1
+      flag.rules.sort_by!(&:priority)
+    end
+  end
+
+  def sort_segment_serving_rules(segment)
+    if segment.serving_rules && segment.serving_rules.length > 1
+      segment.serving_rules.sort_by!(&:priority)
+    end
+  end
+
   def is_segment_outdated(identifier, new_segment)
 
     segment = get_segment(identifier, false)

data/lib/ff/ruby/server/sdk/common/sdk_codes.rb

@@ -34,6 +34,13 @@ class SdkCodes
     logger.info SdkCodes.sdk_err_msg(7000)
   end
 
+  def self.warn_metrics_targets_max_size_exceeded(logger)
+    logger.warn SdkCodes.sdk_err_msg(7004)
+  end
+
+  def self.warn_metrics_evaluations_max_size_exceeded(logger)
+    logger.warn SdkCodes.sdk_err_msg(7007)
+  end
   def self.warn_auth_failed_srv_defaults(logger)
     logger.warn SdkCodes.sdk_err_msg(2001)
   end
@@ -89,6 +96,8 @@ class SdkCodes
       7000 => "Metrics thread started",
       7001 => "Metrics thread exited",
       7002 => "Posting metrics failed, reason:",
+      7004 => "Target metrics exceeded max size, remaining targets for this analytics interval will not be sent",
+      7007 => "Evaluation metrics exceeded max size, remaining evaluations for this analytics interval will not be sent"
     }
 
   def self.sdk_err_msg(error_code, append_text = "")