fix: Release stopped event processors and keep identifiers out of logs

- Stop running event processors at exit from one registry that a
  stopped processor leaves, instead of an at_exit block per start that
  kept every processor in memory.
- Drop the identifier from the duplicate exposure debug log.
- Give the accurate reason when get_experiment_flag skips an exposure
  because flags come from the environment document, which carries no
  experiment data.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: flagsmithsmith[bot]

lib/flagsmith.rb

@@ -220,7 +220,8 @@ def get_value_for_identity(feature_name, user_id = nil, default: nil)
 
     # Get a flag for an identity, taking the same traits as get_identity_flags, and record the
     # identity's exposure to the variant it was served when it is in the feature's running experiment.
-    # Requires enable_events.
+    # Requires enable_events. Exposure needs remote evaluation: the environment document used by local
+    # evaluation and offline mode carries no experiment data, so no exposure is recorded in those modes.
     def get_experiment_flag(feature_name, identifier, **traits)
       require_events!
       flag = get_identity_flags(identifier, **traits)[feature_name]
@@ -281,6 +282,7 @@ def require_events!
     def exposure_skip_reason(flag)
       return 'feature not found' unless flag.is_a?(Flagsmith::Flags::Flag)
       return 'feature is disabled' unless flag.enabled?
+      return 'experiments need remote evaluation, not local evaluation or offline mode' if environment
       return 'identity is not in a running experiment' unless flag.experiment&.in_experiment?
 
       'flag has no variant' if flag.variant.nil?

lib/flagsmith/sdk/event_processor.rb

@@ -3,6 +3,25 @@
 require 'set'
 
 module Flagsmith
+  # Started event processors, stopped together at exit. A stopped processor leaves, so it is not kept in memory.
+  module RunningEventProcessors
+    @processors = Set.new
+    @mutex = Mutex.new
+    at_exit { to_a.each(&:stop) }
+
+    def self.add(processor)
+      @mutex.synchronize { @processors.add(processor) }
+    end
+
+    def self.delete(processor)
+      @mutex.synchronize { @processors.delete(processor) }
+    end
+
+    def self.to_a
+      @mutex.synchronize { @processors.to_a }
+    end
+  end
+
   # Buffers tracking and exposure events, and sends them to the Flagsmith events API in batches.
   #
   # Events are sent every +flush_interval_seconds+, as soon as +max_buffer_items+ are buffered,
@@ -58,12 +77,13 @@ def start
       return if @interval
 
       @interval = set_interval(@flush_interval_seconds) { flush }
-      at_exit { stop }
+      RunningEventProcessors.add(self)
     end
 
     def stop
       @flush_mutex.synchronize { clear_interval(@interval) } if @interval # never interrupts a batch being sent
       @interval = nil
+      RunningEventProcessors.delete(self)
       flush
     end
 
@@ -122,7 +142,7 @@ def duplicate_exposure?(event)
       return false unless event[:event] == FLAG_EXPOSURE_EVENT
       return false if @buffered_exposures.add?(event.values_at(:feature_name, :identifier, :value))
 
-      @logger.debug "Skipping duplicate #{FLAG_EXPOSURE_EVENT} event for feature #{event[:feature_name]}, identifier #{event[:identifier]}"
+      @logger.debug "Skipping duplicate #{FLAG_EXPOSURE_EVENT} event for feature #{event[:feature_name]}"
       true
     end
 

spec/sdk/event_processor_spec.rb

@@ -99,7 +99,7 @@ def respond_to_events_with(status)
     # Then
     expect(sent_batches[0][:body]['events'].map { |event| event['identifier'] }).to eq(%w[user_123 user_456])
     expect(logger).to have_received(:debug)
-      .with('Skipping duplicate $flag_exposure event for feature banner, identifier user_123').once
+      .with('Skipping duplicate $flag_exposure event for feature banner').once
   end
 
   it 'sends an exposure again in a later flush interval' do
@@ -208,4 +208,24 @@ def respond_to_events_with(status)
     # Then
     expect(sent_batches.length).to eq(1)
   end
+
+  it 'is stopped at exit while it is running' do
+    # Given / When
+    subject.start
+
+    # Then
+    expect(Flagsmith::RunningEventProcessors.to_a).to include(subject)
+    subject.stop
+  end
+
+  it 'is not kept for exit once stopped' do
+    # Given
+    subject.start
+
+    # When
+    subject.stop
+
+    # Then
+    expect(Flagsmith::RunningEventProcessors.to_a).not_to include(subject)
+  end
 end

spec/sdk/experiments_spec.rb

@@ -134,6 +134,28 @@
       end
     end
 
+    context 'when the flags come from the environment document' do
+      subject do
+        described_class.new(
+          environment_key: 'ser.environment-key', enable_events: true, logger: logger, offline_mode: true,
+          offline_handler: Flagsmith::OfflineHandlers::LocalFileHandler.new('spec/sdk/fixtures/environment.json')
+        )
+      end
+
+      it 'returns the identity flag and records no exposure' do
+        # Given / When
+        flag = subject.get_experiment_flag('some_feature', 'user_123')
+
+        # Then
+        expect(flag.value).to eq('some-value')
+        expect(subject.event_processor).not_to have_received(:track_exposure_event)
+        expect(logger).to have_received(:debug).with(
+          'Not sending $flag_exposure for feature some_feature: ' \
+          'experiments need remote evaluation, not local evaluation or offline mode.'
+        )
+      end
+    end
+
     context 'when events are not enabled' do
       let(:enable_events) { false }