launchdarkly-server-sdk 8.11.2 → 8.11.3

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
+

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

@@ -1,3 +1,6 @@
+require "uri"
+require "http"
+
 module LaunchDarkly
   module Impl
     module Util
@@ -93,6 +96,68 @@ module LaunchDarkly
         }
         nil
       end
+
+      #
+      # Append the payload filter key query parameter to the provided URI.
+      #
+      # @param uri [String]
+      # @param config [Config]
+      # @return [String]
+      #
+      def self.add_payload_filter_key(uri, config)
+        return uri if config.payload_filter_key.nil?
+
+        begin
+          parsed = URI.parse(uri)
+          new_query_params = URI.decode_www_form(String(parsed.query)) << ["filter", config.payload_filter_key]
+          parsed.query = URI.encode_www_form(new_query_params)
+          parsed.to_s
+        rescue URI::InvalidURIError
+          config.logger.warn { "[LDClient] URI could not be parsed. No filtering will be applied." }
+          uri
+        end
+      end
+
+      def self.new_http_client(uri_s, config)
+        http_client_options = {}
+        if config.socket_factory
+          http_client_options["socket_class"] = config.socket_factory
+        end
+        proxy = URI.parse(uri_s).find_proxy
+        unless proxy.nil?
+          http_client_options["proxy"] = {
+            proxy_address: proxy.host,
+            proxy_port: proxy.port,
+            proxy_username: proxy.user,
+            proxy_password: proxy.password,
+          }
+        end
+        HTTP::Client.new(http_client_options)
+          .timeout({
+            read: config.read_timeout,
+            connect: config.connect_timeout,
+          })
+          .persistent(uri_s)
+      end
+
+      def self.log_exception(logger, message, exc)
+        logger.error { "[LDClient] #{message}: #{exc.inspect}" }
+        logger.debug { "[LDClient] Exception trace: #{exc.backtrace}" }
+      end
+
+      def self.http_error_recoverable?(status)
+        if status >= 400 && status < 500
+          status == 400 || status == 408 || status == 429
+        else
+          true
+        end
+      end
+
+      def self.http_error_message(status, context, recoverable_message)
+        desc = (status == 401 || status == 403) ? " (invalid SDK key)" : ""
+        message = http_error_recoverable?(status) ? recoverable_message : "giving up permanently"
+        "HTTP error #{status}#{desc} for #{context} - #{message}"
+      end
     end
   end
 end

data/lib/ldclient-rb/impl.rb

@@ -5,8 +5,7 @@ module LaunchDarkly
   # and subject to change.
   #
   # @since 5.5.0
-  # @private
-  #
+  # @api private
   module Impl
     # code is in ldclient-rb/impl/
   end

data/lib/ldclient-rb/in_memory_store.rb

@@ -1,24 +1,7 @@
 require "concurrent/atomics"
+require "ldclient-rb/impl/data_store"
 
 module LaunchDarkly
-
-  # These constants denote the types of data that can be stored in the feature store.  If
-  # we add another storable data type in the future, as long as it follows the same pattern
-  # (having "key", "version", and "deleted" properties), we only need to add a corresponding
-  # constant here and the existing store should be able to handle it.
-  #
-  # The :priority and :get_dependency_keys properties are used by FeatureStoreDataSetSorter
-  # to ensure data consistency during non-atomic updates.
-
-  # @private
-  FEATURES = Impl::DataStore::DataKind.new(namespace: "features", priority: 1).freeze
-
-  # @private
-  SEGMENTS = Impl::DataStore::DataKind.new(namespace: "segments", priority: 0).freeze
-
-  # @private
-  ALL_KINDS = [FEATURES, SEGMENTS].freeze
-
   #
   # Default implementation of the LaunchDarkly client's feature store, using an in-memory
   # cache.  This object holds feature flags and related data received from LaunchDarkly.

data/lib/ldclient-rb/integrations/test_data/flag_builder.rb

@@ -12,14 +12,14 @@ module LaunchDarkly
       class FlagBuilder
         attr_reader :key
 
-        # @private
+        # @api private
         def initialize(key)
           @key = key
           @on = true
           @variations = []
         end
 
-        # @private
+        # @api private
         def initialize_copy(other)
           super(other)
           @variations = @variations.clone
@@ -357,7 +357,7 @@ module LaunchDarkly
           self
         end
 
-        # @private
+        # @api private
         def add_rule(rule)
           if @rules.nil?
             @rules = Array.new
@@ -386,7 +386,7 @@ module LaunchDarkly
           end
         end
 
-        # @private
+        # @api private
         def build(version)
           res = { key: @key,
                   version: version,
@@ -486,16 +486,16 @@ module LaunchDarkly
         # Finally, call {#then_return} to finish defining the rule.
         #
         class FlagRuleBuilder
-          # @private
+          # @api private
           FlagRuleClause = Struct.new(:contextKind, :attribute, :op, :values, :negate, keyword_init: true) # rubocop:disable Naming/MethodName:
 
-          # @private
+          # @api private
           def initialize(flag_builder)
             @flag_builder = flag_builder
             @clauses = Array.new
           end
 
-          # @private
+          # @api private
           def intialize_copy(other)
             super(other)
             @clauses = @clauses.clone
@@ -612,7 +612,7 @@ module LaunchDarkly
             end
           end
 
-          # @private
+          # @api private
           def build(ri)
             {
               id: 'rule' + ri.to_s,
@@ -622,7 +622,7 @@ module LaunchDarkly
           end
         end
 
-        # @private
+        # @api private
         def variation_for_boolean(variation)
           variation ? TRUE_VARIATION_INDEX : FALSE_VARIATION_INDEX
         end