ff-ruby-server-sdk 1.4.3 → 1.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21ede6e2de94f3ed2aec871c40b8dbee7a9feec6adbdec14726e5237caedbb0b
-  data.tar.gz: e89c0b57ae84666c87dccf6b25a67f0d0ca77990220ee014c9abe1a1225993c9
+  metadata.gz: c9ee87181e0d3822c070ba3c889bf4b339b1c4e7853b046885c98372d25f7a5e
+  data.tar.gz: 3692d620f62ff96a59b17a4bcbd939f245e0ae1befcb9b477bb7389d5beca7e7
 SHA512:
-  metadata.gz: 943c5b49c1bf887dd6ff24edce3e03cd2bff1badde8dd0802fdc8bda042e2e260b2cd7929c18189ec9dfb39f8b8189bec5b49e32ab021c722a17da71268bcccb
-  data.tar.gz: 5f32b626e8c49fd3074401db1ef6810acfb79b4cdba6f03e7f55e31a2a6e921b73ce273d71780f30dc90f18e74f691e4a203da6503bb0a473a60e49b0b56d37b
+  metadata.gz: b9c6768454e988de4a4829b9c34d3e168ad43ad5a6d5100ca9671bac272714074b5245fe688aaa0bac81da820f1c172e4cc3fb6ceb577e444b22e833d4578980
+  data.tar.gz: 404694820857c6e8959ac6fdc711bf4119779c0b52f8e48ee56c38e27814a6d7bbe024d7423be9d6e90549c087b68da0add84f7a3911b9a820102da621641d27

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

@@ -91,6 +91,20 @@ class Evaluator < Evaluation
 
     flag = @repository.get_flag(identifier)
 
+    # Check if flag exists
+    if flag.nil?
+      # Log a warning if the flag is not found
+      @logger.warn "Flag not found for identifier '#{identifier}'. Serving default variation."
+      return nil
+    end
+
+    # Check if the flag's kind matches the expected type
+    unless flag.kind == expected
+      @logger.warn "Flag kind mismatch: expected '#{expected}', but got '#{flag.kind}' for identifier '#{identifier}'. Serving default variation."
+      return nil
+    end
+
+    # Proceed with prerequisite check if flag type is as expected
     if flag != nil && flag.kind == expected
       unless flag.prerequisites.empty?
         pre_req = check_pre_requisite(flag, target)
@@ -109,6 +123,7 @@ class Evaluator < Evaluation
       end
     end
 
+    # Returning nil will indicate to callers to serve the default variation
     nil
   end
 

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

@@ -50,6 +50,7 @@ class InnerClient < ClientCallback
 
       @connector = connector
     end
+    @condition = ConditionVariable.new
 
     @closing = false
     @failure = false
@@ -66,22 +67,34 @@ class InnerClient < ClientCallback
   end
 
   def bool_variation(identifier, target, default_value)
-
+    unless @initialized
+      log_sdk_not_initialized_warning(identifier, default_value)
+      return default_value
+    end
     @evaluator.bool_variation(identifier, target, default_value, @evaluator_callback)
   end
 
   def string_variation(identifier, target, default_value)
-
+    unless @initialized
+      log_sdk_not_initialized_warning(identifier, default_value)
+      return default_value
+    end
     @evaluator.string_variation(identifier, target, default_value, @evaluator_callback)
   end
 
   def number_variation(identifier, target, default_value)
-
+    unless @initialized
+      log_sdk_not_initialized_warning(identifier, default_value)
+      return default_value
+    end
     @evaluator.number_variation(identifier, target, default_value, @evaluator_callback)
   end
 
   def json_variation(identifier, target, default_value)
-
+    unless @initialized
+      log_sdk_not_initialized_warning(identifier, default_value)
+      return default_value
+    end
     @evaluator.json_variation(identifier, target, default_value, @evaluator_callback)
   end
 
@@ -109,6 +122,7 @@ class InnerClient < ClientCallback
   def on_auth_failed
     SdkCodes::warn_auth_failed_srv_defaults @config.logger
     @initialized = true
+    @condition.signal
   end
 
   def close
@@ -195,67 +209,74 @@ class InnerClient < ClientCallback
   end
 
   def on_processor_ready(processor)
+    @my_mutex.synchronize do
 
-    if @closing
+      if @closing
 
-      return
-    end
+        return
+      end
 
-    if processor == @poll_processor
+      if processor == @poll_processor
 
-      @poller_ready = true
-      @config.logger.debug "PollingProcessor ready"
-    end
+        @poller_ready = true
+        @config.logger.debug "PollingProcessor ready"
+      end
 
-    if processor == @update_processor
+      if processor == @update_processor
 
-      @stream_ready = true
-      @config.logger.debug "Updater ready"
-    end
+        @stream_ready = true
+        @config.logger.debug "Updater ready"
+      end
 
-    if processor == @metrics_processor
+      if processor == @metrics_processor
 
-      @metrics_ready = true
-      @config.logger.debug "Metrics ready"
-    end
+        @metrics_ready = true
+        @config.logger.debug "Metrics ready"
+      end
 
-    if (@config.stream_enabled && !@stream_ready) ||
-      (@config.analytics_enabled && !@metrics_ready) ||
-      !@poller_ready
+      if (@config.stream_enabled && !@stream_ready) ||
+        (@config.analytics_enabled && !@metrics_ready) ||
+        !@poller_ready
 
-      return
-    end
+        return
+      end
 
-    SdkCodes.info_sdk_init_ok @config.logger
+      SdkCodes.info_sdk_init_ok @config.logger
 
-    @initialized = true
+      @condition.signal
+      @initialized = true
+    end
   end
 
   def wait_for_initialization(timeout: nil)
-    synchronize do
-      SdkCodes::info_sdk_waiting_to_initialize(@config.logger, timeout)
+    SdkCodes::info_sdk_waiting_to_initialize(@config.logger, timeout)
+    return if @initialized
 
+    @my_mutex.synchronize do
       start_time = Time.now
+      remaining = timeout ? timeout / 1000.0 : nil # Convert timeout to seconds
 
       until @initialized
-        # Check if a timeout is specified and has been exceeded
-        if timeout && (Time.now - start_time) > (timeout / 1000.0)
-          @config.logger.warn "The SDK has timed out waiting to initialize with supplied timeout #{timeout} ms"
-          handle_initialization_failure
-        end
 
-        sleep(1)
-      end
+        # Break if timeout has elapsed
+        if remaining && remaining <= 0
+          @config.logger.warn "The SDK has timed out waiting to initialize with supplied timeout #{timeout} ms. The SDK will continue to initialize in the background.  Default variations will be served until the SDK initializes."
+          break
+        end
+        # Wait for the signal or timeout
+        @condition.wait(@my_mutex, remaining)
 
-      if @failure
-        raise "Initialization failed"
+        # Recalculate the remaining time after the wait
+        if timeout
+          elapsed = Time.now - start_time
+          remaining = (timeout / 1000.0) - elapsed
+        end
       end
 
-      @config.logger.debug "Waiting for initialization has completed"
+      @config.logger.debug "Waiting for initialization has completed" if @initialized
     end
   end
 
-
   protected
 
   def handle_initialization_failure
@@ -316,9 +337,8 @@ class InnerClient < ClientCallback
 
   private
 
-  def synchronize(&block)
-
-    @my_mutex.synchronize(&block)
+  def log_sdk_not_initialized_warning(identifier, default_value)
+    @config.logger.warn "SDKCODE:6001: SDK is not initialized; serving default variation for bool variation: identifier=#{identifier}, default=#{default_value}"
   end
 
 end

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

@@ -21,7 +21,11 @@ class MetricsEvent
     # project sizes. Issue being tracked in FFM-12192, and once resolved, can feasibly remove
     # these checks in a future release.
     unless other.is_a?(MetricsEvent)
-      @logger.warn("Warning: Attempted to compare MetricsEvent with #{other.class.name}" )
+      # We should always have a logger available except when we've deep cloned this class.  We don't do any
+      # equality check on clones in metrics code anyway, so this is just a safety check.
+      if @logger
+        @logger.warn("Warning: Attempted to compare MetricsEvent with #{other.class.name}")
+      end
       return false
     end
 
@@ -35,4 +39,15 @@ class MetricsEvent
   end
 
 
+  # Exclude logger from serialization
+  def marshal_dump
+    [@feature_config, @target, @variation]
+  end
+
+  def marshal_load(array)
+    @feature_config, @target, @variation = array
+    @logger = nil
+  end
+
+
 end

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

@@ -1,5 +1,6 @@
 require "time"
-require "concurrent-ruby"
+require 'thread'
+require "set"
 
 require_relative "../dto/target"
 require_relative "../../sdk/version"
@@ -11,40 +12,6 @@ require_relative "../api/summary_metrics"
 class MetricsProcessor < Closeable
   GLOBAL_TARGET = Target.new(identifier: "__global__cf_target", name: "Global Target").freeze
 
-  class FrequencyMap < Concurrent::Map
-    def initialize(options = nil, &block)
-      super
-    end
-
-    def increment(key)
-      compute(key) do |old_value|
-        if old_value == nil;
-          1
-        else
-          old_value + 1
-        end
-      end
-    end
-
-    def get(key)
-      self[key]
-    end
-
-    # TODO Will be removed in V2 in favour of simplified clearing. Currently not used outside of tests.
-    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)
@@ -76,15 +43,20 @@ class MetricsProcessor < Closeable
     @feature_name_attribute = "featureName"
     @variation_identifier_attribute = "variationIdentifier"
 
-    @executor = Concurrent::FixedThreadPool.new(10)
-
-    # Used for locking the evalution and target metrics maps before we clone them
+    # Evaluation and target metrics
     @metric_maps_mutex = Mutex.new
-    @evaluation_metrics = FrequencyMap.new
-    @target_metrics = Concurrent::Map.new
+    @evaluation_metrics = {}
+    @target_metrics = {}
 
-    # Keep track of targets that have already been sent to avoid sending them again
-    @seen_targets = Concurrent::Map.new
+    # Keep track of targets that have already been sent to avoid sending them again. We track a max 500K targets
+    # to prevent unbounded growth.
+    @seen_targets_mutex = Mutex.new
+    @seen_targets = Set.new
+    @max_seen_targets = 500000
+    @seen_targets_full = false
+
+    # Mutex to protect aggregation and sending metrics at the end of an interval
+    @send_data_mutex = Mutex.new
 
     @callback.on_metrics_ready
   end
@@ -118,9 +90,9 @@ class MetricsProcessor < Closeable
 
   def register_evaluation_metric(feature_config, variation)
     # Guard clause to ensure feature_config, @global_target, and variation are valid.
-    # While they should be, this adds protection for an edge case we are seeing with very large
-    # project sizes.  Issue being tracked in FFM-12192, and once resolved, can feasibly remove
-    # these checks in a future release.
+    # While they should be, this adds protection for an edge case we are seeing where the the ConcurrentMap (now replaced with our own thread safe hash)
+    # seemed to be accessing invalid areas of memory and seg faulting.
+    # Issue being tracked in FFM-12192, and once resolved, can remove these checks in a future release && once the issue is resolved.
     if feature_config.nil? || !feature_config.respond_to?(:feature) || feature_config.feature.nil?
       @config.logger.warn("Skipping invalid MetricsEvent: feature_config is missing or incomplete. feature_config=#{feature_config.inspect}")
       return
@@ -138,72 +110,81 @@ class MetricsProcessor < Closeable
 
     event = MetricsEvent.new(feature_config, GLOBAL_TARGET, variation, @config.logger)
     @metric_maps_mutex.synchronize do
-      @evaluation_metrics.increment event
+      @evaluation_metrics[event] = (@evaluation_metrics[event] || 0) + 1
     end
   end
 
   def register_target_metric(target)
-    if target.is_private
-      return
-    end
-
-    already_seen = @seen_targets.put_if_absent(target.identifier, true)
-
-    if already_seen
-      return
+    return if target.is_private
+
+    add_to_target_metrics = @seen_targets_mutex.synchronize do
+      # If the set is full, directly allow adding to target_metrics
+      if @seen_targets_full
+        true
+      elsif @seen_targets.include?(target.identifier)
+        false
+      else
+        @seen_targets.add(target.identifier)
+        @seen_targets_full = @seen_targets.size >= @max_seen_targets
+        true
+      end
     end
 
+    # Add to target_metrics if marked for inclusion
     @metric_maps_mutex.synchronize do
-      @target_metrics.put(target.identifier, target)
-    end
+      @target_metrics[target.identifier] = target
+    end if add_to_target_metrics
   end
 
+
   def run_one_iteration
     send_data_and_reset_cache(@evaluation_metrics, @target_metrics)
   end
 
   def send_data_and_reset_cache(evaluation_metrics_map, target_metrics_map)
-    # A single lock is used to synchronise access to both the evaluation and target metrics maps.
-    # While separate locks could be applied to each map individually, we want an interval's eval/target
-    # metrics to be processed in an atomic unit.
-    evaluation_metrics_map_clone, target_metrics_map_clone = @metric_maps_mutex.synchronize do
-
-      clone_evaluations = Concurrent::Map.new
-      clone_targets = Concurrent::Map.new
-      # Clone and clear evaluation metrics map
-      evaluation_metrics_map.each_pair do |key, value|
-        clone_evaluations[key] = value
-      end
+    @send_data_mutex.synchronize do
+      begin
 
-      evaluation_metrics_map.clear
-
-      target_metrics_map.each_pair do |key, value|
-        clone_targets[key] = value
-      end
+        evaluation_metrics_map_clone, target_metrics_map_clone = @metric_maps_mutex.synchronize do
+          # Check if we have metrics to send; if not, skip sending metrics
+          if evaluation_metrics_map.empty? && target_metrics_map.empty?
+            @config.logger.debug "No metrics to send. Skipping sending metrics this interval"
+            return
+          end
 
-      target_metrics_map.clear
+          # Deep clone the evaluation metrics
+          cloned_evaluations = Marshal.load(Marshal.dump(evaluation_metrics_map)).freeze
+          evaluation_metrics_map.clear
 
-      [clone_evaluations, clone_targets]
+          # Deep clone the target metrics
+          cloned_targets = Marshal.load(Marshal.dump(target_metrics_map)).freeze
+          target_metrics_map.clear
+          [cloned_evaluations, cloned_targets]
 
-    end
+        end
 
-    metrics = prepare_summary_metrics_body(evaluation_metrics_map_clone, target_metrics_map_clone)
+        metrics = prepare_summary_metrics_body(evaluation_metrics_map_clone, target_metrics_map_clone)
 
-    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
-      if end_time - start_time > @config.metrics_service_acceptable_duration
-        @config.logger.debug "Metrics service API duration=[" + (end_time - start_time).to_s + "]"
+        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
+          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
+      rescue => e
+        @config.logger.warn "Error when preparing and sending metrics: #{e.message}"
+        @config.logger.warn e.backtrace&.join("\n") || "No backtrace available"
       end
     end
   end
 
-  def prepare_summary_metrics_body(evaluation_metrics_map, target_metrics_map)
+  def prepare_summary_metrics_body(evaluation_metrics_clone, target_metrics_clone)
     metrics = OpenapiClient::Metrics.new({ :target_data => [], :metrics_data => [] })
 
     total_count = 0
-    evaluation_metrics_map.each do |key, value|
+    evaluation_metrics_clone.each do |key, value|
       # While Components should not be missing, this adds protection for an edge case we are seeing with very large
       # project sizes.  Issue being tracked in FFM-12192, and once resolved, can feasibly remove
       # these checks in a future release.
@@ -235,9 +216,9 @@ class MetricsProcessor < Closeable
       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 #{evaluation_metrics_map.size}.  target_data count is #{target_metrics_map.size}"
+    @config.logger.debug "Pushed #{total_count} metric evaluations to server. metrics_data count is #{evaluation_metrics_clone.size}.  target_data count is #{target_metrics_clone.size}"
 
-    target_metrics_map.each_pair do |_, value|
+    target_metrics_clone.each_pair do |_, value|
       add_target_data(metrics, value)
     end
 
@@ -276,18 +257,27 @@ class MetricsProcessor < Closeable
     @running = true
     @thread = Thread.new do
       @config.logger.debug "Async started: " + self.to_s
-      while @ready do
+      mutex = Mutex.new
+      condition = ConditionVariable.new
+
+      while @ready
         unless @initialized
           @initialized = true
-          SdkCodes::info_metrics_thread_started @config.logger
+          SdkCodes::info_metrics_thread_started(@config.logger)
         end
-        sleep(@config.frequency)
-        run_one_iteration
+
+        mutex.synchronize do
+          # Wait for the specified interval or until notified
+          condition.wait(mutex, @config.frequency)
+        end
+
+        # Re-check @ready before running the iteration
+        run_one_iteration if @ready
       end
     end
-    @thread.run
   end
 
+
   def stop_async
     @ready = false
     @initialized = false

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

@@ -15,7 +15,7 @@ class UpdateProcessor < Closeable
     @connector = connector
     @repository = repository
     @updater = callback
-    @executor = Concurrent::FixedThreadPool.new(100)
+    @executor = Concurrent::FixedThreadPool.new(20)
 
     if logger != nil
 

data/lib/ff/ruby/server/sdk/version.rb

@@ -5,7 +5,7 @@ module Ff
     module Server
       module Sdk
 
-        VERSION = "1.4.3"
+        VERSION = "1.4.4"
       end
     end
   end

data/scripts/sdk_specs.sh

@@ -1,4 +1,4 @@
 #!/bin/bash
 
 export ff_ruby_sdk="ff-ruby-server-sdk"
-export ff_ruby_sdk_version="1.4.3"
+export ff_ruby_sdk_version="1.4.4"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ff-ruby-server-sdk
 version: !ruby/object:Gem::Version
-  version: 1.4.3
+  version: 1.4.4
 platform: ruby
 authors:
 - 'Miloš Vasić, cyr.: Милош Васић'
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-13 00:00:00.000000000 Z
+date: 2024-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -142,14 +142,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.6
+        version: 0.1.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.6
+        version: 0.1.7
 - !ruby/object:Gem::Dependency
   name: typhoeus
   requirement: !ruby/object:Gem::Requirement