ff-ruby-server-sdk 1.4.0 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6411beee7ad512c4e70efc7d9fbd45c71835b18eff4bf41b8e056333074dc083
-  data.tar.gz: 1f13b504ffda1c95f4956813ec8dc887935340a26dcba09689864250dbf4589b
+  metadata.gz: d40a21b8332b96f4c3f507f2adece4bc12a9475fb87518323c3b79f959d2782a
+  data.tar.gz: 4be776d630a6c97cc563e801b74b8c25e6250ea3611fa83b6a1b26274ead4d06
 SHA512:
-  metadata.gz: f3cc5c07fe09718e260ca6ab19bb720d0db276a60f6ff9b9229a4374bdfeebce0b519e6edbbf82d202183382f55c447d3ed2293b614035ab4f8e2ff7880b4d56
-  data.tar.gz: 7771ae2a6823afffa73dbda7e49beceab7ad973e8ef4cb8dfdd1781ca0de7ee3a10822d19c58a749a90ffe492c72e5dbcaf0b8a05a04159c510e38d675ff25c9
+  metadata.gz: d11cd5ae4daddce986eae1faa3ca10d16e68a0c708e4e15131d0ee74883e67bac88af39cedfa1ee5497f7ac916bfd270bd8067bcbf71c3e90de242520ff49cd1
+  data.tar.gz: bfc9bc6662bc500c25281c36bb9d8352ba16bdf8ad9f43c06b44074aa4ff791e2ddb8e1e84b1796bd4fb10bfe819190d6eb33bde7ac315eff02e918784653fcb

data/docs/further_reading.md

@@ -46,7 +46,7 @@ The synchronous method is useful for environments where feature flag decisions a
 
 You can use the `wait_for_initialization` method, optionally providing a timeout in milliseconds to prevent waiting indefinitely in case of unrecoverable isues, e.g. incorrect API key used.
 
-**Usage with a timeout**
+**Usage without a timeout**
 
 ```ruby
 client = CfClient.instance
@@ -57,13 +57,15 @@ client.wait_for_initialization
 result = client.bool_variation("bool_flag", target, false)
 ```
 
-**Usage without a timeout**
+**Usage with a timeout**
 
 ```ruby
 client = CfClient.instance
 client.init(api_key, config)
 
-client.wait_for_initialization(timeout_ms: 3000)
+# Only wait for 30 seconds, after which if the SDK has not initialized the call will
+# unblock and the SDK will then serve defaults
+client.wait_for_initialization(timeout_ms: 30000)
 
 result = client.bool_variation("bool_flag", target, false)
 ```

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

@@ -1,56 +1,23 @@
-
+require 'singleton'
 require_relative "../../generated/lib/openapi_client"
 require_relative "../common/closeable"
 require_relative "inner_client"
 
 class CfClient < Closeable
-
-  # Static:
-  class << self
-
-    @@instance = CfClient.new
-
-    def instance
-
-      @@instance
+  include Singleton
+
+  def init(api_key, config, connector = nil)
+    # Only initialize if @client is nil to avoid reinitialization
+    unless @client
+      @config = config || ConfigBuilder.new.build
+      @client = InnerClient.new(api_key, @config, connector)
+      @config.logger.debug "Client initialized with API key: #{api_key}"
     end
+    @client
   end
 
-  # Static - End
-
-  def initialize(api_key = nil, config = nil, connector = nil)
-
-    if config == nil
-
-      @config = ConfigBuilder.new.build
-    else
-
-      @config = config
-    end
-
-    @client = InnerClient.new(api_key, config, connector)
-
-    @config.logger.debug "Client (1): " + @client.to_s
-  end
-
-  def init(api_key = nil, config = nil, connector = nil)
-
-    if @client == nil
-
-      @config = config
-
-      @client = InnerClient.new(
-
-        api_key = api_key,
-        config = config,
-        connector = connector
-      )
-
-      @config.logger.debug "Client (2): " + @client.to_s
-    end
-  end
 
-  def wait_for_initialization(timeout_ms: nil)
+def wait_for_initialization(timeout_ms: nil)
     if @client != nil
       @client.wait_for_initialization(timeout: timeout_ms)
     end

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

@@ -23,7 +23,7 @@ class InnerClientFlagEvaluateCallback < FlagEvaluateCallback
 
   def process_evaluation(feature_config, target, variation)
 
-    @logger.debug "Processing evaluation: " + feature_config.feature.to_s + ", " + target.identifier.to_s
+    @logger.debug "Processing evaluation: #{feature_config&.feature || 'nil feature'}, #{target&.identifier || 'nil target'}"
 
     @metrics_processor.register_evaluation(target, feature_config, variation)
   end

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

@@ -2,11 +2,12 @@ class MetricsEvent
 
   attr_accessor :feature_config, :target, :variation
 
-  def initialize(feature_config, target, variation)
+  def initialize(feature_config, target, variation, logger)
 
     @target = target
     @variation = variation
     @feature_config = feature_config
+    @logger = logger
     freeze
   end
 
@@ -15,6 +16,15 @@ class MetricsEvent
   end
 
   def eql?(other)
+    # Guard clause other is the same type.
+    # While it 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.
+    unless other.is_a?(MetricsEvent)
+      @logger.warn("Warning: Attempted to compare MetricsEvent with #{other.class.name}" )
+      return false
+    end
+
     feature_config.feature == other.feature_config.feature and
       variation.identifier == other.variation.identifier and
       target.identifier == other.target.identifier

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

@@ -9,6 +9,7 @@ require_relative "../api/metrics_event"
 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)
@@ -29,6 +30,7 @@ class MetricsProcessor < Closeable
       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|
@@ -65,7 +67,6 @@ class MetricsProcessor < Closeable
     @target_attribute = "target"
     @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 = Ff::Ruby::Server::Sdk::VERSION
     @server = "server"
@@ -77,6 +78,8 @@ class MetricsProcessor < Closeable
 
     @executor = Concurrent::FixedThreadPool.new(10)
 
+    # Used for locking the evalution and target metrics maps before we clone them
+    @metric_maps_mutex = Mutex.new
     @evaluation_metrics = FrequencyMap.new
     @target_metrics = Concurrent::Map.new
 
@@ -111,12 +114,34 @@ class MetricsProcessor < Closeable
 
   def register_evaluation(target, feature_config, variation)
     register_evaluation_metric(feature_config, variation)
-    register_target_metric(target)
+    if target
+      register_target_metric(target)
+    end
   end
 
   private
 
   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.
+    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
+    end
+
+    if GLOBAL_TARGET.nil? || !GLOBAL_TARGET.respond_to?(:identifier) || GLOBAL_TARGET.identifier.nil?
+      @config.logger.warn("Skipping invalid MetricsEvent: global_target is missing or incomplete. global_target=#{GLOBAL_TARGET.inspect}")
+      return
+    end
+
+    if variation.nil? || !variation.respond_to?(:identifier) || variation.identifier.nil?
+      @config.logger.warn("Skipping iInvalid MetricsEvent: variation is missing or incomplete. variation=#{variation.inspect}")
+      return
+    end
+
+
     if @evaluation_metrics.size > @max_buffer_size
       unless @evaluation_warning_issued.true?
         SdkCodes.warn_metrics_evaluations_max_size_exceeded(@config.logger)
@@ -125,7 +150,7 @@ class MetricsProcessor < Closeable
       return
     end
 
-    event = MetricsEvent.new(feature_config, @global_target, variation)
+    event = MetricsEvent.new(feature_config, GLOBAL_TARGET, variation, @config.logger)
     @evaluation_metrics.increment event
   end
 
@@ -158,15 +183,27 @@ class MetricsProcessor < Closeable
   end
 
   def send_data_and_reset_cache(evaluation_metrics_map, target_metrics_map)
-    evaluation_metrics_map_clone = evaluation_metrics_map.drain_to_map
 
+    evaluation_metrics_map_clone = Concurrent::Map.new
     target_metrics_map_clone = Concurrent::Map.new
 
-    target_metrics_map.each_pair do |key, value|
-      target_metrics_map_clone[key] = value
-    end
+    # 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.
+    @metric_maps_mutex.synchronize do
+      # Clone and clear evaluation metrics map
+      evaluation_metrics_map.each_pair do |key, value|
+        evaluation_metrics_map_clone[key] = value
+      end
 
-    target_metrics_map.clear
+      evaluation_metrics_map.clear
+
+      target_metrics_map.each_pair do |key, value|
+        target_metrics_map_clone[key] = value
+      end
+
+      target_metrics_map.clear
+    end
 
     @evaluation_warning_issued.make_false
     @target_warning_issued.make_false
@@ -188,6 +225,24 @@ class MetricsProcessor < Closeable
 
     total_count = 0
     evaluation_metrics_map.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.
+      # Initialize an array to collect missing components
+      missing_components = []
+
+      # Check each required component and add to missing_components if absent
+      missing_components << 'feature_config' unless key.respond_to?(:feature_config) && key.feature_config
+      missing_components << 'variation' unless key.respond_to?(:variation) && key.variation
+      missing_components << 'target' unless key.respond_to?(:target) && key.target
+      missing_components << 'count' if value.nil?
+
+      # If any components are missing, log a detailed warning and skip processing
+      unless missing_components.empty?
+        @config.logger.warn "Skipping invalid metrics event: missing #{missing_components.join(', ')} in key: #{key.inspect}, full details: #{key.inspect}"
+        next
+      end
+
       total_count += value
       metrics_data = OpenapiClient::MetricsData.new({ :attributes => [] })
       metrics_data.timestamp = (Time.now.to_f * 1000).to_i

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

@@ -5,7 +5,7 @@ module Ff
     module Server
       module Sdk
 
-        VERSION = "1.4.0"
+        VERSION = "1.4.2"
       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.0"
+export ff_ruby_sdk_version="1.4.2"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ff-ruby-server-sdk
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.2
 platform: ruby
 authors:
 - 'Miloš Vasić, cyr.: Милош Васић'
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-02 00:00:00.000000000 Z
+date: 2024-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -305,7 +305,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Harness is a feature management platform that helps teams to build better