ff-ruby-server-sdk 1.4.3 → 1.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21ede6e2de94f3ed2aec871c40b8dbee7a9feec6adbdec14726e5237caedbb0b
-  data.tar.gz: e89c0b57ae84666c87dccf6b25a67f0d0ca77990220ee014c9abe1a1225993c9
+  metadata.gz: a4ab2e35a2f4c9b26b92808b6bd3c8bc1b91dd7be7449fa1ed42324dc7a5dd8c
+  data.tar.gz: d426cc3eadd246b1db5fa67ec583fb4f5c38591195579b780687ad5582262e5e
 SHA512:
-  metadata.gz: 943c5b49c1bf887dd6ff24edce3e03cd2bff1badde8dd0802fdc8bda042e2e260b2cd7929c18189ec9dfb39f8b8189bec5b49e32ab021c722a17da71268bcccb
-  data.tar.gz: 5f32b626e8c49fd3074401db1ef6810acfb79b4cdba6f03e7f55e31a2a6e921b73ce273d71780f30dc90f18e74f691e4a203da6503bb0a473a60e49b0b56d37b
+  metadata.gz: 970504a5a04c27c883b12efc6a54cec3486c14789c3a49389a33dad1d8f43fa0f6fb26046628f397368c4cfa9eb1bd6eca91fb28b72062cd7cec8f0c69ca487a
+  data.tar.gz: d4fc7208a07a8fec31990f693358b649c5b8e63f23f9b95c605b3321d6d45e9d7a5934b262fcd248c06d3322de450eb3a3686bac63ebc8bf426e18fba2f32cf5

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)
@@ -103,12 +117,15 @@ class Evaluator < Evaluation
 
       if variation != nil
         if callback != nil
-          callback.process_evaluation(flag, target, variation)
+          feature_name = flag.feature
+          variation_identifier = variation.identifier
+          callback.process_evaluation(feature_name, target, variation_identifier)
         end
         return variation
       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/inner_client_flag_evaluate_callback.rb

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

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

@@ -1,50 +1,14 @@
 require "time"
-require "concurrent-ruby"
+require 'thread'
+require "set"
 
 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
-  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 +40,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
@@ -107,8 +76,8 @@ class MetricsProcessor < Closeable
     @config.logger.debug "Closing metrics processor"
   end
 
-  def register_evaluation(target, feature_config, variation)
-    register_evaluation_metric(feature_config, variation)
+  def register_evaluation(target, feature_name, variation_identifier)
+    register_evaluation_metric(feature_name, variation_identifier)
     if target
       register_target_metric(target)
     end
@@ -116,128 +85,129 @@ class MetricsProcessor < Closeable
 
   private
 
-  def register_evaluation_metric(feature_config, variation)
+  def register_evaluation_metric(feature_name, variation_identifier)
     # 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}")
+    # 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.
+    unless feature_name && !feature_name.empty?
+      @config.logger.warn("Skipping invalid MetricsEvent: feature_config is missing or incomplete. feature_config=#{feature_name.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}")
+    unless variation_identifier && !variation_identifier.empty?
+      @config.logger.warn("Skipping iInvalid MetricsEvent: variation is missing or incomplete. variation=#{variation_identifier.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
-
-    event = MetricsEvent.new(feature_config, GLOBAL_TARGET, variation, @config.logger)
     @metric_maps_mutex.synchronize do
-      @evaluation_metrics.increment event
+      key = "#{feature_name}\0#{variation_identifier}"
+      @evaluation_metrics[key] = (@evaluation_metrics[key] || 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
-
-      evaluation_metrics_map.clear
+    @send_data_mutex.synchronize do
+      begin
 
-      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|
-      # 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}"
+    evaluation_metrics_clone.each do |key, value|
+      feature_name, variation_identifier = key.split("\0", 2)
+
+      # Although feature_name and variation_identifier should always be present,
+      # this guard provides protection against an edge case where keys reference
+      # other objects in memory. In versions <= 1.4.4, we were keying on the MetricsEvent
+      # class (now deleted). To remediate this, we have transitioned to using strings as keys.
+      # This issue is being tracked in FFM-12192. Once resolved, these checks can be safely
+      # removed in a future release.
+      # If any required data is missing, log a detailed warning and skip processing.
+      unless feature_name && variation_identifier && value.is_a?(Integer) && value > 0
+        @config.logger.warn "Skipping invalid metrics event: missing or invalid feature_name, variation_identifier, or count. Key: #{key.inspect}, Count: #{value.inspect}"
         next
       end
 
       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_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 => @feature_name_attribute, :value => feature_name }))
+      metrics_data.attributes.push(OpenapiClient::KeyValue.new({ :key => @variation_identifier_attribute, :value => variation_identifier }))
       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 #{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 +246,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
+
+        mutex.synchronize do
+          # Wait for the specified interval or until notified
+          condition.wait(mutex, @config.frequency)
         end
-        sleep(@config.frequency)
-        run_one_iteration
+
+        # 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.5"
       end
     end
   end

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

@@ -17,7 +17,6 @@ require_relative "sdk/api/cf_client"
 require_relative "sdk/api/evaluation"
 require_relative "sdk/api/inner_client"
 require_relative "sdk/api/auth_service"
-require_relative "sdk/api/metrics_event"
 require_relative "sdk/api/default_cache"
 require_relative "sdk/api/config_builder"
 require_relative "sdk/api/file_map_store"

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.5"

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.5
 platform: ruby
 authors:
 - 'Miloš Vasić, cyr.: Милош Васић'
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-13 00:00:00.000000000 Z
+date: 2024-11-25 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
@@ -253,7 +253,6 @@ files:
 - lib/ff/ruby/server/sdk/api/inner_client_repository_callback.rb
 - lib/ff/ruby/server/sdk/api/inner_client_updater.rb
 - lib/ff/ruby/server/sdk/api/metrics_callback.rb
-- lib/ff/ruby/server/sdk/api/metrics_event.rb
 - lib/ff/ruby/server/sdk/api/metrics_processor.rb
 - lib/ff/ruby/server/sdk/api/operators.rb
 - lib/ff/ruby/server/sdk/api/polling_processor.rb

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

@@ -1,38 +0,0 @@
-class MetricsEvent
-
-  attr_accessor :feature_config, :target, :variation
-
-  def initialize(feature_config, target, variation, logger)
-
-    @target = target
-    @variation = variation
-    @feature_config = feature_config
-    @logger = logger
-    freeze
-  end
-
-  def ==(other)
-    eql?(other)
-  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
-  end
-
-  def hash
-    feature_config.feature.hash | variation.identifier.hash | target.identifier.hash
-  end
-
-
-end