launchdarkly-server-sdk 8.11.1 → 8.11.3

data/lib/ldclient-rb/impl/expiring_cache.rb

@@ -0,0 +1,79 @@
+
+module LaunchDarkly
+  module Impl
+    # A thread-safe cache with maximum number of entries and TTL.
+    # Adapted from https://github.com/SamSaffron/lru_redux/blob/master/lib/lru_redux/ttl/cache.rb
+    # under MIT license with the following changes:
+    #   * made thread-safe
+    #   * removed many unused methods
+    #   * reading a key does not reset its expiration time, only writing
+    class ExpiringCache
+      def initialize(max_size, ttl)
+        @max_size = max_size
+        @ttl = ttl
+        @data_lru = {}
+        @data_ttl = {}
+        @lock = Mutex.new
+      end
+
+      def [](key)
+        @lock.synchronize do
+          ttl_evict
+          @data_lru[key]
+        end
+      end
+
+      def []=(key, val)
+        @lock.synchronize do
+          ttl_evict
+
+          @data_lru.delete(key)
+          @data_ttl.delete(key)
+
+          @data_lru[key] = val
+          @data_ttl[key] = Time.now.to_f
+
+          if @data_lru.size > @max_size
+            key, _ = @data_lru.first # hashes have a FIFO ordering in Ruby
+
+            @data_ttl.delete(key)
+            @data_lru.delete(key)
+          end
+
+          val
+        end
+      end
+
+      def delete(key)
+        @lock.synchronize do
+          ttl_evict
+
+          @data_lru.delete(key)
+          @data_ttl.delete(key)
+        end
+      end
+
+      def clear
+        @lock.synchronize do
+          @data_lru.clear
+          @data_ttl.clear
+        end
+      end
+
+      private
+
+      def ttl_evict
+        ttl_horizon = Time.now.to_f - @ttl
+        key, time = @data_ttl.first
+
+        until time.nil? || time > ttl_horizon
+          @data_ttl.delete(key)
+          @data_lru.delete(key)
+
+          key, time = @data_ttl.first
+        end
+      end
+    end
+  end
+end
+

data/lib/ldclient-rb/impl/integrations/file_data_source.rb

@@ -1,5 +1,5 @@
 require 'ldclient-rb/in_memory_store'
-require 'ldclient-rb/util'
+require 'ldclient-rb/impl/util'
 
 require 'concurrent/atomics'
 require 'json'
@@ -75,14 +75,14 @@ module LaunchDarkly
 
         def load_all
           all_data = {
-            FEATURES => {},
-            SEGMENTS => {},
+            Impl::DataStore::FEATURES => {},
+            Impl::DataStore::SEGMENTS => {},
           }
           @paths.each do |path|
             begin
               load_file(path, all_data)
             rescue => exn
-              LaunchDarkly::Util.log_exception(@logger, "Unable to load flag data from \"#{path}\"", exn)
+              Impl::Util.log_exception(@logger, "Unable to load flag data from \"#{path}\"", exn)
               @data_source_update_sink&.update_status(
                 LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
                 LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(LaunchDarkly::Interfaces::DataSource::ErrorInfo::INVALID_DATA, 0, exn.to_s, Time.now)
@@ -102,17 +102,17 @@ module LaunchDarkly
             @last_version += 1
           }
 
-          parsed = parse_content(IO.read(path))
+          parsed = parse_content(File.read(path))
           (parsed[:flags] || {}).each do |key, flag|
             flag[:version] = version
-            add_item(all_data, FEATURES, flag)
+            add_item(all_data, Impl::DataStore::FEATURES, flag)
           end
           (parsed[:flagValues] || {}).each do |key, value|
-            add_item(all_data, FEATURES, make_flag_with_value(key.to_s, value, version))
+            add_item(all_data, Impl::DataStore::FEATURES, make_flag_with_value(key.to_s, value, version))
           end
           (parsed[:segments] || {}).each do |key, segment|
             segment[:version] = version
-            add_item(all_data, SEGMENTS, segment)
+            add_item(all_data, Impl::DataStore::SEGMENTS, segment)
           end
         end
 
@@ -212,7 +212,7 @@ module LaunchDarkly
                   end
                   reloader.call if changed
                 rescue => exn
-                  LaunchDarkly::Util.log_exception(logger, "Unexpected exception in FileDataSourcePoller", exn)
+                  Impl::Util.log_exception(logger, "Unexpected exception in FileDataSourcePoller", exn)
                 end
               end
             end

data/lib/ldclient-rb/impl/integrations/test_data/test_data_source.rb

@@ -5,7 +5,6 @@ module LaunchDarkly
   module Impl
     module Integrations
       module TestData
-        # @private
         class TestDataSource
           include LaunchDarkly::Interfaces::DataSource
 

data/lib/ldclient-rb/impl/integrations/test_data/test_data_source_v2.rb

@@ -0,0 +1,288 @@
+require 'concurrent/atomics'
+require 'ldclient-rb/impl/data_system'
+require 'ldclient-rb/interfaces/data_system'
+require 'ldclient-rb/util'
+require 'thread'
+
+module LaunchDarkly
+  module Impl
+    module Integrations
+      module TestData
+        #
+        # Internal implementation of both Initializer and Synchronizer protocols for TestDataV2.
+        #
+        # This component bridges the test data management in TestDataV2 with the FDv2 protocol
+        # interfaces. Each instance implements both Initializer and Synchronizer protocols
+        # and receives change notifications for dynamic updates.
+        #
+        class TestDataSourceV2
+          include LaunchDarkly::Interfaces::DataSystem::Initializer
+          include LaunchDarkly::Interfaces::DataSystem::Synchronizer
+
+          # @api private
+          #
+          # @param test_data [LaunchDarkly::Integrations::TestDataV2] the test data instance
+          #
+          def initialize(test_data)
+            @test_data = test_data
+            @closed = false
+            @update_queue = Queue.new
+            @lock = Mutex.new
+
+            # Always register for change notifications
+            @test_data.add_instance(self)
+          end
+
+          #
+          # Return the name of this data source.
+          #
+          # @return [String]
+          #
+          def name
+            'TestDataV2'
+          end
+
+          #
+          # Implementation of the Initializer.fetch method.
+          #
+          # Returns the current test data as a Basis for initial data loading.
+          #
+          # @param selector_store [LaunchDarkly::Interfaces::DataSystem::SelectorStore] Provides the Selector (unused for test data)
+          # @return [LaunchDarkly::Result] A Result containing either a Basis or an error message
+          #
+          def fetch(selector_store)
+            begin
+              @lock.synchronize do
+                if @closed
+                  return LaunchDarkly::Result.fail('TestDataV2 source has been closed')
+                end
+
+                # Get all current flags and segments from test data
+                init_data = @test_data.make_init_data
+                version = @test_data.get_version
+
+                # Build a full transfer changeset
+                builder = LaunchDarkly::Interfaces::DataSystem::ChangeSetBuilder.new
+                builder.start(LaunchDarkly::Interfaces::DataSystem::IntentCode::TRANSFER_FULL)
+
+                # Add all flags to the changeset
+                init_data[:flags].each do |key, flag_data|
+                  builder.add_put(
+                    LaunchDarkly::Interfaces::DataSystem::ObjectKind::FLAG,
+                    key,
+                    flag_data[:version] || 1,
+                    flag_data
+                  )
+                end
+
+                # Add all segments to the changeset
+                init_data[:segments].each do |key, segment_data|
+                  builder.add_put(
+                    LaunchDarkly::Interfaces::DataSystem::ObjectKind::SEGMENT,
+                    key,
+                    segment_data[:version] || 1,
+                    segment_data
+                  )
+                end
+
+                # Create selector for this version
+                selector = LaunchDarkly::Interfaces::DataSystem::Selector.new_selector(version.to_s, version)
+                change_set = builder.finish(selector)
+
+                basis = LaunchDarkly::Interfaces::DataSystem::Basis.new(change_set: change_set, persist: false, environment_id: nil)
+
+                LaunchDarkly::Result.success(basis)
+              end
+            rescue => e
+              LaunchDarkly::Result.fail("Error fetching test data: #{e.message}", e)
+            end
+          end
+
+          #
+          # Implementation of the Synchronizer.sync method.
+          #
+          # Yields updates as test data changes occur.
+          #
+          # @param selector_store [LaunchDarkly::Interfaces::DataSystem::SelectorStore] Provides the Selector (unused for test data)
+          # @yield [LaunchDarkly::Interfaces::DataSystem::Update] Yields Update objects as synchronization progresses
+          # @return [void]
+          #
+          def sync(selector_store)
+            # First yield initial data
+            initial_result = fetch(selector_store)
+            unless initial_result.success?
+              yield LaunchDarkly::Interfaces::DataSystem::Update.new(
+                state: LaunchDarkly::Interfaces::DataSource::Status::OFF,
+                error: LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(
+                  LaunchDarkly::Interfaces::DataSource::ErrorInfo::STORE_ERROR,
+                  0,
+                  initial_result.error,
+                  Time.now
+                )
+              )
+              return
+            end
+
+            # Yield the initial successful state
+            yield LaunchDarkly::Interfaces::DataSystem::Update.new(
+              state: LaunchDarkly::Interfaces::DataSource::Status::VALID,
+              change_set: initial_result.value.change_set
+            )
+
+            # Continue yielding updates as they arrive
+            until @closed
+              begin
+                # stop() will push nil to the queue to wake us up when shutting down
+                update = @update_queue.pop
+
+                # Handle nil sentinel for shutdown
+                break if update.nil?
+
+                # Yield the actual update
+                yield update
+              rescue => e
+                yield LaunchDarkly::Interfaces::DataSystem::Update.new(
+                  state: LaunchDarkly::Interfaces::DataSource::Status::OFF,
+                  error: LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(
+                    LaunchDarkly::Interfaces::DataSource::ErrorInfo::UNKNOWN,
+                    0,
+                    "Error in test data synchronizer: #{e.message}",
+                    Time.now
+                  )
+                )
+                break
+              end
+            end
+          end
+
+          #
+          # Stop the data source and clean up resources
+          #
+          # @return [void]
+          #
+          def stop
+            @lock.synchronize do
+              return if @closed
+              @closed = true
+            end
+
+            @test_data.closed_instance(self)
+            # Signal shutdown to sync generator
+            @update_queue.push(nil)
+          end
+
+          #
+          # Called by TestDataV2 when a flag is updated.
+          #
+          # This method converts the flag update into an FDv2 changeset and
+          # queues it for delivery through the sync() generator.
+          #
+          # @param flag_data [Hash] the flag data
+          # @return [void]
+          #
+          def upsert_flag(flag_data)
+            @lock.synchronize do
+              return if @closed
+
+              begin
+                version = @test_data.get_version
+
+                # Build a changes transfer changeset
+                builder = LaunchDarkly::Interfaces::DataSystem::ChangeSetBuilder.new
+                builder.start(LaunchDarkly::Interfaces::DataSystem::IntentCode::TRANSFER_CHANGES)
+
+                # Add the updated flag
+                builder.add_put(
+                  LaunchDarkly::Interfaces::DataSystem::ObjectKind::FLAG,
+                  flag_data[:key],
+                  flag_data[:version] || 1,
+                  flag_data
+                )
+
+                # Create selector for this version
+                selector = LaunchDarkly::Interfaces::DataSystem::Selector.new_selector(version.to_s, version)
+                change_set = builder.finish(selector)
+
+                # Queue the update
+                update = LaunchDarkly::Interfaces::DataSystem::Update.new(
+                  state: LaunchDarkly::Interfaces::DataSource::Status::VALID,
+                  change_set: change_set
+                )
+
+                @update_queue.push(update)
+              rescue => e
+                # Queue an error update
+                error_update = LaunchDarkly::Interfaces::DataSystem::Update.new(
+                  state: LaunchDarkly::Interfaces::DataSource::Status::OFF,
+                  error: LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(
+                    LaunchDarkly::Interfaces::DataSource::ErrorInfo::STORE_ERROR,
+                    0,
+                    "Error processing flag update: #{e.message}",
+                    Time.now
+                  )
+                )
+                @update_queue.push(error_update)
+              end
+            end
+          end
+
+          #
+          # Called by TestDataV2 when a segment is updated.
+          #
+          # This method converts the segment update into an FDv2 changeset and
+          # queues it for delivery through the sync() generator.
+          #
+          # @param segment_data [Hash] the segment data
+          # @return [void]
+          #
+          def upsert_segment(segment_data)
+            @lock.synchronize do
+              return if @closed
+
+              begin
+                version = @test_data.get_version
+
+                # Build a changes transfer changeset
+                builder = LaunchDarkly::Interfaces::DataSystem::ChangeSetBuilder.new
+                builder.start(LaunchDarkly::Interfaces::DataSystem::IntentCode::TRANSFER_CHANGES)
+
+                # Add the updated segment
+                builder.add_put(
+                  LaunchDarkly::Interfaces::DataSystem::ObjectKind::SEGMENT,
+                  segment_data[:key],
+                  segment_data[:version] || 1,
+                  segment_data
+                )
+
+                # Create selector for this version
+                selector = LaunchDarkly::Interfaces::DataSystem::Selector.new_selector(version.to_s, version)
+                change_set = builder.finish(selector)
+
+                # Queue the update
+                update = LaunchDarkly::Interfaces::DataSystem::Update.new(
+                  state: LaunchDarkly::Interfaces::DataSource::Status::VALID,
+                  change_set: change_set
+                )
+
+                @update_queue.push(update)
+              rescue => e
+                # Queue an error update
+                error_update = LaunchDarkly::Interfaces::DataSystem::Update.new(
+                  state: LaunchDarkly::Interfaces::DataSource::Status::OFF,
+                  error: LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(
+                    LaunchDarkly::Interfaces::DataSource::ErrorInfo::STORE_ERROR,
+                    0,
+                    "Error processing segment update: #{e.message}",
+                    Time.now
+                  )
+                )
+                @update_queue.push(error_update)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/ldclient-rb/impl/memoized_value.rb

@@ -0,0 +1,34 @@
+
+module LaunchDarkly
+  module Impl
+    # Simple implementation of a thread-safe memoized value whose generator function will never be
+    # run more than once, and whose value can be overridden by explicit assignment.
+    # Note that we no longer use this class and it will be removed in a future version.
+    class MemoizedValue
+      def initialize(&generator)
+        @generator = generator
+        @mutex = Mutex.new
+        @inited = false
+        @value = nil
+      end
+
+      def get
+        @mutex.synchronize do
+          unless @inited
+            @value = @generator.call
+            @inited = true
+          end
+        end
+        @value
+      end
+
+      def set(value)
+        @mutex.synchronize do
+          @value = value
+          @inited = true
+        end
+      end
+    end
+  end
+end
+

data/lib/ldclient-rb/impl/migrations/migrator.rb

@@ -1,4 +1,5 @@
 require 'thread'
+require 'ldclient-rb/impl/util'
 
 module LaunchDarkly
   module Impl
@@ -274,7 +275,7 @@ module LaunchDarkly
           begin
             result = @fn.call(@payload)
           rescue => e
-            LaunchDarkly::Util.log_exception(@logger, "Unexpected error running method for '#{origin}' origin", e)
+            Impl::Util.log_exception(@logger, "Unexpected error running method for '#{origin}' origin", e)
             result = LaunchDarkly::Result.fail("'#{origin}' operation raised an exception", e)
           end
 

data/lib/ldclient-rb/impl/migrations/tracker.rb

@@ -1,5 +1,6 @@
 require "set"
 require "ldclient-rb/impl/sampler"
+require "ldclient-rb/impl/util"
 require "logger"
 
 module LaunchDarkly
@@ -67,7 +68,7 @@ module LaunchDarkly
               begin
                 @consistent = is_consistent.call
               rescue => e
-                LaunchDarkly::Util.log_exception(@logger, "Exception raised during consistency check; failed to record measurement", e)
+                Impl::Util.log_exception(@logger, "Exception raised during consistency check; failed to record measurement", e)
               end
             end
           end

data/lib/ldclient-rb/impl/model/serialization.rb

@@ -34,19 +34,19 @@ module LaunchDarkly
       # SDK code outside of Impl::Model should use this method instead of calling the model class
       # constructors directly, so as not to rely on implementation details.
       #
-      # @param kind [Hash] normally either FEATURES or SEGMENTS
+      # @param kind [Hash] normally either Impl::DataStore::FEATURES or Impl::DataStore::SEGMENTS
       # @param input [object] a JSON string or a parsed hash (or a data model object, in which case
       #  we'll just return the original object)
       # @param logger [Logger|nil] logs errors if there are any data validation problems
       # @return [Object] the flag or segment (or, for an unknown data kind, the data as a hash)
       def self.deserialize(kind, input, logger = nil)
         return nil if input.nil?
-        return input if !input.is_a?(String) && !input.is_a?(Hash)
+        return input unless input.is_a?(String) || input.is_a?(Hash)
         data = input.is_a?(Hash) ? input : JSON.parse(input, symbolize_names: true)
         case kind
-        when FEATURES
+        when Impl::DataStore::FEATURES
           FeatureFlag.new(data, logger)
-        when SEGMENTS
+        when Impl::DataStore::SEGMENTS
           Segment.new(data, logger)
         else
           data
@@ -63,8 +63,8 @@ module LaunchDarkly
       # Translates a { flags: ..., segments: ... } object received from LaunchDarkly to the data store format.
       def self.make_all_store_data(received_data, logger = nil)
         {
-          FEATURES => (received_data[:flags] || {}).transform_values { |data| FeatureFlag.new(data, logger) },
-          SEGMENTS => (received_data[:segments] || {}).transform_values { |data| Segment.new(data, logger) },
+          Impl::DataStore::FEATURES => (received_data[:flags] || {}).transform_values { |data| FeatureFlag.new(data, logger) },
+          Impl::DataStore::SEGMENTS => (received_data[:segments] || {}).transform_values { |data| Segment.new(data, logger) },
         }
       end
     end

data/lib/ldclient-rb/impl/non_blocking_thread_pool.rb

@@ -0,0 +1,48 @@
+require "concurrent"
+require "concurrent/atomics"
+require "concurrent/executors"
+require "thread"
+
+module LaunchDarkly
+  module Impl
+    # Simple wrapper for a FixedThreadPool that rejects new jobs if all the threads are busy, rather
+    # than blocking. Also provides a way to wait for all jobs to finish without shutting down.
+    class NonBlockingThreadPool
+      def initialize(capacity, name = 'LD/NonBlockingThreadPool')
+        @capacity = capacity
+        @pool = Concurrent::FixedThreadPool.new(capacity, name: name)
+        @semaphore = Concurrent::Semaphore.new(capacity)
+      end
+
+      # Attempts to submit a job, but only if a worker is available. Unlike the regular post method,
+      # this returns a value: true if the job was submitted, false if all workers are busy.
+      def post
+        unless @semaphore.try_acquire(1)
+          return
+        end
+        @pool.post do
+          begin
+            yield
+          ensure
+            @semaphore.release(1)
+          end
+        end
+      end
+
+      # Waits until no jobs are executing, without shutting down the pool.
+      def wait_all
+        @semaphore.acquire(@capacity)
+        @semaphore.release(@capacity)
+      end
+
+      def shutdown
+        @pool.shutdown
+      end
+
+      def wait_for_termination
+        @pool.wait_for_termination
+      end
+    end
+  end
+end
+

data/lib/ldclient-rb/impl/repeating_task.rb

@@ -1,4 +1,4 @@
-require "ldclient-rb/util"
+require "ldclient-rb/impl/util"
 
 require "concurrent/atomics"
 
@@ -26,7 +26,7 @@ module LaunchDarkly
             begin
               @task.call
             rescue => e
-              LaunchDarkly::Util.log_exception(@logger, "Uncaught exception from repeating task", e)
+              Impl::Util.log_exception(@logger, "Uncaught exception from repeating task", e)
             end
             delta = @interval - (Time.now - started_at)
             if delta > 0

data/lib/ldclient-rb/impl/simple_lru_cache.rb

@@ -0,0 +1,27 @@
+
+module LaunchDarkly
+  module Impl
+    # A non-thread-safe implementation of a LRU cache set with only add and reset methods.
+    # Based on https://github.com/SamSaffron/lru_redux/blob/master/lib/lru_redux/cache.rb
+    class SimpleLRUCacheSet
+      def initialize(capacity)
+        @values = {}
+        @capacity = capacity
+      end
+
+      # Adds a value to the cache or marks it recent if it was already there. Returns true if already there.
+      def add(value)
+        found = true
+        @values.delete(value) { found = false }
+        @values[value] = true
+        @values.shift if @values.length > @capacity
+        found
+      end
+
+      def clear
+        @values = {}
+      end
+    end
+  end
+end
+